| 28 |
28 |
import eu.etaxonomy.cdm.database.DbSchemaValidation;
|
| 29 |
29 |
import eu.etaxonomy.cdm.database.ICdmDataSource;
|
| 30 |
30 |
import eu.etaxonomy.cdm.io.api.application.CdmIoApplicationController;
|
| 31 |
|
import eu.etaxonomy.cdm.io.pesi.merging.PesiMergeObject;
|
| 32 |
31 |
import eu.etaxonomy.cdm.io.pesi.out.PesiTransformer;
|
| 33 |
32 |
import eu.etaxonomy.cdm.model.common.CdmBase;
|
| 34 |
33 |
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
|
| ... | ... | |
| 47 |
46 |
private static final Logger logger = Logger.getLogger(PesiFindIdenticalNamesActivator.class);
|
| 48 |
47 |
|
| 49 |
48 |
//static final ICdmDataSource faunaEuropaeaSource = CdmDestinations.localH2();
|
| 50 |
|
// static final ICdmDataSource pesiSource = CdmDestinations.cdm_test_local_faunaEu_mysql();
|
| 51 |
49 |
static final ICdmDataSource pesiSource = CdmDestinations.cdm_pesi2019_final();
|
| 52 |
50 |
|
| 53 |
51 |
static final String path = System.getProperty("user.home")+File.separator+".cdmLibrary"+File.separator+"pesi"+File.separator+"pesimerge";
|
| 54 |
52 |
|
| 55 |
|
private static UUID faunaEuSourceUuid = PesiTransformer.uuidSourceRefFaunaEuropaea;
|
|
53 |
private static UUID emSourceUuid = PesiTransformer.uuidSourceRefEuroMed;
|
| 56 |
54 |
private static UUID ermsSourceUuid = PesiTransformer.uuidSourceRefErms;
|
|
55 |
private static UUID faunaEuSourceUuid = PesiTransformer.uuidSourceRefFaunaEuropaea;
|
| 57 |
56 |
private static UUID ifSourceUuid = PesiTransformer.uuidSourceRefIndexFungorum;
|
| 58 |
|
private static UUID emSourceUuid = PesiTransformer.uuidSourceRefEuroMed;
|
| 59 |
57 |
private static List<UUID> sourceRefUuids = new ArrayList<>();
|
| 60 |
|
private static Map<UUID,String> sources = new HashMap<>();
|
|
58 |
private static Map<UUID,String> sourcesLabels = new HashMap<>();
|
| 61 |
59 |
|
| 62 |
60 |
static {
|
| 63 |
61 |
sourceRefUuids.addAll(Arrays.asList(new UUID[]{emSourceUuid, ermsSourceUuid, faunaEuSourceUuid, ifSourceUuid}));
|
| 64 |
|
sources.put(emSourceUuid, "E+M");
|
| 65 |
|
sources.put(ermsSourceUuid, "ERMS");
|
| 66 |
|
sources.put(faunaEuSourceUuid, "FauEu");
|
| 67 |
|
sources.put(ifSourceUuid, "IF");
|
|
62 |
sourcesLabels.put(emSourceUuid, "E+M");
|
|
63 |
sourcesLabels.put(ermsSourceUuid, "ERMS");
|
|
64 |
sourcesLabels.put(faunaEuSourceUuid, "FauEu");
|
|
65 |
sourcesLabels.put(ifSourceUuid, "IF");
|
| 68 |
66 |
}
|
| 69 |
67 |
|
| 70 |
68 |
private void invoke(ICdmDataSource source){
|
| ... | ... | |
| 96 |
94 |
return;
|
| 97 |
95 |
}
|
| 98 |
96 |
System.out.println("Start creating merging objects");
|
| 99 |
|
List<Map<UUID, PesiMergeObject>> mergingObjects = createMergeObjects(namesOfIdenticalTaxa, app);
|
|
97 |
List<Map<UUID, List<PesiMergeObject>>> mergingObjects = createMergeObjects(namesOfIdenticalTaxa, app);
|
| 100 |
98 |
app.commitTransaction(tx);
|
| 101 |
99 |
|
| 102 |
100 |
boolean resultOK = true;
|
| 103 |
101 |
System.out.println("Start creating csv files");
|
| 104 |
|
resultOK &= writeSameNamesDifferentAuthorToCsv(mergingObjects, sources, path + "_authors.csv");
|
| 105 |
|
resultOK &= writeSameNamesDifferentStatusToCsv(mergingObjects, sources, path + "_status.csv");
|
| 106 |
|
resultOK &= writeSameNamesToCsvFile(mergingObjects, sources, path + "_names.csv");
|
| 107 |
|
resultOK &= writeSameNamesDifferentPhylumToCsv(mergingObjects, sources, path + "_phylum.csv");
|
| 108 |
|
resultOK &= writeSameNamesDifferentParentToCsv(mergingObjects, sources, path + "_parent.csv");
|
| 109 |
|
resultOK &= writeSameNamesDifferentRankToCsv(mergingObjects, sources, path + "_rank.csv");
|
|
102 |
resultOK &= writeSameNamesToCsvFile(mergingObjects, path + "_namesAll.csv");
|
|
103 |
resultOK &= writeSameNamesDifferentAuthorToCsv(mergingObjects, path + "_authors.csv");
|
|
104 |
resultOK &= writeSameNamesDifferentStatusToCsv(mergingObjects, path + "_status.csv");
|
|
105 |
resultOK &= writeSameNamesDifferentPhylumToCsv(mergingObjects, path + "_phylum.csv");
|
|
106 |
resultOK &= writeSameNamesDifferentParentToCsv(mergingObjects, path + "_parent.csv");
|
|
107 |
resultOK &= writeSameNamesDifferentRankToCsv(mergingObjects, path + "_rank.csv");
|
| 110 |
108 |
|
| 111 |
109 |
System.out.println("End find identical names for PESI: " + resultOK + ". Results written to " + path);
|
| 112 |
110 |
}
|
| 113 |
111 |
|
| 114 |
112 |
private boolean writeSameNamesToCsvFile(
|
| 115 |
|
List<Map<UUID, PesiMergeObject>> mergingObjects, Map<UUID,String> sources, String sFileName) {
|
|
113 |
List<Map<UUID,List<PesiMergeObject>>> mergingObjects, String sFileName) {
|
| 116 |
114 |
|
| 117 |
115 |
String header = "same names (all)";
|
| 118 |
116 |
String methodName = null;
|
| 119 |
|
return writeDifference(header, methodName, mergingObjects, sources, sFileName);
|
|
117 |
return writeDifference(header, methodName, mergingObjects, sFileName);
|
| 120 |
118 |
}
|
| 121 |
119 |
|
| 122 |
120 |
private boolean writeSameNamesDifferentPhylumToCsv(
|
| 123 |
|
List<Map<UUID, PesiMergeObject>> mergingObjects, Map<UUID,String> sources, String sFileName){
|
|
121 |
List<Map<UUID,List<PesiMergeObject>>> mergingObjects, String sFileName){
|
| 124 |
122 |
|
| 125 |
123 |
String header = "same names but different phylum";
|
| 126 |
124 |
String methodName = "getPhylum";
|
| 127 |
|
return writeDifference(header, methodName, mergingObjects, sources, sFileName);
|
|
125 |
return writeDifference(header, methodName, mergingObjects, sFileName);
|
| 128 |
126 |
}
|
| 129 |
127 |
|
| 130 |
128 |
private boolean writeSameNamesDifferentParentToCsv(
|
| 131 |
|
List<Map<UUID, PesiMergeObject>> mergingObjects, Map<UUID,String> sources, String sFileName){
|
|
129 |
List<Map<UUID,List<PesiMergeObject>>> mergingObjects, String sFileName){
|
| 132 |
130 |
|
| 133 |
131 |
String header = "same names but different parent";
|
| 134 |
132 |
String methodName = "getParentString";
|
| 135 |
|
return writeDifference(header, methodName, mergingObjects, sources, sFileName);
|
|
133 |
return writeDifference(header, methodName, mergingObjects, sFileName);
|
| 136 |
134 |
}
|
| 137 |
135 |
|
| 138 |
136 |
private boolean writeSameNamesDifferentRankToCsv(
|
| 139 |
|
List<Map<UUID, PesiMergeObject>> mergingObjects, Map<UUID,String> sources, String sFileName){
|
|
137 |
List<Map<UUID,List<PesiMergeObject>>> mergingObjects, String sFileName){
|
| 140 |
138 |
|
| 141 |
139 |
String header = "same names but different rank";
|
| 142 |
140 |
String methodName = "getRank";
|
| 143 |
|
return writeDifference(header, methodName, mergingObjects, sources, sFileName);
|
|
141 |
return writeDifference(header, methodName, mergingObjects, sFileName);
|
| 144 |
142 |
}
|
| 145 |
143 |
|
| 146 |
144 |
private boolean writeSameNamesDifferentStatusToCsv(
|
| 147 |
|
List<Map<UUID, PesiMergeObject>> mergingObjects, Map<UUID,String> sources, String sFileName){
|
|
145 |
List<Map<UUID,List<PesiMergeObject>>> mergingObjects, String sFileName){
|
| 148 |
146 |
|
| 149 |
147 |
String header = "same names but different status";
|
| 150 |
148 |
String methodName = "isStatus";
|
| 151 |
|
return writeDifference(header, methodName, mergingObjects, sources, sFileName);
|
|
149 |
return writeDifference(header, methodName, mergingObjects, sFileName);
|
| 152 |
150 |
}
|
| 153 |
151 |
|
| 154 |
152 |
private boolean writeSameNamesDifferentAuthorToCsv(
|
| 155 |
|
List<Map<UUID, PesiMergeObject>> mergingObjects, Map<UUID,String> sources, String sFileName){
|
|
153 |
List<Map<UUID,List<PesiMergeObject>>> mergingObjects, String sFileName){
|
| 156 |
154 |
|
| 157 |
155 |
String header = "same names but different author";
|
| 158 |
156 |
String methodName = "getAuthor";
|
| 159 |
|
return writeDifference(header, methodName, mergingObjects, sources, sFileName);
|
|
157 |
return writeDifference(header, methodName, mergingObjects, sFileName);
|
| 160 |
158 |
}
|
| 161 |
159 |
|
| 162 |
|
private boolean writeDifference(String header, String methodName,
|
| 163 |
|
List<Map<UUID, PesiMergeObject>> mergingObjects, Map<UUID,String> sources, String sFileName) {
|
|
160 |
private boolean writeDifference(String header,
|
|
161 |
String methodName,
|
|
162 |
List<Map<UUID,List<PesiMergeObject>>> mergingObjects,
|
|
163 |
String sFileName) {
|
| 164 |
164 |
|
| 165 |
165 |
try{
|
| 166 |
166 |
Method method = methodName == null? null : PesiMergeObject.class.getMethod(methodName);
|
| 167 |
167 |
|
| 168 |
|
// FileWriter writer = new FileWriter(sFileName);
|
| 169 |
168 |
Writer writer = new OutputStreamWriter(new FileOutputStream(new File(sFileName)), StandardCharsets.UTF_8);
|
| 170 |
169 |
|
| 171 |
170 |
//create Header
|
| 172 |
171 |
createHeader(writer, header);
|
| 173 |
172 |
|
| 174 |
173 |
//write data
|
| 175 |
|
for (Map<UUID, PesiMergeObject> merging : mergingObjects){
|
| 176 |
|
if (isDifferent(merging, method)){
|
| 177 |
|
writeCsvLine(writer, merging, sources) ;
|
|
174 |
for (Map<UUID,List<PesiMergeObject>> merging : mergingObjects){
|
|
175 |
boolean isNextNameCache = true;
|
|
176 |
List<UUID> mySources = new ArrayList<>(merging.keySet());
|
|
177 |
for (int i = 0; i<mySources.size()-1; i++){
|
|
178 |
for (int j = i+1; j<mySources.size(); j++){
|
|
179 |
boolean differenceExists = false;
|
|
180 |
List<PesiMergeObject> mergeList1 = merging.get(mySources.get(i));
|
|
181 |
List<PesiMergeObject> mergeList2 = merging.get(mySources.get(j));
|
|
182 |
for (PesiMergeObject merge1 : mergeList1){
|
|
183 |
for (PesiMergeObject merge2 : mergeList2){
|
|
184 |
differenceExists |= isDifferent(merge1, merge2, method);
|
|
185 |
}
|
|
186 |
}
|
|
187 |
if (differenceExists){
|
|
188 |
for (PesiMergeObject merge1 : mergeList1){
|
|
189 |
for (PesiMergeObject merge2 : mergeList2){
|
|
190 |
writeCsvLine(writer, merge1, merge2, method, isNextNameCache);
|
|
191 |
isNextNameCache = false;
|
|
192 |
}
|
|
193 |
}
|
|
194 |
}
|
|
195 |
}
|
| 178 |
196 |
}
|
| 179 |
197 |
}
|
| 180 |
198 |
writer.flush();
|
| 181 |
199 |
writer.close();
|
| 182 |
200 |
return true;
|
| 183 |
|
}catch(IOException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e){
|
|
201 |
}catch(NoSuchMethodException | SecurityException | IOException e){
|
| 184 |
202 |
logger.error(e.getMessage());
|
| 185 |
203 |
return false;
|
| 186 |
204 |
}
|
| 187 |
205 |
}
|
| 188 |
206 |
|
|
207 |
private boolean isDifferent(PesiMergeObject merge1, PesiMergeObject merge2, Method method){
|
|
208 |
|
|
209 |
try {
|
|
210 |
if (method == null){
|
|
211 |
return true;
|
|
212 |
}
|
|
213 |
Object value1 = method.invoke(merge1);
|
|
214 |
Object value2 = method.invoke(merge2);
|
|
215 |
return !CdmUtils.nullSafeEqual(value1, value2);
|
|
216 |
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
|
|
217 |
e.printStackTrace();
|
|
218 |
return true;
|
|
219 |
}
|
|
220 |
}
|
|
221 |
|
|
222 |
//old method when all sources were in 1 line
|
| 189 |
223 |
private boolean isDifferent(Map<UUID, PesiMergeObject> merging, Method method)
|
| 190 |
224 |
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
|
| 191 |
225 |
|
| ... | ... | |
| 208 |
242 |
return false;
|
| 209 |
243 |
}
|
| 210 |
244 |
|
| 211 |
|
private void createHeader(Writer writer, String firstLine) throws IOException{
|
| 212 |
|
writer.append(firstLine);
|
| 213 |
|
writer.append('\n');
|
| 214 |
|
|
| 215 |
|
for (int i=1; i<=2; i++){
|
| 216 |
|
writer.append("source"+i);
|
| 217 |
|
writer.append(';');
|
| 218 |
|
writer.append("name uuid"+i);
|
| 219 |
|
writer.append(';');
|
| 220 |
|
writer.append("name id"+i);
|
| 221 |
|
writer.append(';');
|
| 222 |
|
writer.append("name"+i);
|
| 223 |
|
writer.append(';');
|
| 224 |
|
writer.append("author"+i);
|
| 225 |
|
writer.append(';');
|
| 226 |
|
writer.append("rank"+i);
|
| 227 |
|
writer.append(';');
|
| 228 |
|
writer.append("status"+i);
|
| 229 |
|
writer.append(';');
|
| 230 |
|
writer.append("phylum"+i);
|
| 231 |
|
writer.append(';');
|
| 232 |
|
writer.append("parent"+i);
|
| 233 |
|
writer.append(';');
|
| 234 |
|
writer.append("parent rank"+i);
|
| 235 |
|
writer.append(';');
|
| 236 |
|
}
|
| 237 |
|
writer.append('\n');
|
|
245 |
private void createHeader(Writer writer, String firstLine){
|
|
246 |
try {
|
|
247 |
writer.append(firstLine);
|
|
248 |
writer.append('\n');
|
|
249 |
writeHeaderPair(writer, "taxon uuid");
|
|
250 |
writeHeaderPair(writer, "taxon id");
|
|
251 |
writer.append("next name cache").append(";");
|
|
252 |
writer.append("diff").append(";");
|
|
253 |
writeHeaderPair(writer, "source");
|
|
254 |
writeHeaderPair(writer, "name uuid");
|
|
255 |
writeHeaderPair(writer, "idInSource");
|
|
256 |
writeHeaderPair(writer, "nameCache");
|
|
257 |
writeHeaderPair(writer, "author");
|
|
258 |
writeHeaderPair(writer, "rank");
|
|
259 |
writeHeaderPair(writer, "kingdom");
|
|
260 |
writeHeaderPair(writer, "phylum");
|
|
261 |
writeHeaderPair(writer, "family");
|
|
262 |
writeHeaderPair(writer, "parentString");
|
|
263 |
writeHeaderPair(writer, "parentRankString");
|
|
264 |
writeHeaderPair(writer, "status");
|
|
265 |
writer.append('\n');
|
|
266 |
} catch (IOException e) {
|
|
267 |
e.printStackTrace();
|
|
268 |
}
|
| 238 |
269 |
}
|
| 239 |
270 |
|
| 240 |
|
private void writeCsvLine(Writer writer, Map<UUID,PesiMergeObject> mergeObjects, Map<UUID,String> sources) throws IOException{
|
|
271 |
private void writeHeaderPair(Writer writer, String header) throws IOException {
|
|
272 |
writer.append(header+"1").append(';');
|
|
273 |
writer.append(header+"2").append(';');
|
|
274 |
}
|
|
275 |
|
|
276 |
private void writeCsvLine(Writer writer,
|
|
277 |
PesiMergeObject merge1, PesiMergeObject merge2,
|
|
278 |
Method method, boolean isNextNameCache){
|
|
279 |
|
|
280 |
writePair(writer, merge1, merge2, "UuidTaxon");
|
|
281 |
writePair(writer, merge1, merge2, "IdTaxon");
|
|
282 |
writeSingleValue(writer, isNextNameCache?"1":"0");
|
|
283 |
boolean different = isDifferent(merge1, merge2, method);
|
|
284 |
writeSingleValue(writer, different?"1":"0");
|
|
285 |
writeSingleValue(writer, sourcesLabels.get(UUID.fromString(merge1.getUuidSource())));
|
|
286 |
writeSingleValue(writer, sourcesLabels.get(UUID.fromString(merge2.getUuidSource())));
|
|
287 |
writePair(writer, merge1, merge2, "UuidName");
|
|
288 |
writePair(writer, merge1, merge2, "IdInSource");
|
|
289 |
writePair(writer, merge1, merge2, "NameCache");
|
|
290 |
writePair(writer, merge1, merge2, "Author");
|
|
291 |
writePair(writer, merge1, merge2, "Rank");
|
|
292 |
writePairNode(writer, merge1, merge2, "Kingdom");
|
|
293 |
writePairNode(writer, merge1, merge2, "Phylum");
|
|
294 |
writePairNode(writer, merge1, merge2, "Family");
|
|
295 |
writePair(writer, merge1, merge2, "ParentString");
|
|
296 |
writePair(writer, merge1, merge2, "ParentRankString");
|
|
297 |
writeSingleValue(writer, merge1.isStatus()?"accepted":"synonym");
|
|
298 |
writeSingleValue(writer, merge2.isStatus()?"accepted":"synonym");
|
|
299 |
try {
|
|
300 |
writer.append('\n');
|
|
301 |
} catch (IOException e) {
|
|
302 |
e.printStackTrace();
|
|
303 |
}
|
|
304 |
}
|
|
305 |
|
|
306 |
private void writeSingleValue(Writer writer, String value) {
|
|
307 |
try {
|
|
308 |
writer.append(value).append(";");
|
|
309 |
} catch (Exception e) {
|
|
310 |
e.printStackTrace();
|
|
311 |
}
|
|
312 |
}
|
|
313 |
|
|
314 |
private void writePairNode(Writer writer, PesiMergeObject merge1, PesiMergeObject merge2, String methodName) {
|
|
315 |
try {
|
|
316 |
Method method = PesiMergeObject.class.getDeclaredMethod("get"+methodName);
|
|
317 |
TaxonNodeDto value = (TaxonNodeDto) method.invoke(merge1);
|
|
318 |
writer.append(value==null?"":value.getTitleCache()).append(";");
|
|
319 |
value = (TaxonNodeDto) method.invoke(merge2);
|
|
320 |
writer.append(value==null?"":value.getTitleCache()).append(";");
|
|
321 |
} catch (Exception e) {
|
|
322 |
e.printStackTrace();
|
|
323 |
}
|
|
324 |
}
|
|
325 |
|
|
326 |
private void writePair(Writer writer, PesiMergeObject merge1, PesiMergeObject merge2, String methodName) {
|
|
327 |
try {
|
|
328 |
Method method = PesiMergeObject.class.getDeclaredMethod("get"+methodName);
|
|
329 |
String value1 = (String) method.invoke(merge1);
|
|
330 |
writer.append(normalize(value1)).append(";");
|
|
331 |
String value2 = (String) method.invoke(merge2);
|
|
332 |
writer.append(normalize(value2)).append(";");
|
|
333 |
} catch (Exception e) {
|
|
334 |
e.printStackTrace();
|
|
335 |
}
|
|
336 |
}
|
|
337 |
|
|
338 |
private String normalize(String val) {
|
|
339 |
return CdmUtils.Nz(val).replace(";", "@");
|
|
340 |
}
|
|
341 |
|
|
342 |
private void writeCsvLine(Writer writer, Map<UUID,PesiMergeObject> mergeObjects, Map<UUID,String> sources) throws IOException{
|
| 241 |
343 |
|
| 242 |
344 |
for (UUID uuid : sourceRefUuids){
|
| 243 |
345 |
PesiMergeObject merging = mergeObjects.get(uuid);
|
| ... | ... | |
| 262 |
364 |
writer.append('\n');
|
| 263 |
365 |
}
|
| 264 |
366 |
|
| 265 |
|
private List<Map<UUID,PesiMergeObject>> createMergeObjects(Map<String, Map<UUID, Set<TaxonName>>> names,
|
|
367 |
private List<Map<UUID,List<PesiMergeObject>>> createMergeObjects(
|
|
368 |
Map<String, Map<UUID, Set<TaxonName>>> identicalNames,
|
| 266 |
369 |
CdmApplicationController appCtr){
|
| 267 |
370 |
|
| 268 |
|
List<Map<UUID,PesiMergeObject>> merge = new ArrayList<>();
|
|
371 |
List<Map<UUID,List<PesiMergeObject>>> merge = new ArrayList<>();
|
| 269 |
372 |
|
| 270 |
|
List<String> nameCaches = new ArrayList<>(names.keySet());
|
|
373 |
List<String> nameCaches = new ArrayList<>(identicalNames.keySet());
|
| 271 |
374 |
nameCaches.sort(StringComparator.Instance);
|
| 272 |
375 |
for (String nameCache: nameCaches){
|
| 273 |
|
createSingleMergeObject(appCtr, merge, names.get(nameCache));
|
|
376 |
createSingleMergeObject(appCtr, merge, identicalNames.get(nameCache));
|
| 274 |
377 |
}
|
| 275 |
|
|
| 276 |
378 |
return merge;
|
| 277 |
379 |
}
|
| 278 |
380 |
|
| 279 |
|
|
| 280 |
|
private void createSingleMergeObject(CdmApplicationController appCtr, List<Map<UUID,PesiMergeObject>> merge,
|
|
381 |
private void createSingleMergeObject(CdmApplicationController appCtr,
|
|
382 |
List<Map<UUID,List<PesiMergeObject>>> merge,
|
| 281 |
383 |
Map<UUID, Set<TaxonName>> identicalNames) {
|
| 282 |
384 |
|
| 283 |
|
Map<UUID,PesiMergeObject> mergeMap = new HashMap<>();
|
|
385 |
Map<UUID,List<PesiMergeObject>> mergeMap = new HashMap<>();
|
| 284 |
386 |
|
| 285 |
387 |
for (UUID sourceUuid : identicalNames.keySet()){
|
| 286 |
388 |
Set<TaxonName> names = identicalNames.get(sourceUuid);
|
| 287 |
|
if (names.isEmpty()){
|
| 288 |
|
continue;
|
| 289 |
|
}
|
| 290 |
|
TaxonName name = names.iterator().next();
|
| 291 |
|
String nameAndIdStr = name.getTitleCache() + "; id = " + name.getId();
|
| 292 |
|
if (names.size()>1){
|
| 293 |
|
logger.warn("Multiple names per source not yet handled. Take arbitrary one: " + nameAndIdStr);
|
| 294 |
|
}
|
| 295 |
|
|
| 296 |
|
PesiMergeObject mergeObject = new PesiMergeObject();
|
| 297 |
|
mergeMap.put(sourceUuid, mergeObject);
|
| 298 |
|
|
| 299 |
|
Set<TaxonBase> taxonBases = name.getTaxonBases();
|
| 300 |
|
if (taxonBases.isEmpty()){
|
| 301 |
|
logger.warn("No taxonbase attached to name. This is not yet handled: " + nameAndIdStr);
|
| 302 |
|
continue;
|
| 303 |
|
}
|
| 304 |
|
if (taxonBases.size() > 1) {
|
| 305 |
|
//TODO: find the two correct names
|
| 306 |
|
logger.warn("Name has not exact 1 but " + taxonBases.size() + " taxon base attached. This is not yet handled. Take arbitrary one.");
|
| 307 |
|
}
|
| 308 |
|
|
| 309 |
|
//uuid
|
| 310 |
|
mergeObject.setUuidName(name.getUuid().toString());
|
|
389 |
List<PesiMergeObject> pmoList = new ArrayList<>();
|
|
390 |
mergeMap.put(sourceUuid, pmoList);
|
|
391 |
|
|
392 |
for (TaxonName name : names){
|
|
393 |
String nameAndIdStr = name.getTitleCache() + "; id = " + name.getId();
|
|
394 |
@SuppressWarnings("rawtypes")
|
|
395 |
Set<TaxonBase> taxonBases = name.getTaxonBases();
|
|
396 |
if (taxonBases.isEmpty()){
|
|
397 |
logger.warn("No taxonbase attached to name. This is not yet handled: " + nameAndIdStr);
|
|
398 |
continue;
|
|
399 |
}
|
|
400 |
for (TaxonBase<?> taxonBase : taxonBases) {
|
|
401 |
if (!taxonBase.isPublish()){
|
|
402 |
continue;
|
|
403 |
}
|
|
404 |
PesiMergeObject mergeObject = PesiMergeObject.NewInstance();
|
|
405 |
pmoList.add(mergeObject);
|
| 311 |
406 |
|
| 312 |
|
//nameCache
|
| 313 |
|
mergeObject.setNameCache(name.getNameCache());
|
|
407 |
//uuid
|
|
408 |
mergeObject.setUuidSource(sourceUuid.toString());
|
|
409 |
mergeObject.setUuidName(name.getUuid().toString());
|
|
410 |
mergeObject.setUuidTaxon(taxonBase.getUuid().toString());
|
|
411 |
mergeObject.setIdTaxon(String.valueOf(taxonBase.getId()));
|
| 314 |
412 |
|
| 315 |
|
//authorship
|
| 316 |
|
mergeObject.setAuthor(name.getAuthorshipCache());
|
|
413 |
//nameCache
|
|
414 |
mergeObject.setNameCache(name.getNameCache());
|
| 317 |
415 |
|
| 318 |
|
//rank
|
| 319 |
|
mergeObject.setRank(name.getRank().getLabel());
|
|
416 |
//authorship
|
|
417 |
mergeObject.setAuthor(name.getAuthorshipCache());
|
| 320 |
418 |
|
| 321 |
|
//Phylum
|
| 322 |
|
TaxonNodeDto phylum = getPhylum(appCtr, name);
|
| 323 |
|
mergeObject.setPhylum(phylum);
|
|
419 |
//rank
|
|
420 |
mergeObject.setRank(name.getRank().getLabel());
|
| 324 |
421 |
|
| 325 |
|
//idInSource
|
| 326 |
|
Iterator<IdentifiableSource> sources = name.getSources().iterator();
|
| 327 |
|
//TODO idInSource - what if multiple sources exist?
|
| 328 |
|
if (sources.hasNext()){
|
| 329 |
|
IdentifiableSource source = sources.next();
|
| 330 |
|
String idInSource = source.getIdInSource();
|
| 331 |
|
mergeObject.setIdInSource(idInSource);
|
| 332 |
|
}
|
|
422 |
//Kingdom
|
|
423 |
TaxonNodeDto kingdom = getHigherTaxon(appCtr, name, Rank.KINGDOM());
|
|
424 |
mergeObject.setKingdom(kingdom);
|
| 333 |
425 |
|
| 334 |
|
//status and parent
|
| 335 |
|
Set<Taxon> taxa = name.getTaxa();
|
| 336 |
|
taxa = getReallyAcceptedTaxa(taxa);
|
| 337 |
|
if (!taxa.isEmpty()){
|
| 338 |
|
mergeObject.setStatus(true);
|
| 339 |
|
Iterator<Taxon> taxaIterator = taxa.iterator();
|
| 340 |
|
Taxon taxon = null;
|
| 341 |
|
while (taxaIterator.hasNext()){
|
| 342 |
|
taxon = taxaIterator.next();
|
| 343 |
|
if (!taxon.isMisapplication()){
|
| 344 |
|
break;
|
|
426 |
//Phylum/Division
|
|
427 |
TaxonNodeDto phylum = getHigherTaxon(appCtr, name, Rank.PHYLUM());
|
|
428 |
if(phylum == null){
|
|
429 |
phylum = getHigherTaxon(appCtr, name, Rank.DIVISION());
|
| 345 |
430 |
}
|
| 346 |
|
}
|
| 347 |
|
@SuppressWarnings("null")
|
| 348 |
|
Set<TaxonNode> nodes = taxon.getTaxonNodes();
|
| 349 |
|
Iterator<TaxonNode> taxonNodeIterator = nodes.iterator();
|
| 350 |
|
TaxonNode parentNode = null;
|
| 351 |
|
while (taxonNodeIterator.hasNext()){
|
| 352 |
|
TaxonNode node = taxonNodeIterator.next();
|
| 353 |
|
if (!node.isTopmostNode()){
|
| 354 |
|
parentNode = node.getParent();
|
|
431 |
mergeObject.setPhylum(phylum);
|
|
432 |
|
|
433 |
//Family
|
|
434 |
TaxonNodeDto family = getHigherTaxon(appCtr, name, Rank.FAMILY());
|
|
435 |
mergeObject.setFamily(family);
|
|
436 |
|
|
437 |
//idInSource
|
|
438 |
Iterator<IdentifiableSource> sources = name.getSources().iterator();
|
|
439 |
//TODO idInSource - what if multiple sources exist?
|
|
440 |
if (sources.hasNext()){
|
|
441 |
IdentifiableSource source = sources.next();
|
|
442 |
String idInSource = source.getIdInSource();
|
|
443 |
mergeObject.setIdInSource(idInSource);
|
| 355 |
444 |
}
|
| 356 |
|
}
|
| 357 |
|
//TODO: ändern mit erweitertem Initializer..
|
| 358 |
|
if (parentNode != null){
|
| 359 |
|
TaxonName parentName = CdmBase.deproxy(parentNode.getTaxon().getName());
|
| 360 |
|
String parentNameCache = parentName.getNameCache();
|
| 361 |
|
mergeObject.setParentString(parentNameCache);
|
| 362 |
|
mergeObject.setParentRankString(parentName.getRank().getLabel());
|
| 363 |
|
}
|
| 364 |
|
}else{
|
| 365 |
|
mergeObject.setStatus(false);
|
| 366 |
|
TaxonNode parentNode = getAcceptedNode(name);
|
| 367 |
|
//TODO: ändern mit erweitertem Initializer..
|
| 368 |
|
if (parentNode != null){
|
| 369 |
|
TaxonName parentName = CdmBase.deproxy(parentNode.getTaxon().getName());
|
| 370 |
|
String parentNameCache = parentName.getNameCache();
|
| 371 |
|
mergeObject.setParentString(parentNameCache);
|
| 372 |
|
mergeObject.setParentRankString(parentName.getRank().getLabel());
|
|
445 |
|
|
446 |
//status and parent
|
|
447 |
makeStatusAndParent(name, mergeObject);
|
| 373 |
448 |
}
|
| 374 |
449 |
}
|
| 375 |
450 |
}
|
| 376 |
451 |
|
|
452 |
merge.add(mergeMap);
|
|
453 |
|
| 377 |
454 |
|
| 378 |
455 |
//set parent informations
|
| 379 |
456 |
|
| ... | ... | |
| 399 |
476 |
mergeObject.setParentStringInFaunaEu(parentName.getNameCache());
|
| 400 |
477 |
}*/
|
| 401 |
478 |
|
| 402 |
|
merge.add(mergeMap);
|
|
479 |
|
| 403 |
480 |
}
|
| 404 |
481 |
|
| 405 |
|
private TaxonNodeDto getPhylum(CdmApplicationController appCtr, TaxonName name) {
|
| 406 |
|
TaxonNodeDto phylum = null;
|
| 407 |
|
if (name.getRank().equals(Rank.PHYLUM())) {
|
|
482 |
private void makeStatusAndParent(TaxonName name, PesiMergeObject mergeObject) {
|
|
483 |
Set<Taxon> taxa = name.getTaxa();
|
|
484 |
taxa = getReallyAcceptedTaxa(taxa);
|
|
485 |
if (!taxa.isEmpty()){
|
|
486 |
mergeObject.setStatus(true);
|
|
487 |
Iterator<Taxon> taxaIterator = taxa.iterator();
|
|
488 |
Taxon taxon = null;
|
|
489 |
while (taxaIterator.hasNext()){
|
|
490 |
taxon = taxaIterator.next();
|
|
491 |
if (!taxon.isMisapplication()){
|
|
492 |
break;
|
|
493 |
}
|
|
494 |
}
|
|
495 |
@SuppressWarnings("null")
|
|
496 |
Set<TaxonNode> nodes = taxon.getTaxonNodes();
|
|
497 |
Iterator<TaxonNode> taxonNodeIterator = nodes.iterator();
|
|
498 |
TaxonNode parentNode = null;
|
|
499 |
while (taxonNodeIterator.hasNext()){
|
|
500 |
TaxonNode node = taxonNodeIterator.next();
|
|
501 |
if (!node.isTopmostNode()){
|
|
502 |
parentNode = node.getParent();
|
|
503 |
}
|
|
504 |
}
|
|
505 |
if (parentNode != null){
|
|
506 |
TaxonName parentName = CdmBase.deproxy(parentNode.getTaxon().getName());
|
|
507 |
String parentNameCache = parentName.getNameCache();
|
|
508 |
mergeObject.setParentString(parentNameCache);
|
|
509 |
mergeObject.setParentRankString(parentName.getRank().getLabel());
|
|
510 |
}
|
|
511 |
}else{
|
|
512 |
mergeObject.setStatus(false);
|
|
513 |
TaxonNode parentNode = getAcceptedNode(name);
|
|
514 |
if (parentNode != null){
|
|
515 |
TaxonName parentName = CdmBase.deproxy(parentNode.getTaxon().getName());
|
|
516 |
String parentNameCache = parentName.getNameCache();
|
|
517 |
mergeObject.setParentString(parentNameCache);
|
|
518 |
mergeObject.setParentRankString(parentName.getRank().getLabel());
|
|
519 |
}
|
|
520 |
}
|
|
521 |
}
|
|
522 |
|
|
523 |
private TaxonNodeDto getHigherTaxon(CdmApplicationController appCtr, TaxonName name, Rank rank) {
|
|
524 |
if (name.getRank().equals(rank)) {
|
| 408 |
525 |
Taxon taxon = getAcceptedTaxon(name);
|
| 409 |
526 |
if (taxon != null) {
|
|
527 |
if (taxon.getTaxonNodes().isEmpty()){
|
|
528 |
return null; //probably MAN
|
|
529 |
}
|
| 410 |
530 |
if (taxon.getTaxonNodes().size()>1){
|
| 411 |
|
logger.warn("More than 1 node not yet handled for getPhylum. Take arbitrary one.");
|
|
531 |
logger.warn("More than 1 node not yet handled for getHigherTaxon. Take arbitrary one.");
|
| 412 |
532 |
}
|
| 413 |
533 |
TaxonNode node = taxon.getTaxonNodes().iterator().next();
|
| 414 |
|
phylum = new TaxonNodeDto(node);
|
|
534 |
return new TaxonNodeDto(node);
|
| 415 |
535 |
}
|
| 416 |
|
|
| 417 |
536 |
}
|
| 418 |
|
if (phylum == null && !name.getRank().isHigher(Rank.PHYLUM())){
|
|
537 |
if (name.getRank().isHigher(rank)){
|
|
538 |
return null;
|
|
539 |
}else{
|
| 419 |
540 |
Taxon taxon = getAcceptedTaxon(name);
|
| 420 |
|
if (!taxon.getTaxonNodes().isEmpty()){
|
|
541 |
if (taxon.getTaxonNodes().isEmpty()){
|
|
542 |
return null;
|
|
543 |
}else{
|
| 421 |
544 |
if (taxon.getTaxonNodes().size()>1){
|
| 422 |
|
logger.warn("More than 1 node not yet handled for getPhylum. Take arbitrary one.");
|
|
545 |
logger.warn("More than 1 node not yet handled for getHigherTaxon. Take arbitrary one.");
|
| 423 |
546 |
}
|
| 424 |
547 |
TaxonNode node = taxon.getTaxonNodes().iterator().next();
|
| 425 |
|
phylum = appCtr.getTaxonNodeService().taxonNodeDtoParentRank(node.getClassification(), Rank.PHYLUM(), name);
|
|
548 |
List<TaxonNodeDto> higherDtos = appCtr.getTaxonNodeService().taxonNodeDtoParentRank(node.getClassification(), rank, taxon);
|
|
549 |
if (higherDtos.isEmpty()){
|
|
550 |
return null;
|
|
551 |
}else {
|
|
552 |
if (higherDtos.size() > 1){
|
|
553 |
logger.warn("More than 1 higher dto. This is not yet implemented: " + taxon.getTitleCache());
|
|
554 |
}
|
|
555 |
return higherDtos.get(0);
|
|
556 |
}
|
| 426 |
557 |
}
|
| 427 |
558 |
}
|
| 428 |
|
return phylum;
|
| 429 |
559 |
}
|
| 430 |
560 |
|
| 431 |
561 |
private TaxonNode getAcceptedNode(TaxonName ermsName) {
|
ref #1447 Improve FindIdenticalNames for PESI