Revision ece7e0ae
Added by Andreas Müller almost 6 years ago
| cdmlib-ext/src/main/java/eu/etaxonomy/cdm/ext/bci/BciSchemaAdapter.java | ||
|---|---|---|
| 166 | 166 |
reference.setTitleCache(text, true); |
| 167 | 167 |
} |
| 168 | 168 |
if(dcFieldName.equals(DC_DATE)){
|
| 169 |
reference.setDatePublished(TimePeriodParser.parseString(text)); |
|
| 169 |
reference.setDatePublished(TimePeriodParser.parseStringVerbatim(text));
|
|
| 170 | 170 |
} |
| 171 | 171 |
if(dcFieldName.equals(DC_PUBLISHER)){
|
| 172 | 172 |
reference.setPublisher(text); |
| cdmlib-ext/src/main/java/eu/etaxonomy/cdm/ext/dc/DublinCoreSchemaAdapter.java | ||
|---|---|---|
| 167 | 167 |
reference.setTitleCache(text, true); |
| 168 | 168 |
} |
| 169 | 169 |
if(dcFieldName.equals(DC_DATE)){
|
| 170 |
reference.setDatePublished(TimePeriodParser.parseString(text)); |
|
| 170 |
reference.setDatePublished(TimePeriodParser.parseStringVerbatim(text));
|
|
| 171 | 171 |
} |
| 172 | 172 |
if(dcFieldName.equals(DC_PUBLISHER)){
|
| 173 | 173 |
reference.setPublisher(text); |
| cdmlib-ext/src/main/java/eu/etaxonomy/cdm/ext/ipni/IpniService.java | ||
|---|---|---|
| 46 | 46 |
import eu.etaxonomy.cdm.model.common.Language; |
| 47 | 47 |
import eu.etaxonomy.cdm.model.common.OriginalSourceType; |
| 48 | 48 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
| 49 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod; |
|
| 49 | 50 |
import eu.etaxonomy.cdm.model.name.IBotanicalName; |
| 50 | 51 |
import eu.etaxonomy.cdm.model.name.NomenclaturalCode; |
| 51 | 52 |
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus; |
| ... | ... | |
| 425 | 426 |
|
| 426 | 427 |
|
| 427 | 428 |
//dates |
| 428 |
TimePeriod date = TimePeriodParser.parseString(valueMap.get(DATE));
|
|
| 429 |
VerbatimTimePeriod date = TimePeriodParser.parseStringVerbatim(valueMap.get(DATE));
|
|
| 429 | 430 |
ref.setDatePublished(date); |
| 430 | 431 |
|
| 431 | 432 |
|
| ... | ... | |
| 548 | 549 |
ref.setAbbrevTitle(nomRefTitle); |
| 549 | 550 |
} |
| 550 | 551 |
|
| 551 |
TimePeriod datePublished = parsePublicationFullYear(valueMap.get(PUBLICATION_YEAR_FULL));
|
|
| 552 |
VerbatimTimePeriod datePublished = parsePublicationFullYear(valueMap.get(PUBLICATION_YEAR_FULL));
|
|
| 552 | 553 |
ref.setDatePublished(datePublished); |
| 553 | 554 |
|
| 554 | 555 |
name.setNomenclaturalReference(ref); |
| ... | ... | |
| 722 | 723 |
* @param string |
| 723 | 724 |
* @return |
| 724 | 725 |
*/ |
| 725 |
private TimePeriod parsePublicationFullYear(String fullYearStr) {
|
|
| 726 |
TimePeriod result = null; |
|
| 726 |
private VerbatimTimePeriod parsePublicationFullYear(String fullYearStr) {
|
|
| 727 |
VerbatimTimePeriod result = null;
|
|
| 727 | 728 |
|
| 728 | 729 |
if (fullYearStr != null){
|
| 729 | 730 |
Matcher matcher = datePattern.matcher(fullYearStr); |
| ... | ... | |
| 731 | 732 |
String yearStr = matcher.group(1); |
| 732 | 733 |
Integer year = Integer.valueOf(yearStr); |
| 733 | 734 |
String exactDate = matcher.group(2); |
| 734 |
result = TimePeriodParser.parseString(exactDate); |
|
| 735 |
result = TimePeriodParser.parseStringVerbatim(exactDate);
|
|
| 735 | 736 |
if (!year.equals(result.getStartYear())){
|
| 736 | 737 |
logger.warn("Year and exact date year do not match");
|
| 737 |
result = TimePeriod.NewInstance(year);
|
|
| 738 |
result = VerbatimTimePeriod.NewVerbatimInstance(year);
|
|
| 738 | 739 |
result.setFreeText(fullYearStr); |
| 739 | 740 |
} |
| 740 | 741 |
}else{
|
| 741 |
result = TimePeriodParser.parseString(fullYearStr); |
|
| 742 |
result = TimePeriodParser.parseStringVerbatim(fullYearStr);
|
|
| 742 | 743 |
} |
| 743 | 744 |
} |
| 744 | 745 |
return result; |
| cdmlib-ext/src/main/java/eu/etaxonomy/cdm/ext/openurl/MobotOpenUrlResponseSchemaAdapter.java | ||
|---|---|---|
| 29 | 29 |
import eu.etaxonomy.cdm.ext.common.SchemaAdapterBase; |
| 30 | 30 |
import eu.etaxonomy.cdm.model.agent.Person; |
| 31 | 31 |
import eu.etaxonomy.cdm.model.agent.Team; |
| 32 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 32 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 33 | 33 |
import eu.etaxonomy.cdm.model.reference.Reference; |
| 34 | 34 |
|
| 35 | 35 |
|
| ... | ... | |
| 264 | 264 |
try {
|
| 265 | 265 |
startYear = Integer.valueOf(trimmedText.substring(0, 4)); |
| 266 | 266 |
endYear = Integer.valueOf(trimmedText.substring(5)); |
| 267 |
reference.setDatePublished(TimePeriod.NewInstance(startYear, endYear));
|
|
| 268 |
} catch (NumberFormatException e) {
|
|
| 267 |
reference.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(startYear, endYear));
|
|
| 268 |
} catch (NumberFormatException e) {
|
|
| 269 | 269 |
logger.error("date can not be parsed: "+ trimmedText);
|
| 270 | 270 |
} |
| 271 | 271 |
} else if(trimmedText.length() == 4) {
|
| ... | ... | |
| 274 | 274 |
} catch (NumberFormatException e) {
|
| 275 | 275 |
logger.error("date can not be parsed: "+ trimmedText);
|
| 276 | 276 |
} |
| 277 |
reference.setDatePublished(TimePeriod.NewInstance(startYear));
|
|
| 277 |
reference.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(startYear));
|
|
| 278 | 278 |
} |
| 279 | 279 |
} |
| 280 | 280 |
if(elementNameToStore.equals(VOLUME)){
|
| cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/common/ImportHelper.java | ||
|---|---|---|
| 31 | 31 |
import eu.etaxonomy.cdm.model.common.IdentifiableSource; |
| 32 | 32 |
import eu.etaxonomy.cdm.model.common.Language; |
| 33 | 33 |
import eu.etaxonomy.cdm.model.common.OriginalSourceType; |
| 34 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 34 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 35 | 35 |
import eu.etaxonomy.cdm.model.description.DescriptionElementBase; |
| 36 | 36 |
import eu.etaxonomy.cdm.model.description.DescriptionElementSource; |
| 37 | 37 |
import eu.etaxonomy.cdm.model.name.TaxonName; |
| ... | ... | |
| 299 | 299 |
} |
| 300 | 300 |
|
| 301 | 301 |
|
| 302 |
public static TimePeriod getDatePublished(String refYear){
|
|
| 303 |
TimePeriod resultNew;
|
|
| 302 |
public static VerbatimTimePeriod getDatePublished(String refYear){
|
|
| 303 |
VerbatimTimePeriod resultNew;
|
|
| 304 | 304 |
try {
|
| 305 |
resultNew = TimePeriodParser.parseString(refYear); |
|
| 305 |
resultNew = TimePeriodParser.parseStringVerbatim(refYear);
|
|
| 306 | 306 |
} catch (IllegalArgumentException e) {
|
| 307 | 307 |
logger.warn("RefYear could not be parsed: " + refYear);
|
| 308 | 308 |
resultNew = null; |
| cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/dwca/in/GbifReferenceCsv2CdmConverter.java | ||
|---|---|---|
| 31 | 31 |
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase; |
| 32 | 32 |
import eu.etaxonomy.cdm.model.common.CdmBase; |
| 33 | 33 |
import eu.etaxonomy.cdm.model.common.LSID; |
| 34 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 34 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 35 | 35 |
import eu.etaxonomy.cdm.model.description.DescriptionElementSource; |
| 36 | 36 |
import eu.etaxonomy.cdm.model.description.Feature; |
| 37 | 37 |
import eu.etaxonomy.cdm.model.description.TaxonDescription; |
| ... | ... | |
| 95 | 95 |
TeamOrPersonBase<?> author = handleCreator(strCreator); |
| 96 | 96 |
reference.setAuthorship(author); |
| 97 | 97 |
//date |
| 98 |
TimePeriod publicationDate = handleDate(strDate); |
|
| 98 |
VerbatimTimePeriod publicationDate = handleDate(strDate);
|
|
| 99 | 99 |
reference.setDatePublished(publicationDate); |
| 100 | 100 |
//title |
| 101 | 101 |
reference.setTitle(strTitle); |
| ... | ... | |
| 232 | 232 |
} |
| 233 | 233 |
|
| 234 | 234 |
|
| 235 |
private TimePeriod handleDate(String strDate) {
|
|
| 236 |
TimePeriod tp = TimePeriodParser.parseString(strDate);
|
|
| 235 |
private VerbatimTimePeriod handleDate(String strDate) {
|
|
| 236 |
VerbatimTimePeriod tp = TimePeriodParser.parseStringVerbatim(strDate);
|
|
| 237 | 237 |
return tp; |
| 238 | 238 |
} |
| 239 | 239 |
|
| cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/excel/taxa/NormalExplicitImport.java | ||
|---|---|---|
| 644 | 644 |
}else if (type.equals(SourceType.Title)) {
|
| 645 | 645 |
ref.setTitle(value); |
| 646 | 646 |
}else if (type.equals(SourceType.Year)) {
|
| 647 |
ref.setDatePublished(TimePeriodParser.parseString(value)); |
|
| 647 |
ref.setDatePublished(TimePeriodParser.parseStringVerbatim(value));
|
|
| 648 | 648 |
}else if (type.equals(SourceType.RefExtension)) {
|
| 649 | 649 |
ExtensionType extensionType = getExtensionType(state, uuidRefExtension, "RefExtension", "Reference Extension", "RefExt."); |
| 650 | 650 |
Extension extension = Extension.NewInstance(ref, value, extensionType); |
| cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/markup/MarkupImportBase.java | ||
|---|---|---|
| 63 | 63 |
import eu.etaxonomy.cdm.model.common.MarkerType; |
| 64 | 64 |
import eu.etaxonomy.cdm.model.common.OriginalSourceType; |
| 65 | 65 |
import eu.etaxonomy.cdm.model.common.TermVocabulary; |
| 66 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 66 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 67 | 67 |
import eu.etaxonomy.cdm.model.description.DescriptionElementBase; |
| 68 | 68 |
import eu.etaxonomy.cdm.model.description.Distribution; |
| 69 | 69 |
import eu.etaxonomy.cdm.model.description.Feature; |
| ... | ... | |
| 2147 | 2147 |
titleCache, volume, issue, edition, editors, pubName, appendix, pages, parentEvent); |
| 2148 | 2148 |
|
| 2149 | 2149 |
//year |
| 2150 |
TimePeriod timeperiod = TimePeriodParser.parseString(year);
|
|
| 2150 |
VerbatimTimePeriod timeperiod = TimePeriodParser.parseStringVerbatim(year);
|
|
| 2151 | 2151 |
if (reference.getType().equals(ReferenceType.BookSection)){
|
| 2152 | 2152 |
reference.getInBook().setDatePublished(timeperiod); |
| 2153 | 2153 |
} |
| cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/markup/MarkupModsImport.java | ||
|---|---|---|
| 22 | 22 |
import eu.etaxonomy.cdm.model.agent.Team; |
| 23 | 23 |
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase; |
| 24 | 24 |
import eu.etaxonomy.cdm.model.common.CdmBase; |
| 25 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 25 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 26 | 26 |
import eu.etaxonomy.cdm.model.reference.Reference; |
| 27 | 27 |
import eu.etaxonomy.cdm.model.reference.ReferenceFactory; |
| 28 | 28 |
import eu.etaxonomy.cdm.strategy.parser.TimePeriodParser; |
| ... | ... | |
| 109 | 109 |
if (modsRef.getDatePublished() != null && ! modsRef.getDatePublished().isEmpty()){
|
| 110 | 110 |
fireWarningEvent("Multiple publish date infos given. I overwrite older information. Please check manually ;", next, 4);
|
| 111 | 111 |
} |
| 112 |
TimePeriod timePeriod = TimePeriodParser.parseString(dateIssued);
|
|
| 112 |
VerbatimTimePeriod timePeriod = TimePeriodParser.parseStringVerbatim(dateIssued);
|
|
| 113 | 113 |
modsRef.setDatePublished(timePeriod); |
| 114 | 114 |
}else if (isStartingElement(next, MODS_PLACE)) {
|
| 115 | 115 |
String place = this.getCData(state, reader, next); |
| cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/markup/MarkupNomenclatureImport.java | ||
|---|---|---|
| 23 | 23 |
|
| 24 | 24 |
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase; |
| 25 | 25 |
import eu.etaxonomy.cdm.model.common.OriginalSourceType; |
| 26 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 26 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 27 | 27 |
import eu.etaxonomy.cdm.model.description.Feature; |
| 28 | 28 |
import eu.etaxonomy.cdm.model.description.TaxonDescription; |
| 29 | 29 |
import eu.etaxonomy.cdm.model.description.TextData; |
| ... | ... | |
| 757 | 757 |
} |
| 758 | 758 |
|
| 759 | 759 |
//year |
| 760 |
TimePeriod timeperiod = TimePeriodParser.parseString(year);
|
|
| 760 |
VerbatimTimePeriod timeperiod = TimePeriodParser.parseStringVerbatim(year);
|
|
| 761 | 761 |
if (reference.getType().equals(ReferenceType.BookSection)){
|
| 762 | 762 |
reference.getInBook().setDatePublished(timeperiod); |
| 763 | 763 |
} |
| cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/reference/ris/in/RisReferenceImport.java | ||
|---|---|---|
| 32 | 32 |
import eu.etaxonomy.cdm.model.common.AnnotationType; |
| 33 | 33 |
import eu.etaxonomy.cdm.model.common.Language; |
| 34 | 34 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
| 35 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod; |
|
| 35 | 36 |
import eu.etaxonomy.cdm.model.reference.Reference; |
| 36 | 37 |
import eu.etaxonomy.cdm.model.reference.ReferenceFactory; |
| 37 | 38 |
import eu.etaxonomy.cdm.model.reference.ReferenceType; |
| ... | ... | |
| 166 | 167 |
RisValue py = getSingleValue(state, record, RisReferenceTag.PY); |
| 167 | 168 |
RisValue da = getSingleValue(state, record, RisReferenceTag.DA); |
| 168 | 169 |
Integer year = makeYear(state, py); |
| 169 |
TimePeriod date = makeDate(state, da); |
|
| 170 |
VerbatimTimePeriod date = makeDate(state, da);
|
|
| 170 | 171 |
assertDateYear(state, year, date, py); |
| 171 | 172 |
ref.setDatePublished(date); |
| 172 | 173 |
//TODO y1 not yet handled |
| ... | ... | |
| 324 | 325 |
* @param da |
| 325 | 326 |
* @return |
| 326 | 327 |
*/ |
| 327 |
private TimePeriod makeDate(RisReferenceImportState state, RisValue da) {
|
|
| 328 |
private VerbatimTimePeriod makeDate(RisReferenceImportState state, RisValue da) {
|
|
| 328 | 329 |
if (da == null){
|
| 329 | 330 |
return null; |
| 330 | 331 |
} |
| ... | ... | |
| 335 | 336 |
return null; |
| 336 | 337 |
} |
| 337 | 338 |
String[] split = da.value.split("/");
|
| 338 |
TimePeriod tp = TimePeriod.NewInstance();
|
|
| 339 |
VerbatimTimePeriod tp = VerbatimTimePeriod.NewVerbatimInstance();
|
|
| 339 | 340 |
if (split.length > 0 && isNotBlank(split[0])){
|
| 340 | 341 |
tp.setStartYear(Integer.valueOf(split[0])); |
| 341 | 342 |
} |
| cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/taxonx/TaxonXModsImport.java | ||
|---|---|---|
| 24 | 24 |
import eu.etaxonomy.cdm.model.agent.Team; |
| 25 | 25 |
import eu.etaxonomy.cdm.model.common.Marker; |
| 26 | 26 |
import eu.etaxonomy.cdm.model.common.MarkerType; |
| 27 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 27 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 28 | 28 |
import eu.etaxonomy.cdm.model.reference.IPublicationBase; |
| 29 | 29 |
import eu.etaxonomy.cdm.model.reference.Reference; |
| 30 | 30 |
import eu.etaxonomy.cdm.model.reference.ReferenceFactory; |
| ... | ... | |
| 131 | 131 |
String dateIssued = elDateIssued.getTextNormalize(); |
| 132 | 132 |
contentList.remove(elDateIssued); |
| 133 | 133 |
|
| 134 |
TimePeriod datePublished = TimePeriodParser.parseString(dateIssued);
|
|
| 134 |
VerbatimTimePeriod datePublished = TimePeriodParser.parseStringVerbatim(dateIssued);
|
|
| 135 | 135 |
if (ref.getType().isPublication()){
|
| 136 | 136 |
((IPublicationBase)ref).setDatePublished(datePublished ); |
| 137 | 137 |
}else{
|
| cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/taxonx2013/TaxonXModsExtractor.java | ||
|---|---|---|
| 17 | 17 |
import eu.etaxonomy.cdm.common.DOI; |
| 18 | 18 |
import eu.etaxonomy.cdm.model.agent.Person; |
| 19 | 19 |
import eu.etaxonomy.cdm.model.agent.Team; |
| 20 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 20 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 21 | 21 |
import eu.etaxonomy.cdm.model.reference.Reference; |
| 22 | 22 |
import eu.etaxonomy.cdm.model.reference.ReferenceFactory; |
| 23 | 23 |
import eu.etaxonomy.cdm.model.reference.ReferenceType; |
| ... | ... | |
| 305 | 305 |
List<String> originInfo = null; |
| 306 | 306 |
List<String> partList = null; |
| 307 | 307 |
|
| 308 |
TimePeriod date; |
|
| 308 |
VerbatimTimePeriod date;
|
|
| 309 | 309 |
|
| 310 | 310 |
String publisher=""; |
| 311 | 311 |
String publishplace=""; |
| ... | ... | |
| 364 | 364 |
if (!content.isEmpty()) {
|
| 365 | 365 |
originInfo.add(children.item(i).getNodeName()+":"+content); |
| 366 | 366 |
if (children.item(i).getNodeName().contains("dateIssued")) {
|
| 367 |
ref.setDatePublished(TimePeriodParser.parseString(content)); |
|
| 367 |
ref.setDatePublished(TimePeriodParser.parseStringVerbatim(content));
|
|
| 368 | 368 |
} |
| 369 | 369 |
} |
| 370 | 370 |
publisher=""; |
| ... | ... | |
| 403 | 403 |
} else if (children.item(i).getNodeName().equalsIgnoreCase("mods:date")){
|
| 404 | 404 |
content = children.item(i).getTextContent().trim(); |
| 405 | 405 |
if (!content.isEmpty()){
|
| 406 |
date = TimePeriodParser.parseString(content); |
|
| 406 |
date = TimePeriodParser.parseStringVerbatim(content);
|
|
| 407 | 407 |
//TODO need to check if date belongs to ref or inref |
| 408 | 408 |
ref.setDatePublished(date); |
| 409 | 409 |
} |
| cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/tcsrdf/TcsRdfTaxonNameImport.java | ||
|---|---|---|
| 35 | 35 |
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase; |
| 36 | 36 |
import eu.etaxonomy.cdm.model.common.Marker; |
| 37 | 37 |
import eu.etaxonomy.cdm.model.common.MarkerType; |
| 38 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 38 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 39 | 39 |
import eu.etaxonomy.cdm.model.name.INonViralName; |
| 40 | 40 |
import eu.etaxonomy.cdm.model.name.NomenclaturalCode; |
| 41 | 41 |
import eu.etaxonomy.cdm.model.name.Rank; |
| ... | ... | |
| 210 | 210 |
if (strYear != null){
|
| 211 | 211 |
try {
|
| 212 | 212 |
year = Integer.valueOf(strYear); |
| 213 |
TimePeriod timeP = TimePeriod.NewInstance(year);
|
|
| 213 |
VerbatimTimePeriod timeP = VerbatimTimePeriod.NewVerbatimInstance(year);
|
|
| 214 | 214 |
nomRef.setDatePublished(timeP); |
| 215 | 215 |
} catch (RuntimeException e) {
|
| 216 | 216 |
logger.warn("year could not be parsed");
|
| cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/tcsxml/DefaultTcsXmlPlaceholders.java | ||
|---|---|---|
| 15 | 15 |
|
| 16 | 16 |
import eu.etaxonomy.cdm.common.ResultWrapper; |
| 17 | 17 |
import eu.etaxonomy.cdm.io.tcsxml.in.TcsXmlImportConfigurator; |
| 18 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 18 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 19 | 19 |
import eu.etaxonomy.cdm.model.reference.Reference; |
| 20 | 20 |
import eu.etaxonomy.cdm.strategy.parser.TimePeriodParser; |
| 21 | 21 |
|
| ... | ... | |
| 74 | 74 |
|
| 75 | 75 |
childName = "DatePublished"; |
| 76 | 76 |
if (element.getName().equalsIgnoreCase(childName) && element.getNamespace().equals(tcsNs)){
|
| 77 |
TimePeriod datePublished = TimePeriodParser.parseString(value);
|
|
| 77 |
VerbatimTimePeriod datePublished = TimePeriodParser.parseStringVerbatim(value);
|
|
| 78 | 78 |
publication.setDatePublished(datePublished); |
| 79 | 79 |
continue; |
| 80 | 80 |
} |
| cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/tcsxml/in/TcsXmlTaxonNameImport.java | ||
|---|---|---|
| 26 | 26 |
import eu.etaxonomy.cdm.io.tcsxml.TcsXmlTransformer; |
| 27 | 27 |
import eu.etaxonomy.cdm.model.agent.Person; |
| 28 | 28 |
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase; |
| 29 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 29 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 30 | 30 |
import eu.etaxonomy.cdm.model.name.INonViralName; |
| 31 | 31 |
import eu.etaxonomy.cdm.model.name.NomenclaturalCode; |
| 32 | 32 |
import eu.etaxonomy.cdm.model.name.Rank; |
| ... | ... | |
| 568 | 568 |
if (name.isZoological()){
|
| 569 | 569 |
name.setPublicationYear(getIntegerYear(year)); |
| 570 | 570 |
}else{
|
| 571 |
TimePeriod period = TimePeriod.NewInstance(getIntegerYear(year));
|
|
| 571 |
VerbatimTimePeriod period = VerbatimTimePeriod.NewVerbatimInstance(getIntegerYear(year));
|
|
| 572 | 572 |
if (name.getNomenclaturalReference()!= null){
|
| 573 | 573 |
name.getNomenclaturalReference().setDatePublished(period); |
| 574 | 574 |
} else{
|
| cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/tropicos/in/TropicosNameImport.java | ||
|---|---|---|
| 25 | 25 |
import eu.etaxonomy.cdm.model.common.IdentifiableEntity; |
| 26 | 26 |
import eu.etaxonomy.cdm.model.common.Language; |
| 27 | 27 |
import eu.etaxonomy.cdm.model.common.OriginalSourceType; |
| 28 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 28 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 29 | 29 |
import eu.etaxonomy.cdm.model.description.Feature; |
| 30 | 30 |
import eu.etaxonomy.cdm.model.description.TaxonNameDescription; |
| 31 | 31 |
import eu.etaxonomy.cdm.model.description.TextData; |
| ... | ... | |
| 240 | 240 |
//date |
| 241 | 241 |
if (titlePageYear != null){
|
| 242 | 242 |
if (yearPublished == null){
|
| 243 |
TimePeriod tp = TimePeriodParser.parseString(titlePageYear);
|
|
| 243 |
VerbatimTimePeriod tp = TimePeriodParser.parseStringVerbatim(titlePageYear);
|
|
| 244 | 244 |
reference.setDatePublished(tp); |
| 245 | 245 |
}else{
|
| 246 |
TimePeriod tp = TimePeriodParser.parseString(yearPublished);
|
|
| 246 |
VerbatimTimePeriod tp = TimePeriodParser.parseStringVerbatim(yearPublished);
|
|
| 247 | 247 |
reference.setDatePublished(tp); |
| 248 | 248 |
} |
| 249 | 249 |
}else if (yearPublished != null){
|
| 250 |
TimePeriod tp = TimePeriodParser.parseString(yearPublished);
|
|
| 250 |
VerbatimTimePeriod tp = TimePeriodParser.parseStringVerbatim(yearPublished);
|
|
| 251 | 251 |
reference.setDatePublished(tp); |
| 252 | 252 |
} |
| 253 | 253 |
|
| cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/TimePeriod.java | ||
|---|---|---|
| 249 | 249 |
} |
| 250 | 250 |
|
| 251 | 251 |
|
| 252 |
//****************** CONVERTERS ******************/ |
|
| 253 |
|
|
| 254 |
public static TimePeriod fromVerbatim(VerbatimTimePeriod verbatimTimePeriod){
|
|
| 255 |
if (verbatimTimePeriod == null){
|
|
| 256 |
return null; |
|
| 257 |
} |
|
| 258 |
TimePeriod result = TimePeriod.NewInstance(); |
|
| 259 |
copyCloned(verbatimTimePeriod, result); |
|
| 260 |
if (StringUtils.isNotBlank(verbatimTimePeriod.getVerbatimDate()) && |
|
| 261 |
StringUtils.isBlank(result.getFreeText())){
|
|
| 262 |
result.setFreeText(verbatimTimePeriod.toString()); |
|
| 263 |
} |
|
| 264 |
return result; |
|
| 265 |
} |
|
| 266 |
public static VerbatimTimePeriod toVerbatim(TimePeriod timePeriod){
|
|
| 267 |
if (timePeriod == null){
|
|
| 268 |
return null; |
|
| 269 |
} |
|
| 270 |
VerbatimTimePeriod result = VerbatimTimePeriod.NewVerbatimInstance(); |
|
| 271 |
copyCloned(timePeriod, result); |
|
| 272 |
return result; |
|
| 273 |
} |
|
| 274 |
public VerbatimTimePeriod toVerbatim(){
|
|
| 275 |
return toVerbatim(this); |
|
| 276 |
} |
|
| 277 |
|
|
| 278 |
|
|
| 252 | 279 |
|
| 253 | 280 |
//*********************** CONSTRUCTOR *********************************/ |
| 254 | 281 |
|
| cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/VerbatimTimePeriod.java | ||
|---|---|---|
| 201 | 201 |
this.verbatimDate = verbatimDate; |
| 202 | 202 |
} |
| 203 | 203 |
|
| 204 |
//****************** CONVERTERS ******************/ |
|
| 205 |
|
|
| 206 |
public static TimePeriod fromVerbatim(VerbatimTimePeriod verbatimTimePeriod){
|
|
| 207 |
if (verbatimTimePeriod == null){
|
|
| 208 |
return null; |
|
| 209 |
} |
|
| 210 |
TimePeriod result = TimePeriod.NewInstance(); |
|
| 211 |
copyCloned(verbatimTimePeriod, result); |
|
| 212 |
if (StringUtils.isNotBlank(verbatimTimePeriod.verbatimDate) && |
|
| 213 |
StringUtils.isBlank(result.getFreeText())){
|
|
| 214 |
result.setFreeText(verbatimTimePeriod.toString()); |
|
| 215 |
} |
|
| 216 |
return result; |
|
| 217 |
} |
|
| 218 |
public static VerbatimTimePeriod toVerbatim(TimePeriod timePeriod){
|
|
| 219 |
if (timePeriod == null){
|
|
| 220 |
return null; |
|
| 221 |
} |
|
| 222 |
VerbatimTimePeriod result = VerbatimTimePeriod.NewVerbatimInstance(); |
|
| 223 |
copyCloned(timePeriod, result); |
|
| 224 |
return result; |
|
| 225 |
} |
|
| 226 | 204 |
|
| 227 | 205 |
|
| 228 | 206 |
|
| cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/reference/ReferenceFactory.java | ||
|---|---|---|
| 12 | 12 |
import org.apache.log4j.Logger; |
| 13 | 13 |
|
| 14 | 14 |
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase; |
| 15 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 15 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 16 | 16 |
|
| 17 | 17 |
public class ReferenceFactory {
|
| 18 | 18 |
private static final Logger logger = Logger.getLogger(ReferenceFactory.class); |
| ... | ... | |
| 107 | 107 |
} |
| 108 | 108 |
|
| 109 | 109 |
public static Reference newArticle(Reference inJournal, TeamOrPersonBase partAuthor, |
| 110 |
String title, String pages, String seriesPart, String volume, TimePeriod datePublished) {
|
|
| 110 |
String title, String pages, String seriesPart, String volume, VerbatimTimePeriod datePublished) {
|
|
| 111 | 111 |
IArticle article = newArticle(); |
| 112 | 112 |
article.setInReference(inJournal); |
| 113 | 113 |
article.setAuthorship(partAuthor); |
| cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/taxon/Taxon.java | ||
|---|---|---|
| 818 | 818 |
private int computeMisapliedNameRelations(){
|
| 819 | 819 |
int count = 0; |
| 820 | 820 |
for (TaxonRelationship rel: this.getRelationsFromThisTaxon()){
|
| 821 |
if (rel.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR()) |
|
| 822 |
|| rel.getType().equals(TaxonRelationshipType.PRO_PARTE_MISAPPLIED_NAME_FOR()) || rel.getType().equals(TaxonRelationshipType.PARTIAL_MISAPPLIED_NAME_FOR())){
|
|
| 821 |
if (rel.getType().isAnyMisappliedName()){
|
|
| 823 | 822 |
count++; |
| 824 | 823 |
} |
| 825 | 824 |
} |
| ... | ... | |
| 845 | 844 |
private int computeProparteSynonymRelations(){
|
| 846 | 845 |
int count = 0; |
| 847 | 846 |
for (TaxonRelationship rel: this.getRelationsFromThisTaxon()){
|
| 848 |
if (rel.getType().equals(TaxonRelationshipType.PRO_PARTE_SYNONYM_FOR()) |
|
| 849 |
|| rel.getType().equals(TaxonRelationshipType.PARTIAL_SYNONYM_FOR())){
|
|
| 847 |
if (rel.getType().isAnySynonym()){
|
|
| 850 | 848 |
count++; |
| 851 | 849 |
} |
| 852 | 850 |
} |
| cdmlib-model/src/main/java/eu/etaxonomy/cdm/strategy/parser/NonViralNameParserImpl.java | ||
|---|---|---|
| 26 | 26 |
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase; |
| 27 | 27 |
import eu.etaxonomy.cdm.model.common.CdmBase; |
| 28 | 28 |
import eu.etaxonomy.cdm.model.common.IParsable; |
| 29 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 29 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 30 | 30 |
import eu.etaxonomy.cdm.model.name.HybridRelationship; |
| 31 | 31 |
import eu.etaxonomy.cdm.model.name.HybridRelationshipType; |
| 32 | 32 |
import eu.etaxonomy.cdm.model.name.IBotanicalName; |
| ... | ... | |
| 467 | 467 |
//continue |
| 468 | 468 |
}else{
|
| 469 | 469 |
ref = makeDetailYearUnparsable(nameToBeFilled,strReference); |
| 470 |
ref.setDatePublished(TimePeriodParser.parseString(yearPart)); |
|
| 470 |
ref.setDatePublished(TimePeriodParser.parseStringVerbatim(yearPart));
|
|
| 471 | 471 |
return; |
| 472 | 472 |
} |
| 473 | 473 |
} |
| ... | ... | |
| 615 | 615 |
if ("".equals(year.trim())){
|
| 616 | 616 |
return true; |
| 617 | 617 |
} |
| 618 |
TimePeriod datePublished = TimePeriodParser.parseString(year);
|
|
| 618 |
VerbatimTimePeriod datePublished = TimePeriodParser.parseStringVerbatim(year);
|
|
| 619 | 619 |
|
| 620 | 620 |
if (nomRef.getType().equals(ReferenceType.BookSection)){
|
| 621 | 621 |
handleBookSectionYear((IBookSection)nomRef, datePublished); |
| ... | ... | |
| 723 | 723 |
* @param bookSection |
| 724 | 724 |
* @param datePublished |
| 725 | 725 |
*/ |
| 726 |
private void handleBookSectionYear(IBookSection bookSection, TimePeriod datePublished){
|
|
| 726 |
private void handleBookSectionYear(IBookSection bookSection, VerbatimTimePeriod datePublished){
|
|
| 727 | 727 |
if (datePublished == null || datePublished.getStart() == null || bookSection == null){
|
| 728 | 728 |
return; |
| 729 | 729 |
} |
| cdmlib-model/src/test/java/eu/etaxonomy/cdm/model/taxon/HomotypicGroupTaxonComparatorTest.java | ||
|---|---|---|
| 22 | 22 |
import org.junit.Test; |
| 23 | 23 |
|
| 24 | 24 |
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer; |
| 25 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 25 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 26 | 26 |
import eu.etaxonomy.cdm.model.name.HomotypicalGroup; |
| 27 | 27 |
import eu.etaxonomy.cdm.model.name.INonViralName; |
| 28 | 28 |
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus; |
| ... | ... | |
| 84 | 84 |
cal2.set(1943, 3, 2); |
| 85 | 85 |
cal3.set(1945, 3, 2); |
| 86 | 86 |
|
| 87 |
ref1.setDatePublished(TimePeriod.NewInstance(cal1));
|
|
| 88 |
ref2.setDatePublished(TimePeriod.NewInstance(cal2));
|
|
| 89 |
ref3.setDatePublished(TimePeriod.NewInstance(cal3));
|
|
| 87 |
ref1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(cal1));
|
|
| 88 |
ref2.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(cal2));
|
|
| 89 |
ref3.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(cal3));
|
|
| 90 | 90 |
|
| 91 | 91 |
botName1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES()); |
| 92 | 92 |
botName2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES()); |
| cdmlib-model/src/test/java/eu/etaxonomy/cdm/model/taxon/TaxonComparatorTest.java | ||
|---|---|---|
| 21 | 21 |
|
| 22 | 22 |
import eu.etaxonomy.cdm.model.agent.Person; |
| 23 | 23 |
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer; |
| 24 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 24 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 25 | 25 |
import eu.etaxonomy.cdm.model.name.IBotanicalName; |
| 26 | 26 |
import eu.etaxonomy.cdm.model.name.IZoologicalName; |
| 27 | 27 |
import eu.etaxonomy.cdm.model.name.Rank; |
| ... | ... | |
| 94 | 94 |
cal2.set(1856, 3, 2); |
| 95 | 95 |
cal3.set(1943, 3, 2); |
| 96 | 96 |
|
| 97 |
ref1.setDatePublished(TimePeriod.NewInstance(cal1));
|
|
| 97 |
ref1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(cal1));
|
|
| 98 | 98 |
// ref2.setDatePublished(TimePeriod.NewInstance(cal2)); |
| 99 |
ref3.setDatePublished(TimePeriod.NewInstance(cal3));
|
|
| 99 |
ref3.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(cal3));
|
|
| 100 | 100 |
|
| 101 | 101 |
Person author1 = Person.NewTitledInstance("Rehder");
|
| 102 | 102 |
author1.setNomenclaturalTitle("Rehder");
|
| cdmlib-model/src/test/java/eu/etaxonomy/cdm/strategy/cache/name/BotanicNameCacheStrategyTest.java | ||
|---|---|---|
| 24 | 24 |
import eu.etaxonomy.cdm.model.agent.Person; |
| 25 | 25 |
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase; |
| 26 | 26 |
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer; |
| 27 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 27 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 28 | 28 |
import eu.etaxonomy.cdm.model.name.INonViralName; |
| 29 | 29 |
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus; |
| 30 | 30 |
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType; |
| ... | ... | |
| 108 | 108 |
GregorianCalendar testDate = new GregorianCalendar(); |
| 109 | 109 |
testDate.set(1968, 3, 2); |
| 110 | 110 |
|
| 111 |
TimePeriod period = TimePeriod.NewInstance(testDate);
|
|
| 111 |
VerbatimTimePeriod period = VerbatimTimePeriod.NewVerbatimInstance(testDate);
|
|
| 112 | 112 |
|
| 113 | 113 |
citationRef.setDatePublished(period); |
| 114 | 114 |
|
| cdmlib-model/src/test/java/eu/etaxonomy/cdm/strategy/cache/name/NonViralNameDefaultCacheStrategyTest.java | ||
|---|---|---|
| 341 | 341 |
Assert.assertEquals("Nepenthes glabrata J.R.Turnbull & A.T.Middleton, My Reference [as \"glabratus\"]", correctName.getFullTitleCache());
|
| 342 | 342 |
citationRef.setProtectedTitleCache(false); |
| 343 | 343 |
citationRef.setTitle("Sp. Pl.");
|
| 344 |
citationRef.setDatePublished(TimePeriodParser.parseString("1988"));
|
|
| 344 |
citationRef.setDatePublished(TimePeriodParser.parseStringVerbatim("1988"));
|
|
| 345 | 345 |
correctName.setFullTitleCache(null, false); |
| 346 | 346 |
Assert.assertEquals("Nepenthes glabrata J.R.Turnbull & A.T.Middleton, Sp. Pl. 1988 [as \"glabratus\"]", correctName.getFullTitleCache());
|
| 347 | 347 |
correctName.addStatus(NomenclaturalStatus.NewInstance(NomenclaturalStatusType.ILLEGITIMATE())); |
| cdmlib-model/src/test/java/eu/etaxonomy/cdm/strategy/cache/reference/DefaultReferenceCacheStrategyTest.java | ||
|---|---|---|
| 22 | 22 |
|
| 23 | 23 |
import eu.etaxonomy.cdm.model.agent.Person; |
| 24 | 24 |
import eu.etaxonomy.cdm.model.agent.Team; |
| 25 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 26 | 25 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod; |
| 27 | 26 |
import eu.etaxonomy.cdm.model.reference.IArticle; |
| 28 | 27 |
import eu.etaxonomy.cdm.model.reference.IBook; |
| ... | ... | |
| 116 | 115 |
cdDvd.setTitle(cdDvdTitle); |
| 117 | 116 |
String publisher = "An ugly publisher"; //not yet implemented |
| 118 | 117 |
String place = "A beutiful place"; //not yet implemented |
| 119 |
TimePeriod publicationDate = TimePeriod.NewInstance(1999, 2001);
|
|
| 118 |
VerbatimTimePeriod publicationDate = VerbatimTimePeriod.NewVerbatimInstance(1999, 2001);
|
|
| 120 | 119 |
cdDvd.setDatePublished(publicationDate); |
| 121 | 120 |
|
| 122 | 121 |
//Generic |
| ... | ... | |
| 140 | 139 |
article1.setTitle("My article");
|
| 141 | 140 |
article1.setInJournal(journal1); |
| 142 | 141 |
article1.setAuthorship(articleTeam1); |
| 143 |
article1.setDatePublished(TimePeriod.NewInstance(1975));
|
|
| 142 |
article1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1975));
|
|
| 144 | 143 |
Assert.assertEquals("Team1, My article in My journal. 1975", article1.getTitleCache());
|
| 145 | 144 |
|
| 146 | 145 |
article1.setInJournal(null); |
| ... | ... | |
| 157 | 156 |
article1.setTitle("My article");
|
| 158 | 157 |
article1.setInJournal(journal1); |
| 159 | 158 |
article1.setAuthorship(articleTeam1); |
| 160 |
article1.setDatePublished(TimePeriod.NewInstance(1975));
|
|
| 159 |
article1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1975));
|
|
| 161 | 160 |
Assert.assertEquals("Team1, My article in My journal. 1975", article1.getTitleCache());
|
| 162 | 161 |
|
| 163 | 162 |
article1.setInJournal(null); |
| ... | ... | |
| 172 | 171 |
article1.setTitle("My article");
|
| 173 | 172 |
article1.setInJournal(journal1); |
| 174 | 173 |
article1.setAuthorship(articleTeam1); |
| 175 |
article1.setDatePublished(TimePeriod.NewInstance(1975));
|
|
| 174 |
article1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1975));
|
|
| 176 | 175 |
Assert.assertEquals("Team1, My article in My journal. 1975", article1.getTitleCache());
|
| 177 | 176 |
article1.setPages("12-22");
|
| 178 | 177 |
Assert.assertEquals("Team1, My article in My journal: 12-22. 1975", article1.getTitleCache());
|
| ... | ... | |
| 194 | 193 |
article1.setTitle("My article");
|
| 195 | 194 |
article1.setInJournal(journal1); |
| 196 | 195 |
article1.setAuthorship(articleTeam1); |
| 197 |
article1.setDatePublished(TimePeriod.NewInstance(1975));
|
|
| 196 |
article1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1975));
|
|
| 198 | 197 |
article1.setAbbrevTitle("M. Art.");
|
| 199 | 198 |
Assert.assertEquals("T., M. Art. in M. Journ. 1975", article1.getAbbrevTitleCache()); //double dot may be removed in future #3645
|
| 200 | 199 |
|
| ... | ... | |
| 212 | 211 |
article1.setTitle("My article");
|
| 213 | 212 |
article1.setInJournal(journal1); |
| 214 | 213 |
article1.setAuthorship(articleTeam1); |
| 215 |
article1.setDatePublished(TimePeriod.NewInstance(1975));
|
|
| 214 |
article1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1975));
|
|
| 216 | 215 |
Assert.assertEquals("in M. J.: 55. 1975", article1.getNomenclaturalCitation(detail1));
|
| 217 | 216 |
|
| 218 | 217 |
article1.setVolume("22");
|
| ... | ... | |
| 233 | 232 |
article1.setVolume("22");
|
| 234 | 233 |
journal1.setAbbrevTitle("J. Pl. Eur.");
|
| 235 | 234 |
journal1.setAuthorship(articleTeam2); |
| 236 |
article1.setDatePublished(TimePeriod.NewInstance(1975));
|
|
| 235 |
article1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1975));
|
|
| 237 | 236 |
//no ser, sect, abt |
| 238 | 237 |
Assert.assertEquals("in J. Pl. Eur. 22: 55. 1975", article1.getNomenclaturalCitation(detail1));
|
| 239 | 238 |
//ser |
| ... | ... | |
| 276 | 275 |
article1.setAuthorship(articleTeam1); |
| 277 | 276 |
article1.setVolume("34");
|
| 278 | 277 |
article1.setSeriesPart("ser. 2");
|
| 279 |
article1.setDatePublished(TimePeriod.NewInstance(1975));
|
|
| 278 |
article1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1975));
|
|
| 280 | 279 |
//FIXME removed for new formatter |
| 281 | 280 |
// Assert.assertEquals("in My journal, ser. 2, 34", defaultStrategy.getTitleWithoutYearAndAuthor((Reference)article1, false));
|
| 282 | 281 |
} |
| ... | ... | |
| 291 | 290 |
article1.setInJournal(journal1); |
| 292 | 291 |
article1.setAuthorship(articleAuthor); |
| 293 | 292 |
article1.setVolume("18");
|
| 294 |
article1.setDatePublished(TimePeriod.NewInstance(1943));
|
|
| 293 |
article1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1943));
|
|
| 295 | 294 |
Assert.assertEquals("Babc. & Stebbins in Univ. Calif. Publ. Bot. 18. 1943", defaultStrategy.getTitleCache((Reference)article1));
|
| 296 | 295 |
} |
| 297 | 296 |
|
| ... | ... | |
| 301 | 300 |
public void testBookGetTitleCache0(){
|
| 302 | 301 |
book1.setTitle("My book");
|
| 303 | 302 |
book1.setAuthorship(bookTeam1); |
| 304 |
book1.setDatePublished(TimePeriod.NewInstance(1975));
|
|
| 303 |
book1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1975));
|
|
| 305 | 304 |
Assert.assertEquals("Unexpected title cache.", "Book Author, My book. 1975", book1.getTitleCache());
|
| 306 | 305 |
|
| 307 | 306 |
book1.setTitleCache(null, false); |
| 308 | 307 |
book1.setEdition("ed. 3");
|
| 309 | 308 |
Assert.assertEquals("Unexpected title cache.", "Book Author, My book, ed. 3. 1975", book1.getTitleCache());
|
| 310 | 309 |
|
| 311 |
TimePeriod newDatePublished = TimePeriodParser.parseString("1975 (after Aug.)");
|
|
| 310 |
VerbatimTimePeriod newDatePublished = TimePeriodParser.parseStringVerbatim("1975 (after Aug.)");
|
|
| 312 | 311 |
book1.setDatePublished(newDatePublished); |
| 313 | 312 |
book1.setTitleCache(null, false); |
| 314 | 313 |
//TODO this behaviour needs to be discussed. Maybe better the complete date published string should be returned. |
| ... | ... | |
| 327 | 326 |
book1.setAbbrevTitle("Acta Inst. Bot. Acad. Sci. URSS");
|
| 328 | 327 |
book1.setSeriesPart("1");
|
| 329 | 328 |
book1.setVolume("Fasc. 11");
|
| 330 |
book1.setDatePublished(TimePeriodParser.parseString("1955"));
|
|
| 329 |
book1.setDatePublished(TimePeriodParser.parseStringVerbatim("1955"));
|
|
| 331 | 330 |
Assert.assertEquals("Unexpected abbrev title cache", "Acta Inst. Bot. Acad. Sci. URSS, ser. 1, Fasc. 11. 1955", book1.getTitleCache());
|
| 332 | 331 |
Assert.assertEquals("Unexpected nomencl. reference", "Acta Inst. Bot. Acad. Sci. URSS, ser. 1, Fasc. 11: 248. 1955", book1.getNomenclaturalCitation("248"));
|
| 333 | 332 |
} |
| ... | ... | |
| 339 | 338 |
IBook book1 = ReferenceFactory.newBook(); |
| 340 | 339 |
book1.setAbbrevTitle("Acta Inst. Bot. Acad. Sci. URSS");
|
| 341 | 340 |
book1.setVolume("Fasc. 11");
|
| 342 |
book1.setDatePublished(TimePeriodParser.parseString("1955"));
|
|
| 341 |
book1.setDatePublished(TimePeriodParser.parseStringVerbatim("1955"));
|
|
| 343 | 342 |
Assert.assertEquals("Unexpected abbrev title cache", "Acta Inst. Bot. Acad. Sci. URSS Fasc. 11. 1955", book1.getTitleCache());
|
| 344 | 343 |
Assert.assertEquals("Unexpected nomencl. reference", "Acta Inst. Bot. Acad. Sci. URSS Fasc. 11: 248. 1955", book1.getNomenclaturalCitation("248"));
|
| 345 | 344 |
book1.setSeriesPart("1");
|
| ... | ... | |
| 350 | 349 |
public void testBookGetNomenclaturalCitation(){
|
| 351 | 350 |
book1.setTitle("My book");
|
| 352 | 351 |
book1.setAuthorship(bookTeam1); |
| 353 |
book1.setDatePublished(TimePeriod.NewInstance(1975));
|
|
| 352 |
book1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1975));
|
|
| 354 | 353 |
Assert.assertEquals("My book: 55. 1975", book1.getNomenclaturalCitation(detail1));
|
| 355 | 354 |
book1.setAbbrevTitle("Analect. Bot.");
|
| 356 | 355 |
Assert.assertEquals("Analect. Bot. 1975", book1.getNomenclaturalCitation(null));
|
| ... | ... | |
| 365 | 364 |
bookSection1.setTitle("My chapter");
|
| 366 | 365 |
bookSection1.setInBook(book1); |
| 367 | 366 |
bookSection1.setAuthorship(sectionTeam1); |
| 368 |
book1.setDatePublished(TimePeriod.NewInstance(1975));
|
|
| 367 |
book1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1975));
|
|
| 369 | 368 |
Assert.assertEquals("Unexpected title cache.", "Section Author - My chapter in Book Author, My book. 1975", bookSection1.getTitleCache());
|
| 370 | 369 |
book1.setDatePublished((VerbatimTimePeriod)null); |
| 371 |
bookSection1.setDatePublished(TimePeriod.NewInstance(1976));
|
|
| 370 |
bookSection1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1976));
|
|
| 372 | 371 |
bookSection1.setTitleCache(null, false); |
| 373 | 372 |
book1.setTitleCache(null, false); |
| 374 | 373 |
Assert.assertEquals("Unexpected title cache.", "Section Author - My chapter in Book Author, My book. 1976", bookSection1.getTitleCache());
|
| 375 |
book1.setDatePublished(TimePeriod.NewInstance(1977));
|
|
| 374 |
book1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1977));
|
|
| 376 | 375 |
bookSection1.setTitleCache(null, false); |
| 377 | 376 |
book1.setTitleCache(null, false); |
| 378 | 377 |
Assert.assertEquals("Unexpected title cache.", "Section Author - My chapter in Book Author, My book. 1976", bookSection1.getTitleCache());
|
| ... | ... | |
| 400 | 399 |
bookSection1.setTitle("My chapter");
|
| 401 | 400 |
bookSection1.setInBook(book1); |
| 402 | 401 |
bookSection1.setAuthorship(sectionTeam1); |
| 403 |
book1.setDatePublished(TimePeriod.NewInstance(1975));
|
|
| 402 |
book1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1975));
|
|
| 404 | 403 |
Assert.assertEquals("Unexpected title cache.", "Section Author - My chapter in Book Author, My book. 1975", bookSection1.getTitleCache());
|
| 405 | 404 |
book1.setDatePublished((VerbatimTimePeriod)null); |
| 406 |
bookSection1.setDatePublished(TimePeriod.NewInstance(1976));
|
|
| 405 |
bookSection1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1976));
|
|
| 407 | 406 |
Assert.assertEquals("Unexpected title cache.", "Section Author - My chapter in Book Author, My book. 1976", bookSection1.getTitleCache());
|
| 408 |
book1.setDatePublished(TimePeriod.NewInstance(1977));
|
|
| 407 |
book1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1977));
|
|
| 409 | 408 |
Assert.assertEquals("Unexpected title cache.", "Section Author - My chapter in Book Author, My book. 1976", bookSection1.getTitleCache());
|
| 410 | 409 |
|
| 411 | 410 |
|
| ... | ... | |
| 422 | 421 |
bookSection1.setTitle("My chapter");
|
| 423 | 422 |
bookSection1.setInBook(book1); |
| 424 | 423 |
bookSection1.setAuthorship(sectionTeam1); |
| 425 |
book1.setDatePublished(TimePeriod.NewInstance(1975));
|
|
| 424 |
book1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1975));
|
|
| 426 | 425 |
//TODO still unclear which is correct |
| 427 | 426 |
// Assert.assertEquals("in Book Author, My book: 55. 1975", bookSection1.getNomenclaturalCitation(detail1));
|
| 428 | 427 |
Assert.assertEquals("in TT., My book: 55. 1975", bookSection1.getNomenclaturalCitation(detail1));
|
| ... | ... | |
| 444 | 443 |
book.setVolume("2(3)");
|
| 445 | 444 |
book.setPlacePublished("Riyadh");
|
| 446 | 445 |
book.setPublisher("National Herbarium");
|
| 447 |
book.setDatePublished(TimePeriod.NewInstance(2000));
|
|
| 446 |
book.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(2000));
|
|
| 448 | 447 |
|
| 449 | 448 |
Team sectionTeam = Team.NewTitledInstance("Chaudhary S. A.", "Chaudhary S. A.");
|
| 450 | 449 |
IBookSection bookSection = ReferenceFactory.newBookSection(); |
| ... | ... | |
| 517 | 516 |
public void testGenericGetAbbrevTitleCache(){
|
| 518 | 517 |
generic1.setTitle("Part Title");
|
| 519 | 518 |
generic1.setAbbrevTitle("Pt. Tit.");
|
| 520 |
generic1.setDatePublished(TimePeriodParser.parseString("1987"));
|
|
| 519 |
generic1.setDatePublished(TimePeriodParser.parseStringVerbatim("1987"));
|
|
| 521 | 520 |
IBook book1 = ReferenceFactory.newBook(); |
| 522 | 521 |
book1.setTitle("My book title");
|
| 523 | 522 |
book1.setAbbrevTitle("My bk. tit.");
|
| ... | ... | |
| 548 | 547 |
Assert.assertEquals("Unexpected nom. ref.", "My prot. abb. tit. in a bk.", generic1.getNomenclaturalCitation(""));
|
| 549 | 548 |
Assert.assertEquals("Unexpected nom. ref.", "My prot. abb. tit. in a bk.: pp. 44", generic1.getNomenclaturalCitation("pp. 44"));
|
| 550 | 549 |
|
| 551 |
generic1.setDatePublished(TimePeriodParser.parseString("1893"));
|
|
| 550 |
generic1.setDatePublished(TimePeriodParser.parseStringVerbatim("1893"));
|
|
| 552 | 551 |
Assert.assertEquals("Unexpected nom. ref.", "My prot. abb. tit. in a bk.: pp. 44. 1893", generic1.getNomenclaturalCitation("pp. 44"));
|
| 553 | 552 |
|
| 554 | 553 |
} |
| ... | ... | |
| 572 | 571 |
@Test |
| 573 | 572 |
public void testGenericYearAndAuthorOnly(){
|
| 574 | 573 |
generic1.setAuthorship(genericTeam1); |
| 575 |
generic1.setDatePublished(TimePeriodParser.parseString("1792"));
|
|
| 574 |
generic1.setDatePublished(TimePeriodParser.parseStringVerbatim("1792"));
|
|
| 576 | 575 |
generic1.setTitleCache(null, false); //reset cache in case aspectJ is not enabled |
| 577 | 576 |
Assert.assertEquals("Unexpected title cache.", "Authorteam, 1792", generic1.getTitleCache());
|
| 578 | 577 |
Assert.assertEquals("1792", generic1.getNomenclaturalCitation(null));
|
| ... | ... | |
| 583 | 582 |
generic1.setAuthorship(genericTeam1); |
| 584 | 583 |
String detail = "sine no."; |
| 585 | 584 |
generic1.setAbbrevTitle("My title");
|
| 586 |
generic1.setDatePublished(TimePeriodParser.parseString("1883-1884"));
|
|
| 585 |
generic1.setDatePublished(TimePeriodParser.parseStringVerbatim("1883-1884"));
|
|
| 587 | 586 |
generic1.setTitleCache(null, false); //reset cache in case aspectJ is not enabled |
| 588 | 587 |
Assert.assertEquals("My title: sine no. 1883-1884", generic1.getNomenclaturalCitation(detail));
|
| 589 | 588 |
} |
| ... | ... | |
| 593 | 592 |
public void testGenericMissingVolume(){
|
| 594 | 593 |
generic1.setTitle("My generic");
|
| 595 | 594 |
generic1.setAuthorship(genericTeam1); |
| 596 |
generic1.setDatePublished(TimePeriodParser.parseString("1883-1884"));
|
|
| 595 |
generic1.setDatePublished(TimePeriodParser.parseStringVerbatim("1883-1884"));
|
|
| 597 | 596 |
generic1.setTitleCache(null, false); //reset cache in case aspectJ is not enabled |
| 598 | 597 |
Assert.assertEquals("My generic: 55. 1883-1884", generic1.getNomenclaturalCitation(detail1));
|
| 599 | 598 |
generic1.setVolume("7");
|
| ... | ... | |
| 606 | 605 |
generic2.setTitle("My InRef");
|
| 607 | 606 |
Person person2 = Person.NewTitledInstance("InRefAuthor");
|
| 608 | 607 |
generic2.setAuthorship(person2); |
| 609 |
generic2.setDatePublished(TimePeriodParser.parseString("1885"));
|
|
| 608 |
generic2.setDatePublished(TimePeriodParser.parseStringVerbatim("1885"));
|
|
| 610 | 609 |
generic1.setInReference(generic2); |
| 611 | 610 |
|
| 612 | 611 |
//only reference has a volume |
| ... | ... | |
| 639 | 638 |
database1.setTitle("My database");
|
| 640 | 639 |
//maybe we should have a trailing dot here |
| 641 | 640 |
Assert.assertEquals("My database: 55", reference.getNomenclaturalCitation(detail1));
|
| 642 |
database1.setDatePublished(TimePeriodParser.parseString("1998"));
|
|
| 641 |
database1.setDatePublished(TimePeriodParser.parseStringVerbatim("1998"));
|
|
| 643 | 642 |
Assert.assertEquals("My database: 55. 1998", reference.getNomenclaturalCitation(detail1));
|
| 644 | 643 |
|
| 645 | 644 |
database1.setTitleCache("Your database", true);
|
| ... | ... | |
| 656 | 655 |
cdDvd.setTitle("My Cd/Dvd");
|
| 657 | 656 |
//maybe we should have a trailing dot here |
| 658 | 657 |
Assert.assertEquals("My Cd/Dvd: 55", reference.getNomenclaturalCitation(detail1));
|
| 659 |
cdDvd.setDatePublished(TimePeriodParser.parseString("1998"));
|
|
| 658 |
cdDvd.setDatePublished(TimePeriodParser.parseStringVerbatim("1998"));
|
|
| 660 | 659 |
Assert.assertEquals("My Cd/Dvd: 55. 1998", reference.getNomenclaturalCitation(detail1));
|
| 661 | 660 |
|
| 662 | 661 |
cdDvd.setTitleCache("Your Cd/Dvd", true);
|
| ... | ... | |
| 673 | 672 |
webPage.setTitle("My WebPage");
|
| 674 | 673 |
//maybe we should have a trailing dot here |
| 675 | 674 |
Assert.assertEquals("My WebPage: 55", reference.getNomenclaturalCitation(detail1));
|
| 676 |
webPage.setDatePublished(TimePeriodParser.parseString("1998"));
|
|
| 675 |
webPage.setDatePublished(TimePeriodParser.parseStringVerbatim("1998"));
|
|
| 677 | 676 |
Assert.assertEquals("My WebPage: 55. 1998", reference.getNomenclaturalCitation(detail1));
|
| 678 | 677 |
|
| 679 | 678 |
webPage.setTitleCache("Your WebPage", true);
|
| cdmlib-model/src/test/java/eu/etaxonomy/cdm/strategy/match/DefaultMatchStrategyTest.java | ||
|---|---|---|
| 27 | 27 |
import eu.etaxonomy.cdm.model.common.Annotation; |
| 28 | 28 |
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer; |
| 29 | 29 |
import eu.etaxonomy.cdm.model.common.LSID; |
| 30 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 30 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 31 | 31 |
import eu.etaxonomy.cdm.model.location.Country; |
| 32 | 32 |
import eu.etaxonomy.cdm.model.location.Point; |
| 33 | 33 |
import eu.etaxonomy.cdm.model.location.ReferenceSystem; |
| ... | ... | |
| 57 | 57 |
private IPrintSeries printSeries1; |
| 58 | 58 |
private Annotation annotation1; |
| 59 | 59 |
private String title1 = "Title1"; |
| 60 |
private TimePeriod datePublished1 = TimePeriod.NewInstance(2000);
|
|
| 60 |
private VerbatimTimePeriod datePublished1 = VerbatimTimePeriod.NewVerbatimInstance(2000);
|
|
| 61 | 61 |
private int hasProblem1 = 1; |
| 62 | 62 |
private LSID lsid1; |
| 63 | 63 |
|
| ... | ... | |
| 70 | 70 |
private String annotationString2; |
| 71 | 71 |
private String title2 = "Title2"; |
| 72 | 72 |
private DateTime created2 = new DateTime(1999, 3, 1, 0, 0, 0, 0); |
| 73 |
private TimePeriod datePublished2 = TimePeriod.NewInstance(2002);
|
|
| 73 |
private VerbatimTimePeriod datePublished2 = VerbatimTimePeriod.NewVerbatimInstance(2002);
|
|
| 74 | 74 |
private int hasProblem2 = 1; |
| 75 | 75 |
private LSID lsid2; |
| 76 | 76 |
|
| ... | ... | |
| 278 | 278 |
//Time period |
| 279 | 279 |
bookTitle1.setTitle(title); |
| 280 | 280 |
bookTitle2.setTitle(title); |
| 281 |
bookTitle1.setDatePublished(TimePeriod.NewInstance(1999, 2002));
|
|
| 281 |
bookTitle1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1999, 2002));
|
|
| 282 | 282 |
Assert.assertFalse("Books with differing publication dates should not match", matchStrategy.invoke(bookTitle1, bookTitle2));
|
| 283 |
bookTitle2.setDatePublished(TimePeriod.NewInstance(1998));
|
|
| 283 |
bookTitle2.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1998));
|
|
| 284 | 284 |
Assert.assertFalse("Books with differing publication dates should not match", matchStrategy.invoke(bookTitle1, bookTitle2));
|
| 285 |
bookTitle2.setDatePublished(TimePeriod.NewInstance(1999));
|
|
| 285 |
bookTitle2.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1999));
|
|
| 286 | 286 |
Assert.assertFalse("Books with differing publication dates should not match", matchStrategy.invoke(bookTitle1, bookTitle2));
|
| 287 |
bookTitle2.setDatePublished(TimePeriod.NewInstance(1999, 2002));
|
|
| 287 |
bookTitle2.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1999, 2002));
|
|
| 288 | 288 |
Assert.assertTrue("Books with same publication dates should match", matchStrategy.invoke(bookTitle1, bookTitle2));
|
| 289 | 289 |
|
| 290 | 290 |
//BookSection |
| cdmlib-model/src/test/java/eu/etaxonomy/cdm/strategy/merge/DefaultMergeStrategyTest.java | ||
|---|---|---|
| 33 | 33 |
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer; |
| 34 | 34 |
import eu.etaxonomy.cdm.model.common.LSID; |
| 35 | 35 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
| 36 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod; |
|
| 36 | 37 |
import eu.etaxonomy.cdm.model.description.TaxonNameDescription; |
| 37 | 38 |
import eu.etaxonomy.cdm.model.location.Country; |
| 38 | 39 |
import eu.etaxonomy.cdm.model.location.Point; |
| ... | ... | |
| 66 | 67 |
private Reference printSeries1; |
| 67 | 68 |
private Annotation annotation1; |
| 68 | 69 |
private String title1 = "Title1"; |
| 69 |
private TimePeriod datePublished1 = TimePeriod.NewInstance(2000);
|
|
| 70 |
private VerbatimTimePeriod datePublished1 = VerbatimTimePeriod.NewVerbatimInstance(2000);
|
|
| 70 | 71 |
private int hasProblem1 = 1; |
| 71 | 72 |
private LSID lsid1; |
| 72 | 73 |
|
| ... | ... | |
| 79 | 80 |
private String annotationString2; |
| 80 | 81 |
private String title2 = "Title2"; |
| 81 | 82 |
private DateTime created2 = new DateTime(1999, 3, 1, 0, 0, 0, 0); |
| 82 |
private TimePeriod datePublished2 = TimePeriod.NewInstance(2002);
|
|
| 83 |
private VerbatimTimePeriod datePublished2 = VerbatimTimePeriod.NewVerbatimInstance(2002);
|
|
| 83 | 84 |
private int hasProblem2 = 1; |
| 84 | 85 |
private LSID lsid2; |
| 85 | 86 |
|
| cdmlib-model/src/test/java/eu/etaxonomy/cdm/test/function/strategy/TestBookDefaultCacheStrategies.java | ||
|---|---|---|
| 12 | 12 |
import java.util.Calendar; |
| 13 | 13 |
|
| 14 | 14 |
import eu.etaxonomy.cdm.model.agent.Person; |
| 15 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 15 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 16 | 16 |
import eu.etaxonomy.cdm.model.media.Media; |
| 17 | 17 |
import eu.etaxonomy.cdm.model.reference.IGeneric; |
| 18 | 18 |
import eu.etaxonomy.cdm.model.reference.Reference; |
| ... | ... | |
| 32 | 32 |
book.setTitle("TestTitel eines Buches");
|
| 33 | 33 |
Calendar cal = Calendar.getInstance(); |
| 34 | 34 |
|
| 35 |
book.setDatePublished(TimePeriod.NewInstance(cal));
|
|
| 35 |
book.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(cal));
|
|
| 36 | 36 |
Person bookAuthor = Person.NewTitledInstance("BuchAuthorTitle");
|
| 37 | 37 |
book.setAuthorship(bookAuthor); |
| 38 | 38 |
book.setVolume("v 22");
|
| ... | ... | |
| 56 | 56 |
inJournal.setAuthorship(journalAuthor); |
| 57 | 57 |
inJournal.setTitle("JournalTitle");
|
| 58 | 58 |
inJournal.setIssn("issn");
|
| 59 |
Reference article = ReferenceFactory.newArticle(inJournal, partAuthor, "artTitel", "123-456", "ser4", "55", TimePeriod.NewInstance(cal));
|
|
| 59 |
Reference article = ReferenceFactory.newArticle(inJournal, partAuthor, "artTitel", "123-456", "ser4", "55", VerbatimTimePeriod.NewVerbatimInstance(cal));
|
|
| 60 | 60 |
System.out.println("FULL: " + article.getNomenclaturalCitation("922 fig"));
|
| 61 | 61 |
System.out.println("Citation: " + article.getCitation());
|
| 62 | 62 |
System.out.println("Titel: " + article.getTitleCache());
|
| ... | ... | |
| 67 | 67 |
Person genericAuthor = Person.NewTitledInstance("GenericAuthorTitle");
|
| 68 | 68 |
generic.setAuthorship(genericAuthor); |
| 69 | 69 |
generic.setTitle("GenericTitle");
|
| 70 |
generic.setDatePublished(TimePeriod.NewInstance(cal));
|
|
| 70 |
generic.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(cal));
|
|
| 71 | 71 |
generic.setEditor("EditorString");
|
| 72 | 72 |
|
| 73 | 73 |
generic.setPages("p.124-754");
|
| cdmlib-model/src/test/java/eu/etaxonomy/cdm/validation/ValidTaxonomicYearTest.java | ||
|---|---|---|
| 61 | 61 |
name.setTitleCache("Aus aus L.", true);
|
| 62 | 62 |
|
| 63 | 63 |
beforeLineeRef = ReferenceFactory.newBook(); |
| 64 |
beforeLineeRef.setDatePublished(TimePeriodParser.parseString("1752"));
|
|
| 64 |
beforeLineeRef.setDatePublished(TimePeriodParser.parseStringVerbatim("1752"));
|
|
| 65 | 65 |
|
| 66 | 66 |
afterLineeRef = ReferenceFactory.newBook(); |
| 67 |
afterLineeRef.setDatePublished(TimePeriodParser.parseString("1754"));
|
|
| 67 |
afterLineeRef.setDatePublished(TimePeriodParser.parseStringVerbatim("1754"));
|
|
| 68 | 68 |
|
| 69 | 69 |
} |
| 70 | 70 |
|
| cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/database/data/FullCoverageDataGenerator.java | ||
|---|---|---|
| 696 | 696 |
reference.setAuthorship(author); |
| 697 | 697 |
reference.setTitle("ref title");
|
| 698 | 698 |
reference.setAbbrevTitle("abbrev title");
|
| 699 |
reference.setDatePublished(TimePeriodParser.parseString("1999"));
|
|
| 699 |
reference.setDatePublished(TimePeriodParser.parseStringVerbatim("1999"));
|
|
| 700 | 700 |
reference.setEdition("edition");
|
| 701 | 701 |
reference.setEditor("editor");
|
| 702 | 702 |
Institution institution = Institution.NewInstance(); |
| cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/common/CdmGenericDaoImplTest.java | ||
|---|---|---|
| 69 | 69 |
import eu.etaxonomy.cdm.model.common.TermVocabulary; |
| 70 | 70 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
| 71 | 71 |
import eu.etaxonomy.cdm.model.common.User; |
| 72 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod; |
|
| 72 | 73 |
import eu.etaxonomy.cdm.model.description.CategoricalData; |
| 73 | 74 |
import eu.etaxonomy.cdm.model.description.CommonTaxonName; |
| 74 | 75 |
import eu.etaxonomy.cdm.model.description.DescriptionBase; |
| ... | ... | |
| 1048 | 1049 |
Assert.assertEquals("Resultlist must have 1 entries", 1, matchResult.size());
|
| 1049 | 1050 |
Assert.assertSame("Resultlist entry must be book 1", book1, matchResult.get(0));
|
| 1050 | 1051 |
|
| 1051 |
book1.setDatePublished(TimePeriod.NewInstance(1999, 2002));
|
|
| 1052 |
book1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1999, 2002));
|
|
| 1052 | 1053 |
matchResult = cdmGenericDao.findMatching(book3, matchStrategy); |
| 1053 | 1054 |
Assert.assertTrue("Resultlist must have no entries", matchResult.isEmpty());
|
| 1054 | 1055 |
|
| 1055 |
book3.setDatePublished(TimePeriod.NewInstance(1999));
|
|
| 1056 |
book3.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1999));
|
|
| 1056 | 1057 |
matchResult = cdmGenericDao.findMatching(book3, matchStrategy); |
| 1057 | 1058 |
Assert.assertTrue("Resultlist must have no entries", matchResult.isEmpty());
|
| 1058 | 1059 |
|
| 1059 |
book3.setDatePublished(TimePeriod.NewInstance(1999,2002));
|
|
| 1060 |
book3.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1999,2002));
|
|
| 1060 | 1061 |
matchResult = cdmGenericDao.findMatching(book3, matchStrategy); |
| 1061 | 1062 |
Assert.assertEquals("Resultlist must have 1 entries", 1, matchResult.size());
|
| 1062 | 1063 |
Assert.assertSame("Resultlist entry must be book 1", book1, matchResult.get(0));
|
| cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/hibernate/CacheStrategyGeneratorTest.java | ||
|---|---|---|
| 28 | 28 |
import eu.etaxonomy.cdm.model.agent.Person; |
| 29 | 29 |
import eu.etaxonomy.cdm.model.agent.Team; |
| 30 | 30 |
import eu.etaxonomy.cdm.model.common.DefinedTerm; |
| 31 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 31 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 32 | 32 |
import eu.etaxonomy.cdm.model.molecular.Amplification; |
| 33 | 33 |
import eu.etaxonomy.cdm.model.name.IBotanicalName; |
| 34 | 34 |
import eu.etaxonomy.cdm.model.name.Rank; |
| ... | ... | |
| 234 | 234 |
article1.setUuid(UUID.fromString("eb090fbc-5895-405c-aba5-cac287efb128"));
|
| 235 | 235 |
article1.setAbbrevTitle("M. Art.");
|
| 236 | 236 |
article1.setVolume("1");
|
| 237 |
article1.setDatePublished(TimePeriod.NewInstance(1972));
|
|
| 237 |
article1.setDatePublished(VerbatimTimePeriod.NewVerbatimInstance(1972));
|
|
| 238 | 238 |
article1.setInJournal(journal1); |
| 239 | 239 |
article1.setAuthorship(articleAuthor); |
| 240 | 240 |
article1.getAbbrevTitleCache(); |
| cdmlib-remote/src/test/java/eu/etaxonomy/cdm/remote/dto/assembler/lsid/AssemblerTest.java | ||
|---|---|---|
| 46 | 46 |
import eu.etaxonomy.cdm.model.common.LSID; |
| 47 | 47 |
import eu.etaxonomy.cdm.model.common.Language; |
| 48 | 48 |
import eu.etaxonomy.cdm.model.common.LanguageString; |
| 49 |
import eu.etaxonomy.cdm.model.common.TimePeriod; |
|
| 49 |
import eu.etaxonomy.cdm.model.common.VerbatimTimePeriod;
|
|
| 50 | 50 |
import eu.etaxonomy.cdm.model.description.Distribution; |
| 51 | 51 |
import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm; |
| 52 | 52 |
import eu.etaxonomy.cdm.model.description.TaxonDescription; |
| ... | ... | |
| 156 | 156 |
book.setTitle("Book.title");
|
| 157 | 157 |
book.setAuthorship(authorship); |
| 158 | 158 |
book.setCreated(new DateTime(2004, 12, 25, 12, 0, 0, 0)); |
| 159 |
book.setDatePublished(new TimePeriod(new Partial(DateTimeFieldType.year(), 1800))); |
|
| 159 |
book.setDatePublished(new VerbatimTimePeriod(new Partial(DateTimeFieldType.year(), 1800)));
|
|
| 160 | 160 |
book.setEdition("1st Edition");
|
| 161 | 161 |
book.setEditor("Editor");
|
| 162 | 162 |
book.setIsbn("isbn");
|
| ... | ... | |
| 174 | 174 |
bookSection.setTitle("BookSection.title");
|
| 175 | 175 |
bookSection.setAuthorship(authorship); |
| 176 | 176 |
bookSection.setCreated(new DateTime(2004, 12, 25, 12, 0, 0, 0)); |
| 177 |
bookSection.setDatePublished(new TimePeriod(new Partial(DateTimeFieldType.year(), 1800))); |
|
| 177 |
bookSection.setDatePublished(new VerbatimTimePeriod(new Partial(DateTimeFieldType.year(), 1800)));
|
|
| 178 | 178 |
bookSection.setReferenceAbstract("referenceAbstract");
|
| 179 | 179 |
bookSection.setUri(new URI("http://persitent.books.foo/myBookSection"));
|
| 180 | 180 |
bookSection.setUuid(UUID.randomUUID()); |
Also available in: Unified diff
ref #6752 stricter handling of Reference.setDatePublished (only for calling methods)