cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/tcs/TcsTaxonNameIO.java

   1 package eu.etaxonomy.cdm.io.tcs;
   2
   3 import java.util.Calendar;
   4 import java.util.List;
   5 import java.util.Map;
   6
   7 import org.apache.log4j.Logger;
   8 import org.jdom.Attribute;
   9 import org.jdom.Element;
  10 import org.jdom.Namespace;
  11
  12 import eu.etaxonomy.cdm.api.application.CdmApplicationController;
  13 import eu.etaxonomy.cdm.api.service.INameService;
  14 import eu.etaxonomy.cdm.common.XmlHelp;
  15 import eu.etaxonomy.cdm.io.common.CdmIoBase;
  16 import eu.etaxonomy.cdm.io.common.ICdmIO;
  17 import eu.etaxonomy.cdm.io.common.IImportConfigurator;
  18 import eu.etaxonomy.cdm.io.common.ImportHelper;
  19 import eu.etaxonomy.cdm.io.common.MapWrapper;
  20 import eu.etaxonomy.cdm.model.agent.INomenclaturalAuthor;
  21 import eu.etaxonomy.cdm.model.agent.Team;
  22 import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
  23 import eu.etaxonomy.cdm.model.common.CdmBase;
  24 import eu.etaxonomy.cdm.model.common.TimePeriod;
  25 import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
  26 import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
  27 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  28 import eu.etaxonomy.cdm.model.name.NonViralName;
  29 import eu.etaxonomy.cdm.model.name.Rank;
  30 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  31 import eu.etaxonomy.cdm.model.reference.Generic;
  32 import eu.etaxonomy.cdm.model.reference.ReferenceBase;
  33 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  34 import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;
  35
  36
  37 public class TcsTaxonNameIO  extends CdmIoBase implements ICdmIO {
  38         private static final Logger logger = Logger.getLogger(TcsTaxonNameIO.class);
  39
  40         private static int modCount = 5000;
  41
  42         public TcsTaxonNameIO(){
  43                 super();
  44         }
  45
  46         @Override
  47         public boolean doCheck(IImportConfigurator config){
  48                 boolean result = true;
  49                 logger.warn("BasionymRelations not yet implemented");
  50                 logger.warn("Checking for TaxonNames not yet implemented");
  51                 //result &= checkArticlesWithoutJournal(tcsConfig);
  52                 //result &= checkPartOfJournal(tcsConfig);
  53
  54                 return result;
  55         }
  56
  57         @Override
  58         public boolean doInvoke(IImportConfigurator config, CdmApplicationController cdmApp, Map<String, MapWrapper<? extends CdmBase>> stores){
  59
  60                 MapWrapper<TaxonNameBase> taxonNameMap = (MapWrapper<TaxonNameBase>)stores.get(ICdmIO.TAXONNAME_STORE);
  61                 MapWrapper<ReferenceBase> referenceMap = (MapWrapper<ReferenceBase>)stores.get(ICdmIO.REFERENCE_STORE);
  62                 MapWrapper<TeamOrPersonBase> authorMap = (MapWrapper<TeamOrPersonBase>)stores.get(ICdmIO.AUTHOR_STORE);
  63
  64                 String tcsElementName;
  65                 Namespace tcsNamespace;
  66                 String cdmAttrName;
  67                 String value;
  68
  69                 logger.info("start makeTaxonNames ...");
  70                 TcsImportConfigurator tcsConfig = (TcsImportConfigurator)config;
  71                 Element root = tcsConfig.getSourceRoot();
  72                 boolean success =true;
  73                 INameService nameService = cdmApp.getNameService();
  74
  75                 Namespace rdfNamespace = root.getNamespace();
  76                 String prefix = "tn";
  77                 Namespace taxonNameNamespace = root.getNamespace(prefix);
  78                 prefix = "tc";
  79                 Namespace taxonConceptNamespace = root.getNamespace(prefix);
  80                 prefix = "tcom";
  81                 Namespace commonNamespace = root.getNamespace(prefix);
  82                 //String strTnNamespace = "http://rs.tdwg.org/ontology/voc/TaxonName#";
  83                 //Namespace taxonNameNamespace = Namespace.getNamespace("tn", strTnNamespace);
  84
  85                 List<Element> elTaxonNames = root.getChildren("TaxonName", taxonNameNamespace);
  86
  87
  88                 int i = 0;
  89                 //for each taxonName
  90                 for (Element elTaxonName : elTaxonNames){
  91
  92                         if ((i++ % modCount) == 0){ logger.info("Names handled: " + (i-1));}
  93
  94                         Attribute about = elTaxonName.getAttribute("about", rdfNamespace);
  95
  96                         //create TaxonName element
  97                         String nameAbout = elTaxonName.getAttributeValue("about", rdfNamespace);
  98                         String strRank = XmlHelp.getChildAttributeValue(elTaxonName, "rank", taxonNameNamespace, "resource", rdfNamespace);
  99                         String strNomenclaturalCode = XmlHelp.getChildAttributeValue(elTaxonName, "nomenclaturalCode", taxonNameNamespace, "resource", rdfNamespace);
 100
 101                         try {
 102                                 Rank rank = TcsTransformer.rankString2Rank(strRank);
 103                                 NomenclaturalCode nomCode = TcsTransformer.nomCodeString2NomCode(strNomenclaturalCode);
 104                                 TaxonNameBase nameBase = nomCode.getNewTaxonNameInstance(rank);
 105
 106                                 //Epethita
 107                                 tcsElementName = "genusPart";
 108                                 tcsNamespace = taxonNameNamespace;
 109                                 cdmAttrName = "genusOrUninomial";
 110                                 success &= ImportHelper.addXmlStringValue(elTaxonName, nameBase, tcsElementName, tcsNamespace, cdmAttrName);
 111
 112                                 tcsElementName = "specificEpithet";
 113                                 tcsNamespace = taxonNameNamespace;
 114                                 cdmAttrName = "specificEpithet";
 115                                 success &= ImportHelper.addXmlStringValue(elTaxonName, nameBase, tcsElementName, tcsNamespace, cdmAttrName);
 116
 117                                 tcsElementName = "infraspecificEpithet";
 118                                 tcsNamespace = taxonNameNamespace;
 119                                 cdmAttrName = "infraSpecificEpithet";
 120                                 success &= ImportHelper.addXmlStringValue(elTaxonName, nameBase, tcsElementName, tcsNamespace, cdmAttrName);
 121
 122                                 tcsElementName = "infragenericEpithet";
 123                                 tcsNamespace = taxonNameNamespace;
 124                                 cdmAttrName = "infraGenericEpithet";
 125                                 success &= ImportHelper.addXmlStringValue(elTaxonName, nameBase, tcsElementName, tcsNamespace, cdmAttrName);
 126
 127                                 //Reference
 128                                 //TODO
 129                                 tcsElementName = "publishedIn";
 130                                 tcsNamespace = commonNamespace;
 131                                 value = (String)ImportHelper.getXmlInputValue(elTaxonName, tcsElementName, tcsNamespace);
 132                                 if (value != null){
 133                                         Generic nomRef = Generic.NewInstance(); //TODO
 134                                         nomRef.setTitleCache(value);
 135                                         nameBase.setNomenclaturalReference(nomRef);
 136
 137                                         //TODO
 138                                         tcsElementName = "year";
 139                                         tcsNamespace = taxonNameNamespace;
 140                                         Integer year = null;
 141                                         try {
 142                                                 value = (String)ImportHelper.getXmlInputValue(elTaxonName, tcsElementName, tcsNamespace);
 143                                                 year = Integer.valueOf(value);
 144                                                 Calendar cal = Calendar.getInstance();
 145                                                 //FIXME
 146                                                 cal.set(year, 1, 1);
 147                                                 nomRef.setDatePublished(TimePeriod.NewInstance(cal));
 148                                         } catch (RuntimeException e) {
 149                                                 logger.warn("year could not be parsed");
 150                                         }
 151                                 }
 152
 153
 154
 155                                 //microReference
 156                                 tcsElementName = "microReference";
 157                                 tcsNamespace = commonNamespace;
 158                                 cdmAttrName = "nomenclaturalMicroReference";
 159                                 success &= ImportHelper.addXmlStringValue(elTaxonName, nameBase, tcsElementName, tcsNamespace, cdmAttrName);
 160
 161                                 //Status
 162                                 tcsNamespace = taxonNameNamespace;
 163                                 Element elAnnotation = elTaxonName.getChild("hasAnnotation", tcsNamespace);
 164                                 if (elAnnotation != null){
 165                                         Element elNomenclaturalNote = elAnnotation.getChild("NomenclaturalNote", tcsNamespace);
 166                                         if (elNomenclaturalNote != null){
 167                                                 String statusValue = (String)ImportHelper.getXmlInputValue(elNomenclaturalNote, "note", tcsNamespace);
 168                                                 String type = XmlHelp.getChildAttributeValue(elNomenclaturalNote, "type", taxonConceptNamespace, "resource", rdfNamespace);
 169                                                 String tdwgType = "http://rs.tdwg.org/ontology/voc/TaxonName#PublicationStatus";
 170                                                 if (tdwgType.equalsIgnoreCase(type)){
 171                                                         try {
 172                                                                 //NomenclaturalStatusType statusType = TaxonXTransformer.nomStatusString2NomStatus(statusValue);
 173                                                                 NomenclaturalStatusType statusType = NomenclaturalStatusType.getNomenclaturalStatusTypeByAbbreviation(statusValue);
 174                                                                 if (statusType != null){
 175                                                                         nameBase.addStatus(NomenclaturalStatus.NewInstance(statusType));
 176                                                                 }
 177                                                         } catch (UnknownCdmTypeException e) {
 178                                                                 if (! statusValue.equals("valid")){
 179                                                                         logger.warn("Unknown NomenclaturalStatusType: " +  statusValue);
 180                                                                 }
 181                                                         }
 182                                                 }
 183                                         }
 184                                 }
 185
 186                                 if (nameBase instanceof NonViralName){
 187                                         NonViralName nonViralName = (NonViralName)nameBase;
 188
 189                                         //AuthorTeams
 190                                         //TODO
 191                                         tcsElementName = "basionymAuthorship";
 192                                         value = (String)ImportHelper.getXmlInputValue(elTaxonName, tcsElementName, taxonNameNamespace);
 193                                         if (value != null){
 194                                                 INomenclaturalAuthor basionymAuthor = Team.NewInstance();
 195                                                 basionymAuthor.setNomenclaturalTitle(value);
 196                                                 nonViralName.setBasionymAuthorTeam(basionymAuthor);
 197                                         }
 198
 199                                         //TODO
 200                                         tcsElementName = "combinationAuthorship";
 201                                         value = (String)ImportHelper.getXmlInputValue(elTaxonName, tcsElementName, taxonNameNamespace);
 202                                         if (value != null){
 203                                                 INomenclaturalAuthor combinationAuthor = Team.NewInstance();
 204                                                 combinationAuthor.setNomenclaturalTitle(value);
 205                                                 nonViralName.setCombinationAuthorTeam(combinationAuthor);
 206                                         }
 207
 208                                 }
 209                                 //nameId
 210                                 //TODO
 211                                 //ImportHelper.setOriginalSource(nameBase, tcsConfig.getSourceReference(), nameId);
 212                                 taxonNameMap.put(nameAbout, nameBase);
 213
 214                         } catch (UnknownCdmTypeException e) {
 215                                 //FIXME
 216                                 logger.warn("Name with id " + nameAbout + " has unknown rank " + strRank + " and could not be saved.");
 217                                 success = false;
 218                         }
 219                 }
 220                 logger.info(i + " names handled");
 221                 nameService.saveTaxonNameAll(taxonNameMap.objects());
 222 //              makeNameSpecificData(nameMap);
 223                 logger.info("end makeTaxonNames ...");
 224                 return success;
 225
 226         }
 227         /* (non-Javadoc)
 228          * @see eu.etaxonomy.cdm.io.common.CdmIoBase#isIgnore(eu.etaxonomy.cdm.io.common.IImportConfigurator)
 229          */
 230         protected boolean isIgnore(IImportConfigurator config){
 231                 return ! config.isDoTaxonNames();
 232         }
 233 }