Commit 8504e5da authored by Noel Alonso's avatar Noel Alonso
Browse files

Añade componentes para consultar ObjectCollecting 

Añade tests
parent e7e56e37

time-series-view/src/main/java/es/redmic/timeseriesview/controller/ObjectCollectingSeriesController.java

0 → 100644
+99 −0
Original line number Diff line number Diff line 
package es.redmic.timeseriesview.controller;



/*-

 * #%L

 * Time series view

 * %%

 * Copyright (C) 2019 REDMIC Project / Server

 * %%

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 * #L%

 */



import javax.validation.Valid;



import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.validation.BindingResult;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.web.bind.annotation.RestController;



import es.redmic.exception.databinding.DTONotValidException;

import es.redmic.models.es.common.dto.SuperDTO;

import es.redmic.models.es.common.query.dto.AggsPropertiesDTO;

import es.redmic.models.es.common.query.dto.DataQueryDTO;

import es.redmic.timeserieslib.dto.objectcollecting.ObjectCollectingSeriesDTO;

import es.redmic.timeseriesview.common.controller.RSeriesController;

import es.redmic.timeseriesview.model.objectcollectingseries.ObjectCollectingSeries;

import es.redmic.timeseriesview.service.ObjectCollectingSeriesESService;



@RestController

@RequestMapping(value = "${controller.mapping.OBJECTCOLLECTING}")

public class ObjectCollectingSeriesController extends RSeriesController<ObjectCollectingSeries, ObjectCollectingSeriesDTO, DataQueryDTO> {



	private ObjectCollectingSeriesESService service;



	@Autowired

	public ObjectCollectingSeriesController(ObjectCollectingSeriesESService service) {

		super(service);

		this.service = service;

	}



	@PostMapping(value = "${controller.mapping.OBJECT_CLASSIFICATION_LIST}/_search")

	@ResponseBody

	public SuperDTO findClassificationList(@Valid @RequestBody DataQueryDTO queryDTO, BindingResult bindingResult) {



		AggsPropertiesDTO agg = new AggsPropertiesDTO();

		agg.setField("classificationList");

		queryDTO.addAgg(agg);

		queryDTO.setSize(0);



		if (bindingResult != null && bindingResult.hasErrors())

			throw new DTONotValidException(bindingResult);



		return service.findClassificationList(queryDTO);

	}



	@PostMapping(value = "${controller.mapping.OBJECT_CLASSIFICATION}/_search")

	@ResponseBody

	public SuperDTO findClassification(@Valid @RequestBody DataQueryDTO queryDTO, BindingResult bindingResult) {



		AggsPropertiesDTO agg = new AggsPropertiesDTO();

		agg.setField("classification");

		queryDTO.addAgg(agg);

		queryDTO.setSize(0);



		if (bindingResult != null && bindingResult.hasErrors())

			throw new DTONotValidException(bindingResult);



		return service.findClassificationStatistics(queryDTO);

	}



	@PostMapping(value = "${controller.mapping.SERIES_TEMPORALDATA}/_search")

	@ResponseBody

	public SuperDTO findTemporalData(@Valid @RequestBody DataQueryDTO queryDTO, BindingResult bindingResult) {



		AggsPropertiesDTO agg = new AggsPropertiesDTO();

		agg.setField("temporaldata");

		queryDTO.addAgg(agg);



		queryDTO.setSize(0);



		if (bindingResult != null && bindingResult.hasErrors())

			throw new DTONotValidException(bindingResult);



		return service.findTemporalDataStatistics(queryDTO);

	}

}

time-series-view/src/main/java/es/redmic/timeseriesview/mapper/ObjectCollectingSeriesESMapper.java

0 → 100644
+271 −0
Original line number Diff line number Diff line 
package es.redmic.timeseriesview.mapper;



/*-

 * #%L

 * Time series view

 * %%

 * Copyright (C) 2019 - 2021 REDMIC Project / Server

 * %%

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 * #L%

 */



