Mercurial > hg > ismi-richfaces
comparison src/main/java/de/mpiwg/itgroup/ismi/search/beans/Titles4PersonQuery.java @ 1:2e911857a759
(none)
author | jurzua |
---|---|
date | Wed, 29 Oct 2014 14:00:28 +0000 |
parents | |
children | 4aa8c425685d |
comparison
equal
deleted
inserted
replaced
0:74df02964906 | 1:2e911857a759 |
---|---|
1 package de.mpiwg.itgroup.ismi.search.beans; | |
2 | |
3 import java.io.Serializable; | |
4 import java.util.ArrayList; | |
5 import java.util.HashMap; | |
6 import java.util.List; | |
7 import java.util.Map; | |
8 | |
9 import javax.faces.model.SelectItem; | |
10 | |
11 import org.apache.commons.lang.StringUtils; | |
12 import org.mpi.openmind.repository.bo.Entity; | |
13 import org.mpi.openmind.repository.bo.Relation; | |
14 import org.mpi.openmind.repository.utils.NormalizerUtils; | |
15 import org.mpi.openmind.search.utils.ResultEntry; | |
16 import org.mpi.openmind.search.utils.SAttributeMultipleName; | |
17 import org.mpi.openmind.search.utils.SAttributeUniqueName; | |
18 import org.mpi.openmind.search.utils.SEntity; | |
19 import org.mpi.openmind.search.utils.SRelLongKey; | |
20 import org.mpi.openmind.search.utils.SRelation; | |
21 import org.mpi.openmind.search.utils.SRelationMultipleName; | |
22 import org.mpi.openmind.search.utils.SRelationUniqueName; | |
23 | |
24 import de.mpiwg.itgroup.ismi.entry.beans.ApplicationBean; | |
25 | |
26 public class Titles4PersonQuery extends AbstractQuery implements Serializable{ | |
27 | |
28 /** | |
29 * | |
30 */ | |
31 private static final long serialVersionUID = -5342126098161866749L; | |
32 private String personName; | |
33 private String roleName = "Author"; | |
34 private static List<SelectItem> roleList; | |
35 private List<SRelLongKey> personTitleKeyList; | |
36 | |
37 private boolean displayCodex = false; | |
38 private boolean displayAlias = false; | |
39 | |
40 public Titles4PersonQuery(ApplicationBean appBean){ | |
41 super(appBean); | |
42 this.exportUrlRoot = ApplicationBean.urlISMIExportServiceAuthors; | |
43 } | |
44 | |
45 //"Author", "Annotator", "Copyist", "Corrector", "Dedicatee", "Illuminator", "Illustrator", "Owner", "Patron", "inspector" | |
46 static{ | |
47 roleList = new ArrayList<SelectItem>(); | |
48 roleList.add(new SelectItem("Author")); | |
49 roleList.add(new SelectItem("Annotator")); | |
50 roleList.add(new SelectItem("Copyist")); | |
51 roleList.add(new SelectItem("Corrector")); | |
52 roleList.add(new SelectItem("Dedicatee")); | |
53 roleList.add(new SelectItem("Illuminator")); | |
54 roleList.add(new SelectItem("Illustrator")); | |
55 roleList.add(new SelectItem("Owner")); | |
56 roleList.add(new SelectItem("Patron")); | |
57 roleList.add(new SelectItem("Inspector")); | |
58 } | |
59 | |
60 @Override | |
61 public void reset(){ | |
62 super.reset(); | |
63 this.personName = null; | |
64 this.roleName = "Author"; | |
65 this.rs = null; | |
66 this.personTitleKeyList = null; | |
67 this.displayAlias = false; | |
68 this.displayCodex = false; | |
69 } | |
70 | |
71 @Override | |
72 protected void search(){ | |
73 | |
74 this.displayAlias = false; | |
75 this.displayCodex = false; | |
76 | |
77 List<ResultEntry> rs0 = this.execute01(personName, roleName); | |
78 List<ResultEntry> rs1 = null; | |
79 if(StringUtils.isNotEmpty(personName)){ | |
80 rs1 = this.execute02(personName, roleName); | |
81 } | |
82 rs = loadResultSet(rs0, rs1); | |
83 | |
84 List<Long> idLongList = new ArrayList<Long>(); | |
85 for(Object e : rs){ | |
86 Titles4PersonEntry entry = (Titles4PersonEntry)e; | |
87 if(!idLongList.contains(entry.getPersonId())) | |
88 idLongList.add(entry.getPersonId()); | |
89 } | |
90 this.idList = ApplicationBean.generateIdList(idLongList); | |
91 | |
92 this.exportDirkUrl = ApplicationBean.generateExportURL(exportUrlRoot, idList, "xml"); | |
93 } | |
94 | |
95 | |
96 | |
97 private List<Titles4PersonEntry> loadResultSet(List<ResultEntry> rs0, List<ResultEntry> rs1){ | |
98 List<Titles4PersonEntry> currentRS = new ArrayList<Titles4PersonEntry>(); | |
99 | |
100 List<Long> personIdList = new ArrayList<Long>(); | |
101 | |
102 | |
103 for(ResultEntry re : rs0){ | |
104 Entity person = getOm().getEntityById(re.getEntMap().get(1)); | |
105 personIdList.add(person.getId()); | |
106 currentRS.addAll(getEntryFromPerson(person, null, null, this.roleName)); | |
107 } | |
108 | |
109 if(rs1 != null){ | |
110 for(ResultEntry re : rs1){ | |
111 Entity person = getOm().getEntityById(re.getEntMap().get(1)); | |
112 if(!personIdList.contains(person.getId())){ | |
113 String alias = getOm().getEntityById(re.getEntMap().get(2)).getOwnValue(); | |
114 String alias2Person = re.getRel(2, 1); | |
115 currentRS.addAll(getEntryFromPerson(person, alias, alias2Person, this.roleName)); | |
116 this.displayAlias = true; | |
117 } | |
118 } | |
119 } | |
120 | |
121 return currentRS; | |
122 } | |
123 | |
124 | |
125 /** | |
126 * Possible ways to find a title from a given person | |
127 * 1- TEXT is_exemplar_of WITNESS is_part_of CODEX owned_by PERSON | |
128 * 2- | |
129 * TEXT was_created_by PERSON | |
130 * TEXT had_patron PERSON | |
131 * TEXT was_dedicated_to PERSON | |
132 */ | |
133 private List<Titles4PersonEntry> getEntryFromPerson(Entity person, String alias, String alias2Person, String role){ | |
134 //rs.add(new Titles4PersonEntry(person, title, title2Person, codex, codex2Person, alias, alias2Person, role, subject, )); | |
135 List<Titles4PersonEntry> rs = new ArrayList<Titles4PersonQuery.Titles4PersonEntry>(); | |
136 | |
137 List<Entity> entList = getOm().getSourcesForTargetRelation(person.getId(), "was_created_by", "TEXT", -1); | |
138 for(Entity title : entList){ | |
139 String subject = getSubject(title); | |
140 rs.add(new Titles4PersonEntry(person, title, alias, alias2Person, role, subject, "TEXT was_created_by PERSON")); | |
141 } | |
142 | |
143 entList = getOm().getSourcesForTargetRelation(person.getId(), "had_patron", "TEXT", -1); | |
144 for(Entity title : entList){ | |
145 String subject = getSubject(title); | |
146 rs.add(new Titles4PersonEntry(person, title, alias, alias2Person, role, subject, "TEXT had_patron PERSON")); | |
147 } | |
148 | |
149 | |
150 entList = getOm().getSourcesForTargetRelation(person.getId(), "was_dedicated_to", "TEXT", -1); | |
151 for(Entity title : entList){ | |
152 String subject = getSubject(title); | |
153 rs.add(new Titles4PersonEntry(person, title, alias, alias2Person, role, subject, "TEXT was_dedicated_to PERSON")); | |
154 } | |
155 | |
156 entList = getOm().getSourcesForTargetRelation(person.getId(), "owned_by", "CODEX", -1); | |
157 for(Entity codex : entList){ | |
158 List<Entity> witnessList = getOm().getSourcesForTargetRelation(codex.getId(), "is_part_of", "WITNESS", -1); | |
159 for(Entity witness : witnessList){ | |
160 List<Entity> textList = getOm().getTargetsForSourceRelation(witness.getId(), "is_exemplar_of", "TEXT", -1); | |
161 for(Entity title : textList){ | |
162 String subject = getSubject(title); | |
163 rs.add(new Titles4PersonEntry(person, title, codex, witness, alias, alias2Person, role, subject, | |
164 "TEXT is_exemplar_of WITNESS is_part_of CODEX owned_by PERSON")); | |
165 this.displayCodex = true; | |
166 System.out.println("this.displayCodex = true;"); | |
167 } | |
168 } | |
169 } | |
170 | |
171 return rs; | |
172 } | |
173 | |
174 private String getSubject(Entity title){ | |
175 List<Entity> subjectList = getOm().getTargetsForSourceRelation(title.getId(), "has_subject", "SUBJECT", 1); | |
176 return (subjectList.size() == 0) ? null : subjectList.get(0).getOwnValue(); | |
177 } | |
178 | |
179 private List<ResultEntry> execute01(String personName, String roleName){ | |
180 | |
181 List<SEntity> entFilters = new ArrayList<SEntity>(); | |
182 List<SRelation> relFilters = new ArrayList<SRelation>(); | |
183 | |
184 //The user can select between: | |
185 //"Author", "Annotator", "Copyist", "Corrector", "Dedicatee", "Illuminator", "Illustrator", "Owner", "Patron", "inspector" | |
186 SEntity role = new SEntity(0, "ROLE"); | |
187 role.addAtt(new SAttributeUniqueName("name", roleName)); | |
188 entFilters.add(role); | |
189 | |
190 //alias, "is_prime_alias_name_of", "PERSON" | |
191 //alias, "is_alias_name_of", "PERSON" | |
192 SEntity person = new SEntity(1, "PERSON"); | |
193 if(StringUtils.isNotEmpty(personName)){ | |
194 person.addAtt(new SAttributeMultipleName(personName, "name_translit", "name")); | |
195 } | |
196 entFilters.add(person); | |
197 | |
198 SRelationUniqueName has_role = new SRelationUniqueName(person, role, "has_role"); | |
199 relFilters.add(has_role); | |
200 | |
201 return this.appBean.getSS().search(entFilters, relFilters); | |
202 } | |
203 | |
204 private List<ResultEntry> execute02(String personName, String roleName){ | |
205 | |
206 List<SEntity> entFilters = new ArrayList<SEntity>(); | |
207 List<SRelation> relFilters = new ArrayList<SRelation>(); | |
208 | |
209 //The user can select between: | |
210 //"Author", "Annotator", "Copyist", "Corrector", "Dedicatee", "Illuminator", "Illustrator", "Owner", "Patron", "inspector" | |
211 SEntity role = new SEntity(0, "ROLE"); | |
212 role.addAtt(new SAttributeUniqueName("name", roleName)); | |
213 entFilters.add(role); | |
214 | |
215 //alias, "is_prime_alias_name_of", "PERSON" | |
216 //alias, "is_alias_name_of", "PERSON" | |
217 SEntity person = new SEntity(1, "PERSON"); | |
218 entFilters.add(person); | |
219 | |
220 SEntity alias = new SEntity(2, "ALIAS"); | |
221 alias.addAtt(new SAttributeUniqueName("alias", personName)); | |
222 entFilters.add(alias); | |
223 | |
224 SRelationMultipleName is_alias = new SRelationMultipleName(alias, person, "is_alias_name_of", "is_prime_alias_name_of"); | |
225 SRelationUniqueName has_role = new SRelationUniqueName(person, role, "has_role"); | |
226 relFilters.add(has_role); | |
227 relFilters.add(is_alias); | |
228 | |
229 return this.appBean.getSS().search(entFilters, relFilters); | |
230 } | |
231 | |
232 public String getPersonName() { | |
233 return personName; | |
234 } | |
235 | |
236 public void setPersonName(String personName) { | |
237 this.personName = personName; | |
238 } | |
239 | |
240 public String getRoleName() { | |
241 return roleName; | |
242 } | |
243 | |
244 public void setRoleName(String roleName) { | |
245 this.roleName = roleName; | |
246 } | |
247 | |
248 public List<SRelLongKey> getPersonTitleKeyList() { | |
249 return personTitleKeyList; | |
250 } | |
251 | |
252 public void setPersonTitleKeyList(List<SRelLongKey> personTitleKeyList) { | |
253 this.personTitleKeyList = personTitleKeyList; | |
254 } | |
255 | |
256 public List<SelectItem> getRoleList() { | |
257 return roleList; | |
258 } | |
259 | |
260 public boolean isDisplayCodex() { | |
261 return displayCodex; | |
262 } | |
263 | |
264 public boolean isDisplayAlias() { | |
265 return displayAlias; | |
266 } | |
267 | |
268 | |
269 | |
270 public class Titles4PersonEntry implements Comparable<Titles4PersonEntry>, Serializable{ | |
271 private static final long serialVersionUID = 7798695003500406910L; | |
272 | |
273 private Long personId; | |
274 private String personOv; | |
275 private String personNOv; | |
276 | |
277 private Long titleId; | |
278 private String titleOv; | |
279 private String titleNOv; | |
280 | |
281 private Long codexId; | |
282 private String codexOv; | |
283 private String codex2Person; | |
284 | |
285 private Long witnessId; | |
286 private String witnessOv; | |
287 private String witnessNOv; | |
288 | |
289 private String alias; | |
290 private String alias2Person; | |
291 | |
292 private String role; | |
293 //private String title2Person; | |
294 private String subject; | |
295 | |
296 | |
297 | |
298 private String query; | |
299 | |
300 public Titles4PersonEntry( | |
301 Entity person, | |
302 Entity title, | |
303 Entity codex, | |
304 Entity witness, | |
305 String alias, | |
306 String alias2Person, | |
307 String role, | |
308 String subject, | |
309 String query | |
310 ){ | |
311 | |
312 set(person, title); | |
313 this.alias = alias; | |
314 this.alias2Person = alias2Person; | |
315 this.role = role; | |
316 this.subject = subject; | |
317 this.query = query; | |
318 if(codex != null){ | |
319 this.codexId = codex.getId(); | |
320 this.codexOv = codex.getOwnValue(); | |
321 } | |
322 if(witness != null){ | |
323 this.witnessId = witness.getId(); | |
324 this.witnessOv = witness.getOwnValue(); | |
325 this.witnessNOv = witness.getNormalizedOwnValue(); | |
326 } | |
327 } | |
328 | |
329 public Titles4PersonEntry( | |
330 Entity person, | |
331 Entity title, | |
332 String alias, | |
333 String alias2Person, | |
334 String role, | |
335 String subject, | |
336 String query | |
337 ){ | |
338 | |
339 set(person, title); | |
340 this.alias = alias; | |
341 this.alias2Person = alias2Person; | |
342 this.role = role; | |
343 this.subject = subject; | |
344 this.query = query; | |
345 } | |
346 | |
347 private void set(Entity person, Entity title){ | |
348 this.personId = person.getId(); | |
349 this.personOv = person.getOwnValue(); | |
350 this.personNOv = person.getNormalizedOwnValue(); | |
351 | |
352 this.titleId = title.getId(); | |
353 this.titleOv = title.getOwnValue(); | |
354 this.titleNOv = title.getNormalizedOwnValue(); | |
355 } | |
356 | |
357 public Long getPersonId() { | |
358 return personId; | |
359 } | |
360 | |
361 public String getPersonOv() { | |
362 return personOv; | |
363 } | |
364 | |
365 public String getPersonNOv() { | |
366 return personNOv; | |
367 } | |
368 | |
369 public String getAlias() { | |
370 return alias; | |
371 } | |
372 | |
373 public String getAlias2Person() { | |
374 return alias2Person; | |
375 } | |
376 | |
377 public Long getTitleId() { | |
378 return titleId; | |
379 } | |
380 | |
381 public String getTitleOv() { | |
382 return titleOv; | |
383 } | |
384 | |
385 public String getTitleNOv() { | |
386 return titleNOv; | |
387 } | |
388 | |
389 public String getRole() { | |
390 return role; | |
391 } | |
392 | |
393 public String getSubject() { | |
394 return subject; | |
395 } | |
396 | |
397 public Long getCodexId() { | |
398 return codexId; | |
399 } | |
400 | |
401 public String getCodexOv() { | |
402 return codexOv; | |
403 } | |
404 | |
405 | |
406 public String getCodex2Person() { | |
407 return codex2Person; | |
408 } | |
409 | |
410 public String getQuery() { | |
411 return query; | |
412 } | |
413 | |
414 public Long getWitnessId() { | |
415 return witnessId; | |
416 } | |
417 | |
418 public String getWitnessOv() { | |
419 return witnessOv; | |
420 } | |
421 | |
422 public String getWitnessNOv() { | |
423 return witnessNOv; | |
424 } | |
425 | |
426 @Override | |
427 public int compareTo(Titles4PersonEntry o) { | |
428 if(!this.personId.equals(o.personId)){ | |
429 | |
430 int comparisonPerson = NormalizerUtils.normalizedToCompare(personNOv).compareTo( | |
431 NormalizerUtils.normalizedToCompare(o.personNOv)); | |
432 if(comparisonPerson != 0){ | |
433 return comparisonPerson; | |
434 }else{ | |
435 if(StringUtils.isNotEmpty(role) && StringUtils.isNotEmpty(o.role)){ | |
436 int comparisonRole = this.role.compareTo(o.role); | |
437 if(comparisonRole != 0){ | |
438 return comparisonRole; | |
439 } | |
440 }else{ | |
441 if(StringUtils.isNotEmpty(role)){ | |
442 return -1; | |
443 }else if(StringUtils.isNotEmpty(o.role)){ | |
444 return 1; | |
445 } | |
446 } | |
447 } | |
448 }else{ | |
449 if(!this.titleId.equals(o.titleId)){ | |
450 //comparing subject | |
451 if(StringUtils.isNotEmpty(subject) && StringUtils.isNotEmpty(o.subject)){ | |
452 int comparisonSubject = this.subject.compareTo(o.subject); | |
453 if(comparisonSubject != 0){ | |
454 return comparisonSubject; | |
455 } | |
456 }else{ | |
457 if(StringUtils.isNotEmpty(subject)){ | |
458 return -1; | |
459 }else if(StringUtils.isNotEmpty(o.subject)){ | |
460 return 1; | |
461 } | |
462 } | |
463 //comparing title | |
464 int comparisonTitle = NormalizerUtils.normalizedToCompare(titleNOv).compareTo( | |
465 NormalizerUtils.normalizedToCompare(o.titleNOv)); | |
466 return comparisonTitle; | |
467 } | |
468 } | |
469 return 0; | |
470 } | |
471 } | |
472 | |
473 } |