import org.joda.time.DateTime;
import eu.etaxonomy.cdm.api.service.exception.RegistrationValidationException;
+import eu.etaxonomy.cdm.api.service.name.TypeDesignationDTO;
+import eu.etaxonomy.cdm.api.service.name.TypeDesignationSetFormatter;
import eu.etaxonomy.cdm.api.service.name.TypeDesignationSetManager;
-import eu.etaxonomy.cdm.api.service.name.TypeDesignationSetManager.TypeDesignationWorkingSet;
+import eu.etaxonomy.cdm.api.service.name.TypeDesignationWorkingSet;
+import eu.etaxonomy.cdm.format.reference.NomenclaturalSourceFormatter;
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
+import eu.etaxonomy.cdm.model.common.VersionableEntity;
import eu.etaxonomy.cdm.model.name.NameTypeDesignation;
import eu.etaxonomy.cdm.model.name.Registration;
import eu.etaxonomy.cdm.model.name.RegistrationStatus;
import eu.etaxonomy.cdm.model.name.TaxonName;
import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;
+import eu.etaxonomy.cdm.model.reference.NamedSourceBase;
import eu.etaxonomy.cdm.model.reference.Reference;
+import eu.etaxonomy.cdm.model.reference.ReferenceType;
import eu.etaxonomy.cdm.ref.EntityReference;
import eu.etaxonomy.cdm.ref.TypedEntityReference;
import eu.etaxonomy.cdm.strategy.cache.TagEnum;
+import eu.etaxonomy.cdm.strategy.cache.TaggedCacheHelper;
import eu.etaxonomy.cdm.strategy.cache.TaggedText;
-public class RegistrationDTO{
+public class RegistrationDTO {
private static final Logger logger = Logger.getLogger(RegistrationDTO.class);
private List<TaggedText> summaryTaggedText;
+ private String nomenclaturalCitationString;
+
+ private String bibliographicCitationString;
+
+ private String bibliographicInRefCitationString;
/**
* @param reg
- * @param typifiedName should be provided in for Registrations for TypeDesignations
+ * @param typifiedName should be provided for registrations for TypeDesignations
* @throws RegistrationValidationException
*/
public RegistrationDTO(Registration reg) {
submitterUserName = reg.getSubmitter().getUsername();
}
- if(hasName(reg)){
- citation = reg.getName().getNomenclaturalReference();
- citationDetail = reg.getName().getNomenclaturalMicroReference();
- name = new EntityReference(reg.getName().getUuid(), reg.getName().getTitleCache());
- }
- if(hasTypifications(reg)){
- if(!reg.getTypeDesignations().isEmpty()){
- for(TypeDesignationBase td : reg.getTypeDesignations()){
- if(citation == null) {
- citation = td.getCitation();
- citationDetail = td.getCitationMicroReference();
- }
- }
- }
+ if(hasName(reg)){
+ name = new EntityReference(reg.getName().getUuid(), reg.getName().getTitleCache());
+ }
+ NamedSourceBase publishedUnit = findPublishedUnit(reg);
+ if(publishedUnit != null) {
+ citation = publishedUnit.getCitation();
+ citationDetail = publishedUnit.getCitationMicroReference();
}
+
switch(registrationType) {
case EMPTY:
summary = "BLANK REGISTRATION";
default:
try {
typeDesignationManager = new TypeDesignationSetManager(reg.getTypeDesignations());
- summary = typeDesignationManager.print();
- summaryTaggedText = typeDesignationManager.toTaggedText();
+ summaryTaggedText = new TypeDesignationSetFormatter(false, true, true).toTaggedText(typeDesignationManager);
+ summary = TaggedCacheHelper.createString(summaryTaggedText);
} catch (RegistrationValidationException e) {
validationProblems.add("Validation errors: " + e.getMessage());
}
break;
}
- // trigger initialization of the reference
- getNomenclaturalCitationString();
-
+ makeBibliographicCitationStrings();
+ makeNomenclaturalCitationString();
}
/**
citation = publication;
// create a TypeDesignationSetManager with only a reference to the typifiedName for validation
typeDesignationManager = new TypeDesignationSetManager(typifiedName);
+ makeBibliographicCitationStrings();
+ makeNomenclaturalCitationString();
}
- /**
- * @param reg
- * @return
- */
- private boolean hasTypifications(Registration reg) {
+ public static NamedSourceBase findPublishedUnit(Registration reg) {
+ NamedSourceBase publishedUnit = null;
+ if(hasName(reg)){
+ publishedUnit = reg.getName().getNomenclaturalSource();
+ } else if(hasTypifications(reg)){
+ if(!reg.getTypeDesignations().isEmpty()){
+ for(TypeDesignationBase<?> td : reg.getTypeDesignations()){
+ if(td.getDesignationSource() != null) {
+ publishedUnit = td.getDesignationSource();
+ }
+ }
+ }
+ }
+ return publishedUnit;
+ }
+
+ private static boolean hasTypifications(Registration reg) {
return reg.getTypeDesignations() != null && reg.getTypeDesignations().size() > 0;
}
- /**
- * @param reg
- * @return
- */
- private boolean hasName(Registration reg) {
+ private static boolean hasName(Registration reg) {
return reg.getName() != null;
}
-
/**
* Provides access to the Registration entity this DTO has been build from.
* This method is purposely not a getter to hide the original Registration
return reg;
}
-
- /**
- * @return the summary
- */
public String getSummary() {
return summary;
}
- /**
- * @return the summary
- */
public List<TaggedText> getSummaryTaggedText() {
return summaryTaggedText;
}
return submitterUserName;
}
- /**
- * @return the registrationType
- */
public RegistrationType getRegistrationType() {
return registrationType;
}
- /**
- * @return the status
- */
public RegistrationStatus getStatus() {
return reg.getStatus();
}
- /**
- * @return the identifier
- */
public String getIdentifier() {
return reg.getIdentifier();
}
-
public UUID getUuid() {
return reg.getUuid();
}
- /**
- * @return the specificIdentifier
- */
public String getSpecificIdentifier() {
return reg.getSpecificIdentifier();
}
- /**
- * @return the registrationDate
- */
public DateTime getRegistrationDate() {
return reg.getRegistrationDate();
}
- /**
- * @return the registrationDate
- */
+ public String getInstitutionTitleCache(){
+ return reg.getInstitution() != null ? reg.getInstitution().getName() : null;
+ }
+
public VerbatimTimePeriod getDatePublished() {
return citation == null ? null : citation.getDatePublished();
}
- /**
- * @return the created
- */
public DateTime getCreated() {
return reg.getCreated();
}
} else {
throw new Exception("Can not set the citation on a non emtpy RegistrationDTO");
}
+ makeBibliographicCitationStrings();
+ makeNomenclaturalCitationString();
}
-
public UUID getCitationUuid() {
return citation == null ? null : citation.getUuid();
}
public EntityReference getTypifiedNameRef() {
- return typeDesignationManager != null ? typeDesignationManager.getTypifiedNameRef() : null;
+ return typeDesignationManager != null ? typeDesignationManager.getTypifiedNameAsEntityRef() : null;
}
- public TaxonName getTypifiedName() {
+ public TaxonName typifiedName() {
return typeDesignationManager != null ? typeDesignationManager.getTypifiedName() : null;
}
return name;
}
- public LinkedHashMap<TypedEntityReference, TypeDesignationWorkingSet> getOrderdTypeDesignationWorkingSets() {
- return typeDesignationManager != null ? typeDesignationManager.getOrderdTypeDesignationWorkingSets() : null;
+ public LinkedHashMap<TypedEntityReference<? extends VersionableEntity>, TypeDesignationWorkingSet> getOrderedTypeDesignationWorkingSets() {
+ return typeDesignationManager != null ? typeDesignationManager.getOrderedTypeDesignationWorkingSets() : null;
}
- /**
- * @param baseEntityReference
- */
public TypeDesignationWorkingSet getTypeDesignationWorkingSet(TypedEntityReference baseEntityReference) {
- return typeDesignationManager != null ? typeDesignationManager.getOrderdTypeDesignationWorkingSets().get(baseEntityReference) : null;
-
+ return typeDesignationManager != null ? typeDesignationManager.getOrderedTypeDesignationWorkingSets().get(baseEntityReference) : null;
}
- /**
- * @param baseEntityReference
- */
public Set<TypeDesignationBase> getTypeDesignationsInWorkingSet(TypedEntityReference baseEntityReference) {
Set<TypeDesignationBase> typeDesignations = new HashSet<>();
TypeDesignationWorkingSet workingSet = getTypeDesignationWorkingSet(baseEntityReference);
- for(EntityReference ref : workingSet.getTypeDesignations()){
+ for(TypeDesignationDTO ref : workingSet.getTypeDesignations()){
typeDesignations.add(findTypeDesignation(ref));
}
return typeDesignations;
public NameTypeDesignation getNameTypeDesignation(TypedEntityReference baseEntityReference) {
Set<TypeDesignationBase> typeDesignations = getTypeDesignationsInWorkingSet(baseEntityReference);
if(typeDesignations.size() == 1){
- TypeDesignationBase item = typeDesignations.iterator().next();
+ TypeDesignationBase<?> item = typeDesignations.iterator().next();
return (NameTypeDesignation)item ;
}
if(typeDesignations.size() == 0){
return null;
}
- /**
- * @param ref
- * @return
- */
- private TypeDesignationBase findTypeDesignation(EntityReference ref) {
- return typeDesignationManager != null ? typeDesignationManager.findTypeDesignation(ref) : null;
+ private TypeDesignationBase<?> findTypeDesignation(TypeDesignationDTO ref) {
+ return typeDesignationManager != null ? typeDesignationManager.findTypeDesignation(ref.getUuid()) : null;
}
- public Collection<TypeDesignationBase> typeDesignations() {
+ public Collection<TypeDesignationBase<?>> typeDesignations() {
return typeDesignationManager != null ? typeDesignationManager.getTypeDesignations() : null;
}
- /**
- * @return the citationString
- */
- public String getNomenclaturalCitationString() {
+ private void makeNomenclaturalCitationString() {
if(citation == null){
- return null;
- }
- if(INomenclaturalReference.class.isAssignableFrom(citation.getClass())){
- return ((INomenclaturalReference)citation).getNomenclaturalCitation(citationDetail);
+ nomenclaturalCitationString = null;
} else {
- logger.error("The citation is not a NomenclaturalReference");
- return citation.generateTitle();
+ if(INomenclaturalReference.class.isAssignableFrom(citation.getClass())){
+ nomenclaturalCitationString = NomenclaturalSourceFormatter.INSTANCE().format(citation, citationDetail);
+ } else {
+ logger.error("The citation is not a NomenclaturalReference");
+ nomenclaturalCitationString = citation.generateTitle();
+ }
}
}
- /**
- * @return the citationString
- */
- public String getBibliographicCitationString() {
+ private void makeBibliographicCitationStrings() {
if(citation == null){
- return null;
+ bibliographicCitationString = null;
} else {
+ Reference bibliographicCitation;
+ String bibliographicCitationDetail = citationDetail;
+ if((citation.getType() == ReferenceType.Section || citation.getType() == ReferenceType.BookSection) && citation.getInReference() != null){
+ bibliographicCitation = citation.getInReference();
+ bibliographicCitationDetail = null; // can possibly be known once https://dev.e-taxonomy.eu/redmine/issues/6623 is solved
+ } else {
+ bibliographicCitation = citation;
+ }
+ if(StringUtils.isNotEmpty(bibliographicCitationDetail)){
+ // TODO see https://dev.e-taxonomy.eu/redmine/issues/6623
+ bibliographicInRefCitationString = bibliographicCitation.generateTitle().replaceAll("\\.$", "") + (StringUtils.isNotEmpty(bibliographicCitationDetail) ? ": " + bibliographicCitationDetail : "");
+ } else {
+ bibliographicInRefCitationString = bibliographicCitation.generateTitle();
+ }
if(StringUtils.isNotEmpty(citationDetail)){
// TODO see https://dev.e-taxonomy.eu/redmine/issues/6623
- return citation.generateTitle().replaceAll("\\.$", "") + (StringUtils.isNotEmpty(citationDetail) ? ": " + citationDetail : "");
+ bibliographicCitationString = citation.generateTitle().replaceAll("\\.$", "") + (StringUtils.isNotEmpty(citationDetail) ? ": " + citationDetail : "");
} else {
- return citation.generateTitle();
-
+ bibliographicCitationString = citation.generateTitle();
}
-
}
}
+ /**
+ * The nomenclatural citation is always the nomenclaturalCitation of the reference which is directly
+ * associated with the registration.
+ * <p>
+ * <b>Note:</b>Compare with {@link #getBibliographicCitationString()}
+ *
+ * @return the nomenclaturalCitationString
+ */
+ public String getNomenclaturalCitationString() {
+ return nomenclaturalCitationString;
+ }
+
+ /**
+ * The bibliographic in-reference citation is either taken from the reference which is directly
+ * associated with the registration. In case this reference is a {@link eu.etaxonomy.cdm.model.reference.ReferenceType#Section} or
+ * {@link eu.etaxonomy.cdm.model.reference.ReferenceType#BookSection} the inReference will be taken instead.
+ * <p>
+ * <b>Note:</b>Compare with {@link #getBibliographicCitationString()}
+ *
+ * @return the bibliographicInRefCitationString
+ */
+ public String getBibliographicInRefCitationString() {
+ return bibliographicInRefCitationString;
+ }
+
+ /**
+ * The bibliographic citation is either reference which is directly
+ * associated with the registration.
+ * <p>
+ * <b>Note:</b>Compare with {@link #getBibliographicInRefCitationString()}
+ *
+ * @return the bibliographicCitationString
+ */
+ public String getBibliographicCitationString() {
+ return bibliographicCitationString;
+ }
+
public boolean isBlocked() {
return reg.getBlockedBy() != null && !reg.getBlockedBy().isEmpty();
}
return blockedBy;
}
- /**
- * @return
- */
public List<String> getValidationProblems() {
return validationProblems;
}
- /**
- * @return
- */
public boolean isPersisted() {
return reg.isPersited();
}
-
}
\ No newline at end of file
BGBM BDI Projects / cdmlib.git / blobdiff