import java.util.ArrayList;

import java.util.List;

import java.util.Map;



import org.mapstruct.Mapper;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;



import es.redmic.elasticsearchlib.common.utils.ElasticSearchUtils;

import es.redmic.models.es.common.dto.JSONCollectionDTO;

import es.redmic.models.es.common.model.DomainES;

import es.redmic.models.es.geojson.common.domain.dto.ConfidenceDTO;

import es.redmic.models.es.geojson.common.model.Aggregations;

import es.redmic.models.es.maintenance.objects.dto.ObjectClassificationDTO;

import es.redmic.models.es.maintenance.objects.dto.ObjectCollectingDTO;

import es.redmic.models.es.maintenance.objects.model.ObjectClassification;

import es.redmic.models.es.maintenance.objects.model.ObjectType;

import es.redmic.models.es.series.common.model.SeriesHitWrapper;

import es.redmic.models.es.series.common.model.SeriesHitsWrapper;

import es.redmic.models.es.series.common.model.SeriesSearchWrapper;

import es.redmic.models.es.series.objectcollecting.dto.ClassificationForListDTO;

import es.redmic.models.es.series.objectcollecting.dto.ClassificationForPieChartDTO;

import es.redmic.models.es.series.objectcollecting.dto.ClassificationsForListDTO;

import es.redmic.models.es.series.objectcollecting.dto.ClassificationsForPieChartDTO;

import es.redmic.models.es.series.objectcollecting.dto.IntervalAggregationDTO;

import es.redmic.models.es.series.objectcollecting.dto.ObjectClassificationForListDTO;

import es.redmic.timeserieslib.dto.objectcollecting.ObjectCollectingSeriesDTO;

import es.redmic.timeseriesview.common.mapper.SeriesESMapper;

import es.redmic.timeseriesview.model.objectcollectingseries.ObjectCollectingSeries;



@Mapper

public abstract class ObjectCollectingSeriesESMapper extends SeriesESMapper<ObjectCollectingSeriesDTO, ObjectCollectingSeries> {



	protected final Logger LOGGER = LoggerFactory.getLogger(ObjectCollectingSeriesESMapper.class);



	public abstract ConfidenceDTO map(DomainES confidence);



	public abstract List<ObjectClassificationDTO> map(List<ObjectClassification> objectClassifications);



	public abstract ObjectCollectingSeriesDTO mapBase(ObjectCollectingSeries model);



	public ObjectCollectingSeriesDTO map(ObjectCollectingSeries model) {



		ObjectCollectingSeriesDTO dto = mapBase(model);



		if (model.getLocalityConfidence() != null)

			dto.setConfidence(map(model.getLocalityConfidence()));



		return dto;

	}



	public ObjectCollectingSeriesDTO map(SeriesHitWrapper<ObjectCollectingSeries> viewResult) {

		return map(viewResult.get_source());

	}



	public JSONCollectionDTO map(SeriesSearchWrapper<ObjectCollectingSeries> viewResult) {



		JSONCollectionDTO result = map(viewResult.getHits());

		result.set_aggs(getAggs(viewResult.getAggregations()));

		return result;

	}



	public JSONCollectionDTO map(SeriesHitsWrapper<ObjectCollectingSeries> seriesHitsWrapper) {



		JSONCollectionDTO result = new JSONCollectionDTO();

		result.setData(mapList(seriesHitsWrapper.getHits()));

		result.get_meta().setMax_score(seriesHitsWrapper.getMax_score());

		result.setTotal(seriesHitsWrapper.getTotal());

		return result;

	}



	public List<ObjectCollectingSeriesDTO> mapList(List<SeriesHitWrapper<ObjectCollectingSeries>> dataHitWrapper) {



		List<ObjectCollectingSeriesDTO> list = new ArrayList<>();

		for (SeriesHitWrapper<ObjectCollectingSeries> entity : dataHitWrapper) {

			list.add(map(entity));

		}

		return list;

	}



	@SuppressWarnings("unchecked")

