X-Git-Url: https://dev.e-taxonomy.eu/gitweb/taxeditor.git/blobdiff_plain/b0127ea95d5cc141bec16f5244bf57af42a349a8..66889a4215d74759957fbf7a08733210a5ebe7e1:/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/matrix/CharacterMatrix.java diff --git a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/matrix/CharacterMatrix.java b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/matrix/CharacterMatrix.java index 57fbd72a2..17bd0adf7 100644 --- a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/matrix/CharacterMatrix.java +++ b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/descriptiveDataSet/matrix/CharacterMatrix.java @@ -33,6 +33,8 @@ import org.eclipse.core.runtime.SubMonitor; import org.eclipse.core.runtime.jobs.IJobChangeEvent; import org.eclipse.core.runtime.jobs.Job; import org.eclipse.core.runtime.jobs.JobChangeAdapter; +import org.eclipse.e4.core.di.annotations.Optional; +import org.eclipse.e4.ui.di.UIEventTopic; import org.eclipse.e4.ui.di.UISynchronize; import org.eclipse.e4.ui.services.EMenuService; import org.eclipse.jface.layout.GridDataFactory; @@ -98,19 +100,28 @@ import ca.odell.glazedlists.SortedList; import ca.odell.glazedlists.TreeList; import eu.etaxonomy.cdm.api.application.CdmApplicationState; import eu.etaxonomy.cdm.api.service.IDescriptiveDataSetService; +import eu.etaxonomy.cdm.api.service.IOccurrenceService; +import eu.etaxonomy.cdm.api.service.UpdateResult; +import eu.etaxonomy.cdm.api.service.config.RemoveDescriptionsFromDescriptiveDataSetConfigurator; +import eu.etaxonomy.cdm.api.service.dto.FieldUnitDTO; import eu.etaxonomy.cdm.api.service.dto.RowWrapperDTO; import eu.etaxonomy.cdm.api.service.dto.SpecimenRowWrapperDTO; import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor; +import eu.etaxonomy.cdm.model.common.CdmBase; import eu.etaxonomy.cdm.model.description.DescriptionBase; import eu.etaxonomy.cdm.model.description.DescriptiveDataSet; -import eu.etaxonomy.cdm.model.description.Feature; -import eu.etaxonomy.cdm.model.description.MeasurementUnit; -import eu.etaxonomy.cdm.model.term.TermNode; -import eu.etaxonomy.cdm.model.term.TermTree; +import eu.etaxonomy.cdm.model.description.SpecimenDescription; +import eu.etaxonomy.cdm.model.occurrence.FieldUnit; +import eu.etaxonomy.cdm.persistence.dto.DescriptiveDataSetBaseDto; +import eu.etaxonomy.cdm.persistence.dto.FeatureDto; import eu.etaxonomy.cdm.persistence.dto.SpecimenNodeWrapper; import eu.etaxonomy.cdm.persistence.dto.TermDto; +import eu.etaxonomy.cdm.persistence.dto.TermNodeDto; +import eu.etaxonomy.cdm.persistence.dto.TermTreeDto; +import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache; import eu.etaxonomy.taxeditor.editor.internal.TaxeditorEditorPlugin; import eu.etaxonomy.taxeditor.editor.l10n.Messages; +import eu.etaxonomy.taxeditor.event.WorkbenchEventConstants; import eu.etaxonomy.taxeditor.model.MessagingUtils; import eu.etaxonomy.taxeditor.session.ICdmEntitySession; import eu.etaxonomy.taxeditor.store.CdmStore; @@ -150,11 +161,12 @@ public class CharacterMatrix extends Composite { private NatTable natTable; - private Collection> rowsToSave = new HashSet<>(); +// private Collection> rowsToSave = new HashSet<>(); + private HashMap> rowsToMerge = new HashMap<>(); - private Map indexToFeatureMap = new HashMap<>(); + private Map indexToFeatureMap = new HashMap<>(); - private Map> categoricalFeatureToStateMap = new HashMap<>(); + private Map> categoricalFeatureToStateMap = new HashMap<>(); private LinkedMap propertyToLabelMap = new LinkedMap<>(); @@ -162,15 +174,13 @@ public class CharacterMatrix extends Composite { private Collection specimenCache = null; - private Map featureToHistogramMap = new HashMap<>(); - - private Map featureToQuantDataStatisticsMap = new HashMap<>(); + private Map featureToHistogramMap = new HashMap<>(); private ListDataProvider bodyDataProvider; private FreezeLayer freezeLayer; - private List features; + private List features; private CharacterMatrixPart part; @@ -185,6 +195,14 @@ public class CharacterMatrix extends Composite { private CharacterMatrixToolbar toolbar; private DescriptionTreeFormat treeFormat; +// private List descriptionUuidsToDelete; + Map> descriptionUuidsToDelete; + + private List specimenToAdd; + + private MouseEventMatcher mouseEventMatcher = null; + + private Set descriptionsToSave = new HashSet<>(); public CharacterMatrix(Composite parent, CharacterMatrixPart part) { super(parent, SWT.NONE); @@ -195,7 +213,7 @@ public class CharacterMatrix extends Composite { natTable = new NatTable(this, false); - createBottomToolbar(); +// createBottomToolbar(); } @@ -226,6 +244,7 @@ public class CharacterMatrix extends Composite { btnToggleTree.setEnabled(!isTree); btnCollapseAll.setEnabled(isTree); btnExpandAll.setEnabled(isTree); + } public boolean isTreeView() { @@ -241,6 +260,7 @@ public class CharacterMatrix extends Composite { /** * configuration */ + configureNatTable(treeView, configRegistry, topMostLayer); /** @@ -251,8 +271,8 @@ public class CharacterMatrix extends Composite { //grab all space GridDataFactory.fillDefaults().grab(true, true).applyTo(natTable); - //update label to current data set - toolbar.getWsLabel().setText(getDescriptiveDataSet().getLabel()); + //update label to current dataset + toolbar.getWsLabel().setText(getDescriptiveDataSet().getTitleCache()); toolbar.getWsLabel().setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false)); toolbar.getWsLabel().getParent().layout(); @@ -281,53 +301,65 @@ public class CharacterMatrix extends Composite { getNatTableState().remove(PersistenceDialog.ACTIVE_VIEW_CONFIGURATION_KEY); } - private List initFeatureList(TermNode node){ - List features = new ArrayList<>(); - List> childNodes = node.getChildNodes(); - for (TermNode childNode : childNodes) { - features.add(childNode.getTerm()); - features.addAll(initFeatureList(childNode)); + private List initFeatureList(TermNodeDto node){ + List features = new ArrayList<>(); + List childNodes = node.getChildren(); + for (TermNodeDto childNode : childNodes) { + if (childNode != null){ + features.add((FeatureDto) childNode.getTerm()); + features.addAll(initFeatureList(childNode)); + } } return features; } public void initDescriptiveDataSet(){ - //get features/columns stored in descriptive data set - TermTree tree = getDescriptiveDataSet().getDescriptiveSystem(); + //get features/columns stored in descriptive dataset + TermTreeDto tree = getDescriptiveDataSet().getDescriptiveSystem(); features = initFeatureList(tree.getRoot()); - Set duplicateFeatures = features.stream().filter(i -> Collections.frequency(features, i) >1) + Set duplicateFeatures = features.stream().filter(i -> Collections.frequency(features, i) >1) .collect(Collectors.toSet()); if (!duplicateFeatures.isEmpty()) { throw new IllegalArgumentException("Duplicate features found: " - + duplicateFeatures.stream().map(feature -> feature.getLabel()).collect(Collectors.joining(","))); + + duplicateFeatures.stream().map(feature -> feature.getRepresentation_L10n()).collect(Collectors.joining(","))); } //init state data for categorical features - features.forEach(feature->fetchSupportedStates(feature)); +// features.forEach(feature->fetchSupportedStates(feature)); + fetchSupportedStates(features); descriptions = new BasicEventList<>(); } - private void fetchSupportedStates(Feature feature) { - List supportedStates = CdmStore.getService(IDescriptiveDataSetService.class).getSupportedStatesForFeature(feature.getUuid()); - categoricalFeatureToStateMap.put(feature, supportedStates); + private void fetchSupportedStates(List features) { + Set featureUuids = new HashSet<>(); + features.forEach(i->featureUuids.add(i.getUuid())); + categoricalFeatureToStateMap = CdmStore.getService(IDescriptiveDataSetService.class).getSupportedStatesForFeature(featureUuids); + } + + private void createLayers(boolean treeView) { + SortedList sortedList = new SortedList<>(descriptions, new MatrixRowComparator()); // wrap the SortedList with the TreeList treeFormat = new DescriptionTreeFormat(getDescriptiveDataSet()); TreeList treeList = new TreeList(sortedList, treeFormat, TreeList.NODES_START_COLLAPSED); + // wrap the SortedList with the TreeList +// treeFormat = new DescriptionTreeFormat(getDescriptiveDataSet()); + /** * data provider */ SpecimenColumnPropertyAccessor columnPropertyAccessor = new SpecimenColumnPropertyAccessor(this); bodyDataProvider = treeView?new ListDataProvider<>(treeList, columnPropertyAccessor):new ListDataProvider<>(sortedList, columnPropertyAccessor); - configRegistry = new ConfigRegistry(); + DataLayer bodyDataLayer = new DataLayer(bodyDataProvider); + bodyDataLayer.registerCommandHandler(new CopyPasteUpdateDataCommandHandler(bodyDataLayer)); /** @@ -361,9 +393,8 @@ public class CharacterMatrix extends Composite { * */ - DataLayer bodyDataLayer = new DataLayer(bodyDataProvider); - bodyDataLayer.registerCommandHandler(new CopyPasteUpdateDataCommandHandler(bodyDataLayer)); + configRegistry = new ConfigRegistry(); //register labels CharacterMatrixConfigLabelAccumulator labelAccumulator = new CharacterMatrixConfigLabelAccumulator(this); bodyDataLayer.setConfigLabelAccumulator(labelAccumulator); @@ -374,7 +405,7 @@ public class CharacterMatrix extends Composite { propertyToLabelMap.put(IDENTIFIER_COLUMN, Messages.CharacterMatrix_IDENTIFIER); propertyToLabelMap.put(COUNTRY_COLUMN, Messages.CharacterMatrix_COUNTRY); for(int i=0;i columnGroups = new LinkedList<>(); - List> rootChildren = getDescriptiveDataSet().getDescriptiveSystem().getRootChildren(); + List rootChildren = getDescriptiveDataSet().getDescriptiveSystem().getRoot().getChildren(); buildHeader(rootChildren, columnGroups); bodyLayer = new MatrixBodyLayerStack(eventLayer, columnGroups); @@ -394,7 +425,10 @@ public class CharacterMatrix extends Composite { freezeLayer = new FreezeLayer(selectionLayer); final CompositeFreezeLayer compositeFreezeLayer = new CompositeFreezeLayer( freezeLayer, bodyLayer.getViewportLayer(), selectionLayer); - TreeLayer treeLayer = new TreeLayer(compositeFreezeLayer, treeRowModel); + TreeLayer treeLayer = null; + if (treeView){ + treeLayer = new TreeLayer(compositeFreezeLayer, treeRowModel); + } topMostLayer = treeView?treeLayer:compositeFreezeLayer; @@ -415,8 +449,8 @@ public class CharacterMatrix extends Composite { ColumnGroupHeaderLayer groupLayerLevel1 = null; ColumnGroupGroupHeaderLayer groupLayerLevel2 = null; groupLayerLevel1 = new ColumnGroupHeaderLayer(columnHeaderLayer, selectionLayer, groupLevel1.getModel()); - for (Entry, TreeSet> entry: groupLevel1.getColumnGroupToIndexMap().entrySet()) { - TermNode group = entry.getKey(); + for (Entry> entry: groupLevel1.getColumnGroupToIndexMap().entrySet()) { + TermNodeDto group = entry.getKey(); TreeSet indexList = entry.getValue(); int[] intArray = indexList.stream().mapToInt(Integer::intValue).toArray(); groupLayerLevel1.addColumnsIndexesToGroup(group.getTerm().getTitleCache(), intArray); @@ -428,8 +462,8 @@ public class CharacterMatrix extends Composite { if(columnGroups.size()>1){ ColumnGroupWrapper groupLevel2 = columnGroups.get(1); groupLayerLevel2 = new ColumnGroupGroupHeaderLayer(groupLayerLevel1, selectionLayer, groupLevel2.getModel()); - for (Entry, TreeSet> entry: groupLevel2.getColumnGroupToIndexMap().entrySet()) { - TermNode group = entry.getKey(); + for (Entry> entry: groupLevel2.getColumnGroupToIndexMap().entrySet()) { + TermNodeDto group = entry.getKey(); TreeSet indexList = entry.getValue(); int[] intArray = indexList.stream().mapToInt(Integer::intValue).toArray(); groupLayerLevel2.addColumnsIndexesToGroup(group.getTerm().getTitleCache(), intArray); @@ -478,28 +512,32 @@ public class CharacterMatrix extends Composite { } - private TreeSet recurseChildIndexes(TermNode node){ + private TreeSet recurseChildIndexes(TermNodeDto node){ TreeSet childIndexes = new TreeSet<>(); - if(node.getChildCount()>0){ - List> childNodes = node.getChildNodes(); - for (TermNode childNode: childNodes) { - childIndexes.addAll(recurseChildIndexes(childNode)); + if(node.getChildren().size() >0){ + List childNodes = node.getChildren(); + for (TermNodeDto childNode: childNodes) { + if (childNode != null){ + childIndexes.addAll(recurseChildIndexes(childNode)); + } } } childIndexes.add(features.indexOf(node.getTerm())+LEADING_COLUMN_COUNT); return childIndexes; } - private void buildHeader(List> nodes, LinkedList columnGroups){ - Map, TreeSet> columnGroupToIndexMap = new HashMap<>(); - List> childNodes = new ArrayList<>(); - for (TermNode node : nodes) { - TreeSet childIndexes = recurseChildIndexes(node); - if(childIndexes.size()>1){ - // filter out groups that only have one member - columnGroupToIndexMap.put(node, childIndexes); + private void buildHeader(List nodes, LinkedList columnGroups){ + Map> columnGroupToIndexMap = new HashMap<>(); + List childNodes = new ArrayList<>(); + for (TermNodeDto node : nodes) { + if (node != null){ + TreeSet childIndexes = recurseChildIndexes(node); + if(childIndexes.size()>1){ + // filter out groups that only have one member + columnGroupToIndexMap.put(node, childIndexes); + } + childNodes.addAll(node.getChildren()); } - childNodes.addAll(node.getChildNodes()); } if(!columnGroupToIndexMap.isEmpty()){ columnGroups.addFirst(new ColumnGroupWrapper(new ColumnGroupModel(), columnGroupToIndexMap)); @@ -534,6 +572,11 @@ public class CharacterMatrix extends Composite { /** * CONFIGURATION */ + //+++CONTEXT MENU+++ + menuService.registerContextMenu(natTable, "eu.etaxonomy.taxeditor.editor.popupmenu.charactermatrix"); //$NON-NLS-1$ + // get the menu registered by EMenuService + final Menu e4Menu = natTable.getMenu(); + natTable.setConfigRegistry(configRegistry); applyStyles(); @@ -554,7 +597,7 @@ public class CharacterMatrix extends Composite { // add the header menu configuration for adding the column header menu // with hide/show actions - natTable.addConfiguration(new CharacterMatrixHeaderMenuConfiguration(natTable)); +// natTable.addConfiguration(new CharacterMatrixHeaderMenuConfiguration(natTable)); // add custom configuration for data conversion and add column labels to viewport layer topMostLayer.addConfiguration(new CellEditorDataConversionConfiguration(this)); @@ -562,32 +605,41 @@ public class CharacterMatrix extends Composite { //copy&paste configuration natTable.addConfiguration(new CopyPasteEditBindings(bodyLayer.getSelectionLayer(), natTable.getInternalCellClipboard())); - //+++CONTEXT MENU+++ - menuService.registerContextMenu(natTable, "eu.etaxonomy.taxeditor.editor.popupmenu.charactermatrix"); //$NON-NLS-1$ - // get the menu registered by EMenuService - final Menu e4Menu = natTable.getMenu(); + // remove the menu reference from NatTable instance natTable.setMenu(null); + + +// natTable.addConfiguration(new CharacterMatrixHeaderMenuConfiguration(natTable)); + + + natTable.configure(); + + natTable.addConfiguration( - new AbstractUiBindingConfiguration() { - @Override - public void configureUiBindings( - UiBindingRegistry uiBindingRegistry) { - // add e4 menu to NatTable - new PopupMenuBuilder(natTable, e4Menu) + new AbstractUiBindingConfiguration() { + @Override + public void configureUiBindings( + UiBindingRegistry uiBindingRegistry) { + // add e4 menu to NatTable + + + uiBindingRegistry.unregisterMouseDownBinding(mouseEventMatcher); + new PopupMenuBuilder(natTable, e4Menu) + .withHideColumnMenuItem() + .withShowAllColumnsMenuItem() .build(); - // register the UI binding for header, corner and body region - uiBindingRegistry.registerMouseDownBinding( - new MouseEventMatcher( - SWT.NONE, - null, - MouseEventMatcher.RIGHT_BUTTON), - new PopupMenuAction(e4Menu)); - } - }); + // register the UI binding for header, corner and body region + mouseEventMatcher = new MouseEventMatcher( + SWT.NONE, + null, + MouseEventMatcher.RIGHT_BUTTON); + uiBindingRegistry.registerMouseDownBinding(mouseEventMatcher, + new PopupMenuAction(e4Menu)); + } + }); - natTable.configure(); } void freezeSupplementalColumns(boolean freeze){ @@ -608,28 +660,28 @@ public class CharacterMatrix extends Composite { } } - private void initLabels(int index, Feature feature) { + private void initLabels(int index, FeatureDto feature) { indexToFeatureMap.put(index+LEADING_COLUMN_COUNT, feature); - String label = feature.getLabel(); + String label = feature.getTitleCache(); String property = feature.getUuid().toString(); //show unit for quantitative data if(feature.isSupportsQuantitativeData()){ - Set recommendedMeasurementUnits = feature.getRecommendedMeasurementUnits(); + Set recommendedMeasurementUnits = feature.getRecommendedMeasurementUnits(); // if(recommendedMeasurementUnits.size()>1){ // MessagingUtils.warningDialog(Messages.CharacterMatrix_INIT_PROBLEM, CharacterMatrix.class, // String.format(Messages.CharacterMatrix_INIT_PROBLEM_MESSAGE, feature.getLabel())); // } if(recommendedMeasurementUnits.size()==1){ - MeasurementUnit unit = recommendedMeasurementUnits.iterator().next(); + TermDto unit = recommendedMeasurementUnits.iterator().next(); label += " ["+unit.getIdInVocabulary()+"]"; //$NON-NLS-1$ //$NON-NLS-2$ } } propertyToLabelMap.put(property, label); } - public void loadDescriptions(UUID descriptiveDataSetUuid, boolean isInitialExpandToDeepestTaxonLevel) { - UUID monitorUuid = CdmApplicationState.getLongRunningTasksService().monitGetRowWrapper(descriptiveDataSetUuid); + public void loadDescriptions(boolean isInitialExpandToDeepestTaxonLevel, boolean initialLoading) { + UUID monitorUuid = CdmApplicationState.getLongRunningTasksService().monitGetRowWrapper(this.getDescriptiveDataSet().getUuid()); final Collection wrappers = new ArrayList<>(); String jobLabel = Messages.CharacterMatrix_LOAD_CHARACTER_DATA; @@ -680,7 +732,10 @@ public class CharacterMatrix extends Composite { } descriptions.clear(); wrappers.stream().filter(row->row.getTaxonNode()!=null).forEach(wrapper->CharacterMatrix.this.descriptions.add(wrapper)); - loadingDone(isInitialExpandToDeepestTaxonLevel); + if(initialLoading){ + loadingDone(isInitialExpandToDeepestTaxonLevel); + } + }); } }); @@ -701,13 +756,22 @@ public class CharacterMatrix extends Composite { private void loadingDone(boolean isInitialExpandToDeepestTaxonLevel) { this.part.loadingDone(); createTable(isTreeView, freezeLayer.isFrozen(), isInitialExpandToDeepestTaxonLevel); + + } + + public List getSupportedStatesForCategoricalFeature(UUID featureUuid){ + return categoricalFeatureToStateMap.get(featureUuid); } - public List getSupportedStatesForCategoricalFeature(Feature feature){ - return categoricalFeatureToStateMap.get(feature); + public Set getDescriptionsToSave() { + return descriptionsToSave; } - public Map getIndexToFeatureMap() { + public void addDescriptionToSave(DescriptionBase descriptionToSave) { + this.descriptionsToSave.add(descriptionToSave); + } + + public Map getIndexToFeatureMap() { return indexToFeatureMap; } @@ -719,6 +783,46 @@ public class CharacterMatrix extends Composite { part.setDirty(); } + public Map> getDescriptionsToDelete() { + return descriptionUuidsToDelete; + } + + public void addDescriptionToDelete(UUID descriptionToDelete, RemoveDescriptionsFromDescriptiveDataSetConfigurator config) { + if (descriptionUuidsToDelete == null){ + descriptionUuidsToDelete = new HashMap<>(); + } + if (descriptionUuidsToDelete.get(config) != null){ + descriptionUuidsToDelete.get(config).add(descriptionToDelete); + }else{ + List uuidList = new ArrayList<>(); + uuidList.add(descriptionToDelete); + this.descriptionUuidsToDelete.put(config, uuidList); + } + + + } + + public List getSpecimenToAdd() { + return specimenToAdd; + } + + public void addSpecimenToAdd(Collection specimenToAdd) { + if (this.specimenToAdd == null){ + this.specimenToAdd = new ArrayList(); + } + + this.specimenToAdd.addAll(specimenToAdd); + this.specimenCache.removeAll(specimenToAdd); + } + public void addSpecimenToAdd(SpecimenRowWrapperDTO specimenToAdd) { + if (this.specimenToAdd == null){ + this.specimenToAdd = new ArrayList(); + } + + this.specimenToAdd.add(specimenToAdd); + this.specimenCache.remove(specimenToAdd); + } + public CharacterMatrixPart getPart() { return part; } @@ -731,16 +835,16 @@ public class CharacterMatrix extends Composite { return descriptions; } - public DescriptiveDataSet getDescriptiveDataSet() { + public DescriptiveDataSetBaseDto getDescriptiveDataSet() { return part.getDescriptiveDataSet(); } - public void setDescriptiveDataSet(DescriptiveDataSet dataSet) { + public void setDescriptiveDataSet(DescriptiveDataSetBaseDto dataSet) { part.setDescriptiveDataSet(dataSet); } public Collection getSpecimenCache() { - return specimenCache; + return specimenCache; } public void setSpecimenCache(Collection specimenCache) { @@ -749,7 +853,7 @@ public class CharacterMatrix extends Composite { //map descriptions on a list of uuids of the described specimen !this.descriptions.stream() .filter(rowWrapper->rowWrapper instanceof SpecimenRowWrapperDTO) - .map(specimenRowWrapper->((SpecimenRowWrapperDTO) specimenRowWrapper).getSpecimen().getUuid()) + .map(specimenRowWrapper->((SpecimenRowWrapperDTO) specimenRowWrapper).getSpecimenDto().getUuid()) .collect(Collectors.toList()) //and check if the specimen to add is already contained .contains(wrapper.getUuidAndTitleCache().getUuid()) @@ -757,12 +861,23 @@ public class CharacterMatrix extends Composite { .collect(Collectors.toList()); } - public void addRowToSave(RowWrapperDTO row){ - rowsToSave.add(row); +// public void addRowToSave(RowWrapperDTO row){ +// rowsToMerge.put(row.getDescription().getDescription().getUuid(), row); +// } +// +// public HashMap> getRowsToSave() { +// return rowsToMerge; +// } + + public HashMap> getRowsToMerge() { + return rowsToMerge; } - public Collection> getRowsToSave() { - return rowsToSave; + public void putRowToMerge(RowWrapperDTO rowToMerge) { + if (this.rowsToMerge == null){ + this.rowsToMerge = new HashMap<>(); + } + this.rowsToMerge.put(rowToMerge.getDescription().getDescriptionUuid(), rowToMerge); } public Properties getNatTableState() { @@ -781,20 +896,132 @@ public class CharacterMatrix extends Composite { return new File(WorkbenchUtility.getBaseLocation(), CHARACTER_MATRIX_STATE_PROPERTIES); } - public List getFeatures() { + public List getFeatures() { return features; } - public Map getFeatureToHistogramMap() { + public Map getFeatureToHistogramMap() { return featureToHistogramMap; } - public Map getFeatureToQuantDataStatisticsMap() { - return featureToQuantDataStatisticsMap; - } + public ICdmEntitySession getCdmEntitiySession(){ return part.getCdmEntitySession(); } + @Inject + @Optional + private void updateSpecimenList(@UIEventTopic(WorkbenchEventConstants.REFRESH_DESCRIPTIVE_DATASET)UUID uuid){ + if(uuid!= null && uuid.equals(part.getDescriptiveDataSet().getUuid())){ + this.specimenCache = null; + + } + } + + public void addRowsToMatrix(Collection wrappers){ + + List specimenUuids = new ArrayList(); + wrappers.forEach(wrapper -> specimenUuids.add(wrapper.getUuidAndTitleCache().getUuid())); +// List specimens = CdmStore.getService(IOccurrenceService.class).load(specimenUuids, null); + Map> specimenMap = new HashMap(); + + for (UUID specimenUuid: specimenUuids ){ + try{ + FieldUnitDTO fieldUnitDto = CdmStore.getService(IOccurrenceService.class).loadFieldUnitDTO(specimenUuid); + if (fieldUnitDto != null){ + UuidAndTitleCache fieldUnit = new UuidAndTitleCache(FieldUnit.class, fieldUnitDto.getUuid(), null, fieldUnitDto.getLabel()); + specimenMap.put(specimenUuid, fieldUnit); + } + }catch(Exception e){ + e.printStackTrace(); + } + + } + for (SpecimenNodeWrapper wrapper: wrappers){ + SpecimenRowWrapperDTO rowWrapper = CdmStore.getService(IDescriptiveDataSetService.class).createSpecimenRowWrapper(wrapper.getUuidAndTitleCache().getUuid(), wrapper.getTaxonNode().getUuid(), getDescriptiveDataSet().getUuid()); + addSpecimenToAdd(rowWrapper); +// SpecimenRowWrapperDTO rowWrapper = new SpecimenRowWrapperDTO(wrapper.getUuidAndTitleCache(), wrapper.getType(), wrapper.getTaxonNode(), specimenMap.get(wrapper.getUuidAndTitleCache().getUuid()), null, null); + descriptions.add(rowWrapper); + } + + + setDirty(); + } + + public HashMap addSpecimensToDescriptiveDataSet(){ + if (specimenToAdd == null || specimenToAdd.isEmpty()){ + return new HashMap<>(); + } + UpdateResult result = CdmStore.getService(IDescriptiveDataSetService.class).addRowWrapperToDataset(specimenToAdd, getDescriptiveDataSet().getUuid()); + if(!result.getExceptions().isEmpty()){ + MessagingUtils.warningDialog(Messages.CharacterMatrixBottomToolbar_ERROR_ROW_CREATION_TITLE, this, + String.format(Messages.CharacterMatrixBottomToolbar_ERROR_ROW_CREATION_MESSAGE, result.getExceptions() + .stream().map(ex->ex.toString()) + .collect(Collectors.joining("\n")))); + } + DescriptiveDataSet dataSet = (DescriptiveDataSet) result.getCdmEntity(); + HashMap resultMap = new HashMap<>(); + for (CdmBase updated: result.getUpdatedObjects()){ + if (updated instanceof SpecimenDescription){ + resultMap.put(updated.getUuid(), (DescriptionBase)updated); + } + + + } + dataSet = this.getCdmEntitiySession().load(dataSet, true); + // update local dataset + DescriptiveDataSetBaseDto dto = DescriptiveDataSetBaseDto.fromDescriptiveDataSet(dataSet); + this.setDescriptiveDataSet(dto); + + //these descriptions are already updated + for (SpecimenRowWrapperDTO row: specimenToAdd){ + this.rowsToMerge.remove(row.getDescription().getDescriptionUuid()); + } + specimenToAdd.clear(); + return resultMap; + + } + + @Inject + @Optional + private void updateView(@UIEventTopic(WorkbenchEventConstants.ADD_TO_MERGE_ROWS) UUID uuid) { + + } + + @Override + public void dispose () { + super.dispose(); + descriptions.dispose(); + descriptions = null; + this.natTable.dispose(); + this.natTable = null; + categoricalFeatureToStateMap = null; + rowsToMerge.clear(); + rowsToMerge = null; + indexToFeatureMap = null; + propertyToLabelMap = null; + specimenCache = null; + featureToHistogramMap = null; + bodyDataProvider = null; + freezeLayer = null; + features = null; + topMostLayer.dispose(); + topMostLayer = null; + configRegistry = null; + bodyLayer.dispose(); + bodyLayer = null; + toolbar.dispose(); + toolbar = null; + treeFormat = null; + descriptionUuidsToDelete = null; + specimenToAdd = null; + mouseEventMatcher = null; + descriptionsToSave = null; + menuService = null; + sync = null; + part = null; + + } + }