use of io.vertigo.dynamo.collections.model.FacetedQueryResult in project vertigo by KleeGroup.
the class AbstractSearchManagerTest method testSortedClusterByFacetTerm.
/**
* Test le facettage par term d'une liste.
*/
@Test
public void testSortedClusterByFacetTerm() {
index(true);
final SearchQuery searchQuery = SearchQuery.builder(ListFilter.of("*:*")).withFacetClustering(makeFacetDefinition).build();
final DtListState listState = new DtListState(null, 0, carIndexDefinition.getIndexDtDefinition().getField("YEAR").getName(), true);
final FacetedQueryResult<Car, SearchQuery> result = searchManager.loadList(carIndexDefinition, searchQuery, listState);
// On vérifie qu'il existe une valeur pour chaque marques et que la première est bien la plus ancienne
final Map<String, Set<Car>> databaseCluster = new HashMap<>();
for (final Car car : carDataBase.getAllCars()) {
databaseCluster.computeIfAbsent(car.getMake().toLowerCase(Locale.FRENCH), k -> new TreeSet<>((e1, e2) -> e2.getYear().compareTo(e1.getYear()))).add(car);
}
Assert.assertEquals(databaseCluster.size(), result.getClusters().size());
for (final Entry<FacetValue, DtList<Car>> entry : result.getClusters().entrySet()) {
final String searchFacetLabel = entry.getKey().getLabel().getDisplay().toLowerCase(Locale.FRENCH);
final Car firstClusterCar = entry.getValue().get(0);
final Set<Car> carsByMake = databaseCluster.get(searchFacetLabel);
Assert.assertEquals(carsByMake.iterator().next().getId(), firstClusterCar.getId());
for (final Car car : entry.getValue()) {
Assert.assertEquals(searchFacetLabel, car.getMake().toLowerCase(Locale.FRENCH));
}
}
}
use of io.vertigo.dynamo.collections.model.FacetedQueryResult in project vertigo by KleeGroup.
the class ESFacetedQueryResultBuilder method build.
/**
* {@inheritDoc}
*/
@Override
public FacetedQueryResult<I, SearchQuery> build() {
final Map<I, Map<DtField, String>> resultHighlights = new HashMap<>();
final Map<FacetValue, DtList<I>> resultCluster;
final DtList<I> dtc = new DtList<>(indexDefinition.getIndexDtDefinition());
if (searchQuery.isClusteringFacet()) {
final Map<String, I> dtcIndex = new LinkedHashMap<>();
resultCluster = createCluster(dtcIndex, resultHighlights);
dtc.addAll(dtcIndex.values());
} else {
for (final SearchHit searchHit : queryResponse.getHits()) {
final SearchIndex<?, I> index = esDocumentCodec.searchHit2Index(indexDefinition, searchHit);
final I result = index.getIndexDtObject();
dtc.add(result);
final Map<DtField, String> highlights = createHighlight(searchHit, indexDefinition.getIndexDtDefinition());
resultHighlights.put(result, highlights);
}
resultCluster = Collections.emptyMap();
}
// On fabrique à la volée le résultat.
final List<Facet> facets = createFacetList(searchQuery, queryResponse);
final long count = queryResponse.getHits().getTotalHits();
return new FacetedQueryResult<>(searchQuery.getFacetedQuery(), count, dtc, facets, searchQuery.isClusteringFacet() ? Optional.of(searchQuery.getClusteringFacetDefinition()) : Optional.empty(), resultCluster, resultHighlights, searchQuery);
}
use of io.vertigo.dynamo.collections.model.FacetedQueryResult in project vertigo by KleeGroup.
the class SwaggerApiBuilder method createSchemaObject.
private Map<String, Object> createSchemaObject(final Type type) {
if (type == null) {
// Si le type est null, on a pas réussi à récupérer la class : souvant dans le cas des generics
return unknownObjectRef;
}
// -----
final Map<String, Object> schema = new LinkedHashMap<>();
final Class<?> objectClass = WebServiceTypeUtil.castAsClass(type);
final String[] typeAndFormat = toSwaggerType(objectClass);
schema.put("type", typeAndFormat[0]);
if (typeAndFormat[1] != null) {
schema.put("format", typeAndFormat[1]);
}
if (WebServiceTypeUtil.isAssignableFrom(Collection.class, type)) {
// we known that List has one parameterized type
final Type itemsType = ((ParameterizedType) type).getActualTypeArguments()[0];
// Si le itemsType est null, on prend le unknownObject
// type argument can't be void
schema.put("items", createSchemaObject(itemsType));
} else if ("object".equals(typeAndFormat[0])) {
final String objectName;
final Class<?> parameterClass;
if (type instanceof ParameterizedType && (((ParameterizedType) type).getActualTypeArguments().length == 1 || FacetedQueryResult.class.isAssignableFrom(objectClass)) && !(((ParameterizedType) type).getActualTypeArguments()[0] instanceof WildcardType)) {
// We have checked there is one parameter or we known that FacetedQueryResult has two parameterized type
final Type itemsType = ((ParameterizedType) type).getActualTypeArguments()[0];
parameterClass = WebServiceTypeUtil.castAsClass(itemsType);
objectName = objectClass.getSimpleName() + "<" + parameterClass.getSimpleName() + ">";
} else {
objectName = objectClass.getSimpleName();
parameterClass = null;
}
schema.put("$ref", "#/definitions/" + objectName);
schema.remove("type");
if (!builderDefinitions.containsKey(objectName)) {
final Map<String, Object> definition = new LinkedHashMap<>();
// we put definitions first to avoid infinite resolution loop
builderDefinitions.put(objectName, definition);
if (DtObject.class.isAssignableFrom(objectClass)) {
final Class<? extends DtObject> dtClass = (Class<? extends DtObject>) objectClass;
appendPropertiesDtObject(definition, dtClass);
} else {
appendPropertiesObject(definition, objectClass, parameterClass);
}
}
}
return schema;
}
use of io.vertigo.dynamo.collections.model.FacetedQueryResult in project vertigo by KleeGroup.
the class FacetedQueryResultJsonSerializerV4 method serialize.
/**
* {@inheritDoc}
*/
@Override
public JsonElement serialize(final FacetedQueryResult<?, ?> facetedQueryResult, final Type typeOfSrc, final JsonSerializationContext context) {
final JsonObject jsonObject = new JsonObject();
// 1- add result list as data, with highlight
if (!facetedQueryResult.getClusterFacetDefinition().isPresent()) {
final DtList<?> dtList = facetedQueryResult.getDtList();
final JsonArray jsonList = (JsonArray) context.serialize(dtList);
jsonObject.add("list", jsonList);
jsonObject.addProperty("listType", dtList.getDefinition().getClassSimpleName());
jsonObject.add("highlight", serializeHighLight(dtList, (FacetedQueryResult) facetedQueryResult));
} else {
// if it's a cluster add data's cluster
final JsonArray jsonCluster = new JsonArray();
for (final Entry<FacetValue, ?> cluster : facetedQueryResult.getClusters().entrySet()) {
final DtList<?> dtList = (DtList<?>) cluster.getValue();
if (!dtList.isEmpty()) {
final JsonArray jsonList = (JsonArray) context.serialize(dtList);
final JsonObject jsonClusterElement = new JsonObject();
jsonClusterElement.addProperty("code", cluster.getKey().getCode());
jsonClusterElement.addProperty("label", cluster.getKey().getLabel().getDisplay());
jsonClusterElement.add("list", jsonList);
jsonClusterElement.addProperty("listType", dtList.getDefinition().getClassSimpleName());
jsonClusterElement.addProperty("totalCount", getFacetCount(cluster.getKey(), facetedQueryResult));
jsonClusterElement.add("highlight", serializeHighLight(dtList, (FacetedQueryResult) facetedQueryResult));
jsonCluster.add(jsonClusterElement);
}
}
jsonObject.add("groups", jsonCluster);
}
// 2- add facet list as facets
final List<Facet> facets = facetedQueryResult.getFacets();
final JsonArray jsonFacet = new JsonArray();
for (final Facet facet : facets) {
final JsonArray jsonFacetValues = new JsonArray();
for (final Entry<FacetValue, Long> entry : facet.getFacetValues().entrySet()) {
if (entry.getValue() > 0) {
final JsonObject jsonFacetValuesElement = new JsonObject();
jsonFacetValuesElement.addProperty("code", entry.getKey().getCode());
jsonFacetValuesElement.addProperty("count", entry.getValue());
jsonFacetValuesElement.addProperty("label", entry.getKey().getLabel().getDisplay());
jsonFacetValues.add(jsonFacetValuesElement);
}
}
final JsonObject jsonFacetElement = new JsonObject();
jsonFacetElement.addProperty("code", facet.getDefinition().getName());
jsonFacetElement.addProperty("label", facet.getDefinition().getLabel().getDisplay());
jsonFacetElement.add("values", jsonFacetValues);
jsonFacet.add(jsonFacetElement);
}
jsonObject.add("facets", jsonFacet);
// 3 -add totalCount
jsonObject.addProperty(DtList.TOTAL_COUNT_META, facetedQueryResult.getCount());
return jsonObject;
}
use of io.vertigo.dynamo.collections.model.FacetedQueryResult in project vertigo by KleeGroup.
the class AbstractSearchManagerTest method testSortedClusterByFacetTerm.
/**
* Test le facettage par term d'une liste.
*/
@Test
public void testSortedClusterByFacetTerm() {
index(true);
final SearchQuery searchQuery = SearchQuery.builder(ListFilter.of("*:*")).withFacetClustering(manufacturerFacetDefinition).build();
final DtListState listState = new DtListState(null, 0, itemIndexDefinition.getIndexDtDefinition().getField("YEAR").getName(), true);
final FacetedQueryResult<Item, SearchQuery> result = searchManager.loadList(itemIndexDefinition, searchQuery, listState);
// On vérifie qu'il existe une valeur pour chaque marques et que la première est bien la plus ancienne
final Map<String, Set<Item>> databaseCluster = new HashMap<>();
for (final Item item : itemDataBase.getAllItems()) {
databaseCluster.computeIfAbsent(item.getManufacturer().toLowerCase(Locale.FRENCH), k -> new TreeSet<>((e1, e2) -> e2.getYear().compareTo(e1.getYear()))).add(item);
}
Assert.assertEquals(databaseCluster.size(), result.getClusters().size());
for (final Entry<FacetValue, DtList<Item>> entry : result.getClusters().entrySet()) {
final String searchFacetLabel = entry.getKey().getLabel().getDisplay().toLowerCase(Locale.FRENCH);
final Item firstClusterItem = entry.getValue().get(0);
final Set<Item> itemsByManufacturer = databaseCluster.get(searchFacetLabel);
Assert.assertEquals(itemsByManufacturer.iterator().next().getId(), firstClusterItem.getId());
for (final Item item : entry.getValue()) {
Assert.assertEquals(searchFacetLabel, item.getManufacturer().toLowerCase(Locale.FRENCH));
}
}
}
Aggregations