1
2
3
4
5
6
7
8
9
10 package eu.etaxonomy.cdm.io.berlinModel.in;
11
12 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_HETEROTYPIC_SYNONYM_OF;
13 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_HOMOTYPIC_SYNONYM_OF;
14 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_INCLUDED_IN;
15 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_MISAPPLIED_NAME_OF;
16 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_PARTIAL_HETEROTYPIC_SYNONYM_OF;
17 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_PARTIAL_HOMOTYPIC_SYNONYM_OF;
18 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_PARTIAL_SYN_OF;
19 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_PROPARTE_HETEROTYPIC_SYNONYM_OF;
20 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_PROPARTE_HOMOTYPIC_SYNONYM_OF;
21 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_PROPARTE_SYN_OF;
22 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_SYNONYM_OF;
23
24 import java.sql.ResultSet;
25 import java.sql.SQLException;
26 import java.util.HashMap;
27 import java.util.HashSet;
28 import java.util.Map;
29 import java.util.Set;
30 import java.util.UUID;
31
32 import org.apache.log4j.Logger;
33 import org.springframework.stereotype.Component;
34
35 import eu.etaxonomy.cdm.common.CdmUtils;
36 import eu.etaxonomy.cdm.common.ResultWrapper;
37 import eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer;
38 import eu.etaxonomy.cdm.io.berlinModel.in.validation.BerlinModelTaxonRelationImportValidator;
39 import eu.etaxonomy.cdm.io.common.IOValidator;
40 import eu.etaxonomy.cdm.io.common.ResultSetPartitioner;
41 import eu.etaxonomy.cdm.io.common.Source;
42 import eu.etaxonomy.cdm.model.common.AnnotatableEntity;
43 import eu.etaxonomy.cdm.model.common.CdmBase;
44 import eu.etaxonomy.cdm.model.common.IdentifiableSource;
45 import eu.etaxonomy.cdm.model.reference.ReferenceBase;
46 import eu.etaxonomy.cdm.model.taxon.Synonym;
47 import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
48 import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
49 import eu.etaxonomy.cdm.model.taxon.Taxon;
50 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
51 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
52 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
53 import eu.etaxonomy.cdm.model.taxon.TaxonomicTree;
54 import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;
55
56
57
58
59
60
61 @Component
62 public class BerlinModelTaxonRelationImport extends BerlinModelImportBase {
63 private static final Logger logger = Logger.getLogger(BerlinModelTaxonRelationImport.class);
64
65 public static final String TREE_NAMESPACE = "PTRefFk";
66
67 private static int modCount = 30000;
68 private static final String pluralString = "taxon relations";
69 private static final String dbTableName = "RelPTaxon";
70
71
72 public BerlinModelTaxonRelationImport(){
73 super();
74 }
75
76
77
78
79
80
81
82
83 private boolean makeTaxonomicTrees(BerlinModelImportState state) throws SQLException{
84 logger.info("start make taxonomic tree ...");
85 Source source = state.getConfig().getSource();
86
87 Set<String> idSet = getTreeReferenceIdSet(source);
88
89
90 String nameSpace = BerlinModelReferenceImport.NOM_REFERENCE_NAMESPACE;
91 Class cdmClass = ReferenceBase.class;
92 idSet = new HashSet<String>();
93 Map<String, ReferenceBase> nomRefMap = (Map<String, ReferenceBase>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
94
95
96 nameSpace = BerlinModelReferenceImport.BIBLIO_REFERENCE_NAMESPACE;
97 cdmClass = ReferenceBase.class;
98
99 Map<String, ReferenceBase> biblioRefMap = (Map<String, ReferenceBase>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
100
101 ResultSet rs = source.getResultSet(getTaxonomicTreeQuery()) ;
102 int i = 0;
103
104 try {
105 while (rs.next()){
106
107 if ((i++ % modCount) == 0 && i!= 1 ){ logger.info("RelPTaxa handled: " + (i-1));}
108
109 Object ptRefFkObj = rs.getObject("PTRefFk");
110 String ptRefFk= String.valueOf(ptRefFkObj);
111 ReferenceBase<?> ref = getReferenceOnlyFromMaps(biblioRefMap, nomRefMap, ptRefFk);
112
113 rs.getString("RefCache");
114 String treeName = "TaxonTree - No Name";
115 String refCache = rs.getString("RefCache");
116 if (CdmUtils.isNotEmpty(refCache)){
117 treeName = refCache;
118 }
119 if (ref != null && CdmUtils.isNotEmpty(ref.getTitleCache())){
120 treeName = ref.getTitleCache();
121 }
122 TaxonomicTree tree = TaxonomicTree.NewInstance(treeName);
123 tree.setReference(ref);
124 if (i == 1 && state.getConfig().getTaxonomicTreeUuid() != null){
125 tree.setUuid(state.getConfig().getTaxonomicTreeUuid());
126 }
127 IdentifiableSource identifiableSource = IdentifiableSource.NewInstance(ptRefFk, TREE_NAMESPACE);
128 tree.addSource(identifiableSource);
129
130 getTaxonTreeService().save(tree);
131 state.putTaxonomicTreeUuidInt((Integer)ptRefFkObj, tree);
132 }
133 } catch (SQLException e) {
134 logger.error("Error in BerlinModleTaxonRelationImport.makeTaxonomicTrees: " + e.getMessage());
135 throw e;
136 }
137 logger.info("end make taxonomic tree ...");
138
139 return true;
140 }
141
142
143
144
145
146 private Set<String> getTreeReferenceIdSet(Source source) throws SQLException {
147 Set<String> result = new HashSet<String>();
148 ResultSet rs = source.getResultSet(getTaxonomicTreeQuery()) ;
149 while (rs.next()){
150 Object id = rs.getObject("PTRefFk");
151 result.add(String.valueOf(id));
152 }
153 return result;
154 }
155
156
157
158
159 private String getTaxonomicTreeQuery() {
160 String strQuery = "SELECT PTaxon.PTRefFk, Reference.RefCache " +
161 " FROM RelPTaxon INNER JOIN " +
162 " PTaxon AS PTaxon ON RelPTaxon.PTNameFk2 = PTaxon.PTNameFk AND RelPTaxon.PTRefFk2 = PTaxon.PTRefFk INNER JOIN " +
163 " Reference ON PTaxon.PTRefFk = Reference.RefId " +
164 " WHERE (RelPTaxon.RelQualifierFk = 1) " +
165 " GROUP BY PTaxon.PTRefFk, Reference.RefCache ";
166 return strQuery;
167 }
168
169
170
171
172
173 @Override
174 protected String getRecordQuery(BerlinModelImportConfigurator config) {
175 String strQuery =
176 " SELECT RelPTaxon.*, FromTaxon.RIdentifier as taxon1Id, ToTaxon.RIdentifier as taxon2Id, ToTaxon.PTRefFk as treeRefFk, q.is_concept_relation " +
177 " FROM PTaxon as FromTaxon " +
178 " INNER JOIN RelPTaxon ON FromTaxon.PTNameFk = RelPTaxon.PTNameFk1 AND FromTaxon.PTRefFk = RelPTaxon.PTRefFk1 " +
179 " INNER JOIN PTaxon AS ToTaxon ON RelPTaxon.PTNameFk2 = ToTaxon.PTNameFk AND RelPTaxon.PTRefFk2 = ToTaxon.PTRefFk " +
180 " INNER JOIN RelPTQualifier q ON q.RelPTQualifierId = RelPTaxon.RelQualifierFk " +
181 " WHERE RelPTaxon.RelPTaxonId IN ("+ID_LIST_TOKEN+") ";
182 return strQuery;
183 }
184
185
186
187
188 public boolean doPartition(ResultSetPartitioner partitioner, BerlinModelImportState state) {
189 boolean success = true ;
190 BerlinModelImportConfigurator config = state.getConfig();
191 Set<TaxonBase> taxaToSave = new HashSet<TaxonBase>();
192 Map<String, TaxonBase> taxonMap = (Map<String, TaxonBase>) partitioner.getObjectMap(BerlinModelTaxonImport.NAMESPACE);
193 Map<Integer, TaxonomicTree> taxonTreeMap = new HashMap<Integer, TaxonomicTree>();
194 Map<String, ReferenceBase> biblioRefMap = (Map<String, ReferenceBase>) partitioner.getObjectMap(BerlinModelReferenceImport.BIBLIO_REFERENCE_NAMESPACE);
195 Map<String, ReferenceBase> nomRefMap = (Map<String, ReferenceBase>) partitioner.getObjectMap(BerlinModelReferenceImport.NOM_REFERENCE_NAMESPACE);
196
197 ResultSet rs = partitioner.getResultSet();
198
199 try{
200 int i = 0;
201
202 while (rs.next()){
203
204 if ((i++ % modCount) == 0 && i!= 1 ){ logger.info("RelPTaxa handled: " + (i-1));}
205
206 int relPTaxonId = rs.getInt("RelPTaxonId");
207 int taxon1Id = rs.getInt("taxon1Id");
208 int taxon2Id = rs.getInt("taxon2Id");
209 Object relRefFkObj = rs.getObject("relRefFk");
210 int treeRefFk = rs.getInt("treeRefFk");
211 int relQualifierFk = rs.getInt("relQualifierFk");
212 String notes = rs.getString("notes");
213 boolean isConceptRelationship = rs.getBoolean("is_concept_relation");
214
215 TaxonBase taxon1 = taxonMap.get(String.valueOf(taxon1Id));
216 TaxonBase taxon2 = taxonMap.get(String.valueOf(taxon2Id));
217
218 String refFk = String.valueOf(relRefFkObj);
219 ReferenceBase citation = getReferenceOnlyFromMaps(biblioRefMap, nomRefMap, refFk);
220
221 String microcitation = null;
222
223 if (taxon2 != null && taxon1 != null){
224 if (!(taxon2 instanceof Taxon)){
225 logger.error("TaxonBase (ID = " + taxon2.getId()+ ", RIdentifier = " + taxon2Id + ") can't be casted to Taxon");
226 success = false;
227 continue;
228 }
229 AnnotatableEntity taxonRelationship = null;
230 Taxon toTaxon = (Taxon)taxon2;
231 if (isTaxonRelationship(relQualifierFk)){
232 if (!(taxon1 instanceof Taxon)){
233 logger.error("TaxonBase (ID = " + taxon1.getId()+ ", RIdentifier = " + taxon1Id + ") can't be casted to Taxon");
234 success = false;
235 continue;
236 }
237 Taxon fromTaxon = (Taxon)taxon1;
238 if (relQualifierFk == TAX_REL_IS_INCLUDED_IN){
239 taxonRelationship = makeTaxonomicallyIncluded(state, taxonTreeMap, treeRefFk, fromTaxon, toTaxon, citation, microcitation);
240 }else if (relQualifierFk == TAX_REL_IS_MISAPPLIED_NAME_OF){
241 taxonRelationship = toTaxon.addMisappliedName(fromTaxon, citation, microcitation);
242 }
243 }else if (isSynonymRelationship(relQualifierFk)){
244 if (!(taxon1 instanceof Synonym)){
245 logger.error("Taxon (ID = " + taxon1.getId()+ ", RIdentifier = " + taxon1Id + ") can't be casted to Synonym");
246 success = false;
247 continue;
248 }
249 Synonym synonym = (Synonym)taxon1;
250 SynonymRelationship synRel = getSynRel(relQualifierFk, toTaxon, synonym, citation, microcitation);
251 taxonRelationship = synRel;
252
253 if (relQualifierFk == TAX_REL_IS_SYNONYM_OF ||
254 relQualifierFk == TAX_REL_IS_HOMOTYPIC_SYNONYM_OF ||
255 relQualifierFk == TAX_REL_IS_HETEROTYPIC_SYNONYM_OF){
256 addProParteAndPartial(synRel, synonym, config);
257 }else if (relQualifierFk == TAX_REL_IS_PROPARTE_SYN_OF ||
258 relQualifierFk == TAX_REL_IS_PROPARTE_HOMOTYPIC_SYNONYM_OF ||
259 relQualifierFk == TAX_REL_IS_PROPARTE_HETEROTYPIC_SYNONYM_OF ){
260 synRel.setProParte(true);
261 }else if(relQualifierFk == TAX_REL_IS_PARTIAL_SYN_OF ||
262 relQualifierFk == TAX_REL_IS_PARTIAL_HOMOTYPIC_SYNONYM_OF ||
263 relQualifierFk == TAX_REL_IS_PARTIAL_HETEROTYPIC_SYNONYM_OF ){
264 synRel.setPartial(true);
265 }else{
266 success = false;
267 logger.warn("Proparte/Partial not yet implemented for TaxonRelationShipType " + relQualifierFk);
268 }
269 }else if (isConceptRelationship){
270 ResultWrapper<Boolean> isInverse = new ResultWrapper<Boolean>();
271 try {
272 TaxonRelationshipType relType = BerlinModelTransformer.taxonRelId2TaxonRelType(relQualifierFk, isInverse);
273 if (! (taxon1 instanceof Taxon)){
274 success = false;
275 logger.error("TaxonBase (ID = " + taxon1.getId()+ ", RIdentifier = " + taxon1Id + ") can't be casted to Taxon");
276 }else{
277 Taxon fromTaxon = (Taxon)taxon1;
278 taxonRelationship = fromTaxon.addTaxonRelation(toTaxon, relType, citation, microcitation);
279 }
280 } catch (UnknownCdmTypeException e) {
281
282 logger.warn("TaxonRelationShipType " + relQualifierFk + " (conceptRelationship) not yet implemented");
283 success = false;
284 }
285 }else {
286
287 logger.warn("TaxonRelationShipType " + relQualifierFk + " not yet implemented");
288 success = false;
289 }
290
291 doNotes(taxonRelationship, notes);
292 taxaToSave.add(taxon2);
293
294
295
296 }else{
297
298 logger.warn("Taxa for RelPTaxon " + relPTaxonId + " do not exist in store");
299 success = false;
300 }
301 }
302 }catch(SQLException e){
303 throw new RuntimeException(e);
304 }
305 logger.info("Taxa to save: " + taxaToSave.size());
306 partitioner.startDoSave();
307 getTaxonService().save(taxaToSave);
308 taxonTreeMap = null;
309 taxaToSave = null;
310
311 return success;
312 }
313
314
315
316
317
318 @Override
319 protected boolean doInvoke(BerlinModelImportState state){
320 try {
321 boolean success = true;
322 success &= makeTaxonomicTrees(state);
323 success &= super.doInvoke(state);
324 return success;
325 } catch (SQLException e) {
326 throw new RuntimeException(e);
327 }
328
329 }
330
331
332
333
334
335 public Map<Object, Map<String, ? extends CdmBase>> getRelatedObjectsForPartition( ResultSet rs) {
336 String nameSpace;
337 Class cdmClass;
338 Set<String> idSet;
339 Map<Object, Map<String, ? extends CdmBase>> result = new HashMap<Object, Map<String, ? extends CdmBase>>();
340
341 try{
342 Set<String> taxonIdSet = new HashSet<String>();
343 Set<String> referenceIdSet = new HashSet<String>();
344
345 while (rs.next()){
346 handleForeignKey(rs, taxonIdSet, "taxon1Id");
347 handleForeignKey(rs, taxonIdSet, "taxon2Id");
348
349 handleForeignKey(rs, referenceIdSet, "RelRefFk");
350 }
351
352
353 nameSpace = BerlinModelTaxonImport.NAMESPACE;
354 cdmClass = TaxonBase.class;
355 idSet = taxonIdSet;
356 Map<String, TaxonBase> taxonMap = (Map<String, TaxonBase>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
357 result.put(nameSpace, taxonMap);
358
359
360
361
362
363
364
365
366
367
368
369
370 nameSpace = BerlinModelReferenceImport.NOM_REFERENCE_NAMESPACE;
371 cdmClass = ReferenceBase.class;
372 idSet = referenceIdSet;
373 Map<String, ReferenceBase> nomReferenceMap = (Map<String, ReferenceBase>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
374 result.put(nameSpace, nomReferenceMap);
375
376
377 nameSpace = BerlinModelReferenceImport.BIBLIO_REFERENCE_NAMESPACE;
378 cdmClass = ReferenceBase.class;
379 idSet = referenceIdSet;
380 Map<String, ReferenceBase> biblioReferenceMap = (Map<String, ReferenceBase>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
381 result.put(nameSpace, biblioReferenceMap);
382
383 } catch (SQLException e) {
384 throw new RuntimeException(e);
385 }
386 return result;
387 }
388
389 private SynonymRelationship getSynRel (int relQualifierFk, Taxon toTaxon, Synonym synonym, ReferenceBase citation, String microcitation){
390 SynonymRelationship result;
391 if (relQualifierFk == TAX_REL_IS_HOMOTYPIC_SYNONYM_OF ||
392 relQualifierFk == TAX_REL_IS_PROPARTE_HOMOTYPIC_SYNONYM_OF ||
393 relQualifierFk == TAX_REL_IS_PARTIAL_HOMOTYPIC_SYNONYM_OF){
394 result = toTaxon.addHomotypicSynonym(synonym, citation, microcitation);
395 }else if (relQualifierFk == TAX_REL_IS_HETEROTYPIC_SYNONYM_OF ||
396 relQualifierFk == TAX_REL_IS_PROPARTE_HETEROTYPIC_SYNONYM_OF ||
397 relQualifierFk == TAX_REL_IS_PARTIAL_HETEROTYPIC_SYNONYM_OF){
398 result = toTaxon.addSynonym(synonym, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(), citation, microcitation);
399 }else if (relQualifierFk == TAX_REL_IS_SYNONYM_OF ||
400 relQualifierFk == TAX_REL_IS_PROPARTE_SYN_OF ||
401 relQualifierFk == TAX_REL_IS_PARTIAL_SYN_OF){
402 result = toTaxon.addSynonym(synonym, SynonymRelationshipType.SYNONYM_OF(), citation, microcitation);
403 }else{
404 logger.warn("SynonymyRelationShipType could not be defined for relQualifierFk " + relQualifierFk + ". 'Unknown'-Type taken instead.");
405 result = toTaxon.addSynonym(synonym, SynonymRelationshipType.SYNONYM_OF(), citation, microcitation);
406 }
407 return result;
408
409 }
410
411 private boolean isSynonymRelationship(int relQualifierFk){
412 if (relQualifierFk == TAX_REL_IS_SYNONYM_OF ||
413 relQualifierFk == TAX_REL_IS_HOMOTYPIC_SYNONYM_OF ||
414 relQualifierFk == TAX_REL_IS_HETEROTYPIC_SYNONYM_OF ||
415 relQualifierFk == TAX_REL_IS_PROPARTE_SYN_OF ||
416 relQualifierFk == TAX_REL_IS_PARTIAL_SYN_OF ||
417 relQualifierFk == TAX_REL_IS_PROPARTE_HOMOTYPIC_SYNONYM_OF ||
418 relQualifierFk == TAX_REL_IS_PROPARTE_HETEROTYPIC_SYNONYM_OF ||
419 relQualifierFk == TAX_REL_IS_PARTIAL_HOMOTYPIC_SYNONYM_OF ||
420 relQualifierFk == TAX_REL_IS_PARTIAL_HETEROTYPIC_SYNONYM_OF
421 ){
422 return true;
423 }else{
424 return false;
425 }
426 }
427
428 private boolean isTaxonRelationship(int relQualifierFk){
429 if (relQualifierFk == TAX_REL_IS_INCLUDED_IN ||
430 relQualifierFk == TAX_REL_IS_MISAPPLIED_NAME_OF){
431 return true;
432 }else{
433 return false;
434 }
435 }
436
437 private void addProParteAndPartial(SynonymRelationship synRel, Synonym synonym, BerlinModelImportConfigurator bmiConfig){
438 if (bmiConfig.isPartialSynonym(synonym)){
439 synRel.setPartial(true);
440 }
441 if (bmiConfig.isProParteSynonym(synonym)){
442 synRel.setProParte(true);
443 }
444 }
445
446 private TaxonNode makeTaxonomicallyIncluded(BerlinModelImportState state, Map<Integer, TaxonomicTree> taxonTreeMap, int treeRefFk, Taxon child, Taxon parent, ReferenceBase citation, String microCitation){
447 TaxonomicTree tree = taxonTreeMap.get(treeRefFk);
448 if (tree == null){
449 UUID treeUuid = state.getTreeUuidByIntTreeKey(treeRefFk);
450 tree = getTaxonTreeService().getTaxonomicTreeByUuid(treeUuid);
451 taxonTreeMap.put(treeRefFk, tree);
452 }
453 if (tree == null){
454 throw new IllegalStateException("Tree for ToTaxon reference does not exist.");
455 }
456 return tree.addParentChild(parent, child, citation, microCitation);
457 }
458
459
460
461
462
463 @Override
464 protected boolean doCheck(BerlinModelImportState state){
465 IOValidator<BerlinModelImportState> validator = new BerlinModelTaxonRelationImportValidator();
466 return validator.validate(state);
467 }
468
469
470
471
472
473 @Override
474 protected String getTableName() {
475 return dbTableName;
476 }
477
478
479
480
481 @Override
482 public String getPluralString() {
483 return pluralString;
484 }
485
486
487
488
489 protected boolean isIgnore(BerlinModelImportState state){
490 return ! state.getConfig().isDoRelTaxa();
491 }
492
493
494 }