Hibernate Search

@Indexed(index = "HospitalIndex")
@AnalyzerDefs({
        @AnalyzerDef(name = "ngram",
                tokenizer = @TokenizerDef(factory = WhitespaceTokenizerFactory.class),
                filters = {
                        @TokenFilterDef(factory = StandardFilterFactory.class),
                        @TokenFilterDef(factory = LowerCaseFilterFactory.class),
                        @TokenFilterDef(factory = EdgeNGramFilterFactory.class,
                                params = {
                                        @Parameter(name = "minGramSize", value = "1"),
                                        @Parameter(name = "maxGramSize", value = "40")}),
                }),
        @AnalyzerDef(name = "search",
                tokenizer = @TokenizerDef(factory = WhitespaceTokenizerFactory.class),
                filters = {
                        @TokenFilterDef(factory = StandardFilterFactory.class),
                        @TokenFilterDef(factory = LowerCaseFilterFactory.class),
                })
})
public class Hospital {

        @Field(index = Index.YES, analyze = Analyze.YES, store = Store.NO, analyzer = @Analyzer(definition = "ngram"))
        private String name = "";

        @Field(index = Index.YES, analyze = Analyze.YES, store = Store.NO, analyzer = @Analyzer(definition = "ngram"))
        private String shortname = "";

        @IndexedEmbedded
        private Set<MobileGroup> mobileGroups;

}

@Indexed(index = "MobileGroupIndex")
public class MobileGroup {
    @Field(index = Index.YES, analyze = Analyze.YES, store = Store.NO, analyzer = @Analyzer(definition = "ngram"))
        private String name = "";

        @Field(index = Index.YES, analyze = Analyze.YES, store = Store.NO, analyzer = @Analyzer(definition = "ngram"))
        private String shortname = "";
}

// search functions

public List<Hospital> findHospital(String searchString) {
    // Define search paths
    List<List<String>> searchPaths = new ArrayList<>();
    searchPaths.add(Arrays.asList("name", "shortname"));
    searchPaths.add(Arrays.asList("wards.name", "wards.shortname"));
    searchPaths.add(Arrays.asList("mobileGroups.name", "mobileGroups.shortname"));
    searchPaths.add(Arrays.asList("mobileGroups.mobileDevices.name"));
    searchPaths.add(Arrays.asList("wards.rooms.name", "wards.rooms.shortname"));
    searchPaths.add(Arrays.asList("wards.rooms.bedPlaces.name", "wards.rooms.bedPlaces.shortname"));
    searchPaths.add(Arrays.asList("wards.rooms.bedPlaces.communicationDevice.name"));
    searchPaths.add(Arrays.asList("mobileGroups.mobileDevices.communicationDevice.name"));
    searchPaths.add(Arrays.asList("wards.rooms.bedPlaces.communicationDevice.infusionDeviceRuntimeInfos.infusionDevice.identNumber.serialnumber"));
    searchPaths.add(Arrays.asList("wards.rooms.bedPlaces.communicationDevice.identNumber.serialnumber"));
    searchPaths.add(Arrays.asList("mobileGroups.mobileDevices.communicationDevice.identNumber.serialnumber"));
    searchPaths.add(Arrays.asList("mobileGroups.mobileDevices.communicationDevice.infusionDeviceRuntimeInfos.infusionDevice.identNumber.serialnumber"));

    return search(searchString, Hospital.class, searchPaths).collect(Collectors.toList());
}

@SuppressWarnings("unchecked")
private <T> Stream<T> search(String searchString, Class<T> entity, List<List<String>> searchPaths) {
    //check if searchString is empty
    if (searchString == null || searchString.isEmpty()) {
        return Stream.empty();
    }

    boolean exactSearch = false;
    if (searchString.matches("^\".*\"$")) {
        exactSearch = true;
        searchString = searchString.substring(1, searchString.length() - 1);
    } else if (searchString.contains("\"")) {
        return Stream.empty();
    }

    // create native Lucene query unsing the query DSL
    QueryBuilder qb = buildQueryBuilder(entity);

    // search for hospitals, care units, mobile groups, rooms, beds, mobile devices and communication devices
    List<Query> queries;
    if (exactSearch) {
        queries = buildPhraseQueries(qb, searchString, searchPaths);
    } else {
        queries = buildKeywordQueries(qb, searchString, searchPaths);
    }

    Query query = buildConnectedShouldBoolQuery(queries, qb);

    // wrap Lucene query in a javax.persistence.Query
    javax.persistence.Query persistenceQuery = fullTextEntityManager.createFullTextQuery(query, entity);
    // execute search
    return persistenceQuery.getResultList().stream();
}