	public ClassificationsForListDTO convertToList(Aggregations source) {

		ClassificationsForListDTO classificationList = new ClassificationsForListDTO();



		Map<String, Object> aggregations = source.getAttributes();

		if (aggregations == null || aggregations.size() == 0)

			return classificationList;



		List<Map<String, Object>> classificationType = ElasticSearchUtils.getBucketsFromAggregations(aggregations);



		List<ClassificationForListDTO> classifications = new ArrayList<>();

		for (int i = 0; i < classificationType.size(); i++) {

			/** Nuevo tipo de clasificación **/

			ClassificationForListDTO classification = new ClassificationForListDTO();

			classification.setName(classificationType.get(i).get("key").toString());

			/** Obtiene las estadisticas a nivel de tipo de classificación **/

			List<Map<String, Object>> timeIntervals = ElasticSearchUtils

					.getBucketsFromAggregations((Map<String, Object>) classificationType.get(i).get("timeIntervals"));

			for (int timeIntervalsIt = 0; timeIntervalsIt < timeIntervals.size(); timeIntervalsIt++) {

				classification.addHeader(timeIntervals.get(timeIntervalsIt).get("key_as_string").toString());

				classification.addV(getValue((Map<String, Object>) timeIntervals.get(timeIntervalsIt).get("value")));

			}

			/** Obtiene todas las clasificaciones del tipo actual **/

			List<Map<String, Object>> levels = ElasticSearchUtils.getBucketsFromAggregations(

					(Map<String, Object>) classificationType.get(i).get("objectClassification"));

			List<ObjectClassificationForListDTO> data = new ArrayList<>();



			for (int levelIt = 0; levelIt < levels.size(); levelIt++) { // niveles de clasificación



				/** Obtiene cada uno de los elementos de la clasificación **/

				List<Map<String, Object>> objects = ElasticSearchUtils.getBucketsFromAggregations(

						(Map<String, Object>) levels.get(levelIt).get("objectClassificationPath"));

				boolean isLeave = (levelIt == levels.size() - 1);



				for (int objectIt = 0; objectIt < objects.size(); objectIt++) { // objectos

					ObjectClassificationForListDTO object = new ObjectClassificationForListDTO();

					object.initV(classification.getHeaderSize());

					object.setPath(objects.get(objectIt).get("key").toString());

					if (!isLeave)

						object.setLeaves(1);



					List<Map<String, Object>> type = ElasticSearchUtils.getBucketsFromAggregations(

							(Map<String, Object>) objects.get(objectIt).get("objectClassificationName"));

					object.setCategory(type.get(0).get("key").toString());



					List<Map<String, Object>> timeIntervalsObject = ElasticSearchUtils

							.getBucketsFromAggregations((Map<String, Object>) type.get(0).get("timeIntervals"));



					for (int timeIntervalsIt = 0; timeIntervalsIt < timeIntervalsObject.size(); timeIntervalsIt++) {

						// posición donde se debe insertar el dato y que depende del intervalo actual

						int pos = classification

								.getHeaderPos(timeIntervalsObject.get(timeIntervalsIt).get("key_as_string").toString());



						Map<String, Object> stats = (Map<String, Object>) timeIntervalsObject.get(timeIntervalsIt)

								.get("value");

						object.setV(pos, getValue(stats));

						// Setea el número de hijos si no es una hoja

						Integer count = (Integer) stats.get("count");

						if (!isLeave && (count > object.getLeaves()))

							object.setLeaves(count);

					}

					data.add(object);

				}

				classification.setData(data);

			}

			classifications.add(classification);

		}

		classificationList.setClassification(classifications);

		return classificationList;

	}



	@SuppressWarnings("unchecked")

