cdmlib-model/pom.xml -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/aspectj/PropertyChangeAspect.aj -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/datagenerator/TaxonGenerator.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/jaxb/CdmNamespacePrefixMapper.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/jaxb/DateTimeAdapter.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/jaxb/FormattedText.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/jaxb/FormattedTextAdapter.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/jaxb/LSIDAdapter.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/jaxb/MultilanguageTextAdapter.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/jaxb/MultilanguageTextElement.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/jaxb/PartialAdapter.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/jaxb/TDWGNamespacePrefixMapper.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/jaxb/UUIDAdapter.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/agent/Address.java -text
-cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/agent/Agent.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/agent/AgentBase.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/agent/Contact.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/agent/INomenclaturalAuthor.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/agent/Institution.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/agent/Person.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/agent/Team.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/agent/TeamOrPersonBase.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/agent/package-info.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/agent/package.html -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/AnnotatableEntity.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/Annotation.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/IEvent.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/IIdentifiableEntity.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/ILoadableTerm.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/IMultiLanguageText.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/IParsable.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/IReferencedEntity.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/IRelated.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/ISourceable.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/IdentifiableEntity.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/Keyword.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/LSID.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/LSIDAuthority.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/LSIDWSDLLocator.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/Language.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/LanguageString.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/LanguageStringBase.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/OrderedTermVocabulary.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/OriginalSource.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/PartialUserType.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/PersistentMultiLanguageText.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/PersistentMultiLanguageTextType.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/ReferencedEntityBase.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/RelationshipBase.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/RelationshipTermBase.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/UUIDUserType.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/VersionableEntity.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/WSDLDefinitionUserType.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/WrongTermTypeException.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/init/ITermInitializer.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/init/ITermLoader.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/init/IVocabularyStore.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/init/TermLoader.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/init/TermNotFoundException.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/package-info.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/description/TaxonNameDescription.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/description/TextData.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/description/TextFormat.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/description/package-info.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/description/package.html -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/location/Continent.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/location/NamedArea.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/location/ReferenceSystem.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/location/TdwgArea.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/location/WaterbodyOrCountry.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/location/package-info.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/location/package.html -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/media/AudioFile.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/media/IMediaDocumented.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/media/ReferencedMedia.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/media/Rights.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/media/RightsTerm.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/media/package-info.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/molecular/DnaSample.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/molecular/GenBankAccession.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/molecular/Locus.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/molecular/PhylogeneticTree.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/molecular/Sequence.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/molecular/package-info.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/molecular/package.html -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/BacterialName.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/BotanicalName.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/TypeDesignationStatus.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/ViralName.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/ZoologicalName.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/package-info.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/package.html -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/occurrence/Collection.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/occurrence/DerivationEvent.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/occurrence/PreservationMethod.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/occurrence/Specimen.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/occurrence/SpecimenOrObservationBase.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/occurrence/package-info.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/occurrence/package.html -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/overview.html -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/reference/Article.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/reference/StrictReferenceBase.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/reference/Thesis.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/reference/WebPage.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/reference/package-info.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/reference/package.html -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/Synonym.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/SynonymRelationship.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/TaxonComparator.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/TaxonRelationship.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/TaxonRelationshipType.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/package-info.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/package.html -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/view/AuditEvent.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/view/AuditEventRecord.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/view/AuditEventRecordImpl.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/view/View.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/view/context/AuditEventContext.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/view/context/AuditEventContextHolder.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/view/context/AuditEventContextHolderStrategy.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/view/context/AuditEventContextImpl.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/view/context/GlobalAuditEventContextHolderStrategy.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/view/context/InheritableThreadLocalAuditEventContextHolderStrategy.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/view/context/ThreadLocalAuditEventContextHolderStrategy.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/strategy/IStrategy.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/strategy/StrategyBase.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/strategy/cache/agent/INomenclaturalAuthorCacheStrategy.java -text
cdmlib-model/src/test/java/eu/etaxonomy/cdm/test/suite/CdmTestSuite.java -text
cdmlib-model/src/test/java/eu/etaxonomy/cdm/test/unit/CdmUnitTestBase.java -text
cdmlib-model/src/test/java/eu/etaxonomy/cdm/test/unit/EntityTestBase.java -text
+cdmlib-model/src/test/resources/log4j.properties -text
cdmlib-persistence/LICENSE.TXT -text
cdmlib-persistence/README.TXT -text
cdmlib-persistence/pom.xml -text
<groupId>org.hibernate</groupId>
<artifactId>hibernate-annotations</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.hibernate</groupId>
+ <artifactId>hibernate-envers</artifactId>
+ </dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-search</artifactId>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-core</artifactId>
</dependency>
-
+ <dependency>
+ <groupId>com.ibm.lsid</groupId>
+ <artifactId>lsid-client</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>wsdl4j</groupId>
+ <artifactId>wsdl4j</artifactId>
+ </dependency>
<!-- joda-time perhaps needed in future for JAXB binding -->
<!--
<dependency>
--- /dev/null
+package eu.etaxonomy.cdm.jaxb;\r
+\r
+import com.sun.xml.bind.marshaller.NamespacePrefixMapper;\r
+\r
+public class CdmNamespacePrefixMapper extends NamespacePrefixMapper {\r
+\r
+ private static final String CDM_PREFIX = "";\r
+ private static final String AGENT_PREFIX = "agent";\r
+ private static final String COMMON_PREFIX = "common";\r
+ private static final String DESCRIPTION_PREFIX = "description";\r
+ private static final String LOCATION_PREFIX = "location";\r
+ private static final String MEDIA_PREFIX = "media";\r
+ private static final String MOLECULAR_PREFIX = "molecular";\r
+ private static final String NAME_PREFIX = "name";\r
+ private static final String OCCURRENCE_PREFIX = "occurrence";\r
+ private static final String REFERENCE_PREFIX = "reference";\r
+ private static final String TAXON_PREFIX = "taxon";\r
+ \r
+ public static final String CDM_NAMESPACE = "http://etaxonomy.eu/cdm/model/1.0";\r
+ public static final String AGENT_NAMESPACE = "http://etaxonomy.eu/cdm/model/agent/1.0";\r
+ public static final String COMMON_NAMESPACE = "http://etaxonomy.eu/cdm/model/common/1.0";\r
+ public static final String DESCRIPTION_NAMESPACE = "http://etaxonomy.eu/cdm/model/description/1.0";\r
+ public static final String LOCATION_NAMESPACE = "http://etaxonomy.eu/cdm/model/location/1.0";\r
+ public static final String MEDIA_NAMESPACE = "http://etaxonomy.eu/cdm/model/media/1.0";\r
+ public static final String MOLECULAR_NAMESPACE = "http://etaxonomy.eu/cdm/model/molecular/1.0";\r
+ public static final String NAME_NAMESPACE = "http://etaxonomy.eu/cdm/model/name/1.0";\r
+ public static final String OCCURRENCE_NAMESPACE = "http://etaxonomy.eu/cdm/model/occurrence/1.0";\r
+ public static final String REFERENCE_NAMESPACE = "http://etaxonomy.eu/cdm/model/reference/1.0";\r
+ public static final String TAXON_NAMESPACE = "http://etaxonomy.eu/cdm/model/taxon/1.0";\r
+ \r
+ public String getPreferredPrefix(String namespaceURI, String suggestion, boolean requirePrefix) {\r
+ String result = suggestion;\r
+ \r
+ /**\r
+ * Returning empty namespace prefix works if a SAXResult is used, but not\r
+ * a DOMResult - see http://forums.java.net/jive/thread.jspa?messageID=217155\r
+ * This has not been resolved yet, as far as I can tell\r
+ */\r
+ \r
+ if(namespaceURI.equals(CdmNamespacePrefixMapper.CDM_NAMESPACE)) {\r
+ return CdmNamespacePrefixMapper.CDM_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(CdmNamespacePrefixMapper.AGENT_NAMESPACE)) {\r
+ return CdmNamespacePrefixMapper.AGENT_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(CdmNamespacePrefixMapper.COMMON_NAMESPACE)) {\r
+ return CdmNamespacePrefixMapper.COMMON_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(CdmNamespacePrefixMapper.DESCRIPTION_NAMESPACE)) {\r
+ return CdmNamespacePrefixMapper.DESCRIPTION_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(CdmNamespacePrefixMapper.LOCATION_NAMESPACE)) {\r
+ return CdmNamespacePrefixMapper.LOCATION_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(CdmNamespacePrefixMapper.MEDIA_NAMESPACE)) {\r
+ return CdmNamespacePrefixMapper.MEDIA_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(CdmNamespacePrefixMapper.MOLECULAR_NAMESPACE)){\r
+ return CdmNamespacePrefixMapper.MOLECULAR_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(CdmNamespacePrefixMapper.NAME_NAMESPACE)) {\r
+ return CdmNamespacePrefixMapper.NAME_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(CdmNamespacePrefixMapper.OCCURRENCE_NAMESPACE)) {\r
+ return CdmNamespacePrefixMapper.OCCURRENCE_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(CdmNamespacePrefixMapper.REFERENCE_NAMESPACE)) {\r
+ return CdmNamespacePrefixMapper.REFERENCE_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(CdmNamespacePrefixMapper.TAXON_NAMESPACE)) {\r
+ return CdmNamespacePrefixMapper.TAXON_PREFIX;\r
+ }\r
+ \r
+ return result;\r
+ }\r
+\r
+}\r
--- /dev/null
+package eu.etaxonomy.cdm.jaxb;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+\r
+import javax.xml.bind.annotation.XmlAccessType;\r
+import javax.xml.bind.annotation.XmlAccessorType;\r
+import javax.xml.bind.annotation.XmlAnyElement;\r
+import javax.xml.bind.annotation.XmlMixed;\r
+import javax.xml.bind.annotation.XmlType;\r
+\r
+import org.w3c.dom.Element;\r
+\r
+/**\r
+ * <p>Java class for anonymous complex type.\r
+ * \r
+ * <p>The following schema fragment specifies the expected content contained within this class.\r
+ * \r
+ * <pre>\r
+ * <complexType>\r
+ * <complexContent>\r
+ * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">\r
+ * <choice minOccurs="0">\r
+ * <any/>\r
+ * </choice>\r
+ * </restriction>\r
+ * </complexContent>\r
+ * </complexType>\r
+ * </pre>\r
+ * \r
+ * \r
+ */\r
+@XmlAccessorType(XmlAccessType.FIELD)\r
+@XmlType(name = "FormattedText", namespace="http://etaxonomy.eu/cdm/model/common/1.0", propOrder = {\r
+ "content"\r
+})\r
+public class FormattedText {\r
+\r
+ @XmlMixed\r
+ @XmlAnyElement\r
+ protected List<Object> content = new ArrayList<Object>();\r
+\r
+ /**\r
+ * Gets the value of the content property.\r
+ * \r
+ * <p>\r
+ * This accessor method returns a reference to the live list,\r
+ * not a snapshot. Therefore any modification you make to the\r
+ * returned list will be present inside the JAXB object.\r
+ * This is why there is not a <CODE>set</CODE> method for the content property.\r
+ * \r
+ * <p>\r
+ * For example, to add a new item, do as follows:\r
+ * <pre>\r
+ * getContent().add(newItem);\r
+ * </pre>\r
+ * \r
+ * \r
+ * <p>\r
+ * Objects of the following type(s) are allowed in the list\r
+ * {@link String }\r
+ * {@link Element }\r
+ * \r
+ * \r
+ */\r
+ public List<Object> getContent() {\r
+ return this.content;\r
+ }\r
+\r
+}\r
--- /dev/null
+package eu.etaxonomy.cdm.jaxb;\r
+\r
+import java.io.StringReader;\r
+import java.io.StringWriter;\r
+\r
+import javax.xml.bind.annotation.adapters.XmlAdapter;\r
+import javax.xml.parsers.DocumentBuilder;\r
+import javax.xml.parsers.DocumentBuilderFactory;\r
+import javax.xml.transform.OutputKeys;\r
+import javax.xml.transform.Result;\r
+import javax.xml.transform.Source;\r
+import javax.xml.transform.Transformer;\r
+import javax.xml.transform.TransformerFactory;\r
+import javax.xml.transform.dom.DOMSource;\r
+import javax.xml.transform.stream.StreamResult;\r
+\r
+import org.apache.commons.logging.Log;\r
+import org.apache.commons.logging.LogFactory;\r
+import org.w3c.dom.DOMException;\r
+import org.w3c.dom.Document;\r
+import org.w3c.dom.DocumentFragment;\r
+import org.w3c.dom.NamedNodeMap;\r
+import org.w3c.dom.Node;\r
+import org.w3c.dom.NodeList;\r
+import org.xml.sax.InputSource;\r
+\r
+public class FormattedTextAdapter extends XmlAdapter<FormattedText,java.lang.String> {\r
+ public static String[] NAMESPACE_PREFIXES = {"xmlns:common",\r
+ "xmlns:agent",\r
+ "xmlns:description",\r
+ "xmlns:location",\r
+ "xmlns:media",\r
+ "xmlns:molecular",\r
+ "xmlns:name",\r
+ "xmlns:occurence",\r
+ "xmlns:reference",\r
+ "xmlns:taxon",\r
+ "xmlns:view",\r
+ "xmlns:xsi"};\r
+\r
+ private static final Log log = LogFactory.getLog(FormattedTextAdapter.class);\r
+ \r
+ public FormattedText marshal(String string) throws Exception {\r
+ if(string != null) {\r
+ String documentString = "<?xml version=\"1.0\"?><text>" + string + "</text>";\r
+ log.debug("Parsing " + documentString);\r
+ FormattedText text = new FormattedText();\r
+ DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();\r
+ DocumentBuilder parser = factory.newDocumentBuilder();\r
+ Document document = parser.parse(new InputSource(new StringReader(documentString)));\r
+ NodeList childNodes = document.getDocumentElement().getChildNodes();\r
+ for(int i = 0; i < childNodes.getLength(); i++) {\r
+ Node node = childNodes.item(i);\r
+ if(node instanceof org.w3c.dom.Text ) {\r
+ org.w3c.dom.Text textNode = (org.w3c.dom.Text) node;\r
+ \r
+ text.getContent().add(textNode.getTextContent());\r
+ } else {\r
+ text.getContent().add(node);\r
+ }\r
+ }\r
+ return text;\r
+ }\r
+ return null;\r
+ }\r
+\r
+ public String unmarshal(FormattedText text) throws Exception {\r
+ DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();\r
+ Document document = factory.newDocumentBuilder().newDocument();\r
+ DocumentFragment documentFragment = document.createDocumentFragment();\r
+ \r
+ for(Object object : text.getContent()) {\r
+ if(object instanceof String) {\r
+ String string = (String)object;\r
+ documentFragment.appendChild(document.createTextNode(string));\r
+ } else {\r
+ Node node = (Node)object;\r
+ NamedNodeMap attributes = node.getAttributes();\r
+ for(String prefix : FormattedTextAdapter.NAMESPACE_PREFIXES) {\r
+ try{\r
+ attributes.removeNamedItem(prefix);\r
+ } catch(DOMException de){\r
+ if(de.code != DOMException.NOT_FOUND_ERR) {\r
+ throw de;\r
+ }\r
+ }\r
+ \r
+ }\r
+\r
+ documentFragment.appendChild(document.importNode(node,true));\r
+ }\r
+\r
+ }\r
+\r
+ TransformerFactory transformerFactory = TransformerFactory.newInstance();\r
+ Transformer transformer = transformerFactory.newTransformer();\r
+ transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION , "yes");\r
+ \r
+ Source input = new DOMSource(documentFragment);\r
+ StringWriter stringWriter = new StringWriter();\r
+ Result output = new StreamResult(stringWriter);\r
+ transformer.transform(input, output);\r
+ return stringWriter.toString();\r
+ }\r
+}\r
--- /dev/null
+package eu.etaxonomy.cdm.jaxb;\r
+\r
+import javax.xml.bind.annotation.adapters.XmlAdapter;\r
+import eu.etaxonomy.cdm.model.common.LSID;\r
+\r
+\r
+public class LSIDAdapter extends XmlAdapter<String, LSID>{\r
+\r
+ public String marshal(LSID lsid) throws Exception {\r
+ return lsid.getLsid();\r
+ }\r
+\r
+ public LSID unmarshal(String string) throws Exception {\r
+ return new LSID(string);\r
+ }\r
+\r
+}\r
\r
import java.util.HashMap;\r
import java.util.Map;\r
+import java.util.concurrent.ConcurrentHashMap;\r
\r
import javax.xml.bind.annotation.adapters.XmlAdapter;\r
\r
* @author a.babadshanjan\r
* @version 1.0\r
*/\r
-public class MultilanguageTextAdapter extends XmlAdapter<MultilanguageTextHelper, Map<Language, LanguageString>> {\r
+public class MultilanguageTextAdapter extends XmlAdapter<MultilanguageTextElement, Map<Language, LanguageString>> {\r
\r
@Override\r
- public MultilanguageTextHelper marshal(Map<Language, LanguageString> value)\r
+ public MultilanguageTextElement marshal(Map<Language, LanguageString> value)\r
throws Exception {\r
\r
- MultilanguageTextHelper multilanguageTextHelper = new MultilanguageTextHelper();\r
+ MultilanguageTextElement multilanguageTextElement = new MultilanguageTextElement();\r
\r
- for(Language language : value.keySet()) {\r
- multilanguageTextHelper.setLanguage(language);\r
- multilanguageTextHelper.setLanguageString(value.get(language));\r
+ for(Language l : value.keySet()) {\r
+ multilanguageTextElement.getLanguageString().add(value.get(l));\r
}\r
-\r
- return multilanguageTextHelper;\r
+ return multilanguageTextElement;\r
}\r
\r
@Override\r
- public Map<Language, LanguageString> unmarshal(MultilanguageTextHelper value)\r
+ public Map<Language, LanguageString> unmarshal(MultilanguageTextElement value)\r
throws Exception {\r
\r
- Map<Language, LanguageString> map = new HashMap<Language, LanguageString>();\r
- \r
- map.put(value.getLanguage(), value.getLanguageString());\r
+ Map<Language,LanguageString> map = new ConcurrentHashMap<Language, LanguageString>();\r
\r
+ for(LanguageString l : value.getLanguageString()) {\r
+ map.put(l.getLanguage(), l);\r
+ }\r
return map;\r
}\r
}\r
--- /dev/null
+//\r
+// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.1-b02-fcs \r
+// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> \r
+// Any modifications to this file will be lost upon recompilation of the source schema. \r
+// Generated on: 2007.12.21 at 08:13:35 PM GMT \r
+//\r
+\r
+\r
+package eu.etaxonomy.cdm.jaxb;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+import javax.xml.bind.annotation.XmlAccessType;\r
+import javax.xml.bind.annotation.XmlAccessorType;\r
+import javax.xml.bind.annotation.XmlElement;\r
+import javax.xml.bind.annotation.XmlType;\r
+\r
+import eu.etaxonomy.cdm.model.common.LanguageString;\r
+\r
+\r
+/**\r
+ * <p>Java class for MultilanguageText complex type.\r
+ * \r
+ * <p>The following schema fragment specifies the expected content contained within this class.\r
+ * \r
+ * <pre>\r
+ * <complexType name="MultilanguageText">\r
+ * <complexContent>\r
+ * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">\r
+ * <sequence>\r
+ * <element ref="{http://etaxonomy.eu/cdm/model/common/1.0}LanguageString" maxOccurs="unbounded"/>\r
+ * </sequence>\r
+ * </restriction>\r
+ * </complexContent>\r
+ * </complexType>\r
+ * </pre>\r
+ * \r
+ * \r
+ */\r
+@XmlAccessorType(XmlAccessType.FIELD)\r
+@XmlType(name = "MultilanguageText", namespace="http://etaxonomy.eu/cdm/model/common/1.0", propOrder = {\r
+ "languageString"\r
+})\r
+public class MultilanguageTextElement {\r
+\r
+ @XmlElement(name = "LanguageString", namespace="http://etaxonomy.eu/cdm/model/common/1.0", required = true)\r
+ protected List<LanguageString> languageString = new ArrayList<LanguageString>();\r
+\r
+ /**\r
+ * Gets the value of the languageString property.\r
+ * \r
+ * <p>\r
+ * This accessor method returns a reference to the live list,\r
+ * not a snapshot. Therefore any modification you make to the\r
+ * returned list will be present inside the JAXB object.\r
+ * This is why there is not a <CODE>set</CODE> method for the languageString property.\r
+ * \r
+ * <p>\r
+ * For example, to add a new item, do as follows:\r
+ * <pre>\r
+ * getLanguageString().add(newItem);\r
+ * </pre>\r
+ * \r
+ * \r
+ * <p>\r
+ * Objects of the following type(s) are allowed in the list\r
+ * {@link LanguageString }\r
+ * \r
+ * \r
+ */\r
+ public List<LanguageString> getLanguageString() {\r
+ return this.languageString;\r
+ }\r
+\r
+}\r
--- /dev/null
+package eu.etaxonomy.cdm.jaxb;\r
+\r
+import java.util.regex.Matcher;\r
+import java.util.regex.Pattern;\r
+\r
+import javax.xml.bind.annotation.adapters.XmlAdapter;\r
+\r
+import org.joda.time.DateTimeFieldType;\r
+import org.joda.time.Partial;\r
+\r
+public class PartialAdapter extends XmlAdapter<String, Partial> {\r
+ \r
+ protected static Pattern PATTERN;\r
+ private static String REGEX = "^(\\d{4})(?:\\-(\\d{2})(?:\\-(\\d{2})(?:T(\\d{2})(?:\\:(\\d{2})(?:\\:(\\d{2})(?:\\.(\\d+))?)?)?)?)?)?$";\r
+ \r
+ static {\r
+ PATTERN = Pattern.compile(REGEX);\r
+ }\r
+\r
+ @Override\r
+ public String marshal(Partial partial) throws Exception {\r
+ StringBuilder stringBuilder = new StringBuilder();\r
+ int[] values = partial.getValues();\r
+ \r
+ switch(values.length) {\r
+ case 7:\r
+ stringBuilder.append("." + values[6]);\r
+ case 6:\r
+ stringBuilder.insert(0,":" + values[5]);\r
+ case 5: \r
+ stringBuilder.insert(0,":" + values[4]);\r
+ case 4:\r
+ stringBuilder.insert(0, "T" + values[3]);\r
+ case 3:\r
+ stringBuilder.insert(0, "-" + values[2]);\r
+ case 2:\r
+ stringBuilder.insert(0, "-" + values[1]);\r
+ case 1:\r
+ stringBuilder.insert(0, values[0]);\r
+ }\r
+ \r
+ return stringBuilder.toString();\r
+ }\r
+\r
+ @Override\r
+ public Partial unmarshal(String string) throws Exception {\r
+ Matcher matcher = PATTERN.matcher(string);\r
+ if(matcher.matches()) {\r
+ int nonNullGroups = 0;\r
+ for(int i = 1; i <= matcher.groupCount(); i++) {\r
+ if(matcher.group(i) != null)\r
+ nonNullGroups++;\r
+ }\r
+ DateTimeFieldType[] dateTimeFieldTypes = new DateTimeFieldType[nonNullGroups];\r
+ int[] values = new int[nonNullGroups];\r
+ switch(nonNullGroups) {\r
+ case 7:\r
+ dateTimeFieldTypes[6] = DateTimeFieldType.millisOfSecond();\r
+ values[6] = Integer.parseInt(matcher.group(7));\r
+ case 6:\r
+ dateTimeFieldTypes[5] = DateTimeFieldType.secondOfMinute();\r
+ values[5] = Integer.parseInt(matcher.group(6));\r
+ case 5:\r
+ dateTimeFieldTypes[4] = DateTimeFieldType.minuteOfHour();\r
+ values[4] = Integer.parseInt(matcher.group(5));\r
+ case 4:\r
+ dateTimeFieldTypes[3] = DateTimeFieldType.hourOfDay();\r
+ values[3] = Integer.parseInt(matcher.group(4));\r
+ case 3:\r
+ dateTimeFieldTypes[2] = DateTimeFieldType.dayOfMonth();\r
+ values[2] = Integer.parseInt(matcher.group(3));\r
+ case 2:\r
+ dateTimeFieldTypes[1] = DateTimeFieldType.monthOfYear();\r
+ values[1] = Integer.parseInt(matcher.group(2));\r
+ case 1:\r
+ dateTimeFieldTypes[0] = DateTimeFieldType.yearOfEra();\r
+ values[0] = Integer.parseInt(matcher.group(1));\r
+ }\r
+ return new Partial(dateTimeFieldTypes, values);\r
+ } else {\r
+ throw new RuntimeException("Could not parse " + string + " with regex " + PartialAdapter.REGEX);\r
+ }\r
+ }\r
+\r
+}\r
--- /dev/null
+package eu.etaxonomy.cdm.jaxb;\r
+\r
+import com.sun.xml.bind.marshaller.NamespacePrefixMapper;\r
+\r
+public class TDWGNamespacePrefixMapper extends NamespacePrefixMapper {\r
+\r
+ private static final String RDF_PREFIX = "rdf";\r
+ private static final String DC_PREFIX = "dc";\r
+ private static final String DCTERMS_PREFIX = "dcterms";\r
+ private static final String OWL_PREFIX = "owl";\r
+ private static final String TAXONNAME_PREFIX = "tn";\r
+ private static final String TAXONCONCEPT_PREFIX = "tc";\r
+ private static final String COMMON_PREFIX = "tcom";\r
+ private static final String PERSON_PREFIX = "tp";\r
+ private static final String TEAM_PREFIX = "tt";\r
+ private static final String PUBLICATIONCITATION_PREFIX = "tpc";\r
+ \r
+ public static final String RDF_NAMESPACE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";\r
+ public static final String DC_NAMESPACE = "http://purl.org/dc/elements/1.1/";\r
+ public static final String DCTERMS_NAMESPACE = "http://purl.org/dc/terms/";\r
+ public static final String OWL_NAMESPACE = "http://www.w3.org/2002/07/owl#";\r
+ public static final String TAXONNAME_NAMESPACE = "http://rs.tdwg.org/ontology/voc/TaxonName#";\r
+ public static final String TAXONCONCEPT_NAMESPACE = "http://rs.tdwg.org/ontology/voc/TaxonConcept#";\r
+ public static final String COMMON_NAMESPACE = "http://rs.tdwg.org/ontology/voc/Common#";\r
+ public static final String PERSON_NAMESPACE = "http://rs.tdwg.org/ontology/voc/Person#";\r
+ public static final String TEAM_NAMESPACE = "http://rs.tdwg.org/ontology/voc/Team#";\r
+ public static final String PUBLICATIONCITATION_NAMESPACE = "http://rs.tdwg.org/ontology/voc/PublicationCitation#";;\r
+ \r
+ public String getPreferredPrefix(String namespaceURI, String suggestion, boolean requirePrefix) {\r
+ String result = suggestion;\r
+ \r
+ /**\r
+ * Returning empty namespace prefix works if a SAXResult is used, but not\r
+ * a DOMResult - see http://forums.java.net/jive/thread.jspa?messageID=217155\r
+ * This has not been resolved yet, as far as I can tell\r
+ */\r
+ \r
+ if(namespaceURI.equals(TDWGNamespacePrefixMapper.RDF_NAMESPACE)) {\r
+ return TDWGNamespacePrefixMapper.RDF_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(TDWGNamespacePrefixMapper.DC_NAMESPACE)) {\r
+ return TDWGNamespacePrefixMapper.DC_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(TDWGNamespacePrefixMapper.DCTERMS_NAMESPACE)) {\r
+ return TDWGNamespacePrefixMapper.DCTERMS_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(TDWGNamespacePrefixMapper.OWL_NAMESPACE)) {\r
+ return TDWGNamespacePrefixMapper.OWL_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(TDWGNamespacePrefixMapper.TAXONNAME_NAMESPACE)) {\r
+ return TDWGNamespacePrefixMapper.TAXONNAME_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(TDWGNamespacePrefixMapper.TEAM_NAMESPACE)) {\r
+ return TDWGNamespacePrefixMapper.TEAM_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(TDWGNamespacePrefixMapper.TAXONCONCEPT_NAMESPACE)) {\r
+ return TDWGNamespacePrefixMapper.TAXONCONCEPT_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(TDWGNamespacePrefixMapper.COMMON_NAMESPACE)){\r
+ return TDWGNamespacePrefixMapper.COMMON_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(TDWGNamespacePrefixMapper.PERSON_NAMESPACE)) {\r
+ return TDWGNamespacePrefixMapper.PERSON_PREFIX;\r
+ }\r
+ \r
+ if(namespaceURI.equals(TDWGNamespacePrefixMapper.PUBLICATIONCITATION_NAMESPACE)) {\r
+ return TDWGNamespacePrefixMapper.PUBLICATIONCITATION_PREFIX;\r
+ }\r
+ \r
+ return result;\r
+ }\r
+\r
+}\r
\r
package eu.etaxonomy.cdm.jaxb;\r
\r
+import java.util.UUID;\r
+\r
import javax.xml.bind.annotation.adapters.XmlAdapter;\r
\r
import org.apache.log4j.Logger;\r
*/\r
\r
\r
-public class UUIDAdapter extends XmlAdapter<String, String> {\r
+public class UUIDAdapter extends XmlAdapter<String, UUID> {\r
private static final Logger logger = Logger.getLogger(UUIDAdapter.class);\r
\r
public static String UUID_URN_PREFIX = "urn-uuid-";\r
\r
@Override\r
- public String marshal(String uuidStr) throws Exception {\r
+ public String marshal(UUID uuid) throws Exception {\r
if (logger.isDebugEnabled()){logger.debug("marshal");}\r
- return UUIDAdapter.UUID_URN_PREFIX + uuidStr;\r
+ if(uuid != null) {\r
+ return UUIDAdapter.UUID_URN_PREFIX + uuid.toString();\r
+ } else {\r
+ return null;\r
+ }\r
}\r
\r
@Override\r
- public String unmarshal(String string) throws Exception {\r
+ public UUID unmarshal(String string) throws Exception {\r
if (logger.isDebugEnabled()){logger.debug("unmarshal");}\r
if(string.startsWith(UUIDAdapter.UUID_URN_PREFIX)) {\r
String uuidPart = string.substring(UUIDAdapter.UUID_URN_PREFIX.length());\r
- return uuidPart;\r
+ return UUID.fromString(uuidPart);\r
} else {\r
throw new Exception("uuid attribute should start with " + UUIDAdapter.UUID_URN_PREFIX);\r
- }\r
- \r
+ } \r
}\r
-\r
}
\ No newline at end of file
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.VersionableEntity;
import eu.etaxonomy.cdm.model.location.Point;
* @created 08-Nov-2007 13:06:09
*/
@XmlAccessorType(XmlAccessType.FIELD)
-@XmlType(name = "", propOrder = {
+@XmlType(name = "Address", propOrder = {
"pobox",
"street",
"postcode",
"locality",
"region",
"country",
- "location",
- "contact"
+ "location"
})
@XmlRootElement(name = "Address")
@Entity
-//@Audited
+@Audited
public class Address extends VersionableEntity {
/**
@XmlElement(name = "Country")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private WaterbodyOrCountry country;
@XmlElement(name = "Location")
private Point location;
-
- //Bidirectional only private
- @XmlElement(name = "Contact")
- private Contact contact;
-
-
- /**
- * Returns the {@link Contact contact} (of a {@link Person person} or of an {@link Institution institution})
- * to which <i>this</i> address belongs.
- * Both kinds of agents cannot have more than one contact, but a contact may include
- * several postal addresses.
- *
- * @return the contact <i>this</i> postal address belongs to
- * @see Contact
- */
- @ManyToOne
- public Contact getContact() {
- return contact;
- }
-
-
- /**
- * Adds <i>this</i> postal address to the set of addresses of a {@link Contact contact}.
- * The same address instance cannot be assigned to different persons
- * or institutions (if they do have the same postal address several
- * address instances must be created). If <i>this</i> address already belongs to a
- * contact this method shifts it from this contact to a new one.
- * Therefore <i>this</i> address will be removed from the set of addresses of the old
- * contact and added to the set of the new one.
- *
- * @param newContact the new contact to which <i>this</i> postal address should belong
- * @see Contact#addAddress(Address)
- * @see Contact#removeAddress(Address)
- */
- protected void setContact(Contact newContact) {
- this.contact = newContact;
- }
-
/**
* Returns the {@link WaterbodyOrCountry country} involved in <i>this</i> postal address.
*
* @return the country
*/
- @ManyToOne(fetch = FetchType.LAZY)
public WaterbodyOrCountry getCountry(){
return this.country;
}
package eu.etaxonomy.cdm.model.agent;
-
-
import javax.persistence.Embedded;
import javax.persistence.Entity;
-import javax.persistence.FetchType;
-import javax.persistence.OneToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.Index;
import org.hibernate.annotations.Table;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.media.IdentifiableMediaEntity;
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "Agent", propOrder = {
+ "contact"
})
@Entity
-//@Audited
-@Table(appliesTo="Agent", indexes = { @Index(name = "agentTitleCacheIndex", columnNames = { "titleCache" }) })
-public abstract class Agent extends IdentifiableMediaEntity{
+@Audited
+@Table(appliesTo="AgentBase", indexes = { @Index(name = "agentTitleCacheIndex", columnNames = { "titleCache" }) })
+public abstract class AgentBase extends IdentifiableMediaEntity{
/**
*
*/
private static final long serialVersionUID = 7732768617469448829L;
-
- // TODO: Move contact field here (from Person and Institution)
-// @XmlElement(name = "Contact")
-// private Contact contact;
+
+ @XmlElement(name = "Contact")
+ @Embedded
+ private Contact contact;
/**
* Returns the {@link Contact contact} of <i>this</i> person.
*
* @see Contact
*/
-// @Embedded
-// public Contact getContact(){
-// return this.contact;
-// }
+ public Contact getContact(){
+ return this.contact;
+ }
/**
* @see #getContact()
*/
-// public void setContact(Contact contact){
-// this.contact = contact;
-// }
+ public void setContact(Contact contact){
+ this.contact = contact;
+ }
-
-
-
-
}
package eu.etaxonomy.cdm.model.agent;
+import java.util.ArrayList;
+import java.util.List;
import java.util.Set;
-//import javax.persistence.Column;
-import javax.persistence.Entity;
-//import javax.persistence.JoinColumn;
-//import javax.persistence.JoinTable;
-//import javax.persistence.ManyToOne;
+import javax.persistence.Embeddable;
+import javax.persistence.FetchType;
import javax.persistence.OneToMany;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
-import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
-//import org.hibernate.annotations.CollectionOfElements;
-
-import eu.etaxonomy.cdm.model.common.VersionableEntity;
+import org.hibernate.annotations.CollectionOfElements;
+import org.hibernate.envers.Audited;
/**
* The class for information on how to approach a {@link Person person} or an {@link Institution institution}.
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "Contact", propOrder = {
- "email",
- "url",
- "phone",
- "fax",
+ "emailAddresses",
+ "urls",
+ "phoneNumbers",
+ "faxNumbers",
"addresses"
})
@XmlRootElement(name = "Contact")
-@Entity
-//@Embeddable
-//@Audited
-public class Contact extends VersionableEntity {
+@Embeddable
+@Audited
+public class Contact {
private static final long serialVersionUID = -1851305307069277625L;
private static final Logger logger = Logger.getLogger(Contact.class);
logger.debug("Constructor call");
}
-
+ @XmlElementWrapper(name = "EmailAddresses")
@XmlElement(name = "EmailAddress")
- private String email;
- // TODO: Make email, url, phone, fax Sets
- //private Set<String> email;
+ @CollectionOfElements(fetch = FetchType.LAZY)
+ private List<String> emailAddresses = new ArrayList<String>();
+ @XmlElementWrapper(name = "URLs")
@XmlElement(name = "URL")
@XmlSchemaType(name = "anyURI")
- private String url;
+ @CollectionOfElements(fetch = FetchType.LAZY)
+ private List<String> urls = new ArrayList<String>();
+ @XmlElementWrapper(name = "PhoneNumbers")
@XmlElement(name = "PhoneNumber")
- private String phone;
+ @CollectionOfElements(fetch = FetchType.LAZY)
+ private List<String> phoneNumbers = new ArrayList<String>();
+ @XmlElementWrapper(name = "FaxNumbers")
@XmlElement(name = "FaxNumber")
- private String fax;
+ @CollectionOfElements(fetch = FetchType.LAZY)
+ private List<String> faxNumbers = new ArrayList<String>();
@XmlElementWrapper(name = "Addresses")
@XmlElement(name = "Address")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
protected Set<Address> addresses;
* @return the set of postal addresses
* @see Address
*/
- @OneToMany(mappedBy="contact")
- @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
public Set<Address> getAddresses(){
return this.addresses;
}
- /**
- * @see #getAddresses()
- */
- protected void setAddresses(Set<Address> addresses){
- this.addresses = addresses;
- }
+
/**
* Adds a new postal {@link Address address} to the set of postal addresses of <i>this</i> contact.
*
*/
public void addAddress(Address address){
if (address != null){
- address.setContact(this);
addresses.add(address);
}
}
+
/**
* Removes one element from the set of postal addresses of <i>this</i> contact.
*
* @see #getAddresses()
*/
public void removeAddress(Address address){
- address.setContact(null);
+ addresses.remove(address);
}
/**
- * Returns the string representing the electronic mail address
+ * Returns the List of strings representing the electronic mail addresses
* included in <i>this</i> contact.
*/
- // TODO:
-// @CollectionOfElements(
-// targetElement = String.class
-// )
-// @JoinTable(
-// name = "item_email",
-// joinColumns = @JoinColumn(name = "email_id")
-// )
-// @Column(name = "EINNAME" , nullable = false)
-// public Set<String> getEmail(){
- public String getEmail(){
- return this.email;
+ public List<String> getEmailAddresses(){
+ return this.emailAddresses;
}
/**
- * @see #getEmail()
+ * @see #getEmailAddress()
+ */
+ public void addEmailAddress(String emailAddress){
+ this.emailAddresses.add(emailAddress);
+ }
+
+ /**
+ * Removes one element from the list of email addresses of <i>this</i> contact.
+ *
+ * @param emailAddress the email address of <i>this</i> contact which should be deleted
+ * @see #getEmailAddresses()
*/
- //public void setEmail(Set<String> email){
- public void setEmail(String email){
- this.email = email;
+ public void removeEmailAddress(String emailAddress){
+ emailAddresses.remove(emailAddress);
}
/**
- * Returns the string representing the "Uniform Resource Locator" (url)
+ * Returns the list of strings representing the "Uniform Resource Locators" (urls)
* included in <i>this</i> contact.
*/
- public String getUrl(){
- return this.url;
+ public List<String> getUrls(){
+ return this.urls;
}
/**
- * @see #getUrl()
+ * @see #getUrls()
*/
- public void setUrl(String url){
- this.url = url;
+ public void addUrl(String url){
+ this.urls.add(url);
+ }
+
+ /**
+ * Removes one element from the list of urls of <i>this</i> contact.
+ *
+ * @param url the url of <i>this</i> contact which should be deleted
+ * @see #getUrls()
+ */
+ public void removeUrl(String url){
+ urls.remove(url);
}
/**
- * Returns the string representing the phone number
+ * Returns the list of strings representing the phone numbers
* included in <i>this</i> contact.
*/
- public String getPhone(){
- return this.phone;
+ public List<String> getPhoneNumbers(){
+ return this.phoneNumbers;
}
/**
* @see #getPhone()
*/
- public void setPhone(String phone){
- this.phone = phone;
+ public void addPhoneNumber(String phoneNumber){
+ this.phoneNumbers.add(phoneNumber);
+ }
+
+ /**
+ * Removes one element from the list of phone numbers of <i>this</i> contact.
+ *
+ * @param phoneNumber the phone number of <i>this</i> contact which should be deleted
+ * @see #getPhoneNumber()
+ */
+ public void removePhoneNumber(String phoneNumber){
+ phoneNumbers.remove(phoneNumber);
}
/**
- * Returns the string representing the telefax number
+ * Returns the list of strings representing the telefax numbers
* included in <i>this</i> contact.
*/
- public String getFax(){
- return this.fax;
+ public List<String> getFaxNumbers(){
+ return this.faxNumbers;
}
/**
- * @see #getFax()
+ * @see #getFaxNumbers()
*/
- public void setFax(String fax){
- this.fax = fax;
+ public void addFaxNumber(String faxNumber){
+ this.faxNumbers.add(faxNumber);
}
+ /**
+ * Removes one element from the list of telefax numbers of <i>this</i> contact.
+ *
+ * @param faxNumber the telefax number of <i>this</i> contact which should be deleted
+ * @see #getFaxNumber()
+ */
+ public void removeFaxNumber(String faxNumber){
+ faxNumbers.remove(faxNumber);
+ }
}
\ No newline at end of file
package eu.etaxonomy.cdm.model.agent;
-import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
+import java.util.HashSet;
+import java.util.Set;
-import java.util.*;
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.ManyToMany;
+import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+
/**
* This class represents public or private institutions.
* It includes name, contact details and institution type.
"code",
"name",
"types",
- "isPartOf",
- "contact"
+ "isPartOf"
})
@XmlRootElement(name = "Institution")
@Entity
-//@Audited
-public class Institution extends Agent {
+@Audited
+public class Institution extends AgentBase {
private static final long serialVersionUID = -951321271656955808L;
public static final Logger logger = Logger.getLogger(Institution.class);
@XmlElementWrapper(name = "Types")
@XmlElement(name = "Type")
- //@XmlIDREF
- //@XmlSchemaType(name = "IDREF")
+ @XmlIDREF
+ @XmlSchemaType(name = "IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
private Set<InstitutionType> types = new HashSet<InstitutionType>();
@XmlElement(name = "IsPartOf")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Institution isPartOf;
-
- // TODO: Move to Agent
- @XmlElement(name = "Contact")
- private Contact contact;
/**
* Creates a new empty institution instance.
super();
}
- /**
- * Returns the {@link Contact contact} corresponding to <i>this</i> institution.
- * It includes telecommunication data
- * and electronic as well as multiple postal addresses.
- */
- // TODO: Move to Agent, mark as @OneToOne
- @ManyToOne
- @Cascade({CascadeType.SAVE_UPDATE})
- public Contact getContact(){
- return this.contact;
- }
- /**
- * @see #getContact()
- */
- public void setContact(Contact contact){
- this.contact = contact;
- }
-
/**
* Returns the set of institution {@link InstitutionType types} (categories)
* used to describe or circumscribe <i>this</i> institution's activities.
* @return the set of institution types
* @see InstitutionType
*/
- @ManyToMany(fetch = FetchType.LAZY)
public Set<InstitutionType> getTypes(){
return this.types;
}
public void removeType(InstitutionType t){
this.types.remove(t);
}
- /**
- * @see #getTypes()
- */
- protected void setTypes(Set<InstitutionType> types){
- this.types = types;
- }
-
/**
* Returns the parent institution of this institution.
* This is for instance the case when this institution is a herbarium
* belonging to a parent institution such as a museum.
*/
- @ManyToOne
- @Cascade({CascadeType.SAVE_UPDATE})
public Institution getIsPartOf(){
return this.isPartOf;
}
+
/**
* Assigns a parent institution to which this institution belongs.
*
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "InstitutionType")
@Entity
-//@Audited
+@Audited
public class InstitutionType extends DefinedTermBase<InstitutionType> {
private static final long serialVersionUID = 8714866112728127219L;
public static final Logger logger = Logger.getLogger(InstitutionType.class);
package eu.etaxonomy.cdm.model.agent;
-import eu.etaxonomy.cdm.model.common.TimePeriod;
-import eu.etaxonomy.cdm.model.common.VersionableEntity;
-import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
-
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+
+import eu.etaxonomy.cdm.model.common.TimePeriod;
+import eu.etaxonomy.cdm.model.common.VersionableEntity;
+
/**
* This class allows to hold one {@link Institution institution} to which a {@link Person person}
* is affiliated. It includes {@link eu.etaxonomy.cdm.model.common.TimePeriod time period} of membership and role of
})
@XmlRootElement(name = "InstitutionalMembership")
@Entity
-//@Audited
+@Audited
public class InstitutionalMembership extends VersionableEntity {
private static final long serialVersionUID = -800814712134999042L;
public static final Logger logger = Logger.getLogger(InstitutionalMembership.class);
@XmlElement(name = "Institution", required = true)
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Institution institute;
@XmlElement(name = "Person", required = true)
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Person person;
public static InstitutionalMembership NewInstance() {
* @see Person#institutionalMemberships
* @see Person#addInstitutionalMembership(Institution, TimePeriod, String, String)
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Person getPerson() {
return person;
}
- /**
+
+ /**
* Assigns a new {@link Person person} (replacing the actual one) to <i>this</i> institutional membership.
* This method also updates both sets of institutions
- * the two persons (the new one and the substituted one) belong to.
+ * the two persons (the new one and the substituted one) belong to.
*
* @param newPerson the new person to be included in <i>this</i> institutional membership
* @see #getPerson()
* @see Person#removeInstitutionalMembership(InstitutionalMembership)
*/
- protected void setPerson(Person newPerson) {
- this.person = newPerson;
+ protected void setPerson(Person person) {
+ this.person = person;
}
-
/**
* Returns the {@link Institution institution} corresponding to <i>this</i> institutional membership.
*/
- @Cascade({CascadeType.SAVE_UPDATE})
- @ManyToOne(fetch = FetchType.LAZY)
public Institution getInstitute(){
return this.institute;
}
public void setRole(String role){
this.role = role;
}
-
}
\ No newline at end of file
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import java.util.*;
import javax.persistence.*;
"suffix",
"lifespan",
"institutionalMemberships",
- "contact",
"keywords"
})
@XmlRootElement(name = "Person")
@Entity
-//@Audited
+@Audited
public class Person extends TeamOrPersonBase<Person> {
private static final long serialVersionUID = 4153566493065539763L;
public static final Logger logger = Logger.getLogger(Person.class);
private String suffix;
@XmlElement(name = "Lifespan")
- //@XmlJavaTypeAdapter(IntervalAdapter.class)
private TimePeriod lifespan;
@XmlElementWrapper(name = "InstitutionalMemberships")
@XmlElement(name = "InstitutionalMembership")
+ @OneToMany(fetch=FetchType.LAZY, mappedBy = "person")
+ @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE})
protected Set<InstitutionalMembership> institutionalMemberships;
- // TODO: Move to Agent
- @XmlElement(name = "Contact")
- private Contact contact;
-
@XmlElementWrapper(name = "Keywords")
@XmlElement(name = "Keyword")
@XmlIDREF
@XmlSchemaType(name="IDREF")
+ @ManyToMany(fetch=FetchType.LAZY)
+ @JoinTable(
+ name="Person_Keyword",
+ joinColumns=@JoinColumn(name="person_fk"),
+ inverseJoinColumns=@JoinColumn(name="keyword_fk")
+ )
private Set<Keyword> keywords = new HashSet<Keyword>();
/**
*
* @see InstitutionalMembership
*/
- @OneToMany(fetch=FetchType.LAZY, mappedBy = "person")
- @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE})
public Set<InstitutionalMembership> getInstitutionalMemberships(){
return this.institutionalMemberships;
}
- /**
- * @see #getInstitutionalMemberships()
- */
- protected void setInstitutionalMemberships(Set<InstitutionalMembership> institutionalMemberships){
- this.institutionalMemberships = institutionalMemberships;
- }
+
/**
* Adds a new {@link InstitutionalMembership membership} of <i>this</i> person in an {@link Institution institution}
*
* @see Keyword
*/
- @ManyToMany(fetch=FetchType.LAZY)
- @JoinTable(
- name="Person_Keyword",
- joinColumns=@JoinColumn(name="person_fk"),
- inverseJoinColumns=@JoinColumn(name="keyword_fk")
- )
- @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
public Set<Keyword> getKeywords(){
return this.keywords;
}
- /**
- * @see #getKeywords()
- */
- public void setKeywords(Set<Keyword> keywords){
- this.keywords = keywords;
- }
+
/**
* Adds a new keyword from the keyword vocabulary to the set of keywords
* describing or circumscribing <i>this</i> person's activities.
public void removeKeyword(Keyword keyword){
this.keywords.remove(keyword);
}
-
-
- /**
- * Returns the {@link Contact contact} of <i>this</i> person.
- * The contact contains several ways to approach <i>this</i> person.
- *
- * @see Contact
- */
- // TODO: Move to Agent, mark as @OneToOne
- @ManyToOne(fetch=FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
- public Contact getContact(){
- return this.contact;
- }
- /**
- * @see #getContact()
- */
- public void setContact(Contact contact){
- this.contact = contact;
- }
-
/**
* Returns the string representing the prefix (for instance "Prof. Dr.<!-- -->")
import java.util.List;
import javax.persistence.Entity;
+import javax.persistence.FetchType;
import javax.persistence.ManyToMany;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.strategy.cache.agent.TeamDefaultCacheStrategy;
})
@XmlRootElement
@Entity
-//@Audited
+@Audited
public class Team extends TeamOrPersonBase<Team> {
private static final long serialVersionUID = 97640416905934622L;
public static final Logger logger = Logger.getLogger(Team.class);
@XmlElement(name = "TeamMember")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
private List<Person> teamMembers = new ArrayList<Person>();
* Returns the list of {@link Person members} belonging to <i>this</i> team.
* A person may be a member of several distinct teams.
*/
- @ManyToMany
- //@IndexColumn(name="sortIndex", base = 0)
- //@JoinColumn (name = "representation_id", nullable=false)
- @Cascade({CascadeType.SAVE_UPDATE})
public List<Person> getTeamMembers(){
return this.teamMembers;
}
- /**
- * @see #getTeamMembers()
- */
- protected void setTeamMembers(List<Person> teamMembers){
- this.teamMembers = teamMembers;
- }
/**
* Adds a new {@link Person person} to <i>this</i> team at the end of the members' list.
* @return a string which identifies <i>this</i> team for nomenclature
*/
@Override
- @Transient
public String getNomenclaturalTitle() {
if (protectedNomenclaturalTitleCache == PROTECTED){
return this.nomenclaturalTitle;
this.nomenclaturalTitle = nomenclaturalTitle;
this.protectedNomenclaturalTitleCache = protectedNomenclaturalTitleCache;
}
-
-
-
-
-
}
\ No newline at end of file
package eu.etaxonomy.cdm.model.agent;\r
\r
import javax.persistence.Entity;\r
+import javax.persistence.Transient;\r
import javax.xml.bind.annotation.XmlAccessType;\r
import javax.xml.bind.annotation.XmlAccessorType;\r
import javax.xml.bind.annotation.XmlElement;\r
import javax.xml.bind.annotation.XmlType;\r
\r
import org.apache.log4j.Logger;\r
+import org.hibernate.envers.Audited;\r
\r
import eu.etaxonomy.cdm.strategy.cache.agent.INomenclaturalAuthorCacheStrategy;\r
\r
\r
/**\r
- * The abstract class for such {@link Agent agents} ({@link Person persons} or {@link Team teams}) who might also be used\r
+ * The abstract class for such {@link AgentBase agents} ({@link Person persons} or {@link Team teams}) who might also be used\r
* for authorship of {@link eu.etaxonomy.cdm.model.reference.ReferenceBase references} or of {@link eu.etaxonomy.cdm.model.name.TaxonNameBase taxon names}.\r
* \r
* @author a.mueller\r
"nomenclaturalTitle"\r
})\r
@Entity\r
-//@Audited\r
-public abstract class TeamOrPersonBase<T extends TeamOrPersonBase<?>> extends Agent implements INomenclaturalAuthor {\r
+@Audited\r
+public abstract class TeamOrPersonBase<T extends TeamOrPersonBase<?>> extends AgentBase implements INomenclaturalAuthor {\r
private static final long serialVersionUID = 5216821307314001961L;\r
public static final Logger logger = Logger.getLogger(TeamOrPersonBase.class);\r
\r
protected String nomenclaturalTitle;\r
\r
@XmlTransient\r
+ @Transient\r
protected INomenclaturalAuthorCacheStrategy<T> cacheStrategy;\r
\r
/**\r
--- /dev/null
+\r
+@javax.xml.bind.annotation.XmlSchema(namespace = "http://etaxonomy.eu/cdm/model/agent/1.0", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)\r
+package eu.etaxonomy.cdm.model.agent;
\ No newline at end of file
import javax.persistence.FetchType;
import javax.persistence.MappedSuperclass;
import javax.persistence.OneToMany;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
@XmlElementWrapper(name = "Markers")
@XmlElement(name = "Marker")
- protected Set<Marker> markers = getNewMarkerSet();
+ @OneToMany(fetch=FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
+ protected Set<Marker> markers = new HashSet<Marker>();
@XmlElementWrapper(name = "Annotations")
@XmlElement(name = "Annotation")
- protected Set<Annotation> annotations = getNewAnnotationSet();
+ @OneToMany(fetch=FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
+ protected Set<Annotation> annotations = new HashSet<Annotation>();
protected AnnotatableEntity() {
super();
//*************** MARKER **********************************************
- @OneToMany(fetch=FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<Marker> getMarkers(){
return this.markers;
}
public void removeMarker(Marker marker){
marker.setMarkedObj(null);
}
- protected void setMarkers(Set<Marker> markers) {
- this.markers = markers;
- }
//*************** ANNOTATIONS **********************************************
- @OneToMany(fetch=FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE})
public Set<Annotation> getAnnotations(){
return this.annotations;
}
annotation.setAnnotatedObj(null);
}
- protected void setAnnotations(Set<Annotation> annotations) {
- this.annotations = annotations;
- }
-
//********************** CLONE *****************************************/
/* (non-Javadoc)
AnnotatableEntity result = (AnnotatableEntity)super.clone();
//Annotations
- Set<Annotation> newAnnotations = getNewAnnotationSet();
+ result.annotations = new HashSet<Annotation>();
for (Annotation annotation : this.annotations ){
- Annotation newExtension = annotation.clone(this);
- newAnnotations.add(newExtension);
+ Annotation newAnnotation = (Annotation)annotation.clone();
+ result.addAnnotation(newAnnotation);
}
- result.setAnnotations(newAnnotations);
-
//Markers
- Set<Marker> newMarkers = getNewMarkerSet();
+ result.markers = new HashSet<Marker>();
for (Marker marker : this.markers ){
- Marker newMarker = marker.clone(this);
- newMarkers.add(newMarker);
+ Marker newMarker = (Marker)marker.clone();
+ result.addMarker(newMarker);
}
- result.setMarkers(newMarkers);
//no changes to: -
return result;
- }
-
- @Transient
- private Set<Annotation> getNewAnnotationSet(){
- return new HashSet<Annotation>();
- }
-
- @Transient
- private Set<Marker> getNewMarkerSet(){
- return new HashSet<Marker>();
- }
-
+ }
}
import org.hibernate.annotations.Any;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+import org.hibernate.envers.NotAudited;
import java.net.MalformedURLException;
import java.net.URL;
"linkbackUrl"
})
@Entity
-//@Audited
+@Audited
public class Annotation extends LanguageStringBase implements Cloneable {
private static final long serialVersionUID = -4484677078599520233L;
private static final Logger logger = Logger.getLogger(Annotation.class);
@XmlElement(name = "Commentator")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Person commentator;
@XmlElement(name = "AnnotatedObject")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @Any(metaDef = "CdmBase",
+ metaColumn=@Column(name = "annotatedObj_type"),
+ fetch = FetchType.LAZY,
+ optional = false)
+ @JoinColumn(name = "annotatedObj_id")
+ @NotAudited
private AnnotatableEntity annotatedObj;
@XmlElement(name = "AnnotationType")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private AnnotationType annotationType;
// for external annotations/comments the URL of these can be set.
* Currently envers does not support @Any
* @return
*/
- @Any(metaDef = "CdmBase",
- metaColumn=@Column(name = "annotatedObj_type"),
- fetch = FetchType.LAZY,
- optional = false)
- @JoinColumn(name = "annotatedObj_id")
-// @NotAudited
public AnnotatableEntity getAnnotatedObj() {
return annotatedObj;
}
- protected void setAnnotatedObj(AnnotatableEntity newAnnotatedObj) {
+ public void setAnnotatedObj(AnnotatableEntity newAnnotatedObj) {
this.annotatedObj = newAnnotatedObj;
}
- @ManyToOne(fetch = FetchType.LAZY)
public AnnotationType getAnnotationType() {
return annotationType;
}
this.annotationType = annotationType;
}
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Person getCommentator(){
return this.commentator;
}
this.commentator = commentator;
}
- @Transient
public URL getLinkbackUrl() {
return linkbackUrl;
}
package eu.etaxonomy.cdm.model.common;
-import org.apache.log4j.Logger;
-
-import au.com.bytecode.opencsv.CSVWriter;
-
-import java.util.*;
+import java.util.UUID;
-import javax.persistence.*;
+import javax.persistence.Entity;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
+import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
+
/**
* Annotation types ...
* @author a.mueller
@XmlType(name = "AnnotationType")
@XmlRootElement(name = "AnnotationType")
@Entity
-//@Audited
+@Audited
public class AnnotationType extends DefinedTermBase<AnnotationType> {
private static final long serialVersionUID = 49629121282854575L;
@SuppressWarnings("unused")
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.MappedSuperclass;
-import javax.persistence.Temporal;
-import javax.persistence.TemporalType;
import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlID;
-import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.XmlType;
* @author m.doering
*
*/
-@XmlAccessorType(XmlAccessType.PROPERTY)
+@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "CdmBase", propOrder = {
"created",
"createdBy"
})
-@XmlRootElement(name = "CdmBase")
@MappedSuperclass
public abstract class CdmBase implements Serializable, ICdmBase{
private static final long serialVersionUID = -3053225700018294809L;
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(CdmBase.class);
+ @Transient
+ @XmlTransient
private PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(this);
+
+ @XmlAttribute(name = "id", required = true)
+ @Id
+ @GeneratedValue(generator = "system-increment")
+ @DocumentId
private int id;
- private UUID uuid;
+ @XmlAttribute(required = true)
+ @XmlJavaTypeAdapter(UUIDAdapter.class)
+ @XmlID
+ @Type(type="uuidUserType")
+ protected UUID uuid;
+
+ @XmlElement (name = "Created", type= String.class)
+ @XmlJavaTypeAdapter(DateTimeAdapter.class)
+ @Type(type="dateTimeUserType")
+ @Basic(fetch = FetchType.LAZY)
private DateTime created;
+
+ @XmlElement (name = "CreatedBy")
+ @XmlIDREF
+ @XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Person createdBy;
/**
*/
public CdmBase() {
this.uuid = UUID.randomUUID();
- this.setCreated(new DateTime());
+ this.created = new DateTime().withMillisOfSecond(0);
}
/**
propertyChangeSupport.removePropertyChangeListener(propertyName, listener);
}
- @Transient
public boolean hasListeners(String propertyName) {
return propertyChangeSupport.hasListeners(propertyName);
}
propertyChangeSupport.firePropertyChange(evt);
}
- /**
- * Method for JAXB only to obtain the UUID value as a String instance.
- * For getting the UUID please use the getUuid method.
- * @return String representation of the UUID
- */
- @XmlAttribute(name = "uuid", required = true)
- @XmlJavaTypeAdapter(UUIDAdapter.class)
- @XmlID
- @XmlSchemaType(name = "ID")
- @Transient
- private String getStrUuid() {
- return this.uuid.toString();
- }
-
- /**
- * Method for JAXB only to set the UUID value as a String instance.
- * For setting the UUID please use setUuid method.
- */
- @Transient
- private void setStrUuid(String uuid) {
- this.uuid = UUID.fromString(uuid);
- }
-
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.ICdmBase#getUuid()
- */
- @XmlTransient
- @Type(type="uuidUserType")
+ */
public UUID getUuid() {
- return this.uuid;
+ return uuid;
}
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.ICdmBase#setUuid(java.util.UUID)
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.ICdmBase#getId()
*/
- @XmlAttribute(name = "id", required = true)
- @Id
- @GeneratedValue(generator = "system-increment")
- @DocumentId
public int getId() {
return this.id;
}
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.ICdmBase#getCreated()
*/
- @XmlElement (name = "Created", type= String.class)
- @XmlJavaTypeAdapter(DateTimeAdapter.class)
- @Type(type="dateTimeUserType")
- @Basic(fetch = FetchType.LAZY)
public DateTime getCreated() {
return created;
}
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.ICdmBase#getCreatedBy()
*/
- @XmlElement (name = "CreatedBy")
- @ManyToOne(fetch=FetchType.LAZY)
- @Cascade( { CascadeType.SAVE_UPDATE })
public Person getCreatedBy() {
return this.createdBy;
}
AnnotationType.class,\r
NamedAreaType.class,\r
NamedAreaLevel.class,\r
- //NomenclaturalCode.class,\r
Feature.class,\r
TdwgArea.class,\r
//NamedArea.class,\r
package eu.etaxonomy.cdm.model.common;
-import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
-import org.hibernate.collection.AbstractPersistentCollection;
-import org.hibernate.search.annotations.Indexed;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
-import au.com.bytecode.opencsv.CSVWriter;
-import eu.etaxonomy.cdm.model.common.init.ITermInitializer;
-import eu.etaxonomy.cdm.model.media.Media;
-import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
-
-import java.lang.reflect.Field;
-import java.util.*;
-
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.Inheritance;
+import javax.persistence.InheritanceType;
+import javax.persistence.ManyToOne;
+import javax.persistence.OneToMany;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
-import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.XmlType;
+import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+import org.hibernate.search.annotations.Indexed;
+
+import au.com.bytecode.opencsv.CSVWriter;
+import eu.etaxonomy.cdm.model.media.Media;
+
/**
* walkaround for enumerations, base type according to TDWG. For linear ordering
})
@XmlRootElement(name = "DefinedTermBase")
@Entity
-//@Audited
+@Audited
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@Indexed
public abstract class DefinedTermBase<T extends DefinedTermBase> extends TermBase implements ILoadableTerm<T>, IDefinedTerm<T> {
@XmlElement(name = "KindOf")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY, targetEntity = DefinedTermBase.class)
+ @Cascade(CascadeType.SAVE_UPDATE)
private T kindOf;
/**
* FIXME - Hibernate retuns this as a collection of CGLibProxy$$DefinedTermBase objects
* which can't be cast to instances of T - can we explicitly initialize these terms using
* Hibernate.initialize(), does this imply a distinct load, and find methods in the dao?
*/
+ @XmlElementWrapper(name = "Generalizations")
@XmlElement(name = "GeneralizationOf")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch=FetchType.LAZY, mappedBy = "kindOf", targetEntity = DefinedTermBase.class)
+ @Cascade({CascadeType.SAVE_UPDATE})
private Set<T> generalizationOf = new HashSet<T>();
@XmlElement(name = "PartOf")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY, targetEntity = DefinedTermBase.class)
+ @Cascade(CascadeType.SAVE_UPDATE)
private T partOf;
/**
*/
@XmlElementWrapper(name = "Includes")
@XmlElement(name = "Include")
- @XmlIDREF
+ @XmlIDREF
@XmlSchemaType(name = "IDREF")
- private Set<T> includes = new HashSet<T>();
+ @OneToMany(fetch=FetchType.LAZY, mappedBy = "partOf", targetEntity = DefinedTermBase.class)
+ @Cascade({CascadeType.SAVE_UPDATE})
+ private Set<T> includes = new HashSet<T>();
+ /**
+ * FIXME should be many-to-many?
+ */
@XmlElementWrapper(name = "Media")
@XmlElement(name = "Medium")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
private Set<Media> media = new HashSet<Media>();
@XmlElement(name = "TermVocabulary")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
protected TermVocabulary<T> vocabulary;
-// ************** Constructor ******************************************/
-
public DefinedTermBase() {
super();
}
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.ILoadableTerm#readCsvLine(java.util.List)
*/
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.model.common.IDefinedTerm#readCsvLine(java.lang.Class, java.util.List, java.util.Map)
- */
public T readCsvLine(Class<T> termClass, List<String> csvLine, Map<UUID,DefinedTermBase> terms) {
try {
T newInstance = termClass.newInstance();
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IDefinedTerm#getByUuid(java.util.UUID)
*/
- @Transient
public T getByUuid(UUID uuid){
return this.vocabulary.findTermByUuid(uuid);
}
-
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IDefinedTerm#getKindOf()
*/
- @ManyToOne(fetch = FetchType.LAZY, targetEntity = DefinedTermBase.class)
- @Cascade({CascadeType.SAVE_UPDATE})
public T getKindOf(){
return this.kindOf;
}
-
/* (non-Javadoc)
- * @see eu.etaxonomy.cdm.model.common.IDefinedTerm#setKindOf(T)
+ * @see eu.etaxonomy.cdm.model.common.IDefinedTerm#getByUuid(java.util.UUID)
*/
public void setKindOf(T kindOf){
this.kindOf = kindOf;
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IDefinedTerm#getGeneralizationOf()
*/
- @OneToMany(fetch=FetchType.LAZY, mappedBy = "kindOf", targetEntity = DefinedTermBase.class)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<T> getGeneralizationOf(){
return this.generalizationOf;
}
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.model.common.IDefinedTerm#setGeneralizationOf(java.util.Set)
- */
- public void setGeneralizationOf(Set<T> generalizationOf) {
- this.generalizationOf = generalizationOf;
- }
-
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IDefinedTerm#addGeneralizationOf(T)
*/
}
}
-
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IDefinedTerm#getPartOf()
*/
- @ManyToOne(fetch = FetchType.LAZY, targetEntity = DefinedTermBase.class)
- @Cascade({CascadeType.SAVE_UPDATE})
public T getPartOf(){
return this.partOf;
}
+
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IDefinedTerm#setPartOf(T)
*/
this.partOf = partOf;
}
-
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IDefinedTerm#getIncludes()
*/
- @OneToMany(fetch=FetchType.LAZY, mappedBy = "partOf", targetEntity = DefinedTermBase.class)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<T> getIncludes(){
return this.includes;
}
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.model.common.IDefinedTerm#setIncludes(java.util.Set)
- */
- public void setIncludes(Set<T> includes) {
- this.includes = includes;
- }
+
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IDefinedTerm#addIncludes(T)
*/
}
}
-
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IDefinedTerm#getMedia()
*/
- @ManyToMany(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<Media> getMedia(){
return this.media;
}
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.model.common.IDefinedTerm#setMedia(java.util.Set)
- */
- public void setMedia(Set<Media> media) {
- this.media = media;
- }
+
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IDefinedTerm#addMedia(eu.etaxonomy.cdm.model.media.Media)
*/
public void addMedia(Media media) {
this.media.add(media);
}
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.model.common.IDefinedTerm#removeMedia(eu.etaxonomy.cdm.model.media.Media)
- */
public void removeMedia(Media media) {
this.media.remove(media);
}
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.model.common.IDefTerm#getVocabulary()
- */
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IDefinedTerm#getVocabulary()
*/
- @XmlTransient
- @ManyToOne(fetch=FetchType.LAZY)
- @Cascade( { CascadeType.SAVE_UPDATE })
public TermVocabulary<T> getVocabulary() {
return this.vocabulary;
}
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.model.common.IDefTerm#setVocabulary(eu.etaxonomy.cdm.model.common.TermVocabulary)
- */
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IDefinedTerm#setVocabulary(eu.etaxonomy.cdm.model.common.TermVocabulary)
*/
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
-import eu.etaxonomy.cdm.model.agent.Agent;
+import eu.etaxonomy.cdm.model.agent.AgentBase;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "EventBase", propOrder = {
@XmlElement(name = "Actor")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private Agent actor;
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
+ private AgentBase actor;
@XmlElement(name = "Description")
private String description;
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.occurrence.IEvent#getActor()
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
- public Agent getActor() {
+ public AgentBase getActor() {
return actor;
}
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.occurrence.IEvent#setActor(eu.etaxonomy.cdm.model.agent.Agent)
*/
- public void setActor(Agent actor) {
+ public void setActor(AgentBase actor) {
this.actor = actor;
}
package eu.etaxonomy.cdm.model.common;
+import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
+import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.annotations.Any;
+import org.hibernate.envers.Audited;
+import org.hibernate.envers.NotAudited;
/**
* This class aims to make available more "attributes" for identifiable entities
"extendedObj"
})
@Entity
-//@Audited
+@Audited
public class Extension extends VersionableEntity implements Cloneable {
private static final long serialVersionUID = -857207737641432202L;
@SuppressWarnings("unused")
@XmlElement(name = "ExtensionType")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private ExtensionType type;
@XmlElement(name = "ExtendedObject")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @Any(metaDef = "CdmBase",
+ metaColumn=@Column(name = "extendedObj_type"),
+ fetch = FetchType.LAZY,
+ optional = false)
+ @JoinColumn(name = "extendedObj_id")
+ @NotAudited
private IdentifiableEntity extendedObj;
public static Extension NewInstance(){
}
-
-
- @Transient
public IdentifiableEntity getExtendedObj() {
return extendedObj;
}
this.extendedObj = extendedObj;
}
- @ManyToOne(fetch = FetchType.LAZY)
+
public ExtensionType getType(){
return this.type;
}
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "ExtensionType")
@Entity
-//@Audited
+@Audited
public class ExtensionType extends DefinedTermBase<ExtensionType> {
private static final long serialVersionUID = -7761963794004133427L;
@SuppressWarnings("unused")
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.media.ReferencedMedia;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "Figure")
@Entity
-//@Audited
+@Audited
public class Figure extends ReferencedMedia {
private static final long serialVersionUID = -1712467725277327725L;
@SuppressWarnings("unused")
* \r
*/\r
private static final long serialVersionUID = 2651969425860655040L;\r
- \r
- private String authority;\r
\r
@NaturalId\r
+ private String authority;\r
+\r
public String getAuthority() {\r
return authority;\r
}\r
*/\r
private static final long serialVersionUID = 7216686200093054648L;\r
\r
+ @NaturalId\r
protected String name;\r
\r
+ @ManyToMany(fetch = FetchType.LAZY, mappedBy = "groups")\r
protected Set<User> members = new HashSet<User>();\r
\r
+ @ManyToMany(fetch = FetchType.LAZY, targetEntity = GrantedAuthorityImpl.class)\r
protected Set <GrantedAuthority> grantedAuthorities = new HashSet<GrantedAuthority>();\r
\r
- @ManyToMany(fetch = FetchType.LAZY, targetEntity = GrantedAuthorityImpl.class)\r
public Set<GrantedAuthority> getGrantedAuthorities() {\r
return grantedAuthorities;\r
}\r
-\r
- public void setGrantedAuthorities(Set<GrantedAuthority> grantedAuthorities) {\r
- this.grantedAuthorities = grantedAuthorities;\r
- }\r
\r
- @NaturalId\r
public void setName(String name) {\r
this.name = name;\r
}\r
return name;\r
}\r
\r
- @ManyToMany(fetch = FetchType.LAZY, mappedBy = "groups")\r
public Set<User> getMembers() {\r
return members;\r
}\r
- \r
- protected void setMembers(Set<User> members) {\r
- this.members = members;\r
- }\r
\r
public boolean addMember(User user) {\r
user.getGroups().add(this);\r
package eu.etaxonomy.cdm.model.common;
-import eu.etaxonomy.cdm.model.agent.Agent;
+import eu.etaxonomy.cdm.model.agent.AgentBase;
public interface IEvent {
public abstract void setTimeperiod(TimePeriod timeperiod);
- public abstract Agent getActor();
+ public abstract AgentBase getActor();
- public abstract void setActor(Agent actor);
+ public abstract void setActor(AgentBase actor);
}
\ No newline at end of file
\r
public interface IIdentifiableEntity {\r
\r
- public String getLsid();\r
+ public LSID getLsid();\r
\r
- public void setLsid(String lsid);\r
+ public void setLsid(LSID lsid);\r
\r
public String generateTitle();\r
\r
*/\r
public String toString();\r
\r
+ public byte[] getData();\r
+\r
}
\ No newline at end of file
--- /dev/null
+package eu.etaxonomy.cdm.model.common;
+
+import java.util.List;
+
+public interface IMultiLanguageText {
+
+ /**
+ * @param language
+ * @return
+ */
+ public abstract String getText(Language language);
+
+ /**
+ * @param languageString
+ * @return String the previous text in the MultilanguageSet that was associated with the language
+ * defined in languageString, or null if there was no such text before. (A null return can also indicate that the text was previously null.)
+ */
+ public abstract LanguageString add(LanguageString languageString);
+
+ /**
+ * Iterates on the languages. As soon as there exists a language string for this language in this multilanguage text
+ * it is returned.
+ * @param languages
+ * @return
+ */
+ public LanguageString getPreferredLanguageString(List<Language> languages);
+
+}
\ No newline at end of file
import java.util.Set;
import javax.persistence.Column;
+import javax.persistence.Embedded;
import javax.persistence.FetchType;
-import javax.persistence.ManyToMany;
import javax.persistence.MappedSuperclass;
import javax.persistence.OneToMany;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.XmlType;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.search.annotations.FieldBridge;
import org.hibernate.search.annotations.Fields;
+import eu.etaxonomy.cdm.jaxb.FormattedTextAdapter;
+import eu.etaxonomy.cdm.jaxb.LSIDAdapter;
import eu.etaxonomy.cdm.model.media.Rights;
import eu.etaxonomy.cdm.model.name.NonViralName;
-import eu.etaxonomy.cdm.model.name.TaxonNameBase;
/**
* Superclass for the primary CDM classes that can be referenced from outside via LSIDs and contain a simple generated title string as a label for human reading.
private static final Logger logger = Logger.getLogger(IdentifiableEntity.class);
@XmlTransient
- public final boolean PROTECTED = true;
+ public static final boolean PROTECTED = true;
@XmlTransient
- public final boolean NOT_PROTECTED = false;
+ public static final boolean NOT_PROTECTED = false;
- @XmlElement(name = "LSID")
- private String lsid;
+ @XmlElement(name = "LSID", type = String.class)
+ @XmlJavaTypeAdapter(LSIDAdapter.class)
+ @Embedded
+ private LSID lsid;
@XmlElement(name = "TitleCache", required = true)
+ @XmlJavaTypeAdapter(FormattedTextAdapter.class)
+ @Column(length=255, name="titleCache")
+ @Fields({@Field(index = org.hibernate.search.annotations.Index.TOKENIZED),
+ @Field(name = "titleCache_forSort", index = org.hibernate.search.annotations.Index.UN_TOKENIZED)
+ })
+ @FieldBridge(impl=StripHtmlBridge.class)
private String titleCache;
//if true titleCache will not be automatically generated/updated
@XmlElementWrapper(name = "Rights")
@XmlElement(name = "Rights")
- private Set<Rights> rights = getNewRightsSet();
+ @OneToMany(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
+ private Set<Rights> rights = new HashSet<Rights>();
@XmlElementWrapper(name = "Extensions")
@XmlElement(name = "Extension")
- private Set<Extension> extensions = getNewExtensionSet();
+ @OneToMany(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
+ private Set<Extension> extensions = new HashSet<Extension>();
@XmlElementWrapper(name = "Sources")
@XmlElement(name = "OriginalSource")
- private Set<OriginalSource> sources = getNewOriginalSourcesSet();
+ @OneToMany(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
+ private Set<OriginalSource> sources = new HashSet<OriginalSource>();
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#getLsid()
*/
- public String getLsid(){
+ public LSID getLsid(){
return this.lsid;
}
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#setLsid(java.lang.String)
*/
- public void setLsid(String lsid){
+ public void setLsid(LSID lsid){
this.lsid = lsid;
}
+ /**
+ * By default, we expect most cdm objects to be abstract things
+ * i.e. unable to return a data representation.
+ *
+ * Specific subclasses (e.g. Sequence) can override if necessary.
+ */
+ public byte[] getData() {
+ return null;
+ }
+
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#generateTitle()
*/
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#getTitleCache()
*/
- @Transient
public String getTitleCache(){
if (protectedTitleCache){
return this.titleCache;
setTitleCache(titleCache, PROTECTED);
}
- //@Index(name="titleCacheIndex")
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#getTitleCache()
- */
- @Column(length=255, name="titleCache")
- @Fields({@Field(index = org.hibernate.search.annotations.Index.TOKENIZED),
- @Field(name = "titleCache_forSort", index = org.hibernate.search.annotations.Index.UN_TOKENIZED)
- })
- @FieldBridge(impl=StripHtmlBridge.class)
- @Deprecated //for hibernate use only
- protected String getPersistentTitleCache(){
- return getTitleCache();
- }
- @Deprecated //for hibernate use only
- protected void setPersistentTitleCache(String titleCache){
- this.titleCache = titleCache;
- }
-
-
-
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#setTitleCache(java.lang.String, boolean)
*/
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#getRights()
- * FIXME do we really mean ManyToMany i.e. that objects can share
- * rights statements? This should be made explict
*/
- @ManyToMany(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
- public Set<Rights> getRights(){
- return this.rights;
- }
-
- protected void setRights(Set<Rights> rights) {
- this.rights = rights;
+ public Set<Rights> getRights() {
+ return this.rights;
}
+
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#addRights(eu.etaxonomy.cdm.model.media.Rights)
*/
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#getExtensions()
*/
- @OneToMany(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<Extension> getExtensions(){
return this.extensions;
}
- protected void setExtensions(Set<Extension> extensions) {
- this.extensions = extensions;
- }
+
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#addExtension(eu.etaxonomy.cdm.model.common.Extension)
*/
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#getSources()
*/
- @OneToMany(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<OriginalSource> getSources() {
return this.sources;
}
- protected void setSources(Set<OriginalSource> sources) {
- this.sources = sources;
- }
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#addSource(eu.etaxonomy.cdm.model.common.OriginalSource)
*/
IdentifiableEntity result = (IdentifiableEntity)super.clone();
//Extensions
- Set<Extension> newExtensions = getNewExtensionSet();
+ result.extensions = new HashSet<Extension>();
for (Extension extension : this.extensions ){
- Extension newExtension = extension.clone(this);
- newExtensions.add(newExtension);
+ Extension newExtension = (Extension)extension.clone();
+ result.addExtension(newExtension);
}
- result.setExtensions(newExtensions);
//OriginalSources
- Set<OriginalSource> newOriginalSources = getNewOriginalSourcesSet();
+ result.sources = new HashSet<OriginalSource>();
for (OriginalSource originalSource : this.sources){
- OriginalSource newSource = originalSource.clone(this);
- newOriginalSources.add(newSource);
+ OriginalSource newSource = (OriginalSource)originalSource.clone();
+ result.addSource(newSource);
}
- result.setSources(newOriginalSources);
//Rights
- Set<Rights> rights = getNewRightsSet();
- rights.addAll(this.rights);
- result.setRights(rights);
+ result.rights = new HashSet<Rights>();
+ for(Rights rights : this.rights) {
+ result.addRights(rights);
+ }
//result.setLsid(lsid);
//result.setTitleCache(titleCache);
}
return result;
}
-
- @Transient
- private Set<Extension> getNewExtensionSet(){
- return new HashSet<Extension>();
- }
-
- @Transient
- private Set<OriginalSource> getNewOriginalSourcesSet(){
- return new HashSet<OriginalSource>();
- }
-
- @Transient
- private Set<Rights> getNewRightsSet(){
- return new HashSet<Rights>();
- }
-
}
\ No newline at end of file
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
/**
* simple keywords. could be taxonomic scope/skill , geographic scope or anything else
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "Keyword")
@Entity
-//@Audited
+@Audited
public class Keyword extends OrderedTermBase<Keyword> {
private static final long serialVersionUID = -4907208557010483263L;
@SuppressWarnings("unused")
--- /dev/null
+package eu.etaxonomy.cdm.model.common;\r
+\r
+import java.util.NoSuchElementException;\r
+import java.util.StringTokenizer;\r
+\r
+import javax.persistence.Embeddable;\r
+import javax.persistence.FetchType;\r
+import javax.persistence.ManyToOne;\r
+\r
+import com.ibm.lsid.MalformedLSIDException;\r
+\r
+/**\r
+ * This class is copied from com.ibm.lsid.LSID, I needed to re-implement this since \r
+ * the domain objects are required to be Serializable\r
+ * \r
+ * \r
+ * @author Ben Szekely (<a href="mailto:bhszekel@us.ibm.com">bhszekel@us.ibm.com</a>)\r
+ * @author ben.clark\r
+ * @see com.ibm.lsid.client.LSID\r
+ */\r
+@Embeddable\r
+public class LSID {\r
+\r
+ private String lsid;\r
+ \r
+ private String authority;\r
+ \r
+ private String namespace;\r
+ \r
+ private String object;\r
+ \r
+ private String revision;\r
+ \r
+ private LSID() { }\r
+ \r
+ /**\r
+ * Construct a new LSID with the String representation.\r
+ * @param String The lsid String respresentation\r
+ */\r
+ public LSID(String lsid) throws MalformedLSIDException {\r
+ if (lsid.endsWith(":")) {\r
+ lsid = lsid.substring(0, lsid.length() - 1);\r
+ }\r
+ StringTokenizer st = new StringTokenizer(lsid, ":");\r
+ // check for urn and lsid\r
+ try {\r
+ String urn = st.nextToken().toLowerCase();\r
+ String l = st.nextToken().toLowerCase();\r
+ if (!urn.equals("urn") || !l.equals("lsid")) {\r
+ throw new MalformedLSIDException("urn:lsid: not found: [" + lsid + "]");\r
+ }\r
+ }\r
+ catch (NoSuchElementException e) {\r
+ throw new MalformedLSIDException(e, "urn:lsid: not found: [" + lsid + "]");\r
+ }\r
+\r
+ try {\r
+ authority = st.nextToken().toLowerCase();\r
+ } \r
+ catch (NoSuchElementException e) {\r
+ throw new MalformedLSIDException(e, "authority not found: [" + lsid + "]");\r
+ }\r
+\r
+ try {\r
+ namespace = st.nextToken();\r
+ }\r
+ catch (NoSuchElementException e) {\r
+ throw new MalformedLSIDException(e, "namespace not found: [" + lsid + "]");\r
+ }\r
+\r
+ try {\r
+ object = st.nextToken();\r
+ }\r
+ catch (NoSuchElementException e) {\r
+ throw new MalformedLSIDException(e, "object not found: [" + lsid + "]");\r
+ }\r
+ if (st.hasMoreTokens()) {\r
+ revision = st.nextToken();\r
+ }\r
+ \r
+ this.lsid = "urn:lsid:" + this.authority + ":" + this.namespace + ":" + this.object + (this.revision != null ? ":" + this.revision : "");\r
+ }\r
+ \r
+ /**\r
+ * Construct a new LSID with the given components\r
+ * @param String the authority\r
+ * @param String the namespace\r
+ * @param String the object\r
+ * @param String the revision, can be null\r
+ */\r
+ public LSID(String authority, String namespace, String object, String revision) throws MalformedLSIDException {\r
+ this.authority = authority.toLowerCase();\r
+ this.namespace = namespace;//.toLowerCase();\r
+ this.object = object;//.toLowerCase();\r
+ if (revision != null)\r
+ this.revision = revision;//.toLowerCase();\r
+ lsid = "urn:lsid:" + this.authority + ":" + this.namespace + ":" + this.object + (this.revision != null ? ":" + this.revision : "");\r
+ } \r
+ \r
+ /**\r
+ * Returns the lsid \r
+ * @return String The lsid String representation\r
+ */\r
+ public String getLsid() {\r
+ return lsid;\r
+ }\r
+\r
+ \r
+\r
+ /**\r
+ * Returns the authority component of the LSID\r
+ * @return LSIDAuthority the authority\r
+ */\r
+ public String getAuthority() {\r
+ return authority;\r
+ }\r
+\r
+ /**\r
+ * Returns the namespace component of the LSID\r
+ * @return String\r
+ */\r
+ public String getNamespace() {\r
+ return namespace;\r
+ }\r
+\r
+ /**\r
+ * Returns the object component of the LSID\r
+ * @return String\r
+ */\r
+ public String getObject() {\r
+ return object;\r
+ }\r
+\r
+ /**\r
+ * Returns the revision component of the LSID if it exists\r
+ * @return String\r
+ */\r
+ public String getRevision() {\r
+ return revision;\r
+ }\r
+ \r
+ /**\r
+ * return the string representation\r
+ * @return String\r
+ */\r
+ public String toString() {\r
+ return lsid;\r
+ }\r
+ \r
+ /**\r
+ * Two LSIDs are equal their string representations are equal disregarding case.\r
+ */\r
+ public boolean equals(Object lsid) {\r
+ if(this == lsid) {\r
+ return true;\r
+ } else if (lsid != null && lsid instanceof LSID) {\r
+ LSID theLSID = (LSID)lsid;\r
+ return theLSID.toString().equals(toString());\r
+ } else {\r
+ return false;\r
+ }\r
+ }\r
+}\r
--- /dev/null
+package eu.etaxonomy.cdm.model.common;\r
+\r
+import java.util.HashMap;\r
+import java.util.Map;\r
+\r
+import javax.persistence.Entity;\r
+import javax.persistence.FetchType;\r
+import javax.wsdl.Definition;\r
+\r
+import org.hibernate.annotations.CollectionOfElements;\r
+import org.hibernate.annotations.NaturalId;\r
+import org.hibernate.annotations.Type;\r
+import org.hibernate.annotations.TypeDef;\r
+import org.hibernate.annotations.TypeDefs;\r
+\r
+import com.ibm.lsid.MalformedLSIDException;\r
+\r
+@Entity\r
+@TypeDefs(@TypeDef(name="wsdlDefinitionUserType", typeClass=WSDLDefinitionUserType.class))\r
+public class LSIDAuthority extends CdmBase {\r
+\r
+ /**\r
+ * \r
+ */\r
+ private static final long serialVersionUID = 9168994979216936689L;\r
+\r
+ public static final String AUTHORITY_ID_PREFIX = "lsidauth:";\r
+ \r
+ private static final String AUTHORITY_PROTOCOL="http";\r
+ private static final String AUTHORITY_PATH="/authority/";\r
+\r
+ @NaturalId\r
+ private String authority;\r
+ \r
+ // the resolved components of the lsid\r
+ private String server;\r
+ private int port = -1;\r
+ private String url;\r
+ \r
+ // the wsdl describing how to invoke operations on the authority\r
+ @Type(type = "wsdlDefinitionUserType")\r
+ private Definition authorityWSDL;\r
+ \r
+ @CollectionOfElements(fetch = FetchType.LAZY)\r
+ private Map<String,Class<? extends IIdentifiableEntity>> namespaces = new HashMap<String,Class<? extends IIdentifiableEntity>>();\r
+ \r
+ /**\r
+ * Hibernate requires a no-arguement constructor (this could be private, I suppose)\r
+ */\r
+ private LSIDAuthority() { }\r
+ \r
+ /**\r
+ * Construct an LSID authority object.\r
+ * @param String LSID Authority must be valid authority string, or an ID of the form: lsidauth:<validauthoritystring>"\r
+ */\r
+ public LSIDAuthority(String authstr) throws MalformedLSIDException {\r
+ try {\r
+ authority = authstr.toLowerCase();\r
+ if (authority.startsWith(AUTHORITY_ID_PREFIX))\r
+ authority = authority.substring(AUTHORITY_ID_PREFIX.length());\r
+ } catch (Exception e) {\r
+ throw new MalformedLSIDException(e, "LSID Authority must be valid authority string, or of form: lsidauth:<validauthoritystring>");\r
+ } \r
+ }\r
+ \r
+ /**\r
+ * Convenience constructor, construct an LSID authority object\r
+ * @param LSID use this LSID's authority to construct this object\r
+ */\r
+ public LSIDAuthority(LSID lsid) throws MalformedLSIDException {\r
+ authority = lsid.getAuthority(); \r
+ } \r
+ \r
+ /**\r
+ * Returns the authority String\r
+ * @return String the authority String\r
+ */\r
+ public String getAuthority() {\r
+ return authority; \r
+ }\r
+ \r
+ /**\r
+ * Returns the authority ID representation of this authority, lsidauth:authstr\r
+ * @return String the ID representation\r
+ */\r
+ public String getAuthorityID() {\r
+ return AUTHORITY_ID_PREFIX + authority;\r
+ }\r
+ \r
+ /**\r
+ * Returns the authority String\r
+ * @return String the authority String\r
+ */\r
+ public String toString() {\r
+ return authority; \r
+ }\r
+ \r
+ /**\r
+ * Tests equality on the authority string\r
+ * @return\r
+ */\r
+ public boolean equals(Object o) {\r
+ if (!(o instanceof LSIDAuthority))\r
+ return false;\r
+ LSIDAuthority auth = (LSIDAuthority)o;\r
+ return o.toString().equals(toString());\r
+ }\r
+ \r
+ /**\r
+ * Returns the port of the resolved Authority, invalid until resolved.\r
+ * @return int the port.\r
+ */\r
+ public int getPort() {\r
+ return port;\r
+ }\r
+\r
+ /**\r
+ * Returns the server of the resolved Authority, invalid until resolved.\r
+ * @return String the hostname of the server\r
+ */\r
+ public String getServer() {\r
+ return server;\r
+ }\r
+ \r
+ /**\r
+ * Returns the url of the resolved Authority, invalid until resolved. This overrides the \r
+ * server and port properties, and might contain a full path or even a different protocol.\r
+ * @return String\r
+ */\r
+ public String getUrl() {\r
+ if (url == null) {\r
+ if (server != null && port != -1)\r
+ url = "http://" + getServer() + ":" + getPort() + AUTHORITY_PATH;\r
+ else\r
+ return null;\r
+ }\r
+ return url;\r
+ }\r
+\r
+ /**\r
+ * Sets the port.\r
+ * @param port The port to set\r
+ */\r
+ public void setPort(int port) {\r
+ this.port = port;\r
+ }\r
+\r
+ /**\r
+ * Sets the server.\r
+ * @param server The server to set\r
+ */\r
+ public void setServer(String server) {\r
+ this.server = server;\r
+ }\r
+ \r
+ /**\r
+ * Sets the URL to use. This overrides the server and port properties, and might contain a full path or even a \r
+ * different protocol.\r
+ * @param server The server to set\r
+ */\r
+ public void setUrl(String url) {\r
+ this.url = url;\r
+ }\r
+ \r
+ /**\r
+ * Set the wsdl describing the ports available\r
+ * @param LSIDWSDLWrapper the wsdl to set\r
+ */\r
+ public void setWSDL(Definition wsdl) {\r
+ this.authorityWSDL = wsdl;\r
+ }\r
+ \r
+ /**\r
+ * get the wsdl describing the ports available\r
+ * @return LSIDWSDLWRapper the wsdl\r
+ */\r
+ public Definition getWSDL() {\r
+ return this.authorityWSDL;\r
+ }\r
+ \r
+ /**\r
+ * @return boolean, whether or not the authority has been resolved.\r
+ */\r
+ public boolean isResolved() {\r
+ return (getUrl() != null);\r
+ }\r
+ \r
+ /**\r
+ * get the url of an authority with the given server and port\r
+ */\r
+ public String getAuthorityEnpointURL(String server, int port) {\r
+ return AUTHORITY_PROTOCOL + "://" + server + ":" + port + AUTHORITY_PATH; \r
+ }\r
+\r
+ public Map<String,Class<? extends IIdentifiableEntity>> getNamespaces() {\r
+ return namespaces;\r
+ }\r
+ \r
+ public void addNamespace(String namespace, Class<? extends IIdentifiableEntity> identifiableClass) {\r
+ this.namespaces.put(namespace, identifiableClass);\r
+ }\r
+ \r
+ public void removeNamespace(String namespace) {\r
+ this.namespaces.remove(namespace);\r
+ }\r
+}\r
--- /dev/null
+package eu.etaxonomy.cdm.model.common;\r
+\r
+import java.io.File;\r
+import java.io.IOException;\r
+import java.io.InputStream;\r
+import java.io.InputStreamReader;\r
+import java.io.Reader;\r
+import java.net.URL;\r
+\r
+import javax.wsdl.xml.WSDLLocator;\r
+\r
+import org.apache.commons.logging.Log;\r
+import org.apache.commons.logging.LogFactory;\r
+import org.xml.sax.InputSource;\r
+\r
+import com.ibm.wsdl.util.StringUtils;\r
+\r
+/**\r
+ * WSDLLocator based almost totally upon WSIFWSDLLocatorImpl by Owen Burroughs\r
+ * Created primarily because locating the required wsdl documents in the classpath \r
+ * seems like a safer thing than using a file path and relying on users remembering to\r
+ * copy the correct wsdl files into the correct places.\r
+ * \r
+ * @author ben.clark\r
+ * @author Owen Burroughs\r
+ */\r
+public class LSIDWSDLLocator implements WSDLLocator {\r
+ private static Log log = LogFactory.getLog(LSIDWSDLLocator.class);\r
+ \r
+ private Reader baseReader = null;\r
+ private Reader importReader = null;\r
+ private String contextURI = null;\r
+ private String wsdlLocation = null;\r
+ private String documentBase = null;\r
+ private String importBase = null;\r
+ private ClassLoader loader = null; \r
+\r
+ public LSIDWSDLLocator(String ctxt, String wsdlURI, ClassLoader cl) {\r
+ contextURI = ctxt;\r
+ wsdlLocation = wsdlURI;\r
+ loader = cl;\r
+ }\r
+\r
+ public LSIDWSDLLocator(String docBase, Reader reader, ClassLoader cl) {\r
+ documentBase = docBase;\r
+ baseReader = reader;\r
+ loader = cl;\r
+ }\r
+\r
+ /**\r
+ * @see javax.wsdl.xml.WSDLLocator#getBaseReader()\r
+ */\r
+ public Reader getBaseReader() {\r
+ if (baseReader == null) {\r
+ try {\r
+ URL url = null;\r
+ URL contextURL = (contextURI != null) ? StringUtils.getURL(\r
+ null, contextURI) : null;\r
+ if (loader != null) {\r
+ InputStream in = null;\r
+ try {\r
+ if (contextURL != null)\r
+ url = new URL(contextURL, wsdlLocation);\r
+ else {\r
+ if (wsdlLocation.indexOf(":") == -1)\r
+ url = new URL("file", null, wsdlLocation);\r
+ else\r
+ url = new URL(wsdlLocation);\r
+ }\r
+ String wsdlRelativeLocation = url.getPath();\r
+ if (wsdlRelativeLocation.startsWith("/"))\r
+ wsdlRelativeLocation = wsdlRelativeLocation\r
+ .substring(1);\r
+ in = loader\r
+ .getResourceAsStream(wsdlRelativeLocation);\r
+ baseReader = new InputStreamReader(in);\r
+ } catch (Exception exc) {\r
+ }\r
+ }\r
+ if (baseReader == null) {\r
+ url = StringUtils.getURL(contextURL, wsdlLocation);\r
+ baseReader = new InputStreamReader(StringUtils\r
+ .getContentAsInputStream(url));\r
+ }\r
+ if (url != null)\r
+ documentBase = url.toString();\r
+ } catch (Exception e) {\r
+ documentBase = wsdlLocation;\r
+ }\r
+ }\r
+\r
+ return baseReader;\r
+ }\r
+\r
+ /**\r
+ * @see javax.wsdl.xml.WSDLLocator#getBaseURI()\r
+ */\r
+ public String getBaseURI() {\r
+ return documentBase; \r
+ }\r
+\r
+ /**\r
+ * used to read imports as a document is parsed\r
+ * \r
+ * @see javax.wsdl.xml.WSDLLocator#getImportReader(String, String)\r
+ */\r
+ public Reader getImportReader(String base, String relativeLocation) {\r
+ // Reset importReader if finding import within import\r
+ importReader = null;\r
+ boolean triedSU = false;\r
+ try {\r
+ // If a ClassLoader was used to load the base\r
+ // document, chances\r
+ // are we need to use it to find the import.\r
+ URL url = null;\r
+ if (loader != null) {\r
+ if (relativeLocation.startsWith("/")\r
+ || relativeLocation.startsWith("\\")) {\r
+ // Relative location has been specified from a root dir.\r
+ // However,\r
+ // using a ClassLoader, root dirs don't mean anything.\r
+ relativeLocation = relativeLocation.substring(1,relativeLocation.length());\r
+ InputStream in = loader.getResourceAsStream(relativeLocation);\r
+ importReader = new InputStreamReader(in);\r
+ } else if (relativeLocation.indexOf("://") != -1) {\r
+ // This is a fully specified URL of some kind so don't\r
+ // use the\r
+ // ClassLoader to find the import.\r
+ triedSU = true;\r
+ url = StringUtils.getURL(null, relativeLocation);\r
+ importReader = new InputStreamReader(StringUtils\r
+ .getContentAsInputStream(url));\r
+ } else {\r
+ // Import location has been specified relative to the\r
+ // base document\r
+ // and so we can to try to form the complete path to it.\r
+ if (base != null) {\r
+ int i = base.lastIndexOf("/");\r
+ if (i == -1) {\r
+ i = base.lastIndexOf("\\");\r
+ }\r
+ if (i != -1) {\r
+ String path = base.substring(0, i + 1);\r
+ String resolvedPath = path + relativeLocation;\r
+ if (relativeLocation.startsWith("..")) {\r
+ resolvedPath = resolvePath(path,\r
+ relativeLocation);\r
+ }\r
+ if (resolvedPath == null) {\r
+ throw new Exception("Invalid Path");\r
+ }\r
+\r
+ // Make sure that resolved path starts with\r
+ // file:\r
+ if (resolvedPath.startsWith("file:")) {\r
+ url = new URL(null, resolvedPath);\r
+ } else {\r
+ url = new URL(null, "file:" + resolvedPath);\r
+ }\r
+ } else {\r
+ url = new URL(null, "file:" + base + File.separator + relativeLocation);\r
+ }\r
+ InputStream in = loader.getResourceAsStream(url.getPath());\r
+ importReader = new InputStreamReader(in);\r
+ } else {\r
+ url = new URL(null, "file:" + relativeLocation);\r
+ InputStream in = loader.getResourceAsStream(url.getPath());\r
+ importReader = new InputStreamReader(in);\r
+ }\r
+ }\r
+ } else {\r
+ triedSU = true;\r
+ URL contextURL = (base != null) ? StringUtils.getURL(null,\r
+ base) : null;\r
+ url = StringUtils.getURL(contextURL, relativeLocation);\r
+ importReader = new InputStreamReader(StringUtils\r
+ .getContentAsInputStream(url));\r
+ }\r
+ importBase = (url == null) ? relativeLocation : url.toString();\r
+ } catch (Exception e) {\r
+ log.error(e.toString());\r
+ log.error(e.getMessage());\r
+ // If we have not tried using a non-ClassLoader route, try it\r
+ // now\r
+ // as a last resort.\r
+ if (!triedSU) {\r
+ try {\r
+ URL contextURL = (base != null) ? StringUtils.getURL(\r
+ null, base) : null;\r
+ URL url = StringUtils.getURL(contextURL,\r
+ relativeLocation);\r
+ importReader = new InputStreamReader(StringUtils\r
+ .getContentAsInputStream(url));\r
+ importBase = (url == null) ? relativeLocation : url\r
+ .toString();\r
+ } catch (Exception e2) {\r
+ log.error(e2.toString());\r
+ log.error("Cannot find " + importBase + " so setting importBase to unknownImportURI");\r
+ // we can't find the import so set a temporary value for\r
+ // the import URI. This is\r
+ // necessary to avoid a NullPointerException in\r
+ // WSDLReaderImpl\r
+ importBase = "unknownImportURI";\r
+ }\r
+ } else {\r
+ log.error("Cannot find " + importBase + " so setting importBase to unknownImportURI");\r
+ // we can't find the import so set a temporary value for the\r
+ // import URI. This is\r
+ // necessary to avoid a NullPointerException in\r
+ // WSDLReaderImpl\r
+ importBase = "unknownImportURI";\r
+ }\r
+ }\r
+\r
+ return importReader;\r
+ }\r
+ \r
+ /**\r
+ * Resolve a path when the relative location begins with ..\r
+ */\r
+ private String resolvePath(String ba, String rel) {\r
+ StringBuffer sb = new StringBuffer(rel);\r
+ int dd = 0;\r
+ while (sb.length() > 0) {\r
+ if (sb.length() > 3 && sb.charAt(0) == '.'\r
+ && sb.charAt(1) == '.'\r
+ && (sb.charAt(2) == '/' || sb.charAt(2) == '\\')) {\r
+ dd++;\r
+ sb.delete(0, 3);\r
+ } else {\r
+ break;\r
+ }\r
+ }\r
+ StringBuffer sb2 = new StringBuffer(ba);\r
+ int j = sb2.length() - 1;\r
+ int found = 0;\r
+ for (int k = j; k >= 0; k--) {\r
+ if (k != j && (sb2.charAt(k) == '/' || sb2.charAt(k) == '\\')) {\r
+ found++;\r
+ }\r
+ if (found < dd) {\r
+ sb2.deleteCharAt(k);\r
+ } else {\r
+ break;\r
+ }\r
+ }\r
+ if (found + 1 < dd)\r
+ return null;\r
+ return sb2.toString() + sb.toString();\r
+ }\r
+\r
+ /**\r
+ * @see javax.wsdl.xml.WSDLLocator#getLatestImportURI()\r
+ */\r
+ public String getLatestImportURI() {\r
+ return importBase; \r
+ }\r
+\r
+ /**\r
+ * @see javax.wsdl.xml.WSDLLocator#getBaseInputSource()\r
+ */\r
+ public InputSource getBaseInputSource() {\r
+ return new InputSource(getBaseReader());\r
+ }\r
+\r
+ /**\r
+ * @see javax.wsdl.xml.WSDLLocator#getImportInputSource(String, String)\r
+ */\r
+ public InputSource getImportInputSource(String arg0, String arg1) {\r
+ return new InputSource(getImportReader(arg0, arg1));\r
+ }\r
+\r
+ public void close() {\r
+ if (baseReader != null)\r
+ try {\r
+ baseReader.close();\r
+ } catch (IOException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ }\r
+ if (importReader != null)\r
+ try {\r
+ importReader.close();\r
+ } catch (IOException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ }\r
+ }\r
+\r
+}\r
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
-import org.hibernate.LazyInitializationException;
+import org.hibernate.envers.Audited;
import au.com.bytecode.opencsv.CSVWriter;
@XmlType(name = "Language")
@XmlRootElement(name = "Language")
@Entity
-//@Audited
+@Audited
public class Language extends DefinedTermBase<Language> {
private static final long serialVersionUID = -5030610079904074217L;
private static final Logger logger = Logger.getLogger(Language.class);
}
@XmlAttribute(name = "iso639_1")
- private char[] iso639_1 = new char[2];
+ //TODO create userDefinedType ?
+ @Column(length=2)
+ private String iso639_1;
+
@XmlAttribute(name = "iso639_2")
- private char[] iso639_2 = new char[3];
+ //TODO create userDefinedType ?
+ @Column(length=3)
+ private String iso639_2;
public Language() {
super();
super();
this.setUuid(uuid);
}
- public Language(char[] iso639_1, char[] iso639_2, String englishLabel, String frenchLabel) throws Exception {
+ public Language(String iso639_1, String iso639_2, String englishLabel, String frenchLabel) throws Exception {
super();
- if(iso639_1.length > 2){
+ if(iso639_1 != null && iso639_1.length() > 2){
logger.warn("iso639_1 too long: "+iso639_1.toString());
}
- if(iso639_2.length > 3){
+ if(iso639_1 != null && iso639_2.length() > 3){
logger.warn("iso639_2 too long: "+iso639_2.toString());
}
this.iso639_1=iso639_1;
this.iso639_2=iso639_2;
String textEnglish = englishLabel;
String textFrench = englishLabel;
- String label = String.valueOf(iso639_2);
+ String label = iso639_2;
String labelAbbrev = null;
this.addRepresentation(new Representation(textEnglish, label, labelAbbrev, Language.ENGLISH()));
this.addRepresentation(new Representation(textFrench, label, labelAbbrev, Language.FRENCH()));
*
* @return the iso639 alpha-2 language code or null if not available
*/
- //TODO create userDefinedType ?
- @Column(length=2)
public String getIso639_1() {
-
- return String.valueOf(iso639_1);
+ return iso639_1;
}
public void setIso639_1(String iso639_1) {
if(iso639_1.length() > 2){
logger.warn("Iso639-1: "+iso639_1+" too long");
}
- this.iso639_1 = iso639_1.toCharArray();
+ this.iso639_1 = iso639_1;
}
/**
*
* @return the iso639 alpha-3 language code or null if not available
*/
- //TODO create userDefinedType ?
- @Column(length=3)
public String getIso639_2() {
- return String.valueOf(iso639_2);
+ return iso639_2;
}
public void setIso639_2(String iso639_2) {
if(iso639_2.length() > 3 ){
logger.warn("Iso639-2: "+iso639_2+" too long");
}
- this.iso639_2 = iso639_2.toCharArray();
+ this.iso639_2 = iso639_2;
}
@Override
newInstance.setIso639_1(csvLine.get(5).trim());
newInstance.setIso639_2(csvLine.get(4).trim());
//TODO could replace with generic validation
- if(iso639_1.length > 2){
+ if(iso639_1 != null && iso639_1.length() > 2){
logger.warn("Iso639-1: "+ newInstance.getIso639_1() +" from "+csvLine.get(3)+" ,"+csvLine.get(2)+" too long");
}
- if(iso639_2.length > 3 ){
+ if(iso639_2 != null && iso639_2.length() > 3 ){
logger.warn("Iso639-2: "+newInstance.getIso639_2()+" from "+csvLine.get(3)+" ,"+csvLine.get(2)+" too long");
}
*/
@Override
public String toString() {
- try {
+ if (this.getLabel() != null){
return this.getLabel();
- } catch (LazyInitializationException e) {
+ }else{
return super.toString();
}
}
package eu.etaxonomy.cdm.model.common;
+import javax.persistence.Embeddable;
import javax.persistence.Entity;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import org.hibernate.search.annotations.Indexed;
/**
@XmlType(name = "LanguageString")
@XmlRootElement(name = "LanguageString")
@Entity
-//@Audited
+@Audited
@Indexed
-public class LanguageString extends LanguageStringBase{
+public class LanguageString extends LanguageStringBase implements Cloneable {
private static final long serialVersionUID = -1502298496073201104L;
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(LanguageString.class);
}
}
-
+ @Override
+ public Object clone() throws CloneNotSupportedException {
+ LanguageString result = (LanguageString)super.clone();
+ return result;
+ }
}
\ No newline at end of file
import javax.persistence.Lob;
import javax.persistence.ManyToOne;
import javax.persistence.MappedSuperclass;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import org.apache.log4j.Logger;
import org.hibernate.search.annotations.Field;
import org.hibernate.search.annotations.FieldBridge;
import org.hibernate.search.annotations.Index;
+import eu.etaxonomy.cdm.jaxb.FormattedTextAdapter;
+
/**
* @author a.mueller
* @version 1.0
private static final Logger logger = Logger.getLogger(LanguageStringBase.class);
@XmlElement(name = "Text")
+ @XmlJavaTypeAdapter(FormattedTextAdapter.class)
+ @Column(length=4096)
+ @Field(index=Index.TOKENIZED)
+ @FieldBridge(impl=StripHtmlBridge.class)
+ @Lob
protected String text;
@XmlElement(name = "Language")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.EAGER)
protected Language language;
protected LanguageStringBase() {
}
- @ManyToOne(fetch = FetchType.EAGER)
- //@Cascade({CascadeType.SAVE_UPDATE})
public Language getLanguage(){
return this.language;
}
this.language = language;
}
- @Column(length=4096)
- @Field(index=Index.TOKENIZED)
- @FieldBridge(impl=StripHtmlBridge.class)
- @Lob
public String getText(){
return this.text;
}
this.text = text;
}
- @Transient
public String getLanguageLabel(){
if (language != null){
return this.language.getRepresentation(Language.DEFAULT()).getLabel();
return null;
}
}
- @Transient
+
public String getLanguageLabel(Language lang){
if (language != null){
return this.language.getRepresentation(lang).getLabel();
return null;
}
}
+
+ @Override
+ public Object clone() throws CloneNotSupportedException{
+ LanguageStringBase result = (LanguageStringBase) super.clone();
+ return result;
+ }
}
\ No newline at end of file
package eu.etaxonomy.cdm.model.common;
-import org.apache.log4j.Logger;
-import org.hibernate.annotations.Any;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
-
-import javax.persistence.*;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.JoinColumn;
+import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import org.apache.log4j.Logger;
+import org.hibernate.annotations.Any;
+import org.hibernate.envers.Audited;
+import org.hibernate.envers.NotAudited;
+
/**
* This class aims to make available some "flags" for identifiable entities in a
* flexible way. Application developers (and even users) can define their own
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "Marker")
@Entity
-//@Audited
+@Audited
public class Marker extends VersionableEntity implements Cloneable{
private static final long serialVersionUID = -7474489691871404610L;
@SuppressWarnings("unused")
@XmlElement(name = "MarkerType")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private MarkerType markerType;
@XmlElement(name = "MarkedObject")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @Any(metaDef = "CdmBase",
+ fetch=FetchType.LAZY,
+ metaColumn = @Column(name="markedObj_type"),
+ optional = false)
+ @JoinColumn(name = "markedObj_id")
+ @NotAudited
private AnnotatableEntity markedObj;
/**
/**
* @return
*/
- @Any(metaDef = "CdmBase",
- fetch=FetchType.LAZY,
- metaColumn = @Column(name="markedObj_type"),
- optional = false)
- @JoinColumn(name = "markedObj_id")
-// @NotAudited
public AnnotatableEntity getMarkedObj() {
return markedObj;
}
- protected void setMarkedObj(AnnotatableEntity newMarkedObject) {
+ public void setMarkedObj(AnnotatableEntity newMarkedObject) {
this.markedObj = newMarkedObject;
}
/**
* @return
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public MarkerType getMarkerType(){
return this.markerType;
}
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import java.util.*;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "MarkerType")
@Entity
-//@Audited
+@Audited
public class MarkerType extends DefinedTermBase<MarkerType> {
private static final long serialVersionUID = -9117424749919907396L;
public static final Logger logger = Logger.getLogger(MarkerType.class);
import java.util.HashMap;
import java.util.List;
-import java.util.Set;
-
-import javax.xml.bind.annotation.XmlAccessType;
-import javax.xml.bind.annotation.XmlAccessorType;
-import javax.xml.bind.annotation.XmlRootElement;
-import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
-
+import eu.etaxonomy.cdm.model.occurrence.DerivedUnitBase;
/**
* @author m.doering
* Special array that takes care that all LanguageString elements have a unique language
*/
-@XmlAccessorType(XmlAccessType.FIELD)
-@XmlType(name = "MultilanguageText")
-@XmlRootElement(name = "MultilanguageText")
-public class MultilanguageText extends HashMap<Language, LanguageString> implements Cloneable{
+public class MultilanguageText extends HashMap<Language, LanguageString> implements Cloneable, IMultiLanguageText {
private static final long serialVersionUID = 7876604337076705862L;
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(MultilanguageText.class);
* Factory method
* @return
*/
- public static MultilanguageText NewInstance(LanguageString languageString){
- MultilanguageText result = new MultilanguageText(languageString);
+ public static IMultiLanguageText NewInstance(LanguageString languageString){
+ IMultiLanguageText result = new MultilanguageText(languageString);
return result;
}
this.add(languageString);
}
-
-
- /**
- * @param language
- * @return
+ public MultilanguageText(int initialCapacity, float loadFactor) {
+ super(initialCapacity, loadFactor);
+ }
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.model.common.IMultiLanguageText#getText(eu.etaxonomy.cdm.model.common.Language)
*/
public String getText(Language language){
LanguageString languageString = super.get(language);
}
}
- /**
- * @param languageString
- * @return String the previous text in the MultilanguageSet that was associated with the language
- * defined in languageString, or null if there was no such text before. (A null return can also indicate that the text was previously null.)
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.model.common.IMultiLanguageText#add(eu.etaxonomy.cdm.model.common.LanguageString)
*/
public LanguageString add(LanguageString languageString){
if (languageString == null){
}
- /**
- * Iterates on the languages. As soon as there exists a language string for this language in this multilanguage text
- * it is returned.
- * @param languages
- * @return
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.model.common.IMultiLanguageText#getPreferredLanguageString(java.util.List)
*/
public LanguageString getPreferredLanguageString(List<Language> languages){
* @see java.lang.Object#clone()
*/
@Override
- public MultilanguageText clone(){
+ public MultilanguageText clone() {
MultilanguageText result = (MultilanguageText)super.clone();
- Set<Language> languages = super.keySet();
- for (Language language : languages){
- LanguageString languageString = super.get(language);
- this.put(language, languageString);
+
+ for (LanguageString languageString : this.values()){
+ LanguageString newLanguageString;
+ try {
+ newLanguageString = (LanguageString)languageString.clone();
+ result.put(newLanguageString.getLanguage(), newLanguageString);
+ } catch (CloneNotSupportedException e) {
+ logger.error(e);
+ }
}
//no changes to: -
return result;
package eu.etaxonomy.cdm.model.common;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-
-import org.apache.log4j.Logger;
-
+import javax.persistence.Entity;
+import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
-import javax.persistence.*;
+
+import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
/**
* @author m.doering
})
@XmlRootElement(name = "OrderedTermBase")
@Entity
-//@Audited
+@Audited
public abstract class OrderedTermBase<T extends OrderedTermBase> extends DefinedTermBase<T> implements Comparable<T> {
private static final long serialVersionUID = 8000797926720467399L;
@SuppressWarnings("unused")
}
public OrderedTermBase(String term, String label, String labelAbbrev) {
super(term, label, labelAbbrev);
- }
- private int getOrderIndex(){
- return this.orderIndex;
- }
- private void setOrderIndex(int orderIndex){
- this.orderIndex = orderIndex;
- }
+ }
/* (non-Javadoc)
* @see java.lang.Comparable#compareTo(java.lang.Object)
* @param orderedTerm
* @return boolean result of the comparison
*/
- @Transient
public boolean isLower(T orderedTerm){
return (this.compareTo(orderedTerm) < 0 );
}
* @param orderedTerm
* @return boolean result of the comparison
*/
- @Transient
public boolean isHigher(T orderedTerm){
return (this.compareTo(orderedTerm) > 0 );
}
/** To be used only by OrderedTermVocabulary*/
@Deprecated
- public boolean decreaseIndex(OrderedTermVocabulary<OrderedTermBase> vocabulary){
+ protected boolean decreaseIndex(OrderedTermVocabulary<T> vocabulary){
if (vocabulary.indexChangeAllowed(this) == true){
orderIndex--;
return true;
/** To be used only by OrderedTermVocabulary*/
@Deprecated
- public boolean incrementIndex(OrderedTermVocabulary<OrderedTermBase> vocabulary){
+ protected boolean incrementIndex(OrderedTermVocabulary<T> vocabulary){
if (vocabulary.indexChangeAllowed(this) == true){
orderIndex++;
return true;
}
@Override
- public boolean equals(Object o){
- if (! OrderedTermBase.class.isAssignableFrom(o.getClass())){
+ public boolean equals(Object object){
+ if(this == object)
+ return true;
+ if((object == null) || (!OrderedTermBase.class.isAssignableFrom(object.getClass()))) {
return false;
}else{
- OrderedTermBase otb = (OrderedTermBase)o;
- if (otb.getUuid().equals(this.getUuid())){
+ OrderedTermBase orderedTermBase = (OrderedTermBase)object;
+ if (orderedTermBase.getUuid().equals(this.getUuid())){
return true;
}else{
return false;
import javax.xml.bind.annotation.XmlType;\r
\r
import org.apache.log4j.Logger;\r
+import org.hibernate.envers.Audited;\r
\r
/**\r
* @author a.mueller\r
@XmlType(name = "OrderedTermVocabulary")\r
@XmlRootElement(name = "OrderedTermVocabulary")\r
@Entity\r
-//@Audited\r
+@Audited\r
public class OrderedTermVocabulary<T extends OrderedTermBase> extends TermVocabulary<T> {\r
private static final long serialVersionUID = 7871741306306371242L;\r
@SuppressWarnings("unused")\r
super();\r
}\r
\r
- @Transient\r
@Override\r
public Set<T> getNewTermSet() {\r
return new TreeSet<T>();\r
}\r
\r
- @Transient\r
public SortedSet<T> getOrderedTerms(T otb) {\r
SortedSet<T> result = getSortedSetOfTerms();\r
return result;\r
}\r
\r
\r
- @Transient\r
public SortedSet<T> getHigherAndEqualTerms(T otb) {\r
SortedSet<T> result = new TreeSet<T>();\r
SortedSet<T> sortedSet = getSortedSetOfTerms();\r
result.addAll( sortedSet.tailSet(otb));\r
return result;\r
}\r
- @Transient\r
+\r
public SortedSet<T> getHigherTerms(T otb) {\r
SortedSet<T> result = getHigherAndEqualTerms(otb);\r
for (T setObject : terms){\r
return result;\r
}\r
\r
- @Transient\r
public SortedSet<T> getLowerAndEqualTerms(T otb) {\r
SortedSet<T> result = new TreeSet<T>();\r
SortedSet<T> sortedSet = getSortedSetOfTerms();\r
return result;\r
}\r
\r
- @Transient\r
public SortedSet<T> getLowerTerms(T otb) {\r
SortedSet<T> result = getLowerAndEqualTerms(otb);\r
for (T setObject : terms){\r
return result;\r
}\r
\r
- @Transient\r
public SortedSet<T> getEqualTerms(T otb) {\r
SortedSet<T> result = new TreeSet<T>();\r
for (T setObject : terms){\r
return result;\r
}\r
\r
- @Transient\r
public T getNextHigherTerm(T otb) {\r
try {\r
return getHigherTerms(otb).first();\r
}\r
}\r
\r
- @Transient\r
public T getNextLowerTerm(T otb) {\r
try {\r
return getLowerTerms(otb).last();\r
}\r
}\r
\r
- @Transient\r
public T getLowestTerm() {\r
try {\r
SortedSet<T> sortedSet = getSortedSetOfTerms();\r
}\r
}\r
\r
- @Transient\r
public T getHighestTerm() {\r
try {\r
SortedSet<T> sortedSet = getSortedSetOfTerms();\r
}\r
}\r
\r
- @Override\r
public void addTerm(T term) {\r
SortedSet<T> sortedTerms = getSortedSetOfTerms();\r
int lowestOrderIndex;\r
super.removeTerm(term);\r
}\r
\r
+ @Transient\r
private T toBeChangedByObject;\r
\r
- public boolean indexChangeAllowed(T otb){\r
- return otb == toBeChangedByObject ;\r
+ public boolean indexChangeAllowed(OrderedTermBase<T> orderedTermBase){\r
+ return orderedTermBase == toBeChangedByObject ;\r
}\r
\r
\r
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Any;
+import org.hibernate.envers.Audited;
+import org.hibernate.envers.NotAudited;
import eu.etaxonomy.cdm.model.reference.ReferenceBase;
})
@XmlRootElement(name = "OriginalSource")
@Entity
-//@Audited
+@Audited
public class OriginalSource extends ReferencedEntityBase implements Cloneable {
private static final long serialVersionUID = -1972959999261181462L;
@SuppressWarnings("unused")
private String idNamespace;
@XmlTransient
+ @Any(metaDef = "CdmBase",
+ metaColumn=@Column(name = "sourcedObj_type"),
+ fetch = FetchType.LAZY,
+ optional = false)
+ @JoinColumn(name = "sourcedObj_id")
+ @NotAudited
private IdentifiableEntity sourcedObj;
/**
this.idNamespace = idNamespace;
}
-
- @Any(metaDef = "CdmBase",
- metaColumn=@Column(name = "sourcedObj_type"),
- fetch = FetchType.LAZY,
- optional = false)
- @JoinColumn(name = "sourcedObj_id")
-// @NotAudited
public IdentifiableEntity getSourcedObj() {
return sourcedObj;
}
--- /dev/null
+package eu.etaxonomy.cdm.model.common;
+
+import java.util.List;
+
+import org.hibernate.collection.PersistentMap;
+import org.hibernate.engine.SessionImplementor;
+
+public class PersistentMultiLanguageText extends PersistentMap implements IMultiLanguageText {
+
+ public PersistentMultiLanguageText(SessionImplementor sessionImplementor, MultilanguageText collection) {
+ super(sessionImplementor, collection);
+ }
+
+ public PersistentMultiLanguageText() {
+ super();
+ }
+
+ public LanguageString add(LanguageString languageString) {
+ if (languageString == null){
+ return null;
+ }else{
+ return (LanguageString)super.put(languageString.getLanguage(), languageString);
+ }
+ }
+
+ public LanguageString getPreferredLanguageString(List<Language> languages) {
+ LanguageString languageString = null;
+ for (Language language : languages) {
+ languageString = (LanguageString)super.get(language);
+ if(languageString != null){
+ return languageString;
+ }
+ }
+ return (LanguageString)super.get(Language.DEFAULT());
+ }
+
+ public String getText(Language language) {
+ LanguageString languageString = (LanguageString)super.get(language);
+ if (languageString != null){
+ return languageString.getText();
+ }else {
+ return null;
+ }
+ }
+}
--- /dev/null
+package eu.etaxonomy.cdm.model.common;
+
+import java.util.Iterator;
+import java.util.Map;
+
+import org.hibernate.HibernateException;
+import org.hibernate.collection.PersistentCollection;
+import org.hibernate.engine.SessionImplementor;
+import org.hibernate.persister.collection.CollectionPersister;
+import org.hibernate.usertype.UserCollectionType;
+
+public class PersistentMultiLanguageTextType implements UserCollectionType {
+
+ public PersistentMultiLanguageTextType() {
+ }
+
+ public boolean contains(Object collection, Object obj) {
+ Map map = (Map) collection;
+ return map.containsValue(obj);
+ }
+
+ public Iterator getElementsIterator(Object collection) {
+ return ( (java.util.Map) collection ).values().iterator();
+ }
+
+ public Object indexOf(Object collection, Object element) {
+ Iterator iter = ( (Map) collection ).entrySet().iterator();
+ while ( iter.hasNext() ) {
+ Map.Entry me = (Map.Entry) iter.next();
+ //TODO: proxies!
+ if ( me.getValue()==element ) return me.getKey();
+ }
+ return null;
+ }
+
+ public Object instantiate(int anticipatedSize) {
+ return anticipatedSize <= 0
+ ? new MultilanguageText()
+ : new MultilanguageText( anticipatedSize + (int)( anticipatedSize * .75f ), .75f );
+ }
+
+ public PersistentCollection instantiate(SessionImplementor session, CollectionPersister persister) throws HibernateException {
+ return new PersistentMultiLanguageText();
+ }
+
+ public Object replaceElements(Object original, Object target, CollectionPersister collectionPersister,
+ Object owner,Map copyCache, SessionImplementor sessionImplementor) throws HibernateException {
+
+ java.util.Map result = (java.util.Map) target;
+ result.clear();
+
+ Iterator iter = ( (java.util.Map) original ).entrySet().iterator();
+ while ( iter.hasNext() ) {
+ java.util.Map.Entry me = (java.util.Map.Entry) iter.next();
+ Object key = collectionPersister.getIndexType().replace( me.getKey(), null, sessionImplementor, owner, copyCache );
+ Object value = collectionPersister.getElementType().replace( me.getValue(), null, sessionImplementor, owner, copyCache );
+ result.put(key, value);
+ }
+
+ return result;
+ }
+
+ public PersistentCollection wrap(SessionImplementor sessionImplementor, Object collection) {
+ return new PersistentMultiLanguageText( sessionImplementor, (MultilanguageText) collection );
+ }
+
+}
@XmlElement(name = "Citation")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private ReferenceBase citation;
@XmlElement(name = "CitationMicroReference")
this.originalNameString = originalNameString;
this.citation = citation;
}
-
-
-
+
public String getCitationMicroReference(){
return this.citationMicroReference;
}
this.originalNameString = originalNameString;
}
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public ReferenceBase getCitation(){
return this.citation;
}
import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
* @author m.doering
*/
@XmlAccessorType(XmlAccessType.FIELD)
-@XmlType(name = "RelationshipBase", propOrder = { })
+@XmlType(name = "RelationshipBase")
@XmlRootElement(name = "RelationshipBase")
@MappedSuperclass
public abstract class RelationshipBase<FROM extends IRelated, TO extends IRelated, TYPE extends RelationshipTermBase> extends ReferencedEntityBase {
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(RelationshipBase.class);
- private boolean isDoubtful;
+ @XmlAttribute(name = "isDoubtful")
+ private boolean doubtful;
protected RelationshipBase(){
super();
to.addRelationship(this);
}
- @Transient
public abstract TYPE getType();
protected abstract void setType(TYPE type);
- @Transient
protected abstract FROM getRelatedFrom();
protected abstract void setRelatedFrom(FROM relatedFrom);
- @Transient
protected abstract TO getRelatedTo();
protected abstract void setRelatedTo(TO relatedTo);
* @return true, if the relationship is doubtful, false otherwise
*/
public boolean isDoubtful(){
- return this.isDoubtful;
+ return this.doubtful;
}
- public void setDoubtful(boolean isDoubtful){
- this.isDoubtful = isDoubtful;
+ public void setDoubtful(boolean doubtful){
+ this.doubtful = doubtful;
}
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import au.com.bytecode.opencsv.CSVWriter;
})
@XmlRootElement(name = "RelationshipTermBase")
@Entity
-//@Audited
+@Audited
public abstract class RelationshipTermBase<T extends RelationshipTermBase> extends OrderedTermBase<T> {
private static final long serialVersionUID = 5497187985269083971L;
@SuppressWarnings("unused")
@XmlElement(name = "InverseRepresentation")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private Set<Representation> inverseRepresentations = new HashSet();
+ @OneToMany(fetch = FetchType.LAZY)
+ @JoinTable(name="RelationshipTermBase_inverseRepresentation")
+ @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE})
+ private Set<Representation> inverseRepresentations = new HashSet<Representation>();
public RelationshipTermBase() {
super();
this.transitive = transitive;
}
-
- @OneToMany(fetch = FetchType.LAZY)
- @JoinTable(name="RelationshipTermBase_inverseRepresentation")
- @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE})
public Set<Representation> getInverseRepresentations() {
return inverseRepresentations;
}
- protected void setInverseRepresentations(
- Set<Representation> inverseRepresentations) {
- this.inverseRepresentations = inverseRepresentations;
- }
+
public void addInverseRepresentation(Representation inverseRepresentation) {
this.inverseRepresentations.add(inverseRepresentation);
}
this.addInverseRepresentation(inverseRepresentation);
}
- @Transient
public Representation getInverseRepresentation(Language lang) {
Representation result = null;
if (this.isSymmetric()){
* Inverse representation convenience methods similar to TermBase.xxx
* @see eu.etaxonomy.cdm.model.common.TermBase#getLabel()
*/
- @Transient
public String getInverseLabel() {
if(getInverseLabel(Language.DEFAULT())!=null){
return this.getInverseRepresentation(Language.DEFAULT()).getLabel();
return super.getUuid().toString();
}
- @Transient
public String getInverseLabel(Language lang) {
Representation r = this.getInverseRepresentation(lang);
if(r==null){
}
}
- @Transient
public String getInverseDescription() {
return this.getInverseRepresentation(Language.DEFAULT()).getDescription();
}
- @Transient
public String getInverseDescription(Language lang) {
return this.getInverseRepresentation(lang).getDescription();
}
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
})
@XmlRootElement(name = "Representation")
@Entity
-//@Audited
+@Audited
public class Representation extends LanguageStringBase {
private static final long serialVersionUID = -4202420199587324532L;
@SuppressWarnings("unused")
this.abbreviatedLabel = abbreviatedLabel;
}
- @Transient
public String getDescription(){
return getText();
}
+
protected void setDescription(String text) {
super.setText(text);
}
* should be used for a larger description of the label.
*/
@Override
- @Transient
public String getText(){
return super.getText();
}
@XmlElementWrapper(name = "Representations")
@XmlElement(name = "Representation")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch=FetchType.LAZY)
+ @Cascade( { CascadeType.SAVE_UPDATE, CascadeType.DELETE })
private Set<Representation> representations = new HashSet<Representation>();
public TermBase(){
this.addRepresentation(new Representation(term, label, labelAbbrev, Language.DEFAULT()) );
}
- @OneToMany(fetch=FetchType.LAZY)
- @Cascade( { CascadeType.SAVE_UPDATE, CascadeType.DELETE })
public Set<Representation> getRepresentations() {
return this.representations;
}
- public void setRepresentations(Set<Representation> representations) {
- this.representations = representations;
- }
-
public void addRepresentation(Representation representation) {
this.representations.add(representation);
}
this.representations.remove(representation);
}
- @Transient
public Representation getRepresentation(Language lang) {
for (Representation repr : representations){
Language reprLanguage = repr.getLanguage();
* @param language
* @return
*/
- @Transient
public Representation getPreferredRepresentation(Language language) {
Representation repr = getRepresentation(language);
if(repr == null){
* @param languages
* @return
*/
- @Transient
public Representation getPreferredRepresentation(List<Language> languages) {
Representation repr = null;
if(languages != null){
this.uri = uri;
}
- @Transient
public String getLabel() {
if(getLabel(Language.DEFAULT())!=null){
Representation repr = getRepresentation(Language.DEFAULT());
return super.getUuid().toString();
}
- @Transient
public String getLabel(Language lang) {
Representation repr = this.getRepresentation(lang);
return (repr == null) ? null : repr.getLabel();
}
- @Transient
public void setLabel(String label){
Language lang = Language.DEFAULT();
setLabel(label, lang);
}
- @Transient
public void setLabel(String label, Language language){
if (language != null){
Representation repr = getRepresentation(language);
}
}
-
- @Transient
public String getDescription() {
return this.getDescription(Language.DEFAULT());
}
- @Transient
public String getDescription(Language lang) {
Representation repr = this.getRepresentation(lang);
return (repr == null) ? null :repr.getDescription();
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.OneToMany;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.Type;
+import org.hibernate.envers.Audited;
/**
})
@XmlRootElement(name = "TermVocabulary")
@Entity
-//@Audited
+@Audited
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
public class TermVocabulary<T extends DefinedTermBase> extends TermBase implements Iterable<T> {
private static final long serialVersionUID = 1925052321596648672L;
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(TermVocabulary.class);
-
- public T findTermByUuid(UUID uuid){
- for(T t : terms) {
- if(t.getUuid().equals(uuid)) {
- return t;
- }
- }
- return null;
- }
-
-
-
//The vocabulary source (e.g. ontology) defining the terms to be loaded when a database is created for the first time.
// Software can go and grap these terms incl labels and description.
// UUID needed? Further vocs can be setup through our own ontology.
@XmlElement(name = "Term")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(mappedBy="vocabulary", fetch=FetchType.LAZY, targetEntity = DefinedTermBase.class)
+ @Type(type="DefinedTermBase")
+ @Cascade({CascadeType.SAVE_UPDATE})
protected Set<T> terms = getNewTermSet();
+
+ public T findTermByUuid(UUID uuid){
+ for(T t : terms) {
+ if(t.getUuid().equals(uuid)) {
+ return t;
+ }
+ }
+ return null;
+ }
public TermVocabulary(String term, String label, String labelAbbrev, String termSourceUri) {
super(term, label, labelAbbrev);
// TODO Auto-generated constructor stub
}
- @Transient
Set<T> getNewTermSet() {
return new HashSet<T>();
}
- @OneToMany(mappedBy="vocabulary", fetch=FetchType.LAZY, targetEntity = DefinedTermBase.class)
- @Type(type="DefinedTermBase")
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<T> getTerms() {
return terms;
}
- protected void setTerms(Set<T> terms) {
- this.terms = terms;
- }
public void addTerm(T term) {
term.setVocabulary(this);
* @param language
* @return
*/
- @Transient
public SortedSet<T> getTermsOrderedByLabels(Language language){
TermLanguageComparator<T> comp = new TermLanguageComparator<T>();
comp.setCompareLanguage(language);
public TermVocabulary<T> readCsvLine(List<String> csvLine) {
return readCsvLine(csvLine, Language.ENGLISH());
}
+
public TermVocabulary<T> readCsvLine(List<String> csvLine, Language lang) {
this.setUuid(UUID.fromString(csvLine.get(0)));
this.setUri(csvLine.get(1));
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Type;
import org.joda.time.Partial;
import org.joda.time.ReadableInstant;
+import eu.etaxonomy.cdm.jaxb.PartialAdapter;
+
/**
* @author m.doering
* @version 1.0
@XmlElement(name = "Start")
+ @XmlJavaTypeAdapter(value = PartialAdapter.class)
+ @Type(type="partialUserType")
private Partial start;
@XmlElement(name = "End")
+ @XmlJavaTypeAdapter(value = PartialAdapter.class)
+ @Type(type="partialUserType")
private Partial end;
* and both have a year value that is not null
* @return
*/
- @Transient
public boolean isPeriod(){
if (getStartYear() != null && getEndYear() != null ){
return true;
}
}
- //@Temporal(TemporalType.TIMESTAMP)
- @Type(type="partialUserType")
+
public Partial getStart() {
return start;
}
+
public void setStart(Partial start) {
this.start = start;
}
- //@Temporal(TemporalType.TIMESTAMP)
- @Type(type="partialUserType")
public Partial getEnd() {
return end;
}
this.end = end;
}
- @Transient
+
public String getYear(){
String result = "";
if (getStartYear() != null){
return result;
}
- @Transient
public Integer getStartYear(){
return getPartialValue(start, yearType);
}
- @Transient
public Integer getStartMonth(){
return getPartialValue(start, monthType);
}
- @Transient
public Integer getStartDay(){
return getPartialValue(start, dayType);
}
- @Transient
public Integer getEndYear(){
return getPartialValue(end, yearType);
}
- @Transient
public Integer getEndMonth(){
return getPartialValue(end, monthType);
}
- @Transient
public Integer getEndDay(){
return getPartialValue(end, dayType);
}
-
- @Transient
private Integer getPartialValue(Partial partial, DateTimeFieldType type){
if (partial == null || ! partial.isSupported(type)){
return null;
}
}
-
-
//*********** CLONE **********************************/
/* (non-Javadoc)
*/\r
private static final long serialVersionUID = 6582191171369439163L;\r
\r
+ @NaturalId\r
protected String username;\r
\r
/**\r
\r
protected String emailAddress;\r
\r
+ @ManyToMany(fetch = FetchType.LAZY, targetEntity = GrantedAuthorityImpl.class)\r
protected Set <GrantedAuthority> grantedAuthorities = new HashSet<GrantedAuthority>();\r
\r
+ @ManyToMany(fetch = FetchType.LAZY)\r
protected Set<Group> groups = new HashSet<Group>();\r
\r
protected boolean enabled;\r
\r
protected boolean accountNonLocked; \r
\r
+ @Transient\r
private GrantedAuthority[] authorities;\r
\r
private void initAuthorities() {\r
authorities = allAuthorities.toArray(new GrantedAuthority[allAuthorities.size()]);\r
}\r
\r
- @Transient\r
public GrantedAuthority[] getAuthorities() {\r
if(authorities == null) initAuthorities();\r
return authorities;\r
return password;\r
}\r
\r
- @NaturalId\r
public String getUsername() {\r
return username;\r
}\r
this.emailAddress = emailAddress;\r
}\r
\r
- @ManyToMany(fetch = FetchType.LAZY, targetEntity = GrantedAuthorityImpl.class)\r
public Set<GrantedAuthority> getGrantedAuthorities() {\r
return grantedAuthorities;\r
}\r
initAuthorities();\r
}\r
\r
- @ManyToMany(fetch = FetchType.LAZY)\r
public Set<Group> getGroups() {\r
return groups;\r
}\r
import javax.persistence.MappedSuperclass;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
-import javax.persistence.Transient;
-import javax.persistence.Version;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
-import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlIDREF;
+import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.XmlType;
// "updated",
"updatedBy"
})
-@XmlRootElement(name = "VersionableEntity")
@MappedSuperclass
public abstract class VersionableEntity extends CdmBase {
private static final long serialVersionUID = 1409299200302758513L;
// There is a problem with "updated" during deserialization because of the @Version annotation.
@XmlTransient
//@XmlElement(name ="Updated")
+ @Temporal(TemporalType.TIMESTAMP)
+ @Basic(fetch = FetchType.LAZY)
private Calendar updated;
@XmlElement(name = "UpdatedBy")
+ @XmlIDREF
+ @XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Person updatedBy;
- @ManyToOne(fetch=FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Person getUpdatedBy(){
return this.updatedBy;
}
*
* @return
*/
- @Temporal(TemporalType.TIMESTAMP)
- @Basic(fetch = FetchType.LAZY)
public Calendar getUpdated(){
return this.updated;
}
public void setUpdated(Calendar updated){
this.updated = updated;
}
-
- /**
- * based on created
- */
- @Transient
- public Calendar getValidFrom(){
- return null;
- }
-
- /**
- * based on updated
- */
- @Transient
- public Calendar getValidTo(){
- return null;
- }
/**
* Is true if UUID and created timestamp are the same for the passed Object and this one.
--- /dev/null
+package eu.etaxonomy.cdm.model.common;\r
+\r
+import java.io.Reader;\r
+import java.io.Serializable;\r
+import java.io.StringReader;\r
+import java.io.StringWriter;\r
+import java.sql.Clob;\r
+import java.sql.PreparedStatement;\r
+import java.sql.ResultSet;\r
+import java.sql.SQLException;\r
+import java.sql.Types;\r
+\r
+import javax.wsdl.Definition;\r
+import javax.wsdl.WSDLException;\r
+import javax.wsdl.factory.WSDLFactory;\r
+import javax.wsdl.xml.WSDLLocator;\r
+import javax.wsdl.xml.WSDLReader;\r
+import javax.wsdl.xml.WSDLWriter;\r
+\r
+import org.apache.commons.logging.Log;\r
+import org.apache.commons.logging.LogFactory;\r
+import org.hibernate.Hibernate;\r
+import org.hibernate.HibernateException;\r
+import org.hibernate.usertype.UserType;\r
+\r
+import com.ibm.wsdl.factory.WSDLFactoryImpl;\r
+\r
+/**\r
+ * UserType which allows persistence of a wsdl definition - used to persist the \r
+ * wsdl definition of an LSIDAuthority\r
+ * \r
+ * @author ben\r
+ *\r
+ * @see org.cateproject.model.lsid.PersistableLSIDAuthority\r
+ * @see org.hibernate.usertype.UserType UserType\r
+ * @see javax.wsdl.Definition Definition\r
+ */\r
+public class WSDLDefinitionUserType implements UserType {\r
+ private static Log log = LogFactory.getLog(WSDLDefinitionUserType.class);\r
+ private static final int[] TYPES = { Types.CLOB };\r
+\r
+ public Object deepCopy(Object o) throws HibernateException {\r
+ \r
+ if (o == null) {\r
+ return null;\r
+ }\r
+ \r
+ Definition d = (Definition) o;\r
+\r
+ try {\r
+ WSDLFactory wsdlFactory = WSDLFactoryImpl.newInstance();\r
+ StringWriter stringWriter = new StringWriter();\r
+ WSDLWriter writer = wsdlFactory.newWSDLWriter();\r
+ writer.writeWSDL(d, stringWriter);\r
+ WSDLReader wsdlReader = wsdlFactory.newWSDLReader();\r
+ Reader reader = new StringReader(stringWriter.getBuffer().toString());\r
+ WSDLLocator locator = new LSIDWSDLLocator("wsdl",reader,Thread.currentThread().getContextClassLoader());\r
+ Definition definition = wsdlReader.readWSDL(locator);\r
+ return definition;\r
+ } catch (Exception e) {\r
+ throw new HibernateException(e);\r
+ }\r
+ }\r
+\r
+ public Object assemble(Serializable cached, Object owner) throws HibernateException {\r
+ try {\r
+ WSDLFactory wsdlFactory = WSDLFactoryImpl.newInstance();\r
+ WSDLReader wsdlReader = wsdlFactory.newWSDLReader();\r
+ Reader reader = new StringReader(cached.toString());\r
+ WSDLLocator locator = new LSIDWSDLLocator("wsdl",reader,Thread.currentThread().getContextClassLoader());\r
+ Definition definition = wsdlReader.readWSDL(locator);\r
+ return definition;\r
+ } catch (Exception e) {\r
+ throw new HibernateException(e);\r
+ }\r
+ }\r
+ \r
+ public Serializable disassemble(Object value) throws HibernateException {\r
+ try {\r
+ WSDLFactory wsdlFactory = WSDLFactoryImpl.newInstance();\r
+ Definition definition = (Definition) value;\r
+ StringWriter stringWriter = new StringWriter();\r
+ WSDLWriter writer = wsdlFactory.newWSDLWriter();\r
+ writer.writeWSDL(definition, stringWriter);\r
+ return stringWriter.getBuffer().toString();\r
+ } catch (WSDLException e) {\r
+ throw new HibernateException(e);\r
+ }\r
+ }\r
+\r
+ public boolean equals(Object x, Object y) throws HibernateException {\r
+ return (x == y) || (x != null && y != null && (x.equals(y)));\r
+ }\r
+\r
+ public int hashCode(Object x) throws HibernateException {\r
+ return x.hashCode();\r
+ }\r
+\r
+ public boolean isMutable() {\r
+ return true;\r
+ }\r
+\r
+ public Object nullSafeGet(ResultSet resultSet, String[] names, Object o)\r
+ throws HibernateException, SQLException {\r
+ Clob val = (Clob) resultSet.getClob(names[0]);\r
+ if(val == null) {\r
+ return null;\r
+ } else {\r
+ try {\r
+ WSDLFactory wsdlFactory = WSDLFactoryImpl.newInstance();\r
+ WSDLReader wsdlReader = wsdlFactory.newWSDLReader();\r
+ Reader reader = val.getCharacterStream();\r
+ WSDLLocator locator = new LSIDWSDLLocator("wsdl",reader,Thread.currentThread().getContextClassLoader());\r
+ Definition definition = wsdlReader.readWSDL(locator);\r
+ return definition;\r
+ } catch (Exception e) {\r
+ throw new HibernateException(e);\r
+ }\r
+ }\r
+ }\r
+\r
+ public void nullSafeSet(PreparedStatement preparedStatement, Object o, int index)\r
+ throws HibernateException, SQLException {\r
+ if (null == o) { \r
+ preparedStatement.setNull(index, Types.CLOB); \r
+ } else { \r
+ try {\r
+ Definition definition = (Definition) o;\r
+ WSDLFactory wsdlFactory = WSDLFactoryImpl.newInstance();\r
+ StringWriter stringWriter = new StringWriter();\r
+ WSDLWriter writer = wsdlFactory.newWSDLWriter();\r
+ writer.writeWSDL(definition, stringWriter);\r
+ preparedStatement.setClob(index, Hibernate.createClob(stringWriter.getBuffer().toString()));\r
+ } catch (WSDLException e) {\r
+ throw new HibernateException(e);\r
+ }\r
+ \r
+ }\r
+ }\r
+\r
+ public Object replace(Object original, Object target, Object owner)\r
+ throws HibernateException {\r
+ return original;\r
+ }\r
+\r
+ public Class returnedClass() {\r
+ return Definition.class;\r
+ }\r
+\r
+ public int[] sqlTypes() {\r
+ return TYPES;\r
+ }\r
+\r
+}\r
--- /dev/null
+package eu.etaxonomy.cdm.model.common.init;\r
+\r
+import java.util.UUID;\r
+\r
+import eu.etaxonomy.cdm.model.common.DefinedTermBase;\r
+import eu.etaxonomy.cdm.model.common.ILoadableTerm;\r
+import eu.etaxonomy.cdm.model.common.TermVocabulary;\r
+\r
+/**\r
+ * Terms, vocabularies, and representations loaded during termloading by class TermLoader added \r
+ * by the user maybe stored and accessed through this interface.\r
+ * Care must be taken as TermLoader indirectly calls getTermByUuid(uuid) for the default \r
+ * language uuid during the loading process. So make sure that initialize() and getTermByUuid(uuid) \r
+ * are not implemeted in an endless recursion!\r
+ * \r
+ * @author a.mueller\r
+ *\r
+ */\r
+public interface IVocabularyStore {\r
+ \r
+ /**\r
+ * TODO\r
+ * @param vocabulary\r
+ */\r
+ public void saveOrUpdate(TermVocabulary vocabulary);\r
+ \r
+ \r
+ \r
+ /**\r
+ * TODO\r
+ * @param term\r
+ */\r
+ public void saveOrUpdate(ILoadableTerm term);\r
+\r
+ \r
+ /** ATTENTION: Be aware that TermLoader indirectly calls getTermByUuid(uuid)\r
+ * for the default language. So make sure that before loading the Terms by the\r
+ * TermLoader getTermByUuid() returns a valid Object without going to endless recursion.\r
+ * @param uuid the definedTermBases UUID\r
+ * @return the DefinedTermBase to return\r
+ */\r
+ public DefinedTermBase getTermByUuid(UUID uuid);\r
+ \r
+ public <T extends DefinedTermBase> T getTermByUuid(UUID uuid, Class<T> clazz);\r
+ \r
+ /**\r
+ * @param uuid\r
+ * @return\r
+ */\r
+ public TermVocabulary getVocabularyByUuid(UUID uuid);\r
+ \r
+ /** Initializes the IVocabularStore by making sure that all basic terms that are\r
+ * loaded by the TermLoader are available afterwards.\r
+ * ATTENTION: Be aware that TermLoader indirectly calls getTermByUuid(uuid)\r
+ * for the default language. So make sure that before loading the Terms by the\r
+ * TermLoader getTermByUuid() returns a valid Object without going to endless recursion.\r
+ * @return true if terms where successfully loaded\r
+ */\r
+ public boolean initialize();\r
+\r
+}\r
/* Package Annotations*/\r
\r
+@javax.xml.bind.annotation.XmlSchema(namespace = "http://etaxonomy.eu/cdm/model/common/1.0", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)\r
@GenericGenerator(\r
name="system-increment", \r
strategy = "increment"\r
metaType="string", \r
idType="integer",\r
metaValues={\r
- @MetaValue(value = "Institution", targetEntity = Institution.class),\r
- @MetaValue(value = "Person", targetEntity = Person.class),\r
- @MetaValue(value = "Team", targetEntity = Team.class),\r
- @MetaValue(value = "Annotation", targetEntity = Annotation.class),\r
- @MetaValue(value = "TaxonDescription", targetEntity = TaxonDescription.class),\r
- @MetaValue(value = "SpecimenDescription", targetEntity = SpecimenDescription.class),\r
- @MetaValue(value = "Synonym", targetEntity = Synonym.class),\r
- @MetaValue(value = "Taxon", targetEntity = Taxon.class)\r
+ @MetaValue(value = "eu.etaxonomy.cdm.model.agent.Institution", targetEntity = Institution.class),\r
+ @MetaValue(value = "eu.etaxonomy.cdm.model.agent.Person", targetEntity = Person.class),\r
+ @MetaValue(value = "eu.etaxonomy.cdm.model.agent.Team", targetEntity = Team.class),\r
+ @MetaValue(value = "eu.etaxonomy.cdm.model.common.Annotation", targetEntity = Annotation.class),\r
+ @MetaValue(value = "eu.etaxonomy.cdm.model.description.TaxonDescription", targetEntity = TaxonDescription.class),\r
+ @MetaValue(value = "eu.etaxonomy.cdm.model.description.SpecimenDescription", targetEntity = SpecimenDescription.class),\r
+ @MetaValue(value = "eu.etaxonomy.cdm.model.taxon.Synonym", targetEntity = Synonym.class),\r
+ @MetaValue(value = "eu.etaxonomy.cdm.model.taxon.Taxon", targetEntity = Taxon.class)\r
})\r
package eu.etaxonomy.cdm.model.common;\r
\r
import java.util.UUID;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
@XmlType(name = "AbsenceTerm")
@XmlRootElement(name = "AbsenceTerm")
@Entity
-//@Audited
+@Audited
public class AbsenceTerm extends PresenceAbsenceTermBase<AbsenceTerm> {
private static final long serialVersionUID = -7145360212307512860L;
private static final Logger logger = Logger.getLogger(AbsenceTerm.class);
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
/**
* This class represents information pieces expressed in categorical type of
})
@XmlRootElement(name = "CategoricalData")
@Entity
-//@Audited
+@Audited
public class CategoricalData extends DescriptionElementBase {
private static final long serialVersionUID = -6298361966947668998L;
private static final Logger logger = Logger.getLogger(CategoricalData.class);
@XmlElementWrapper(name = "States")
@XmlElement(name = "State")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
private List<StateData> states = new ArrayList<StateData>();
* Returns the (ordered) list of {@link State states} describing the {@link Feature feature}
* corresponding to <i>this</i> categorical data.
*/
- @ManyToMany(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public List<StateData> getStates(){
return this.states;
}
- /**
- * @see #getStates()
- */
- @SuppressWarnings("unused")
- private void setStates(List<StateData> states){
- this.states = states;
- }
+
/**
* Adds a {@link State state} to the list of {@link #getStates() states}
* describing the {@link Feature feature} corresponding to <i>this</i> categorical data.
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.Language;
-import eu.etaxonomy.cdm.model.common.MultilanguageText;
+
import eu.etaxonomy.cdm.model.taxon.Taxon;
/**
})
@XmlRootElement(name = "CommonTaxonName")
@Entity
-//@Audited
+@Audited
public class CommonTaxonName extends DescriptionElementBase {
private static final long serialVersionUID = 2643808051976643339L;
private static final Logger logger = Logger.getLogger(CommonTaxonName.class);
@XmlElement(name = "Language")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private Language language;
/**
/**
* Returns the {@link Language language} used for <i>this</i> common name.
*/
- @ManyToOne(fetch = FetchType.LAZY)
public Language getLanguage(){
return this.language;
}
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import org.hibernate.search.annotations.Indexed;
-import org.hibernate.search.annotations.IndexedEmbedded;
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
"describedSpecimenOrObservations",
"descriptionSources",
"descriptiveSystem",
- "descriptionElements"
+ "elements"
})
@Entity
-//@Audited
+@Audited
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@Indexed
public abstract class DescriptionBase extends IdentifiableEntity {
@XmlElementWrapper(name = "DescribedSpecimenOrObservations")
@XmlElement(name = "DescribedSpecimenOrObservation")
@XmlIDREF
- @XmlSchemaType(name = "IDREF")
+ @XmlSchemaType(name="IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
private Set<SpecimenOrObservationBase> describedSpecimenOrObservations = new HashSet<SpecimenOrObservationBase>();
@XmlElementWrapper(name = "DescriptionSources")
@XmlElement(name = "DescriptionSource")
+ @XmlIDREF
+ @XmlSchemaType(name="IDREF")
+ @ManyToMany(fetch = FetchType.LAZY) //FIXME what is the difference between this and IdentifiableEntity.sources
private Set<ReferenceBase> descriptionSources = new HashSet<ReferenceBase>();
@XmlElementWrapper(name = "DescriptiveSystem")
@XmlElement(name = "Feature")
+ @ManyToMany(fetch = FetchType.LAZY) //FIXME
+ @Cascade( { CascadeType.SAVE_UPDATE })
+ @JoinTable(name = "DescriptionBase_Feature")
private Set<Feature> descriptiveSystem = new HashSet<Feature>();
@XmlElementWrapper(name = "DescriptionElements")
@XmlElement(name = "TaxonInteraction", namespace = "http://etaxonomy.eu/cdm/model/description/1.0", type = TaxonInteraction.class),
@XmlElement(name = "TextData", namespace = "http://etaxonomy.eu/cdm/model/description/1.0", type = TextData.class)
})
- private Set<DescriptionElementBase> descriptionElements = new HashSet<DescriptionElementBase>();
+ @OneToMany(fetch=FetchType.LAZY, mappedBy = "inDescription")
+ @Cascade( { CascadeType.SAVE_UPDATE })
+ private Set<DescriptionElementBase> elements = new HashSet<DescriptionElementBase>();
/**
* Returns the set of {@link SpecimenOrObservationBase specimens or observations} involved in
* @see #addDescribedSpecimenOrObservations(SpecimenOrObservationBase)
* @see #removeDescribedSpecimenOrObservations(SpecimenOrObservationBase)
*/
- @ManyToMany(fetch = FetchType.LAZY)
public Set<SpecimenOrObservationBase> getDescribedSpecimenOrObservations() {
return describedSpecimenOrObservations;
}
-
- /**
- * @see #getDescribedSpecimenOrObservations()
- * @see #addDescribedSpecimenOrObservations(SpecimenOrObservationBase)
- */
- public void setDescribedSpecimenOrObservations(
- Set<SpecimenOrObservationBase> describedSpecimenOrObservations) {
- this.describedSpecimenOrObservations = describedSpecimenOrObservations;
- }
/**
* Adds an existing {@link SpecimenOrObservationBase specimen or observation} to the set of
* @see #addDescriptionSource(ReferenceBase)
* @see #removeDescriptionSource(ReferenceBase)
*/
- @ManyToMany(fetch = FetchType.LAZY) //FIXME
- @Cascade( { CascadeType.SAVE_UPDATE })
public Set<ReferenceBase> getDescriptionSources() {
return this.descriptionSources;
}
- /**
- * @see #getDescriptionSources()
- * @see #addDescriptionSource(ReferenceBase)
- */
- protected void setDescriptionSources(Set<ReferenceBase> descriptionSources) {
- this.descriptionSources = descriptionSources;
- }
-
/**
* Adds an existing {@link ReferenceBase reference} to the set of
* {@link #getDescriptionSources() references} used as sources for <i>this</i>
* @see #addElement(DescriptionElementBase)
* @see #removeElement(DescriptionElementBase)
*/
- @OneToMany(fetch=FetchType.LAZY, mappedBy = "inDescription")
- @Cascade( { CascadeType.SAVE_UPDATE })
public Set<DescriptionElementBase> getElements() {
- return this.descriptionElements;
- }
-
- /**
- * @see #getElements()
- * @see #addElement(DescriptionElementBase)
- */
- protected void setElements(Set<DescriptionElementBase> element) {
- this.descriptionElements = element;
- if (element == null){
- this.setElements(new HashSet<DescriptionElementBase>());
- }
+ return this.elements;
}
/**
*/
public void addElement(DescriptionElementBase element) {
element.setInDescription(this);
- this.descriptionElements.add(element);
+ this.elements.add(element);
}
/**
* @see #addElement(DescriptionElementBase)
*/
public void removeElement(DescriptionElementBase element) {
- this.descriptionElements.remove(element);
+ this.elements.remove(element);
element.setInDescription(null);
}
* @return the number of elements of the elementary description data set
*/
public int size(){
- return this.descriptionElements.size();
+ return this.elements.size();
}
/**
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
import eu.etaxonomy.cdm.model.taxon.Taxon;
+import eu.etaxonomy.cdm.model.common.IMultiLanguageText;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.LanguageString;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import org.hibernate.search.annotations.Indexed;
import org.hibernate.search.annotations.IndexedEmbedded;
"inDescription"
})
@Entity
-//@Audited
+@Audited
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@Indexed
-public abstract class DescriptionElementBase extends ReferencedEntityBase implements IMediaEntity{
+public abstract class DescriptionElementBase extends ReferencedEntityBase implements IMediaEntity {
private static final long serialVersionUID = 5000910777835755905L;
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(DescriptionElementBase.class);
-
- // ************* CONSTRUCTORS *************/
- /**
- * Class constructor: creates a new empty description element instance.
- *
- * @see #DescriptionElementBase(Feature)
- */
- protected DescriptionElementBase(){
- }
-
- /**
- * Class constructor: creates a new description element instance with the
- * given {@link Feature feature} that is described or measured.
- *
- * @param feature the feature described or measured
- * @see #DescriptionElementBase()
- */
- protected DescriptionElementBase(Feature feature){
- if (feature == null){
- feature = Feature.UNKNOWN();
- }
- this.feature = feature;
- }
-
//type, category of information. In structured descriptions characters
@XmlElement(name = "Feature")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @IndexedEmbedded
private Feature feature;
@XmlElementWrapper(name = "Modifiers")
@XmlElement(name = "Modifier")
+ @XmlIDREF
+ @XmlSchemaType(name = "IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
+ @JoinTable(name="DescriptionElementBase_Modifier")
private Set<Modifier> modifiers = new HashSet<Modifier>();
@XmlElement(name = "ModifyingText")
@XmlJavaTypeAdapter(MultilanguageTextAdapter.class)
- private MultilanguageText modifyingText;
+ @OneToMany(fetch = FetchType.LAZY)
+ @JoinTable(name = "DescriptionElementBase_ModifyingText")
+ private Map<Language,LanguageString> modifyingText = new HashMap<Language,LanguageString>();
@XmlElementWrapper(name = "Media")
@XmlElement(name = "Medium")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
private Set<Media> media = new HashSet<Media>();
@XmlElement(name = "InDescription")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
+ @IndexedEmbedded
private DescriptionBase inDescription;
+ // ************* CONSTRUCTORS *************/
+ /**
+ * Class constructor: creates a new empty description element instance.
+ *
+ * @see #DescriptionElementBase(Feature)
+ */
+ protected DescriptionElementBase(){
+ }
+
+ /**
+ * Class constructor: creates a new description element instance with the
+ * given {@link Feature feature} that is described or measured.
+ *
+ * @param feature the feature described or measured
+ * @see #DescriptionElementBase()
+ */
+ protected DescriptionElementBase(Feature feature){
+ if (feature == null){
+ feature = Feature.UNKNOWN();
+ }
+ this.feature = feature;
+ }
/**
* Returns the set of {@link Media media} (that is pictures, movies,
* recorded sounds ...) <i>this</i> description element is based on.
*/
- @ManyToMany(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<Media> getMedia(){
return this.media;
}
- /**
- * @see #getMedia()
- */
- protected void setMedia(Set<Media> media) {
- this.media = media;
- }
+
/**
* Adds a {@link Media media} to the set of {@link #getMedia() media}
* <i>this</i> description element is based on.
* part of.
* @return
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
- @IndexedEmbedded
public DescriptionBase getInDescription() {
return this.inDescription;
}
/**
- * Sets the {@link DescriptionBase description} that <i>this</i> DescriptionElement
- * is part of
- *
- * @param description the {@link DescriptionBase description} that <i>this</i>
- * DescriptionElement is part of
+ * @see #setInDescription()
*/
protected void setInDescription(DescriptionBase inDescription) {
this.inDescription = inDescription;
}
-
/**
* Does exactly the same as getFeature().
+ * @author ben.clark
+ * FIXME Is there a need to have two methods with different names which do the same thing?
*
* @see #getFeature()
*/
- @Transient
public Feature getType(){
return this.getFeature();
}
* A feature is a property that can be described or measured but not the
* description or the measurement itself.
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade(CascadeType.SAVE_UPDATE)
- @IndexedEmbedded
public Feature getFeature(){
return this.feature;
}
+
/**
* @see #getFeature()
*/
this.feature = feature;
}
-
/**
* Returns the set of {@link Modifier modifiers} used to qualify the validity of
* <i>this</i> description element. This is only metainformation.
*/
- @OneToMany(fetch = FetchType.LAZY)
- @JoinTable(name="DescriptionElementBase_Modifier")
public Set<Modifier> getModifiers(){
return this.modifiers;
}
- /**
- * @see #getModifiers()
- */
- protected void setModifiers(Set<Modifier> modifiers){
- this.modifiers = modifiers;
- }
+
/**
* Adds a {@link Modifier modifier} to the set of {@link #getModifiers() modifiers}
* used to qualify the validity of <i>this</i> description element.
* stored in the modifying text. This is only metainformation
* (like "Some experts express doubt about this assertion").
*/
- public MultilanguageText getModifyingText(){
+ public Map<Language,LanguageString> getModifyingText(){
return this.modifyingText;
}
- /**
- * @see #getModifyingText()
- */
- protected void setModifyingText(MultilanguageText modifyingText){
- this.modifyingText = modifyingText;
- }
+
/**
* Adds a translated {@link LanguageString text in a particular language}
* to the {@link MultilanguageText multilanguage text} used to qualify the validity
* @see #addModifyingText(String, Language)
*/
public LanguageString addModifyingText(LanguageString description){
- return this.modifyingText.add(description);
+ return this.modifyingText.put(description.getLanguage(),description);
}
/**
* Creates a {@link LanguageString language string} based on the given text string
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.location.NamedArea;
import eu.etaxonomy.cdm.model.taxon.Taxon;
})
@XmlRootElement(name = "Distribution")
@Entity
-//@Audited
+@Audited
public class Distribution extends DescriptionElementBase {
private static final long serialVersionUID = 8366462435651559730L;
@SuppressWarnings("unused")
@XmlElement(name = "NamedArea")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private NamedArea area;
@XmlElement(name = "PresenceAbsenceStatus")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private PresenceAbsenceTermBase<?> status;
return result;
}
-
-
-
/**
* Deprecated because {@link Feature feature} should always be {@link Feature#DISTRIBUTION() DISTRIBUTION}
* for all distribution instances.
/**
* Returns the {@link NamedArea named area} <i>this</i> distribution applies to.
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public NamedArea getArea(){
return this.area;
}
/**
* Returns the {@link PresenceAbsenceTermBase presence or absence term} for <i>this</i> distribution.
*/
- @ManyToOne(fetch = FetchType.LAZY)
public PresenceAbsenceTermBase<?> getStatus(){
return this.status;
}
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
-import eu.etaxonomy.cdm.model.common.ILoadableTerm;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import eu.etaxonomy.cdm.model.name.BotanicalName;
})
@XmlRootElement(name = "Feature")
@Entity
-//@Audited
+@Audited
public class Feature extends DefinedTermBase<Feature> {
private static final long serialVersionUID = 6754598791831848704L;
private static final Logger logger = Logger.getLogger(Feature.class);
@XmlElement(name = "SupportsCommonTaxonName")
private boolean supportsCommonTaxonName;
+ /*
+ * FIXME Should this be Many-To-Many or do we expect each Feature to have its own unique modifier enums?
+ */
@XmlElementWrapper(name = "RecommendedModifierEnumerations")
@XmlElement(name = "RecommendedModifierEnumeration")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch = FetchType.LAZY)
+ @JoinTable(name="DefinedTermBase_RecommendedModifierEnumeration")
private Set<TermVocabulary<Modifier>> recommendedModifierEnumeration = new HashSet<TermVocabulary<Modifier>>();
@XmlElementWrapper(name = "RecommendedStatisticalMeasures")
@XmlElement(name = "RecommendedStatisticalMeasure")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
+ @JoinTable(name="DefinedTermBase_StatisticalMeasure")
private Set<StatisticalMeasure> recommendedStatisticalMeasures = new HashSet<StatisticalMeasure>();
+ /*
+ * FIXME Should this be Many-To-Many or do we expect each Feature to have its own unique state enums?
+ */
@XmlElementWrapper(name = "SupportedCategoricalEnumerations")
@XmlElement(name = "SupportedCategoricalEnumeration")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch = FetchType.LAZY)
+ @JoinTable(name="DefinedTermBase_SupportedCategoricalEnumeration")
private Set<TermVocabulary<State>> supportedCategoricalEnumerations = new HashSet<TermVocabulary<State>>();
/* ***************** CONSTRUCTOR AND FACTORY METHODS **********************************/
*
* @return the boolean value of the supportsQuantitativeData flag
*/
- public boolean isSupportsQuantitativeData() {
+ public boolean supportsQuantitativeData() {
return supportsQuantitativeData;
}
*
* @return the boolean value of the supportsTextData flag
*/
- public boolean isSupportsTextData() {
+ public boolean supportsTextData() {
return supportsTextData;
}
*
* @return the boolean value of the supportsDistribution flag
*/
- public boolean isSupportsDistribution() {
+ public boolean supportsDistribution() {
return supportsDistribution;
}
*
* @return the boolean value of the supportsIndividualAssociation flag
*/
- public boolean isSupportsIndividualAssociation() {
+ public boolean supportsIndividualAssociation() {
return supportsIndividualAssociation;
}
*
* @return the boolean value of the supportsTaxonInteraction flag
*/
- public boolean isSupportsTaxonInteraction() {
+ public boolean supportsTaxonInteraction() {
return supportsTaxonInteraction;
}
*
* @return the boolean value of the supportsCommonTaxonName flag
*/
- public boolean isSupportsCommonTaxonName() {
+ public boolean supportsCommonTaxonName() {
return supportsCommonTaxonName;
}
* {@link Modifier modifiers} recommended to be used for {@link DescriptionElementBase description elements}
* with <i>this</i> feature.
*
- * FIXME Should this be Many-To-Many or do we expect each Feature to have its own unique modifier enums?
*/
- @OneToMany(fetch = FetchType.LAZY)
- @JoinTable(name="DefinedTermBase_RecommendedModifierEnumeration")
public Set<TermVocabulary<Modifier>> getRecommendedModifierEnumeration() {
return recommendedModifierEnumeration;
}
- /**
- * @see #getRecommendedModifierEnumeration()
- */
- protected void setRecommendedModifierEnumeration(
- Set<TermVocabulary<Modifier>> recommendedModifierEnumeration) {
- this.recommendedModifierEnumeration = recommendedModifierEnumeration;
- }
-
/**
* Adds a {@link TermVocabulary term vocabulary} (with {@link Modifier modifiers}) to the set of
* {@link #getRecommendedModifierEnumeration() recommended modifier vocabularies} assigned
* Returns the set of {@link StatisticalMeasure statistical measures} recommended to be used
* in case of {@link QuantitativeData quantitative data} with <i>this</i> feature.
*/
- @ManyToMany(fetch = FetchType.LAZY)
- @JoinTable(name="DefinedTermBase_StatisticalMeasure")
-// @Cascade({CascadeType.SAVE_UPDATE})
public Set<StatisticalMeasure> getRecommendedStatisticalMeasures() {
return recommendedStatisticalMeasures;
}
- /**
- * @see #getRecommendedStatisticalMeasures()
- */
- protected void setRecommendedStatisticalMeasures(
- Set<StatisticalMeasure> recommendedStatisticalMeasures) {
- this.recommendedStatisticalMeasures = recommendedStatisticalMeasures;
- }
-
/**
* Adds a {@link StatisticalMeasure statistical measure} to the set of
* {@link #getRecommendedStatisticalMeasures() recommended statistical measures} assigned
* possible {@link State states} to be used in {@link CategoricalData categorical data}
* with <i>this</i> feature.
*
- * FIXME Should this be Many-To-Many or do we expect each Feature to have its own unique state enums?
*/
- @OneToMany(fetch = FetchType.LAZY)
- @JoinTable(name="DefinedTermBase_SupportedCategoricalEnumeration")
public Set<TermVocabulary<State>> getSupportedCategoricalEnumerations() {
return supportedCategoricalEnumerations;
}
- /**
- * @see #getSupportedCategoricalEnumerations()
- */
- protected void setSupportedCategoricalEnumerations(
- Set<TermVocabulary<State>> supportedCategoricalEnumerations) {
- this.supportedCategoricalEnumerations = supportedCategoricalEnumerations;
- }
/**
* Adds a {@link TermVocabulary term vocabulary} to the set of
* {@link #getSupportedCategoricalEnumerations() supported state vocabularies} assigned
TermVocabulary<State> supportedCategoricalEnumeration) {
this.supportedCategoricalEnumerations.remove(supportedCategoricalEnumeration);
}
-
private static final UUID uuidUnknown = UUID.fromString("910307f1-dc3c-452c-a6dd-af5ac7cd365c");
private static final UUID uuidDescription = UUID.fromString("9087cdcd-8b08-4082-a1de-34c9ba9fb493");
return PHENOLOGY;
}
-
/**
* Returns the "occurrence" feature.
*/
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.VersionableEntity;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "FeatureNode", propOrder = {
"feature",
-// "type",
"parent",
"children"
})
@XmlRootElement(name = "FeatureNode")
@Entity
-//@Audited
+@Audited
public class FeatureNode extends VersionableEntity {
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(FeatureNode.class);
@XmlElement(name = "Feature")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private Feature feature;
-
-// @XmlElement(name = "FeatureType")
-// @XmlIDREF
-// @XmlSchemaType(name = "IDREF")
-// private Feature type;
@XmlElement(name = "Parent")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
+ @JoinColumn(name="parent_fk")
private FeatureNode parent;
@XmlElementWrapper(name = "Children")
@XmlElement(name = "Child")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch = FetchType.LAZY,mappedBy="parent")
+ @Cascade({CascadeType.SAVE_UPDATE})
private List<FeatureNode> children = new ArrayList<FeatureNode>();
/**
result.setFeature(feature);
return result;
}
-
-
-
//** ********************** FEATURE ******************************/
-// /**
-// * Does the same as getFeature
- // */
- // @Transient
- // @Deprecated
- // protected Feature getType() {
- // return feature;
- // }
- // /**
- // * Does the same as setFeature
- // */
- // protected void setType(Feature feature) {
- // this.feature = feature;
- // }
/**
* Returns the {@link Feature feature} <i>this</i> feature node is based on.
*/
- @ManyToOne(fetch = FetchType.LAZY)
public Feature getFeature() {
return feature;
}
public void setFeature(Feature feature) {
this.feature = feature;
}
-
//** ********************** PARENT ******************************/
-
/**
* Returns the feature node <i>this</i> feature node is a child of.
*
* @see #getChildren()
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @JoinColumn(name="parent_fk")
- @Cascade({CascadeType.SAVE_UPDATE})
public FeatureNode getParent() {
return parent;
}
* Returns the (ordered) list of feature nodes which are children nodes of
* <i>this</i> feature node.
*/
- @OneToMany(fetch = FetchType.LAZY,mappedBy="parent")
- @Cascade({CascadeType.SAVE_UPDATE})
public List<FeatureNode> getChildren() {
return children;
}
- /**
- * Assigns the given feature node list as the list of children of
- * <i>this</i> feature node. Due to bidirectionality this method must also
- * add <i>this</i> feature node to the list of children of the given parent.
- *
- * @param children the feature node list to be set as child list
- * @see #getChildren()
- * @see #addChild(FeatureNode)
- * @see #addChild(FeatureNode, int)
- */
- public void setChildren(List<FeatureNode> children) {
- this.children = children;
- }
+
/**
* Adds the given feature node at the end of the list of children of
* <i>this</i> feature node. Due to bidirectionality this method must also
* @see #addChild(FeatureNode, int)
* @see #removeChild(int)
*/
- @Transient
public FeatureNode getChildAt(int childIndex) {
return children.get(childIndex);
}
*
* @see #getChildren()
*/
- @Transient
public int getChildCount() {
return children.size();
}
* @see #addChild(FeatureNode, int)
* @see #removeChild(int)
*/
- @Transient
-// public int getIndex(TreeNode node) {
public int getIndex(FeatureNode node) {
if (! children.contains(node)){
return -1;
* @see #getChildren()
* @see #getChildCount()
*/
- @Transient
public boolean isLeaf() {
return children.size() < 1;
}
package eu.etaxonomy.cdm.model.description;
-
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.ManyToOne;
-import javax.persistence.Transient;
+import javax.persistence.OneToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.TermBase;
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "FeatureTree", propOrder = {
- "isDescriptionSeparated",
+ "descriptionSeparated",
"root"
})
@XmlRootElement(name = "FeatureTree")
@Entity
-//@Audited
+@Audited
public class FeatureTree extends TermBase {
/**
*
//private Set<FeatureNode> nodes = new HashSet<FeatureNode>();
@XmlElement(name = "Root")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
+ @OneToOne(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
private FeatureNode root;
@XmlElement(name = "IsDescriptionSeparated")
- private boolean isDescriptionSeparated = false;
+ private boolean descriptionSeparated = false;
/**
* Class constructor: creates a new feature tree instance with an empty
* @return the boolean value of the isDescriptionSeparated flag
*/
public boolean isDescriptionSeparated() {
- return isDescriptionSeparated;
+ return descriptionSeparated;
}
/**
* @see #isDescriptionSeparated()
*/
- public void setDescriptionSeparated(boolean isDescriptionSeperated) {
- this.isDescriptionSeparated = isDescriptionSeperated;
+ public void setDescriptionSeparated(boolean descriptionSeperated) {
+ this.descriptionSeparated = descriptionSeperated;
}
// @OneToMany
* recursively point to their child nodes the complete feature tree is
* defined by its root node.
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public FeatureNode getRoot() {
return root;
}
* Returns the (ordered) list of {@link FeatureNode feature nodes} which are immediate
* children of the root node of <i>this</i> feature tree.
*/
- @Transient
public List<FeatureNode> getRootChildren(){
List<FeatureNode> result = new ArrayList<FeatureNode>();
result.addAll(root.getChildren());
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import java.util.*;
})
@XmlRootElement(name = "IdentificationKey")
@Entity
-//@Audited
+@Audited
public class IdentificationKey extends Media {
private static final long serialVersionUID = -29095811051894471L;
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(IdentificationKey.class);
+ /*
+ * FIXME - shouldn't this be @ManyToMany - i.e. many keys can refer to the
+ * same taxon and some taxa will be covered by multiple keys?
+ */
@XmlElementWrapper(name = "CoveredTaxa")
@XmlElement(name = "CoveredTaxon")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch = FetchType.LAZY)
private Set<Taxon> coveredTaxa = new HashSet<Taxon>();
@XmlElementWrapper( name = "GeoScopes")
@XmlElement( name = "GeoScope")
+ @ManyToMany(fetch = FetchType.LAZY)
private Set<NamedArea> geoScopes = new HashSet<NamedArea>();
@XmlElementWrapper(name = "TaxonomicScope")
@XmlElement(name = "Taxon")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
+ @JoinTable(
+ name="IdentificationKey_Taxon",
+ joinColumns=@JoinColumn(name="identificationKey_fk"),
+ inverseJoinColumns=@JoinColumn(name="taxon_fk")
+ )
private Set<Taxon> taxonomicScope = new HashSet<Taxon>();
/**
/**
* Returns the set of possible {@link Taxon taxa} corresponding to
* <i>this</i> identification key.
- * FIXME - shouldn't this be @ManyToMany - i.e. many keys can refer to the
- * same taxon and some taxa will be covered by multiple keys?
*/
- @OneToMany(fetch = FetchType.LAZY)
public Set<Taxon> getCoveredTaxa() {
return coveredTaxa;
}
* Returns the set of {@link NamedArea named areas} indicating the geospatial
* data where <i>this</i> identification key is valid.
*/
- @ManyToMany(fetch = FetchType.LAZY)
public Set<NamedArea> getGeoScopes() {
return geoScopes;
}
-
- /**
- * @see #getGeoScopes()
- */
- public void setGeoScopes(Set<NamedArea> geoScopes) {
- this.geoScopes = geoScopes;
- }
/**
* Adds a {@link NamedArea geoScope} to the set of {@link #getGeoScopes() geogspatial scopes}
* Returns the set of {@link Taxon taxa} that define the taxonomic
* scope of <i>this</i> identification key
*/
- @ManyToMany(fetch = FetchType.LAZY)
- @JoinTable(
- name="IdentificationKey_Taxon",
- joinColumns=@JoinColumn(name="identificationKey_fk"),
- inverseJoinColumns=@JoinColumn(name="taxon_fk")
- )
public Set<Taxon> getTaxonomicScope() {
return taxonomicScope;
}
-
- /**
- * @see #getTaxonomicScope()
- */
- public void setTaxonomicScope(Set<Taxon> taxonomicScope) {
- this.taxonomicScope = taxonomicScope;
- }
/**
* Adds a {@link Taxon taxa} to the set of {@link #getTaxonomicScope() taxonomic scopes}
package eu.etaxonomy.cdm.model.description;
+import java.util.HashMap;
+import java.util.Map;
+
import javax.persistence.Entity;
import javax.persistence.FetchType;
+import javax.persistence.JoinTable;
import javax.persistence.ManyToOne;
+import javax.persistence.OneToMany;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+import eu.etaxonomy.cdm.jaxb.MultilanguageTextAdapter;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.LanguageString;
import eu.etaxonomy.cdm.model.common.MultilanguageText;
})
@XmlRootElement(name = "IndividualsAssociation")
@Entity
-//@Audited
+@Audited
public class IndividualsAssociation extends DescriptionElementBase {
private static final long serialVersionUID = -4117554860254531809L;
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(IndividualsAssociation.class);
@XmlElement(name = "Description")
- private MultilanguageText description;
+ @XmlJavaTypeAdapter(MultilanguageTextAdapter.class)
+ @OneToMany(fetch = FetchType.LAZY)
+ @JoinTable(name = "IndividualAssociation_LanguageString")
+ private Map<Language,LanguageString> description = new HashMap<Language,LanguageString>();
@XmlElement(name = "AssociatedSpecimenOrObservation")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private SpecimenOrObservationBase associatedSpecimenOrObservation;
/**
* The first specimen or observation is the specimen or observation
* described in the corresponding {@link SpecimenDescription specimen description}.
*/
- @ManyToOne(fetch = FetchType.LAZY)
public SpecimenOrObservationBase getAssociatedSpecimenOrObservation() {
return associatedSpecimenOrObservation;
}
* <i>this</i> individuals association. The different {@link LanguageString language strings}
* contained in the multilanguage text should all have the same meaning.
*/
- public MultilanguageText getDescription(){
+ public Map<Language,LanguageString> getDescription(){
return this.description;
}
- /**
- * @see #getDescription()
- */
- private void setDescription(MultilanguageText description){
- this.description = description;
- }
+
/**
* Adds a translated {@link LanguageString text in a particular language}
* to the {@link MultilanguageText multilanguage text} used to describe
* @see #addDescription(String, Language)
*/
public void addDescription(LanguageString description){
- this.description.add(description);
+ this.description.put(description.getLanguage(),description);
}
/**
* Creates a {@link LanguageString language string} based on the given text string
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
@XmlType(name = "MeasurementUnit")
@XmlRootElement(name = "MeasurementUnit")
@Entity
-//@Audited
+@Audited
public class MeasurementUnit extends DefinedTermBase<MeasurementUnit> {
private static final long serialVersionUID = 4904519152652248312L;
@SuppressWarnings("unused")
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
@XmlType(name = "Modifier")
@XmlRootElement(name = "Modifier")
@Entity
-//@Audited
+@Audited
public class Modifier extends OrderedTermBase<Modifier> {
private static final long serialVersionUID = -2491833848163461951L;
@SuppressWarnings("unused")
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.common.CdmUtils;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
@XmlType(name = "PresenceAbsenceTermBase")
@XmlRootElement(name = "PresenceAbsenceTermBase")
@Entity
-//@Audited
+@Audited
public abstract class PresenceAbsenceTermBase<T extends PresenceAbsenceTermBase<?>> extends OrderedTermBase<T> {
private static final long serialVersionUID = 1596291470042068880L;
private static final Logger logger = Logger.getLogger(PresenceAbsenceTermBase.class);
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
@XmlType(name = "PresenceTerm")
@XmlRootElement(name = "PresenceTerm")
@Entity
-//@Audited
+@Audited
public class PresenceTerm extends PresenceAbsenceTermBase<PresenceTerm> {
private static final long serialVersionUID = -2876981902335193596L;
private static final Logger logger = Logger.getLogger(PresenceTerm.class);
public static final PresenceTerm INTRODUCED_NATURALIZED(){return INTRODUCED_NATURALIZED; }
public static final PresenceTerm INTRODUCED_REPORTED_IN_ERROR(){return INTRODUCED_REPORTED_IN_ERROR; }
public static final PresenceTerm ENDEMIC_FOR_THE_RELEVANT_AREA(){return ENDEMIC_FOR_THE_RELEVANT_AREA; }
-
- @Transient
+
public static PresenceTerm getPresenceTermByAbbreviation(String abbrev) {
if (abbrev == null) { throw new NullPointerException("abbrev is 'null' in getPresenceTermByAbbreviation");
import javax.persistence.FetchType;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
/**
* This class represents information pieces expressed in numerical data
})
@XmlRootElement(name = "QuantitativeData")
@Entity
-//@Audited
+@Audited
public class QuantitativeData extends DescriptionElementBase {
private static final long serialVersionUID = -2755806455420051488L;
@SuppressWarnings("unused")
@XmlElement(name = "MeasurementUnit")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private MeasurementUnit unit;
@XmlElementWrapper(name = "StatisticalValues")
@XmlElement(name = "StatisticalValue")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
private Set<StatisticalMeasurementValue> statisticalValues = new HashSet<StatisticalMeasurementValue>();
/**
* Returns the set of {@link StatisticalMeasurementValue statistical measurement values} describing
* the {@link Feature feature} corresponding to <i>this</i> quantitative data.
*/
- @OneToMany(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<StatisticalMeasurementValue> getStatisticalValues() {
return statisticalValues;
}
- /**
- * @see #getStatisticalValues()
- */
- protected void setStatisticalValues(
- Set<StatisticalMeasurementValue> statisticalValues) {
- this.statisticalValues = statisticalValues;
- }
+
/**
* Adds a {@link StatisticalMeasurementValue statistical measurement value} to the set of
* {@link #getStatisticalValues() statistical measurement values} describing
* Returns the {@link MeasurementUnit measurement unit} used in <i>this</i>
* quantitative data.
*/
- @ManyToOne(fetch = FetchType.LAZY)
public MeasurementUnit getUnit(){
return this.unit;
}
* belonging to <i>this</i> quantitative data. Returns "0" if no such
* statistical measurement value instance exists.
*/
- @Transient
public float getMin(){
return 0;
}
* belonging to <i>this</i> quantitative data. Returns "0" if no such
* statistical measurement value instance exists.
*/
- @Transient
public float getMax(){
return 0;
}
* "typical lower boundary" and belonging to <i>this</i> quantitative data.
* Returns "0" if no such statistical measurement value instance exists.
*/
- @Transient
public float getTypicalLowerBoundary(){
return 0;
}
* "typical upper boundary" and belonging to <i>this</i> quantitative data.
* Returns "0" if no such statistical measurement value instance exists.
*/
- @Transient
public float getTypicalUpperBoundary(){
return 0;
}
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
@XmlType(name = "Scope")
@XmlRootElement(name = "Scope")
@Entity
-//@Audited
+@Audited
public class Scope extends Modifier {
private static final long serialVersionUID = 4479960075363470677L;
@SuppressWarnings("unused")
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
@XmlType(name = "Sex")
@XmlRootElement(name = "Sex")
@Entity
-//@Audited
+@Audited
public class Sex extends Scope {
private static final long serialVersionUID = 3463642992193419657L;
@SuppressWarnings("unused")
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
@XmlType(name = "SpecimenDescription")
@XmlRootElement(name = "SpecimenDescription")
@Entity
-//@Audited
+@Audited
public class SpecimenDescription extends DescriptionBase {
private static final long serialVersionUID = -8506790426682192703L;
@SuppressWarnings("unused")
package eu.etaxonomy.cdm.model.description;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
@XmlType(name = "Stage")
@XmlRootElement(name = "Stage")
@Entity
-//@Audited
+@Audited
public class Stage extends Scope {
private static final long serialVersionUID = 2338810516765894760L;
@SuppressWarnings("unused")
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.OrderedTermBase;
@XmlType(name = "State")
@XmlRootElement(name = "State")
@Entity
-//@Audited
+@Audited
public class State extends OrderedTermBase<State> {
private static final long serialVersionUID = -4816292463790262516L;
@SuppressWarnings("unused")
package eu.etaxonomy.cdm.model.description;
-import eu.etaxonomy.cdm.model.common.Language;
-import eu.etaxonomy.cdm.model.common.LanguageString;
-import eu.etaxonomy.cdm.model.common.MultilanguageText;
-import eu.etaxonomy.cdm.model.common.TermVocabulary;
-import eu.etaxonomy.cdm.model.common.VersionableEntity;
-import org.apache.log4j.Logger;
-
-import java.util.*;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.ManyToOne;
+import javax.persistence.OneToMany;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
+
+import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
+
+import eu.etaxonomy.cdm.jaxb.MultilanguageTextAdapter;
+import eu.etaxonomy.cdm.model.common.Language;
+import eu.etaxonomy.cdm.model.common.LanguageString;
+import eu.etaxonomy.cdm.model.common.MultilanguageText;
+import eu.etaxonomy.cdm.model.common.TermVocabulary;
+import eu.etaxonomy.cdm.model.common.VersionableEntity;
/**
* This class represents the assignment of values ({@link State state terms}) to {@link Feature features}
})
@XmlRootElement(name = "StateData")
@Entity
-//@Audited
+@Audited
public class StateData extends VersionableEntity {
private static final long serialVersionUID = -4380314126624505415L;
@SuppressWarnings("unused")
@XmlElement(name = "State")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private State state;
@XmlElementWrapper(name = "Modifiers")
@XmlElement(name = "Modifier")
+ @OneToMany(fetch = FetchType.LAZY)
private Set<Modifier> modifiers = new HashSet<Modifier>();
@XmlElement(name = "ModifyingText")
- private MultilanguageText modifyingText;
+ @XmlJavaTypeAdapter(MultilanguageTextAdapter.class)
+ @OneToMany(fetch = FetchType.LAZY)
+ private Map<Language,LanguageString> modifyingText = new HashMap<Language,LanguageString>();
/**
* Class constructor: creates a new empty state data instance.
/**
* Returns the {@link State state term} used in <i>this</i> state data.
*/
- @ManyToOne(fetch = FetchType.LAZY)
public State getState(){
return this.state;
}
* Returns the set of {@link Modifier modifiers} used to qualify the validity
* of <i>this</i> state data. This is only metainformation.
*/
- @OneToMany(fetch = FetchType.LAZY)
public Set<Modifier> getModifiers(){
return this.modifiers;
}
- /**
- * @see #getModifiers()
- */
- @SuppressWarnings("unused")
- private void setModifiers(Set<Modifier> modifiers) {
- this.modifiers = modifiers;
- }
+
/**
* Adds a {@link Modifier modifier} to the set of {@link #getModifiers() modifiers}
* used to qualify the validity of <i>this</i> state data.
* stored in the modifying text. This is only metainformation
* (like "Some experts express doubt about this assertion").
*/
- public MultilanguageText getModifyingText(){
+ public Map<Language,LanguageString> getModifyingText(){
return this.modifyingText;
}
- /**
- * @see #getModifyingText()
- */
- @SuppressWarnings("unused")
- private void setModifyingText(MultilanguageText modifyingText) {
- this.modifyingText = modifyingText;
- }
+
/**
* Creates a {@link LanguageString language string} based on the given text string
* and the given {@link Language language} and adds it to the {@link MultilanguageText multilanguage text}
* @see #addModifyingText(String, Language)
*/
public void addModifyingText(LanguageString text){
- this.modifyingText.add(text);
+ this.modifyingText.put(text.getLanguage(),text);
}
/**
* Removes from the {@link MultilanguageText multilanguage text} used to qualify the validity
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.Language;
@XmlType(name = "StatisticalMeasure")
@XmlRootElement(name = "StatisticalMeasure")
@Entity
-//@Audited
+@Audited
public class StatisticalMeasure extends DefinedTermBase<StatisticalMeasure> {
private static final long serialVersionUID = 9168097283660941430L;
@SuppressWarnings("unused")
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.VersionableEntity;
@XmlType(name = "StatisticalMeasureValue")
@XmlRootElement(name = "StatisticalMeasureValue")
@Entity
-//@Audited
+@Audited
public class StatisticalMeasurementValue extends VersionableEntity {
private static final long serialVersionUID = -3576311887760351982L;
@SuppressWarnings("unused")
@XmlElement(name = "Modifier")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch = FetchType.LAZY)
private Set<Modifier> modifiers = new HashSet<Modifier>();
@XmlElement(name = "StatisticalMeasureType")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private StatisticalMeasure type;
* Returns the type of {@link StatisticalMeasure statistical measure} used in
* <i>this</i> statistical measurement value.
*/
- @ManyToOne(fetch = FetchType.LAZY)
public StatisticalMeasure getType(){
return this.type;
}
* or probability of <i>this</i> statistical measurement value.
* This is only metainformation.
*/
- @OneToMany(fetch = FetchType.LAZY)
public Set<Modifier> getModifiers() {
return modifiers;
}
- /**
- * @see #getModifiers()
- */
- protected void setModifiers(Set<Modifier> modifiers) {
- this.modifiers = modifiers;
- }
+
/**
* Adds a {@link Modifier modifier} to the set of {@link #getModifiers() modifiers}
* used to qualify the validity of <i>this</i> statistical measurement value.
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
+import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
+import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import org.hibernate.search.annotations.Indexed;
import eu.etaxonomy.cdm.model.location.NamedArea;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "TaxonDescription", propOrder = {
"scopes",
- "geoScopes"
+ "geoScopes",
+ "taxon"
})
@XmlRootElement(name = "TaxonDescription")
@Entity
-//@Audited
+@Audited
@Indexed
public class TaxonDescription extends DescriptionBase {
private static final long serialVersionUID = 8065879180505546803L;
@XmlElementWrapper(name = "Scopes")
@XmlElement(name = "Scope")
+ @XmlIDREF
+ @XmlSchemaType(name="IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
+ @JoinTable(name="DescriptionBase_Scope")
private Set<Scope> scopes = new HashSet<Scope>();
@XmlElementWrapper( name = "GeoScopes")
@XmlElement( name = "GeoScope")
+ @XmlIDREF
+ @XmlSchemaType(name="IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
+ @JoinTable(name="DescriptionBase_GeoScope")
+ //@Cascade({CascadeType.SAVE_UPDATE})
private Set<NamedArea> geoScopes = new HashSet<NamedArea>();
- @XmlTransient
+ @XmlElement( name = "Taxon")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @XmlIDREF
+ @XmlSchemaType(name="IDREF")
+ @JoinColumn(name="taxon_fk")
+ @Cascade(CascadeType.SAVE_UPDATE)
private Taxon taxon;
+ public Taxon getTaxon() {
+ return taxon;
+ }
/**
* Class constructor: creates a new empty taxon description instance.
super();
}
-
/**
* Creates a new empty taxon description instance.
*
* Returns the set of {@link NamedArea named areas} indicating the geospatial
* data where <i>this</i> taxon description is valid.
*/
- @OneToMany(fetch = FetchType.LAZY)
- @JoinTable(name="DescriptionBase_GeoScope")
- //@Cascade({CascadeType.SAVE_UPDATE})
public Set<NamedArea> getGeoScopes(){
return this.geoScopes;
}
- /**
- * @see #getGeoScopes()
- */
- protected void setGeoScopes(Set<NamedArea> geoScopes){
- this.geoScopes = geoScopes;
- }
+
/**
* Adds a {@link NamedArea named area} to the set of {@link #getGeoScopes() named areas}
* delimiting the geospatial area where <i>this</i> taxon description is valid.
public void addGeoScope(NamedArea geoScope){
this.geoScopes.add(geoScope);
}
+
/**
* Removes one element from the set of {@link #getGeoScopes() named areas} delimiting
* the geospatial area where <i>this</i> taxon description is valid.
* restricting the validity of <i>this</i> taxon description. This set
* of scopes should contain no more than one "sex" and one "life stage".
*/
- @OneToMany(fetch = FetchType.LAZY)
- @JoinTable(name="DescriptionBase_Scope")
public Set<Scope> getScopes(){
return this.scopes;
}
- /**
- * @see #getScopes()
- */
- protected void setScopes(Set<Scope> scopes){
- this.scopes = scopes;
- }
+
/**
* Adds a {@link Scope scope} (mostly a {@link Stage life stage} or a {@link Sex sex})
* to the set of {@link #getScopes() scopes} restricting the validity of
public void addScope(Scope scope){
this.scopes.add(scope);
}
+
/**
* Removes one element from the set of {@link #getScopes() scopes}
* restricting the validity of <i>this</i> taxon description.
public void removeScope(Scope scope){
this.scopes.remove(scope);
}
-
-
- /**
- * Returns the {@link Taxon taxon} <i>this</i> taxon description is about.
- */
- @ManyToOne(fetch = FetchType.LAZY)
- @JoinColumn(name="taxon_fk")
- @Cascade(CascadeType.SAVE_UPDATE)
- public Taxon getTaxon() {
- return taxon;
- }
- @Deprecated //for hibernate use only, use taxon.addDescription() instead
- protected void setTaxon(Taxon taxon) {
- this.taxon = taxon;
- }
-
}
\ No newline at end of file
package eu.etaxonomy.cdm.model.description;
+import java.util.HashMap;
+import java.util.Map;
+
import javax.persistence.Entity;
import javax.persistence.FetchType;
+import javax.persistence.JoinTable;
import javax.persistence.ManyToOne;
+import javax.persistence.OneToMany;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.jaxb.MultilanguageTextAdapter;
import eu.etaxonomy.cdm.model.common.Language;
})
@XmlRootElement(name = "TaxonInteraction")
@Entity
-//@Audited
+@Audited
public class TaxonInteraction extends DescriptionElementBase {
private static final long serialVersionUID = -5014025677925668627L;
@SuppressWarnings("unused")
@XmlElement(name = "Description")
@XmlJavaTypeAdapter(MultilanguageTextAdapter.class)
- private MultilanguageText description;
+ @OneToMany(fetch = FetchType.LAZY)
+ @JoinTable(name = "TaxonInteraction_LanguageString")
+ private Map<Language,LanguageString> description = new HashMap<Language,LanguageString>();
@XmlElement(name = "Taxon2")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Taxon taxon2;
/**
* The first taxon is the taxon described in the corresponding
* {@link TaxonDescription taxon description}.
*/
- @ManyToOne(fetch = FetchType.LAZY)
public Taxon getTaxon2(){
return this.taxon2;
}
* <i>this</i> taxon interaction. The different {@link LanguageString language strings}
* contained in the multilanguage text should all have the same meaning.
*/
- public MultilanguageText getDescription(){
+ public Map<Language,LanguageString> getDescription(){
return this.description;
}
- /**
- * @see #getDescription()
- */
- @SuppressWarnings("unused")
- private void setDescription(MultilanguageText description){
- this.description = description;
- }
+
/**
* Adds a translated {@link LanguageString text in a particular language}
* to the {@link MultilanguageText multilanguage text} used to describe
* @see #addDescription(String, Language)
*/
public void addDescription(LanguageString description){
- this.description.add(description);
+ this.description.put(description.getLanguage(),description);
}
/**
* Creates a {@link LanguageString language string} based on the given text string
import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
/**
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "TaxonNameDescription", propOrder = {
+ "taxonName"
})
@XmlRootElement(name = "TaxonNameDescription")
@Entity
-//@Audited
+@Audited
public class TaxonNameDescription extends DescriptionBase {
private static final long serialVersionUID = -7349160369642038687L;
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(TaxonNameDescription.class);
- @XmlTransient
+ @XmlElement(name="TaxonName")
+ @XmlIDREF
+ @XmlSchemaType(name="IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @JoinColumn(name="taxonName_fk")
+ @Cascade(CascadeType.SAVE_UPDATE)
private TaxonNameBase<?,?> taxonName;
-
/**
* Class constructor: creates a new empty taxon name description instance.
*/
super();
}
-
/**
* Creates a new empty taxon name description instance.
*/
* Returns the {@link TaxonNameBase taxon name} to which <i>this</i> taxon name description
* provides additional information not ruled by a {@link NomenclaturalCode nomenclatural code}.
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @JoinColumn(name="taxonName_fk")
- @Cascade(CascadeType.SAVE_UPDATE)
public TaxonNameBase<?,?> getTaxonName() {
return taxonName;
}
- @Deprecated //for hibernate use only, use taxonName.addDescription() instead
- protected void setTaxonName(TaxonNameBase<?,?> taxonName) {
- this.taxonName = taxonName;
- }
-
-
}
package eu.etaxonomy.cdm.model.description;
+import java.util.HashMap;
import java.util.Map;
import javax.persistence.Entity;
import javax.persistence.ManyToOne;
import javax.persistence.MapKey;
import javax.persistence.OneToMany;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import org.hibernate.search.annotations.Indexed;
import org.hibernate.search.annotations.IndexedEmbedded;
import eu.etaxonomy.cdm.jaxb.MultilanguageTextAdapter;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.LanguageString;
-import eu.etaxonomy.cdm.model.common.MultilanguageText;
/**
* This class represents information pieces expressed in one or several natural
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "TextData", propOrder = {
- "multiLanguageText",
+ "multilanguageText",
"format"
})
@XmlRootElement(name = "TextData")
@Entity
-//@Audited
+@Audited
@Indexed
public class TextData extends DescriptionElementBase {
private static final long serialVersionUID = -2165015581278282615L;
//@XmlElement(name = "MultiLanguageText", type = MultilanguageText.class)
@XmlElement(name = "MultiLanguageText")
@XmlJavaTypeAdapter(MultilanguageTextAdapter.class)
- //private MultilanguageText multiLanguageText;
- private Map<Language, LanguageString> multiLanguageText;
+ @OneToMany (fetch= FetchType.LAZY)
+ @MapKey(name="language")
+ @Cascade({CascadeType.SAVE_UPDATE})
+ @IndexedEmbedded
+ private Map<Language, LanguageString> multilanguageText = new HashMap<Language,LanguageString>();
@XmlElement(name = "Format")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private TextFormat format;
// ************* CONSTRUCTORS *************/
*/
public TextData(Feature feature){
super(feature);
- initTextSet();
}
//********* METHODS **************************************/
*
* @see #getText(Language)
*/
- @OneToMany (fetch= FetchType.LAZY)
- @MapKey(name="language")
- @Cascade({CascadeType.SAVE_UPDATE})
- @IndexedEmbedded
+
public Map<Language, LanguageString> getMultilanguageText() {
- //public MultilanguageText getMultilanguageText() {
- initTextSet();
- return multiLanguageText;
- }
- /**
- * @see #getMultilanguageText()
- */
- protected void setMultilanguageText(Map<Language, LanguageString> texts) {
- //protected void setMultilanguageText(MultilanguageText texts) {
- this.multiLanguageText = texts;
+ return multilanguageText;
}
+
/**
* Returns the text string in the given {@link Language language} with the content
* of <i>this</i> text data.
*
* @param language the language in which the text string looked for is formulated
* @see #getMultilanguageText()
- */
- @Transient
+ */
public String getText(Language language) {
- initTextSet();
- LanguageString languageString = multiLanguageText.get(language);
+ LanguageString languageString = multilanguageText.get(language);
if (languageString == null){
return null;
}else{
* @see #getMultilanguageText()
* @see #putText(LanguageString)
*/
- @Transient
public LanguageString putText(String text, Language language) {
- initTextSet();
- LanguageString result = this.multiLanguageText.put(language , LanguageString.NewInstance(text, language));
+ LanguageString result = this.multilanguageText.put(language , LanguageString.NewInstance(text, language));
return (result == null ? null : result);
}
/**
* @see #getMultilanguageText()
* @see #putText(String, Language)
*/
- @Transient
public LanguageString putText(LanguageString languageString) {
- initTextSet();
if (languageString == null){
return null;
}else{
Language language = languageString.getLanguage();
- return this.multiLanguageText.put(language, languageString);
+ return this.multilanguageText.put(language, languageString);
}
}
/**
* @see #getMultilanguageText()
*/
public LanguageString removeText(Language language) {
- initTextSet();
- return this.multiLanguageText.remove(language);
- }
-
- private void initTextSet(){
- if (multiLanguageText == null){
- multiLanguageText = MultilanguageText.NewInstance();
- }
+ return this.multilanguageText.remove(language);
}
/**
* @see #getMultilanguageText()
*/
public int countLanguages(){
- initTextSet();
- return multiLanguageText.size();
+ return multilanguageText.size();
}
*
* @see #getMultilanguageText()
*/
- @ManyToOne(fetch = FetchType.LAZY)
public TextFormat getFormat() {
return format;
}
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
@XmlType(name = "TextFormat")
@XmlRootElement(name = "TextFormat")
@Entity
-//@Audited
+@Audited
public class TextFormat extends DefinedTermBase<TextFormat> {
private static final long serialVersionUID = 2063382669537212917L;
@SuppressWarnings("unused")
--- /dev/null
+\r
+@javax.xml.bind.annotation.XmlSchema(namespace = "http://etaxonomy.eu/cdm/model/description/1.0", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)\r
+package eu.etaxonomy.cdm.model.description;
\ No newline at end of file
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.Language;
@XmlType(name = "Continent")
@XmlRootElement(name = "Continent")
@Entity
-//@Audited
+@Audited
public class Continent extends NamedArea {
private static final long serialVersionUID = 4650684072484353151L;
private static final Logger logger = Logger.getLogger(Continent.class);
package eu.etaxonomy.cdm.model.location;
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;
-import eu.etaxonomy.cdm.model.common.ILoadableTerm;
-import eu.etaxonomy.cdm.model.common.Language;
-import eu.etaxonomy.cdm.model.common.TermVocabulary;
-import eu.etaxonomy.cdm.model.common.TimePeriod;
-import eu.etaxonomy.cdm.model.common.OrderedTermBase;
-import eu.etaxonomy.cdm.model.media.Media;
-
-import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
-
-import java.util.*;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.JoinTable;
+import javax.persistence.ManyToMany;
+import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+
+import eu.etaxonomy.cdm.model.common.DefinedTermBase;
+import eu.etaxonomy.cdm.model.common.OrderedTermBase;
+import eu.etaxonomy.cdm.model.common.TermVocabulary;
+import eu.etaxonomy.cdm.model.common.TimePeriod;
+import eu.etaxonomy.cdm.model.media.Media;
+
/**
* @author m.doering
* @version 1.0
})
@XmlRootElement(name = "NamedArea")
@Entity
-//@Audited
+@Audited
public class NamedArea extends OrderedTermBase<NamedArea> {
private static final long serialVersionUID = 6248434369557403036L;
private static final Logger logger = Logger.getLogger(NamedArea.class);
@XmlElement(name = "Shape")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Media shape;
@XmlElement(name = "PointApproximation")
@XmlElement(name = "WaterbodiesOrCountry")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
+ @JoinTable(name="DefinedTermBase_WaterbodyOrCountry")
private Set<WaterbodyOrCountry> waterbodiesOrCountries = new HashSet<WaterbodyOrCountry>();
@XmlElement(name = "NamedAreaType")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private NamedAreaType type;
@XmlElement(name = "NamedAreaLevel")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private NamedAreaLevel level;
/**
public NamedArea() {
super();
}
+
public NamedArea(String term, String label, String labelAbbrev) {
super(term, label, labelAbbrev);
}
-
- @ManyToOne(fetch = FetchType.LAZY)
- //@Cascade({CascadeType.SAVE_UPDATE}) //NamedAreaType is DefinedTerm -> no Cascade
public NamedAreaType getType(){
return this.type;
}
+
public void setType(NamedAreaType type){
this.type = type;
}
- @ManyToOne(fetch = FetchType.LAZY)
- //@Cascade({CascadeType.SAVE_UPDATE}) //NamedAreaLevel is DefinedTerm -> no Cascade
public NamedAreaLevel getLevel(){
return this.level;
}
+
public void setLevel(NamedAreaLevel level){
this.level = level;
}
public TimePeriod getValidPeriod(){
return this.validPeriod;
}
+
public void setValidPeriod(TimePeriod validPeriod){
this.validPeriod = validPeriod;
}
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Media getShape(){
return this.shape;
}
this.shape = shape;
}
- @ManyToMany(fetch = FetchType.LAZY)
- @JoinTable(name="DefinedTermBase_WaterbodyOrCountry")
-// @Cascade({CascadeType.SAVE_UPDATE})
+
public Set<WaterbodyOrCountry> getWaterbodiesOrCountries() {
return waterbodiesOrCountries;
}
- protected void setWaterbodiesOrCountries(
- Set<WaterbodyOrCountry> waterbodiesOrCountries) {
- this.waterbodiesOrCountries = waterbodiesOrCountries;
- }
- public void addWaterbodyOrCountry(
- WaterbodyOrCountry waterbodyOrCountry) {
+
+ public void addWaterbodyOrCountry(WaterbodyOrCountry waterbodyOrCountry) {
this.waterbodiesOrCountries.add(waterbodyOrCountry);
}
- public void removeWaterbodyOrCountry(
- WaterbodyOrCountry waterbodyOrCountry) {
+
+ public void removeWaterbodyOrCountry(WaterbodyOrCountry waterbodyOrCountry) {
this.waterbodiesOrCountries.remove(waterbodyOrCountry);
}
NamedArea newInstance = super.readCsvLine(termClass, csvLine, terms);
String levelString = (String)csvLine.get(6);
+
if(levelString != null && levelString.length() != 0) {
UUID levelUuid = UUID.fromString(levelString);
NamedAreaLevel level = (NamedAreaLevel)terms.get(levelUuid);
if(partOfString != null && partOfString.length() != 0) {
UUID partOfUuid = UUID.fromString(partOfString);
NamedArea partOf = (NamedArea)terms.get(partOfUuid);
- partOf.addIncludes(this);
- }
+ partOf.addIncludes(newInstance);
+ }
return newInstance;
}
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
@XmlType(name = "NamedAreaLevel")
@XmlRootElement(name = "NamedAreaLevel")
@Entity
-//@Audited
+@Audited
public class NamedAreaLevel extends OrderedTermBase<NamedAreaLevel> {
private static final long serialVersionUID = -7977901140330659208L;
@SuppressWarnings("unused")
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
@XmlType(name = "NamedAreaType")
@XmlRootElement(name = "NamedAreaType")
@Entity
-//@Audited
+@Audited
public class NamedAreaType extends DefinedTermBase<NamedAreaType> {
private static final long serialVersionUID = 8280172429797206548L;
private static final Logger logger = Logger.getLogger(NamedAreaType.class);
package eu.etaxonomy.cdm.model.location;
import javax.persistence.Embeddable;
+import javax.persistence.FetchType;
import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
@XmlElement(name = "ReferenceSystem")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private ReferenceSystem referenceSystem;
/**
public Point() {
}
- @ManyToOne
public ReferenceSystem getReferenceSystem(){
return this.referenceSystem;
}
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
@XmlType(name = "ReferenceSystem")
@XmlRootElement(name = "ReferenceSystem")
@Entity
-//@Audited
+@Audited
public class ReferenceSystem extends DefinedTermBase<ReferenceSystem> {
private static final long serialVersionUID = 2704455299046749175L;
private static final Logger logger = Logger.getLogger(ReferenceSystem.class);
import javax.xml.bind.annotation.XmlType;\r
\r
import org.apache.log4j.Logger;\r
+import org.hibernate.envers.Audited;\r
import org.jdom.Element;\r
import org.jdom.Namespace;\r
\r
@XmlType(name = "TdwgArea")\r
@XmlRootElement(name = "TdwgArea")\r
@Entity\r
-//@Audited\r
+@Audited\r
public class TdwgArea extends NamedArea {\r
private static final long serialVersionUID = 4662215686356109015L;\r
private static final Logger logger = Logger.getLogger(TdwgArea.class);\r
private static Map<String, UUID> abbrevMap = null;\r
private static Map<String, UUID> labelMap = null;\r
\r
- \r
protected static Map<UUID, TdwgArea> termMap = null; \r
\r
protected static TdwgArea getTermByUuid(UUID uuid){\r
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import au.com.bytecode.opencsv.CSVWriter;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
-import eu.etaxonomy.cdm.model.common.ILoadableTerm;
import eu.etaxonomy.cdm.model.common.Language;
-import eu.etaxonomy.cdm.model.common.TermVocabulary;
/**
* +/- current ISO codes. year given with each entry
})
@XmlRootElement(name = "WaterbodyOrCountry")
@Entity
-//@Audited
+@Audited
public class WaterbodyOrCountry extends NamedArea {
private static final long serialVersionUID = -6791671976199722843L;
private static final Logger logger = Logger.getLogger(WaterbodyOrCountry.class);
* 2 character ISO 3166 Country codes
*/
@XmlAttribute(name = "iso3166_A2")
- private char[] iso3166_A2 = new char[2];
+ @Column(length=2)
+ private String iso3166_A2;
@XmlElementWrapper(name = "Continents")
@XmlElement(name = "Continent")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
+ @JoinTable(name="DefinedTermBase_Continent")
private Set<Continent> continents = new HashSet<Continent>();
private static final UUID uuidAfghanistan = UUID.fromString("974ce01a-5bce-4be8-b728-a46869354960");
return new WaterbodyOrCountry(term, label, labelAbbrev);
}
-
public WaterbodyOrCountry() {
super();
}
super(term, label, labelAbbrev);
}
- @ManyToMany(fetch = FetchType.LAZY)
- @JoinTable(name="DefinedTermBase_Continent")
-// @Cascade({CascadeType.SAVE_UPDATE})
public Set<Continent> getContinents() {
return continents;
}
- protected void setContinents(Set<Continent> continents) {
- this.continents = continents;
- }
public void addContinents(Continent continent) {
this.continents.add(continent);
}
+
public void removeContinents(Continent continent) {
this.continents.remove(continent);
}
* Get 2 character ISO 3166 Country code
* @return a String representation of the ISO 3166 code
*/
- //TODO create userDefinedType ?
- @Column(length=2)
public String getIso3166_A2(){
- return String.valueOf(iso3166_A2);
+ return iso3166_A2;
}
/**
* @param iso3166_A2 a String representation of the ISO 3166 code
*/
public void setIso3166_A2(String iso3166_A2){
- this.iso3166_A2 = iso3166_A2.toCharArray();
+ this.iso3166_A2 = iso3166_A2;
}
// public TimePeriod getValidPeriod(){
}
return null;
}
+
public void writeCsvLine(CSVWriter writer) {
String [] line = new String[6];
line[0] = getUuid().toString();
--- /dev/null
+\r
+@javax.xml.bind.annotation.XmlSchema(namespace = "http://etaxonomy.eu/cdm/model/location/1.0", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)\r
+package eu.etaxonomy.cdm.model.location;
\ No newline at end of file
package eu.etaxonomy.cdm.model.media;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
})
@XmlRootElement(name = "AudioFile")
@Entity
-//@Audited
+@Audited
public class AudioFile extends MediaRepresentationPart {
private static final long serialVersionUID = 2327736023969971196L;
private static final Logger logger = Logger.getLogger(AudioFile.class);
@XmlElement(name = "Duration")
private int duration;
-
public static AudioFile NewInstance(String uri, Integer size){
logger.debug("NewInstance");
return new AudioFile(uri, size);
import java.util.Set;
import javax.persistence.FetchType;
-import javax.persistence.ManyToMany;
import javax.persistence.MappedSuperclass;
-import javax.persistence.Transient;
+import javax.persistence.ManyToMany;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlIDREF;
-import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
@XmlType(name = "IdentifiableMediaEntity", propOrder = {
"media"
})
-@XmlRootElement(name = "IdentifiableMediaEntity")
@MappedSuperclass
public abstract class IdentifiableMediaEntity extends IdentifiableEntity implements IMediaDocumented, IMediaEntity{
@XmlElement(name = "Medium")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private Set<Media> media = getNewMediaSet();
+ @ManyToMany(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
+ private Set<Media> media = new HashSet<Media>();
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.media.IMediaEntity#getMedia()
*/
- @ManyToMany(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<Media> getMedia() {
return media;
}
- protected void setMedia(Set<Media> media) {
- this.media = media;
- }
+
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.media.IMediaEntity#addMedia(eu.etaxonomy.cdm.model.media.Media)
*/
public Object clone() throws CloneNotSupportedException{
IdentifiableMediaEntity result = (IdentifiableMediaEntity)super.clone();
//Media
- Set<Media> media = getNewMediaSet();
- media.addAll(this.media);
- result.setMedia(media);
+ result.media = new HashSet<Media>();
+ for(Media media : this.media) {
+ result.addMedia(media);
+ }
//no changes to: -
return result;
}
-
- @Transient
- private Set<Media> getNewMediaSet(){
- return new HashSet<Media>();
- }
}
import java.util.Calendar;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.common.MediaMetaData.ImageMetaData;
-import eu.etaxonomy.cdm.model.agent.Agent;
+import eu.etaxonomy.cdm.model.agent.AgentBase;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
})
@XmlRootElement(name = "ImageFile")
@Entity
-//@Audited
+@Audited
public class ImageFile extends MediaRepresentationPart {
private static final long serialVersionUID = 5451418445009559953L;
private static final Logger logger = Logger.getLogger(ImageFile.class);
* @param width the width of the image file
* @return
*/
- public static Media NewMediaInstance(Calendar mediaCreated, Agent artist, String uri, String mimeType, String suffix, Integer size, Integer height, Integer width){
+ public static Media NewMediaInstance(Calendar mediaCreated, AgentBase artist, String uri, String mimeType, String suffix, Integer size, Integer height, Integer width){
Media media = Media.NewInstance();
media.setMediaCreated(mediaCreated);
media.setArtist(artist);
package eu.etaxonomy.cdm.model.media;
-
import eu.etaxonomy.cdm.jaxb.MultilanguageTextAdapter;
-import eu.etaxonomy.cdm.model.agent.Agent;
+import eu.etaxonomy.cdm.model.agent.AgentBase;
import eu.etaxonomy.cdm.model.common.AnnotatableEntity;
+import eu.etaxonomy.cdm.model.common.IMultiLanguageText;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.LanguageString;
import eu.etaxonomy.cdm.model.common.MultilanguageText;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import java.util.*;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
+import javax.xml.bind.annotation.XmlElements;
import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
})
@XmlRootElement(name = "Media")
@Entity
-//@Audited
+@Audited
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
public class Media extends AnnotatableEntity {
private static final long serialVersionUID = -1927421567263473658L;
private static final Logger logger = Logger.getLogger(Media.class);
- @XmlElement(name = "MediaTitle")
- @XmlJavaTypeAdapter(MultilanguageTextAdapter.class)
// TODO once hibernate annotations support custom collection type
// private MultilanguageText title = new MultilanguageText();
- private Map<Language, LanguageString> title = new HashMap<Language,LanguageString>();
-
+ @XmlElement(name = "MediaTitle")
+ @XmlJavaTypeAdapter(MultilanguageTextAdapter.class)
+ @OneToMany(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE,CascadeType.DELETE})
+ private Map<Language,LanguageString> title = new HashMap<Language,LanguageString>();
//creation date of the media (not of the record)
@XmlElement(name = "MediaCreated")
+ @Temporal(TemporalType.DATE)
private Calendar mediaCreated;
+ // TODO once hibernate annotations support custom collection type
+ // private MultilanguageText description = new MultilanguageText();
@XmlElement(name = "MediaDescription")
@XmlJavaTypeAdapter(MultilanguageTextAdapter.class)
- // TODO once hibernate annotations support custom collection type
- // private MultilanguageText description = new MultilanguageText();
- private Map<Language, LanguageString> description = new HashMap<Language,LanguageString>();
+ @OneToMany(fetch = FetchType.LAZY)
+ @JoinTable(name = "Media_Description")
+ @Cascade({CascadeType.SAVE_UPDATE,CascadeType.DELETE})
+ private Map<Language,LanguageString> description = new HashMap<Language,LanguageString>();
//A single medium such as a picture can have multiple representations in files.
//Common are multiple resolutions or file formats for images for example
@XmlElementWrapper(name = "MediaRepresentations")
@XmlElement(name = "MediaRepresentation")
+ @OneToMany(mappedBy="media",fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE})
private Set<MediaRepresentation> representations = new HashSet<MediaRepresentation>();
+ // FIXME should be OneToMany?
@XmlElementWrapper(name = "Rights")
@XmlElement(name = "Right")
+ @ManyToMany(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
private Set<Rights> rights = new HashSet<Rights>();
@XmlElement(name = "Artist")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private Agent artist;
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
+ private AgentBase artist;
/**
* Factory method
return new Media();
}
-
/**
* Constructor
*/
super();
}
- @OneToMany(mappedBy="media",fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE})
public Set<MediaRepresentation> getRepresentations(){
return this.representations;
}
- protected void setRepresentations(Set<MediaRepresentation> representations){
- this.representations = representations;
- }
+
@SuppressWarnings("deprecation")
public void addRepresentation(MediaRepresentation representation){
if (representation != null){
representation.setMedia(this);
}
}
+
@SuppressWarnings("deprecation")
public void removeRepresentation(MediaRepresentation representation){
this.getRepresentations().remove(representation);
}
-
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
- public Agent getArtist(){
+ public AgentBase getArtist(){
return this.artist;
}
- public void setArtist(Agent artist){
+
+ public void setArtist(AgentBase artist){
this.artist = artist;
}
-
- @ManyToMany(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<Rights> getRights(){
return this.rights;
}
- protected void setRights(Set<Rights> rights){
- this.rights = rights;
- }
+
public void addRights(Rights rights){
this.rights.add(rights);
}
+
public void removeRights(Rights rights){
this.rights.remove(rights);
}
- @OneToMany (fetch= FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
- @JoinTable(name = "Media_Title")
- public Map<Language, LanguageString> getTitle(){
+ public Map<Language,LanguageString> getTitle(){
return this.title;
}
- public void setTitle(Map<Language,LanguageString> title){
- this.title = title;
+
+ public void addTitle(LanguageString title){
+ this.title.put(title.getLanguage(), title);
+ }
+
+ public void removeTitle(Language language){
+ this.title.remove(language);
}
- @Temporal(TemporalType.DATE)
public Calendar getMediaCreated(){
return this.mediaCreated;
}
+
public void setMediaCreated(Calendar mediaCreated){
this.mediaCreated = mediaCreated;
}
- @OneToMany (fetch= FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
- @JoinTable(name = "Media_Description")
- public Map<Language, LanguageString> getDescription(){
+ public Map<Language,LanguageString> getDescription(){
return this.description;
}
- protected void setDescription(Map<Language, LanguageString> description){
- this.description = description;
- }
- public void addDescription(Language key, LanguageString description){
- this.description.put(key, description);
+
+ public void addDescription(LanguageString description){
+ this.description.put(description.getLanguage(),description);
}
+
public void addDescription(String text, Language language){
this.description.put(language, LanguageString.NewInstance(text, language));
}
+
public void removeDescription(Language language){
this.description.remove(language);
}
-
}
\ No newline at end of file
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlElements;
+import javax.xml.bind.annotation.XmlIDREF;
+import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.XmlType;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.IndexColumn;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.VersionableEntity;
@XmlType(name = "MediaRepresentation", propOrder = {
"mimeType",
"suffix",
+ "media",
"mediaRepresentationParts"
})
@Entity
-//@Audited
+@Audited
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
public class MediaRepresentation extends VersionableEntity {
private static final long serialVersionUID = -1520078266008619806L;
@XmlElement(name = "Suffix")
private String suffix;
- @XmlTransient
+ @XmlElement(name = "Media")
+ @XmlIDREF
+ @XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Media media;
@XmlElementWrapper(name = "MediaRepresentationParts")
@XmlElement(name = "ImageFile", namespace = "http://etaxonomy.eu/cdm/model/media/1.0", type = ImageFile.class),
@XmlElement(name = "MovieFile", namespace = "http://etaxonomy.eu/cdm/model/media/1.0", type = MovieFile.class)
})
+ @OneToMany (cascade = {javax.persistence.CascadeType.ALL}, fetch= FetchType.LAZY)
+ @IndexColumn(name="sortIndex", base = 0)
+ @JoinColumn (name = "representation_id", nullable=false)
+ @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
private List<MediaRepresentationPart> mediaRepresentationParts = new ArrayList<MediaRepresentationPart>();
/**
this.suffix = suffix;
}
- @ManyToOne(fetch = FetchType.LAZY)
public Media getMedia() {
return media;
}
}
- @OneToMany (cascade = {javax.persistence.CascadeType.ALL}, fetch= FetchType.LAZY)
- @IndexColumn(name="sortIndex", base = 0)
- @JoinColumn (name = "representation_id", nullable=false)
- @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
public List<MediaRepresentationPart> getParts(){
return this.mediaRepresentationParts;
}
- protected void setParts(List<MediaRepresentationPart> mediaRepresentationParts){
- this.mediaRepresentationParts = mediaRepresentationParts;
- }
+
@SuppressWarnings("deprecation")
public void addRepresentationPart(MediaRepresentationPart mediaRepresentationPart){
if (mediaRepresentationPart != null){
import javax.xml.bind.annotation.XmlAccessType;\r
import javax.xml.bind.annotation.XmlAccessorType;\r
import javax.xml.bind.annotation.XmlElement;\r
+import javax.xml.bind.annotation.XmlIDREF;\r
+import javax.xml.bind.annotation.XmlSchemaType;\r
import javax.xml.bind.annotation.XmlTransient;\r
import javax.xml.bind.annotation.XmlType;\r
\r
import org.apache.log4j.Logger;\r
+import org.hibernate.annotations.Cascade;\r
+import org.hibernate.annotations.CascadeType;\r
+import org.hibernate.envers.Audited;\r
\r
import eu.etaxonomy.cdm.model.common.VersionableEntity;\r
\r
* @version 1.0\r
*/\r
@XmlAccessorType(XmlAccessType.FIELD)\r
-@XmlType(name = "MediaRepresentationPart", propOrder = { "uri", "size" })\r
+@XmlType(name = "MediaRepresentationPart", propOrder = { \r
+ "uri", \r
+ "size",\r
+ "mediaRepresentation"\r
+ })\r
@Entity\r
-//@Audited\r
+@Audited\r
public class MediaRepresentationPart extends VersionableEntity {\r
private static final long serialVersionUID = -1674422508643785796L;\r
private static final Logger logger = Logger.getLogger(MediaRepresentationPart.class);\r
private Integer size;\r
\r
// the MediaRepresentation of this MediaRepresentationPart\r
- @XmlTransient\r
+ @XmlElement(name = "MediaRepresentation")\r
+ @XmlIDREF\r
+ @XmlSchemaType(name = "IDREF")\r
+ @ManyToOne(fetch = FetchType.LAZY)\r
+ @JoinColumn(name = "representation_id", nullable = false, updatable = false, insertable = false)\r
+ @Cascade(CascadeType.SAVE_UPDATE)\r
private MediaRepresentation mediaRepresentation;\r
\r
/**\r
\r
/*************** getter /setter *************************************/\r
\r
- @ManyToOne(fetch = FetchType.LAZY)\r
- @JoinColumn(name = "representation_id", nullable = false, updatable = false, insertable = false)\r
public MediaRepresentation getMediaRepresentation() {\r
return this.mediaRepresentation;\r
}\r
package eu.etaxonomy.cdm.model.media;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
})
@XmlRootElement(name = "MovieFile")
@Entity
-//@Audited
+@Audited
public class MovieFile extends MediaRepresentationPart {
private static final long serialVersionUID = 8650308822737671731L;
private static final Logger logger = Logger.getLogger(MovieFile.class);
package eu.etaxonomy.cdm.model.media;
-import eu.etaxonomy.cdm.model.common.IReferencedEntity;
-import eu.etaxonomy.cdm.model.reference.ReferenceBase;
-import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
-
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+
+import eu.etaxonomy.cdm.model.common.IReferencedEntity;
+import eu.etaxonomy.cdm.model.reference.ReferenceBase;
+
/**
* @author m.doering
* @version 1.0
})
@XmlRootElement(name = "ReferencedMedia")
@Entity
-//@Audited
+@Audited
public abstract class ReferencedMedia extends Media implements IReferencedEntity {
static Logger logger = Logger.getLogger(ReferencedMedia.class);
@XmlElement(name = "Citation")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private ReferenceBase citation;
-
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public ReferenceBase getCitation(){
return this.citation;
}
+
public void setCitation(ReferenceBase citation){
this.citation = citation;
}
public String getCitationMicroReference(){
return this.citationMicroReference;
}
+
public void setCitationMicroReference(String citationMicroReference){
this.citationMicroReference = citationMicroReference;
}
package eu.etaxonomy.cdm.model.media;
-import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
-
-import eu.etaxonomy.cdm.model.agent.Agent;
-import eu.etaxonomy.cdm.model.common.Language;
-import eu.etaxonomy.cdm.model.common.LanguageStringBase;
-
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+
+import eu.etaxonomy.cdm.model.agent.AgentBase;
+import eu.etaxonomy.cdm.model.common.Language;
+import eu.etaxonomy.cdm.model.common.LanguageStringBase;
+
/**
* Typically, rights information includes a statement about various property
* rights associated with the resource, including intellectual property rights.
})
@XmlRootElement(name = "Rights")
@Entity
-//@Audited
+@Audited
public class Rights extends LanguageStringBase {
private static final long serialVersionUID = 4920749849951432284L;
private static final Logger logger = Logger.getLogger(Rights.class);
@XmlElement(name = "Type")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private RightsTerm type;
// owner etc as defined by the rightstype
@XmlElement(name = "Agent")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private Agent agent;
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
+ private AgentBase agent;
/**
super(text, language);
}
-
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public RightsTerm getType(){
return this.type;
}
+
public void setType(RightsTerm type){
this.type = type;
}
-
public String getUri(){
return this.uri;
}
+
public void setUri(String uri){
this.uri = uri;
}
-
-
+
public String getAbbreviatedText(){
return this.abbreviatedText;
}
+
public void setAbbreviatedText(String abbreviatedStatement){
this.abbreviatedText = abbreviatedStatement;
}
-
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
- public Agent getAgent() {
+ public AgentBase getAgent() {
return agent;
}
- public void setAgent(Agent agent) {
+
+ public void setAgent(AgentBase agent) {
this.agent = agent;
}
-
}
\ No newline at end of file
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
@XmlType(name = "RightsTerm")
@XmlRootElement(name = "RightsTerm")
@Entity
-//@Audited
+@Audited
public class RightsTerm extends DefinedTermBase<RightsTerm> {
private static final long serialVersionUID = -5823263624000932116L;
private static final Logger logger = Logger.getLogger(RightsTerm.class);
--- /dev/null
+\r
+@javax.xml.bind.annotation.XmlSchema(namespace = "http://etaxonomy.eu/cdm/model/media/1.0", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)\r
+package eu.etaxonomy.cdm.model.media;
\ No newline at end of file
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.occurrence.Collection;
import eu.etaxonomy.cdm.model.occurrence.DerivedUnitBase;
})
@XmlRootElement(name = "DnaSample")
@Entity
-//@Audited
+@Audited
public class DnaSample extends Specimen implements Cloneable {
private static final long serialVersionUID = -2978411330023671805L;
private static final Logger logger = Logger.getLogger(DnaSample.class);
@XmlElement(name = "sequence")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private Set<Sequence> sequences = getNewSequenceSet();
+ @OneToMany(fetch = FetchType.LAZY)
+ private Set<Sequence> sequences = new HashSet<Sequence>();
- @OneToMany(fetch = FetchType.LAZY)
public Set<Sequence> getSequences() {
return sequences;
}
- protected void setSequences(Set<Sequence> sequences) {
- this.sequences = sequences;
- }
+
+ // FIXME shouldn't this be the singular? i.e. addSequence( . . . )
public void addSequences(Sequence sequence) {
this.sequences.add(sequence);
}
+
+ // FIXME shouldn't this be the singular? i.e. removeSequence( . . . )
public void removeSequences(Sequence sequence) {
this.sequences.remove(sequence);
}
-
- @Transient
public Collection getStoredAt(){
- logger.debug("getStoredAt");
return this.getCollection();
}
+
public void setStoredAt(Collection storedAt){
this.setCollection(storedAt);
}
- @Transient
public Set<SpecimenOrObservationBase> getExtractedFrom(){
return getOriginals();
}
- @Transient
public String getBankNumber(){
return this.getCatalogNumber();
}
+
public void setBankNumber(String bankNumber){
this.setCatalogNumber(bankNumber);
}
public DnaSample clone(){
DnaSample result = (DnaSample)super.clone();
//sequenceSet
- Set<Sequence> sequenceSet = getNewSequenceSet();
- sequenceSet.addAll(this.sequences);
- result.setSequences(sequenceSet);
+ result.sequences = new HashSet<Sequence>();
+ for(Sequence sequence : this.sequences) {
+ result.addSequences(sequence);
+ }
//no changes to: bankNumber
return result;
}
-
- @Transient
- private Set<Sequence> getNewSequenceSet(){
- return new HashSet<Sequence>();
- }
-
-
}
\ No newline at end of file
import eu.etaxonomy.cdm.model.common.VersionableEntity;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
})
@XmlRootElement(name = "GenBankAccession")
@Entity
-//@Audited
+@Audited
public class GenBankAccession extends VersionableEntity {
private static final long serialVersionUID = -8179493118062601585L;
private static final Logger logger = Logger.getLogger(GenBankAccession.class);
import eu.etaxonomy.cdm.model.common.VersionableEntity;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
})
@XmlRootElement(name = "Locus")
@Entity
-//@Audited
+@Audited
public class Locus extends VersionableEntity {
private static final long serialVersionUID = 3907156009866200988L;
private static final Logger logger = Logger.getLogger(Locus.class);
import eu.etaxonomy.cdm.model.media.ReferencedMedia;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import java.util.*;
})
@XmlRootElement(name = "PhylogeneticTree")
@Entity
-//@Audited
+@Audited
public class PhylogeneticTree extends ReferencedMedia {
private static final long serialVersionUID = -7020182117362324067L;
private static final Logger logger = Logger.getLogger(PhylogeneticTree.class);
@XmlElement(name = "UsedSequence")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch = FetchType.LAZY)
private Set<Sequence> usedSequences = new HashSet<Sequence>();
- @OneToMany(fetch = FetchType.LAZY)
public Set<Sequence> getUsedSequences() {
logger.debug("getUsedSequences");
return usedSequences;
}
- protected void setUsedSequences(Set<Sequence> usedSequences) {
- this.usedSequences = usedSequences;
- }
+
public void addUsedSequences(Sequence usedSequence) {
this.usedSequences.add(usedSequence);
}
+
public void removeUsedSequences(Sequence usedSequence) {
this.usedSequences.remove(usedSequence);
}
-
}
\ No newline at end of file
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
import eu.etaxonomy.cdm.model.common.IReferencedEntity;
import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.Index;
import org.hibernate.annotations.Table;
+import org.hibernate.envers.Audited;
import java.util.*;
"sequence",
"length",
"dateSequenced",
- "isBarcode",
+ "barcode",
"citationMicroReference",
"publishedIn",
"locus",
})
@XmlRootElement(name = "Sequence")
@Entity
-//@Audited
+@Audited
@Table(appliesTo="Sequence", indexes = { @Index(name = "sequenceTitleCacheIndex", columnNames = { "titleCache" }) })
public class Sequence extends IdentifiableEntity implements IReferencedEntity, IMediaDocumented{
private static final long serialVersionUID = 8298983152731241775L;
//should be calculated in case sequence is set
@XmlElement(name = "DateSequenced")
+ @Temporal(TemporalType.DATE)
private Calendar dateSequenced;
//should be calculated in case sequence is set
@XmlAttribute(name = "isBarcode")
- private boolean isBarcode;
+ private boolean barcode;
//the sequence as a string of base pairs. 5'->3'
@XmlElement(name = "CitationMicroReference")
private String citationMicroReference;
- @XmlElement(name = "IublishedIn")
+ @XmlElement(name = "PublishedIn")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private ReferenceBase publishedIn;
@XmlElementWrapper(name = "Citations")
@XmlElement(name = "Citation")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch = FetchType.LAZY)
private Set<ReferenceBase> citations = new HashSet<ReferenceBase>();
@XmlElementWrapper(name = "GenBankAccessions")
@XmlElement(name = "GenBankAccession")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch = FetchType.LAZY)
private Set<GenBankAccession> genBankAccession = new HashSet<GenBankAccession>();
@XmlElement(name = "Locus")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Locus locus;
@XmlElementWrapper(name = "Chromatograms")
@XmlElement(name = "Chromatogram")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch = FetchType.LAZY)
private Set<Media> chromatograms = new HashSet<Media>();
-
- @ManyToOne(fetch = FetchType.LAZY)
+
public Locus getLocus(){
logger.debug("getLocus");
return this.locus;
}
+
public void setLocus(Locus locus){
this.locus = locus;
}
- @ManyToOne(fetch = FetchType.LAZY)
public ReferenceBase getPublishedIn(){
return this.publishedIn;
}
+
public void setPublishedIn(ReferenceBase publishedIn){
this.publishedIn = publishedIn;
}
-
-
- @OneToMany(fetch = FetchType.LAZY)
public Set<ReferenceBase> getCitations() {
return citations;
}
this.citations.remove(citation);
}
-
- @OneToMany(fetch = FetchType.LAZY)
public Set<GenBankAccession> getGenBankAccession() {
return genBankAccession;
}
- protected void setGenBankAccession(Set<GenBankAccession> genBankAccession) {
- this.genBankAccession = genBankAccession;
- }
public void addGenBankAccession(GenBankAccession genBankAccession) {
this.genBankAccession.add(genBankAccession);
}
+
public void removeGenBankAccession(GenBankAccession genBankAccession) {
this.genBankAccession.remove(genBankAccession);
}
-
- @OneToMany(fetch = FetchType.LAZY)
public Set<Media> getChromatograms() {
return chromatograms;
}
- protected void setChromatograms(Set<Media> chromatograms) {
- this.chromatograms = chromatograms;
- }
public void addChromatogram(Media chromatogram) {
this.chromatograms.add(chromatogram);
}
+
public void removeChromatogram(Media chromatogram) {
this.chromatograms.remove(chromatogram);
}
- @Transient
public Set<Media> getMedia() {
return getChromatograms();
}
-
public String getSequence(){
return this.sequence;
}
this.length = length;
}
- @Temporal(TemporalType.DATE)
public Calendar getDateSequenced(){
return this.dateSequenced;
}
}
public boolean isBarcode(){
- return this.isBarcode;
+ return this.barcode;
}
/**
*
* @param isBarcode isBarcode
*/
- public void setBarcode(boolean isBarcode){
- this.isBarcode = isBarcode;
+ public void setBarcode(boolean barcode){
+ this.barcode = barcode;
}
public String getCitationMicroReference(){
return "";
}
- @Transient
public ReferenceBase getCitation(){
- return null;
+ return publishedIn;
}
}
\ No newline at end of file
--- /dev/null
+\r
+@javax.xml.bind.annotation.XmlSchema(namespace = "http://etaxonomy.eu/cdm/model/molecular/1.0", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)\r
+package eu.etaxonomy.cdm.model.molecular;
\ No newline at end of file
package eu.etaxonomy.cdm.model.name;
-import javax.persistence.Entity;
-import javax.persistence.Transient;
+import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
+
+import eu.etaxonomy.cdm.strategy.cache.name.BotanicNameDefaultCacheStrategy;
+import eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy;
+
+import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
-import org.apache.log4j.Logger;
-
/**
* The taxon name class for bacteria.
* <P>
})
@XmlRootElement(name = "BacterialName")
@Entity
-//@Audited
-public class BacterialName extends NonViralName {
+@Audited
+public class BacterialName extends NonViralName<BacterialName> {
+ /**
+ *
+ */
+ private static final long serialVersionUID = -7641841279209976443L;
+
static Logger logger = Logger.getLogger(BacterialName.class);
//Author team and year of the subgenus name
* @see NonViralName#isCodeCompliant()
* @see TaxonNameBase#getHasProblem()
*/
- @Transient
@Override
public NomenclaturalCode getNomenclaturalCode(){
return NomenclaturalCode.ICNB;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.OneToMany;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
import eu.etaxonomy.cdm.model.common.RelationshipBase;
import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;
+import eu.etaxonomy.cdm.model.reference.ReferenceBase;
import eu.etaxonomy.cdm.strategy.cache.name.BotanicNameDefaultCacheStrategy;
import eu.etaxonomy.cdm.strategy.parser.INonViralNameParser;
import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "BotanicalName", propOrder = {
- "isHybridFormula",
- "isMonomHybrid",
- "isBinomHybrid",
- "isTrinomHybrid",
- "isAnamorphic",
+ "hybridFormula",
+ "monomHybrid",
+ "binomHybrid",
+ "trinomHybrid",
+ "anamorphic",
"hybridRelationships"
})
@XmlRootElement(name = "BotanicalName")
@Entity
-//@Audited
-public class BotanicalName extends NonViralName {
+@Audited
+public class BotanicalName extends NonViralName<BotanicalName> {
+ /**
+ *
+ */
+ private static final long serialVersionUID = 6818651572463497727L;
+
private static final Logger logger = Logger.getLogger(BotanicalName.class);
//if set: this name is a hybrid formula (a hybrid that does not have an own name) and no other hybrid flags may be set. A
//hybrid name may not have either an authorteam nor other name components.
@XmlElement(name ="IsHybridFormula")
- private boolean isHybridFormula = false;
+ private boolean hybridFormula = false;
@XmlElement(name ="IsMonomHybrid")
- private boolean isMonomHybrid = false;
+ private boolean monomHybrid = false;
@XmlElement(name ="IsBinomHybrid")
- private boolean isBinomHybrid = false;
+ private boolean binomHybrid = false;
@XmlElement(name ="IsTrinomHybrid")
- private boolean isTrinomHybrid = false;
+ private boolean trinomHybrid = false;
//Only for fungi: to indicate that the type of the name is asexual or not
@XmlElement(name ="IsAnamorphic")
- private boolean isAnamorphic;
+ private boolean anamorphic;
@XmlElementWrapper(name = "HybridRelationships")
@XmlElement(name = "HybridRelationship")
+ @OneToMany(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
private Set<HybridRelationship> hybridRelationships = new HashSet();
static private INonViralNameParser nameParser = new NonViralNameParserImpl();
* @see #addHybridRelationship(HybridRelationship)
* @see #addRelationship(RelationshipBase)
*/
- @OneToMany(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
public Set<HybridRelationship> getHybridRelationships() {
return hybridRelationships;
}
- /**
- * @see #getHybridRelationships()
- */
- protected void setHybridRelationships(Set<HybridRelationship> relationships) {
- this.hybridRelationships = relationships;
- }
+
/**
* Adds the given {@link HybridRelationship hybrid relationship} to the set
* of {@link #getHybridRelationships() hybrid relationships} of both botanical taxon names
* @see #getChildRelationships()
* @see HybridRelationshipType
*/
- @Transient
public Set<HybridRelationship> getParentRelationships() {
// FIXME: filter relations
return hybridRelationships;
* @see #getParentRelationships()
* @see HybridRelationshipType
*/
- @Transient
public Set<HybridRelationship> getChildRelationships() {
// FIXME: filter relations
return hybridRelationships;
* @see #isTrinomHybrid()
*/
public boolean isHybridFormula(){
- return this.isHybridFormula;
+ return this.hybridFormula;
}
/**
* @see #isHybridFormula()
*/
- public void setHybridFormula(boolean isHybridFormula){
- this.isHybridFormula = isHybridFormula;
+ public void setHybridFormula(boolean hybridFormula){
+ this.hybridFormula = hybridFormula;
}
/**
* @see #isTrinomHybrid()
*/
public boolean isMonomHybrid(){
- return this.isMonomHybrid;
+ return this.monomHybrid;
}
/**
* @see #isBinomHybrid()
* @see #isTrinomHybrid()
*/
- public void setMonomHybrid(boolean isMonomHybrid){
- this.isMonomHybrid = isMonomHybrid;
+ public void setMonomHybrid(boolean monomHybrid){
+ this.monomHybrid = monomHybrid;
}
/**
* @see #isTrinomHybrid()
*/
public boolean isBinomHybrid(){
- return this.isBinomHybrid;
+ return this.binomHybrid;
}
/**
* @see #isMonomHybrid()
* @see #isTrinomHybrid()
*/
- public void setBinomHybrid(boolean isBinomHybrid){
- this.isBinomHybrid = isBinomHybrid;
+ public void setBinomHybrid(boolean binomHybrid){
+ this.binomHybrid = binomHybrid;
}
/**
* @see #isBinomHybrid()
*/
public boolean isTrinomHybrid(){
- return this.isTrinomHybrid;
+ return this.trinomHybrid;
}
/**
* @see #isBinomHybrid()
* @see #isMonomHybrid()
*/
- public void setTrinomHybrid(boolean isTrinomHybrid){
- this.isTrinomHybrid = isTrinomHybrid;
+ public void setTrinomHybrid(boolean trinomHybrid){
+ this.trinomHybrid = trinomHybrid;
}
/**
* @return the boolean value of the isAnamorphic flag
*/
public boolean isAnamorphic(){
- return this.isAnamorphic;
+ return this.anamorphic;
}
/**
* @see #isAnamorphic()
*/
- public void setAnamorphic(boolean isAnamorphic){
- this.isAnamorphic = isAnamorphic;
+ public void setAnamorphic(boolean anamorphic){
+ this.anamorphic = anamorphic;
}
* @see NonViralName#isCodeCompliant()
* @see TaxonNameBase#getHasProblem()
*/
- @Transient
@Override
public NomenclaturalCode getNomenclaturalCode(){
return NomenclaturalCode.ICBN;
-
}
}
\ No newline at end of file
package eu.etaxonomy.cdm.model.name;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
})
@XmlRootElement(name = "CultivarPlantName")
@Entity
-//@Audited
+@Audited
public class CultivarPlantName extends BotanicalName {
static Logger logger = Logger.getLogger(CultivarPlantName.class);
* @see NonViralName#isCodeCompliant()
* @see TaxonNameBase#getHasProblem()
*/
- @Transient
@Override
public NomenclaturalCode getNomenclaturalCode(){
return NomenclaturalCode.ICNCP;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.OneToMany;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.AnnotatableEntity;
import eu.etaxonomy.cdm.model.reference.ReferenceBase;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.TaxonComparator;
-import eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy;
/**
"typifiedNames"
})
@Entity
-//@Audited
+@Audited
public class HomotypicalGroup extends AnnotatableEntity {
static Logger logger = Logger.getLogger(HomotypicalGroup.class);
@XmlElement(name = "TypifiedName")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(mappedBy="homotypicalGroup", fetch=FetchType.LAZY)
protected Set<TaxonNameBase> typifiedNames = new HashSet<TaxonNameBase>();
/**
*
* @see #getSpecimenTypeDesignations()
*/
- @OneToMany(mappedBy="homotypicalGroup", fetch=FetchType.LAZY)
public Set<TaxonNameBase> getTypifiedNames() {
return typifiedNames;
}
- /**
- * @see #getTypifiedNames()
- */
- protected void setTypifiedNames(Set<TaxonNameBase> typifiedNames) {
- this.typifiedNames = typifiedNames;
- }
/**
* Adds a new {@link TaxonNameBase taxon name} to the set of taxon names that belong
* @see #getTypeDesignations()
* @see TaxonNameBase#getSpecimenTypeDesignations()
*/
- @Transient
public Set<SpecimenTypeDesignation> getSpecimenTypeDesignations(){
Set<SpecimenTypeDesignation> result = new HashSet<SpecimenTypeDesignation>();
for (TaxonNameBase taxonName : typifiedNames){
* @see #getTypeDesignations()
* @see TaxonNameBase#getNameTypeDesignations()
*/
- @Transient
public Set<NameTypeDesignation> getNameTypeDesignations(){
Set<NameTypeDesignation> result = new HashSet<NameTypeDesignation>();
for (TaxonNameBase taxonName : typifiedNames){
* @see #getSpecimenTypeDesignations()
* @see TaxonNameBase#getTypeDesignations()
*/
- @Transient
public Set<TypeDesignationBase> getTypeDesignations(){
Set<TypeDesignationBase> result = new HashSet<TypeDesignationBase>();
for (TaxonNameBase taxonName : typifiedNames){
* @see TaxonNameBase#getTaxa()
* @see taxon.Synonym
*/
- @Transient
public List<Synonym> getSynonymsInGroup(ReferenceBase sec){
List<Synonym> result = new ArrayList();
for (TaxonNameBase<?, ?>n : this.getTypifiedNames()){
package eu.etaxonomy.cdm.model.name;
-import eu.etaxonomy.cdm.model.common.RelationshipBase;
-import eu.etaxonomy.cdm.model.reference.ReferenceBase;
-
-import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
-
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+
+import eu.etaxonomy.cdm.model.common.RelationshipBase;
+import eu.etaxonomy.cdm.model.reference.ReferenceBase;
+
/**
* The class representing a hybrid relationship between one of the {@link BotanicalName parents}
* of a hybrid taxon name and the hybrid taxon name itself. A hybrid taxon name
"ruleConsidered"
})
@Entity
-//@Audited
+@Audited
public class HybridRelationship extends RelationshipBase<BotanicalName, BotanicalName, HybridRelationshipType> {
private static final Logger logger = Logger.getLogger(HybridRelationship.class);
@XmlElement(name = "RelatedFrom")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private BotanicalName relatedFrom;
@XmlElement(name = "RelatedTo")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private BotanicalName relatedTo;
@XmlElement(name = "Type")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.LAZY)
private HybridRelationshipType type;
//for hibernate use only, don't use
* @see #getHybridName()
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom()
*/
- @Transient
public BotanicalName getParentName(){
return this.getRelatedFrom();
}
* @see #getParentName()
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedTo()
*/
- @Transient
public BotanicalName getHybridName(){
return this.getRelatedTo();
}
this.ruleConsidered = ruleConsidered;
}
- @ManyToOne(fetch=FetchType.EAGER)
- @Cascade({CascadeType.SAVE_UPDATE})
protected BotanicalName getRelatedFrom() {
return relatedFrom;
}
- @ManyToOne(fetch=FetchType.EAGER)
- @Cascade({CascadeType.SAVE_UPDATE})
protected BotanicalName getRelatedTo() {
return relatedTo;
}
- @ManyToOne(fetch = FetchType.LAZY)
public HybridRelationshipType getType() {
return type;
}
import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
@XmlType(name = "HybridRelationshipType")
@XmlRootElement(name = "HybridRelationshipType")
@Entity
-//@Audited
+@Audited
public class HybridRelationshipType extends RelationshipTermBase<HybridRelationshipType> {
static Logger logger = Logger.getLogger(HybridRelationshipType.class);
package eu.etaxonomy.cdm.model.name;
-import eu.etaxonomy.cdm.model.common.RelationshipBase;
-import eu.etaxonomy.cdm.model.reference.ReferenceBase;
-import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
-
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+
+import eu.etaxonomy.cdm.model.common.RelationshipBase;
+import eu.etaxonomy.cdm.model.reference.ReferenceBase;
+
/**
* The class representing a relationship between two {@link TaxonNameBase taxon names} according
* to the {@link NomenclaturalCode nomenclatural code} which governs both of them.
"ruleConsidered"
})
@Entity
-//@Audited
+@Audited
public class NameRelationship extends RelationshipBase<TaxonNameBase, TaxonNameBase, NameRelationshipType> {
static Logger logger = Logger.getLogger(NameRelationship.class);
@XmlElement(name = "RelatedFrom")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private TaxonNameBase relatedFrom;
@XmlElement(name = "RelatedTo")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private TaxonNameBase relatedTo;
@XmlElement(name = "Type")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private NameRelationshipType type;
//for hibernate, don't use
* @see #getToName()
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom()
*/
- @Transient
public TaxonNameBase getFromName(){
return this.getRelatedFrom();
}
+
/**
* @see #getFromName()
*/
* @see #getFromName()
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedTo()
*/
- @Transient
public TaxonNameBase getToName(){
return this.getRelatedTo();
}
+
/**
* @see #getToName()
*/
this.ruleConsidered = ruleConsidered;
}
- @ManyToOne(fetch=FetchType.EAGER)
- @Cascade({CascadeType.SAVE_UPDATE})
protected TaxonNameBase getRelatedFrom() {
return relatedFrom;
}
- @ManyToOne(fetch=FetchType.EAGER)
- @Cascade({CascadeType.SAVE_UPDATE})
protected TaxonNameBase getRelatedTo() {
return relatedTo;
}
- @ManyToOne(fetch = FetchType.LAZY)
public NameRelationshipType getType() {
return type;
}
-
protected void setRelatedFrom(TaxonNameBase relatedFrom) {
this.relatedFrom = relatedFrom;
}
-
protected void setRelatedTo(TaxonNameBase relatedTo) {
this.relatedTo = relatedTo;
}
-
protected void setType(NameRelationshipType type) {
this.type = type;
}
-
}
\ No newline at end of file
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.RelationshipTermBase;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "NameRelationshipType")
@Entity
-//@Audited
+@Audited
public class NameRelationshipType extends RelationshipTermBase<NameRelationshipType> {
static Logger logger = Logger.getLogger(NameRelationshipType.class);
* @see NomenclaturalStatusType#isInvalidType()
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom()
*/
- @Transient
public boolean isInvalidType(){
if (this.equals(VALIDATED_BY_NAME()) ||
this.equals(LATER_VALIDATED_BY_NAME())
* @see NomenclaturalStatusType#isLegitimateType()
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom()
*/
- @Transient
public boolean isLegitimateType(){
if (this.equals(BASIONYM()) ||
this.equals(REPLACED_SYNONYM()) ||
* @see NomenclaturalStatusType#isIllegitimateType()
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom()
*/
- @Transient
public boolean isIllegitimateType(){
//TODO: implement isX method. Maybe as persistent class attribute?
//TODO: RejectedInFavour,
package eu.etaxonomy.cdm.model.name;
-import java.util.HashSet;
-import java.util.Set;
-
import javax.persistence.Entity;
import javax.persistence.FetchType;
-import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
-import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.ReferencedEntityBase;
import eu.etaxonomy.cdm.model.reference.ReferenceBase;
@XmlRootElement(name = "NameTypeDesignation")
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "NameTypeDesignation", propOrder = {
- "isRejectedType",
- "isConservedType",
- "isLectoType",
+ "rejectedType",
+ "conservedType",
+ "lectoType",
"typeName"
})
@Entity
-//@Audited
+@Audited
public class NameTypeDesignation extends TypeDesignationBase implements ITypeDesignation {
static Logger logger = Logger.getLogger(NameTypeDesignation.class);
@XmlElement(name = "IsRejectedType")
- private boolean isRejectedType;
+ private boolean rejectedType;
@XmlElement(name = "IsConservedType")
- private boolean isConservedType;
+ private boolean conservedType;
@XmlElement(name = "IsLectoType")
- private boolean isLectoType;
+ private boolean lectoType;
@XmlElement(name = "TypeName")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private TaxonNameBase typeName;
// @XmlElement(name = "HomotypicalGroup")
* @see TaxonNameBase#addNameTypeDesignation(TaxonNameBase, ReferenceBase, String, String, boolean, boolean, boolean, boolean, boolean)
*/
protected NameTypeDesignation(TaxonNameBase typeName, ReferenceBase citation, String citationMicroReference,
- String originalNameString, boolean isRejectedType, boolean isConservedType, boolean isNotDesignated) {
+ String originalNameString, boolean rejectedType, boolean conservedType, boolean isNotDesignated) {
super(citation, citationMicroReference, originalNameString, isNotDesignated);
this.setTypeName(typeName);
- this.isRejectedType = isRejectedType;
- this.isConservedType = isConservedType;
+ this.rejectedType = rejectedType;
+ this.conservedType = conservedType;
}
//********* METHODS **************************************/
* taxon name type in <i>this</i> taxon name type designation. The {@link Rank rank}
* of the taxon name type must be "species".
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public TaxonNameBase getTypeName(){
return this.typeName;
}
* @see #isConservedType()
*/
public boolean isRejectedType(){
- return this.isRejectedType;
+ return this.rejectedType;
}
/**
* @see #isRejectedType()
*/
- public void setRejectedType(boolean isRejectedType){
- this.isRejectedType = isRejectedType;
+ public void setRejectedType(boolean rejectedType){
+ this.rejectedType = rejectedType;
}
/**
* @see #isRejectedType()
*/
public boolean isConservedType(){
- return this.isConservedType;
+ return this.conservedType;
}
/**
* @see #isConservedType()
*/
- public void setConservedType(boolean isConservedType){
- this.isConservedType = isConservedType;
+ public void setConservedType(boolean conservedType){
+ this.conservedType = conservedType;
}
/**
* @see eu.etaxonomy.cdm.model.name.ITypeDesignation#isLectoType()
*/
public boolean isLectoType() {
- return isLectoType;
+ return lectoType;
}
/**
* @see #isLectoType()
*/
- public void setLectoType(boolean isLectoType) {
- this.isLectoType = isLectoType;
+ public void setLectoType(boolean lectoType) {
+ this.lectoType = lectoType;
}
-
}
\ No newline at end of file
\r
package eu.etaxonomy.cdm.model.name;\r
\r
-import java.util.HashMap;\r
import java.util.HashSet;\r
import java.util.List;\r
import java.util.Map;\r
import java.util.Set;\r
import java.util.UUID;\r
\r
-import javax.persistence.Entity;\r
-import javax.persistence.Transient;\r
-import javax.xml.bind.annotation.XmlAccessType;\r
-import javax.xml.bind.annotation.XmlAccessorType;\r
+import javax.xml.bind.annotation.XmlEnum;\r
+import javax.xml.bind.annotation.XmlEnumValue;\r
+import javax.xml.bind.annotation.XmlType;\r
\r
import org.apache.log4j.Logger;\r
\r
import au.com.bytecode.opencsv.CSVWriter;\r
-\r
-import eu.etaxonomy.cdm.model.common.DefaultTermInitializer;\r
import eu.etaxonomy.cdm.model.common.DefinedTermBase;\r
import eu.etaxonomy.cdm.model.common.IDefinedTerm;\r
-import eu.etaxonomy.cdm.model.common.TermVocabulary;\r
import eu.etaxonomy.cdm.model.media.Media;\r
\r
/**\r
* @version 2.0\r
*/\r
\r
+@XmlType(name = "NomenclaturalCode")\r
+@XmlEnum\r
public enum NomenclaturalCode implements IDefinedTerm<NomenclaturalCode> {\r
//International Code of Nomenclature of Bacteria\r
- ICNB(UUID.fromString("ff4b0979-7abf-4b40-95c0-8b8b1e8a4d5e"), 1 ), \r
+ @XmlEnumValue("ICNB") ICNB(UUID.fromString("ff4b0979-7abf-4b40-95c0-8b8b1e8a4d5e")), \r
//International Code of Botanical Nomenclature\r
- ICBN(UUID.fromString("540fc02a-8a8e-4813-89d2-581dad4dd482"), 2 ), \r
+ @XmlEnumValue("ICBN") ICBN(UUID.fromString("540fc02a-8a8e-4813-89d2-581dad4dd482")), \r
//International Code of Cultivated Plants\r
- ICNCP(UUID.fromString("65a432b5-92b1-4c9a-8090-2a185e423d2e"), 3 ), \r
+ @XmlEnumValue("ICNCP") ICNCP(UUID.fromString("65a432b5-92b1-4c9a-8090-2a185e423d2e")), \r
//International Code of Zoological Nomenclature\r
- ICZN(UUID.fromString("b584c2f8-dbe5-4454-acad-2b45e63ec11b"), 4 ), \r
+ @XmlEnumValue("ICZN") ICZN(UUID.fromString("b584c2f8-dbe5-4454-acad-2b45e63ec11b")), \r
//International Code for Virus Classification and Nomenclature\r
- ICVCN(UUID.fromString("e9d6d6b4-ccb7-4f28-b828-0b1501f8c75a"), 5 );\r
- \r
+ @XmlEnumValue("ICVCN") ICVCN(UUID.fromString("e9d6d6b4-ccb7-4f28-b828-0b1501f8c75a")); \r
\r
private static final Logger logger = Logger.getLogger(NomenclaturalCode.class);\r
\r
private UUID uuid;\r
- private Integer id;\r
\r
- private NomenclaturalCode(UUID uuid, int id){\r
+ private NomenclaturalCode(UUID uuid){\r
this.uuid = uuid;\r
- this.id = id;\r
}\r
\r
\r
* @see BacterialName#NewInstance(Rank)\r
* @see ViralName#NewInstance(Rank)\r
*/\r
- @Transient\r
public TaxonNameBase<?,?> getNewTaxonNameInstance(Rank rank){\r
TaxonNameBase<?,?> result;\r
- if (this.equals(NomenclaturalCode.ICBN)){\r
- result = BotanicalName.NewInstance(rank);\r
- }else if (this.equals(NomenclaturalCode.ICZN)){\r
+ NomenclaturalCode nomCode = this;\r
+ \r
+ switch (this){\r
+ case ICBN:\r
+ result = ZoologicalName.NewInstance(rank);\r
+ break;\r
+ case ICZN:\r
result = ZoologicalName.NewInstance(rank);\r
- }else if (this.equals(NomenclaturalCode.ICNCP)){\r
+ break;\r
+ case ICNCP:\r
result = CultivarPlantName.NewInstance(rank);\r
- }else if (this.equals(NomenclaturalCode.ICNB)){\r
+ break;\r
+ case ICNB:\r
result = BacterialName.NewInstance(rank);\r
- }else if (this.equals(NomenclaturalCode.ICVCN)){\r
+ break;\r
+ case ICVCN:\r
result = ViralName.NewInstance(rank);\r
- }else {\r
+ break;\r
+ default:\r
logger.warn("Unknown nomenclatural code: " + this.getUuid());\r
result = null;\r
}\r
* @see BacterialName#NewInstance(Rank)\r
* @see ViralName#NewInstance(Rank)\r
*/\r
- @Transient\r
public <T extends TaxonNameBase> Class<? extends T> getCdmClass(){\r
Class<? extends T> result;\r
- if (this.equals(NomenclaturalCode.ICBN)){\r
+ switch (this){\r
+ case ICBN:\r
result = (Class<T>)BotanicalName.class;\r
- }else if (this.equals(NomenclaturalCode.ICZN)){\r
+ break;\r
+ case ICZN:\r
result = (Class<T>)ZoologicalName.class;\r
- }else if (this.equals(NomenclaturalCode.ICNCP)){\r
+ break;\r
+ case ICNCP:\r
result = (Class<T>)CultivarPlantName.class;\r
- }else if (this.equals(NomenclaturalCode.ICNB)){\r
+ break;\r
+ case ICNB:\r
result = (Class<T>)BacterialName.class;\r
- }else if (this.equals(NomenclaturalCode.ICVCN)){\r
+ break;\r
+ case ICVCN:\r
result = (Class<T>)ViralName.class;\r
- }else {\r
+ break;\r
+ default:\r
logger.warn("Unknown nomenclatural code: " + this.getUuid());\r
result = null;\r
}\r
return result;\r
- }\r
-\r
- \r
+ } \r
}\r
\r
//@XmlAccessorType(XmlAccessType.FIELD)\r
import eu.etaxonomy.cdm.model.common.ReferencedEntityBase;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
"type"
})
@Entity
-//@Audited
+@Audited
public class NomenclaturalStatus extends ReferencedEntityBase {
private static final long serialVersionUID = -2451270405173131900L;
static Logger logger = Logger.getLogger(NomenclaturalStatus.class);
@XmlElement(name = "NomenclaturalStatusType")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private NomenclaturalStatusType type;
/**
* Returns the {@link NomenclaturalStatusType nomenclatural status type} of <i>this</i>
* nomenclatural status.
*/
- @ManyToOne(fetch = FetchType.LAZY)
public NomenclaturalStatusType getType(){
return this.type;
}
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import javax.persistence.Entity;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
+
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
-import eu.etaxonomy.cdm.model.common.ILoadableTerm;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.OrderedTermBase;
-import eu.etaxonomy.cdm.model.common.Representation;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;
-import org.apache.log4j.Logger;
-
-import java.util.*;
-
-import javax.persistence.*;
-import javax.xml.bind.annotation.XmlAccessType;
-import javax.xml.bind.annotation.XmlAccessorType;
-import javax.xml.bind.annotation.XmlType;
-
/**
* The class representing categories of nomenclatural status (like "invalid",
* "conserved" or "novum") to qualify the use of a particular taxon name string
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "NomenclaturalStatusType")
@Entity
-//@Audited
+@Audited
public class NomenclaturalStatusType extends OrderedTermBase<NomenclaturalStatusType> {
static Logger logger = Logger.getLogger(NomenclaturalStatusType.class);
* @see #isIllegitimateType()
* @see eu.etaxonomy.cdm.model.common.DefinedTermBase#getKindOf()
*/
- @Transient
public boolean isInvalidType(){
if (this.equals(INVALID())
|| this.equals(NUDUM())
* @see #isIllegitimateType()
* @see eu.etaxonomy.cdm.model.common.DefinedTermBase#getKindOf()
*/
- @Transient
public boolean isLegitimateType(){
if (this.equals(LEGITIMATE()) ||
this.equals(NOVUM()) ||
* @see #SANCTIONED()
* @see eu.etaxonomy.cdm.model.common.DefinedTermBase#getKindOf()
*/
- @Transient
public boolean isIllegitimateType(){
if (this.equals(ILLEGITIMATE()) ||
this.equals(SUPERFLUOUS()) ||
* @return the nomenclatural status type
*
*/
- @Transient
public static NomenclaturalStatusType getNomenclaturalStatusTypeByAbbreviation(String statusAbbreviation) throws UnknownCdmTypeException{
if (statusAbbreviation == null){ throw new NullPointerException("statusAbbreviation is 'null' in getNomenclaturalStatusTypeByAbbreviation");
}else if (statusAbbreviation.equalsIgnoreCase("nom. ambig.")) { return NomenclaturalStatusType.AMBIGUOUS();
* @return the nomenclatural status type
*
*/
- @Transient
public static NomenclaturalStatusType getNomenclaturalStatusTypeByLabel(String statusLabel) throws UnknownCdmTypeException{
if (statusLabel == null){ throw new NullPointerException("statusLabel is 'null' in getNomenclaturalStatusTypeByLabel");
}else if (statusLabel.equalsIgnoreCase("Ambiguous")) { return NomenclaturalStatusType.AMBIGUOUS();
import javax.persistence.Entity;
+import javax.persistence.FetchType;
import javax.persistence.ManyToOne;
import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.Target;
+import org.hibernate.envers.Audited;
import org.hibernate.search.annotations.Field;
import org.hibernate.search.annotations.Fields;
import org.hibernate.search.annotations.Index;
import eu.etaxonomy.cdm.model.agent.INomenclaturalAuthor;
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;
+import eu.etaxonomy.cdm.model.reference.ReferenceBase;
import eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy;
import eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy;
* The taxon name class for all non viral taxa. Parenthetical authorship is derived
* from basionym relationship. The scientific name including author strings and
* maybe year can be stored as a string in the inherited {@link eu.etaxonomy.cdm.model.common.IdentifiableEntity#getTitleCache() titleCache} attribute.
- * The year itself is an information obtained from the {@link eu.etaxonomy.cdm.model.reference.INomenclaturalReference#getYear() nomenclatural reference}.
+ * The year itself is an information obtained from the {@link eu.etaxonomy.cdm.model.reference.ReferenceBase#getYear() nomenclatural reference}.
* The scientific name string without author strings and year can be stored in the {@link #getNameCache() nameCache} attribute.
* <P>
* This class corresponds partially to: <ul>
})
@XmlRootElement(name = "NonViralName")
@Entity
-//@Audited
+@Audited
@Indexed
public class NonViralName<T extends NonViralName> extends TaxonNameBase<T, INonViralNameCacheStrategy> {
private static final Logger logger = Logger.getLogger(NonViralName.class);
@XmlElement(name = "NameCache")
+ @Fields({@Field(index = org.hibernate.search.annotations.Index.TOKENIZED),
+ @Field(name = "name_forSort", index = org.hibernate.search.annotations.Index.UN_TOKENIZED)
+ })
private String nameCache;
@XmlElement(name = "GenusOrUninomial")
+ @Field(index=Index.TOKENIZED)
private String genusOrUninomial;
@XmlElement(name = "InfraGenericEpithet")
+ @Field(index=Index.TOKENIZED)
private String infraGenericEpithet;
@XmlElement(name = "SpecificEpithet")
+ @Field(index=Index.TOKENIZED)
private String specificEpithet;
@XmlElement(name = "InfraSpecificEpithet")
+ @Field(index=Index.TOKENIZED)
private String infraSpecificEpithet;
@XmlElement(name = "CombinationAuthorTeam", type = TeamOrPersonBase.class)
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Target(TeamOrPersonBase.class)
+ @Cascade(CascadeType.SAVE_UPDATE)
private INomenclaturalAuthor combinationAuthorTeam;
- @XmlElement(name = "CombinationAuthorTeam", type = TeamOrPersonBase.class)
+ @XmlElement(name = "ExCombinationAuthorTeam", type = TeamOrPersonBase.class)
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Target(TeamOrPersonBase.class)
+ @Cascade(CascadeType.SAVE_UPDATE)
private INomenclaturalAuthor exCombinationAuthorTeam;
- @XmlElement(name = "CombinationAuthorTeam", type = TeamOrPersonBase.class)
+ @XmlElement(name = "BasionymAuthorTeam", type = TeamOrPersonBase.class)
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Target(TeamOrPersonBase.class)
+ @Cascade(CascadeType.SAVE_UPDATE)
private INomenclaturalAuthor basionymAuthorTeam;
- @XmlElement(name = "CombinationAuthorTeam", type = TeamOrPersonBase.class)
+ @XmlElement(name = "ExBasionymAuthorTeam", type = TeamOrPersonBase.class)
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Target(TeamOrPersonBase.class)
+ @Cascade(CascadeType.SAVE_UPDATE)
private INomenclaturalAuthor exBasionymAuthorTeam;
@XmlElement(name = "AuthorshipCache")
+ @Field(index=Index.TOKENIZED)
private String authorshipCache;
@XmlElement(name = "ProtectedAuthorshipCache")
protected boolean protectedNameCache;
@XmlTransient
+ @Transient
protected INonViralNameCacheStrategy cacheStrategy;
// ************* CONSTRUCTORS *************/
* only containing the {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy default cache strategy}.
*
* @see #NonViralName(Rank, HomotypicalGroup)
- * @see #NonViralName(Rank, String, String, String, String, TeamOrPersonBase, INomenclaturalReference, String, HomotypicalGroup)
+ * @see #NonViralName(Rank, String, String, String, String, TeamOrPersonBase, ReferenceBase, String, HomotypicalGroup)
* @see eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy
* @see eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy
* @see eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy
* @param rank the rank to be assigned to <i>this</i> non viral taxon name
* @param homotypicalGroup the homotypical group to which <i>this</i> non viral taxon name belongs
* @see #NonViralName()
- * @see #NonViralName(Rank, String, String, String, String, TeamOrPersonBase, INomenclaturalReference, String, HomotypicalGroup)
+ * @see #NonViralName(Rank, String, String, String, String, TeamOrPersonBase, ReferenceBase, String, HomotypicalGroup)
* @see #NewInstance(Rank, HomotypicalGroup)
* @see eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy
* @see eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy
* containing its {@link Rank rank},
* its {@link HomotypicalGroup homotypical group},
* its scientific name components, its {@link eu.etaxonomy.cdm.model.agent.TeamOrPersonBase author(team)},
- * its {@link eu.etaxonomy.cdm.model.reference.INomenclaturalReference nomenclatural reference} and
+ * its {@link eu.etaxonomy.cdm.model.reference.ReferenceBase nomenclatural reference} and
* the {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy default cache strategy}.
* The new non viral taxon name instance will be also added to the set of
* non viral taxon names belonging to this homotypical group.
* @see #NewInstance(Rank, HomotypicalGroup)
* @see #NonViralName(Rank, HomotypicalGroup)
* @see #NonViralName()
- * @see #NonViralName(Rank, String, String, String, String, TeamOrPersonBase, INomenclaturalReference, String, HomotypicalGroup)
+ * @see #NonViralName(Rank, String, String, String, String, TeamOrPersonBase, ReferenceBase, String, HomotypicalGroup)
* @see eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy
* @see eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy
* @see eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy
* @see #NewInstance(Rank)
* @see #NonViralName(Rank, HomotypicalGroup)
* @see #NonViralName()
- * @see #NonViralName(Rank, String, String, String, String, TeamOrPersonBase, INomenclaturalReference, String, HomotypicalGroup)
+ * @see #NonViralName(Rank, String, String, String, String, TeamOrPersonBase, ReferenceBase, String, HomotypicalGroup)
* @see eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy
* @see eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy
* @see eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy
* @see eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy
* @see eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy
*/
- @Transient
@Override
public INonViralNameCacheStrategy getCacheStrategy() {
return cacheStrategy;
}
+
/**
* @see #getCacheStrategy()
*/
* @see eu.etaxonomy.cdm.model.agent.INomenclaturalAuthor
* @see eu.etaxonomy.cdm.model.agent.TeamOrPersonBase#getNomenclaturalTitle()
*/
- @ManyToOne
- @Cascade({CascadeType.SAVE_UPDATE})
- @Target(TeamOrPersonBase.class)
public INomenclaturalAuthor getCombinationAuthorTeam(){
return this.combinationAuthorTeam;
}
+
/**
* @see #getCombinationAuthorTeam()
*/
* @see eu.etaxonomy.cdm.model.agent.INomenclaturalAuthor
* @see eu.etaxonomy.cdm.model.agent.TeamOrPersonBase#getNomenclaturalTitle()
*/
- @ManyToOne
- @Cascade({CascadeType.SAVE_UPDATE})
- @Target(TeamOrPersonBase.class)
public INomenclaturalAuthor getExCombinationAuthorTeam(){
return this.exCombinationAuthorTeam;
}
+
/**
* @see #getExCombinationAuthorTeam()
*/
* @see eu.etaxonomy.cdm.model.agent.INomenclaturalAuthor
* @see eu.etaxonomy.cdm.model.agent.TeamOrPersonBase#getNomenclaturalTitle()
*/
- @ManyToOne
- @Cascade({CascadeType.SAVE_UPDATE})
- @Target(TeamOrPersonBase.class)
public INomenclaturalAuthor getBasionymAuthorTeam(){
return basionymAuthorTeam;
}
+
/**
* @see #getBasionymAuthorTeam()
*/
* @see eu.etaxonomy.cdm.model.agent.INomenclaturalAuthor
* @see eu.etaxonomy.cdm.model.agent.TeamOrPersonBase#getNomenclaturalTitle()
*/
- @ManyToOne
- @Cascade({CascadeType.SAVE_UPDATE})
- @Target(TeamOrPersonBase.class)
public INomenclaturalAuthor getExBasionymAuthorTeam(){
return exBasionymAuthorTeam;
}
+
/**
* @see #getExBasionymAuthorTeam()
*/
* @return the string containing the suprageneric name, the genus name or the genus part of <i>this</i> non viral taxon name
* @see #getNameCache()
*/
- @Field(index=Index.TOKENIZED)
public String getGenusOrUninomial() {
return genusOrUninomial;
}
* @return the string containing the infrageneric part of <i>this</i> non viral taxon name
* @see #getNameCache()
*/
- @Field(index=Index.TOKENIZED)
public String getInfraGenericEpithet(){
return this.infraGenericEpithet;
}
* @return the string containing the species epithet of <i>this</i> non viral taxon name
* @see #getNameCache()
*/
- @Field(index=Index.TOKENIZED)
public String getSpecificEpithet(){
return this.specificEpithet;
}
* @return the string containing the infraspecific part of <i>this</i> non viral taxon name
* @see #getNameCache()
*/
- @Field(index=Index.TOKENIZED)
public String getInfraSpecificEpithet(){
return this.infraSpecificEpithet;
}
* @return the string which identifies <i>this</i> non viral taxon name (without authors or year)
* @see #generateNameCache()
*/
- @Fields({@Field(index = org.hibernate.search.annotations.Index.TOKENIZED),
- @Field(name = "name_forSort", index = org.hibernate.search.annotations.Index.UN_TOKENIZED)
- })
public String getNameCache() {
if (protectedNameCache){
return this.nameCache;
* @return the string with the concatenated and formated authorteams for <i>this</i> non viral taxon name
* @see #generateAuthorship()
*/
- @Field(index=Index.TOKENIZED)
public String getAuthorshipCache() {
if (protectedAuthorshipCache){
return this.authorshipCache;
* @see TaxonNameBase#isCodeCompliant()
*/
@Override
- @Transient
public boolean isCodeCompliant() {
//FIXME
logger.warn("is CodeCompliant not yet implemented");
* @see #isCodeCompliant()
* @see TaxonNameBase#getHasProblem()
*/
- @Transient
@Override
public NomenclaturalCode getNomenclaturalCode() {
logger.warn("Non Viral Name has no specific Code defined. Use subclasses");
import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import java.util.*;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "Rank")
@Entity
-//@Audited
+@Audited
public class Rank extends OrderedTermBase<Rank> {
private static final Logger logger = Logger.getLogger(Rank.class);
* @see #isSpecies()
* @see #isInfraSpecific()
*/
- @Transient
public boolean isSupraGeneric(){
return (this.isHigher(Rank.GENUS()));
}
* @see #isSpecies()
* @see #isInfraSpecific()
*/
- @Transient
public boolean isGenus(){
return (this.equals(Rank.GENUS()));
}
* @see #isSpecies()
* @see #isInfraSpecific()
*/
- @Transient
public boolean isInfraGeneric(){
return (this.isLower(Rank.GENUS()) && this.isHigher(Rank.SPECIES()));
}
* @see #isInfraGeneric()
* @see #isInfraSpecific()
*/
- @Transient
public boolean isSpecies(){
return (this.equals(Rank.SPECIES()));
}
* @see #isInfraGeneric()
* @see #isSpecies()
*/
- @Transient
public boolean isInfraSpecific(){
return (this.isLower(Rank.SPECIES()));
}
* @param strRank the string identifying the rank
* @return the rank
*/
- @Transient
public static Rank getRankByNameOrAbbreviation(String strRank)
throws UnknownCdmTypeException{
return getRankByNameOrAbbreviation(strRank, false);
* unknown or not yet implemented
* @return the rank
*/
- @Transient
public static Rank getRankByNameOrAbbreviation(String strRank, boolean useUnknown)
throws UnknownCdmTypeException{
try {
* @param abbrev the string for the name abbreviation
* @return the rank
*/
- @Transient
public static Rank getRankByAbbreviation(String abbrev)
throws UnknownCdmTypeException{
return getRankByAbbreviation(abbrev, false);
* unknown or not yet implemented
* @return the rank
*/
- @Transient
public static Rank getRankByAbbreviation(String abbrev, boolean useUnknown)
throws UnknownCdmTypeException{
if (abbrev == null){ throw new NullPointerException("abbrev is 'null' in getRankByAbbreviation");
* @param rankName the string for the name of the rank
* @return the rank
*/
- @Transient
public static Rank getRankByName(String rankName)throws UnknownCdmTypeException{
return getRankByName(rankName, false);
}
* unknown or not yet implemented
* @return the rank
*/
- @Transient
public static Rank getRankByName(String rankName, boolean useUnknown)
throws UnknownCdmTypeException{
if (rankName.equalsIgnoreCase("Regnum")){ return Rank.KINGDOM();
*
* @return the abbreviation string for <i>this</i> rank
*/
- @Transient
public String getAbbreviation(){
if (this.equals(Rank.ORDER()) ){return "ordo";}
if (this.equals(Rank.FAMILY()) ){return "fam.";}
Rank.UNKNOWN_RANK = termVocabulary.findTermByUuid(Rank.uuidUnknownRank);
Rank.VARIETY = termVocabulary.findTermByUuid(Rank.uuidVariety);
}
-
-
-
-
}
\ No newline at end of file
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.ManyToOne;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.occurrence.DerivedUnitBase;
import eu.etaxonomy.cdm.model.occurrence.Specimen;
"typeStatus"
})
@Entity
-//@Audited
+@Audited
public class SpecimenTypeDesignation extends TypeDesignationBase implements ITypeDesignation {
private static final Logger logger = Logger.getLogger(SpecimenTypeDesignation.class);
@XmlElement(name = "TypeSpecimen")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private DerivedUnitBase typeSpecimen;
@XmlElement(name = "TypeStatus")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private TypeDesignationStatus typeStatus;
-
-
-
// /**
// * Creates a new specimen type designation instance
this.setTypeStatus(status);
}
-
-
-
//********* METHODS **************************************/
-
-
/**
* Returns the {@link occurrence.DerivedUnitBase derived unit} (specimen or figure) that is used
* in <i>this</i> specimen type designation to typify the {@link TaxonNameBase taxon name}.
*
* @see #getHomotypicalGroup()
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public DerivedUnitBase getTypeSpecimen(){
return this.typeSpecimen;
}
* types like "holotype", "neotype", "syntype" or "isotype" applies to <i>this</i>
* specimen type designation.
*/
- @ManyToOne(fetch = FetchType.LAZY)
public TypeDesignationStatus getTypeStatus(){
return this.typeStatus;
}
* @see TypeDesignationStatus#isLectotype()
* @see TypeDesignationStatus#HOLOTYPE()
*/
- @Transient
public boolean isLectoType() {
return typeStatus.isLectotype();
}
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.Index;
import org.hibernate.annotations.Table;
-import org.hibernate.annotations.Target;
+import org.hibernate.envers.Audited;
import org.hibernate.search.annotations.Indexed;
+import org.springframework.util.ReflectionUtils;
import eu.etaxonomy.cdm.model.common.IParsable;
import eu.etaxonomy.cdm.model.common.IReferencedEntity;
"relationsFromThisName",
"relationsToThisName",
"status",
- "descriptions"
-// "taxonBases"
+ "descriptions",
+ "taxonBases"
})
@XmlRootElement(name = "TaxonNameBase")
@Entity
-//@Audited
+@Audited
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@Table(appliesTo="TaxonNameBase", indexes = { @Index(name = "taxonNameBaseTitleCacheIndex", columnNames = { "titleCache" }) })
@Indexed
private static final Logger logger = Logger.getLogger(TaxonNameBase.class);
- private static Method methodDescriptionSetTaxonName;
-
@XmlElement(name = "FullTitleCache")
+ @Column(length=330, name="fullTitleCache")
private String fullTitleCache;
//if true titleCache will not be automatically generated/updated
@XmlElementWrapper(name = "Descriptions")
@XmlElement(name = "Description")
+ @OneToMany(mappedBy="taxonName", fetch= FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
private Set<TaxonNameDescription> descriptions = new HashSet<TaxonNameDescription>();
@XmlElement(name = "AppendedPhrase")
@XmlElement(name = "TypeDesignation")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
+ //TODO @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
+ @Cascade(CascadeType.SAVE_UPDATE)
private Set<TypeDesignationBase> typeDesignations = new HashSet<TypeDesignationBase>();
@XmlElement(name = "HomotypicalGroup")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private HomotypicalGroup homotypicalGroup = new HomotypicalGroup();
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
+ private HomotypicalGroup homotypicalGroup;
@XmlElementWrapper(name = "RelationsFromThisName")
@XmlElement(name = "RelationFromThisName")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
+ @OneToMany(mappedBy="relatedFrom", fetch= FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
private Set<NameRelationship> relationsFromThisName = new HashSet<NameRelationship>();
@XmlElementWrapper(name = "RelationsToThisName")
@XmlElement(name = "RelationToThisName")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(mappedBy="relatedTo", fetch= FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
private Set<NameRelationship> relationsToThisName = new HashSet<NameRelationship>();
- @XmlElementWrapper(name = "NomenclaturalStatus_")
+ @XmlElementWrapper(name = "NomenclaturalStatuses")
@XmlElement(name = "NomenclaturalStatus")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
+ @OneToMany(fetch= FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
private Set<NomenclaturalStatus> status = new HashSet<NomenclaturalStatus>();
- @XmlTransient
- //@XmlElementWrapper(name = "TaxonBases")
- //@XmlElement(name = "TaxonBase")
+ @XmlElementWrapper(name = "TaxonBases")
+ @XmlElement(name = "TaxonBase")
+ @XmlIDREF
+ @XmlSchemaType(name = "IDREF")
+ @OneToMany(mappedBy="name", fetch= FetchType.LAZY)
private Set<TaxonBase> taxonBases = new HashSet<TaxonBase>();
-
-
-
@XmlElement(name = "Rank")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private Rank rank;
-// FIXME: This must be an IDREF to the corresponding nomenclatural reference.
-// @XmlTransient
-// @XmlAnyElement
- @XmlElement(name = "NomenclaturalReference", type = ReferenceBase.class)
+
+ @XmlElement(name = "NomenclaturalReference")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private INomenclaturalReference nomenclaturalReference;
-
- static Method methodTaxonBaseSetName;
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
+ private ReferenceBase nomenclaturalReference;
// ************* CONSTRUCTORS *************/
/**
* @see #TaxonNameBase(Rank, HomotypicalGroup)
*/
public TaxonNameBase() {
- this(null, null);
+ super();
}
/**
* Class constructor: creates a new taxon name
}
//********* METHODS **************************************/
-
- //@Index(name="TaxonNameBaseTitleCacheIndex")
-// public String getTitleCache(){
-// return super.getTitleCache();
-// }
/**
* Returns the boolean value "false" since the components of <i>this</i> taxon name
*
* @return false
*/
- @Transient
public abstract boolean isCodeCompliant();
public abstract String generateFullTitle();
- @Transient
public String getFullTitleCache(){
if (protectedFullTitleCache){
return this.fullTitleCache;
this.setProtectedFullTitleCache(protectCache);
}
- @Column(length=330, name="fullTitleCache")
- @Deprecated //for hibernate use only
- protected String getPersistentFullTitleCache(){
- return getFullTitleCache();
- }
-
- @Deprecated //for hibernate use only
- protected void setPersistentFullTitleCache(String fullTitleCache){
- this.fullTitleCache = fullTitleCache;
- }
-
public boolean isProtectedFullTitleCache() {
return protectedFullTitleCache;
}
* @see #addRelationshipToName(TaxonNameBase, NameRelationshipType, String)
* @see #addRelationshipFromName(TaxonNameBase, NameRelationshipType, String)
*/
- @Transient
public Set<NameRelationship> getNameRelations() {
Set<NameRelationship> rels = new HashSet<NameRelationship>();
rels.addAll(getRelationsFromThisName());
this.relationsToThisName.remove(nameRelation);
this.relationsFromThisName.remove(nameRelation);
}
-
public void removeTaxonName(TaxonNameBase taxonName) {
Set<NameRelationship> nameRelationships = new HashSet<NameRelationship>();
* @see #getRelationsToThisName()
* @see #addRelationshipFromName(TaxonNameBase, NameRelationshipType, String)
*/
- @OneToMany(mappedBy="relatedFrom", fetch= FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
public Set<NameRelationship> getRelationsFromThisName() {
return relationsFromThisName;
}
- private void setRelationsFromThisName(Set<NameRelationship> relationsFromThisName) {
- this.relationsFromThisName = relationsFromThisName;
- }
-
+
/**
* Returns the set of all {@link NameRelationship name relationships}
* in which <i>this</i> taxon name is involved as a target.
* @see #getRelationsFromThisName()
* @see #addRelationshipToName(TaxonNameBase, NameRelationshipType, String)
*/
- @OneToMany(mappedBy="relatedTo", fetch= FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
public Set<NameRelationship> getRelationsToThisName() {
return relationsToThisName;
}
- private void setRelationsToThisName(Set<NameRelationship> relationsToThisName) {
- this.relationsToThisName = relationsToThisName;
- }
-
/**
* Returns the set of {@link NomenclaturalStatus nomenclatural status} assigned
* @see NomenclaturalStatus
* @see NomenclaturalStatusType
*/
- @OneToMany(fetch= FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<NomenclaturalStatus> getStatus() {
return status;
}
- /**
- * @see #getStatus()
- */
- protected void setStatus(Set<NomenclaturalStatus> nomStatus) {
- this.status = nomStatus;
- }
+
/**
* Adds a new {@link NomenclaturalStatus nomenclatural status}
* to <i>this</i> taxon name's set of nomenclatural status.
public void addStatus(NomenclaturalStatus nomStatus) {
this.status.add(nomStatus);
}
+
/**
* Removes one element from the set of nomenclatural status of <i>this</i> taxon name.
* Type and ruleConsidered attributes of the nomenclatural status object
* false otherwise (also in case <i>this</i> taxon name is the only one in the
* homotypical group).
*/
- @Transient
public boolean isOriginalCombination(){
Set<NameRelationship> relationsFromThisName = this.getRelationsFromThisName();
for (NameRelationship relation : relationsFromThisName) {
* Karsten transferred later <i>this</i> taxon to the genus Picea. Therefore,
* <i>Pinus abies</i> L. is the basionym of the new combination <i>Picea abies</i> (L.) H. Karst.
*/
- @Transient
public T getBasionym(){
//TODO: pick the right name relationships...
logger.warn("get Basionym not yet implemented");
logger.warn("not yet implemented");
}
-
-
/**
* Returns the {@link eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy cache strategy} used to generate
* several strings corresponding to <i>this</i> taxon name
* @see eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy
* @see eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy
*/
- @Transient
public abstract S getCacheStrategy();
/**
* @see #getCacheStrategy()
*/
+
public abstract void setCacheStrategy(S cacheStrategy);
/**
*
* @see Rank
*/
- @ManyToOne(fetch = FetchType.LAZY)
- //@Cascade({CascadeType.SAVE_UPDATE})
public Rank getRank(){
return this.rank;
}
+
/**
* @see #getRank()
*/
* @see eu.etaxonomy.cdm.model.reference.INomenclaturalReference
* @see eu.etaxonomy.cdm.model.reference.ReferenceBase
*/
- @ManyToOne
- @Cascade({CascadeType.SAVE_UPDATE})
- @Target(ReferenceBase.class)
public INomenclaturalReference getNomenclaturalReference(){
- return this.nomenclaturalReference;
+ return (INomenclaturalReference)this.nomenclaturalReference;
}
/**
* Assigns a {@link eu.etaxonomy.cdm.model.reference.INomenclaturalReference nomenclatural reference} to <i>this</i> taxon name.
* @see #getNomenclaturalReference()
*/
public void setNomenclaturalReference(INomenclaturalReference nomenclaturalReference){
- this.nomenclaturalReference = nomenclaturalReference;
+ this.nomenclaturalReference = (ReferenceBase)nomenclaturalReference;
}
/**
public String getAppendedPhrase(){
return this.appendedPhrase;
}
+
/**
* @see #getAppendedPhrase()
*/
this.problemEnds = end;
}
-
-
-
//*********************** TYPE DESIGNATION *********************************************//
-
-
-
/**
* Returns the set of {@link TypeDesignationBase type designations} assigned
* to <i>this</i> taxon name.
* @see NameTypeDesignation
* @see SpecimenTypeDesignation
*/
- @ManyToMany(fetch = FetchType.LAZY)
- //TODO @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
- @Cascade(CascadeType.SAVE_UPDATE)
public Set<TypeDesignationBase> getTypeDesignations() {
return typeDesignations;
}
- /**
- * @see #getNameTypeDesignations()
- */
- private void setTypeDesignations(Set<TypeDesignationBase> typeDesignations) {
- this.typeDesignations = typeDesignations;
- }
-
/**
* Removes one element from the set of {@link TypeDesignationBase type designations} assigned to
* <i>this</i> taxon name. The type designation itself will be nullified.
this.typeDesignations.remove(typeDesignation);
}
-
/**
* Returns the set of {@link SpecimenTypeDesignation specimen type designations} assigned
* to <i>this</i> taxon name. The {@link Rank rank} of <i>this</i> taxon name is generally
* @see NameTypeDesignation
* @see HomotypicalGroup
*/
- @Transient
public Set<SpecimenTypeDesignation> getSpecimenTypeDesignationsOfHomotypicalGroup() {
return this.getHomotypicalGroup().getSpecimenTypeDesignations();
}
* @see NameTypeDesignation
* @see SpecimenTypeDesignation
*/
- @Transient
public Set<NameTypeDesignation> getNameTypeDesignations() {
Set<NameTypeDesignation> result = new HashSet<NameTypeDesignation>();
for (TypeDesignationBase typeDesignation : this.typeDesignations){
* Returns the set of {@link SpecimenTypeDesignation specimen type designations}
* that typify <i>this</i> taxon name.
*/
- @Transient
public Set<SpecimenTypeDesignation> getSpecimenTypeDesignations() {
Set<SpecimenTypeDesignation> result = new HashSet<SpecimenTypeDesignation>();
for (TypeDesignationBase typeDesignation : this.typeDesignations){
*
* @see HomotypicalGroup
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
+
public HomotypicalGroup getHomotypicalGroup() {
return homotypicalGroup;
}
- @Deprecated //only for bidirectional and persistence use
- protected void setHomotypicalGroup(HomotypicalGroup newHomotypicalGroup) {
- this.homotypicalGroup = newHomotypicalGroup;
+
+ /*
+ * @see #getHomotypicalGroup()
+ */
+ protected void setHomotypicalGroup(HomotypicalGroup homotypicalGroup) {
+ this.homotypicalGroup = homotypicalGroup;
}
// *************************************************************************//
/**
* @see #getNomenclaturalReference()
*/
- @Transient
public StrictReferenceBase getCitation(){
//TODO What is the purpose of this method differing from the getNomenclaturalReference method?
logger.warn("getCitation not yet implemented");
* @see #getNomenclaturalReference()
* @see #getNomenclaturalMicroReference()
*/
- @Transient
@Deprecated
public String getCitationString(){
logger.warn("getCitationString not yet implemented");
/**
* Not yet implemented
*/
- @Transient
@Deprecated
public String[] getProblems(){
logger.warn("getProblems not yet implemented");
* @return the string containing the publication date of <i>this</i> taxon name
* @see eu.etaxonomy.cdm.model.reference.INomenclaturalReference#getYear()
*/
- @Transient
public String getReferenceYear(){
if (this.getNomenclaturalReference() != null ){
return this.getNomenclaturalReference().getYear();
* @see #getTaxa()
* @see #getSynonyms()
*/
- @OneToMany(mappedBy="name", fetch= FetchType.LAZY)
public Set<TaxonBase> getTaxonBases() {
return this.taxonBases;
}
- /**
- * @see #getTaxonBases()
- */
- protected void setTaxonBases(Set<TaxonBase> taxonBases) {
- if (taxonBases == null){
- taxonBases = new HashSet<TaxonBase>();
- }else{
- this.taxonBases = taxonBases;
- }
- }
+
/**
* Adds a new {@link eu.etaxonomy.cdm.model.taxon.TaxonBase taxon base}
* to the set of taxon bases using <i>this</i> taxon name.
*/
//TODO protected
public void addTaxonBase(TaxonBase taxonBase){
+ Method method = ReflectionUtils.findMethod(TaxonBase.class, "setName", new Class[] {TaxonNameBase.class});
+ ReflectionUtils.makeAccessible(method);
+ ReflectionUtils.invokeMethod(method, taxonBase, new Object[] {this});
taxonBases.add(taxonBase);
- initMethods();
- invokeSetMethod(methodTaxonBaseSetName, taxonBase);
}
/**
* Removes one element from the set of {@link eu.etaxonomy.cdm.model.taxon.TaxonBase taxon bases} that refer to <i>this</i> taxon name.
* @see #addTaxonBase(TaxonBase)
*/
public void removeTaxonBase(TaxonBase taxonBase){
+ Method method = ReflectionUtils.findMethod(TaxonBase.class, "setName", new Class[] {TaxonNameBase.class});
+ ReflectionUtils.makeAccessible(method);
+ ReflectionUtils.invokeMethod(method, taxonBase, new Object[] {null});
taxonBases.remove(taxonBase);
- initMethods();
- invokeSetMethodWithNull(methodTaxonBaseSetName, taxonBase);
- }
-
- private void initMethods(){
- if (methodTaxonBaseSetName == null){
- try {
- methodTaxonBaseSetName = TaxonBase.class.getDeclaredMethod("setName", TaxonNameBase.class);
- methodTaxonBaseSetName.setAccessible(true);
- } catch (Exception e) {
- e.printStackTrace();
- //TODO handle exception
- }
- }
- if (methodDescriptionSetTaxonName == null){
- try {
- methodDescriptionSetTaxonName = TaxonNameDescription.class.getDeclaredMethod("setTaxonName", TaxonNameBase.class);
- methodDescriptionSetTaxonName.setAccessible(true);
- } catch (Exception e) {
- e.printStackTrace();
- //TODO handle exception
- }
- }
}
-
-
/**
* Returns the set of {@link eu.etaxonomy.cdm.model.taxon.Taxon taxa} ("accepted/correct" names according to any
* reference) that are based on <i>this</i> taxon name. This set is a subset of
* @see #getTaxonBases()
* @see #getSynonyms()
*/
- @Transient
public Set<Taxon> getTaxa(){
Set<Taxon> result = new HashSet<Taxon>();
for (TaxonBase taxonBase : this.taxonBases){
* @see #getTaxonBases()
* @see #getTaxa()
*/
- @Transient
public Set<Synonym> getSynonyms() {
Set<Synonym> result = new HashSet<Synonym>();
for (TaxonBase taxonBase : this.taxonBases){
* @see #removeDescription(TaxonNameDescription)
* @see eu.etaxonomy.cdm.model.description.TaxonNameDescription
*/
- @OneToMany(mappedBy="taxonName", fetch= FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<TaxonNameDescription> getDescriptions() {
return descriptions;
}
- /**
- * @see #getDescriptions()
- */
- protected void setDescriptions(Set<TaxonNameDescription> descriptions) {
- this.descriptions = descriptions;
- }
+
/**
* Adds a new {@link eu.etaxonomy.cdm.model.description.TaxonNameDescription taxon name description}
* to the set of taxon name descriptions assigned to <i>this</i> taxon name. The
* @see #removeDescription(TaxonNameDescription)
*/
public void addDescription(TaxonNameDescription description) {
- initMethods();
- this.invokeSetMethod(methodDescriptionSetTaxonName, description);
+ Method method = ReflectionUtils.findMethod(TaxonNameDescription.class, "setTaxonName", new Class[] {TaxonNameBase.class});
+ ReflectionUtils.makeAccessible(method);
+ ReflectionUtils.invokeMethod(method, description, new Object[] {this});
descriptions.add(description);
}
/**
* @see eu.etaxonomy.cdm.model.description.TaxonNameDescription#getTaxonName()
*/
public void removeDescription(TaxonNameDescription description) {
- initMethods();
- this.invokeSetMethod(methodDescriptionSetTaxonName, null);
+ Method method = ReflectionUtils.findMethod(TaxonNameDescription.class, "setTaxonName", new Class[] {TaxonNameBase.class});
+ ReflectionUtils.makeAccessible(method);
+ ReflectionUtils.invokeMethod(method, description, new Object[] {null});
descriptions.remove(description);
}
-
-
-
-
-
// ***********
/**
* Returns the boolean value indicating whether a given taxon name belongs
return false;
}
-
-
//********* Rank comparison shortcuts ********************//
/**
* Returns the boolean value indicating whether the taxonomic {@link Rank rank} of <i>this</i>
* @see #isSpecies()
* @see #isInfraSpecific()
*/
- @Transient
public boolean isSupraGeneric() {
if (rank == null){
return false;
* @see #isSpecies()
* @see #isInfraSpecific()
*/
- @Transient
public boolean isGenus() {
if (rank == null){
return false;
* @see #isSpecies()
* @see #isInfraSpecific()
*/
- @Transient
public boolean isInfraGeneric() {
if (rank == null){
return false;
* @see #isInfraGeneric()
* @see #isInfraSpecific()
*/
- @Transient
public boolean isSpecies() {
if (rank == null){
return false;
* @see #isInfraGeneric()
* @see #isSpecies()
*/
- @Transient
public boolean isInfraSpecific() {
if (rank == null){
return false;
* @see #isCodeCompliant()
* @see #getHasProblem()
*/
- @Transient
abstract public NomenclaturalCode getNomenclaturalCode();
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.common.IdentifiableEntity#generateTitle()
// TODO Auto-generated method stub
logger.warn("not yet implemented");
return null;
- }
-
+ }
}
import java.util.Set;\r
\r
import javax.persistence.Entity;\r
+import javax.persistence.FetchType;\r
import javax.persistence.Inheritance;\r
import javax.persistence.InheritanceType;\r
-import javax.persistence.FetchType;\r
import javax.persistence.ManyToMany;\r
import javax.persistence.ManyToOne;\r
-import javax.persistence.OneToMany;\r
import javax.xml.bind.annotation.XmlElement;\r
import javax.xml.bind.annotation.XmlElementWrapper;\r
import javax.xml.bind.annotation.XmlIDREF;\r
import javax.xml.bind.annotation.XmlRootElement;\r
import javax.xml.bind.annotation.XmlSchemaType;\r
-import javax.xml.bind.annotation.XmlTransient;\r
import javax.xml.bind.annotation.XmlType;\r
\r
import org.apache.log4j.Logger;\r
import org.hibernate.annotations.Cascade;\r
import org.hibernate.annotations.CascadeType;\r
+import org.hibernate.envers.Audited;\r
\r
import eu.etaxonomy.cdm.model.common.ReferencedEntityBase;\r
import eu.etaxonomy.cdm.model.reference.ReferenceBase;\r
@XmlType(name = "TypeDesignationBase", propOrder = {\r
"typifiedNames",\r
"homotypicalGroup",\r
- "isNotDesignated"\r
+ "notDesignated"\r
})\r
@Entity\r
-//@Audited\r
+@Audited\r
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)\r
public abstract class TypeDesignationBase extends ReferencedEntityBase implements ITypeDesignation {\r
private static final Logger logger = Logger.getLogger(TypeDesignationBase.class);\r
\r
\r
@XmlElement(name = "IsNotDesignated")\r
- private boolean isNotDesignated;\r
+ private boolean notDesignated;\r
\r
@XmlElementWrapper(name = "TypifiedNames")\r
@XmlElement(name = "TypifiedName")\r
@XmlIDREF\r
@XmlSchemaType(name = "IDREF")\r
// Need these references (bidirectional) to fill table TypeDesignationBase_TaxonNameBase\r
+ @ManyToMany(fetch = FetchType.LAZY)\r
private Set<TaxonNameBase> typifiedNames = new HashSet<TaxonNameBase>();\r
\r
@XmlElement(name = "HomotypicalGroup")\r
@XmlIDREF\r
@XmlSchemaType(name = "IDREF")\r
+ @ManyToOne(fetch = FetchType.LAZY)\r
+ @Cascade(CascadeType.SAVE_UPDATE)\r
private HomotypicalGroup homotypicalGroup;\r
\r
// **************** CONSTRUCTOR *************************************/\r
* @see #isNotDesignated()\r
* @see TaxonNameBase#getTypeDesignations()\r
*/\r
- protected TypeDesignationBase(ReferenceBase citation, String citationMicroReference, String originalNameString, boolean isNotDesignated){\r
+ protected TypeDesignationBase(ReferenceBase citation, String citationMicroReference, String originalNameString, boolean notDesignated){\r
super(citation, citationMicroReference, originalNameString);\r
- this.isNotDesignated = isNotDesignated;\r
+ this.notDesignated = notDesignated;\r
}\r
\r
\r
* \r
* @see #getTypifiedNames()\r
*/\r
- @ManyToOne(fetch = FetchType.LAZY)\r
- @Cascade({CascadeType.SAVE_UPDATE})\r
public HomotypicalGroup getHomotypicalGroup() {\r
return homotypicalGroup;\r
}\r
\r
- @Deprecated //for hibernate use only\r
- private void setHomotypicalGroup(HomotypicalGroup homotypicalGroup) {\r
- this.homotypicalGroup = homotypicalGroup; \r
- }\r
-\r
/* (non-Javadoc)\r
* @see eu.etaxonomy.cdm.model.name.ITypeDesignation#getTypifiedNames()\r
*/\r
* type designation. This is a subset of the taxon names belonging to the\r
* corresponding {@link #getHomotypicalGroup() homotypical group}.\r
*/\r
- @ManyToMany(fetch = FetchType.LAZY)\r
- @Cascade({CascadeType.SAVE_UPDATE})\r
public Set<TaxonNameBase> getTypifiedNames() {\r
return typifiedNames;\r
}\r
* in case of a {@link SpecimenTypeDesignation specimen type designation}, should then be "null".\r
*/\r
public boolean isNotDesignated() {\r
- return isNotDesignated;\r
+ return notDesignated;\r
}\r
\r
/**\r
* @see #isNotDesignated()\r
*/\r
- public void setNotDesignated(boolean isNotDesignated) {\r
- this.isNotDesignated = isNotDesignated;\r
- }\r
-\r
-\r
- @Deprecated //for hibernate use only\r
- private void setTypifiedNames(Set<TaxonNameBase> typifiedNames) {\r
- this.typifiedNames = typifiedNames;\r
+ public void setNotDesignated(boolean notDesignated) {\r
+ this.notDesignated = notDesignated;\r
}\r
\r
@Deprecated //for bidirectional use only\r
protected void addTypifiedName(TaxonNameBase taxonName){\r
this.typifiedNames.add(taxonName);\r
}\r
- \r
-\r
}\r
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.OrderedTermBase;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "TypeDesignationStatus")
@Entity
-//@Audited
+@Audited
public class TypeDesignationStatus extends OrderedTermBase<TypeDesignationStatus> {
static Logger logger = Logger.getLogger(TypeDesignationStatus.class);
* @see #HOLOTYPE()
* @see eu.etaxonomy.cdm.model.common.DefinedTermBase#getKindOf()
*/
- @Transient
public boolean isLectotype(){
if (this.equals(LECTOTYPE()) ||
this.equals(ISOLECTOTYPE()) ||
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy;
})
@XmlRootElement(name = "ViralName")
@Entity
-//@Audited
+@Audited
public class ViralName extends TaxonNameBase<ViralName, INameCacheStrategy<ViralName>> {
private static final Logger logger = Logger.getLogger(ViralName.class);
@XmlTransient
+ @Transient
protected INameCacheStrategy<ViralName> cacheStrategy;
@XmlElement(name = "Acronym")
* @see TaxonNameBase#isCodeCompliant()
*/
@Override
- @Transient
public boolean isCodeCompliant() {
logger.warn("not yet implemented");
return false;
* @see TaxonNameBase#getHasProblem()
* @see TaxonNameBase#getNomenclaturalCode()
*/
- @Transient
@Override
public NomenclaturalCode getNomenclaturalCode(){
return NomenclaturalCode.ICVCN;
* @see eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy
* @see eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy
*/
- @Transient
@Override
public INameCacheStrategy getCacheStrategy() {
return cacheStrategy;
import javax.persistence.Transient;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;
+import eu.etaxonomy.cdm.model.reference.ReferenceBase;
import eu.etaxonomy.cdm.strategy.cache.name.ZooNameDefaultCacheStrategy;
import eu.etaxonomy.cdm.strategy.parser.INonViralNameParser;
import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;
})
@XmlRootElement(name = "ZoologicalName")
@Entity
-//@Audited
-public class ZoologicalName extends NonViralName {
+@Audited
+public class ZoologicalName extends NonViralName<ZoologicalName> {
+ /**
+ *
+ */
+ private static final long serialVersionUID = 845745609734814484L;
+
static Logger logger = Logger.getLogger(ZoologicalName.class);
//Name of the breed of an animal
* @see NonViralName#getNomenclaturalCode()
* @see TaxonNameBase#getHasProblem()
*/
- @Transient
@Override
public NomenclaturalCode getNomenclaturalCode(){
return NomenclaturalCode.ICZN;
--- /dev/null
+\r
+@javax.xml.bind.annotation.XmlSchema(namespace = "http://etaxonomy.eu/cdm/model/name/1.0", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)\r
+package eu.etaxonomy.cdm.model.name;
\ No newline at end of file
import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.Index;
import org.hibernate.annotations.Table;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.agent.Institution;
import eu.etaxonomy.cdm.model.media.IdentifiableMediaEntity;
})
@XmlRootElement(name = "Collection")
@Entity
-//@Audited
+@Audited
@Table(appliesTo="Collection", indexes = { @Index(name = "collectionTitleCacheIndex", columnNames = { "titleCache" }) })
public class Collection extends IdentifiableMediaEntity implements Cloneable{
private static final Logger logger = Logger.getLogger(Collection.class);
@XmlElement(name = "Institution")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Institution institute;
@XmlElement(name = "SuperCollection")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Collection superCollection;
super();
}
-
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Institution getInstitute(){
return this.institute;
}
return "";
}
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Collection getSuperCollection() {
return superCollection;
}
return null;
}
}
-
-
-
}
\ No newline at end of file
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.EventBase;
})
@XmlRootElement(name = "DerivationEvent")
@Entity
-//@Audited
+@Audited
public class DerivationEvent extends EventBase implements Cloneable{
static Logger logger = Logger.getLogger(DerivationEvent.class);
@XmlElement(name = "Original")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private Set<SpecimenOrObservationBase> originals = getNewOriginalsSet();
+ @ManyToMany(fetch = FetchType.LAZY,mappedBy="derivationEvents")
+ protected Set<SpecimenOrObservationBase> originals = new HashSet<SpecimenOrObservationBase>();
@XmlElementWrapper(name = "Derivatives")
@XmlElement(name = "Derivative")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- protected Set<DerivedUnitBase> derivatives = getNewDerivatesSet();
+ @OneToMany(fetch=FetchType.LAZY,mappedBy="derivationEvent")
+ @Cascade({CascadeType.SAVE_UPDATE})
+ protected Set<DerivedUnitBase> derivatives = new HashSet<DerivedUnitBase>();
@XmlElement(name = "DerivationEventType")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private DerivationEventType type;
/**
super();
}
- @ManyToMany(fetch = FetchType.LAZY,mappedBy="derivationEvents")
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<SpecimenOrObservationBase> getOriginals() {
return originals;
}
- protected void setOriginals(Set<SpecimenOrObservationBase> originals) {
- this.originals = originals;
- }
+
public void addOriginal(SpecimenOrObservationBase original) {
if (! this.originals.contains(original)){
this.originals.add(original);
this.originals.remove(original);
}
-
- @OneToMany(fetch=FetchType.LAZY,mappedBy="derivationEvent")
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<DerivedUnitBase> getDerivatives() {
return derivatives;
}
- protected void setDerivatives(Set<DerivedUnitBase> derivatives) {
- this.derivatives = derivatives;
- }
+
public void addDerivative(DerivedUnitBase derivative) {
if (derivative != null){
derivative.setDerivedFrom(this);
}
}
-
- @ManyToOne(fetch = FetchType.LAZY)
public DerivationEventType getType() {
return type;
}
+
public void setType(DerivationEventType type) {
this.type = type;
}
-
//*********** CLONE **********************************/
/**
* @see java.lang.Object#clone()
*/
@Override
- public Object clone(){
+ public Object clone() throws CloneNotSupportedException {
try{
DerivationEvent result = (DerivationEvent)super.clone();
//type
result.setType(this.getType());
//derivates
- Set<DerivedUnitBase> derivates = getNewDerivatesSet();
- derivates.addAll(this.derivatives);
- result.setDerivatives(derivates);
+ result.derivatives = new HashSet<DerivedUnitBase>();
+ for(DerivedUnitBase derivative : this.derivatives) {
+ result.addDerivative(derivative);
+ }
//originals
- Set<SpecimenOrObservationBase> originals = getNewOriginalsSet();
- originals.addAll(this.originals);
- result.setOriginals(this.getOriginals());
+ result.originals = new HashSet<SpecimenOrObservationBase>();
+ for(SpecimenOrObservationBase original : this.originals) {
+ result.addOriginal(original);
+ }
//no changes to: -
return result;
} catch (CloneNotSupportedException e) {
return null;
}
}
-
- @Transient
- private static Set<DerivedUnitBase> getNewDerivatesSet(){
- return new HashSet<DerivedUnitBase>();
- }
-
- @Transient
- private static Set<SpecimenOrObservationBase> getNewOriginalsSet(){
- return new HashSet<SpecimenOrObservationBase>();
- }
-
}
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
@XmlType(name = "DerivationEventType")
@XmlRootElement(name = "DerivationEventType")
@Entity
-//@Audited
+@Audited
public class DerivationEventType extends DefinedTermBase<DerivationEventType> {
private static final Logger logger = Logger.getLogger(DerivationEventType.class);
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "DerivedUnit")
@Entity
-//@Audited
+@Audited
public class DerivedUnit extends DerivedUnitBase implements Cloneable{
private static final Logger logger = Logger.getLogger(DerivedUnit.class);
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.ManyToOne;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
"collection",
"catalogNumber",
"storedUnder",
- "derivedFrom",
+ "derivationEvent",
"accessionNumber",
"collectorsNumber"
})
@XmlRootElement(name = "DerivedUnitBase")
@Entity
-//@Audited
+@Audited
public abstract class DerivedUnitBase extends SpecimenOrObservationBase implements Cloneable{
@XmlElement(name = "Collection")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Collection collection;
@XmlElement(name = "CatalogNumber")
@XmlElement(name = "StoredUnder")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private TaxonNameBase storedUnder;
@XmlElement(name = "DerivedFrom")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private DerivationEvent derivedFrom;
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
+ private DerivationEvent derivationEvent;
/**
* Constructor
FieldObservation field = (FieldObservation) this.getOriginalUnit();
field.setGatheringEvent(gatheringEvent);
}
-
-
-
- @Deprecated //only for bidirectional and persistence use
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
- private DerivationEvent getDerivationEvent() {
- return getDerivedFrom();
- }
- @Deprecated //only for bidirectional and persistence use
- private void setDerivationEvent(DerivationEvent derivationEvent) {
- this.derivedFrom = derivationEvent;
- }
- @Transient
+
public DerivationEvent getDerivedFrom() {
- return derivedFrom;
+ return derivationEvent;
}
+
public void setDerivedFrom(DerivationEvent derivedFrom){
if (getDerivedFrom() != null){
getDerivedFrom().getDerivatives().remove(derivedFrom);
}
- this.derivedFrom = derivedFrom;
+ this.derivationEvent = derivedFrom;
if (derivedFrom != null){
derivedFrom.getDerivatives().add(this);
}
}
- @Transient
public Set<SpecimenOrObservationBase> getOriginals(){
return this.getDerivedFrom().getOriginals();
}
-
@Override
- @Transient
public GatheringEvent getGatheringEvent() {
// FIXME: implement efficient way of getting original gathering event
// keep link to original gathering event for performance mainly.
return null;
}
-
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Collection getCollection(){
return this.collection;
}
+
public void setCollection(Collection collection){
this.collection = collection;
}
this.collectorsNumber = collectorsNumber;
}
-
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public TaxonNameBase getStoredUnder() {
return storedUnder;
}
-
//*********** CLONE **********************************/
/**
//collection
result.setCollection(this.collection);
//derivedFrom
- result.setDerivedFrom(this.derivedFrom);
+ result.setDerivedFrom(this.derivationEvent);
//storedUnder
result.setStoredUnder(this.storedUnder);
//no changes to: accessionNumber, catalogNumber, collectorsNumber
return result;
}
-
-
-
}
import javax.persistence.FetchType;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
-import javax.persistence.Transient;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlElementWrapper;
+import javax.xml.bind.annotation.XmlIDREF;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlSchemaType;
+import javax.xml.bind.annotation.XmlType;
-import eu.etaxonomy.cdm.model.agent.Agent;
-import eu.etaxonomy.cdm.model.reference.ReferenceBase;
-import eu.etaxonomy.cdm.model.taxon.Taxon;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import org.joda.time.Partial;
+import eu.etaxonomy.cdm.model.agent.AgentBase;
import eu.etaxonomy.cdm.model.common.EventBase;
+import eu.etaxonomy.cdm.model.reference.ReferenceBase;
+import eu.etaxonomy.cdm.model.taxon.Taxon;
/**
* @author m.doering
* @version 1.0
* @created 08-Nov-2007 13:06:21
*/
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "DeterminationEvent", propOrder = {
+ "identifiedUnit",
+ "taxon",
+ "modifier",
+ "preferredFlag",
+ "setOfReferences"
+})
+@XmlRootElement(name = "DeterminationEvent")
@Entity
-//@Audited
+@Audited
public class DeterminationEvent extends EventBase {
private static final Logger logger = Logger.getLogger(DeterminationEvent.class);
+ @XmlElement(name = "IdentifiedUnit")
+ @XmlIDREF
+ @XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private SpecimenOrObservationBase identifiedUnit;
- private Taxon taxon;
+
+ @XmlElement(name = "Taxon")
+ @XmlIDREF
+ @XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
+ private Taxon taxon;
+
+ @XmlElement(name = "Modifier")
+ @XmlIDREF
+ @XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private DeterminationModifier modifier;
+
+ @XmlElement(name = "PreferredFlag")
private boolean preferredFlag;
- private Set<ReferenceBase> setOfReferences = getNewReferencesSet();
+
+ @XmlElementWrapper(name = "SetOfReferences")
+ @XmlElement(name = "Reference")
+ @XmlIDREF
+ @XmlSchemaType(name = "IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
+ private Set<ReferenceBase> setOfReferences = new HashSet<ReferenceBase>();
super();
}
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade( { CascadeType.SAVE_UPDATE })
public DeterminationModifier getModifier() {
return modifier;
}
this.modifier = modifier;
}
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade( { CascadeType.SAVE_UPDATE })
public Taxon getTaxon(){
return this.taxon;
}
this.taxon = taxon;
}
-
- @Transient
public Partial getIdentificationDate(){
return this.getTimeperiod().getStart();
}
this.getTimeperiod().setStart(identificationDate);
}
- @Transient
- public Agent getDeterminer() {
+ public AgentBase getDeterminer() {
return this.getActor();
}
- public void setDeterminer(Agent determiner) {
+
+ public void setDeterminer(AgentBase determiner) {
this.setActor(determiner);
}
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade( { CascadeType.SAVE_UPDATE })
public SpecimenOrObservationBase getIdentifiedUnit() {
return identifiedUnit;
}
this.preferredFlag = preferredFlag;
}
- @Transient
- private static Set<ReferenceBase> getNewReferencesSet(){
- return new HashSet<ReferenceBase>();
- }
-
- @ManyToMany(fetch = FetchType.LAZY)
- @Cascade( { CascadeType.SAVE_UPDATE })
public Set<ReferenceBase> getReferences() {
return setOfReferences;
}
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import eu.etaxonomy.cdm.model.description.Modifier;
@XmlType(name = "DeterminationModifier")
@XmlRootElement(name = "DeterminationModifier")
@Entity
-//@Audited
+@Audited
public class DeterminationModifier extends Modifier {
private static final Logger logger = Logger.getLogger(DeterminationModifier.class);
package eu.etaxonomy.cdm.model.occurrence;
-import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
+import java.util.HashSet;
+import java.util.Set;
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.ManyToOne;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations .CascadeType;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
+
/**
* In situ observation of a taxon in the field. If a specimen exists,
* in most cases a parallel field observation object should be instantiated and the specimen then is "derived" from the field unit
})
@XmlRootElement(name = "FieldObservation")
@Entity
-//@Audited
+@Audited
public class FieldObservation extends SpecimenOrObservationBase implements Cloneable{
private static final Logger logger = Logger.getLogger(FieldObservation.class);
@XmlElement(name = "GatheringEvent")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade( { CascadeType.SAVE_UPDATE })
private GatheringEvent gatheringEvent;
/**
return new FieldObservation();
}
-
/**
* Constructor
*/
protected FieldObservation(){
super();
}
-
- @Override
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade( { CascadeType.SAVE_UPDATE })
+
+ @Override
public GatheringEvent getGatheringEvent() {
- return this.gatheringEvent;
+ return gatheringEvent;
}
+
public void setGatheringEvent(GatheringEvent gatheringEvent) {
this.gatheringEvent = gatheringEvent;
}
public String getFieldNumber() {
return fieldNumber;
}
+
public void setFieldNumber(String fieldNumber) {
this.fieldNumber = fieldNumber;
}
-
public String getFieldNotes() {
return fieldNotes;
}
+
public void setFieldNotes(String fieldNotes) {
this.fieldNotes = fieldNotes;
}
-
//*********** CLONE **********************************/
/**
@Override
public FieldObservation clone(){
try{
- FieldObservation result = (FieldObservation)super.clone();
- result.setGatheringEvent(this.gatheringEvent); //TODO ?
+ FieldObservation result = (FieldObservation)super.clone();
//no changes to: fieldNotes, fieldNumber
return result;
} catch (CloneNotSupportedException e) {
}
}
-
-
}
\ No newline at end of file
package eu.etaxonomy.cdm.model.occurrence;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
})
@XmlRootElement(name = "Fossil")
@Entity
-//@Audited
+@Audited
public class Fossil extends Specimen implements Cloneable{
private static final Logger logger = Logger.getLogger(Fossil.class);
import java.util.HashSet;
import java.util.Set;
+import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
+import javax.persistence.OneToOne;
import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import org.joda.time.Partial;
-import eu.etaxonomy.cdm.model.agent.Agent;
+import eu.etaxonomy.cdm.model.agent.AgentBase;
import eu.etaxonomy.cdm.model.common.EventBase;
import eu.etaxonomy.cdm.model.common.LanguageString;
import eu.etaxonomy.cdm.model.common.TimePeriod;
})
@XmlRootElement(name = "GatheringEvent")
@Entity
-//@Audited
+@Audited
public class GatheringEvent extends EventBase implements Cloneable{
static Logger logger = Logger.getLogger(GatheringEvent.class);
- //Locality name (as free text) where this occurrence happened
@XmlElement(name = "Locality")
+ @OneToOne(fetch = FetchType.LAZY)
+ @Cascade({CascadeType.ALL,CascadeType.DELETE_ORPHAN})
private LanguageString locality;
@XmlElement(name = "ExactLocation")
@XmlElement(name = "CollectingArea")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private Set<NamedArea> collectingAreas = getNewNamedAreaSet();
+ @ManyToMany(fetch = FetchType.LAZY)
+ private Set<NamedArea> collectingAreas = new HashSet<NamedArea>();
@XmlElement(name = "CollectingMethod")
private String collectingMethod;
@XmlElement(name = "DistanceToWaterSurface")
private Integer distanceToWaterSurface;
-
/**
* Factory method
* @return
this.exactLocation = exactLocation;
}
- @ManyToMany(fetch = FetchType.LAZY)
+
public Set<NamedArea> getCollectingAreas(){
return this.collectingAreas;
}
- public void setCollectingAreas(Set<NamedArea> area){
- if (area == null){
- getNewNamedAreaSet();
- }
- this.collectingAreas = area;
- }
+
+
public void addCollectingArea(NamedArea area){
if (this.collectingAreas == null)
this.collectingAreas = getNewNamedAreaSet();
this.collectingAreas.add(area);
}
+
public void removeCollectingArea(NamedArea area){
//TODO to be implemented?
logger.warn("not yet fully implemented?");
this.collectingAreas.remove(area);
}
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public LanguageString getLocality(){
return this.locality;
}
+
public void setLocality(LanguageString locality){
this.locality = locality;
}
* EventBase managed attributes
* @return
*/
- @Transient
+
public Partial getGatheringDate(){
return this.getTimeperiod().getStart();
}
+
public void setGatheringDate(Partial gatheringDate){
this.setTimeperiod(TimePeriod.NewInstance(gatheringDate));
}
- @Transient
+
public void setGatheringDate(Calendar gatheringDate){
this.setTimeperiod(TimePeriod.NewInstance(gatheringDate));
}
- @Transient
- public Agent getCollector(){
+ public AgentBase getCollector(){
return this.getActor();
}
- public void setCollector(Agent collector){
+
+ public void setCollector(AgentBase collector){
this.setActor(collector);
}
-
public String getCollectingMethod() {
return collectingMethod;
}
+
public void setCollectingMethod(String collectingMethod) {
this.collectingMethod = collectingMethod;
}
-
public Integer getAbsoluteElevation() {
return absoluteElevation;
}
this.absoluteElevation = absoluteElevation;
}
-
public Integer getAbsoluteElevationError() {
return absoluteElevationError;
}
+
public void setAbsoluteElevationError(Integer absoluteElevationError) {
this.absoluteElevationError = absoluteElevationError;
}
+
public Integer getDistanceToGround() {
return distanceToGround;
}
+
public void setDistanceToGround(Integer distanceToGround) {
this.distanceToGround = distanceToGround;
}
+
public Integer getDistanceToWaterSurface() {
return distanceToWaterSurface;
}
+
public void setDistanceToWaterSurface(Integer distanceToWaterSurface) {
this.distanceToWaterSurface = distanceToWaterSurface;
}
-
//*********** CLONE **********************************/
/**
//exact location
result.setExactLocation(this.exactLocation.clone());
//namedAreas
- Set<NamedArea> namedAreas = getNewNamedAreaSet();
- namedAreas.addAll(this.collectingAreas);
- result.setCollectingAreas(namedAreas);
+ result.collectingAreas = new HashSet<NamedArea>();
+ for(NamedArea collectingArea : this.collectingAreas) {
+ result.addCollectingArea(collectingArea);
+ }
//no changes to: distanceToWaterSurface, distanceToGround, collectingMethod, absoluteElevationError, absoluteElevation
return result;
package eu.etaxonomy.cdm.model.occurrence;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
})
@XmlRootElement(name = "LivingBeing")
@Entity
-//@Audited
+@Audited
public class LivingBeing extends DerivedUnitBase implements Cloneable {
private static final Logger logger = Logger.getLogger(LivingBeing.class);
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
* @created 08-Nov-2007 13:06:32
*/
@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "Observation")
@XmlRootElement(name = "Observation")
@Entity
-//@Audited
+@Audited
public class Observation extends DerivedUnitBase implements Cloneable{
private static final Logger logger = Logger.getLogger(Observation.class);
package eu.etaxonomy.cdm.model.occurrence;
-import java.util.UUID;
-
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlType;
/**
* http://rs.tdwg.org/ontology/voc/Collection.rdf#SpecimenPreservationMethodTypeTerm
* @created 08-Nov-2007 13:06:44
*/
@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "PreservationMethod")
@XmlRootElement(name = "PreservationMethod")
@Entity
-//@Audited
+@Audited
public class PreservationMethod extends DefinedTermBase<PreservationMethod> {
private static final Logger logger = Logger.getLogger(PreservationMethod.class);
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
/**
* A specimen is regarded as derived from an field observation,
})
@XmlRootElement(name = "Specimen")
@Entity
-//@Audited
+@Audited
public class Specimen extends DerivedUnitBase implements Cloneable {
private static final Logger logger = Logger.getLogger(Specimen.class);
@XmlElement(name = "Preservation")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private PreservationMethod preservation;
/**
super();
}
- @ManyToOne(fetch = FetchType.LAZY)
public PreservationMethod getPreservation(){
return this.preservation;
}
+
public void setPreservation(PreservationMethod preservation){
this.preservation = preservation;
}
package eu.etaxonomy.cdm.model.occurrence;
+import java.lang.reflect.Method;
+import java.util.HashMap;
import java.util.HashSet;
+import java.util.Map;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.Index;
import org.hibernate.annotations.Table;
+import org.hibernate.envers.Audited;
+import org.springframework.util.ReflectionUtils;
+import eu.etaxonomy.cdm.jaxb.MultilanguageTextAdapter;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.LanguageString;
-import eu.etaxonomy.cdm.model.common.MultilanguageText;
import eu.etaxonomy.cdm.model.description.DescriptionBase;
import eu.etaxonomy.cdm.model.description.Sex;
import eu.etaxonomy.cdm.model.description.SpecimenDescription;
})
@XmlRootElement(name = "SpecimenOrObservationBase")
@Entity
-//@Audited
+@Audited
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@Table(appliesTo="SpecimenOrObservationBase", indexes = { @Index(name = "specimenOrObservationBaseTitleCacheIndex", columnNames = { "titleCache" }) })
public abstract class SpecimenOrObservationBase extends IdentifiableMediaEntity {
@XmlElementWrapper(name = "Descriptions")
@XmlElement(name = "Description")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
- private Set<DescriptionBase> descriptions = getNewDescriptionSet();
+ @ManyToMany(fetch = FetchType.LAZY,mappedBy="describedSpecimenOrObservations",targetEntity=DescriptionBase.class)
+ private Set<SpecimenDescription> descriptions = new HashSet<SpecimenDescription>();
@XmlElementWrapper(name = "Determinations")
@XmlElement(name = "Determination")
- private Set<DeterminationEvent> determinations = getNewDeterminationEventSet();
+ @OneToMany(mappedBy="identifiedUnit")
+ @Cascade({CascadeType.SAVE_UPDATE})
+ private Set<DeterminationEvent> determinations = new HashSet<DeterminationEvent>();
@XmlElement(name = "Sex")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private Sex sex;
@XmlElement(name = "LifeStage")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private Stage lifeStage;
@XmlElement(name = "IndividualCount")
// the verbatim description of this occurrence. Free text usable when no atomised data is available.
// in conjunction with titleCache which serves as the "citation" string for this object
@XmlElement(name = "Description")
- private MultilanguageText description;
+ @XmlJavaTypeAdapter(MultilanguageTextAdapter.class)
+ @OneToMany(fetch = FetchType.LAZY)
+ protected Map<Language,LanguageString> description = new HashMap<Language,LanguageString>();
// events that created derivedUnits from this unit
@XmlElementWrapper(name = "DerivationEvents")
@XmlElement(name = "DerivationEvent")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private Set<DerivationEvent> derivationEvents = getNewDerivationEventSet();
+ @ManyToMany(fetch=FetchType.LAZY)
+ protected Set<DerivationEvent> derivationEvents = new HashSet<DerivationEvent>();
/**
* Constructor
super();
}
- @ManyToMany(fetch = FetchType.LAZY, mappedBy = "describedSpecimenOrObservations")
- public Set<DescriptionBase> getDescriptions() {
+ public Set<SpecimenDescription> getDescriptions() {
return this.descriptions;
}
- protected void setDescriptions(Set<DescriptionBase> descriptions) {
- this.descriptions = descriptions;
- }
+
public void addDescription(SpecimenDescription description) {
- if (this.descriptions == null){
- this.descriptions = getNewDescriptionSet();
- }
this.descriptions.add(description);
+ Method method = ReflectionUtils.findMethod(SpecimenDescription.class, "addDescribedSpecimenOrObservations", new Class[] {SpecimenOrObservationBase.class});
+ ReflectionUtils.makeAccessible(method);
+ ReflectionUtils.invokeMethod(method, description, new Object[] {this});
}
+
public void removeDescription(SpecimenDescription description) {
this.descriptions.remove(description);
+ Method method = ReflectionUtils.findMethod(SpecimenDescription.class, "removeDescribedSpecimenOrObservations", new Class[] {SpecimenOrObservationBase.class});
+ ReflectionUtils.makeAccessible(method);
+ ReflectionUtils.invokeMethod(method, description, new Object[] {this});
}
- @ManyToMany(fetch=FetchType.LAZY)
- @Cascade( { CascadeType.SAVE_UPDATE })
public Set<DerivationEvent> getDerivationEvents() {
return this.derivationEvents;
}
- protected void setDerivationEvents(Set<DerivationEvent> derivationEvents) {
- this.derivationEvents = derivationEvents;
- }
+
public void addDerivationEvent(DerivationEvent derivationEvent) {
if (! this.derivationEvents.contains(derivationEvent)){
this.derivationEvents.add(derivationEvent);
derivationEvent.addOriginal(this);
}
}
+
public void removeDerivationEvent(DerivationEvent derivationEvent) {
this.derivationEvents.remove(derivationEvent);
}
-
-
- @OneToMany(mappedBy="identifiedUnit")
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<DeterminationEvent> getDeterminations() {
return this.determinations;
}
- protected void setDeterminations(Set<DeterminationEvent> determinations) {
- this.determinations = determinations;
- }
+
public void addDetermination(DeterminationEvent determination) {
// FIXME bidirectional integrity. Use protected Determination setter
this.determinations.add(determination);
}
+
public void removeDetermination(DeterminationEvent determination) {
// FIXME bidirectional integrity. Use protected Determination setter
this.determinations.remove(determination);
}
-
- @ManyToOne(fetch = FetchType.LAZY)
public Sex getSex() {
return sex;
}
this.sex = sex;
}
- @ManyToOne(fetch = FetchType.LAZY)
public Stage getLifeStage() {
return lifeStage;
}
this.lifeStage = lifeStage;
}
-
@Override
public String generateTitle(){
return "";
}
-
-
+
public Integer getIndividualCount() {
return individualCount;
}
this.individualCount = individualCount;
}
-
- public MultilanguageText getDefinition(){
+ public Map<Language,LanguageString> getDefinition(){
return this.description;
}
- private void setDefinition(MultilanguageText description){
- this.description = description;
- }
+
public void addDefinition(LanguageString description){
- initDescription();
- this.description.add(description);
+ this.description.put(description.getLanguage(),description);
}
+
public void addDefinition(String text, Language language){
- initDescription();
this.description.put(language, LanguageString.NewInstance(text, language));
}
public void removeDefinition(Language lang){
this.description.remove(lang);
}
-
/**
* for derived units get the single next higher parental/original unit.
* If multiple original units exist throw error
* @return
*/
- @Transient
public SpecimenOrObservationBase getOriginalUnit(){
return null;
}
- @Transient
public abstract GatheringEvent getGatheringEvent();
* @see java.lang.Object#clone()
*/
@Override
- public Object clone() throws CloneNotSupportedException{
+ public Object clone() throws CloneNotSupportedException {
SpecimenOrObservationBase result = null;
result = (SpecimenOrObservationBase)super.clone();
//defininion (description, languageString)
- if (this.getDefinition() != null){
- result.setDefinition(this.getDefinition().clone());
- }
+ result.description = new HashMap<Language,LanguageString>();
+ for(LanguageString languageString : this.description.values()) {
+ LanguageString newLanguageString = (LanguageString)languageString.clone();
+ result.addDefinition(newLanguageString);
+ }
+
//sex
result.setSex(this.sex);
//life stage
result.setLifeStage(this.lifeStage);
//Descriptions
- Set<DescriptionBase> descriptions = getNewDescriptionSet();
- descriptions.addAll(this.descriptions);
- result.setDescriptions(descriptions);
+ for(DescriptionBase description : this.descriptions) {
+ result.addDescription((SpecimenDescription)description);
+ }
- //DeterminationEvent
- Set<DeterminationEvent> determinationEvents = getNewDeterminationEventSet();
- determinationEvents.addAll(this.determinations);
- result.setDeterminations(determinationEvents);
+ //DeterminationEvent FIXME should clone() the determination
+ // as the relationship is OneToMany
+ for(DeterminationEvent determination : this.determinations) {
+ result.addDetermination(determination);
+ }
//DerivationEvent
- Set<DerivationEvent> derivationEvent = getNewDerivationEventSet();
- derivationEvent.addAll(this.getDerivationEvents());
- result.setDerivationEvents(derivationEvent);
+ for(DerivationEvent derivationEvent : this.derivationEvents) {
+ result.addDerivationEvent(derivationEvent);
+ }
//no changes to: individualCount
return result;
}
-
- @Transient
- private Set<DescriptionBase> getNewDescriptionSet(){
- return new HashSet<DescriptionBase>();
- }
-
- @Transient
- private Set<DeterminationEvent> getNewDeterminationEventSet(){
- return new HashSet<DeterminationEvent>();
- }
-
-
- @Transient
- private Set<DerivationEvent> getNewDerivationEventSet(){
- return new HashSet<DerivationEvent>();
- }
-
- /**
- * Initializes the description multilanguage text if it is not yet initialized (== null).
- */
- @Transient
- private void initDescription(){
- if (this.description == null){
- this.description = new MultilanguageText();
- }
- }
}
\ No newline at end of file
--- /dev/null
+\r
+@javax.xml.bind.annotation.XmlSchema(namespace = "http://etaxonomy.eu/cdm/model/occurrence/1.0", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)\r
+package eu.etaxonomy.cdm.model.occurrence;
\ No newline at end of file
import javax.persistence.Entity;
+import javax.persistence.FetchType;
import javax.persistence.ManyToOne;
import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
import eu.etaxonomy.cdm.model.common.TimePeriod;
"series",
"volume",
"pages",
- "inJournal",
- "nomRefBase"
+ "inJournal"
})
@XmlRootElement(name = "Article")
@Entity
-//@Audited
+@Audited
public class Article extends StrictReferenceBase implements INomenclaturalReference, IVolumeReference, Cloneable {
private static final long serialVersionUID = -1528079480114388117L;
private static final Logger logger = Logger.getLogger(Article.class);
@XmlElement(name = "InJournal")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Journal inJournal;
- //@XmlTransient
- @XmlElementRef(name = "NomenclaturalReferenceBase")
+ @XmlTransient
+ @Transient
private NomenclaturalReferenceHelper nomRefBase = NomenclaturalReferenceHelper.NewInstance(this);
* @return the journal
* @see Journal
*/
- @ManyToOne
- @Cascade({CascadeType.SAVE_UPDATE})
public Journal getInJournal(){
return this.inJournal;
}
+
/**
* @see #getInJournal()
*/
* @see StrictReferenceBase#getCitation()
*/
@Override
- @Transient
public String getCitation(){
return nomRefBase.getCitation();
}
*
* @see #getCitation()
*/
- @Transient
public String getNomenclaturalCitation(String microReference) {
return nomRefBase.getNomenclaturalCitation(microReference);
}
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
@XmlType(name = "BibtexEntryType")
@XmlRootElement(name = "BibtexEntryType")
@Entity
-//@Audited
+@Audited
public class BibtexEntryType extends DefinedTermBase<BibtexEntryType> {
/**
*
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.TimePeriod;
import eu.etaxonomy.cdm.strategy.cache.reference.BibtexDefaultCacheStrategy;
})
@XmlRootElement(name = "BibtexReference")
@Entity
-//@Audited
+@Audited
public class BibtexReference extends ReferenceBase implements INomenclaturalReference, Cloneable {
/**
*
private static final Logger logger = Logger.getLogger(BibtexReference.class);
@XmlElement(name = "BibtexEntryType")
+ @ManyToOne(fetch = FetchType.LAZY)
private BibtexEntryType type;
@XmlElement(name = "Journal")
@XmlElement(name = "Crossref")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
private BibtexReference crossref;
@XmlElementRef(name = "NomenclaturalReferenceBase")
+ @Transient
private NomenclaturalReferenceHelper nomRefBase = NomenclaturalReferenceHelper.NewInstance(this);
* @return the BibTeX reference containing <i>this</i> BibTeX reference
* @see BibtexEntryType
*/
- @ManyToOne
- @Cascade({CascadeType.SAVE_UPDATE})
public BibtexReference getCrossref(){
return this.crossref;
}
*
* @return the BibTeX entry type of <i>this</i> BibTeX reference
*/
- @ManyToOne(fetch = FetchType.LAZY)
public BibtexEntryType getType() {
return type;
}
public void setType(BibtexEntryType type) {
this.type = type;
}
-
-
-
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.reference.INomenclaturalReference#setDatePublished(eu.etaxonomy.cdm.model.common.TimePeriod)
* @see ReferenceBase#getCitation()
*/
@Override
- @Transient
public String getCitation(){
return nomRefBase.getCitation();
}
* @see getCitation()
* @see INomenclaturalReference#getNomenclaturalCitation(String)
*/
- @Transient
public String getNomenclaturalCitation(String microReference) {
return nomRefBase.getNomenclaturalCitation(microReference);
}
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
-import javax.xml.bind.annotation.XmlElementRef;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.strategy.cache.reference.BookDefaultCacheStrategy;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "Book", propOrder = {
"edition",
- "isbn",
- "nomRefBase"
+ "isbn"
})
@XmlRootElement(name = "Book")
@Entity
-//@Audited
+@Audited
public class Book extends PrintedUnitBase implements INomenclaturalReference, Cloneable {
/**
@XmlElement(name = "ISBN")
private String isbn;
- //@XmlTransient
- @XmlElementRef(name = "NomenclaturalReferenceBase")
+ @XmlTransient
+ @Transient
private NomenclaturalReferenceHelper nomRefBase = NomenclaturalReferenceHelper.NewInstance(this);
-
-
/**
* Class constructor: creates a new empty book instance
* @see StrictReferenceBase#getCitation()
*/
@Override
- @Transient
public String getCitation(){
return nomRefBase.getCitation();
}
* nomenclatural citation
* @see #getCitation()
*/
- @Transient
public String getNomenclaturalCitation(String microReference) {
return nomRefBase.getNomenclaturalCitation(microReference);
}
import javax.persistence.Entity;
+import javax.persistence.FetchType;
import javax.persistence.ManyToOne;
import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
-import javax.xml.bind.annotation.XmlElementRef;
import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
import eu.etaxonomy.cdm.model.common.TimePeriod;
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "BookSection", propOrder = {
- "inBook",
- "nomRefBase"
+ "inBook"
})
@XmlRootElement(name = "BookSection")
@Entity
-//@Audited
+@Audited
public class BookSection extends SectionBase implements INomenclaturalReference, Cloneable {
/**
@XmlElement(name = "BookSection")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Book inBook;
- //@XmlTransient
- @XmlElementRef(name = "NomenclaturalReferenceBase")
+ @XmlTransient
+ @Transient
private NomenclaturalReferenceHelper nomRefBase = NomenclaturalReferenceHelper.NewInstance(this);
* @return the book containing <i>this</i> book section
* @see Book
*/
- @ManyToOne
- @Cascade({CascadeType.SAVE_UPDATE})
public Book getInBook(){
return this.inBook;
}
* @see StrictReferenceBase#getCitation()
*/
@Override
- @Transient
public String getCitation(){
return nomRefBase.getCitation();
}
* nomenclatural citation
* @see #getCitation()
*/
- @Transient
public String getNomenclaturalCitation(String microReference) {
return nomRefBase.getNomenclaturalCitation(microReference);
}
* @see StrictReferenceBase#getDatePublished()
**/
@Override
- @Transient
// This method overrides StrictReferenceBase.getDatePublished() only to have
// a specific Javadoc for BookSection.getDatePublished().
public TimePeriod getDatePublished(){
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
/**
* This class represents electronic publications the support of which are Cds
@XmlType(name = "CdDvd")
@XmlRootElement(name = "CdDvd")
@Entity
-//@Audited
+@Audited
public class CdDvd extends PublicationBase implements Cloneable{
/**
*
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
/**
* This class represents a database used as an information source. A database is
@XmlType(name = "Database")
@XmlRootElement(name = "Database")
@Entity
-//@Audited
+@Audited
public class Database extends PublicationBase implements Cloneable {
/**
"pages",
"editor",
"publisher",
- "placePublished",
- "nomRefBase"
+ "placePublished"
})
@XmlRootElement(name = "Generic")
@Entity
@XmlElement(name = "Pages")
private String pages;
- //@XmlTransient
- @XmlElementRef(name = "NomenclaturalReferenceBase")
+ @XmlTransient
+ @Transient
private NomenclaturalReferenceHelper nomRefBase = NomenclaturalReferenceHelper.NewInstance(this);
* @see StrictReferenceBase#getCitation()
*/
@Override
- @Transient
public String getCitation(){
return nomRefBase.getCitation();
}
* nomenclatural citation
* @see #getCitation()
*/
- @Transient
public String getNomenclaturalCitation(String microReference) {
return nomRefBase.getNomenclaturalCitation(microReference);
}
* Returns a formatted string containing the reference citation excluding
* authors but including the details as used in a {@link TaxonNameBase taxon name}.
*/
- @Transient
public String getNomenclaturalCitation(String microReference);
/**
* Returns a string representation for the year of publication / creation
* of a reference.
*/
- @Transient
public String getYear();
/**
import javax.persistence.Entity;
+import javax.persistence.FetchType;
import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
/**
* This class represents isolated parts (usually papers or abstracts) within
})
@XmlRootElement(name = "InProceedings")
@Entity
-//@Audited
+@Audited
public class InProceedings extends SectionBase {
@XmlElement(name = "InProceedings")
@XmlIDREF
@XmlSchemaType(name = "InProceedings")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Proceedings inProceedings;
/**
* published
* @see Proceedings
*/
- @ManyToOne
- @Cascade({CascadeType.SAVE_UPDATE})
public Proceedings getInProceedings(){
return this.inProceedings;
}
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.strategy.cache.reference.JournalDefaultCacheStrategy;
})
@XmlRootElement(name = "Journal")
@Entity
-//@Audited
+@Audited
public class Journal extends PublicationBase implements Cloneable {
static Logger logger = Logger.getLogger(Journal.class);
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
/**
* This class represents published maps from which information can be derived.
@XmlType(name = "Map")
@XmlRootElement(name = "Map")
@Entity
-//@Audited
+@Audited
public class Map extends PublicationBase implements Cloneable {
private static final Logger logger = Logger.getLogger(Map.class);
\r
package eu.etaxonomy.cdm.model.reference;\r
\r
-import javax.persistence.Transient;\r
import javax.xml.bind.annotation.XmlAccessType;\r
import javax.xml.bind.annotation.XmlAccessorType;\r
import javax.xml.bind.annotation.XmlElement;\r
* @created 28.06.2008\r
* @version 1.0\r
*/\r
-@XmlAccessorType(XmlAccessType.FIELD)\r
-@XmlType(name = "NomenclaturalReferenceHelper", propOrder = {\r
- "nomenclaturalReference"\r
-})\r
-@XmlRootElement(name = "NomenclaturalReferenceHelper")\r
class NomenclaturalReferenceHelper {\r
private static final Logger logger = Logger.getLogger(NomenclaturalReferenceHelper.class);\r
\r
- @XmlElement(name = "NomenclaturalReference")\r
- @XmlIDREF\r
- @XmlSchemaType(name = "IDREF")\r
private ReferenceBase nomenclaturalReference; \r
//private IReferenceBaseCacheStrategy<ReferenceBase> cacheStrategy; \r
\r
* \r
* @see strategy.cache.reference.INomenclaturalReferenceCacheStrategy\r
*/\r
- @Transient\r
public String getCitation(){\r
//TODO\r
logger.warn("getCitation not yet fully implemented");\r
* @see name.TaxonNameBase#getNomenclaturalReference()\r
* @see strategy.cache.reference.INomenclaturalReferenceCacheStrategy\r
*/\r
- @Transient\r
public String getNomenclaturalCitation(String microReference) {\r
if (nomenclaturalReference.isProtectedTitleCache()){\r
return nomenclaturalReference.getTitleCache();\r
/* (non-Javadoc)\r
* @see eu.etaxonomy.cdm.model.reference.ReferenceBase#generateTitle()\r
*/\r
- @Transient\r
/**\r
* Generates, according to the {@link INomenclaturalReferenceCacheStrategy cache strategy}\r
* assigned to the {@link ReferenceBase reference} of <i>this</i> nomenclatural reference helper,\r
}\r
\r
//\r
- @Transient\r
private String getTokenizedFullNomenclaturalTitel() {\r
if (getCacheStrategy() == null || ! (getCacheStrategy() instanceof INomenclaturalReferenceCacheStrategy) ){\r
logger.warn("cacheStrategy == null of not instanceOf INomenclaturalReferenceCacheStrategy");\r
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
/**
* This class represents patents. A patent is a document containing the set of
* exclusive rights granted by a state to an inventor or his assignee for a
@XmlType(name = "Patent")
@XmlRootElement(name = "Patent")
@Entity
-//@Audited
+@Audited
public class Patent extends StrictReferenceBase implements Cloneable {
private static final Logger logger = Logger.getLogger(Patent.class);
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
/**
* This class represents personal communications. A personal communication is a
@XmlType(name = "PersonalCommunication")
@XmlRootElement(name = "PersonalCommunication")
@Entity
-//@Audited
+@Audited
public class PersonalCommunication extends StrictReferenceBase implements Cloneable {
private static final Logger logger = Logger.getLogger(PersonalCommunication.class);
-
-
+
/**
* Creates a new empty personal communication instance.
*/
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
/**
* This class represents collections of {@link PrintedUnitBase printed published references} which
})
@XmlRootElement(name = "PrintSeries")
@Entity
-//@Audited
+@Audited
public class PrintSeries extends PublicationBase implements Cloneable {
private static final Logger logger = Logger.getLogger(PrintSeries.class);
import javax.persistence.Entity;
+import javax.persistence.FetchType;
import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
/**
* This (abstract) class represents printed {@link PublicationBase published references} which
})
@XmlRootElement(name = "PrintedUnitBase")
@Entity
-//@Audited
+@Audited
public abstract class PrintedUnitBase extends PublicationBase implements IVolumeReference{
static Logger logger = Logger.getLogger(PrintedUnitBase.class);
@XmlElement(name = "InSeries")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private PrintSeries inSeries;
@XmlElement(name = "SeriesPart")
* @return printed series
* @see PrintSeries
*/
- @ManyToOne
- @Cascade({CascadeType.SAVE_UPDATE})
public PrintSeries getInSeries(){
return this.inSeries;
}
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
/**
* This class represents conference proceedings. Proceedings are a
})
@XmlRootElement(name = "Proceedings")
@Entity
-//@Audited
+@Audited
public class Proceedings extends PrintedUnitBase implements Cloneable {
private static final Logger logger = Logger.getLogger(Proceedings.class);
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
/**
* This (abstract) class represents all different kind of published {@link StrictReferenceBase references}
})
@XmlRootElement(name = "PublicationBase")
@Entity
-//@Audited
+@Audited
public abstract class PublicationBase extends StrictReferenceBase {
static Logger logger = Logger.getLogger(PublicationBase.class);
import javax.persistence.Entity;
+import javax.persistence.FetchType;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.ManyToOne;
import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.Index;
import org.hibernate.annotations.Table;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
import eu.etaxonomy.cdm.model.common.IParsable;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "ReferenceBase", propOrder = {
"uri",
- "isNomenclaturallyRelevant",
+ "nomenclaturallyRelevant",
"authorTeam"
})
@XmlRootElement(name = "RelationshipBase")
@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
-//@Audited
+@Audited
@Table(appliesTo="ReferenceBase", indexes = { @Index(name = "ReferenceBaseTitleCacheIndex", columnNames = { "titleCache" }) })
public abstract class ReferenceBase extends IdentifiableMediaEntity implements IParsable{
//flag to subselect only references that could be useful for nomenclatural citations. If a reference is used as a
//nomenclatural reference in a name this flag should be automatically set
@XmlElement(name = "IsNomenclaturallyRelevant")
- private boolean isNomenclaturallyRelevant;
+ private boolean nomenclaturallyRelevant;
@XmlElement(name = "AuthorTeam")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private TeamOrPersonBase authorTeam;
//this flag will be set to true if the parseName method was unable to successfully parse the name
private int problemEnds = -1;
@XmlTransient
+ @Transient
protected IReferenceBaseCacheStrategy<ReferenceBase> cacheStrategy;
/**
* @return the author (team) of <i>this</i> reference
* @see eu.etaxonomy.cdm.model.agent.TeamOrPersonBase
*/
- @ManyToOne
- @Cascade({CascadeType.SAVE_UPDATE})
public TeamOrPersonBase getAuthorTeam(){
return this.authorTeam;
}
* reference is used as a nomenclatural reference for any taxon name.
*/
public boolean isNomenclaturallyRelevant(){
- return this.isNomenclaturallyRelevant;
+ return this.nomenclaturallyRelevant;
}
/**
* @see #isNomenclaturallyRelevant()
*/
- public void setNomenclaturallyRelevant(boolean isNomenclaturallyRelevant){
- this.isNomenclaturallyRelevant = isNomenclaturallyRelevant;
+ public void setNomenclaturallyRelevant(boolean nomenclaturallyRelevant){
+ this.nomenclaturallyRelevant = nomenclaturallyRelevant;
}
/**
*
* @see #generateTitle()
*/
- @Transient
// TODO implement
public String getCitation(){
return "";
* Returns a string containing the date (mostly only the year) of
* publication / creation of <i>this</i> reference.
*/
- @Transient
public abstract String getYear();
/* (non-Javadoc)
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.agent.Institution;
})
@XmlRootElement(name = "Report")
@Entity
-//@Audited
+@Audited
public class Report extends PublicationBase implements Cloneable {
static Logger logger = Logger.getLogger(Report.class);
@XmlElement(name = "Institution")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Institution institution;
/**
* @return the institution
* @see eu.etaxonomy.cdm.model.agent.Institution
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Institution getInstitution(){
return this.institution;
}
+
/**
* @see #getInstitution()
*/
public void setInstitution(Institution institution){
this.institution = institution;
}
-
-
/**
* Clones <i>this</i> report instance. This is a shortcut that enables to
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
/**
* This (abstract) class represents isolated sections (parts, chapters or
})
@XmlRootElement(name = "SectionBase")
@Entity
-//@Audited
+@Audited
public abstract class SectionBase extends StrictReferenceBase {
static Logger logger = Logger.getLogger(SectionBase.class);
*
* @return the printed unit containing <i>this</i> section
*/
- @Transient
public PrintedUnitBase getPrintedUnit(){
logger.warn("Not yet implemented");
return null;
import eu.etaxonomy.cdm.strategy.cache.reference.StrictReferenceBaseDefaultCacheStrategy;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
})
@XmlRootElement(name = "StrictReferenceBase")
@Entity
-//@Audited
+@Audited
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
public abstract class StrictReferenceBase extends ReferenceBase {
* @see #getTitle()
*/
@Override
- @Transient
// TODO implement
public String getCitation(){
return "";
* the {@link #getDatePublished() datePublished} attribute.
*/
@Override
- @Transient
public String getYear(){
if (this.getDatePublished() == null){
return null;
return null;
}
}
-
-
}
\ No newline at end of file
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+import sun.management.resources.agent;
import eu.etaxonomy.cdm.model.agent.Institution;
/**
})
@XmlRootElement(name = "Thesis")
@Entity
-//@Audited
+@Audited
public class Thesis extends PublicationBase implements Cloneable{
private static final Logger logger = Logger.getLogger(Thesis.class);
@XmlElement(name = "School")
+ @XmlIDREF
+ @XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Institution school;
/**
* @return the high school institution
* @see agent.Institution
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Institution getSchool(){
return this.school;
}
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
/**
* This class represents electronic publications available on the world wide web.
@XmlType(name = "WebPage")
@XmlRootElement(name = "WebPage")
@Entity
-//@Audited
+@Audited
public class WebPage extends PublicationBase implements Cloneable {
static Logger logger = Logger.getLogger(WebPage.class);
--- /dev/null
+\r
+@javax.xml.bind.annotation.XmlSchema(namespace = "http://etaxonomy.eu/cdm/model/reference/1.0", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)\r
+package eu.etaxonomy.cdm.model.reference;
\ No newline at end of file
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.IRelated;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
})
@XmlRootElement(name = "Synonym")
@Entity
-//@Audited
+@Audited
public class Synonym extends TaxonBase implements IRelated<SynonymRelationship>{
static Logger logger = Logger.getLogger(Synonym.class);
- //@XmlTransient
// Don't need the synonym relations here since they are stored at taxon side?
@XmlElementWrapper(name = "SynonymRelations")
@XmlElement(name = "SynonymRelationship")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(mappedBy="relatedFrom", fetch=FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
private Set<SynonymRelationship> synonymRelations = new HashSet<SynonymRelationship>();
// ************* CONSTRUCTORS *************/
* @see #addRelationship(SynonymRelationship)
* @see #removeSynonymRelation(SynonymRelationship)
*/
- @OneToMany(mappedBy="relatedFrom", fetch=FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE})
public Set<SynonymRelationship> getSynonymRelations() {
return synonymRelations;
}
- /**
- * @see #getSynonymRelations()
- * @see #addRelationship(SynonymRelationship)
- */
- protected void setSynonymRelations(Set<SynonymRelationship> synonymRelations) {
- this.synonymRelations = synonymRelations;
- }
+
/**
* Adds an existing {@link SynonymRelationship synonym relationship} to the set of
* {@link #getSynonymRelations() synonym relationships} assigned to <i>this</i> synonym. If
* @see #getRelationType(Taxon)
* @see SynonymRelationship#isProParte()
*/
- @Transient
public Set<Taxon> getAcceptedTaxa() {
Set<Taxon>taxa=new HashSet<Taxon>();
for (SynonymRelationship rel:getSynonymRelations()){
* @see #getSynonymRelations()
* @see #getAcceptedTaxa()
*/
- @Transient
public Set<SynonymRelationshipType> getRelationType(Taxon taxon){
Set<SynonymRelationshipType> result = new HashSet<SynonymRelationshipType>();
if (taxon == null ){
package eu.etaxonomy.cdm.model.taxon;
-import eu.etaxonomy.cdm.model.common.IRelated;
-import eu.etaxonomy.cdm.model.common.RelationshipBase;
-import eu.etaxonomy.cdm.model.common.RelationshipTermBase;
-import eu.etaxonomy.cdm.model.reference.ReferenceBase;
-
-import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
-
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+
+import eu.etaxonomy.cdm.model.common.IRelated;
+import eu.etaxonomy.cdm.model.common.RelationshipBase;
+import eu.etaxonomy.cdm.model.common.RelationshipTermBase;
+import eu.etaxonomy.cdm.model.reference.ReferenceBase;
+
/**
* The class representing the assignation of a {@link Synonym synonym} to an
* ("accepted/correct") {@link Taxon taxon}. This includes a {@link SynonymRelationshipType synonym relationship type}
"relatedFrom",
"relatedTo",
"type",
- "isProParte",
- "isPartial"
+ "proParte",
+ "partial"
})
@XmlRootElement(name = "SynonymRelationship")
@Entity
-//@Audited
+@Audited
public class SynonymRelationship extends RelationshipBase<Synonym, Taxon, SynonymRelationshipType> {
private static final Logger logger = Logger.getLogger(SynonymRelationship.class);
@XmlElement(name = "IsProParte")
- private boolean isProParte = false;
+ private boolean proParte = false;
@XmlElement(name = "IsPartial")
- private boolean isPartial = false;
+ private boolean partial = false;
@XmlElement(name = "RelatedFrom")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.EAGER)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Synonym relatedFrom;
@XmlElement(name = "RelatedTo")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.EAGER)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Taxon relatedTo;
@XmlElement(name = "Type")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.EAGER)
private SynonymRelationshipType type;
//for hibernate, don't use
* more synonym relationship with the same synonym should exist.
*/
public boolean isProParte() {
- return isProParte;
+ return proParte;
}
/**
* @see #isProParte()
*/
- public void setProParte(boolean isProParte) {
- this.isProParte = isProParte;
+ public void setProParte(boolean proParte) {
+ this.proParte = proParte;
}
/**
* exist.
*/
public boolean isPartial() {
- return isPartial;
+ return partial;
}
/**
* @see #isPartial()
*/
- public void setPartial(boolean isPartial) {
- this.isPartial = isPartial;
+ public void setPartial(boolean partial) {
+ this.partial = partial;
}
/**
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedTo()
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getType()
*/
- @Transient
public Taxon getAcceptedTaxon(){
return this.getRelatedTo();
}
* @see #getAcceptedTaxon()
* @see Taxon#getSynonymRelations()
*/
- protected void setAcceptedTaxon(Taxon acceptedTaxon){
+ public void setAcceptedTaxon(Taxon acceptedTaxon){
this.setRelatedTo(acceptedTaxon);
}
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom()
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getType()
*/
- @Transient
public Synonym getSynonym(){
return this.getRelatedFrom();
}
* @see #getSynonym()
* @see Synonym#getSynonymRelations()
*/
- protected void setSynonym(Synonym synonym){
+ public void setSynonym(Synonym synonym){
this.setRelatedFrom(synonym);
}
- @ManyToOne(fetch=FetchType.EAGER)
- @Cascade({CascadeType.SAVE_UPDATE})
protected Synonym getRelatedFrom() {
return relatedFrom;
}
- @ManyToOne(fetch=FetchType.EAGER)
- @Cascade({CascadeType.SAVE_UPDATE})
protected Taxon getRelatedTo() {
return relatedTo;
}
- @ManyToOne(fetch = FetchType.LAZY)
public SynonymRelationshipType getType() {
return type;
}
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.RelationshipTermBase;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "SynonymRelationshipType")
@Entity
-//@Audited
+@Audited
public class SynonymRelationshipType extends RelationshipTermBase<SynonymRelationshipType> {
static Logger logger = Logger.getLogger(SynonymRelationshipType.class);
import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
import org.hibernate.search.annotations.Indexed;
+import org.springframework.util.ReflectionUtils;
import java.lang.reflect.Method;
import java.util.*;
})
@XmlRootElement(name = "Taxon")
@Entity
-//@Audited
+@Audited
@Indexed
public class Taxon extends TaxonBase implements Iterable<Taxon>, IRelated<RelationshipBase>{
@XmlElementWrapper(name = "Descriptions")
@XmlElement(name = "Description")
+ @OneToMany(mappedBy="taxon", fetch= FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
private Set<TaxonDescription> descriptions = new HashSet<TaxonDescription>();
// all related synonyms
@XmlElementWrapper(name = "SynonymRelations")
@XmlElement(name = "SynonymRelationship")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
+ @OneToMany(mappedBy="relatedTo", fetch=FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
private Set<SynonymRelationship> synonymRelations = new HashSet<SynonymRelationship>();
// all taxa relations with rel.fromTaxon==this
@XmlElementWrapper(name = "RelationsFromThisTaxon")
@XmlElement(name = "FromThisTaxonRelationship")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
+ @OneToMany(mappedBy="relatedFrom", fetch=FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
private Set<TaxonRelationship> relationsFromThisTaxon = new HashSet<TaxonRelationship>();
// all taxa relations with rel.toTaxon==this
@XmlElement(name = "ToThisTaxonRelationship")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @OneToMany(mappedBy="relatedTo", fetch=FetchType.LAZY)
+ @Cascade({CascadeType.SAVE_UPDATE})
private Set<TaxonRelationship> relationsToThisTaxon = new HashSet<TaxonRelationship>();
// shortcut to the taxonomicIncluded (parent) taxon. Managed by the taxonRelations setter
@XmlElement(name = "TaxonomicParentCache")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+// @Cascade(CascadeType.SAVE_UPDATE)
private Taxon taxonomicParentCache;
//cached number of taxonomic children
@XmlElement(name = "TaxonomicChildrenCount")
private int taxonomicChildrenCount;
-
- private static Method methodDescriptionSetTaxon;
-
// ************* CONSTRUCTORS *************/
Taxon result = new Taxon(taxonNameBase, sec);
return result;
}
-
/**
* Returns the set of {@link eu.etaxonomy.cdm.model.description.TaxonDescription taxon descriptions}
* @see #addDescription(TaxonDescription)
* @see eu.etaxonomy.cdm.model.description.TaxonDescription#getTaxon()
*/
- @OneToMany(mappedBy="taxon", fetch= FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<TaxonDescription> getDescriptions() {
return descriptions;
}
- /**
- * @see #getDescriptions()
- */
- protected void setDescriptions(Set<TaxonDescription> descriptions) {
- this.descriptions = descriptions;
- }
+
/**
* Adds a new {@link eu.etaxonomy.cdm.model.description.TaxonDescription taxon description} to the set
* of taxon descriptions assigned to <i>this</i> (accepted/correct) taxon.
* @see eu.etaxonomy.cdm.model.description.TaxonDescription#getTaxon()
*/
public void addDescription(TaxonDescription description) {
- initMethods();
if (description.getTaxon() != null){
description.getTaxon().removeDescription(description);
}
- //description.setTaxon(this) for not visible method
- this.invokeSetMethod(methodDescriptionSetTaxon, description);
+ Method method = ReflectionUtils.findMethod(TaxonDescription.class, "setTaxon", new Class[] {Taxon.class});
+ ReflectionUtils.makeAccessible(method);
+ ReflectionUtils.invokeMethod(method, description, new Object[] {this});
descriptions.add(description);
}
* @see eu.etaxonomy.cdm.model.description.TaxonDescription#getTaxon()
*/
public void removeDescription(TaxonDescription description) {
- initMethods();
//description.setTaxon(null) for not visible method
- this.invokeSetMethodWithNull(methodDescriptionSetTaxon, description);
+ Method method = ReflectionUtils.findMethod(TaxonDescription.class, "setTaxon", new Class[] {Taxon.class});
+ ReflectionUtils.makeAccessible(method);
+ ReflectionUtils.invokeMethod(method, description, new Object[] {null});
descriptions.remove(description);
}
- private void initMethods(){
- if (methodDescriptionSetTaxon == null){
- try {
- methodDescriptionSetTaxon = TaxonDescription.class.getDeclaredMethod("setTaxon", Taxon.class);
- methodDescriptionSetTaxon.setAccessible(true);
- } catch (Exception e) {
- e.printStackTrace();
- //TODO handle exception
- }
- }
- }
-
-
/**
* Returns the set of all {@link SynonymRelationship synonym relationships}
* in which <i>this</i> ("accepted/correct") taxon is involved. <i>This</i> taxon can only
* @see #removeSynonymRelation(SynonymRelationship)
* @see #getSynonyms()
*/
- @OneToMany(mappedBy="relatedTo", fetch=FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE})
public Set<SynonymRelationship> getSynonymRelations() {
return synonymRelations;
}
- /**
- * @see #getSynonymRelations()
- * @see #addSynonymRelation(SynonymRelationship)
- */
- protected void setSynonymRelations(Set<SynonymRelationship> synonymRelations) {
- this.synonymRelations = synonymRelations;
- }
+
/**
* Adds an existing {@link SynonymRelationship synonym relationship} to the set of
* {@link #getSynonymRelations() synonym relationships} assigned to <i>this</i> taxon. If
* @see #getRelationsToThisTaxon()
* @see #getTaxonRelations()
*/
- @OneToMany(mappedBy="relatedFrom", fetch=FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
public Set<TaxonRelationship> getRelationsFromThisTaxon() {
return relationsFromThisTaxon;
}
- /**
- * @see #getRelationsFromThisTaxon()
- */
- protected void setRelationsFromThisTaxon(
- Set<TaxonRelationship> relationsFromThisTaxon) {
- this.relationsFromThisTaxon = relationsFromThisTaxon;
- }
/**
* @see #getRelationsFromThisTaxon()
* @see #getTaxonRelations()
*/
- @OneToMany(mappedBy="relatedTo", fetch=FetchType.LAZY)
- @Cascade({CascadeType.SAVE_UPDATE, CascadeType.DELETE_ORPHAN})
public Set<TaxonRelationship> getRelationsToThisTaxon() {
return relationsToThisTaxon;
}
this.relationsToThisTaxon = relationsToThisTaxon;
}
- @ManyToOne
- // used by hibernate only...
- private Taxon getTaxonomicParentCache() {
- return taxonomicParentCache;
- }
- private void setTaxonomicParentCache(Taxon taxonomicParent) {
- this.taxonomicParentCache = taxonomicParent;
- }
-
/**
* Returns the set of all {@link TaxonRelationship taxon relationships}
* between two taxa in which <i>this</i> taxon is involved either as a source or
* @see #getRelationsFromThisTaxon()
* @see #getRelationsToThisTaxon()
*/
- @Transient
public Set<TaxonRelationship> getTaxonRelations() {
Set<TaxonRelationship> rels = new HashSet<TaxonRelationship>();
rels.addAll(getRelationsToThisTaxon());
// check if this removes the taxonomical parent. If so, also remove shortcut to the higher taxon
if (rel.getType().equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN()) ){
if (fromTaxon != null && fromTaxon.equals(this)){
- this.setTaxonomicParentCache(null);
+ this.taxonomicParentCache = null;
}else if (toTaxon != null && toTaxon.equals(this)){
this.setTaxonomicChildrenCount(computeTaxonomicChildrenCount());
}
}
// check if this sets the taxonomical parent. If so, remember a shortcut to this taxon
if (rel.getType().equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN()) && toTaxon!=null ){
- this.setTaxonomicParentCache(toTaxon);
+ this.taxonomicParentCache = toTaxon;
}
}else if (this.equals(toTaxon)){
relationsToThisTaxon.add(rel);
misappliedNameTaxon.addTaxonRelation(this, TaxonRelationshipType.MISAPPLIED_NAME_FOR(), citation, microcitation);
}
-
-// @Transient
// public void removeMisappliedName(Taxon misappliedNameTaxon){
// Set<TaxonRelationship> taxRels = this.getTaxonRelations();
// for (TaxonRelationship taxRel : taxRels ){
* @param taxon the taxon which plays the source role in the taxon relationship
* @param taxonRelType the taxon relationship type
*/
- @Transient
- public void removeTaxon(Taxon toTaxon, TaxonRelationshipType taxonRelType){
+ public void removeTaxon(Taxon taxon, TaxonRelationshipType taxonRelType){
Set<TaxonRelationship> taxRels = this.getTaxonRelations();
for (TaxonRelationship taxRel : taxRels ){
if (taxRel.getType().equals(taxonRelType)
- && taxRel.getToTaxon().equals(toTaxon)){
+ && taxRel.getFromTaxon().equals(taxon)){
this.removeTaxonRelation(taxRel);
}
}
* @see #getTaxonomicParent()
* @see #getTaxonomicChildrenCount()
*/
- @Transient
public void addTaxonomicChild(Taxon child, ReferenceBase citation, String microcitation){
if (child == null){
throw new NullPointerException("Child Taxon is 'null'");
child.setTaxonomicParent(this, citation, microcitation);
}
}
+
/**
* Removes one {@link TaxonRelationship taxon relationship} with {@link TaxonRelationshipType taxon relationship type}
* "taxonomically included in" and with the given child taxon playing the
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedTo()
*
*/
- @Transient
public void removeTaxonomicChild(Taxon child){
Set<TaxonRelationship> taxRels = this.getTaxonRelations();
for (TaxonRelationship taxRel : taxRels ){
* @see #getTaxonomicChildrenCount()
* @see #getRelationsFromThisTaxon()
*/
- @Transient
public Taxon getTaxonomicParent() {
- return getTaxonomicParentCache();
+ return this.taxonomicParentCache;
}
/**
* Replaces both the taxonomic parent cache with the given new parent taxon
* @see #getTaxonomicChildrenCount()
* @see #getRelationsToThisTaxon()
*/
- @Transient
public Set<Taxon> getTaxonomicChildren() {
Set<Taxon> taxa = new HashSet<Taxon>();
Set<TaxonRelationship> rels = this.getRelationsToThisTaxon();
return taxonomicChildrenCount;
}
-
/**
* @see #getTaxonomicChildrenCount()
*/
* @see #getTaxonomicChildrenCount()
* @see #getTaxonomicChildren()
*/
- @Transient
public boolean hasTaxonomicChildren(){
return this.taxonomicChildrenCount > 0;
}
- @Transient
private int computeTaxonomicChildrenCount(){
int count = 0;
for (TaxonRelationship rel: this.getRelationsToThisTaxon()){
* (misapplied name) for at least one other taxon.
*/
// TODO cache as for #hasTaxonomicChildren
- @Transient
public boolean isMisappliedName(){
return computeMisapliedNameRelations() > 0;
}
* misaplied name for another taxon.
* @return
*/
- @Transient
private int computeMisapliedNameRelations(){
int count = 0;
for (TaxonRelationship rel: this.getRelationsFromThisTaxon()){
* @see #removeSynonym(Synonym)
* @see SynonymRelationship
*/
- @Transient
public boolean hasSynonyms(){
return this.getSynonymRelations().size() > 0;
}
* @see #removeTaxonRelation(TaxonRelationship)
* @see TaxonRelationship
*/
- @Transient
public boolean hasTaxonRelationships(){
return this.getTaxonRelations().size() > 0;
}
* @see #getRelationsToThisTaxon()
* @see #addMisappliedName(Taxon, ReferenceBase, String)
*/
- @Transient
public Set<Taxon> getMisappliedNames(){
Set<Taxon> taxa = new HashSet<Taxon>();
Set<TaxonRelationship> rels = this.getRelationsToThisTaxon();
* @see #removeSynonymRelation(SynonymRelationship)
* @see #removeSynonym(Synonym)
*/
- @Transient
public Set<Synonym> getSynonyms(){
Set<Synonym> syns = new HashSet<Synonym>();
for (SynonymRelationship rel: this.getSynonymRelations()){
* @see #removeSynonymRelation(SynonymRelationship)
* @see #removeSynonym(Synonym)
*/
- @Transient
public Set<Synonym> getSynonymsSortedByType(){
// FIXME: need to sort synonyms according to type!!!
logger.warn("getSynonymsSortedByType() not yet implemented");
* @see #removeSynonymRelation(SynonymRelationship)
* @see #removeSynonym(Synonym)
*/
- @Transient
public Set<TaxonNameBase> getSynonymNames(){
Set<TaxonNameBase> names = new HashSet<TaxonNameBase>();
for (SynonymRelationship rel: this.getSynonymRelations()){
Synonym synonym = Synonym.NewInstance(synonymName, this.getSec());
return addSynonym(synonym, synonymType, citation, citationMicroReference);
}
-
/**
* Creates a new {@link Synonym synonym} (with the given {@link eu.etaxonomy.cdm.model.name.TaxonNameBase taxon name}),
public SynonymRelationship addHeterotypicSynonymName(TaxonNameBase synonymName){
return addHeterotypicSynonymName(synonymName, null, null, null);
}
-
/**
* Creates a new {@link Synonym synonym} (with the given {@link eu.etaxonomy.cdm.model.name.TaxonNameBase taxon name}),
}
}
-
-
/**
* Returns an {@link java.lang.Iterable#iterator() iterator} over the set of taxa which
* are {@link #getTaxonomicChildren() taxonomic children} of <i>this</i> taxon.
* @see eu.etaxonomy.cdm.model.name.HomotypicalGroup
* @see eu.etaxonomy.cdm.model.name.HomotypicalGroup#getSynonymsInGroup(ReferenceBase)
*/
- @Transient
public List<Synonym> getHomotypicSynonymsByHomotypicGroup(){
if (this.getHomotypicGroup() == null){
return null;
* @see #getHomotypicSynonymyGroups()
* @see SynonymRelationshipType
*/
- @Transient
public List<Synonym> getHomotypicSynonymsByHomotypicRelationship(){
Set<SynonymRelationship> synonymRelations = this.getSynonymRelations();
List<Synonym> result = new ArrayList<Synonym>();
* @see #getSynonyms()
* @see eu.etaxonomy.cdm.model.name.HomotypicalGroup
*/
- @Transient
public List<HomotypicalGroup> getHomotypicSynonymyGroups(){
List<HomotypicalGroup> result = new ArrayList<HomotypicalGroup>();
result.add(this.getHomotypicGroup());
* @see SynonymRelationshipType#HETEROTYPIC_SYNONYM_OF()
* @see eu.etaxonomy.cdm.model.name.HomotypicalGroup
*/
- @Transient
public List<HomotypicalGroup> getHeterotypicSynonymyGroups(){
List<HomotypicalGroup> list = getHomotypicSynonymyGroups();
list.remove(this.getHomotypicGroup());
package eu.etaxonomy.cdm.model.taxon;
import java.lang.reflect.Method;
+
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.Index;
import org.hibernate.annotations.Table;
+import org.hibernate.envers.Audited;
import org.hibernate.search.annotations.Indexed;
import org.hibernate.search.annotations.IndexedEmbedded;
"sec"
})
@Entity
-//@Audited
+@Audited
@Indexed
@Table(appliesTo="TaxonBase", indexes = { @Index(name = "taxonBaseTitleCacheIndex", columnNames = { "titleCache" }) })
public abstract class TaxonBase extends IdentifiableEntity {
private static Method methodTaxonNameAddTaxonBase;
- private static void initMethods() {
- if (methodTaxonNameAddTaxonBase == null){
- try {
- methodTaxonNameAddTaxonBase = TaxonNameBase.class.getDeclaredMethod("addTaxonBase", TaxonBase.class);
- methodTaxonNameAddTaxonBase.setAccessible(true);
- } catch (Exception e) {
- e.printStackTrace();
- //TODO handle exception
+ static {
+ try {
+ methodTaxonNameAddTaxonBase = TaxonNameBase.class.getDeclaredMethod("addTaxonBase", TaxonBase.class);
+ methodTaxonNameAddTaxonBase.setAccessible(true);
+ } catch (Exception e) {
+ logger.error(e);
+ for(StackTraceElement ste : e.getStackTrace()) {
+ logger.error(ste);
}
}
}
//The assignment to the Taxon or to the Synonym class is not definitive
@XmlAttribute(name = "isDoubtful")
- private boolean isDoubtful;
+ private boolean doubtful;
@XmlElement(name = "Name", required = true)
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @JoinColumn(name="taxonName_fk")
+ @IndexedEmbedded
+ @Cascade(CascadeType.SAVE_UPDATE)
private TaxonNameBase name;
// The concept reference
@XmlElement(name = "Sec")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private ReferenceBase sec;
protected TaxonBase(TaxonNameBase taxonNameBase, ReferenceBase sec){
super();
if (taxonNameBase != null){
- initMethods();
this.invokeSetMethod(methodTaxonNameAddTaxonBase, taxonNameBase);
}
this.setSec(sec);
/**
* Returns the {@link TaxonNameBase taxon name} used in <i>this</i> (abstract) taxon.
*/
- @ManyToOne
- @JoinColumn(name="taxonName_fk")
- @Cascade(CascadeType.SAVE_UPDATE)
- @IndexedEmbedded
public TaxonNameBase getName(){
return this.name;
}
- @Deprecated //for hibernate use only, use taxon.addDescription() instead
- private void setName(TaxonNameBase newName){
- this.name = newName;
+
+ /*
+ * @see #getName
+ */
+ protected void setName(TaxonNameBase name) {
+ this.name = name;
}
/**
* Returns the {@link eu.etaxonomy.cdm.model.name.HomotypicalGroup homotypical group} of the
* {@link eu.etaxonomy.cdm.model.name.TaxonNameBase taxon name} used in <i>this</i> (abstract) taxon.
*/
- @Transient
public HomotypicalGroup getHomotypicGroup(){
if (this.getName() == null){
return null;
* still change in the course of taxonomical working process.
*/
public boolean isDoubtful(){
- return this.isDoubtful;
+ return this.doubtful;
}
/**
* @see #isDoubtful()
*/
- public void setDoubtful(boolean isDoubtful){
- this.isDoubtful = isDoubtful;
+ public void setDoubtful(boolean doubtful){
+ this.doubtful = doubtful;
}
/**
* This is the reference or the treatment using the {@link TaxonNameBase taxon name}
* in <i>this</i> (abstract) taxon.
*/
- @ManyToOne(fetch = FetchType.LAZY)
- @Cascade(CascadeType.SAVE_UPDATE)
public ReferenceBase getSec() {
return sec;
}
* might be saved (true) or not (false). An (abstract) taxon is meaningful
* as long as both its {@link #getName() taxon name} and its {@link #getSec() reference}
* exist (are not "null").
+ * FIXME This should be part of a more generic validation architecture
*/
- @Transient
public boolean isSaveable(){
if ( (this.getName() == null) || (this.getSec() == null) ){
return false;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.name.ZoologicalName;\r
import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;\r
+import eu.etaxonomy.cdm.model.reference.ReferenceBase;\r
\r
/**\r
* This class makes available a method to compare two {@link TaxonBase taxa} by\r
package eu.etaxonomy.cdm.model.taxon;
-import eu.etaxonomy.cdm.model.common.RelationshipBase;
-import eu.etaxonomy.cdm.model.reference.ReferenceBase;
-
-import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
-
-import javax.persistence.*;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.ManyToOne;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;
+import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+
+import eu.etaxonomy.cdm.model.common.RelationshipBase;
+import eu.etaxonomy.cdm.model.reference.ReferenceBase;
+
/**
* The class representing a relationship between two {@link Taxon ("accepted/correct") taxa}.
* This includes a {@link TaxonRelationshipType taxon relationship type} (for instance "congruent to" or
})
@XmlRootElement(name = "TaxonRelationship")
@Entity
-//@Audited
+@Audited
public class TaxonRelationship extends RelationshipBase<Taxon, Taxon, TaxonRelationshipType> {
static private final Logger logger = Logger.getLogger(TaxonRelationship.class);
@XmlElement(name = "RelatedFrom")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.EAGER)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Taxon relatedFrom;
@XmlElement(name = "RelatedTo")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.EAGER)
+ @Cascade(CascadeType.SAVE_UPDATE)
private Taxon relatedTo;
@XmlElement(name = "Type")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToOne(fetch=FetchType.EAGER)
private TaxonRelationshipType type;
//for hibernate, don't use
super(from, to, type, citation, citationMicroReference);
}
-
/**
* Returns the {@link Taxon taxon} involved as a source in <i>this</i>
* taxon relationship.
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom()
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getType()
*/
- @Transient
public Taxon getFromTaxon(){
return getRelatedFrom();
}
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedTo()
* @see eu.etaxonomy.cdm.model.common.RelationshipBase#getType()
*/
- @Transient
public Taxon getToTaxon(){
return getRelatedTo();
}
setRelatedTo(toTaxon);
}
- @ManyToOne(fetch=FetchType.EAGER)
- @Cascade({CascadeType.SAVE_UPDATE})
protected Taxon getRelatedFrom() {
return relatedFrom;
}
- @ManyToOne(fetch=FetchType.EAGER)
- @Cascade({CascadeType.SAVE_UPDATE})
protected Taxon getRelatedTo() {
return relatedTo;
}
- @ManyToOne(fetch = FetchType.LAZY)
public TaxonRelationshipType getType() {
return type;
}
protected void setType(TaxonRelationshipType type) {
this.type = type;
}
-
}
\ No newline at end of file
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
import javax.persistence.*;
import javax.xml.bind.annotation.XmlAccessType;
@XmlType(name = "TaxonRelationshipType")
@XmlRootElement(name = "TaxonRelationshipType")
@Entity
-//@Audited
+@Audited
public class TaxonRelationshipType extends RelationshipTermBase<TaxonRelationshipType> {
static Logger logger = Logger.getLogger(TaxonRelationshipType.class);
--- /dev/null
+\r
+@javax.xml.bind.annotation.XmlSchema(namespace = "http://etaxonomy.eu/cdm/model/taxon/1.0", elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)\r
+package eu.etaxonomy.cdm.model.taxon;
\ No newline at end of file
--- /dev/null
+package eu.etaxonomy.cdm.model.view;
+
+import java.util.UUID;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+
+import org.hibernate.annotations.Type;
+import org.hibernate.envers.RevisionEntity;
+import org.hibernate.envers.RevisionNumber;
+import org.hibernate.envers.RevisionTimestamp;
+
+@Entity
+@RevisionEntity
+public class AuditEvent {
+public static final AuditEvent CURRENT_VIEW;
+
+ static {
+ CURRENT_VIEW = new AuditEvent();
+ CURRENT_VIEW.setUuid(UUID.fromString("966728f0-ae51-11dd-ad8b-0800200c9a66"));
+ };
+
+ @Type(type="uuidUserType")
+ private UUID uuid;
+
+ public AuditEvent() {
+ this.uuid = UUID.randomUUID();
+ }
+
+ @Id
+ @GeneratedValue
+ @RevisionNumber
+ private Integer revisionNumber;
+
+ @RevisionTimestamp
+ private Long timestamp;
+
+ public Integer getRevisionNumber() {
+ return revisionNumber;
+ }
+
+ public void setUuid(UUID uuid) {
+ this.uuid = uuid;
+ }
+
+ public boolean equals(Object obj) {
+ if(this == obj)
+ return true;
+
+ if((obj == null) || (obj.getClass() != this.getClass()))
+ return false;
+
+ AuditEvent auditEvent = (AuditEvent) obj;
+ return uuid == auditEvent.uuid || (uuid != null && uuid.equals(auditEvent.uuid));
+ }
+
+ public int hashCode() {
+ int hash = 7;
+ hash = 31 * hash + (null == uuid ? 0 : uuid.hashCode());
+ return hash;
+ }
+
+ public void setRevisionNumber(Integer revisionNumber) {
+ this.revisionNumber = revisionNumber;
+ }
+}
--- /dev/null
+package eu.etaxonomy.cdm.model.view;\r
+\r
+import org.hibernate.envers.RevisionType;\r
+\r
+import eu.etaxonomy.cdm.model.common.CdmBase;\r
+\r
+public interface AuditEventRecord<T extends CdmBase> {\r
+ public T getAuditableObject();\r
+ public AuditEvent getAuditEvent();\r
+ public RevisionType getRevisionType();\r
+}\r
--- /dev/null
+package eu.etaxonomy.cdm.model.view;\r
+\r
+import org.hibernate.envers.RevisionType;\r
+\r
+import eu.etaxonomy.cdm.model.common.CdmBase;\r
+\r
+public class AuditEventRecordImpl<T extends CdmBase> implements AuditEventRecord<T> {\r
+ \r
+ private AuditEvent auditEvent;\r
+ private T auditableObject;\r
+ private RevisionType revisionType;\r
+\r
+ public AuditEventRecordImpl(Object[] obj) {\r
+ assert obj.length == 3 : "The array must have three elements";\r
+ auditableObject = (T)obj[0];\r
+ auditEvent = (AuditEvent)obj[1];\r
+ revisionType = (RevisionType)obj[2];\r
+ }\r
+ \r
+ public AuditEvent getAuditEvent() {\r
+ return auditEvent;\r
+ }\r
+\r
+ public T getAuditableObject() {\r
+ return auditableObject;\r
+ }\r
+\r
+ public RevisionType getRevisionType() {\r
+ return revisionType;\r
+ }\r
+\r
+}\r
import org.apache.log4j.Logger;
+import org.hibernate.annotations.Cascade;
+import org.hibernate.annotations.CascadeType;
import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.common.ICdmBase;
private String name;
private String description;
+ @ManyToOne(fetch = FetchType.LAZY)
+ @Cascade(CascadeType.SAVE_UPDATE)
private ReferenceBase reference;
+ @OneToMany(fetch = FetchType.LAZY)
private Set<View> superViews = new HashSet<View>();
+ @Transient
private Set<CdmBase> members = new HashSet<CdmBase>();
+ @Transient
private Set<CdmBase> nonMembers = new HashSet<CdmBase>();
public String getName(){
public String getDescription(){
return this.description;
}
+
public void setDescription(String description){
this.description = description;
}
- @Transient
public ReferenceBase getCitation() {
return getReference();
}
this.reference = reference;
}
-
- @OneToMany
public Set<View> getSuperViews() {
return superViews;
}
- protected void setSuperViews(Set<View> superViews) {
- this.superViews = superViews;
- }
+
public void addSuperView(View superView) {
this.superViews.add(superView);
}
this.superViews.remove(superView);
}
-
- @Transient
public Set<CdmBase> getMembers() {
return members;
}
- protected void setMembers(Set<CdmBase> members) {
- this.members = members;
- }
+
public void addMember(CdmBase member) {
this.members.add(member);
}
this.members.remove(member);
}
-
- @Transient
public Set<CdmBase> getNonMembers() {
return nonMembers;
}
- protected void setNonMembers(Set<CdmBase> nonMembers) {
- this.nonMembers = nonMembers;
- }
+
public void addNonMember(CdmBase member) {
this.nonMembers.add(member);
}
public void removeNonMember(ICdmBase member) {
this.nonMembers.remove(member);
}
-
}
\ No newline at end of file
--- /dev/null
+package eu.etaxonomy.cdm.model.view.context;
+
+import java.io.Serializable;
+
+import eu.etaxonomy.cdm.model.view.AuditEvent;
+
+public interface AuditEventContext extends Serializable {
+ public AuditEvent getAuditEvent();
+
+ public void setAuditEvent(AuditEvent auditEvent);
+
+}
--- /dev/null
+package eu.etaxonomy.cdm.model.view.context;
+
+import java.lang.reflect.Constructor;
+
+import org.springframework.util.ReflectionUtils;
+
+/**
+ * Class based heavily on SecurityContextHolder, part
+ * of spring-security, but instead binding a AuditEvent object to the
+ * context.
+ *
+ * @author ben
+ * @author Ben Alex
+ *
+ */
+public class AuditEventContextHolder {
+ public static final String MODE_THREADLOCAL = "MODE_THREADLOCAL";
+ public static final String MODE_INHERITABLETHREADLOCAL = "MODE_INHERITABLETHREADLOCAL";
+ public static final String MODE_GLOBAL = "MODE_GLOBAL";
+ public static final String SYSTEM_PROPERTY = "cate.view.strategy";
+ private static String strategyName = System.getProperty(SYSTEM_PROPERTY);
+ private static AuditEventContextHolderStrategy strategy;
+ private static int initializeCount = 0;
+
+ static {
+ initialize();
+ }
+
+ public static void clearContext() {
+ strategy.clearContext();
+ }
+
+ public static AuditEventContext getContext() {
+ return strategy.getContext();
+ }
+
+ public static int getInitializeCount() {
+ return initializeCount;
+ }
+
+ private static void initialize() {
+ if ((strategyName == null) || "".equals(strategyName)) {
+ // Set default
+ strategyName = MODE_THREADLOCAL;
+ }
+
+ if (strategyName.equals(MODE_THREADLOCAL)) {
+ strategy = new ThreadLocalAuditEventContextHolderStrategy();
+ } else if (strategyName.equals(MODE_INHERITABLETHREADLOCAL)) {
+ strategy = new InheritableThreadLocalAuditEventContextHolderStrategy();
+ } else if (strategyName.equals(MODE_GLOBAL)) {
+ strategy = new GlobalAuditEventContextHolderStrategy();
+ } else {
+ // Try to load a custom strategy
+ try {
+ Class clazz = Class.forName(strategyName);
+ Constructor customStrategy = clazz.getConstructor(new Class[] {});
+ strategy = (AuditEventContextHolderStrategy) customStrategy.newInstance(new Object[] {});
+ } catch (Exception ex) {
+ ReflectionUtils.handleReflectionException(ex);
+ }
+ }
+
+ initializeCount++;
+ }
+
+ public static void setContext(AuditEventContext context) {
+ strategy.setContext(context);
+ }
+
+ public static void setStrategyName(String strategyName) {
+ AuditEventContextHolder.strategyName = strategyName;
+ initialize();
+ }
+
+ public String toString() {
+ return "AuditEventContextHolder[strategy='" + strategyName + "'; initializeCount=" + initializeCount + "]";
+ }
+}
--- /dev/null
+package eu.etaxonomy.cdm.model.view.context;
+
+/**
+ * Class based heavily on SecurityContextHolderStrategy, part
+ * of spring-security, but instead binding a View object to the
+ * context.
+ *
+ * @author ben
+ * @author Ben Alex
+ *
+ */
+public interface AuditEventContextHolderStrategy {
+ void clearContext();
+ AuditEventContext getContext();
+ void setContext(AuditEventContext context);
+
+}
--- /dev/null
+package eu.etaxonomy.cdm.model.view.context;
+
+import eu.etaxonomy.cdm.model.view.AuditEvent;
+import eu.etaxonomy.cdm.model.view.View;
+
+/**
+ * Class based heavily on SecurityContextImpl, part
+ * of spring-security, but instead binding a View object to the
+ * context.
+ *
+ * @author ben
+ * @author Ben Alex
+ *
+ */
+public class AuditEventContextImpl implements AuditEventContext {
+
+ private AuditEvent auditEvent;
+
+ public AuditEvent getAuditEvent() {
+ return auditEvent;
+ }
+
+ public void setAuditEvent(AuditEvent auditEvent) {
+ this.auditEvent = auditEvent;
+ }
+
+ public boolean equals(Object obj) {
+ if (obj instanceof AuditEventContextImpl) {
+ AuditEventContextImpl test = (AuditEventContextImpl) obj;
+
+ if ((this.getAuditEvent() == null) && (test.getAuditEvent() == null)) {
+ return true;
+ }
+
+ if ((this.getAuditEvent() != null) && (test.getAuditEvent() != null)
+ && this.getAuditEvent().equals(test.getAuditEvent())) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public int hashCode() {
+ if (this.auditEvent == null) {
+ return -1;
+ } else {
+ return this.auditEvent.hashCode();
+ }
+ }
+
+ public String toString() {
+ StringBuffer sb = new StringBuffer();
+ sb.append(super.toString());
+
+ if (this.auditEvent == null) {
+ sb.append(": Null auditEvent");
+ } else {
+ sb.append(": AuditEvent: ").append(this.auditEvent);
+ }
+
+ return sb.toString();
+ }
+}
--- /dev/null
+package eu.etaxonomy.cdm.model.view.context;
+
+import org.springframework.util.Assert;
+/**
+ * Class based heavily on GlobalSecurityContextHolderStrategy, part
+ * of spring-security, but instead binding a View object to the
+ * context.
+ *
+ * @author ben
+ *
+ */
+public class GlobalAuditEventContextHolderStrategy implements
+ AuditEventContextHolderStrategy {
+
+ private static AuditEventContext contextHolder;
+
+ public void clearContext() {
+ contextHolder = null;
+ }
+
+ public AuditEventContext getContext() {
+ if (contextHolder == null) {
+ contextHolder = new AuditEventContextImpl();
+ }
+
+ return contextHolder;
+ }
+
+ public void setContext(AuditEventContext context) {
+ Assert.notNull(context, "Only non-null AuditEventContext instances are permitted");
+ contextHolder = context;
+ }
+
+}
--- /dev/null
+package eu.etaxonomy.cdm.model.view.context;
+
+import org.springframework.util.Assert;
+
+/**
+ * Class based heavily on InheritableThreadLocalSecurityContextHolderStrategy, part
+ * of spring-security, but instead binding a View object to the
+ * context.
+ *
+ * @author ben
+ * @author Ben Alex
+ *
+ */
+public class InheritableThreadLocalAuditEventContextHolderStrategy implements
+ AuditEventContextHolderStrategy {
+
+ private static ThreadLocal contextHolder = new InheritableThreadLocal();
+
+ public void clearContext() {
+ contextHolder.set(null);
+ }
+
+ public AuditEventContext getContext() {
+ if (contextHolder.get() == null) {
+ contextHolder.set(new AuditEventContextImpl());
+ }
+
+ return (AuditEventContext) contextHolder.get();
+ }
+
+ public void setContext(AuditEventContext context) {
+ Assert.notNull(context, "Only non-null AuditEventContext instances are permitted");
+ contextHolder.set(context);
+ }
+
+}
--- /dev/null
+package eu.etaxonomy.cdm.model.view.context;
+
+import org.springframework.util.Assert;
+
+/**
+ * Class based heavily on ThreadLocalSecurityContextHolderStrategy, part
+ * of spring-security, but instead binding a View object to the
+ * context.
+ *
+ * @author ben
+ * @author Ben Alex
+ *
+ */
+public class ThreadLocalAuditEventContextHolderStrategy implements
+ AuditEventContextHolderStrategy {
+
+ private static ThreadLocal contextHolder = new ThreadLocal();
+
+ public void clearContext() {
+ contextHolder.set(null);
+ }
+
+ public AuditEventContext getContext() {
+ if (contextHolder.get() == null) {
+ contextHolder.set(new AuditEventContextImpl());
+ }
+
+ return (AuditEventContext) contextHolder.get();
+ }
+
+ public void setContext(AuditEventContext context) {
+ Assert.notNull(context, "Only non-null AuditEventContext instances are permitted");
+ contextHolder.set(context);
+ }
+
+}
import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;\r
import eu.etaxonomy.cdm.model.reference.IVolumeReference;\r
import eu.etaxonomy.cdm.model.reference.Journal;\r
+import eu.etaxonomy.cdm.model.reference.ReferenceBase;\r
import eu.etaxonomy.cdm.model.reference.StrictReferenceBase;\r
import eu.etaxonomy.cdm.strategy.exceptions.StringNotParsableException;\r
import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;\r
\r
public NonViralName getNonViralNameInstance(String fullString, NomenclaturalCode code, Rank rank){\r
NonViralName result = null;\r
- if (code == null){\r
+ if(code ==null) {\r
boolean isBotanicalName = anyBotanicFullNamePattern.matcher(fullString).find();\r
boolean isZoologicalName = anyZooFullNamePattern.matcher(fullString).find();;\r
boolean isBacteriologicalName = false;\r
}else {\r
result = NonViralName.NewInstance(rank);\r
}\r
- }else if (code.equals(NomenclaturalCode.ICBN)){\r
- result = BotanicalName.NewInstance(rank);\r
- }else if (code.equals(NomenclaturalCode.ICZN)){\r
- result = ZoologicalName.NewInstance(rank);\r
- }else if (code.equals(NomenclaturalCode.ICNCP)){\r
- logger.warn("ICNCP parsing not yet implemented");\r
- result = CultivarPlantName.NewInstance(rank);\r
- }else if (code.equals(NomenclaturalCode.ICNB)){\r
- logger.warn("ICNB not yet implemented");\r
- result = BacterialName.NewInstance(rank);\r
- }else if (code.equals(NomenclaturalCode.ICVCN)){\r
- logger.error("Viral name is not a NonViralName !!");\r
- }else{\r
- logger.error("Unknown Nomenclatural Code !!");\r
+ } else {\r
+ switch (code) {\r
+ case ICBN:\r
+ result = BotanicalName.NewInstance(rank);\r
+ break;\r
+ case ICZN:\r
+ result = ZoologicalName.NewInstance(rank);\r
+ break;\r
+ case ICNCP:\r
+ logger.warn("ICNCP parsing not yet implemented");\r
+ result = CultivarPlantName.NewInstance(rank);\r
+ break;\r
+ case ICNB:\r
+ logger.warn("ICNB not yet implemented");\r
+ result = BacterialName.NewInstance(rank);\r
+ break;\r
+ case ICVCN:\r
+ logger.error("Viral name is not a NonViralName !!");\r
+ break;\r
+ default:\r
+ // FIXME Unreachable code\r
+ logger.error("Unknown Nomenclatural Code !!");\r
+ }\r
}\r
return result;\r
}\r
### set log levels - for more verbose logging change 'info' to 'debug' ###
-log4j.rootLogger=info, stdout
+log4j.rootLogger=warn, stdout
### *** CDM *** ###
-#log4j.logger.eu.etaxonomy.cdm = warn
-#log4j.logger.eu.etaxonomy.cdm.model.common.init = debug,stdout
-#log4j.logger.eu.etaxonomy.cdm.test.function = info
+log4j.logger.eu.etaxonomy.cdm = warn
+log4j.logger.eu.etaxonomy.cdm.database.init = debug
+log4j.logger.eu.etaxonomy.cdm.test.function = info
### *** SPRING ************ ###
/**\r
-* Copyright (C) 2007 EDIT\r
-* European Distributed Institute of Taxonomy \r
-* http://www.e-taxonomy.eu\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
- \r
+ * Copyright (C) 2007 EDIT\r
+ * European Distributed Institute of Taxonomy \r
+ * http://www.e-taxonomy.eu\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
+\r
package eu.etaxonomy.cdm.model.common;\r
\r
import junit.framework.Assert;\r
\r
import org.apache.log4j.Logger;\r
-import org.junit.After;\r
-import org.junit.AfterClass;\r
-import org.junit.Before;\r
-import org.junit.BeforeClass;\r
import org.junit.Test;\r
\r
import eu.etaxonomy.cdm.test.unit.EntityTestBase;\r
public class DefinedTermBaseTest extends EntityTestBase {\r
private static Logger logger = Logger.getLogger(DefinedTermBaseTest.class);\r
\r
- @BeforeClass\r
- public static void setUpBeforeClass() throws Exception {\r
- }\r
-\r
- @AfterClass\r
- public static void tearDownAfterClass() throws Exception {\r
- }\r
-\r
- @Before\r
- public void setUp() throws Exception {\r
- }\r
-\r
- @After\r
- public void tearDown() throws Exception {\r
- }\r
- \r
-/********* TEST *************************************/\r
+ /** ******* TEST ************************************ */\r
\r
@Test\r
public final void testInitTermList() {\r
public final void testSetVocabulary() {\r
logger.warn("Not yet implemented"); // TODO\r
}\r
- \r
- @Test\r
- @Override //has Problem\r
- public final void testPersistentGetterSetterPair() {\r
- Assert.assertTrue(true);\r
- }\r
}\r
private OrderedTermBase otb4;\r
\r
@BeforeClass\r
- public static void setUpBeforeClass() throws Exception {\r
- }\r
-\r
- @AfterClass\r
- public static void tearDownAfterClass() throws Exception {\r
+ public static void setUpBeforeClass() {\r
+ DefaultTermInitializer vocabularyStore = new DefaultTermInitializer();\r
+ vocabularyStore.initialize();\r
}\r
\r
@Before\r
otb3.orderIndex = 4;\r
otb4.orderIndex = 5;\r
}\r
-\r
- @After\r
- public void tearDown() throws Exception {\r
- }\r
\r
private class DerivedOrderedTermBase extends OrderedTermBase<DerivedOrderedTermBase>{\r
private DerivedOrderedTermBase(){\r
\r
@Test\r
public final void testIndexChangeAllowed() {\r
- assertFalse(oVoc1.indexChangeAllowed(otb1));\r
+// assertFalse(oVoc1.indexChangeAllowed(otb1));\r
}\r
\r
@Test\r
assertEquals("The uuid of GERMAN should equal d1131746-e58b-4e80-a865-f5182c9c3073",uuidGerman,Language.GERMAN().getUuid());\r
assertNotNull("GERMAN should have an ENGLISH representation",Language.GERMAN().getRepresentation(Language.ENGLISH()));\r
}\r
-\r
}\r
public void testSetMultilanguageText() {\r
MultilanguageText multilanguageText = MultilanguageText.NewInstance();\r
assertFalse(multilanguageText.equals(textData1.getMultilanguageText()));\r
- textData1.setMultilanguageText(multilanguageText);\r
- assertSame(multilanguageText, textData1.getMultilanguageText());\r
- textData1.setMultilanguageText(null);\r
+ \r
+ textData1.getMultilanguageText().clear();\r
assertNotNull(textData1.getMultilanguageText());\r
assertEquals(0, textData1.getMultilanguageText().size());\r
}\r
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer;\r
import eu.etaxonomy.cdm.model.reference.Article;\r
import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;\r
+import eu.etaxonomy.cdm.model.reference.ReferenceBase;\r
import eu.etaxonomy.cdm.test.unit.EntityTestBase;\r
\r
\r
\r
HybridRelationship hybridRelationship1 = new HybridRelationship(femaleParent, botanicalName1, HybridRelationshipType.FEMALE_PARENT(), null );\r
HybridRelationship hybridRelationship2 = new HybridRelationship(maleParent, botanicalName1, HybridRelationshipType.MALE_PARENT(), null );\r
- Set set = new HashSet<HybridRelationship>();\r
- set.add(hybridRelationship1);\r
- set.add(hybridRelationship2);\r
- botanicalName1.setHybridRelationships(set);\r
+ \r
+ botanicalName1.addHybridRelationship(hybridRelationship1);\r
+ botanicalName1.addHybridRelationship(hybridRelationship2);\r
assertEquals(2, botanicalName1.getHybridRelationships().size());\r
- botanicalName1.setHybridRelationships(set);\r
- set.add("sdfds");\r
+\r
//TODO\r
//assertEquals(2, botanicalName1.getHybridRelationships().size());\r
logger.warn("not yet fully implemented");\r
- botanicalName2.setHybridRelationships(null);\r
+ botanicalName2.getHybridRelationships().clear();\r
//TODO how should this be defined??\r
- assertNull(botanicalName2.getHybridRelationships());\r
+ assertTrue(botanicalName2.getHybridRelationships().isEmpty());\r
}\r
\r
@Test\r
\r
package eu.etaxonomy.cdm.model.name;\r
\r
-import static org.junit.Assert.*;\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertFalse;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertNotSame;\r
+import static org.junit.Assert.assertNull;\r
+import static org.junit.Assert.assertSame;\r
+import static org.junit.Assert.assertTrue;\r
\r
import org.apache.log4j.Logger;\r
-import org.junit.After;\r
-import org.junit.AfterClass;\r
import org.junit.Before;\r
import org.junit.BeforeClass;\r
import org.junit.Test;\r
*/\r
@Before\r
public void setUp() throws Exception {\r
- nameBase1 = new TaxonNameBaseTestClass();\r
+ nameBase1 = new TaxonNameBaseTestClass(null,null);\r
nameBase2 = new TaxonNameBaseTestClass(Rank.GENUS());\r
}\r
\r
\r
package eu.etaxonomy.cdm.model.occurrence;\r
\r
-import static org.junit.Assert.*;\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertFalse;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertNotSame;\r
+import static org.junit.Assert.assertNull;\r
+import static org.junit.Assert.assertSame;\r
+import static org.junit.Assert.assertTrue;\r
\r
import java.util.Calendar;\r
import java.util.UUID;\r
\r
import org.apache.log4j.Logger;\r
import org.joda.time.DateTime;\r
-import org.junit.After;\r
-import org.junit.AfterClass;\r
import org.junit.Before;\r
-import org.junit.BeforeClass;\r
import org.junit.Test;\r
\r
+import com.ibm.lsid.MalformedLSIDException;\r
+\r
import eu.etaxonomy.cdm.model.agent.Person;\r
import eu.etaxonomy.cdm.model.common.Annotation;\r
import eu.etaxonomy.cdm.model.common.Extension;\r
+import eu.etaxonomy.cdm.model.common.LSID;\r
import eu.etaxonomy.cdm.model.common.Language;\r
import eu.etaxonomy.cdm.model.common.LanguageStringBase;\r
import eu.etaxonomy.cdm.model.common.Marker;\r
public class SpecimenTest {\r
private static final Logger logger = Logger.getLogger(SpecimenTest.class);\r
\r
- private static Specimen specimen;\r
+ private Specimen specimen;\r
\r
- /**\r
- * @throws java.lang.Exception\r
- */\r
- @BeforeClass\r
- public static void setUpBeforeClass() throws Exception {\r
- }\r
-\r
- /**\r
- * @throws java.lang.Exception\r
- */\r
- @AfterClass\r
- public static void tearDownAfterClass() throws Exception {\r
- }\r
-\r
- /**\r
- * @throws java.lang.Exception\r
- */\r
@Before\r
public void setUp() throws Exception {\r
specimen = Specimen.NewInstance();\r
}\r
\r
- /**\r
- * @throws java.lang.Exception\r
- */\r
- @After\r
- public void tearDown() throws Exception {\r
- }\r
-\r
/**\r
* Test method for {@link eu.etaxonomy.cdm.model.occurrence.Specimen#NewInstance()}.\r
*/\r
int id = 22;\r
int individualCount = 25;\r
Stage lifeStage = Stage.NewInstance();\r
- String lsid = "lsid";\r
+ LSID lsid = null;\r
+ try {\r
+ lsid = new LSID("urn:lsid:example.com:foo:1");\r
+ } catch (MalformedLSIDException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ }\r
Specimen nextVersion = Specimen.NewInstance();\r
Specimen previousVersion = Specimen.NewInstance();\r
PreservationMethod preservation = PreservationMethod.NewInstance();\r
assertEquals(sex, specimenClone.getSex());\r
assertEquals(titleCache, specimenClone.getTitleCache());\r
\r
-\r
- assertFalse(annotation.equals(specimenClone.getAnnotations().iterator().next()));\r
+ Annotation clonedAnnotation = specimenClone.getAnnotations().iterator().next();\r
+ assertFalse(annotation.equals(clonedAnnotation));\r
assertEquals(annotation.getText(), ((LanguageStringBase)specimenClone.getAnnotations().iterator().next()).getText() );\r
assertNotSame(annotation, specimenClone.getAnnotations().iterator().next() );\r
\r
- assertEquals(definition, specimenClone.getDefinition().getText(Language.DEFAULT()));\r
+ assertEquals(definition, specimenClone.getDefinition().get(Language.DEFAULT()).getText());\r
//TODO \r
// assertNotSame(definition, specimenClone.getDefinition().getText(Language.DEFAULT()));\r
\r
import org.junit.BeforeClass;\r
import org.junit.Test;\r
\r
+import eu.etaxonomy.cdm.model.common.DefaultTermInitializer;\r
import eu.etaxonomy.cdm.model.name.BotanicalName;\r
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
private Taxon taxon1;\r
private Synonym synonym1;\r
private Taxon freeT;\r
- /**\r
- * @throws java.lang.Exception\r
- */\r
+ \r
@BeforeClass\r
- public static void setUpBeforeClass() throws Exception {\r
-\r
- }\r
-\r
- /**\r
- * @throws java.lang.Exception\r
- */\r
- @AfterClass\r
- public static void tearDownAfterClass() throws Exception {\r
+ public static void setUpBeforeClass() {\r
+ DefaultTermInitializer vocabularyStore = new DefaultTermInitializer();\r
+ vocabularyStore.initialize();\r
}\r
\r
/**\r
import eu.etaxonomy.cdm.model.reference.BookSection;\r
import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;\r
import eu.etaxonomy.cdm.model.reference.Journal;\r
+import eu.etaxonomy.cdm.model.reference.ReferenceBase;\r
import eu.etaxonomy.cdm.model.reference.StrictReferenceBase;\r
\r
/**\r
\r
import org.apache.log4j.Logger;\r
\r
-import eu.etaxonomy.cdm.model.agent.Agent;\r
+import eu.etaxonomy.cdm.model.agent.AgentBase;\r
import eu.etaxonomy.cdm.model.agent.Institution;\r
import eu.etaxonomy.cdm.model.agent.Person;\r
import eu.etaxonomy.cdm.model.common.Annotation;\r
\r
logger.info("Create gathering event");\r
GatheringEvent gatheringEvent = GatheringEvent.NewInstance();\r
- Agent gatherer = Person.NewTitledInstance("Lorentz,P.G. s.n.");\r
+ AgentBase gatherer = Person.NewTitledInstance("Lorentz,P.G. s.n.");\r
gatheringEvent.setActor(gatherer);\r
Calendar gatheringDate = Calendar.getInstance();\r
int year = 1922;\r
logger.warn("FieldObservation: " + fieldObservation2);\r
GatheringEvent gatheringEvent2= fieldObservation2.getGatheringEvent();\r
logger.warn("GatheringEvent: " + gatheringEvent2);\r
- Agent gatherer2 = gatheringEvent2.getCollector();\r
+ AgentBase gatherer2 = gatheringEvent2.getCollector();\r
logger.warn("Gatherer: "+ gatherer2);\r
}\r
}\r
import eu.etaxonomy.cdm.model.name.BotanicalName;\r
import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.ZoologicalName;\r
+import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;\r
\r
import eu.etaxonomy.cdm.strategy.parser.INonViralNameParser;\r
import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;\r
System.out.println(nvName.hasProblem());\r
System.out.println(" Name: " + nvName.getTitleCache());\r
System.out.println(" Reference: " + ((nvName.getNomenclaturalReference() == null) ? "-" : nvName.getNomenclaturalReference().getTitleCache()));\r
- System.out.println(" FullReference: " + ((nvName.getNomenclaturalReference() == null) ? "-" : nvName.getNomenclaturalReference().getNomenclaturalCitation(nvName.getNomenclaturalMicroReference())));\r
+ System.out.println(" FullReference: " + ((nvName.getNomenclaturalReference() == null) ? "-" : ((INomenclaturalReference)nvName.getNomenclaturalReference()).getNomenclaturalCitation(nvName.getNomenclaturalMicroReference())));\r
return nvName.hasProblem() == true? 1: 0;\r
\r
}\r
import javax.persistence.Transient;\r
\r
import org.apache.log4j.Logger;\r
+import org.junit.Ignore;\r
import org.junit.Test;\r
\r
import eu.etaxonomy.cdm.model.common.CdmBase;\r
\r
/**\r
* Tests if all persistent (not transient) getter have an according setter.\r
+ * FIXME Having matched getter / setter pairs is not strictly necessary if we \r
+ * use field-level hibernate annotations, and is perhaps even desirable (i.e. \r
+ * prevent the use of set() methods on *-to-Many fields by enforcing use of add*() \r
+ * and remove*())\r
*/\r
@Test \r
- public void testPersistentGetterSetterPair() {\r
+ @Ignore\r
+ public final void testPersistentGetterSetterPair() {\r
//\r
Annotation annotation = clazzToTest.getAnnotation(Entity.class);\r
if (annotation != null){\r
--- /dev/null
+### ************ APPENDER ***********************************###
+
+### direct log messages to stdout ###
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.Target=System.out
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
+
+### direct messages to file hibernate.log ###
+log4j.appender.file=org.apache.log4j.FileAppender
+log4j.appender.file.File=hibernate.log
+log4j.appender.file.layout=org.apache.log4j.PatternLayout
+log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
+
+
+### ************* LOG LEVELS *********************************###
+
+### set log levels - for more verbose logging change 'info' to 'debug' ###
+
+log4j.rootLogger=warn, stdout
+
+ ### *** CDM *** ###
+
+#log4j.logger.eu.etaxonomy.cdm = warn
+#log4j.logger.eu.etaxonomy.cdm.model.common.init = debug,stdout
+#log4j.logger.eu.etaxonomy.cdm.test.function = info
+
+
+ ### *** SPRING ************ ###
+log4j.logger.org.springframework.transaction = warn
+log4j.logger.org.springframework.orm.hibernate3.SessionFactoryUtils = info
+log4j.logger.org.springframework.orm.hibernate3 = info
+log4j.logger.org.springframework.FileSystemXmlApplicationContext = warn
+log4j.logger.org.springframework.core.io.support = info
+
+
+
+### No warnings as thrown by SQLServer
+log4j.logger.org.hibernate.cfg = warn
+
+### No warnings as thrown by SQLServer
+log4j.logger.org.hibernate.util.JDBCExceptionReporter = error
+
+### log HQL query parser activity
+#log4j.logger.org.hibernate.hql.ast.AST=debug
+
+### log just the SQL
+log4j.logger.org.hibernate.SQL=warn
+
+### log JDBC bind parameters ###
+log4j.logger.org.hibernate.type=warn
+
+### log schema export/update ###
+log4j.logger.org.hibernate.tool.hbm2ddl=warn
+
+### log HQL parse trees
+#log4j.logger.org.hibernate.hql=debug
+
+### log cache activity ###
+#log4j.logger.org.hibernate.cache=debug
+
+### log transaction activity
+#log4j.logger.org.hibernate.transaction=debug
+
+### log JDBC resource acquisition
+log4j.logger.org.hibernate.jdbc=info
+
+### enable the following line if you want to track down connection ###
+### leakages when using DriverManagerConnectionProvider ###
+#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace
+
+ ### *** Profiling Logger ************ ###
+
+#log4j.logger.org.springframework.aop.interceptor.PerformanceMonitorInterceptor=TRACE, profiling
+### Profiling output
+#log4j.appender.profiling=org.apache.log4j.RollingFileAppender
+#log4j.appender.profiling.File=profiling.log
+#log4j.appender.profiling.MaxFileSize=1024KB
+#log4j.appender.profiling.MaxBackupIndex=1
+#log4j.appender.profiling.layout=org.apache.log4j.PatternLayout
+#log4j.appender.profiling.layout.conversionPattern=%d,%p,%m%n
+
BGBM BDI Projects / cdmlib.git / commitdiff