cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/TermVocabulary.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/TimePeriod.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/User.java -text
-cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/UuidAndTitleCache.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/VersionableEntity.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/VocabularyEnum.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/WrongTermTypeException.java -text
cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/dao/validation/IEntityValidationDao.java -text
cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/dto/ITermRepresentation_L10n.java -text
cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/dto/TermDto.java -text
+cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/dto/UuidAndTitleCache.java -text
cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/fetch/CdmFetch.java -text
cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/hibernate/CacheStrategyGenerator.java -text
cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/persistence/hibernate/CdmDataChangeEvent.java -text
import eu.etaxonomy.cdm.model.common.LanguageString;
import eu.etaxonomy.cdm.model.common.OriginalSourceBase;
import eu.etaxonomy.cdm.model.common.OriginalSourceType;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.description.DescriptionBase;
import eu.etaxonomy.cdm.model.description.DescriptionElementSource;
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;
private boolean sourceNotLinkedToElement(DerivedUnit derivedUnitBase2, Reference<?> b, String d) {
Set<IdentifiableSource> linkedSources = derivedUnitBase2.getSources();
for (IdentifiableSource is:linkedSources){
- Reference a = is.getCitation();
+ Reference<?> a = is.getCitation();
String c = is.getCitationMicroReference();
boolean refMatch=false;
private boolean sourceNotLinkedToElement(SpecimenOrObservationBase<?> specimen, OriginalSourceBase<?> source) {
Set<IdentifiableSource> linkedSources = specimen.getSources();
for (IdentifiableSource is:linkedSources){
- Reference a = is.getCitation();
- Reference b = source.getCitation();
+ Reference<?> a = is.getCitation();
+ Reference<?> b = source.getCitation();
String c = is.getCitationMicroReference();
String d = source.getCitationMicroReference();
private boolean sourceNotLinkedToElement(IndividualsAssociation indAssociation, Reference<?> a, String d) {
Set<DescriptionElementSource> linkedSources = indAssociation.getSources();
for (DescriptionElementSource is:linkedSources){
- Reference b = is.getCitation();
+ Reference<?> b = is.getCitation();
String c = is.getCitationMicroReference();
boolean refMatch=false;
private boolean sourceNotLinkedToElement(TaxonDescription taxonDescription, Reference<?> a, String d) {
Set<IdentifiableSource> linkedSources = taxonDescription.getSources();
for (IdentifiableSource is:linkedSources){
- Reference b = is.getCitation();
+ Reference<?> b = is.getCitation();
String c = is.getCitationMicroReference();
boolean refMatch=false;
private boolean sourceNotLinkedToElement(IndividualsAssociation indAssociation, OriginalSourceBase<?> source) {
Set<DescriptionElementSource> linkedSources = indAssociation.getSources();
for (DescriptionElementSource is:linkedSources){
- Reference a = is.getCitation();
- Reference b = source.getCitation();
+ Reference<?> a = is.getCitation();
+ Reference<?> b = source.getCitation();
String c = is.getCitationMicroReference();
String d = source.getCitationMicroReference();
private boolean sourceNotLinkedToElement(TaxonDescription taxonDescription, OriginalSourceBase<?> sour) {
Set<IdentifiableSource> linkedSources = taxonDescription.getSources();
for (IdentifiableSource is:linkedSources){
- Reference a = is.getCitation();
- Reference b = sour.getCitation();
+ Reference<?> a = is.getCitation();
+ Reference<?> b = sour.getCitation();
String c = is.getCitationMicroReference();
String d = sour.getCitationMicroReference();
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
-import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.OriginalSourceType;
import eu.etaxonomy.cdm.model.common.TimePeriod;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.description.DescriptionElementSource;
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.IndividualsAssociation;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;
import eu.etaxonomy.cdm.strategy.parser.TimePeriodParser;
/**
* @author p.kelbert
* @created 29.10.2008
- * @version 1.0
- */
-/**
- * @author pkelbert
* @date 13 mars 2013
*
*/
@Component
public class SpecimenSythesysExcelImport extends CdmImportBase<SpecimenSynthesysExcelImportConfigurator, SpecimenSynthesysExcelImportState>
-implements ICdmIO<SpecimenSynthesysExcelImportState> {
+ implements ICdmIO<SpecimenSynthesysExcelImportState> {
private static final Logger logger = Logger.getLogger(SpecimenSythesysExcelImport.class);
getTaxonService().saveOrUpdate(taxon);
}
-
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.io.common.CdmIoBase#isIgnore(eu.etaxonomy.cdm.io.common.IoStateBase)
- */
@Override
protected boolean isIgnore(SpecimenSynthesysExcelImportState state) {
return false;
}
-
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.io.specimen.SpecimenIoBase#doInvoke(eu.etaxonomy.cdm.io.specimen.abcd206.SpecimenImportState)
- */
@Override
protected void doInvoke(SpecimenSynthesysExcelImportState state) {
boolean success = true;
}
-
-
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.io.common.CdmIoBase#doCheck(eu.etaxonomy.cdm.io.common.IoStateBase)
- */
@Override
protected boolean doCheck(SpecimenSynthesysExcelImportState state) {
logger.warn("Validation not yet implemented for " + getClass().getSimpleName());
return true;
}
-
-
}
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.TimePeriod;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TextData;
import eu.etaxonomy.cdm.model.taxon.Classification;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;
import eu.etaxonomy.cdm.strategy.parser.ParserProblem;
import eu.etaxonomy.cdm.model.common.LSID;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.OriginalSourceType;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.FeatureNode;
import eu.etaxonomy.cdm.model.description.FeatureTree;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;
import eu.etaxonomy.cdm.strategy.parser.INonViralNameParser;
import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;
import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImplRegExBase;
-import eu.etaxonomy.cdm.strategy.parser.ParserProblem;
/**
* @author pkelbert
private MyName currentMyName;
private Reference<?> sourceUrlRef;
-
+
private String followingText; //text element immediately following a tax:name in tax:nomenclature TODO move do state
private String usedFollowingTextPrefix; //the part of the following text which has been used during taxon name creation
-
+
private final TaxonXAddSources sourceHandler = new TaxonXAddSources();
/**
private Taxon handleSingleNode(Reference<?> refMods, URI sourceName,
List<TaxonNameBase> namesToSave, Node child, Taxon acceptedTaxon) {
Taxon defaultTaxon =null;
-
+
String nodeName = child.getNodeName();
if (nodeName.equalsIgnoreCase("tax:nomenclature")){
NodeList nomenclatureChildren = child.getChildNodes();
sourceHandler.addAndSaveSource(refMods, derivedUnitBase);
TaxonDescription taxonDescription = importer.getTaxonDescription(acceptedTaxon, false, true);
-
+
Feature feature=null;
feature = makeFeature(derivedUnitBase);
if(!StringUtils.isEmpty(descr)) {
derivedUnitBase = derivedUnitFacade.innerDerivedUnit();
sourceHandler.addAndSaveSource(refMods, derivedUnitBase);
-
+
//TODO this may not always be correct, ask user
TaxonNameBase<?,?> typifiableName = acceptedTaxon != null ? acceptedTaxon.getName() : null;
myspecimenOrObservation = extractSpecimenOrObservation(event,derivedUnitBase,SpecimenOrObservationType.DerivedUnit, typifiableName);
sourceHandler.addAndSaveSource(refMods, derivedUnitBase);
TaxonDescription taxonDescription = importer.getTaxonDescription(acceptedTaxon, false, true);
-
+
Feature feature = makeFeature(derivedUnitBase);
featuresMap.put(feature.getTitleCache(),feature);
if(!StringUtils.isEmpty(descr)) {
/**
- * @param currentName
+ * @param currentName
* @param materials: the XML node group
* @param acceptedTaxon: the current accepted Taxon
* @param refMods: the current reference extracted from the MODS
}else{
logger.warn("node not handled yet: " + insideNodes.item(j).getNodeName());
}
-
+
}
if (!StringUtils.isBlank(StringUtils.join(blabla," "))) {
fullDescription.add(StringUtils.join(blabla," "));
*/
private void setParticularDescription(String descr, Taxon acceptedTaxon, Taxon defaultTaxon, Reference<?> refMods, Feature currentFeature) {
logger.info("setParticularDescription " + currentFeature.getTitleCache()+", \n blabla : "+descr);
-
+
//remove redundant feature title
String featureStr = currentFeature.getTitleCache();
if (!descr.isEmpty() && descr.toLowerCase().startsWith(featureStr.toLowerCase())){
descr = descr.replaceAll("(?i)" + featureStr + "\\.\\s*", "");
- }
+ }
+
-
acceptedTaxon = CdmBase.deproxy(acceptedTaxon, Taxon.class);
featuresMap.put(currentFeature.getTitleCache(),currentFeature);
}
}
-
+
for(MyName name:names){
TaxonNameBase nameToBeFilled = name.getTaxonNameBase();
Synonym synonym = name.getSyno();
addFollowingTextToName(nameToBeFilled, followingText);
-
+
/* INonViralNameParser parser = NonViralNameParserImpl.NewInstance();
nameToBeFilled = parser.parseFullName(name.getName(), nomenclaturalCode, name.getRank());
if (nameToBeFilled.hasProblem() &&
private boolean addFollowingTextToName(TaxonNameBase nameToBeFilled, String followingText) {
if (nameToBeFilled != null && StringUtils.isNotBlank(followingText)){
if (! followingText.matches("\\d\\.?")){
-
+
if (followingText.startsWith(",")){
followingText = followingText.substring(1).trim();
}
return true;
}
return false;
-
+
}
/**
String nomNovStatus = this.newNameStatus(currentMyName.getStatus());
if (nomNovStatus != null){
nameToBeFilled.setAppendedPhrase(nomNovStatus);
- }else{
+ }else{
try {
NomenclaturalStatusType statusType = nomStatusString2NomStatus(currentMyName.getStatus());
nameToBeFilled.addStatus(NomenclaturalStatus.NewInstance(statusType));
for (int i=0;i<children.getLength();i++){
if(children.item(i).getNodeName().equalsIgnoreCase("tax:status")){
String status = children.item(i).getTextContent().trim();
-
+
if (!status.isEmpty()){
if (newNameStatus(status) != null){
newNameStatus = newNameStatus(status);
boolean containsSynonyms=false;
boolean wasSynonym = false;
usedFollowingTextPrefix = null; //reset
-
+
for (int i=0; i<children.getLength(); i++){
Node childNode = children.item(i);
String childName = childNode.getNodeName();
-
-
+
+
//following text
followingText = null;
if ( i + 1 < children.getLength()){
followingText = followingTextNode.getTextContent();
}
}
-
+
//traverse nodes
if (childName.equalsIgnoreCase("#text")) {
freetext = childNode.getTextContent().trim();
//System.out.println("HANDLE FIRST NAME OF THE LIST");
if(!containsSynonyms){
wasSynonym = false;
-
+
//System.out.println("I : "+i);
currentMyName = new MyName(false);
try {
//System.out.println("SET SECUNDUM "+configState.getConfig().getSecundum());
}
importer.getTaxonService().saveOrUpdate(acceptedTaxon);
-
+
if (!sourcelinked){
sourceHandler.addSource(refMods, acceptedTaxon);
}
try{
extractSynonyms(childNode, acceptedTaxon, refMods, followingText);
wasSynonym = true;
-
+
}catch(NullPointerException e){
logger.warn("null pointer exception, the accepted taxon might be null");
}
extractReferences(childNode,nametosave,acceptedTaxon,refMods);
}else if (childName.equalsIgnoreCase("tax:bibref")){
logger.warn(childName + " still preliminary");
-
+
NonViralName<?> currentName = currentMyName == null ? null : currentMyName.getTaxonNameBase();
boolean handled = addFollowingTextToName (currentName, childNode.getTextContent() );
if (! handled){
- setParticularDescription(freetext.trim(), acceptedTaxon,acceptedTaxon, refMods, getNotMarkedUpFeatureObject());
+ setParticularDescription(freetext.trim(), acceptedTaxon,acceptedTaxon, refMods, getNotMarkedUpFeatureObject());
}
}else{
logger.warn(childName + " not yet handled");
handled = addFollowingTextToName (currentName, childNode.getTextContent() );
}
if (! handled){
- setParticularDescription(freetext.trim(), acceptedTaxon,acceptedTaxon, refMods, getNotMarkedUpFeatureObject());
+ setParticularDescription(freetext.trim(), acceptedTaxon,acceptedTaxon, refMods, getNotMarkedUpFeatureObject());
}
}
-
+
freetext = "";
}
//importer.getClassificationService().saveOrUpdate(classification);
return acceptedTaxon;
}
-
+
private TaxonNameBase<?,?> parseWithExtension(INonViralNameParser parser, String atomisedNameStr, Rank rank, String followingText, HashMap<String, String> atomisedMap) {
Object[] nameExtensionResult = getPossibleExtension(followingText, atomisedMap, nomenclaturalCode);
-
+
TaxonNameBase<?,?> name = parser.parseFullName(atomisedNameStr, nomenclaturalCode, rank);
if (nameExtensionResult != null && nameExtensionResult[0] != null){
String ext = (String)nameExtensionResult[0];
if (StringUtils.isBlank(followingText)){
return null;
}
-
+
boolean includeAuthor = true;
boolean includeYear = false;
if (atomisedMap.containsKey("dwc:scientificnameauthorship")){
match = matcher.group();
}
}
-
+
return new Object[]{match, includeAuthor, includeYear};
}
n=n.trim();
String author = myname.getAuthor();
if(n.split(" ").length>2){
-
+
String n2=n.split(" ")[0]+" "+n.split(" ")[1];
String a= "";
try{
n=n.trim();
String author = myname.getAuthor();
if(n.split(" ").length>2){
-
+
String n2=n.split(" ")[0]+" "+n.split(" ")[1];
String a="";
try{
myname.setAuthor(a);
//System.out.println("FINDCREATESPECIES --"+n2+"--"+n+"**"+a+"##");
n=n2;
-
+
}
Taxon species = myname.findOrCreateTaxon(atomisedMap.get("dwc:species"),n, Rank.SPECIES(),rank);
myname.setSpecies(species);
}
}
-
+
/**
- * @param refMods
+ * @param refMods
* @see #createUnparsedSynonym(Rank, String, HashMap, MyName)
* the original TaxonXImport extracted Synonyms by creating acc Taxa with partial names
* I (AM) do not understand this but don't want to destroy code which maybe works in some cases) there
*/
private void createUnparsedSynonymNew(Rank rank, String newName, HashMap<String, String> atomisedMap, MyName myname, Reference<?> refMods) {
logger.info("createSynonym");
-
+
NonViralName<?> nameToBeFilled = this.getNonViralNameAccNomenclature();
//System.out.println("createsynonym");
if(rank.equals(Rank.UNKNOWN_RANK())){
- //TODO
+ //TODO
myname.setNotParsableTaxon(newName);
-
+
nameToBeFilled.setTitleCache(newName, true);
}else{
if(atomisedMap.get("dwc:genus") != null ){
myname.setSynonym(true);
}
}
-
+
/**
* @param rank
* @param newName
*/
@SuppressWarnings("rawtypes")
public NonViralName<?> castTaxonNameBase(TaxonNameBase tnb, NonViralName<?> nvn) {
-
+
//logger.info("castTaxonNameBase");
NonViralName<?> taxonnamebase2 = nvn;
if (nomenclaturalCode.equals(NomenclaturalCode.ICNAFP)) {
public String getVarietyStr() {
return varietyStr;
}
-
+
public Integer getPublicationYear() {
return publicationYear;
}
}
}
}
-
+
tmpTaxonBase = CdmBase.deproxy(tmpTaxonBase, TaxonBase.class);
if (author != null) {
if (!getIdentifier().isEmpty() && (getIdentifier().length()>2)){
}
}
TaxonNameBase<?,?> tnb = CdmBase.deproxy(tmpTaxonBase.getName(), TaxonNameBase.class);
-
+
if(!isSynonym) {
this.taxon=(Taxon)tmpTaxonBase;
} else {
}
this.syno=(Synonym)tmpTaxonBase;
}
-
+
taxonNameBase = castTaxonNameBase(tnb, taxonNameBase);
}
if (! compare){
return false;
}
-
+
if (nodeName.getNameCache() != null && nodeName.getNameCache().equals(newName.getNameCache())){
if (nodeName.getNameCache().equals(nodeName.getTitleCache())){
if (newName.getNameCache().length() < newName.getTitleCache().length()){
}
}
}
-
+
return false;
}
// return higherTaxon;
}
//add the relation to the highertaxon, except if the current rank to add IS the maxRank
-
+
//TODO higher Ranks
-
+
if(hierarchy.containsKey(Rank.FAMILY()) && !state2.getConfig().getMaxRank().equals(Rank.FAMILY())){
higherTaxon=saveAndGetHigherTaxon(Rank.FAMILY(),higherTaxon);
}
importer.getClassificationService().saveOrUpdate(classification);
}
-
+
}
tmp = CdmBase.deproxy(tmp, Taxon.class);
return tmp;
}
-
+
/**
* @param tnb
* @return
private Taxon buildGenus(String partialname, NonViralName<?> tnb) {
Taxon tmp;
tnb.setGenusOrUninomial(partialname);
-
+
tmp = findMatchingTaxon(tnb,refMods);
if(tmp ==null){
if (currentlsid !=null){
if (currentlsid.getLsid().equals(lsid.getLsid())){
try{
- return (Taxon) t;
+ return t;
}
catch(Exception e){logger.warn("Exception occurred while comparing LSIDs "+e );}
}
if (tnb.getTitleCache() == null){
tnb.setTitleCache(tnb.toString(), tnb.isProtectedTitleCache());
}
-
+
Pager<TaxonBase> pager=importer.getTaxonService().findByTitle(TaxonBase.class, tnb.getTitleCache().split("sec.")[0].trim(), MatchMode.BEGINNING, null, null, null, null, null);
List<TaxonBase>records = pager.getRecords();
if(parentDoesNotExist) {
Taxon tmp = findMatchingTaxon(parentNameName,ref);
if(tmp ==null){
-
+
parent=Taxon.NewInstance(parentNameName, ref);
importer.getTaxonService().save(parent);
parent = CdmBase.deproxy(parent, Taxon.class);
import eu.etaxonomy.cdm.model.agent.InstitutionalMembership;\r
import eu.etaxonomy.cdm.model.agent.Person;\r
import eu.etaxonomy.cdm.model.agent.Team;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
\r
public interface IAgentDao extends IIdentifiableDao<AgentBase> {\r
\r
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* European Distributed Institute of Taxonomy
* http://www.e-taxonomy.eu
-*
+*
* The contents of this file are subject to the Mozilla Public License Version 1.1
* See LICENSE.TXT at the top of this package for the full license terms.
*/
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
import eu.etaxonomy.cdm.model.common.Identifier;
import eu.etaxonomy.cdm.model.common.LSID;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.media.Rights;
import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
import eu.etaxonomy.cdm.persistence.query.OrderHint;
public interface IIdentifiableDao <T extends IdentifiableEntity> extends IAnnotatableDao<T>, ITitledDao<T>, ISearchableDao<T>{
-
+
/**
* Return an object by LSID. NOTE: Because of the fact that LSIDs are supposed to
* be globally resolvable, this method behaves in a different way to other methods
- *
- * In short, it attempts to find an object of type T in the current view using the LSID passed. If the LSID passed has a
+ *
+ * In short, it attempts to find an object of type T in the current view using the LSID passed. If the LSID passed has a
* revision part, then this will be used in the query, but if not, then it is expected that the request is for the 'current'
- * version of the object and the revision part will not be used as a matching criteria in the query.
- *
- * If the object does not appear in the current view (i.e. it has been deleted), then this method will search the history
+ * version of the object and the revision part will not be used as a matching criteria in the query.
+ *
+ * If the object does not appear in the current view (i.e. it has been deleted), then this method will search the history
* tables for a match, again using the revision if it exists, but ignoring it if not.
- *
+ *
* @param lsid a LifeScience Identifier identifying the desired object
*/
public T find(LSID lsid);
-
+
/**
* Return a count of the sources for this identifiable entity
- *
+ *
* @param identifiableEntity The identifiable entity
* @return a count of OriginalSource instances
*/
public int countSources(T identifiableEntity);
-
+
/**
* Return a List of the sources for this identifiable entity
- *
+ *
* @param identifiableEntity The identifiable entity
* @param pageSize The maximum number of sources returned (can be null for all sources)
* @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)
* @return a List of OriginalSource instances
*/
public List<IdentifiableSource> getSources(T identifiableEntity, Integer pageSize, Integer pageNumber, List<String> propertyPaths);
-
+
/**
* Return a count of the rights for this identifiable entity
- *
+ *
* @param identifiableEntity The identifiable entity
* @return a count of Rights instances
*/
public int countRights(T identifiableEntity);
-
-
+
+
/**
* Return a List of the rights for this identifiable entity
- *
+ *
* @param identifiableEntity The identifiable entity
* @param pageSize The maximum number of rights returned (can be null for all rights)
* @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)
* @return a List of Rights instances
*/
public List<Rights> getRights(T identifiableEntity, Integer pageSize, Integer pageNumber, List<String> propertyPaths);
-
+
// TODO Migrated from IOriginalSourceDao
public List<T> findOriginalSourceByIdInSource(String idInSource, String idNamespace);
-
+
/**
* Return a list of all uuids mapped to titleCache in the convenient <code>UuidAndTitleCache</code> object.
* Retrieving this list is considered to be significantly faster than initializing the fully fledged buiseness
- * objects. To be used in cases where you want to present large amount of data and provide details after
- * a selection has been made.
- *
+ * objects. To be used in cases where you want to present large amount of data and provide details after
+ * a selection has been made.
+ *
* @return a list of <code>UuidAndTitleCache</code> instances
*/
- public List<UuidAndTitleCache<T>> getUuidAndTitleCache();
-
+ public List<UuidAndTitleCache<T>> getUuidAndTitleCache();
+
/**
* Return a List of objects matching the given query string, optionally filtered by class, optionally with a particular MatchMode
- *
+ *
* @param clazz filter by class - can be null to include all instances of type T
* @param queryString the query string to filter by
* @param matchmode use a particular type of matching (can be null - defaults to exact matching)
* @return a List of instances of type T matching the queryString
*/
public List<T> findByTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths);
-
-
+
+
/**
* TODO
/**
* Return a List of objects matching the given query string, optionally filtered by class, optionally with a particular MatchMode
- *
+ *
* @param clazz filter by class - can be null to include all instances of type T
* @param queryString the query string to filter by
* @param matchmode use a particular type of matching (can be null - defaults to exact matching)
* @return a List of instances of type T matching the queryString
*/
public List<T> findByReferenceTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths);
-
+
/**
* Return a count of objects matching the given query string in the titleCache, optionally filtered by class, optionally with a particular MatchMode
- *
+ *
* @param clazz filter by class - can be null to include all instances of type T
* @param queryString the query string to filter by
* @param matchmode use a particular type of matching (can be null - defaults to exact matching)
* @return a count of instances of type T matching the queryString
*/
public int countByTitle(Class<? extends T> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria);
-
+
/**
* Return a count of objects matching the given query string in the title, optionally filtered by class, optionally with a particular MatchMode
- *
+ *
* @param clazz filter by class - can be null to include all instances of type T
* @param queryString the query string to filter by
* @param matchmode use a particular type of matching (can be null - defaults to exact matching)
/**
* Return a count of distinct titleCache Strings for a given {@link IdentifiableEntity}, optionally filtered by class, optionally with a particular MatchMode
- *
+ *
* @param clazz filter by class - can be null to include all instances of type T
* @param queryString the query string to filter by
* @param matchmode use a particular type of matching (can be null - defaults to exact matching)
* @return
*/
public <S extends T> int countByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode);
-
+
/**
- * Returns a tuple including the identifier type, the identifier string,
+ * Returns a tuple including the identifier type, the identifier string,
* and if includeEntity is <code>false</code> the CDM entities uuid, and titleCache,
- * otherwise the CDM entity itself
+ * otherwise the CDM entity itself
* @param clazz the identifiable entity subclass, may be null
* @param identifier the identifier as {@link String}
* @param identifierType the identifier type, maybe null
- * @param matchmode
+ * @param matchmode
* @param includeCdmEntity
* @param pageSize
* @param pageNumber
import java.util.Set;\r
import java.util.UUID;\r
\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.description.DescriptionBase;\r
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;\r
import eu.etaxonomy.cdm.model.description.DescriptiveSystemRole;\r
import eu.etaxonomy.cdm.model.description.Feature;\r
import eu.etaxonomy.cdm.model.description.WorkingSet;\r
import eu.etaxonomy.cdm.persistence.dao.common.IAnnotatableDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
\r
public interface IWorkingSetDao extends IAnnotatableDao<WorkingSet> {\r
- \r
+\r
public Map<DescriptionBase,Set<DescriptionElementBase>> getDescriptionElements(WorkingSet workingSet, Set<Feature> features, Integer pageSize, Integer pageNumber, List<String> propertyPaths);\r
\r
public <T extends DescriptionElementBase> Map<UuidAndTitleCache, Map<UUID, Set<T>>> getTaxonFeatureDescriptionElementMap(Class<T> clazz, UUID workingSetUuid, DescriptiveSystemRole role);\r
import eu.etaxonomy.cdm.model.agent.InstitutionalMembership;\r
import eu.etaxonomy.cdm.model.agent.Person;\r
import eu.etaxonomy.cdm.model.agent.Team;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.view.AuditEvent;\r
import eu.etaxonomy.cdm.persistence.dao.agent.IAgentDao;\r
import eu.etaxonomy.cdm.persistence.dao.hibernate.common.IdentifiableDaoBase;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
\r
\r
@Repository\r
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
import eu.etaxonomy.cdm.model.common.LSID;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.media.Rights;
import eu.etaxonomy.cdm.persistence.dao.QueryParseException;
import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
import eu.etaxonomy.cdm.persistence.query.OrderHint;
public class IdentifiableDaoBase<T extends IdentifiableEntity> extends AnnotatableDaoImpl<T> implements IIdentifiableDao<T>{
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(IdentifiableDaoBase.class);
+
protected String defaultField = "titleCache_tokenized";
protected Class<? extends T> indexedClasses[];
import org.springframework.beans.factory.annotation.Qualifier;\r
import org.springframework.stereotype.Repository;\r
\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.description.CategoricalData;\r
import eu.etaxonomy.cdm.model.description.DescriptionBase;\r
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;\r
import eu.etaxonomy.cdm.model.description.WorkingSet;\r
import eu.etaxonomy.cdm.persistence.dao.description.IWorkingSetDao;\r
import eu.etaxonomy.cdm.persistence.dao.hibernate.common.AnnotatableDaoImpl;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
\r
@Repository\r
@Qualifier("workingSetDaoImpl")\r
import org.hibernate.Session;
import org.springframework.stereotype.Repository;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.molecular.Amplification;
import eu.etaxonomy.cdm.persistence.dao.hibernate.common.AnnotatableDaoImpl;
import eu.etaxonomy.cdm.persistence.dao.molecular.IAmplificationDao;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
/**
* @author pplitzner
Query query = session.createQuery("select uuid, id, labelCache from Amplification");
+ @SuppressWarnings("unchecked")
List<Object[]> result = query.list();
for(Object[] object : result){
import org.hibernate.Session;
import org.springframework.stereotype.Repository;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.molecular.Primer;
import eu.etaxonomy.cdm.persistence.dao.hibernate.common.AnnotatableDaoImpl;
import eu.etaxonomy.cdm.persistence.dao.molecular.IPrimerDao;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
/**
* @author pplitzner
Query query = session.createQuery("select uuid, id, label from Primer");
+ @SuppressWarnings("unchecked")
List<Object[]> result = query.list();
for(Object[] object : result){
\r
import eu.etaxonomy.cdm.model.common.CdmBase;\r
import eu.etaxonomy.cdm.model.common.RelationshipBase;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.name.BacterialName;\r
import eu.etaxonomy.cdm.model.name.BotanicalName;\r
import eu.etaxonomy.cdm.model.name.CultivarPlantName;\r
import eu.etaxonomy.cdm.persistence.dao.name.IHomotypicalGroupDao;\r
import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;\r
import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.query.MatchMode;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
\r
}\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao#getNameRelationships(eu.etaxonomy.cdm.model.name.TaxonNameBase, eu.etaxonomy.cdm.model.common.RelationshipBase.Direction, eu.etaxonomy.cdm.model.name.NameRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)\r
- */\r
@Override\r
public List<NameRelationship> getNameRelationships(TaxonNameBase name, NameRelationship.Direction direction,\r
NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints,\r
\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao#getUuidAndTitleCacheOfNames()\r
- */\r
@Override\r
public List<UuidAndTitleCache> getUuidAndTitleCacheOfNames() {\r
String queryString = "SELECT uuid, id, fullTitleCache FROM TaxonNameBase";\r
import org.springframework.beans.factory.annotation.Autowired;\r
import org.springframework.stereotype.Repository;\r
\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.description.DescriptionBase;\r
import eu.etaxonomy.cdm.model.description.IndividualsAssociation;\r
import eu.etaxonomy.cdm.model.media.Media;\r
import eu.etaxonomy.cdm.persistence.dao.name.IHomotypicalGroupDao;\r
import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;\r
import eu.etaxonomy.cdm.persistence.dao.occurrence.IOccurrenceDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.query.MatchMode;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
\r
import org.springframework.beans.factory.annotation.Qualifier;\r
import org.springframework.stereotype.Repository;\r
\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.reference.IArticle;\r
import eu.etaxonomy.cdm.model.reference.IBookSection;\r
import eu.etaxonomy.cdm.model.reference.IInProceedings;\r
import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
import eu.etaxonomy.cdm.persistence.dao.hibernate.common.IdentifiableDaoBase;\r
import eu.etaxonomy.cdm.persistence.dao.reference.IReferenceDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
import eu.etaxonomy.cdm.strategy.cache.reference.ReferenceDefaultCacheStrategy;\r
\r
public void rebuildIndex() {\r
FullTextSession fullTextSession = Search.getFullTextSession(getSession());\r
\r
- for(Reference reference : list(null,null)) { // re-index all agents\r
+ for(Reference<?> reference : list(null,null)) { // re-index all agents\r
Hibernate.initialize(reference.getAuthorship());\r
\r
if(reference.getType().equals(ReferenceType.Article)) {\r
\r
Query query = session.createQuery("select uuid, id, titleCache from " + type.getSimpleName());\r
\r
- List<Object[]> result = query.list();\r
+ @SuppressWarnings("unchecked")\r
+ List<Object[]> result = query.list();\r
\r
for(Object[] object : result){\r
list.add(new UuidAndTitleCache<Reference>(type, (UUID) object[0], (Integer)object[1], (String) object[2]));\r
return references;\r
}\r
\r
- @Override\r
- public List<Reference> getSubordinateReferences(\r
- Reference reference) {\r
+\r
+ @Override\r
+ public List<Reference> getSubordinateReferences(Reference reference) {\r
\r
List<Reference> references = new ArrayList();\r
- List<Reference> subordinateReferences = new ArrayList();\r
+ List<Reference> subordinateReferences = new ArrayList<Reference>();\r
\r
Query query = getSession().createQuery("select r from Reference r where r.inReference = (:reference)");\r
query.setParameter("reference", reference);\r
- references.addAll(query.list());\r
- for(Reference ref : references){\r
+\r
+ @SuppressWarnings("unchecked")\r
+ List<Reference<?>> list = query.list();\r
+ references.addAll(list);\r
+ for(Reference<?> ref : references){\r
subordinateReferences.addAll(getSubordinateReferences(ref));\r
}\r
references.addAll(subordinateReferences);\r
return references;\r
}\r
\r
- @Override\r
+ @Override\r
public List<TaxonBase> listCoveredTaxa(Reference reference, boolean includeSubordinateReferences, List<OrderHint> orderHints, List<String> propertyPaths) {\r
\r
/*\r
*/\r
\r
//TODO implement search in nameDescriptions\r
- List<TaxonBase> taxonBaseList = new ArrayList<TaxonBase>();\r
Set<Reference> referenceSet = new HashSet<Reference>();\r
referenceSet.add(reference);\r
if(includeSubordinateReferences){\r
query.setParameterList("referenceBase_5", referenceSet);\r
query.setParameterList("referenceBase_6", referenceSet);\r
\r
- taxonBaseList = query.list();\r
+ @SuppressWarnings("unchecked")\r
+ List<TaxonBase> taxonBaseList = query.list();\r
\r
defaultBeanInitializer.initializeAll(taxonBaseList, propertyPaths);\r
\r
import eu.etaxonomy.cdm.model.common.OriginalSourceBase;\r
import eu.etaxonomy.cdm.model.common.RelationshipBase;\r
import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.location.NamedArea;\r
import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.persistence.dao.hibernate.common.IdentifiableDaoBase;\r
import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;\r
import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.fetch.CdmFetch;\r
import eu.etaxonomy.cdm.persistence.query.MatchMode;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
import java.util.List;
import java.util.UUID;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.molecular.Amplification;
import eu.etaxonomy.cdm.persistence.dao.common.IAnnotatableDao;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
/**
* @author pplitzner
import java.util.List;
import java.util.UUID;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.molecular.Primer;
import eu.etaxonomy.cdm.persistence.dao.common.IAnnotatableDao;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
/**
* @author pplitzner
import org.hibernate.criterion.Criterion;\r
\r
import eu.etaxonomy.cdm.model.common.RelationshipBase;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.name.HybridRelationship;\r
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;\r
import eu.etaxonomy.cdm.model.name.NameRelationship;\r
import eu.etaxonomy.cdm.model.name.ZoologicalName;\r
import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;\r
import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.query.MatchMode;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
\r
\r
import org.springframework.dao.DataAccessException;\r
\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.description.DescriptionBase;\r
import eu.etaxonomy.cdm.model.description.IndividualsAssociation;\r
import eu.etaxonomy.cdm.model.description.TaxonDescription;\r
import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;\r
import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.query.MatchMode;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
\r
\r
import java.util.List;\r
\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.reference.Reference;\r
import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;\r
import eu.etaxonomy.cdm.persistence.dao.common.ITitledDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
\r
/**\r
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;\r
import eu.etaxonomy.cdm.model.common.RelationshipBase;\r
import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.location.NamedArea;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;\r
import eu.etaxonomy.cdm.persistence.dao.common.ITitledDao;\r
import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.fetch.CdmFetch;\r
import eu.etaxonomy.cdm.persistence.query.MatchMode;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
* See LICENSE.TXT at the top of this package for the full license terms.
*/
-package eu.etaxonomy.cdm.model.common;
+package eu.etaxonomy.cdm.persistence.dto;
import java.io.Serializable;
import java.util.UUID;
import org.apache.log4j.Logger;
+import eu.etaxonomy.cdm.model.common.ICdmBase;
+
/**
* @author n.hoffmann
* @created Aug 14, 2009
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;\r
import eu.etaxonomy.cdm.model.common.Marker;\r
import eu.etaxonomy.cdm.model.common.MarkerType;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.location.NamedArea;\r
import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.persistence.dao.reference.IReferenceDao;\r
import eu.etaxonomy.cdm.persistence.dao.taxon.IClassificationDao;\r
import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.fetch.CdmFetch;\r
import eu.etaxonomy.cdm.persistence.query.GroupByCount;\r
import eu.etaxonomy.cdm.persistence.query.GroupByDate;\r
// $Id$\r
/**\r
* Copyright (C) 2007 EDIT\r
-* European Distributed Institute of Taxonomy \r
+* European Distributed Institute of Taxonomy\r
* http://www.e-taxonomy.eu\r
-* \r
+*\r
* The contents of this file are subject to the Mozilla Public License Version 1.1\r
* See LICENSE.TXT at the top of this package for the full license terms.\r
*/\r
import eu.etaxonomy.cdm.model.agent.Team;\r
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;\r
import eu.etaxonomy.cdm.model.common.CdmBase;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.dao.agent.IAgentDao;\r
import eu.etaxonomy.cdm.persistence.dao.common.ICdmGenericDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;\r
import eu.etaxonomy.cdm.strategy.merge.DefaultMergeStrategy;\r
import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;\r
@Transactional(readOnly = true)\r
public class AgentServiceImpl extends IdentifiableServiceBase<AgentBase,IAgentDao> implements IAgentService {\r
private static final Logger logger = Logger.getLogger(AgentServiceImpl.class);\r
- \r
+\r
@Autowired\r
ICdmGenericDao genericDao;\r
\r
- @Autowired\r
+ @Override\r
+ @Autowired\r
protected void setDao(IAgentDao dao) {\r
assert dao != null;\r
this.dao = dao;\r
}\r
- \r
+\r
/**\r
* Constructor\r
*/\r
public AgentServiceImpl(){\r
if (logger.isDebugEnabled()) { logger.debug("Load AgentService Bean"); }\r
}\r
- \r
+\r
\r
@Override\r
@Transactional(readOnly = false)\r
}\r
super.updateTitleCacheImpl(clazz, stepSize, cacheStrategy, monitor);\r
}\r
- \r
+\r
@Override\r
public List<Institution> searchInstitutionByCode(String code) {\r
return dao.getInstitutionByCode(code);\r
@Override\r
public Pager<InstitutionalMembership> getInstitutionalMemberships(Person person, Integer pageSize, Integer pageNumber) {\r
Integer numberOfResults = dao.countInstitutionalMemberships(person);\r
- \r
+\r
List<InstitutionalMembership> results = new ArrayList<InstitutionalMembership>();\r
if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)\r
- results = dao.getInstitutionalMemberships(person, pageSize, pageNumber); \r
+ results = dao.getInstitutionalMemberships(person, pageSize, pageNumber);\r
}\r
- \r
+\r
return new DefaultPagerImpl<InstitutionalMembership>(pageNumber, numberOfResults, pageSize, results);\r
}\r
\r
@Override\r
public Pager<Person> getMembers(Team team, Integer pageSize, Integer pageNumber) {\r
Integer numberOfResults = dao.countMembers(team);\r
- \r
+\r
List<Person> results = new ArrayList<Person>();\r
if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)\r
- results = dao.getMembers(team, pageSize, pageNumber); \r
+ results = dao.getMembers(team, pageSize, pageNumber);\r
}\r
- \r
+\r
return new DefaultPagerImpl<Person>(pageNumber, numberOfResults, pageSize, results);\r
}\r
\r
@Override\r
public Pager<Address> getAddresses(AgentBase agent, Integer pageSize, Integer pageNumber) {\r
Integer numberOfResults = dao.countAddresses(agent);\r
- \r
+\r
List<Address> results = new ArrayList<Address>();\r
if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)\r
- results = dao.getAddresses(agent, pageSize, pageNumber); \r
+ results = dao.getAddresses(agent, pageSize, pageNumber);\r
}\r
- \r
+\r
return new DefaultPagerImpl<Address>(pageNumber, numberOfResults, pageSize, results);\r
}\r
\r
public List<UuidAndTitleCache<Institution>> getInstitutionUuidAndTitleCache() {\r
return dao.getInstitutionUuidAndTitleCache();\r
}\r
- \r
+\r
@Override\r
public DeleteResult delete(AgentBase base){\r
- \r
+\r
DeleteResult result = this.isDeletable(base, null);\r
- \r
+\r
if (result.isOk()){\r
if (base instanceof Team){\r
Team baseTeam = (Team) base;\r
}\r
}\r
saveOrUpdate(base);\r
- \r
+\r
dao.delete(base);\r
- \r
+\r
}\r
- \r
- return result; \r
+\r
+ return result;\r
}\r
\r
@Override\r
}else{\r
throw new IllegalStateException("Unhandled state of team members collection");\r
}\r
- \r
+\r
return result;\r
}\r
\r
IMergeStrategy strategy = DefaultMergeStrategy.NewInstance(TeamOrPersonBase.class);\r
strategy.setDefaultMergeMode(MergeMode.SECOND);\r
strategy.setDefaultCollectionMergeMode(MergeMode.SECOND);\r
- \r
+\r
if (! genericDao.isMergeable(team, person, strategy)){\r
throw new MergeException("Person can not be transformed into team.");\r
}\r
}\r
return team;\r
}\r
- \r
- \r
+\r
+\r
}\r
import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;
import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
import eu.etaxonomy.cdm.model.common.CdmBase;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.media.Media;
import eu.etaxonomy.cdm.persistence.dao.taxon.IClassificationDao;
import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;
import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonNodeDao;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.OrderHint;
import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;
import eu.etaxonomy.cdm.model.agent.InstitutionalMembership;\r
import eu.etaxonomy.cdm.model.agent.Person;\r
import eu.etaxonomy.cdm.model.agent.Team;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
import eu.etaxonomy.cdm.strategy.merge.MergeException;\r
\r
import eu.etaxonomy.cdm.api.service.config.CreateHierarchyForClassificationConfigurator;
import eu.etaxonomy.cdm.api.service.pager.Pager;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.media.MediaRepresentation;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.taxon.Classification;
import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.OrderHint;
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
import eu.etaxonomy.cdm.model.common.LSID;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.media.Rights;
import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
import eu.etaxonomy.cdm.persistence.query.OrderHint;
import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
import eu.etaxonomy.cdm.api.service.search.SearchResult;\r
import eu.etaxonomy.cdm.model.common.CdmBase;\r
import eu.etaxonomy.cdm.model.common.Language;\r
-import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;\r
import eu.etaxonomy.cdm.model.common.ReferencedEntityBase;\r
import eu.etaxonomy.cdm.model.common.RelationshipBase;\r
-import eu.etaxonomy.cdm.model.common.TermVocabulary;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;\r
import eu.etaxonomy.cdm.model.name.HybridRelationship;\r
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;\r
import eu.etaxonomy.cdm.model.name.NameRelationship;\r
import eu.etaxonomy.cdm.model.name.NameRelationshipType;\r
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;\r
-import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;\r
import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.name.TypeDesignationBase;\r
import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.query.MatchMode;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
import eu.etaxonomy.cdm.strategy.cache.TaggedText;\r
* If name is <code>null</code> this method has no effect.\r
* @param name\r
* @param config\r
- * \r
+ *\r
*/\r
public DeleteResult delete(TaxonNameBase name, NameDeletionConfigurator config);\r
\r
* @return\r
*/\r
public List getNamesByName(String name, CdmBase sessionObject);\r
- \r
+\r
/**\r
* Fuzzy matching for the taxon name elements. The input name is first atomised using the {@link NonViralNameParserImpl}\r
* into its separate parts (genusOrUninomial,infraGenericEpithet,specificEpithet,infraGenericEpithet,authorshipCache).\r
* Each field is then matched separately with the same accuracy parameter.\r
- * \r
+ *\r
* @param name taxon name to fuzzy match\r
* @param accuracy value > 0.0 and < 1.0 which determines the accuracy of the result.\r
* @param languages list of languages to consider when matching (currently not used)\r
* @param highlightFragments\r
- * @param propertyPaths \r
- * @param maxNoOfResults \r
+ * @param propertyPaths\r
+ * @param maxNoOfResults\r
* @return\r
* @throws CorruptIndexException\r
* @throws IOException\r
String name,\r
float accuracy,\r
List<Language> languages,\r
- boolean highlightFragments, \r
+ boolean highlightFragments,\r
List<String> propertyPaths,\r
int maxNoOfResults) throws CorruptIndexException, IOException, ParseException;\r
- \r
+\r
/**\r
- * Fuzzy matching for the taxon name elements using only the lucene index. \r
- * \r
+ * Fuzzy matching for the taxon name elements using only the lucene index.\r
+ *\r
* The input name is first atomised using the {@link NonViralNameParserImpl}\r
* into its separate parts (genusOrUninomial,infraGenericEpithet,specificEpithet,infraGenericEpithet,authorshipCache).\r
* Each field is then matched separately with the same accuracy parameter.\r
- * \r
+ *\r
* @param name taxon name to fuzzy match\r
* @param accuracy value > 0.0 and < 1.0 which determines the accuracy of the result.\r
* @param languages list of languages to consider when matching (currently not used)\r
* @param highlightFragments\r
- * @param maxNoOfResults \r
+ * @param maxNoOfResults\r
* @return\r
* @throws CorruptIndexException\r
* @throws IOException\r
String name,\r
float accuracy,\r
List<Language> languages,\r
- boolean highlightFragments, \r
+ boolean highlightFragments,\r
int maxNoOfResults) throws CorruptIndexException, IOException, ParseException;\r
- \r
+\r
/**\r
- * Fuzzy matching against the name cache using only the lucene index. \r
- * \r
- * \r
+ * Fuzzy matching against the name cache using only the lucene index.\r
+ *\r
+ *\r
* @param name taxon name to fuzzy match\r
* @param accuracy value > 0.0 and < 1.0 which determines the accuracy of the result.\r
* @param languages list of languages to consider when matching (currently not used)\r
* @param highlightFragments\r
- * @param maxNoOfResults \r
+ * @param maxNoOfResults\r
* @return\r
* @throws CorruptIndexException\r
* @throws IOException\r
String name,\r
float accuracy,\r
List<Language> languages,\r
- boolean highlightFragments, \r
+ boolean highlightFragments,\r
int maxNoOfResults) throws CorruptIndexException, IOException, ParseException;\r
- \r
+\r
/**\r
* Exact matching for the taxon name elements using only the lucene index.\r
- * \r
+ *\r
* The input name is first atomised using the {@link NonViralNameParserImpl}\r
* into its separate parts (genusOrUninomial,infraGenericEpithet,specificEpithet,infraGenericEpithet,authorshipCache).\r
* Each field is then matched separately with the same accuracy parameter.\r
- * \r
+ *\r
* @param name taxon name to fuzzy match\r
* @param wildcard boolean flag to indicate whether a wildcard '*' should be added at the end of the query\r
* @param languages list of languages to consider when matching (currently not used)\r
* @param highlightFragments\r
- * @param maxNoOfResults \r
+ * @param maxNoOfResults\r
* @return\r
* @throws CorruptIndexException\r
* @throws IOException\r
* @throws ParseException\r
*/\r
- \r
+\r
public List<DocumentSearchResult> findByNameExactSearch(\r
- String name, \r
+ String name,\r
boolean wildcard,\r
List<Language> languages,\r
- boolean highlightFragments, \r
+ boolean highlightFragments,\r
int maxNoOfResults) throws CorruptIndexException, IOException, ParseException;\r
\r
// TODO: Remove getNamesByName() methods. Use findNamesByTitle() instead.\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.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.description.DescriptionBase;\r
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;\r
import eu.etaxonomy.cdm.model.description.IndividualsAssociation;\r
import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;\r
import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
\r
/**\r
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* European Distributed Institute of Taxonomy
* http://www.e-taxonomy.eu
-*
+*
* The contents of this file are subject to the Mozilla Public License Version 1.1
* See LICENSE.TXT at the top of this package for the full license terms.
*/
import java.util.List;
import eu.etaxonomy.cdm.api.service.pager.Pager;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.OrderHint;
public interface IReferenceService extends IIdentifiableEntityService<Reference> {
-
+
/**
* Returns a Paged List of Reference instances where the default field matches the String queryString (as interpreted by the Lucene QueryParser)
- *
+ *
* @param clazz filter the results by class (or pass null to return all Reference instances)
* @param queryString
* @param pageSize The maximum number of references returned (can be null for all matching references)
* @return a Pager Reference instances
* @see <a href="http://lucene.apache.org/java/2_4_0/queryparsersyntax.html">Apache Lucene - Query Parser Syntax</a>
*/
- public Pager<Reference> search(Class<? extends Reference> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths);
-
+ @Override
+ public Pager<Reference> search(Class<? extends Reference> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths);
+
/**
* Returns a map that holds uuid, titleCache pairs of all references in the current database
- *
- * @return
+ *
+ * @return
* a <code>Map</code> containing uuid and titleCache of references
*/
public List<UuidAndTitleCache<Reference>> getUuidAndTitle();
-
+
/**
* TODO candidate for harmonization: rename to listForPublishing
* @return
*/
public List<Reference> getAllReferencesForPublishing();
-
+
/**
* TODO candidate for harmonization: rename to listNomenclaturalReferences
* @return
/**
* returns
- *
+ *
* <ol>
* <li>all taxa directly covered by this reference</li>
* <li>all taxa covered by the according in references of this reference</li>
* </ol>
- *
+ *
* searches for taxa using the following relations:
* <ul>
* <li>taxon.name.nomenclaturalreference</li>
* <li>taxon.name.descriptions.descriptionElement.sources</li>
* <li>taxon.name.descriptions.descriptionSources</li>
* </ul>
- *
+ *
* @param reference
* @param includeSubordinateReferences TODO
* @param propertyPaths
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.queryParser.ParseException;
-import org.springframework.transaction.annotation.Transactional;
import eu.etaxonomy.cdm.api.service.config.IFindTaxaAndNamesConfigurator;
import eu.etaxonomy.cdm.api.service.config.IncludedTaxonConfiguration;
import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;
import eu.etaxonomy.cdm.model.common.RelationshipBase;
import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.fetch.CdmFetch;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
import eu.etaxonomy.cdm.persistence.query.OrderHint;
public List<Taxon> listAcceptedTaxaFor(UUID synonymUuid, UUID classificationUuid, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints,
List<String> propertyPaths);
-
+
public List<TaxonBase> findTaxaByName(MatchingTaxonConfigurator config);
import java.util.Set;\r
import java.util.UUID;\r
\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.description.DescriptionBase;\r
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;\r
import eu.etaxonomy.cdm.model.description.DescriptiveSystemRole;\r
import eu.etaxonomy.cdm.model.description.Feature;\r
import eu.etaxonomy.cdm.model.description.WorkingSet;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
\r
\r
public interface IWorkingSetService extends IAnnotatableService<WorkingSet> {\r
/**\r
* Returns a Map of descriptions each with the descriptionelements that match the supplied features (or all description elements if no features are supplied)\r
- * \r
+ *\r
* @param workingSet the working set which the descriptions belong to\r
* @param features restrict the returned description elements to those which have features in this set\r
* @param pageSize The maximum number of descriptions returned (can be null for all descriptions that belong to the working set)\r
- * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based, \r
+ * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based,\r
* can be null, equivalent of starting at the beginning of the recordset). Descriptions are sorted by titleCache\r
* @param propertyPaths properties to be initialized (applied to the descriptionElements)\r
* @return\r
\r
public <T extends DescriptionElementBase> Map<UuidAndTitleCache, Map<UUID, Set<T>>> getTaxonFeatureDescriptionElementMap(Class<T> clazz, UUID workingSetUuid, DescriptiveSystemRole role);\r
\r
- \r
- \r
+\r
+\r
}\r
// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* European Distributed Institute of Taxonomy
* http://www.e-taxonomy.eu
-*
+*
* The contents of this file are subject to the Mozilla Public License Version 1.1
* See LICENSE.TXT at the top of this package for the full license terms.
*/
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
import eu.etaxonomy.cdm.model.common.LSID;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.media.Rights;
import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
-import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;
import eu.etaxonomy.cdm.persistence.dao.hibernate.HibernateBeanInitializer;
import eu.etaxonomy.cdm.persistence.dao.initializer.AutoPropertyInitializer;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
import eu.etaxonomy.cdm.persistence.query.OrderHint;
import eu.etaxonomy.cdm.persistence.query.OrderHint.SortOrder;
import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;
import eu.etaxonomy.cdm.strategy.merge.MergeException;
-public abstract class IdentifiableServiceBase<T extends IdentifiableEntity,DAO extends IIdentifiableDao<T>> extends AnnotatableServiceBase<T,DAO>
+public abstract class IdentifiableServiceBase<T extends IdentifiableEntity,DAO extends IIdentifiableDao<T>> extends AnnotatableServiceBase<T,DAO>
implements IIdentifiableEntityService<T>{
-
+
protected static final int UPDATE_TITLE_CACHE_DEFAULT_STEP_SIZE = 1000;
protected static final Logger logger = Logger.getLogger(IdentifiableServiceBase.class);
@Transactional(readOnly = true)
public Pager<Rights> getRights(T t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
Integer numberOfResults = dao.countRights(t);
-
+
List<Rights> results = new ArrayList<Rights>();
if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
- results = dao.getRights(t, pageSize, pageNumber,propertyPaths);
+ results = dao.getRights(t, pageSize, pageNumber,propertyPaths);
}
-
+
return new DefaultPagerImpl<Rights>(pageNumber, numberOfResults, pageSize, results);
}
-
+
@Override
@Transactional(readOnly = true)
public Pager<IdentifiableSource> getSources(T t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
Integer numberOfResults = dao.countSources(t);
-
+
List<IdentifiableSource> results = new ArrayList<IdentifiableSource>();
if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
- results = dao.getSources(t, pageSize, pageNumber,propertyPaths);
+ results = dao.getSources(t, pageSize, pageNumber,propertyPaths);
}
-
+
return new DefaultPagerImpl<IdentifiableSource>(pageNumber, numberOfResults, pageSize, results);
}
-
+
@Transactional(readOnly = false)
@Override
public T replace(T x, T y) {
/**
* FIXME Candidate for harmonization
* Given that this method is strongly typed, and generic, could we not simply expose it as
- * List<T> findByTitle(String title) as it is somewhat less cumbersome. Admittedly, I don't
+ * List<T> findByTitle(String title) as it is somewhat less cumbersome. Admittedly, I don't
* understand what is going on with the configurators etc. so maybe there is a good reason for
- * the design of this method.
+ * the design of this method.
* @param title
* @return
*/
protected List<T> findCdmObjectsByTitle(String title){
return ((IIdentifiableDao)dao).findByTitle(title);
}
-
+
@Transactional(readOnly = true)
protected List<T> findCdmObjectsByTitle(String title, Class<T> clazz){
return ((IIdentifiableDao)dao).findByTitleAndClass(title, clazz);
protected List<T> findCdmObjectsByTitle(String title, CdmBase sessionObject){
return ((IIdentifiableDao)dao).findByTitle(title, sessionObject);
}
-
+
/*
* TODO - Migrated from CommonServiceBase
* (non-Javadoc)
}
return result;
}
-
+
@Transactional(readOnly = true)
@Override
public List<UuidAndTitleCache<T>> getUuidAndTitleCache() {
return dao.getUuidAndTitleCache();
}\r
-
+
@Transactional(readOnly = true)\r
@Override
public Pager<T> findByTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {\r
Integer numberOfResults = dao.countByTitle(clazz, queryString, matchmode, criteria);\r
- \r
+\r
List<T> results = new ArrayList<T>();\r
if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)\r
- results = dao.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); \r
+ results = dao.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);\r
}\r
- \r
+\r
return new DefaultPagerImpl<T>(pageNumber, numberOfResults, pageSize, results);\r
}
-
+
@Transactional(readOnly = true)
@Override
public Pager<T> findByTitle(IIdentifiableEntityServiceConfigurator<T> config){
return findByTitle(config.getClazz(), config.getTitleSearchStringSqlized(), config.getMatchMode(), config.getCriteria(), config.getPageSize(), config.getPageNumber(), config.getOrderHints(), config.getPropertyPaths());
}
-
+
@Transactional(readOnly = true)
@Override
public List<T> listByTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
Integer numberOfResults = dao.countByTitle(clazz, queryString, matchmode, criteria);
-
+
List<T> results = new ArrayList<T>();
if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
- results = dao.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ results = dao.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
return results;
}
-
+
@Transactional(readOnly = true)
@Override
public Pager<T> findTitleCache(Class<? extends T> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, MatchMode matchMode){
long numberOfResults = dao.countTitleCache(clazz, queryString, matchMode);
-
+
List<T> results = new ArrayList<T>();
if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
results = dao.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
}
int r = 0;
r += numberOfResults;
-
+
return new DefaultPagerImpl<T>(pageNumber, r , pageSize, results);
}
@Override
public List<T> listByReferenceTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
Integer numberOfResults = dao.countByReferenceTitle(clazz, queryString, matchmode, criteria);
-
+
List<T> results = new ArrayList<T>();
if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
- results = dao.findByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+ results = dao.findByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
}
return results;
}
-
+
@Transactional(readOnly = true)
@Override
public T find(LSID lsid) {
return dao.find(lsid);
}
-
+
@Transactional(readOnly = true)
@Override
public Pager<T> search(Class<? extends T> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
Integer numberOfResults = dao.count(clazz,queryString);
-
+
List<T> results = new ArrayList<T>();
if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
- results = dao.search(clazz,queryString, pageSize, pageNumber, orderHints, propertyPaths);
+ results = dao.search(clazz,queryString, pageSize, pageNumber, orderHints, propertyPaths);
}
-
+
return new DefaultPagerImpl<T>(pageNumber, numberOfResults, pageSize, results);
}
-
+
@Override
@Transactional(readOnly = false)
public void updateTitleCache() {
updateTitleCache(null, null, null, null);
}
-
- @Transactional(readOnly = false) //TODO check transactional behaviour, e.g. what happens with the session if count is very large
+
+ @Transactional(readOnly = false) //TODO check transactional behaviour, e.g. what happens with the session if count is very large
protected <S extends T > void updateTitleCacheImpl(Class<S> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<T> cacheStrategy, IProgressMonitor monitor) {
if (stepSize == null){
stepSize = UPDATE_TITLE_CACHE_DEFAULT_STEP_SIZE;
if (monitor == null){
monitor = DefaultProgressMonitor.NewInstance();
}
-
+
int count = dao.count(clazz);
monitor.beginTask("update titles", count);
int worked = 0;
// not sure if such strict ordering is necessary here, but for safety reasons I do it
ArrayList<OrderHint> orderHints = new ArrayList<OrderHint>();
orderHints.add( new OrderHint("id", OrderHint.SortOrder.ASCENDING));
-
-
+
+
Map<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>> oldAutoInit = switchOfAutoinitializer();
List<S> list = this.list(clazz, stepSize, i, orderHints, null);
switchOnOldAutoInitializer(oldAutoInit);
-
+
List<T> entitiesToUpdate = new ArrayList<T>();
for (T entity : list){
HibernateProxyHelper.deproxy(entity, clazz);
/**
* Removes all auto initializers from the bean initializer
- *
+ *
* @see #switchOnOldAutoInitializer(Map)
- * @return
+ * @return
*/
protected Map<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>> switchOfAutoinitializer() {
HibernateBeanInitializer initializer = (HibernateBeanInitializer)this.appContext.getBean("defaultBeanInitializer");
private void updateTitleCacheForSingleEntity(
IIdentifiableEntityCacheStrategy<T> cacheStrategy,
List<T> entitiesToUpdate, T entity) {
-
+
assert (entity.isProtectedTitleCache() == false );
-
+
//exclude recursive inreferences
if (entity.isInstanceOf(Reference.class)){
Reference<?> ref = CdmBase.deproxy(entity, Reference.class);
return;
}
}
-
-
+
+
//define the correct cache strategy
IIdentifiableEntityCacheStrategy entityCacheStrategy = cacheStrategy;
if (entityCacheStrategy == null){
entityCacheStrategy = entity.getCacheStrategy();
- //FIXME find out why the wrong cache strategy is loaded here, see #1876
+ //FIXME find out why the wrong cache strategy is loaded here, see #1876
if (entity instanceof Reference){
entityCacheStrategy = ReferenceFactory.newReference(((Reference<?>)entity).getType()).getCacheStrategy();
}
}
entity.setCacheStrategy(entityCacheStrategy);
-
-
+
+
//old titleCache
entity.setProtectedTitleCache(true);
String oldTitleCache = entity.getTitleCache();
entity.setTitleCache(oldTitleCache, false); //before we had entity.setProtectedTitleCache(false) but this deleted the titleCache itself
-
+
//NonViralNames and Reference have more caches //TODO handle in NameService
String oldNameCache = null;
String oldFullTitleCache = null;
String oldAbbrevTitleCache = null;
if (entity instanceof NonViralName ){
-
+
try{
NonViralName<?> nvn = (NonViralName) entity;
if (!nvn.isProtectedNameCache()){
}catch(ClassCastException e){
System.out.println("entity: " + entity.getTitleCache());
}
-
+
}else if (entity instanceof Reference){
Reference<?> ref = (Reference<?>) entity;
if (!ref.isProtectedAbbrevTitleCache()){
newTitleCache = entityCacheStrategy.getTitleCache(nvn);
//System.out.println("titleCache: " +entity.getTitleCache());
}
-
+
if ( oldTitleCache == null || oldTitleCache != null && ! oldTitleCache.equals(newTitleCache) ){
entity.setTitleCache(null, false);
String newCache = entity.getTitleCache();
entitiesToUpdate.add(entity);
}
}
-
-
+
+
}
-
-
+
+
/**
* Needs override if not only the title cache should be set to null to
protected void setOtherCachesNull(T entity) {
return;
}
-
-
+
+
private class DeduplicateState{
String lastTitleCache;
Integer pageSize = 50;
int nPages = 3;
int startPage = 0;
boolean isCompleted = false;
- int result;
+ int result;
}
-
+
@Override
@Transactional(readOnly = false)
public int deduplicate(Class<? extends T> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
DeduplicateState dedupState = new DeduplicateState();
-
+
if (clazz == null){
logger.warn("Deduplication clazz must not be null!");
return 0;
matchStrategy = DefaultMatchStrategy.NewInstance(matchableClass);
}
List<T> nextGroup = new ArrayList<T>();
-
+
int result = 0;
// double countTotal = count(clazz);
-//
-// Number countPagesN = Math.ceil(countTotal/dedupState.pageSize.doubleValue()) ;
+//
+// Number countPagesN = Math.ceil(countTotal/dedupState.pageSize.doubleValue()) ;
// int countPages = countPagesN.intValue();
-//
-
+//
+
List<OrderHint> orderHints = Arrays.asList(new OrderHint[]{new OrderHint("titleCache", SortOrder.ASCENDING)});
-
+
while (! dedupState.isCompleted){
//get x page sizes
List<T> objectList = getPages(clazz, dedupState, orderHints);
int finishedPages = nUnEqualPages / dedupState.pageSize;
dedupState.startPage = finishedPages;
}
-
+
result += handleLastGroup(nextGroup, matchStrategy, mergeStrategy);
return result;
}
dedupState.result += handleLastGroup(nextGroup, matchStrategy, mergeStrategy);
nextGroup = new ArrayList<T>();
nextGroup.add(object);
- nUnEqual++;
+ nUnEqual++;
}
dedupState.lastTitleCache = currentTitleCache;
}
}
T firstObject = group.get(i);
T secondObject = group.get(j);
-
+
try {
if (matchStrategy.invoke((IMatchable)firstObject, (IMatchable)secondObject)){
commonService.merge((IMergable)firstObject, (IMergable)secondObject, mergeStrategy);
}
}
return result;
- }
-
+ }
+
@Transactional(readOnly = true)
@Override
public Integer countByTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria){
Integer numberOfResults = dao.countByTitle(clazz, queryString, matchmode, criteria);
-
+
return numberOfResults;
}
-
+
@Transactional(readOnly = true)
@Override
public Integer countByTitle(IIdentifiableEntityServiceConfigurator<T> config){
return countByTitle(config.getClazz(), config.getTitleSearchStringSqlized(),
config.getMatchMode(), config.getCriteria());
-
+
}
@Override
@Transactional(readOnly = true)
public <S extends T> Pager<FindByIdentifierDTO<S>> findByIdentifier(
- Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode,
+ Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode,
boolean includeEntity, Integer pageSize,
Integer pageNumber, List<String> propertyPaths) {
-
+
Integer numberOfResults = dao.countByIdentifier(clazz, identifier, identifierType, matchmode);
List<Object[]> daoResults = new ArrayList<Object[]>();
if(numberOfResults > 0) { // no point checking again
daoResults = dao.findByIdentifier(clazz, identifier, identifierType,
matchmode, includeEntity, pageSize, pageNumber, propertyPaths);
}
-
+
List<FindByIdentifierDTO<S>> result = new ArrayList<FindByIdentifierDTO<S>>();
for (Object[] daoObj : daoResults){
if (includeEntity){
result.add(new FindByIdentifierDTO<S>((DefinedTerm)daoObj[0], (String)daoObj[1], (S)daoObj[2]));
}else{
- result.add(new FindByIdentifierDTO<S>((DefinedTerm)daoObj[0], (String)daoObj[1], (UUID)daoObj[2], (String)daoObj[3]));
+ result.add(new FindByIdentifierDTO<S>((DefinedTerm)daoObj[0], (String)daoObj[1], (UUID)daoObj[2], (String)daoObj[3]));
}
}
return new DefaultPagerImpl<FindByIdentifierDTO<S>>(pageNumber, numberOfResults, pageSize, result);
import eu.etaxonomy.cdm.model.common.ReferencedEntityBase;\r
import eu.etaxonomy.cdm.model.common.RelationshipBase;\r
import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.description.DescriptionElementSource;\r
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;\r
import eu.etaxonomy.cdm.model.name.HybridRelationship;\r
import eu.etaxonomy.cdm.persistence.dao.name.INomenclaturalStatusDao;\r
import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;\r
import eu.etaxonomy.cdm.persistence.dao.name.ITypeDesignationDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.query.MatchMode;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
import eu.etaxonomy.cdm.strategy.cache.TaggedText;\r
public DeleteResult delete(TaxonNameBase name){\r
NameDeletionConfigurator config = new NameDeletionConfigurator();\r
DeleteResult result = delete(name, config);\r
- \r
- \r
+\r
+\r
return result;\r
- \r
+\r
}\r
\r
/* (non-Javadoc)\r
@Override\r
public DeleteResult delete(TaxonNameBase name, NameDeletionConfigurator config) {\r
DeleteResult result = new DeleteResult();\r
- \r
+\r
if (name == null){\r
result.setAbort();\r
return result;\r
}\r
- \r
+\r
try{\r
result = this.isDeletable(name, config);\r
}catch(Exception e){\r
if (result.isOk()){\r
//remove references to this name\r
removeNameRelationshipsByDeleteConfig(name, config);\r
- \r
+\r
//remove name from homotypical group\r
HomotypicalGroup homotypicalGroup = name.getHomotypicalGroup();\r
if (homotypicalGroup != null){\r
homotypicalGroup.removeTypifiedName(name, false);\r
}\r
- \r
+\r
//all type designation relationships are removed as they belong to the name\r
deleteTypeDesignation(name, null);\r
// //type designations\r
// String message = "Name can't be deleted as it has types. Remove types prior to deletion.";\r
// throw new ReferrencedObjectUndeletableException(message);\r
// }\r
- \r
- \r
+\r
+\r
try{\r
UUID nameUuid = dao.delete(name);\r
- \r
+\r
}catch(Exception e){\r
result.addException(e);\r
result.setError();\r
}\r
return result;\r
- } \r
- \r
- \r
- \r
+ }\r
+\r
+\r
+\r
return result;\r
}\r
\r
List<TaggedText> taggedName = taxonNameBase.getTaggedName();\r
return taggedName;\r
}\r
- \r
+\r
@Override\r
public DeleteResult isDeletable(TaxonNameBase name, DeleteConfiguratorBase config){\r
DeleteResult result = new DeleteResult();\r
result.setError();\r
return result;\r
}\r
- \r
+\r
if (!name.getNameRelations().isEmpty() && !nameConfig.isRemoveAllNameRelationships()){\r
HomotypicalGroup homotypicalGroup = HibernateProxyHelper.deproxy(name.getHomotypicalGroup(), HomotypicalGroup.class);\r
- \r
+\r
if (!nameConfig.isIgnoreIsBasionymFor() && homotypicalGroup.getBasionyms().contains(name)){\r
result.addException(new Exception( "Name can't be deleted as it is a basionym."));\r
result.setAbort();\r
\r
//TODO inline references\r
\r
- \r
+\r
if (!nameConfig.isIgnoreIsReplacedSynonymFor() && name.isReplacedSynonym()){\r
String message = "Name can't be deleted as it is a replaced synonym.";\r
result.addException(new Exception(message));\r
result.setAbort();\r
}\r
return result;\r
- \r
+\r
}\r
\r
@Override\r
public List<HashMap<String,String>> getNameRecords(){\r
- \r
+\r
return dao.getNameRecords();\r
- \r
+\r
}\r
\r
}\r
import eu.etaxonomy.cdm.model.common.DefinedTermBase;\r
import eu.etaxonomy.cdm.model.common.ICdmBase;\r
import eu.etaxonomy.cdm.model.common.Language;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.description.CategoricalData;\r
import eu.etaxonomy.cdm.model.description.DescriptionBase;\r
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;\r
import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao;\r
import eu.etaxonomy.cdm.persistence.dao.initializer.AbstractBeanInitializer;\r
import eu.etaxonomy.cdm.persistence.dao.occurrence.IOccurrenceDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;\r
\r
// $Id$\r
/**\r
* Copyright (C) 2007 EDIT\r
-* European Distributed Institute of Taxonomy \r
+* European Distributed Institute of Taxonomy\r
* http://www.e-taxonomy.eu\r
-* \r
+*\r
* The contents of this file are subject to the Mozilla Public License Version 1.1\r
* See LICENSE.TXT at the top of this package for the full license terms.\r
*/\r
package eu.etaxonomy.cdm.api.service;\r
\r
import java.util.List;\r
-import java.util.Set;\r
-import java.util.UUID;\r
\r
import org.apache.log4j.Logger;\r
-import org.hibernate.ObjectDeletedException;\r
import org.springframework.beans.factory.annotation.Autowired;\r
import org.springframework.stereotype.Service;\r
-import org.springframework.transaction.annotation.Propagation;\r
import org.springframework.transaction.annotation.Transactional;\r
\r
-import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException;\r
import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;\r
-import eu.etaxonomy.cdm.model.common.CdmBase;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
-import eu.etaxonomy.cdm.model.description.PolytomousKey;\r
-import eu.etaxonomy.cdm.model.name.NonViralName;\r
-import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.reference.Reference;\r
import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
import eu.etaxonomy.cdm.persistence.dao.common.ICdmGenericDao;\r
import eu.etaxonomy.cdm.persistence.dao.reference.IReferenceDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;\r
\r
\r
@Service\r
@Transactional(readOnly = true)\r
public class ReferenceServiceImpl extends IdentifiableServiceBase<Reference,IReferenceDao> implements IReferenceService {\r
- \r
+\r
static Logger logger = Logger.getLogger(ReferenceServiceImpl.class);\r
- \r
+\r
@Autowired\r
private ICdmGenericDao genericDao;\r
/**\r
if (logger.isDebugEnabled()) { logger.debug("Load ReferenceService Bean"); }\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy)\r
- */\r
@Override\r
@Transactional(readOnly = false)\r
public void updateTitleCache(Class<? extends Reference> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<Reference> cacheStrategy, IProgressMonitor monitor) {\r
}\r
super.updateTitleCacheImpl(clazz, stepSize, cacheStrategy, monitor);\r
}\r
- \r
+\r
\r
@Override\r
protected void setOtherCachesNull(Reference ref) {\r
}\r
\r
\r
- @Autowired\r
+ @Override\r
+ @Autowired\r
protected void setDao(IReferenceDao dao) {\r
this.dao = dao;\r
}\r
\r
- public List<UuidAndTitleCache<Reference>> getUuidAndTitle() {\r
- \r
+ @Override\r
+ public List<UuidAndTitleCache<Reference>> getUuidAndTitle() {\r
+\r
return dao.getUuidAndTitle();\r
}\r
- \r
- public List<Reference> getAllReferencesForPublishing(){\r
+\r
+ @Override\r
+ public List<Reference> getAllReferencesForPublishing(){\r
return dao.getAllNotNomenclaturalReferencesForPublishing();\r
}\r
\r
- public List<Reference> getAllNomenclaturalReferences() {\r
- \r
+ @Override\r
+ public List<Reference> getAllNomenclaturalReferences() {\r
+\r
return dao.getAllNomenclaturalReferences();\r
}\r
\r
@Override\r
public List<TaxonBase> listCoveredTaxa(Reference reference, boolean includeSubordinateReferences, List<String> propertyPaths) {\r
- \r
+\r
List<TaxonBase> taxonList = dao.listCoveredTaxa(reference, includeSubordinateReferences, null, propertyPaths);\r
- \r
+\r
return taxonList;\r
}\r
- \r
+\r
@Override\r
public DeleteResult delete(Reference reference) {\r
//check whether the reference is used somewhere\r
DeleteResult result = isDeletable(reference, null);\r
- \r
+\r
if (result.isOk()){\r
dao.delete(reference);\r
}\r
- \r
+\r
return result;\r
}\r
}\r
import eu.etaxonomy.cdm.model.common.OriginalSourceType;\r
import eu.etaxonomy.cdm.model.common.RelationshipBase;\r
import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.description.CommonTaxonName;\r
import eu.etaxonomy.cdm.model.description.DescriptionBase;\r
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;\r
import eu.etaxonomy.cdm.persistence.dao.occurrence.IOccurrenceDao;\r
import eu.etaxonomy.cdm.persistence.dao.taxon.IClassificationDao;\r
import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.fetch.CdmFetch;\r
import eu.etaxonomy.cdm.persistence.query.MatchMode;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
return taxonRelTypeVocabulary;\r
}\r
\r
-\r
-\r
- /*\r
- * (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#swapSynonymWithAcceptedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym)\r
- */\r
@Override\r
@Transactional(readOnly = false)\r
public void swapSynonymAndAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon){\r
}\r
\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeSynonymToAcceptedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon)\r
- */\r
-\r
@Override\r
@Transactional(readOnly = false)\r
public Taxon changeSynonymToAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon, boolean deleteSynonym, boolean copyCitationInfo, Reference citation, String microCitation) throws HomotypicalGroupChangeException{\r
return fromTaxon;\r
}\r
\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeHomotypicalGroupOfSynonym(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.name.HomotypicalGroup, eu.etaxonomy.cdm.model.taxon.Taxon, boolean, boolean)\r
- */\r
@Transactional(readOnly = false)\r
@Override\r
public void changeHomotypicalGroupOfSynonym(Synonym synonym, HomotypicalGroup newHomotypicalGroup, Taxon targetTaxon,\r
\r
}\r
\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy)\r
- */\r
@Override\r
@Transactional(readOnly = false)\r
public void updateTitleCache(Class<? extends TaxonBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<TaxonBase> cacheStrategy, IProgressMonitor monitor) {\r
return taxa;\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#getSynonyms(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)\r
- */\r
@Override\r
public Pager<SynonymRelationship> getSynonyms(Taxon taxon, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {\r
Integer numberOfResults = dao.countSynonyms(taxon, type);\r
return new DefaultPagerImpl<SynonymRelationship>(pageNumber, numberOfResults, pageSize, results);\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#getSynonyms(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)\r
- */\r
@Override\r
public Pager<SynonymRelationship> getSynonyms(Synonym synonym, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {\r
Integer numberOfResults = dao.countSynonyms(synonym, type);\r
return new DefaultPagerImpl<SynonymRelationship>(pageNumber, numberOfResults, pageSize, results);\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#getHomotypicSynonymsByHomotypicGroup(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.List)\r
- */\r
@Override\r
public List<List<Synonym>> getSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths){\r
List<List<Synonym>> result = new ArrayList<List<Synonym>>();\r
\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#getHomotypicSynonymsByHomotypicGroup(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.List)\r
- */\r
@Override\r
public List<Synonym> getHomotypicSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths){\r
Taxon t = (Taxon)dao.load(taxon.getUuid(), propertyPaths);\r
return t.getHomotypicSynonymsByHomotypicGroup();\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#getHeterotypicSynonymyGroups(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.List)\r
- */\r
@Override\r
public List<List<Synonym>> getHeterotypicSynonymyGroups(Taxon taxon, List<String> propertyPaths){\r
Taxon t = (Taxon)dao.load(taxon.getUuid(), propertyPaths);\r
return results;\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaAndNames(eu.etaxonomy.cdm.api.service.config.ITaxonServiceConfigurator)\r
- */\r
@Override\r
public Pager<IdentifiableEntity> findTaxaAndNames(IFindTaxaAndNamesConfigurator configurator) {\r
\r
return dao.getUuidAndTitleCache();\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllMedia(eu.etaxonomy.cdm.model.taxon.Taxon, int, int, int, java.lang.String[])\r
- */\r
@Override\r
public List<MediaRepresentation> getAllMedia(Taxon taxon, int size, int height, int widthOrDuration, String[] mimeTypes){\r
List<MediaRepresentation> medRep = new ArrayList<MediaRepresentation>();\r
return medRep;\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#listTaxonDescriptionMedia(eu.etaxonomy.cdm.model.taxon.Taxon, boolean)\r
- */\r
@Override\r
public List<Media> listTaxonDescriptionMedia(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships, boolean limitToGalleries, List<String> propertyPath){\r
return listMedia(taxon, includeRelationships, limitToGalleries, true, false, false, propertyPath);\r
}\r
\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#listMedia(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, boolean, java.util.List)\r
- */\r
@Override\r
public List<Media> listMedia(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships,\r
Boolean limitToGalleries, Boolean includeTaxonDescriptions, Boolean includeOccurrences,\r
return taxonMedia;\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaByID(java.util.Set)\r
- */\r
@Override\r
public List<TaxonBase> findTaxaByID(Set<Integer> listOfIDs) {\r
return this.dao.listByIds(listOfIDs, null, null, null, null);\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxonByUuid(UUID uuid, List<String> propertyPaths)\r
- */\r
@Override\r
public TaxonBase findTaxonByUuid(UUID uuid, List<String> propertyPaths){\r
return this.dao.findByUuid(uuid, null ,propertyPaths);\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#countAllRelationships()\r
- */\r
@Override\r
public int countAllRelationships() {\r
return this.dao.countAllRelationships();\r
}\r
\r
-\r
-\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#findIdenticalTaxonNames(java.util.List)\r
- */\r
@Override\r
public List<TaxonNameBase> findIdenticalTaxonNames(List<String> propertyPath) {\r
return this.dao.findIdenticalTaxonNames(propertyPath);\r
}\r
\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator)\r
- */\r
@Override\r
public DeleteResult deleteTaxon(Taxon taxon, TaxonDeletionConfigurator config, Classification classification) {\r
\r
return result;\r
}\r
\r
-\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteSynonym(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon, boolean, boolean)\r
- */\r
@Transactional(readOnly = false)\r
@Override\r
public DeleteResult deleteSynonym(Synonym synonym, SynonymDeletionConfigurator config) {\r
\r
}\r
\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteSynonym(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon, boolean, boolean)\r
- */\r
@Transactional(readOnly = false)\r
@Override\r
public DeleteResult deleteSynonym(Synonym synonym, Taxon taxon, SynonymDeletionConfigurator config) {\r
\r
}\r
\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#findIdenticalTaxonNameIds(java.util.List)\r
- */\r
@Override\r
public List<TaxonNameBase> findIdenticalTaxonNameIds(List<String> propertyPath) {\r
\r
return this.dao.findIdenticalNamesNew(propertyPath);\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#getPhylumName(eu.etaxonomy.cdm.model.name.TaxonNameBase)\r
- */\r
@Override\r
public String getPhylumName(TaxonNameBase name){\r
return this.dao.getPhylumName(name);\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteSynonymRelationships(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon)\r
- */\r
@Override\r
public long deleteSynonymRelationships(Synonym syn, Taxon taxon) {\r
return dao.deleteSynonymRelationships(syn, taxon);\r
}\r
\r
-/* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteSynonymRelationships(eu.etaxonomy.cdm.model.taxon.Synonym)\r
- */\r
@Override\r
public long deleteSynonymRelationships(Synonym syn) {\r
return dao.deleteSynonymRelationships(syn, null);\r
}\r
\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#listSynonymRelationships(eu.etaxonomy.cdm.model.taxon.TaxonBase, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List, eu.etaxonomy.cdm.model.common.RelationshipBase.Direction)\r
- */\r
@Override\r
public List<SynonymRelationship> listSynonymRelationships(\r
TaxonBase taxonBase, SynonymRelationshipType type, Integer pageSize, Integer pageNumber,\r
return results;\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#findBestMatchingTaxon(java.lang.String)\r
- */\r
@Override\r
public Taxon findBestMatchingTaxon(String taxonName) {\r
MatchingTaxonConfigurator config = MatchingTaxonConfigurator.NewInstance();\r
return findBestMatchingTaxon(config);\r
}\r
\r
-\r
-\r
@Override\r
public Taxon findBestMatchingTaxon(MatchingTaxonConfigurator config) {\r
\r
return configSecUuid.equals(taxonSecUuid);\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#findBestMatchingSynonym(java.lang.String)\r
- */\r
@Override\r
public Synonym findBestMatchingSynonym(String taxonName) {\r
List<TaxonBase> synonymList = dao.findByNameTitleCache(false, true, taxonName, null, MatchMode.EXACT, null, 0, null, null);\r
return null;\r
}\r
\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#moveSynonymToAnotherTaxon(eu.etaxonomy.cdm.model.taxon.SynonymRelationship, eu.etaxonomy.cdm.model.taxon.Taxon, boolean, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String, boolean)\r
- */\r
@Override\r
public SynonymRelationship moveSynonymToAnotherTaxon(SynonymRelationship oldSynonymRelation, Taxon newTaxon, boolean moveHomotypicGroup,\r
SynonymRelationshipType newSynonymRelationshipType, Reference reference, String referenceDetail, boolean keepReference) throws HomotypicalGroupChangeException {\r
return result;\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#getUuidAndTitleCacheTaxon()\r
- */\r
@Override\r
public List<UuidAndTitleCache<TaxonBase>> getUuidAndTitleCacheTaxon() {\r
return dao.getUuidAndTitleCacheTaxon();\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#getUuidAndTitleCacheSynonym()\r
- */\r
@Override\r
public List<UuidAndTitleCache<TaxonBase>> getUuidAndTitleCacheSynonym() {\r
return dao.getUuidAndTitleCacheSynonym();\r
}\r
\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#findByFullText(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.model.taxon.Classification, java.util.List, boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)\r
- */\r
@Override\r
public Pager<SearchResult<TaxonBase>> findByFullText(\r
Class<? extends TaxonBase> clazz, String queryString,\r
return luceneSearch;\r
}\r
\r
-\r
-\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaAndNamesByFullText(java.util.EnumSet, java.lang.String, eu.etaxonomy.cdm.model.taxon.Classification, java.util.Set, java.util.List, boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.Map)\r
- */\r
@Override\r
public Pager<SearchResult<TaxonBase>> findTaxaAndNamesByFullText(\r
EnumSet<TaxaAndNamesSearchMode> searchModes, String queryString, Classification classification,\r
return luceneSearch;\r
}\r
\r
-\r
-\r
- /* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#findByDescriptionElementFullText(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.model.taxon.Classification, java.util.List, java.util.List, boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)\r
- */\r
@Override\r
public Pager<SearchResult<TaxonBase>> findByDescriptionElementFullText(\r
Class<? extends DescriptionElementBase> clazz, String queryString,\r
return synonymRelationship.getSynonym();\r
\r
}\r
+\r
@Override\r
public DeleteResult isDeletable(TaxonBase taxonBase, DeleteConfiguratorBase config){\r
DeleteResult result = new DeleteResult();\r
\r
return result;\r
}\r
+\r
private DeleteResult isDeletableForTaxon(Set<CdmBase> references, TaxonDeletionConfigurator config){\r
String message = null;\r
DeleteResult result = new DeleteResult();\r
import org.springframework.stereotype.Service;\r
import org.springframework.transaction.annotation.Transactional;\r
\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.description.DescriptionBase;\r
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;\r
import eu.etaxonomy.cdm.model.description.DescriptiveSystemRole;\r
import eu.etaxonomy.cdm.model.description.Feature;\r
import eu.etaxonomy.cdm.model.description.WorkingSet;\r
import eu.etaxonomy.cdm.persistence.dao.description.IWorkingSetDao;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
\r
@Service\r
@Transactional(readOnly = false)\r
import org.springframework.transaction.annotation.Transactional;
import eu.etaxonomy.cdm.api.service.AnnotatableServiceBase;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.molecular.Amplification;
import eu.etaxonomy.cdm.persistence.dao.molecular.IAmplificationDao;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
/**
* @author pplitzner
import java.util.UUID;
import eu.etaxonomy.cdm.api.service.IAnnotatableService;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.molecular.Amplification;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
/**
* @author pplitzner
* @return a list of {@link UuidAndTitleCache}
*/
public List<UuidAndTitleCache<Amplification>> getAmplificationUuidAndLabelCache();
-
}
import java.util.UUID;
import eu.etaxonomy.cdm.api.service.IAnnotatableService;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.molecular.Primer;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
/**
* @author pplitzner
* @return a list of {@link UuidAndTitleCache}
*/
public List<UuidAndTitleCache<Primer>> getPrimerUuidAndTitleCache();
-
}
import eu.etaxonomy.cdm.api.service.AnnotatableServiceBase;
import eu.etaxonomy.cdm.api.service.PreferenceServiceImpl;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.molecular.Primer;
import eu.etaxonomy.cdm.persistence.dao.molecular.IPrimerDao;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
/**
* @author pplitzner
@Service
@Transactional(readOnly = true)
public class PrimerServiceImpl extends AnnotatableServiceBase<Primer, IPrimerDao> implements IPrimerService{
+ @SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(PreferenceServiceImpl.class);
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.IPrimerService#getPrimerUuidAndTitleCache()
- */
@Override
public List<UuidAndTitleCache<Primer>> getPrimerUuidAndTitleCache() {
return dao.getPrimerUuidAndTitleCache();
}
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.api.service.ServiceBase#setDao(eu.etaxonomy.cdm.persistence.dao.common.ICdmEntityDao)
- */
@Override
@Autowired
protected void setDao(IPrimerDao dao) {
this.dao = dao;
}
-}
+}
\ No newline at end of file
import eu.etaxonomy.cdm.model.common.DefinedTermBase;\r
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;\r
import eu.etaxonomy.cdm.model.common.Language;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.model.description.CategoricalData;\r
import eu.etaxonomy.cdm.model.description.CommonTaxonName;\r
import eu.etaxonomy.cdm.model.description.DescriptionBase;\r
import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;\r
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
import eu.etaxonomy.cdm.persistence.query.MatchMode;\r
import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;\r
import org.junit.Test;
import org.unitils.spring.annotation.SpringBeanByType;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.molecular.Primer;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
/**
import eu.etaxonomy.cdm.database.DbSchemaValidation;
import eu.etaxonomy.cdm.model.agent.Person;
import eu.etaxonomy.cdm.model.agent.Team;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
-import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
/**
* <h2>NOTE</h2>
BGBM BDI Projects / cdmlib.git / commitdiff