eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/matrix/SpecimenColumnPropertyAccessor.java

   1 /**
   2 * Copyright (C) 2017 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9 package eu.etaxonomy.taxeditor.editor.descriptiveDataSet.matrix;
  10
  11 import java.util.ArrayList;
  12 import java.util.Collection;
  13 import java.util.List;
  14 import java.util.Set;
  15
  16 import org.apache.commons.lang3.StringUtils;
  17 import org.eclipse.nebula.widgets.nattable.data.IColumnPropertyAccessor;
  18
  19 import eu.etaxonomy.cdm.api.service.dto.RowWrapperDTO;
  20 import eu.etaxonomy.cdm.api.service.dto.SpecimenRowWrapperDTO;
  21 import eu.etaxonomy.cdm.api.service.dto.TaxonRowWrapperDTO;
  22 import eu.etaxonomy.cdm.persistence.dto.DescriptionElementDto;
  23 import eu.etaxonomy.cdm.persistence.dto.FeatureDto;
  24 import eu.etaxonomy.cdm.persistence.dto.TermDto;
  25 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
  26
  27 /**
  28  * Property accessor class which maps setting and getting data for
  29  * each row in the character matrix
  30  *
  31  * @author pplitzner
  32  * @since Nov 26, 2017
  33  *
  34  */
  35 public class SpecimenColumnPropertyAccessor implements IColumnPropertyAccessor<Object>{
  36
  37     private CharacterMatrix matrix;
  38
  39     public SpecimenColumnPropertyAccessor(CharacterMatrix matrix) {
  40         this.matrix = matrix;
  41     }
  42
  43     @Override
  44     public Object getDataValue(Object rowObject, int columnIndex) {
  45         if(rowObject instanceof SpecimenRowWrapperDTO){
  46             SpecimenRowWrapperDTO rowWrapper = (SpecimenRowWrapperDTO) rowObject;
  47             switch (columnIndex) {
  48             case 0:
  49                 if(matrix.isTreeView()){
  50                     return "#"+rowWrapper.getSpecimenDto().getId();
  51                 }
  52                 else{
  53                     return rowWrapper.getTaxonNode();
  54                 }
  55             case 1:
  56                 if (rowWrapper.getSpecimenDto() != null){
  57                         if (StringUtils.isBlank(rowWrapper.getSpecimenDto().getCollectorsString())){
  58                                 if (rowWrapper.getFieldUnit() != null){
  59                                         return rowWrapper.getFieldUnit().getTitleCache();
  60                                 }else{
  61                                         return "no information";
  62                                 }
  63                         }
  64                     return rowWrapper.getSpecimenDto().getCollectorsString();
  65                 }else if (rowWrapper.getFieldUnit() != null){
  66                                 return rowWrapper.getFieldUnit().getTitleCache();
  67                         }else{
  68                                 return "no information";
  69                         }
  70             case 2:
  71                 return rowWrapper.getIdentifier();
  72             case 3:
  73                 return rowWrapper.getCountry();
  74
  75             default:
  76                 break;
  77             }
  78             FeatureDto feature = matrix.getIndexToFeatureMap().get(columnIndex);
  79             return rowWrapper.getDisplayDataForFeature(feature.getUuid());
  80         }
  81         else if(rowObject instanceof TaxonRowWrapperDTO){
  82             TaxonRowWrapperDTO taxonWrapper = (TaxonRowWrapperDTO)rowObject;
  83             if(columnIndex==0){
  84                 return taxonWrapper.getDescription();
  85             }
  86             FeatureDto feature = matrix.getIndexToFeatureMap().get(columnIndex);
  87             if (feature == null){
  88                 return null;
  89             }
  90             return taxonWrapper.getDisplayDataForFeature(feature.getUuid());
  91
  92         } else if (columnIndex == 0) {
  93             return rowObject;
  94         }
  95         return null;
  96     }
  97
  98     public Object getData(Object rowObject, int columnIndex) {
  99         if (rowObject instanceof SpecimenRowWrapperDTO) {
 100             SpecimenRowWrapperDTO rowWrapper = (SpecimenRowWrapperDTO) rowObject;
 101             switch (columnIndex) {
 102             case 0:
 103                 if (matrix.isTreeView()) {
 104                     return "#" + rowWrapper.getSpecimenDto().getId();
 105                 } else {
 106                     return rowWrapper.getTaxonNode();
 107                 }
 108             case 1:
 109                 if (rowWrapper.getSpecimenDto() != null) {
 110                     if (StringUtils.isBlank(rowWrapper.getSpecimenDto().getCollectorsString())) {
 111                         if (rowWrapper.getFieldUnit() != null) {
 112                             return rowWrapper.getFieldUnit().getTitleCache();
 113                         } else {
 114                             return "no information";
 115                         }
 116                     }
 117                     return rowWrapper.getSpecimenDto().getCollectorsString();
 118                 } else if (rowWrapper.getFieldUnit() != null) {
 119                     return rowWrapper.getFieldUnit().getTitleCache();
 120                 } else {
 121                     return "no information";
 122                 }
 123             case 2:
 124                 return rowWrapper.getIdentifier();
 125             case 3:
 126                 return rowWrapper.getCountry();
 127
 128             default:
 129                 break;
 130             }
 131             FeatureDto feature = matrix.getIndexToFeatureMap().get(columnIndex);
 132             Set<DescriptionElementDto> data = rowWrapper.getDataValueForFeature(feature.getUuid());
 133             DescriptionElementDto result = null;
 134             if (data != null && !data.isEmpty()) {
 135                 result = data.iterator().next();
 136             }
 137             return result;
 138         } else if (rowObject instanceof TaxonRowWrapperDTO) {
 139             TaxonRowWrapperDTO taxonWrapper = (TaxonRowWrapperDTO) rowObject;
 140             if (columnIndex == 0) {
 141                 return taxonWrapper.getDescription();
 142             }
 143             FeatureDto feature = matrix.getIndexToFeatureMap().get(columnIndex);
 144             if (feature == null) {
 145                 return null;
 146             }
 147             return taxonWrapper.getDataValueForFeature(feature.getUuid());
 148
 149         } else if (columnIndex == 0) {
 150             return rowObject;
 151         }
 152         return null;
 153     }
 154
 155     @Override
 156     public void setDataValue(Object rowObject, int columnIndex, Object newValue) {
 157         if (rowObject instanceof RowWrapperDTO) {
 158             RowWrapperDTO rowWrapper = (RowWrapperDTO) rowObject;
 159
 160             FeatureDto feature = matrix.getIndexToFeatureMap().get(columnIndex);
 161             if(feature.isSupportsCategoricalData()
 162                     && newValue instanceof Collection){
 163
 164                 List<Object> dtos = new ArrayList<>();
 165
 166                 //TODO:This needs to be adapted because already added modifiers will be deleted!!!!!
 167                 if (((Collection) newValue).stream().allMatch(o -> o instanceof TermDto)) {
 168                     dtos = (List<Object>) newValue;
 169                 }
 170
 171                 rowWrapper.setDataValueForCategoricalData(feature.getUuid(), dtos, PreferencesUtil.getGlobalLanguage());
 172                 matrix.putRowToMerge(rowWrapper);
 173             }
 174         }
 175     }
 176
 177     @Override
 178     public int getColumnCount() {
 179         return matrix.getPropertyToLabelMap().size();
 180     }
 181
 182     @Override
 183     public String getColumnProperty(int columnIndex) {
 184         return matrix.getPropertyToLabelMap().get(columnIndex);
 185     }
 186
 187     @Override
 188     public int getColumnIndex(String propertyName){
 189         return matrix.getPropertyToLabelMap().indexOf(propertyName);
 190     }
 191
 192 }