src/main/java/eu/etaxonomy/cdm/vaadin/container/LeafNodeTaxonContainer.java

   1 /**
   2  * Copyright (C) 2015 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.cdm.vaadin.container;
  10
  11 import java.sql.SQLException;
  12 import java.util.ArrayList;
  13 import java.util.Collection;
  14 import java.util.HashMap;
  15 import java.util.HashSet;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.Set;
  19
  20 import org.apache.log4j.Logger;
  21
  22 import com.vaadin.data.Container;
  23 import com.vaadin.data.Item;
  24 import com.vaadin.data.Property;
  25 import com.vaadin.data.util.filter.Compare;
  26 import com.vaadin.data.util.filter.IsNull;
  27 import com.vaadin.data.util.filter.Not;
  28 import com.vaadin.data.util.filter.SimpleStringFilter;
  29 import com.vaadin.data.util.sqlcontainer.RowId;
  30 import com.vaadin.data.util.sqlcontainer.RowItem;
  31
  32 import eu.etaxonomy.cdm.model.name.Rank;
  33 import eu.etaxonomy.cdm.vaadin.util.CdmQueryFactory;
  34
  35 /**
  36  * @author cmathew
  37  * @date 10 Mar 2015
  38  *
  39  */
  40 public class LeafNodeTaxonContainer extends CdmSQLContainer implements Container.Hierarchical  {
  41
  42     private static final Logger logger = Logger.getLogger(LeafNodeTaxonContainer.class);
  43
  44
  45     public static final String NAME_ID = "Name";
  46     public static final String ACCTAXON_ID = "AccTaxonId";
  47     public static final String PB_ID = "Pb";
  48     public static final String FN_ID = "Fn";
  49     public static final String UNP_ID = "Unp";
  50     public static final String UNR_ID = "Unr";
  51     public static final String RANK_ID = "Rank";
  52     public static final String HAS_SYN_ID = "HasSynonyms";
  53
  54     public Set<Filter> currentFilters;
  55
  56
  57     private Filter nrFilter, unpFilter, unfFilter, unpbFilter, rankFilter,  classificationFilter, synonymFilter, idFilter;
  58     private SimpleStringFilter nameFilter;
  59
  60     private int classificationId = -1;
  61
  62     private final Map<RowId, RowItem> synItems = new HashMap<>();
  63
  64     private final Map<Object,List<Object>> taxonSynonymMap;
  65
  66     private final CdmSQLContainer synonymContainer;
  67
  68
  69     /**
  70      * @param delegate
  71      * @throws SQLException
  72      */
  73     public LeafNodeTaxonContainer(int classificationId) throws SQLException {
  74         super(CdmQueryFactory.generateTaxonBaseQuery(NAME_ID, PB_ID, UNP_ID, RANK_ID, HAS_SYN_ID));
  75         this.synonymContainer = new CdmSQLContainer(CdmQueryFactory.generateSynonymOfTaxonQuery(NAME_ID));
  76         this.synonymContainer.sort(new String[]{NAME_ID}, new boolean[]{true});
  77         this.classificationId = classificationId;
  78         taxonSynonymMap = new HashMap<>();
  79         initFilters();
  80         addContainerFilter(classificationFilter);
  81         enableCacheFlushNotifications();
  82         addContainerFilter(rankFilter);
  83     }
  84
  85     private void initFilters() {
  86         //nrFilter = new Compare.Equal(StatusPresenter.UNR_ID, true);
  87         unpFilter = new Compare.Equal("tn.unplaced", true);
  88         //unfFilter = new Compare.Equal(StatusPresenter.FN_ID, false);
  89         unpbFilter = new Compare.Equal("tb.publish", false);
  90         classificationFilter = new Compare.Equal("tn.classification_id", classificationId);
  91
  92         // get species aggregate rank order index
  93         int saoIndex = Rank.SPECIESAGGREGATE().getOrderIndex();
  94         rankFilter = new Compare.GreaterOrEqual("dtb.orderindex", saoIndex);
  95
  96         synonymFilter = new Not(new IsNull("acc.id"));
  97
  98         currentFilters = new HashSet<>();
  99     }
 100
 101
 102
 103     public void setUnplacedFilter() {
 104         addContainerFilter(unpFilter);
 105     }
 106
 107
 108     public void removeUnplacedFilter() {
 109         removeContainerFilter(unpFilter);
 110     }
 111
 112
 113     public void setUnpublishedFilter() {
 114         addContainerFilter(unpbFilter);
 115     }
 116
 117
 118     public void removeUnpublishedFilter() {
 119         removeContainerFilter(unpbFilter);
 120     }
 121
 122
 123     public void setNameFilter(String filterString) {
 124         removeNameFilter();
 125         nameFilter = new SimpleStringFilter("n.titleCache", filterString, true, true);
 126         addContainerFilter(nameFilter);
 127     }
 128
 129
 130     public void removeNameFilter() {
 131         removeContainerFilter(nameFilter);
 132     }
 133
 134     public void setIdFilter(Object itemId) {
 135         removeIdFilter();
 136         idFilter = new Compare.Equal("tb.id", itemId.toString());
 137         addContainerFilter(idFilter);
 138     }
 139
 140     public void removeIdFilter() {
 141         removeContainerFilter(idFilter);
 142     }
 143
 144     public void removeDynamicFilters() {
 145         removeUnplacedFilter();
 146         removeUnpublishedFilter();
 147         removeNameFilter();
 148         removeIdFilter();
 149
 150     }
 151     public int getTotalNoOfTaxa() {
 152         return size();
 153     }
 154
 155     @Override
 156     public Collection<?> getChildren(Object itemId) {
 157         List<Object> synList = taxonSynonymMap.get(itemId);
 158         if(synList != null) {
 159             return synList;
 160         }
 161
 162         return addToSynonymCache(itemId);
 163     }
 164
 165     @Override
 166     public Object getParent(Object itemId) {
 167         return null;
 168     }
 169
 170     @Override
 171     public Collection<?> rootItemIds() {
 172         return getItemIds();
 173     }
 174
 175     @Override
 176     public boolean setParent(Object itemId, Object newParentId) throws UnsupportedOperationException {
 177         return true;
 178     }
 179
 180     @Override
 181     public boolean areChildrenAllowed(Object itemId) {
 182         Property<?> hasSynProperty = getItem(itemId).getItemProperty(HAS_SYN_ID);
 183         if(hasSynProperty == null) {
 184             return false;
 185         }
 186        return (Long)hasSynProperty.getValue() > 0;
 187     }
 188
 189     @Override
 190     public boolean setChildrenAllowed(Object itemId, boolean areChildrenAllowed) throws UnsupportedOperationException {
 191         return true;
 192     }
 193
 194     @Override
 195     public boolean isRoot(Object itemId) {
 196         return true;
 197     }
 198
 199     @Override
 200     public boolean hasChildren(Object itemId) {
 201         return true;
 202     }
 203
 204     public boolean isSynonym(Object itemId) {
 205         Property<?> hasSynProperty = getItem(itemId).getItemProperty(HAS_SYN_ID);
 206         return hasSynProperty == null;
 207     }
 208
 209     public void removeTaxonFromCache(Object itemId) {
 210         taxonSynonymMap.remove(itemId);
 211     }
 212
 213     public void refreshSynonymCache() {
 214         if(taxonSynonymMap != null) {
 215             for(Object taxonItemId  : taxonSynonymMap.keySet()) {
 216                 addToSynonymCache(taxonItemId);
 217             }
 218         }
 219     }
 220
 221     private List<Object> addToSynonymCache(Object taxonItemId) {
 222         Filter synonymOfTaxonFilter = new Compare.Equal("acc.id", Integer.valueOf(taxonItemId.toString()));
 223         synonymContainer.addContainerFilter(synonymOfTaxonFilter);
 224         List<Object> synList = new ArrayList<>();
 225         synList.addAll(synonymContainer.getItemIds());
 226         for(Object synItemId : synList) {
 227             addSynItem((RowItem) synonymContainer.getItem(synItemId));
 228         }
 229         synonymContainer.removeAllContainerFilters();
 230
 231         taxonSynonymMap.put(taxonItemId, synList);
 232
 233         return synList;
 234     }
 235
 236     @Override
 237     public Item getItem(Object itemId) {
 238         Item item = synItems.get(itemId);
 239         if(item == null) {
 240             item = super.getItem(itemId);
 241         }
 242         return item;
 243     }
 244
 245
 246     @Override
 247     public boolean removeAllItems() throws UnsupportedOperationException {
 248         taxonSynonymMap.clear();
 249         synItems.clear();
 250         return super.removeAllItems();
 251     }
 252
 253     @Override
 254     public void refresh() {
 255         if(synItems != null) {
 256             synItems.clear();
 257         }
 258         refreshSynonymCache();
 259         super.refresh();
 260     }
 261
 262     public void addSynItem(RowItem rowItem) {
 263         synItems.put(rowItem.getId(), rowItem);
 264
 265     }
 266
 267 }