import eu.etaxonomy.cdm.api.service.pager.Pager;\r
import eu.etaxonomy.cdm.api.service.search.SearchResult;\r
import eu.etaxonomy.cdm.api.service.util.TaxonRelationshipEdge;\r
-import eu.etaxonomy.cdm.model.common.CdmBase;\r
import eu.etaxonomy.cdm.model.common.ICdmBase;\r
import eu.etaxonomy.cdm.model.common.Language;\r
import eu.etaxonomy.cdm.model.description.DescriptionBase;\r
import eu.etaxonomy.cdm.model.description.TaxonDescription;\r
import eu.etaxonomy.cdm.model.location.Country;\r
import eu.etaxonomy.cdm.model.media.Media;\r
-import eu.etaxonomy.cdm.model.molecular.AmplificationResult;\r
import eu.etaxonomy.cdm.model.molecular.DnaSample;\r
import eu.etaxonomy.cdm.model.molecular.Sequence;\r
-import eu.etaxonomy.cdm.model.molecular.SingleRead;\r
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;\r
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;\r
import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;\r
*/\r
public DeleteResult delete(SpecimenOrObservationBase<?> specimen, SpecimenDeleteConfigurator config);\r
\r
- /**\r
- * Deletes the specified specimen and all sub derivates.<br>\r
- * <b>Note:</b> Be sure to allow child deletion in the config.\r
- * @param from the specimen which should be deleted with all its sub derivates\r
- * @param config the {@link SpecimenDeleteConfigurator} to specify how the deletion should be handled\r
- * @return the {@link DeleteResult} which holds information about the outcome of this operation\r
- */\r
- public DeleteResult deleteDerivateHierarchy(CdmBase from, SpecimenDeleteConfigurator config);\r
-\r
- /**\r
- * Deletes the specified specimen and all sub derivates by first loading the corresponding uuids\r
- * and then calling {@link #deleteDerivateHierarchy(CdmBase, SpecimenDeleteConfigurator) deleteDerivateHierarchy}\r
- * @param fromUuid uuid of the specimen which should be deleted with all its sub derivates\r
- * @param config the {@link SpecimenDeleteConfigurator} to specify how the deletion should be handled\r
- * @return {@link DeleteResult} which holds information about the outcome of this operation\r
- */\r
- public DeleteResult deleteDerivateHierarchy(UUID fromUuid, SpecimenDeleteConfigurator config);\r
-\r
/**\r
* Retrieves all {@link IndividualsAssociation} with the given specimen.<br>\r
* @param specimen the specimen for which the associations are retrieved\r
*/\r
public List<DerivedUnit> getAllChildDerivatives(SpecimenOrObservationBase<?> specimen);\r
\r
- /**\r
- * Deletes a {@link SingleRead} from the given {@link Sequence} and its {@link AmplificationResult}.\r
- * @param singleRead the single read to delete\r
- * @param sequence the sequence to which the single read belongs\r
- * @return the {@link DeleteResult} which holds information about the outcome of this operation\r
- */\r
- public DeleteResult deleteSingleRead(SingleRead singleRead, Sequence sequence);\r
-\r
- /**\r
- * Deletes a {@link SingleRead} from the given {@link Sequence} and its {@link AmplificationResult},\r
- * by first loading the corresponding uuids and then calling {@link #deleteSingleRead(SingleRead, Sequence) deleteSingleRead}\r
- * @param singleReadUuid uuid of the single read to delete\r
- * @param sequenceUuid uuid of the sequence to which the single read belongs\r
- * @return the {@link DeleteResult} which holds information about the outcome of this operation\r
- */\r
- public DeleteResult deleteSingleRead(UUID singleReadUuid, UUID sequenceUuid);\r
-\r
}\r
return deleteResult;
}
- @Override
- public DeleteResult deleteSingleRead(SingleRead singleRead, Sequence sequence){
- DeleteResult deleteResult = new DeleteResult();
- singleRead = HibernateProxyHelper.deproxy(singleRead, SingleRead.class);
- //delete from amplification result
- if(singleRead.getAmplificationResult()!=null){
- deleteResult.addUpdatedObject(singleRead.getAmplificationResult());
- singleRead.getAmplificationResult().removeSingleRead(singleRead);
- }
- //delete from sequence
- sequence.removeSingleRead(singleRead);
- deleteResult.addUpdatedObject(sequence);
-
- //check if used in other sequences
- List<SingleRead> toDelete = new ArrayList<SingleRead>();
- Map<SingleRead, Collection<Sequence>> singleReadSequencesMap = sequenceService.getSingleReadSequencesMap();
- if(singleReadSequencesMap.containsKey(singleRead)){
- for (Entry<SingleRead, Collection<Sequence>> entry : singleReadSequencesMap.entrySet()) {
- if(entry.getValue().isEmpty()){
- toDelete.add(singleRead);
- }
- }
- for (SingleRead singleReadToDelete : toDelete) {
- singleReadDao.delete(singleReadToDelete);
- }
- }
- else{
- singleReadDao.delete(singleRead);
- }
- deleteResult.setStatus(Status.OK);
- return deleteResult;
- }
-
- @Override
- @Transactional(readOnly = false)
- public DeleteResult deleteSingleRead(UUID singleReadUuid, UUID sequenceUuid){
- SingleRead singleRead = null;
- Sequence sequence = CdmBase.deproxy(sequenceService.load(sequenceUuid), Sequence.class);
- for(SingleRead sr : sequence.getSingleReads()) {
- if(sr.getUuid().equals(singleReadUuid)) {
- singleRead = sr;
- break;
- }
- }
- return deleteSingleRead(singleRead, sequence);
- }
-
- @Override
- public DeleteResult deleteDerivateHierarchy(CdmBase from, SpecimenDeleteConfigurator config) {
- DeleteResult deleteResult = new DeleteResult();
- String deleteMolecularNotAllowed = "Deleting molecular data is not allowed in config";
- if (from.isInstanceOf(Sequence.class)) {
- if (!config.isDeleteMolecularData()) {
- deleteResult.setAbort();
- deleteResult.addException(new ReferencedObjectUndeletableException(deleteMolecularNotAllowed));
- return deleteResult;
- }
- Sequence sequence = HibernateProxyHelper.deproxy(from, Sequence.class);
- DnaSample dnaSample = sequence.getDnaSample();
- dnaSample.removeSequence(sequence);
- deleteResult.includeResult(sequenceService.delete(sequence));
- deleteResult.addUpdatedObject(dnaSample);
- }
- else if(from instanceof SingleRead){
- SingleRead singleRead = (SingleRead)from;
- //delete from amplification result
- if(singleRead.getAmplificationResult()!=null){
- singleRead.getAmplificationResult().removeSingleRead(singleRead);
- }
- deleteResult.setAbort();
- deleteResult.addException(new ReferencedObjectUndeletableException("Deleted ONLY from amplification. "
- + "Single read may still be attached to a consensus sequence."));
- }
- else if(from.isInstanceOf(SpecimenOrObservationBase.class)) {
- deleteResult.includeResult(delete(HibernateProxyHelper.deproxy(from, SpecimenOrObservationBase.class), config));
- }
- return deleteResult;
- }
-
- @Override
- @Transactional(readOnly = false)
- public DeleteResult deleteDerivateHierarchy(UUID fromUuid, SpecimenDeleteConfigurator config) {
- return deleteDerivateHierarchy(dao.load(fromUuid),config);
- }
-
-// private DeleteResult deepDelete(SpecimenOrObservationBase<?> entity, SpecimenDeleteConfigurator config){
- // Set<DerivationEvent> derivationEvents = entity.getDerivationEvents();
- // for (DerivationEvent derivationEvent : derivationEvents) {
- // Set<DerivedUnit> derivatives = derivationEvent.getDerivatives();
- // for (DerivedUnit derivedUnit : derivatives) {
- // DeleteResult deleteResult = deepDelete(derivedUnit, config);
- // if(!deleteResult.isOk()){
- // return deleteResult;
- // }
- // }
- // }
- // return delete(entity, config);
- // }
-
@Override
public Collection<IndividualsAssociation> listIndividualsAssociations(SpecimenOrObservationBase<?> specimen, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
return dao.listIndividualsAssociations(specimen, null, null, null, null);
import eu.etaxonomy.cdm.api.service.DeleteResult;
import eu.etaxonomy.cdm.api.service.IAnnotatableService;
import eu.etaxonomy.cdm.api.service.UpdateResult;
-import eu.etaxonomy.cdm.api.service.config.SpecimenDeleteConfigurator;
+import eu.etaxonomy.cdm.model.molecular.AmplificationResult;
import eu.etaxonomy.cdm.model.molecular.Sequence;
import eu.etaxonomy.cdm.model.molecular.SingleRead;
public Map<SingleRead, Collection<Sequence>> getSingleReadSequencesMap();
/**
- * @param fromUuid
- * @param config
- * @return
+ * Deletes a {@link SingleRead} from the given {@link Sequence} and its {@link AmplificationResult}.
+ * @param singleRead the single read to delete
+ * @param sequence the sequence to which the single read belongs
+ * @return the {@link DeleteResult} which holds information about the outcome of this operation
*/
- public DeleteResult delete(UUID fromUuid, SpecimenDeleteConfigurator config);
+ public DeleteResult deleteSingleRead(SingleRead singleRead, Sequence sequence);
+ /**
+ * Deletes a {@link SingleRead} from the given {@link Sequence} and its {@link AmplificationResult},
+ * by first loading the corresponding uuids and then calling {@link #deleteSingleRead(SingleRead, Sequence) deleteSingleRead}
+ * @param singleReadUuid uuid of the single read to delete
+ * @param sequenceUuid uuid of the sequence to which the single read belongs
+ * @return the {@link DeleteResult} which holds information about the outcome of this operation
+ */
+ public DeleteResult deleteSingleRead(UUID singleReadUuid, UUID sequenceUuid);
}
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.UUID;
import org.apache.log4j.Logger;
import eu.etaxonomy.cdm.api.service.PreferenceServiceImpl;
import eu.etaxonomy.cdm.api.service.UpdateResult;
import eu.etaxonomy.cdm.api.service.UpdateResult.Status;
-import eu.etaxonomy.cdm.api.service.config.SpecimenDeleteConfigurator;
+import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.model.molecular.DnaSample;
import eu.etaxonomy.cdm.model.molecular.Sequence;
import eu.etaxonomy.cdm.model.molecular.SingleRead;
+import eu.etaxonomy.cdm.model.molecular.SingleReadAlignment;
import eu.etaxonomy.cdm.persistence.dao.molecular.ISequenceDao;
+import eu.etaxonomy.cdm.persistence.dao.molecular.ISingleReadDao;
/**
* @author pplitzner
@Autowired
IOccurrenceService occurrenceService;
+ @Autowired
+ ISingleReadDao singleReadDao;
+
@Override
@Autowired
protected void setDao(ISequenceDao dao) {
return singleReadToSequences;
}
+ @Override
+ public DeleteResult delete(Sequence sequence) {
+ DeleteResult deleteResult = new DeleteResult();
+ //remove from dnaSample
+ DnaSample dnaSample = sequence.getDnaSample();
+ if(dnaSample!=null){
+ dnaSample.removeSequence(sequence);
+ deleteResult.addUpdatedObject(dnaSample);
+ }
+ //remove singleReads
+ for (SingleReadAlignment singleReadAlignment : sequence.getSingleReadAlignments()) {
+ deleteSingleRead(singleReadAlignment.getSingleRead(), sequence);
+ }
+ dao.delete(sequence);
+ return deleteResult;
+ }
+
+ @Override
+ public DeleteResult deleteSingleRead(SingleRead singleRead, Sequence sequence){
+ DeleteResult deleteResult = new DeleteResult();
+ singleRead = HibernateProxyHelper.deproxy(singleRead, SingleRead.class);
+ //delete from amplification result
+ if(singleRead.getAmplificationResult()!=null){
+ deleteResult.addUpdatedObject(singleRead.getAmplificationResult());
+ singleRead.getAmplificationResult().removeSingleRead(singleRead);
+ }
+ //delete from sequence
+ sequence.removeSingleRead(singleRead);
+ deleteResult.addUpdatedObject(sequence);
+
+ //check if used in other sequences
+ List<SingleRead> toDelete = new ArrayList<SingleRead>();
+ Map<SingleRead, Collection<Sequence>> singleReadSequencesMap = getSingleReadSequencesMap();
+ if(singleReadSequencesMap.containsKey(singleRead)){
+ for (Entry<SingleRead, Collection<Sequence>> entry : singleReadSequencesMap.entrySet()) {
+ if(entry.getValue().isEmpty()){
+ toDelete.add(singleRead);
+ }
+ }
+ for (SingleRead singleReadToDelete : toDelete) {
+ singleReadDao.delete(singleReadToDelete);
+ }
+ }
+ else{
+ singleReadDao.delete(singleRead);
+ }
+ deleteResult.setStatus(Status.OK);
+ return deleteResult;
+ }
+
@Override
@Transactional(readOnly = false)
- public DeleteResult delete(UUID fromUuid, SpecimenDeleteConfigurator config) {
- return occurrenceService.deleteDerivateHierarchy(dao.load(fromUuid),config);
+ public DeleteResult deleteSingleRead(UUID singleReadUuid, UUID sequenceUuid){
+ SingleRead singleRead = null;
+ Sequence sequence = CdmBase.deproxy(load(sequenceUuid), Sequence.class);
+ for(SingleRead sr : sequence.getSingleReads()) {
+ if(sr.getUuid().equals(singleReadUuid)) {
+ singleRead = sr;
+ break;
+ }
+ }
+ return deleteSingleRead(singleRead, sequence);
}
+
}
package eu.etaxonomy.cdm.api.service;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
assertEquals("incorrect number of single reads", 1, dnaSample.getAmplificationResults().iterator().next().getSingleReads().size());
//delete field unit
- deleteResult = occurrenceService.deleteDerivateHierarchy(fieldUnit, config);
+ deleteResult = occurrenceService.delete(fieldUnit, config);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals(assertMessage, 0, occurrenceService.count(SpecimenOrObservationBase.class));
assertEquals(assertMessage, 0, occurrenceService.count(FieldUnit.class));
assertEquals("incorrect number of single reads", 1, dnaSample.getAmplificationResults().iterator().next().getSingleReads().size());
//delete derived unit
- deleteResult = occurrenceService.deleteDerivateHierarchy(derivedUnit, config);
+ deleteResult = occurrenceService.delete(derivedUnit, config);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals(assertMessage, 1, occurrenceService.count(SpecimenOrObservationBase.class));
assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
assertEquals("incorrect number of single reads", 1, dnaSample.getAmplificationResults().iterator().next().getSingleReads().size());
//delete dna sample
- deleteResult = occurrenceService.deleteDerivateHierarchy(dnaSample, config);
+ deleteResult = occurrenceService.delete(dnaSample, config);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals(assertMessage, 2, occurrenceService.count(SpecimenOrObservationBase.class));
assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
//A: delete singleRead
//delete singleReadA from sequenceA1 (singleReadA should NOT be deleted)
- deleteResult = occurrenceService.deleteSingleRead(singleReadA, sequenceA1);
+ deleteResult = sequenceService.deleteSingleRead(singleReadA, sequenceA1);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals("incorrect number of single reads", 2, singleReadDao.count());
assertEquals(0, sequenceA1.getSingleReadAlignments().size());
assertNotNull(singleReadDao.load(singleReadAUuid));
//delete singleReadA from sequenceA2 (singleReadA should be deleted)
- deleteResult = occurrenceService.deleteSingleRead(singleReadA, sequenceA2);
+ deleteResult = sequenceService.deleteSingleRead(singleReadA, sequenceA2);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals("incorrect number of single reads", 1, singleReadDao.count());
assertEquals(0, sequenceA2.getSingleReadAlignments().size());
//B: delete sequence
//delete sequenceB1 (singleReadB should NOT be deleted)
- deleteResult = occurrenceService.delete(sequenceB1Uuid);
+ deleteResult = sequenceService.delete(sequenceB1Uuid);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals("incorrect number of single reads", 1, singleReadDao.count());
assertNotNull(singleReadDao.load(singleReadBUuid));
//delete sequenceB1 (singleReadB should be deleted)
- deleteResult = occurrenceService.delete(sequenceB2Uuid);
+ deleteResult = sequenceService.delete(sequenceB2Uuid);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals("incorrect number of single reads", 0, singleReadDao.count());
assertTrue(singleReadDao.load(singleReadBUuid)==null);
assertEquals(assertMessage, 1, occurrenceService.count(DnaSample.class));
//delete field unit
- deleteResult = occurrenceService.deleteDerivateHierarchy(fieldUnit, config);
+ deleteResult = occurrenceService.delete(fieldUnit, config);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals(assertMessage, 0, occurrenceService.count(SpecimenOrObservationBase.class));
assertEquals(assertMessage, 0, occurrenceService.count(FieldUnit.class));
assertEquals("incorrect number of single reads", 1, consensusSequence.getSingleReads().size());
assertEquals(consensusSequence.getSingleReads().iterator().next(), dnaSample.getAmplificationResults().iterator().next().getSingleReads().iterator().next());
- //delete sequence -> should fail
- deleteResult = occurrenceService.deleteDerivateHierarchy(consensusSequence, config);
- assertFalse(deleteResult.toString(), deleteResult.isOk());
-
//allow deletion of molecular data
config.setDeleteMolecularData(true);
SingleRead singleRead = dnaSample.getAmplificationResults().iterator().next().getSingleReads().iterator().next();
- deleteResult = occurrenceService.deleteSingleRead(singleRead, consensusSequence);
+ deleteResult = sequenceService.deleteSingleRead(singleRead, consensusSequence);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals("incorrect number of single reads", 0, dnaSample.getAmplificationResults().iterator().next().getSingleReads().size());
assertEquals("incorrect number of single reads", 0, consensusSequence.getSingleReads().size());
assertEquals("incorrect number of single reads", 0, singleReadDao.count());
//delete sequence
- deleteResult = occurrenceService.deleteDerivateHierarchy(consensusSequence, config);
+ deleteResult = sequenceService.delete(consensusSequence);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals("number of sequences incorrect", 0, dnaSample.getSequences().size());
//delete dna sample
- deleteResult = occurrenceService.deleteDerivateHierarchy(dnaSample, config);
+ deleteResult = occurrenceService.delete(dnaSample, config);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals(assertMessage, 3, occurrenceService.count(SpecimenOrObservationBase.class));
assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
assertEquals(assertMessage, 0, occurrenceService.count(DnaSample.class));
//delete tissue sample
- deleteResult = occurrenceService.deleteDerivateHierarchy(tissueSample, config);
+ deleteResult = occurrenceService.delete(tissueSample, config);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals(assertMessage, 2, occurrenceService.count(SpecimenOrObservationBase.class));
assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
assertEquals(assertMessage, 0, occurrenceService.count(DnaSample.class));
//delete derived unit
- deleteResult = occurrenceService.deleteDerivateHierarchy(derivedUnit, config);
+ deleteResult = occurrenceService.delete(derivedUnit, config);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals(assertMessage, 1, occurrenceService.count(SpecimenOrObservationBase.class));
assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
assertEquals(assertMessage, 0, occurrenceService.count(DnaSample.class));
//delete field unit
- deleteResult = occurrenceService.deleteDerivateHierarchy(fieldUnit, config);
+ deleteResult = occurrenceService.delete(fieldUnit, config);
assertTrue(deleteResult.toString(), deleteResult.isOk());
assertEquals(assertMessage, 0, occurrenceService.count(SpecimenOrObservationBase.class));
BGBM BDI Projects / cdmlib.git / commitdiff