Examples of org.elasticsearch.view.ViewContext

        if (!getResult.exists()) {
            throw new ElasticSearchIllegalArgumentException("Document not found, cannot render view");
        }


        // Try to get a view stored at document level
        ViewContext viewContext = extract(getResult.sourceAsMap(), request.format());


        if (viewContext == null) {
            // Then, get the view stored in the mapping _meta field
            MappingMetaData mappingMetaData = clusterService.state().metaData().index(request.index()).mapping(request.type());
            if (mappingMetaData != null) {
                try {
                    Map<String, Object> mapping = mappingMetaData.sourceAsMap();
                    viewContext = extract(mapping, request.format());
                } catch (IOException e) {
                    throw new ElasticSearchParseException("Failed to parse mapping content to map", e);
                }
            }
        }


        if (viewContext == null) {
            throw new ElasticSearchViewNotFoundException("No view [" + request.format() + "] found for document type [" + request.type() + "]");
        }


        // Set some org.elasticsearch.test.integration.views.mappings.data required for view rendering
        viewContext.index(getResult.index())
                .type(getResult.type())
                .id(getResult.id())
                .version(getResult.version())
                .source(getResult.sourceAsMap());

                    }
                    if ((candidate != null) && (candidate instanceof Map)) {
                        Map mapCandidate = (Map) candidate;


                        // ViewContext holds the org.elasticsearch.test.integration.views.mappings.data for view rendering
                        ViewContext viewContext = new ViewContext((String) mapCandidate.get("view_lang"), (String) mapCandidate.get("view"), (String) mapCandidate.get("content_type"));


                        Object queries = mapCandidate.get("queries");
                        Map<String, Object> mapQueries = null;


                        if (queries != null) {
                            if (queries instanceof List) {
                                List listQueries = (List) queries;
                                mapQueries = new HashMap<String, Object>(listQueries.size());
                                for (Object query : listQueries) {
                                    if (query instanceof Map) {
                                        Map q = (Map) query;
                                        for (Object queryName : q.keySet()) {
                                            if (queryName instanceof String) {
                                                mapQueries.put((String) queryName, q.get(queryName));
                                            }
                                        }
                                    }
                                }
                            } else if (queries instanceof Map) {
                                mapQueries = (Map) queries;
                            }
                        }


                        if (mapQueries != null) {
                            for (String queryName : mapQueries.keySet()) {
                                try {
                                    Map<String, Object> mapQuery = (Map) mapQueries.get(queryName);


                                    String[] indices = null;
                                    if (mapQuery.get("indices") instanceof List) {
                                        indices = (String[]) ((List) mapQuery.get("indices")).toArray(new String[0]);
                                    } else if (mapQuery.get("indices") instanceof String) {
                                        indices = new String[]{((String) mapQuery.get("indices"))};
                                    }


                                    String[] types = null;
                                    if (mapQuery.get("types") instanceof List) {
                                        types = (String[]) ((List) mapQuery.get("types")).toArray(new String[0]);
                                    } else if (mapQuery.get("types") instanceof String) {
                                        types = new String[]{((String) mapQuery.get("types"))};
                                    }


                                    SearchSourceBuilder searchSourceBuilder = null;
                                    if (mapQuery.get("sort") instanceof List) {
                                        if (searchSourceBuilder == null) {
                                            searchSourceBuilder = new SearchSourceBuilder();
                                        }
                                        for (Object sort : (List) mapQuery.get("sort")) {
                                            if (sort instanceof String) {
                                                searchSourceBuilder.sort((String) sort);
                                            } else if (sort instanceof Map) {
                                                for (Object field : ((Map) sort).keySet()) {
                                                    String sortField = (String) field;
                                                    String reverse = (String) ((Map) sort).get(field);
                                                    if ("asc".equals(reverse)) {
                                                        searchSourceBuilder.sort(sortField, SortOrder.ASC);
                                                    } else if ("desc".equals(reverse)) {
                                                        searchSourceBuilder.sort(sortField, SortOrder.DESC);
                                                    }
                                                }
                                            }
                                        }
                                    }


                                    if (mapQuery.get("fields") instanceof List) {
                                        if (searchSourceBuilder == null) {
                                            searchSourceBuilder = new SearchSourceBuilder();
                                        }
                                        for (Object field : (List) mapQuery.get("fields")) {
                                            if (field instanceof String) {
                                                searchSourceBuilder.field((String) field);
                                            }
                                        }
                                    }


                                    SearchRequest searchRequest = new SearchRequest();
                                    if (indices != null) {
                                        searchRequest.indices(indices);
                                    }
                                    if (types != null) {
                                        searchRequest.types(types);
                                    }


                                    ImmutableMap.Builder<String, Object> builder = ImmutableMap.builder();
                                    builder.put("query", (Map) mapQuery.get("query"));
                                    searchRequest.source(builder.build());


                                    if (searchSourceBuilder != null) {
                                        searchRequest.extraSource(searchSourceBuilder);
                                    }


                                    SearchResponse searchResponse = searchAction.execute(searchRequest).get();
                                    viewContext.queriesAndHits(queryName, searchResponse.hits());


                                } catch (Exception e) {
                                    viewContext.queriesAndHits(queryName, null);
                                }
                            }
                        }
                        return viewContext;
                    }

Examples of org.elasticsearch.view.ViewContext

Related Classes of org.elasticsearch.view.ViewContext