Project

General

Profile

« Previous | Next » 

Revision 44742

Working on backwards compatibility. IMPORTANT: sygma and refine are not yet compatible

View differences:

SearchRequestController.java
2 2

  
3 3
import com.google.common.collect.Iterables;
4 4
import eu.dnetlib.data.search.app.SearchServiceImpl;
5
import eu.dnetlib.data.search.utils.cql.ParameterQueryEnhancer;
5 6
import eu.dnetlib.data.search.utils.vocabulary.VocabularyManager;
6 7
import eu.dnetlib.domain.data.FormattedSearchResult;
7 8
import org.apache.commons.collections.ListUtils;
......
67 68

  
68 69
	@RequestMapping(value = "/search", method = RequestMethod.GET)
69 70
	public void search(HttpServletRequest request, HttpServletResponse response) {
70

  
71 71
		PrintWriter writer = null;
72 72
		FormattedSearchResult formattedSearchResult = null;
73 73

  
74
		String action = request.getParameter("action");
75
		if (action == null) {
76
			throw new UnsupportedOperationException("Undefined action.");
77
		}
78

  
79
		String query = request.getParameter("query");
80
		if (query == null) {
81
			throw new IncompleteArgumentException("Undefined query. Search request");
82
		}
83

  
74
        String action = readActionParameter(request);
75
        String query = readQueryParameter(request);
84 76
		String format = (request.getParameter("format") != null) ? request.getParameter("format") : "xml";
85
        createResponseMeta(response, format, "UTF-8");
86 77

  
87 78
		String locale = request.getParameter("locale");
88 79

  
80
        //TODO check paging
89 81
		int page = readParameter(request, "page", 1);
90 82
		int size = readParameter(request, "size", 10);
91 83

  
......
95 87

  
96 88
		String sTransformer = request.getParameter("sTransformer");
97 89
		String rTransformer = request.getParameter("rTransformer");
98

  
99 90
		Collection<String> fields = readParameter(request, "fields");
100 91

  
92
        checkTransformerParameters(action, sTransformer, rTransformer, fields);
101 93

  
102
		try {
103
			writer = response.getWriter();
104
			if (action.equals("search")) {
105
				if (sTransformer == null) {
106
					throw new IncompleteArgumentException(
107
							"Undefined search transformer. Search request");
108
				}
94
        try {
95
            createResponseMeta(response, format, "UTF-8");
96
            writer = response.getWriter();
109 97

  
110
				formattedSearchResult = searchService.search(query,
111
						sTransformer, format, locale, page, size);
98
            formattedSearchResult = searchService.searchNrefine(query,
99
                    sTransformer, rTransformer, format, locale, page, size,
100
                    fields);
112 101

  
113
			} else if (action.equals("refine")) {
114
				if (rTransformer == null) {
115
					throw new IncompleteArgumentException(
116
							"Undefined refine transformer. Refine request");
117
				}
118

  
119
				if (fields == null) {
120
					throw new IncompleteArgumentException(
121
							"Undefined refine fields. Refine request");
122
				}
123

  
124
				formattedSearchResult = searchService.refine(query,
125
						rTransformer, format, locale, fields);
126

  
127
			} else if (action.equals("searchNrefine")) {
128

  
129
				if (sTransformer == null) {
130
					throw new IncompleteArgumentException(
131
							"Undefined search transformer. Search and Refine request");
132
				}
133

  
134
				if (rTransformer == null) {
135
					throw new IncompleteArgumentException(
136
							"Undefined refine transformer. Search and Refine request");
137
				}
138

  
139
				if (fields == null) {
140
					throw new IncompleteArgumentException(
141
							"Undefined refine fields. Search and Refine request");
142
				}
143

  
144
				formattedSearchResult = searchService.searchNrefine(query,
145
						sTransformer, rTransformer, format, locale, page, size,
146
						fields);
147

  
148
			} else {
149
				throw new UnsupportedOperationException("The action " + action
150
						+ " is not supported. Please try one of {search, refine, searchNrefine}.");
151
			}
152

  
153 102
			writer.append(formattedSearchResult.getFormattedResult());
154 103

  
155 104
		} catch (Exception e) {
......
163 112
		}
164 113
	}
165 114

  
166
	
115
    private void checkTransformerParameters(String action, String sTransformer, String rTransformer, Collection<String> fields) {
116
        if (action.equals("search")) {
117
            if (sTransformer == null) {
118
                throw new IncompleteArgumentException("Undefined search transformer. Search request");
119
            }
120

  
121
        } else if (action.equals("refine")) {
122
            if (rTransformer == null) {
123
                throw new IncompleteArgumentException(
124
                        "Undefined refine transformer. Refine request");
125
            }
126

  
127
            if (fields == null) {
128
                throw new IncompleteArgumentException(
129
                        "Undefined refine fields. Refine request");
130
            }
131

  
132
        } else if (action.equals("searchNrefine")) {
133

  
134
            if (sTransformer == null) {
135
                throw new IncompleteArgumentException(
136
                        "Undefined search transformer. Search and Refine request");
137
            }
138

  
139
            if (rTransformer == null) {
140
                throw new IncompleteArgumentException(
141
                        "Undefined refine transformer. Search and Refine request");
142
            }
143

  
144
            if (fields == null) {
145
                throw new IncompleteArgumentException(
146
                        "Undefined refine fields. Search and Refine request");
147
            }
148

  
149
        } else {
150
            throw new UnsupportedOperationException("The action " + action
151
                    + " is not supported. Please try one of {search, refine, searchNrefine}.");
152
        }
153
    }
154

  
155
    private String readQueryParameter(HttpServletRequest request) {
156
        String query = request.getParameter("query");
157
        if (query == null) {
158
            throw new IncompleteArgumentException("Undefined query. Search request");
159
        }
160
        return query;
161
    }
162

  
163
    private String readActionParameter(HttpServletRequest request) {
164
        String action = request.getParameter("action");
165
        if (action == null) {
166
            throw new UnsupportedOperationException("Undefined action.");
167
        }
168
        return action;
169
    }
170

  
171

  
167 172
    @RequestMapping(value="/search/openSearchDescriptor", method = RequestMethod.GET)
168 173
    public String printOpenSearchDescriptor(ModelMap model) {
169 174
        return "openSearchDescriptor";
......
195 200

  
196 201
            Collection<String> referrers = readParameter(request,"referrer");
197 202
            String newFormat = defineFormatter(model, format, true, referrers);
198
            logger.debug("FORMATTER " + newFormat);
199 203

  
200 204
            StringBuilder queryBuilder = new StringBuilder();
201 205
            queryBuilder.append(PUBLICATION_BASIC_QUERY);
202 206

  
203
			QueryEnhancer.enhanceQueryWithFundingLevelParams(queryBuilder, request, vocabularyManager, isModelSygma(model));
204
            QueryEnhancer.enhanceQueryWithOpenAIREIds(queryBuilder, request);
205
            QueryEnhancer.enhanceQueryWithMetadataKeywords(queryBuilder, request);
206
            QueryEnhancer.enhanceQueryWithFundingParams(queryBuilder, request);
207
            QueryEnhancer.enhanceQueryWithRelProjectParams(queryBuilder, request);
208
            QueryEnhancer.enhanceQueryWithAccessRights(queryBuilder, request);
209
            QueryEnhancer.enhanceQueryWithDate(queryBuilder, request);
210
            QueryEnhancer.enhanceQueryWithDoi(queryBuilder, request);
207
			ParameterQueryEnhancer.enhanceQueryWithFundingLevelParams(queryBuilder, request, vocabularyManager, isModelSygma(model));
208
            ParameterQueryEnhancer.enhanceQueryWithOpenAIREIds(queryBuilder, request);
209
            ParameterQueryEnhancer.enhanceQueryWithMetadataKeywords(queryBuilder, request);
210
            ParameterQueryEnhancer.enhanceQueryWithFundingParams(queryBuilder, request);
211
            ParameterQueryEnhancer.enhanceQueryWithRelProjectParams(queryBuilder, request);
212
            ParameterQueryEnhancer.enhanceQueryWithAccessRights(queryBuilder, request);
213
            ParameterQueryEnhancer.enhanceQueryWithDate(queryBuilder, request);
214
            ParameterQueryEnhancer.enhanceQueryWithDoi(queryBuilder, request);
211 215

  
212
            QueryEnhancer.enhanceQueryWithResultsSortParameters(queryBuilder, request);
216
            ParameterQueryEnhancer.enhanceQueryWithResultsSortParameters(queryBuilder, request);
213 217

  
214 218
			FormattedSearchResult formattedSearchResult = searchService.search(queryBuilder.toString(),sTransformer, (newFormat!=null)?newFormat:format, locale, page, size);
215 219
			writer.append(formattedSearchResult.getFormattedResult());
......
256 260
            StringBuilder queryBuilder = new StringBuilder();
257 261
            queryBuilder.append(DATASET_BASIC_QUERY);
258 262

  
259
            QueryEnhancer.enhanceQueryWithFundingLevelParams(queryBuilder, request, vocabularyManager, isModelSygma(model));
260
            QueryEnhancer.enhanceQueryWithOpenAIREIds(queryBuilder, request);
261
            QueryEnhancer.enhanceQueryWithMetadataKeywords(queryBuilder, request);
262
            QueryEnhancer.enhanceQueryWithFundingParams(queryBuilder, request);
263
            QueryEnhancer.enhanceQueryWithRelProjectParams(queryBuilder, request);
264
            QueryEnhancer.enhanceQueryWithAccessRights(queryBuilder, request);
265
            QueryEnhancer.enhanceQueryWithDate(queryBuilder, request);
266
            QueryEnhancer.enhanceQueryWithDoi(queryBuilder, request);
263
            ParameterQueryEnhancer.enhanceQueryWithFundingLevelParams(queryBuilder, request, vocabularyManager, isModelSygma(model));
264
            ParameterQueryEnhancer.enhanceQueryWithOpenAIREIds(queryBuilder, request);
265
            ParameterQueryEnhancer.enhanceQueryWithMetadataKeywords(queryBuilder, request);
266
            ParameterQueryEnhancer.enhanceQueryWithFundingParams(queryBuilder, request);
267
            ParameterQueryEnhancer.enhanceQueryWithRelProjectParams(queryBuilder, request);
268
            ParameterQueryEnhancer.enhanceQueryWithAccessRights(queryBuilder, request);
269
            ParameterQueryEnhancer.enhanceQueryWithDate(queryBuilder, request);
270
            ParameterQueryEnhancer.enhanceQueryWithDoi(queryBuilder, request);
267 271

  
268
            QueryEnhancer.enhanceQueryWithResultsSortParameters(queryBuilder, request);
272
            ParameterQueryEnhancer.enhanceQueryWithResultsSortParameters(queryBuilder, request);
269 273

  
270 274
			FormattedSearchResult formattedSearchResult =  searchService.search(queryBuilder.toString(),sTransformer, (newFormat!=null)?newFormat:format, locale, page, size);
271 275
			writer.append(formattedSearchResult.getFormattedResult());
......
311 315

  
312 316
            FormattedSearchResult formattedSearchResult = null;
313 317

  
314
            QueryEnhancer.enhanceProjectQueryWithOpenAIREIds(queryBuilder, request);
315
            QueryEnhancer.enhanceQueryWithProjectMetadataKeywords(queryBuilder, request);
316
            QueryEnhancer.enhanceQueryWithProjectFundingParams(queryBuilder, request);
317
            QueryEnhancer.enhanceProjectQueryWithFundingLevelParams(queryBuilder, request, vocabularyManager);
318
            QueryEnhancer.enhanceQueryWithParticipantsInfoParams(queryBuilder, request);
319
            QueryEnhancer.enhanceQueryWithYearParams(queryBuilder, request);
320
            QueryEnhancer.enhanceQueryWithSC39Params(queryBuilder, request);
318
            ParameterQueryEnhancer.enhanceProjectQueryWithOpenAIREIds(queryBuilder, request);
319
            ParameterQueryEnhancer.enhanceQueryWithProjectMetadataKeywords(queryBuilder, request);
320
            ParameterQueryEnhancer.enhanceQueryWithProjectFundingParams(queryBuilder, request);
321
            ParameterQueryEnhancer.enhanceProjectQueryWithFundingLevelParams(queryBuilder, request, vocabularyManager);
322
            ParameterQueryEnhancer.enhanceQueryWithParticipantsInfoParams(queryBuilder, request);
323
            ParameterQueryEnhancer.enhanceQueryWithYearParams(queryBuilder, request);
324
            ParameterQueryEnhancer.enhanceQueryWithSC39Params(queryBuilder, request);
321 325

  
322
            QueryEnhancer.enhanceQueryWithProjectSortParameters(queryBuilder, request);
326
            ParameterQueryEnhancer.enhanceQueryWithProjectSortParameters(queryBuilder, request);
323 327

  
324 328
			formattedSearchResult = searchService.search(queryBuilder.toString(),sTransformer, format, locale, page, size);
325 329
			writer.append(formattedSearchResult.getFormattedResult());

Also available in: Unified diff