	public ClassificationsForPieChartDTO convertToPieChart(Aggregations source) {

		ClassificationsForPieChartDTO classificationList = new ClassificationsForPieChartDTO();



		Map<String, Object> aggregations = source.getAttributes();

		if (aggregations == null || aggregations.size() == 0)

			return classificationList;



		List<Map<String, Object>> classificationIntervals = ElasticSearchUtils.getBucketsFromAggregations(aggregations);



		List<ClassificationForPieChartDTO> classifications = new ArrayList<>();

		for (int i = 0; i < classificationIntervals.size(); i++) {



			String timeInterval = classificationIntervals.get(i).get("key_as_string").toString();



			List<Map<String, Object>> types = ElasticSearchUtils

					.getBucketsFromAggregations((Map<String, Object>) classificationIntervals.get(i).get("object"));



			for (int typesIt = 0; typesIt < types.size(); typesIt++) {



				/** Nuevo tipo de clasificación para el interval **/



				IntervalAggregationDTO interval = new IntervalAggregationDTO();

				interval.setTimeInterval(timeInterval);



				String classificationName = types.get(typesIt).get("key").toString();



				ClassificationForPieChartDTO classification = getClassificationForName(classifications,

						classificationName);



				List<IntervalAggregationDTO> data = classification.getData();



				/** Obtiene todas las clasificaciones para recorrerlas por niveles **/

				List<Map<String, Object>> levels = ElasticSearchUtils.getBucketsFromAggregations(

						(Map<String, Object>) types.get(typesIt).get("objectClassification"));



				for (int levelIt = 0; levelIt < levels.size(); levelIt++) {



					/**

					 * Obtiene cada uno de los elementos de la clasificación

					 **/

					List<Map<String, Object>> objects = ElasticSearchUtils.getBucketsFromAggregations(

							(Map<String, Object>) levels.get(levelIt).get("objectClassificationPath"));



					for (int objectIt = 0; objectIt < objects.size(); objectIt++) { // objectos



						List<Map<String, Object>> type = ElasticSearchUtils.getBucketsFromAggregations(

								(Map<String, Object>) objects.get(objectIt).get("objectClassificationName"));

						/**

						 * Obtiene las estadisticas a nivel de tipo de classificación

						 **/

						Map<String, Object> stats = (Map<String, Object>) type.get(0).get("stats");



						interval.addCategory(objects.get(objectIt).get("key").toString(),

								type.get(0).get("key").toString(), getValue((Map<String, Object>) stats.get("value")));

					}

				}

				data.add(interval);

				classification.setData(data);



				addToClassifications(classifications, classification);

			}

		}

		classificationList.setClassification(classifications);

		return classificationList;

	}



	private ClassificationForPieChartDTO getClassificationForName(List<ClassificationForPieChartDTO> classifications,

			String classificationName) {



		for (int i = 0; i < classifications.size(); i++) {

			if (classifications.get(i).getName().equals(classificationName))

				return classifications.get(i);

		}



		ClassificationForPieChartDTO classification = new ClassificationForPieChartDTO();

		classification.setName(classificationName);

		classification.setData(new ArrayList<>());

		return classification;

	}



	private void addToClassifications(List<ClassificationForPieChartDTO> classifications,

			ClassificationForPieChartDTO classification) {



		if (!classifications.contains(classification))

			classifications.add(classification);

	}



	private int getValue(Map<String,Object> stats) {



		Object sum = stats.get("sum");

		int value = 0;

		if (sum != null)

			value = (int) (double) stats.get("sum");



		return value;

	}

}

time-series-view/src/main/java/es/redmic/timeseriesview/model/objectcollectingseries/ObjectCollectingSeries.java

0 → 100644
+155 −0
Original line number Diff line number Diff line 
package es.redmic.timeseriesview.model.objectcollectingseries;



/*-

 * #%L

 * Models

 * %%

 * Copyright (C) 2019 REDMIC Project / Server

 * %%

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 * #L%

 */



import java.util.List;



import es.redmic.models.es.common.model.DomainES;

import es.redmic.models.es.geodata.ancillarydata.model.Analytic;

import es.redmic.models.es.geodata.ancillarydata.model.Metric;

import es.redmic.models.es.geodata.genomics.model.Molecular;

