private BilingualQueryResult processBilingualDocument(
@NotNull String queryInput, @NotNull Document doc, @NotNull Language targetLanguage) {
BilingualQueryResultBuilder resultBuilder = ImmutableBilingualQueryResult.builder();
processTranslationTable(queryInput, doc, resultBuilder, Language.GERMAN, targetLanguage);
processTranslationTable(queryInput, doc, resultBuilder, targetLanguage, Language.GERMAN);
findRecommendations(doc, resultBuilder);
return resultBuilder.build();
}
private void processEntry(
@NotNull String queryString,
@NotNull Element entryNode,
@NotNull BilingualQueryResultBuilder resultBuilder,
@NotNull Language sourceLanguage,
@NotNull Language targetLanguage) {
if (!StringUtils.equals(entryNode.tag().getName(), "tr")) {
LOGGER.warn("Expected <tr> tag - got <{}>", entryNode.tag().getName());
return;
}
Elements words = entryNode.getElementsByClass("words");
if (words.size() != 2) {
LOGGER.warn("Expected 2 elements with class \"words\" - got {}", words.size());
return;
}
BilingualEntryBuilder entryBuilder = ImmutableBilingualEntry.builder();
entryBuilder.setEntryType(detectEntryType(words.get(0)));
entryBuilder.setInputObject(processSingleNode(words.get(0), sourceLanguage, queryString));
entryBuilder.setOutputObject(processSingleNode(words.get(1), targetLanguage, queryString));
resultBuilder.addBilingualEntry(entryBuilder.build());
}
private void findRecommendations(
@NotNull Document doc, @NotNull BilingualQueryResultBuilder resultBuilder) {
// Determine all candidate nodes:
Elements alternativeNodes = doc.select("div.cc > p > *");
Language currentLanguage = null;
for (Element node : alternativeNodes) {
// If the next node is a flagicon, try to determine the language for the next entries from the
// class name
if (node.tagName().equals("span") && node.hasClass("flagicon")) {
Set<String> classNames = node.classNames();
classNames.remove("flagicon");
for (String className : classNames) {
Language candidate = Language.getExistingLanguageById(className);
if (candidate != null) {
currentLanguage = candidate;
break;
}
}
} else if (node.tagName().equals("a")) {
String recommendationText = node.text();
DictionaryObjectBuilder objectBuilder = ImmutableDictionaryObject.builder();
objectBuilder.setLanguage(currentLanguage).setGeneralForm(recommendationText);
resultBuilder.addSimilarRecommendation(objectBuilder.build());
}
}
}
private void extractBilingualSynonyms(
@NotNull Element translationTable,
@NotNull BilingualQueryResultBuilder resultBuilder,
@NotNull Language sourceLanguage) {
Elements synonymNodes = translationTable.select("tr.translationInlineSynonymsRow");
if (synonymNodes.size() == 0) {
LOGGER.debug("No synonym entries found");
return;
}
String synonymEntryTitle =
translationTable.select(".translationInlineSynonymsTitle span.highlight").first().text();
Map<String, SynonymGroupBuilder> synonymGroupMap = new HashMap<>();
for (Element synonymNode : synonymNodes) {
// Extract only information from the "from"-node (i.e. source language)
Element fromNode = synonymNode.getElementsByClass("from").first();
DictionaryObject newSynonym = processSingleNode(fromNode, sourceLanguage, synonymEntryTitle);
String groupName = newSynonym.getDescription();
if (groupName != null) {
SynonymGroupBuilder groupBuilder =
synonymGroupMap.computeIfAbsent(
groupName,
(s) ->
ImmutableSynonymGroup.builder()
.setBaseMeaning(
ImmutableDictionaryObject.createSimpleObject(sourceLanguage, s)));
groupBuilder.addSynonym(newSynonym);
} else {
LOGGER.warn("Synonym group is null");
}
}
SynonymEntryBuilder synonymEntryBuilder =
ImmutableSynonymEntry.builder()
.setBaseObject(
ImmutableDictionaryObject.createSimpleObject(sourceLanguage, synonymEntryTitle));
for (SynonymGroupBuilder synonymGroupBuilder : synonymGroupMap.values()) {
synonymEntryBuilder.addSynonymGroup(synonymGroupBuilder.build());
}
resultBuilder.addSynonymEntry(synonymEntryBuilder.build());
}