private QueryBuilder buildQueryBuilder(Class<?> entity) {
    return fullTextEntityManager
    .getSearchFactory()
    .buildQueryBuilder()
    .forEntity(entity)
    .overridesForField("name", "search")
    .overridesForField("shortname", "search")
    .overridesForField("mobileGroups.mobileDevices.communicationDevice.identNumber.serialnumber", "search")
    .overridesForField("mobileGroups.mobileDevices.communicationDevice.infusionDeviceRuntimeInfos.infusionDevice.identNumber.serialnumber", "search")
    .overridesForField("mobileGroups.mobileDevices.communicationDevice.name", "search")
    .overridesForField("mobileGroups.mobileDevices.name", "search")
    .overridesForField("mobileGroups.name", "search")
    .overridesForField("mobileGroups.shortname", "search")
    .overridesForField("mobileDevices.communicationDevice.identNumber.serialnumber", "search")
    .overridesForField("mobileDevices.communicationDevice.infusionDeviceRuntimeInfos.infusionDevice.identNumber.serialnumber", "search")
    .overridesForField("mobileDevices.communicationDevice.name", "search")
    .overridesForField("mobileDevices.name", "search")
    .overridesForField("wards.name", "search")
    .overridesForField("wards.rooms.bedPlaces.communicationDevice.identNumber.serialnumber", "search")
    .overridesForField("wards.rooms.bedPlaces.communicationDevice.infusionDeviceRuntimeInfos.infusionDevice.identNumber.serialnumber", "search")
    .overridesForField("wards.rooms.bedPlaces.communicationDevice.name", "search")
    .overridesForField("wards.rooms.bedPlaces.name", "search")
    .overridesForField("wards.rooms.bedPlaces.shortname", "search")
    .overridesForField("wards.rooms.name", "search")
    .overridesForField("wards.rooms.shortname", "search")
    .overridesForField("wards.shortname", "search")
    .overridesForField("rooms.bedPlaces.communicationDevice.identNumber.serialnumber", "search")
    .overridesForField("rooms.bedPlaces.communicationDevice.infusionDeviceRuntimeInfos.infusionDevice.identNumber.serialnumber", "search")
    .overridesForField("rooms.bedPlaces.communicationDevice.name", "search")
    .overridesForField("rooms.bedPlaces.name", "search")
    .overridesForField("rooms.bedPlaces.shortname", "search")
    .overridesForField("rooms.name", "search")
    .overridesForField("rooms.shortname", "search")
    .overridesForField("communicationDevice.identNumber.serialnumber", "search")
    .overridesForField("communicationDevice.infusionDeviceRuntimeInfos.infusionDevice.identNumber.serialnumber", "search")
    .overridesForField("communicationDevice.name", "search")
    .overridesForField("bedPlaces.communicationDevice.identNumber.serialnumber", "search")
    .overridesForField("bedPlaces.communicationDevice.infusionDeviceRuntimeInfos.infusionDevice.identNumber.serialnumber", "search")
    .overridesForField("bedPlaces.communicationDevice.name", "search")
    .overridesForField("bedPlaces.name", "search")
    .overridesForField("bedPlaces.shortname", "search")
    .overridesForField("infusionDeviceRuntimeInfos.infusionDevice.identNumber.serialnumber", "search")
    .overridesForField("identNumber.serialnumber", "search")
    .get();
}

private static List<Query> buildKeywordQueries(QueryBuilder qb, String keyword, List<List<String>> fieldsList) {
    if (keyword == null || keyword.isEmpty()) {
        return null;
    } else if (fieldsList == null || fieldsList.isEmpty()) {
        return null;
    }
    List<Query> queries = new ArrayList<Query>();
    for (List<String> fields : fieldsList) {
        String[] fieldsArray = fields.toArray(new String[fields.size()]);
        queries.add(buildKeywordQuery(qb, keyword, fieldsArray));
    }
    return queries;
}

private static List<Query> buildPhraseQueries(QueryBuilder qb, String phrase, List<List<String>> fieldsList) {
    if (phrase == null || phrase.isEmpty()) {
        return null;
    } else if (fieldsList == null || fieldsList.isEmpty()) {
        return null;
    }
    List<Query> queries = new ArrayList<Query>();
    for (List<String> fields : fieldsList) {
        String[] fieldsArray = fields.toArray(new String[fields.size()]);
        queries.add(buildPhraseQuery(qb, phrase, fieldsArray));
    }
    return queries;
}


private static Query buildKeywordQuery(QueryBuilder qb, String keyword, String[] fields) {
    if (keyword == null || keyword.isEmpty()) {
        return null;
    }
    return qb.keyword().onFields(fields).matching(keyword).createQuery();
}

private static Query buildPhraseQuery(QueryBuilder qb, String phrase, String[] fields) {
    if (phrase == null || phrase.isEmpty() || fields.length == 0) {
        return null;
    }
    Query query = qb.phrase().onField(fields[0]).ignoreAnalyzer().sentence(phrase).createQuery();
    for (int i = 1; i < fields.length - 1; i++) {
        Query tmp = qb.phrase().onField(fields[i]).ignoreAnalyzer().sentence(phrase).createQuery();
        query = qb.bool().should(query).should(tmp).createQuery();
    }
    return query;
}

private static Query buildConnectedShouldBoolQuery(List<Query> queries, QueryBuilder qb) {
    if (queries.isEmpty()) {
        return null;
    }
    Query booleanQuery = qb.bool().should(queries.get(0)).createQuery();
    for (int i = 1; i < queries.size(); i++) {
        booleanQuery = qb.bool().should(booleanQuery).should(queries.get(i)).createQuery();
    }
    return booleanQuery;
}