import es.redmic.models.es.geodata.misc.model.Element;

import es.redmic.models.es.geodata.qualifiers.model.Attribute;

import es.redmic.models.es.geodata.samples.model.Sample;

import es.redmic.models.es.maintenance.objects.model.ObjectClassification;

import es.redmic.timeseriesview.model.common.SeriesCommon;



public class ObjectCollectingSeries extends SeriesCommon {



	private Double radius;



	private String collectorName;



	private String collectionRegNo;



	private DomainES confidence;

	private DomainES localityConfidence;



	private List<ObjectClassification> object;



	private List<Analytic> analytics;



	private List<Attribute> attributes;



	private List<Metric> metrics;



	private List<Molecular> molecular;



	private List<Element> elements;



	private Sample sample;



	public Double getRadius() {

		return radius;

	}



	public void setRadius(Double radius) {

		this.radius = radius;

	}



	public String getCollectorName() {

		return collectorName;

	}



	public void setCollectorName(String collectorName) {

		this.collectorName = collectorName;

	}



	public String getCollectionRegNo() {

		return collectionRegNo;

	}



	public void setCollectionRegNo(String collectionRegNo) {

		this.collectionRegNo = collectionRegNo;

	}



	public DomainES getConfidence() {

		return confidence;

	}



	public void setConfidence(DomainES confidence) {

		this.confidence = confidence;

	}



	public DomainES getLocalityConfidence() {

		return localityConfidence;

	}



	public void setLocalityConfidence(DomainES localityConfidence) {

		this.localityConfidence = localityConfidence;

	}



	public List<ObjectClassification> getObject() {

		return object;

	}



	public void setObject(List<ObjectClassification> object) {

		this.object = object;

	}



	public List<Analytic> getAnalytics() {

		return analytics;

	}



	public void setAnalytics(List<Analytic> analytics) {

		this.analytics = analytics;

	}



	public List<Attribute> getAttributes() {

		return attributes;

	}



	public void setAttributes(List<Attribute> attributes) {

		this.attributes = attributes;

	}



	public List<Metric> getMetrics() {

		return metrics;

	}



	public void setMetrics(List<Metric> metrics) {

		this.metrics = metrics;

	}



	public List<Molecular> getMolecular() {

		return molecular;

	}



	public void setMolecular(List<Molecular> molecular) {

		this.molecular = molecular;

	}



	public List<Element> getElements() {

		return elements;

	}



	public void setElements(List<Element> elements) {

		this.elements = elements;

	}



	public Sample getSample() {

		return sample;

	}



	public void setSample(Sample sample) {

		this.sample = sample;

	}

}

time-series-view/src/main/java/es/redmic/timeseriesview/repository/ObjectCollectingSeriesESRepository.java

0 → 100644
+167 −0

File added.

Preview size limit exceeded, changes collapsed.

time-series-view/src/main/java/es/redmic/timeseriesview/service/ObjectCollectingSeriesESService.java

0 → 100644
+128 −0
Original line number Diff line number Diff line 
package es.redmic.timeseriesview.service;



/*-

 * #%L

 * Time series view

 * %%

 * Copyright (C) 2019 REDMIC Project / Server

 * %%

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 * #L%

 */



import java.util.List;



import org.mapstruct.factory.Mappers;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;



import es.redmic.models.es.common.dto.ElasticSearchDTO;

import es.redmic.models.es.common.dto.JSONCollectionDTO;

import es.redmic.models.es.common.query.dto.DataQueryDTO;

import es.redmic.models.es.series.common.model.SeriesHitWrapper;

import es.redmic.models.es.series.common.model.SeriesHitsWrapper;

import es.redmic.models.es.series.common.model.SeriesSearchWrapper;

import es.redmic.models.es.series.objectcollecting.dto.ClassificationsForListDTO;

import es.redmic.models.es.series.objectcollecting.dto.ClassificationsForPieChartDTO;

import es.redmic.models.es.series.timeseries.dto.DataHistogramDTO;

import es.redmic.timeserieslib.dto.objectcollecting.ObjectCollectingSeriesDTO;

import es.redmic.timeseriesview.common.service.RSeriesESService;

import es.redmic.timeseriesview.mapper.DataHistogramESMapper;

import es.redmic.timeseriesview.mapper.ObjectCollectingSeriesESMapper;

import es.redmic.timeseriesview.model.objectcollectingseries.ObjectCollectingSeries;

import es.redmic.timeseriesview.repository.ObjectCollectingSeriesESRepository;



@Service

public class ObjectCollectingSeriesESService

		extends RSeriesESService<ObjectCollectingSeries, ObjectCollectingSeriesDTO, DataQueryDTO> {



	private static final String DEFAULT_SEARCH_FIELD = "remark";



	int nestingDepth = 2;



	ObjectCollectingSeriesESRepository repository;



	@Autowired

	public ObjectCollectingSeriesESService(ObjectCollectingSeriesESRepository repository) {

		super(repository);

		this.repository = repository;

	}



	@SuppressWarnings("unchecked")

	public ElasticSearchDTO findClassificationList(DataQueryDTO query) {



		SeriesSearchWrapper<ObjectCollectingSeries> response = repository.find(query);



		ClassificationsForListDTO dtoOut = Mappers.getMapper(ObjectCollectingSeriesESMapper.class)

			.convertToList(response.getAggregations());



		return new ElasticSearchDTO(dtoOut.getClassification(), dtoOut.getClassification().size());

	}



	@SuppressWarnings("unchecked")

	public ElasticSearchDTO findClassificationStatistics(DataQueryDTO query) {



		SeriesSearchWrapper<ObjectCollectingSeries> response = repository.find(query);



		ClassificationsForPieChartDTO dtoOut = Mappers.getMapper(ObjectCollectingSeriesESMapper.class)

			.convertToPieChart(response.getAggregations());



		return new ElasticSearchDTO(dtoOut.getClassification(), dtoOut.getClassification().size());

	}



	@SuppressWarnings("unchecked")

	public ElasticSearchDTO findTemporalDataStatistics(DataQueryDTO query) {



		SeriesSearchWrapper<ObjectCollectingSeries> response = repository.find(query);



		DataHistogramDTO dtoOut = Mappers.getMapper(DataHistogramESMapper.class).map(response.getAggregations());



		dtoOut.setDataDefinitionIds((List<Integer>) query.getTerms().get("dataDefinition"));

		return new ElasticSearchDTO(dtoOut, dtoOut.getData().size());

	}



	@Override

	protected ObjectCollectingSeriesDTO viewResultToDTO(SeriesHitWrapper<ObjectCollectingSeries> viewResult) {

		return Mappers.getMapper(ObjectCollectingSeriesESMapper.class).map(viewResult);

	}



	@Override

	protected ObjectCollectingSeriesDTO viewResultToDTO(ObjectCollectingSeries model) {

		return Mappers.getMapper(ObjectCollectingSeriesESMapper.class).map(model);

	}



	@Override

	protected JSONCollectionDTO viewResultToDTO(SeriesSearchWrapper<ObjectCollectingSeries> viewResult) {

		return Mappers.getMapper(ObjectCollectingSeriesESMapper.class).map(viewResult);

	}



	@Override

	protected JSONCollectionDTO viewResultToDTO(SeriesHitsWrapper<ObjectCollectingSeries> viewResult) {

		return Mappers.getMapper(ObjectCollectingSeriesESMapper.class).map(viewResult);

	}



	@Override

	protected String[] getDefaultSearchFields() {

		return new String[] { DEFAULT_SEARCH_FIELD };

	}



	@Override

	protected String[] getDefaultHighlightFields() {

		return new String[] { DEFAULT_SEARCH_FIELD };

	}



	@Override

	protected String[] getDefaultSuggestFields() {

		return new String[] { DEFAULT_SEARCH_FIELD };;

	}

}