https://randaberg.kommune.no/globalassets/layout/js/intellisearch.js

1/**
2 * IntelliSearch search class
3 * @class
4 * @param {string} serviceUrl - The URL for the IntelliSearch SearchService REST API
5 */
6var IntelliSearch = function(serviceUrl) {
7
8	var self = this;
9	
10	self.request = {
11		method: 'GET',
12		mode: 'cors'
13	};
14	
15	/**
16	 * Log function
17	 * @method
18	 * @param {number} level - The log level from 1 to 4
19	 * @param {string} s - The message to log
20	 */
21	self.Log = function(level, s) {
22		if (self.logLevel >= level) { console.log(s); }
23	};
24	
25	/**
26	 * Set the log level
27	 * @method
28	 * @param {number} n - The new log level
29	 */
30	self.SetLogLevel = function(n) {
31		n = n < 1 ? 1 : n > 4 ? 4 : Math.floor(n);
32		self.logLevel = n;
33	};
34
35	/**
36	 * Set the service URL
37	 * @method
38	 * @param {string} url - The URL to set as the service URL
39	 */
40	self.SetServiceUrl = function(url) {
41		self.serviceUrl = url;
42		self.findUrl = self.serviceUrl + 'search/find/';
43		self.categorizeUrl = self.serviceUrl + 'search/categorize/';
44		self.autocompleteUrl = self.autocompleteUrl + 'autocomplete/';
45	};
46
47	/**
48	 * Execute a find, returns a promise
49	 * @method
50	 * @param {string} query - The search query
51	 * @param {Object} params - Optional parameters used to refine the find call
52	 * @returns {Promise}
53	 */
54	self.Find = function(query, params) {
55		query = query || 'test';
56		params = params || {};
57
58		var paramsStr = '';
59		for (var key in params) {
60			if (paramsStr != '') { paramsStr += '&'; }
61			paramsStr += key + '=' + encodeURIComponent(params[key]);
62		}
63		var url = self.findUrl + query + '?' + paramsStr;
64		self.Log(4, 'URL: ' + url);
65
66		var promise = new Promise(function(resolve, reject) {
67		
68			// Generate the fetch request out of the URL and our request variable
69			var request = new Request(url, self.request);
70			
71			// Fetch the request and return JSON
72			fetch(request).then( function fetchSucceeded(response) {
73			
74				if (response.status != 200) {
75					var errorMessage = 'Unexpected status: ' + response.status;
76					self.Log(1, errorMessage);
77					reject(errorMessage);
78					return;
79				}
80				
81				// Return JSON from the response
82				return response.json();
83				
84			}).then( function jsonSucceeded(json) {
85			
86				var data = json;
87				
88				// Enrich the data
89				var pageSize = params.pageSize || params.s || 10;
90				data.EstimatedPageCount = Math.ceil(data.EstimatedMatchCount / pageSize);
91				data.serviceUrl = self.serviceUrl;
92				data.fullUrl = url;
93				data.query = query;
94				data.params = params;
95				data.params.pageNum = data.params.pageNum || 0;
96				
97				// Create the result
98				var findResult = new FindResult(data);
99				
100				// Resolve the promise
101				resolve(findResult);
102				
103			}, function jsonFailed(reason) {
104			
105				self.Log(1, 'Failed to parse JSON. Reason: ' + reason);
106				reject(reason);
107				
108			});
109			
110		});
111
112		return promise;
113	};
114
115	/**
116	 * Execute a categorize, returns a promise
117	 * @method
118	 * @param {string} query - The search query
119	 * @param {Object} params - Optional parameters used to refine the categorize call
120	 * @returns {Promise}
121	 */
122	self.Categorize = function(query, params) {
123		var paramsStr = '';
124		for (var key in params) {
125			if (paramsStr != '') { paramsStr += '&'; }
126			paramsStr += key + '=' + encodeURIComponent(params[key]);
127		}
128		paramsStr = paramsStr.replace("%7C", "|");
129		var url = self.categorizeUrl + query + '?' + paramsStr;
130		self.Log(4, 'URL: ' + url);
131		var promise = new Promise(function(resolve, reject) {
132			var request = new Request(url, self.request);
133			fetch(request).then( function fetchSucceeded(response) {
134				if (response.status != 200) {
135					var errorMessage = 'Unexpected status: ' + response.status;
136					self.Log(1, errorMessage);
137					reject(errorMessage);
138					return;
139				}
140				return response.json();
141			}).then( function jsonSucceeded(json) {
142				var data = json;
143				// Enrich the data
144				data.query = query;
145				data.params = params;
146				// Create the result
147				var categorizeResult = new CategorizeResult(data);
148				resolve(categorizeResult);
149			}, function jsonFailed(reason) {
150				self.Log(1, 'Failed to parse JSON. Reason: ' + reason);
151				reject(reason);
152			});
153		});
154		return promise;
155	};
156
157	/**
158	 * Execute an autocomplete, returns a promise
159	 * @method
160	 * @param {string} query - The search query
161	 * @param {Object} params - Optional parameters used to refine the autocomplete call
162	 * @returns {Promise}
163	 */
164	self.Autocomplete = function(query, params) {
165		var paramsStr = '';
166		for (var key in params) {
167			if (paramsStr != '') { paramsStr += '&'; }
168			paramsStr += key + '=' + encodeURIComponent(params[key]);
169		}
170		var url = self.autocompleteUrl + query + '?' + paramsStr;
171		self.Log(4, 'URL: ' + url);
172		var promise = new Promise(function(resolve, reject) {

173			var request = new Request(url, self.request);
174			fetch(request).then( function fetchSucceeded(response) {
175				if (response.status != 200) {
176					var errorMessage = 'Unexpected status: ' + response.status;
177					self.Log(1, errorMessage);
178					reject(errorMessage);
179					return;
180				}
181				return response.json();
182			}).then( function jsonSucceeded(json) {
183				var data = json;
184				// Enrich the data
185				data.query = query;
186				data.params = params;
187				// Create the result
188				var categorizeResult = new CategorizeResult(data);
189				resolve(categorizeResult);
190			}, function jsonFailed(reason) {
191				self.Log(1, 'Failed to parse JSON. Reason: ' + reason);
192				reject(reason);
193			});
194		});
195		return promise;
196	};
197
198	self.SetLogLevel(3);
199	self.SetServiceUrl(serviceUrl);
200
201};
202
203/**
204 * The find result object
205 * @class
206 * @param {Object} result - an object containing data from the find call
207 */
208var FindResult = function(result) {
209
210	var self = this;
211
212	self.result = result;
213
214	/**
215	 * Get the raw result data
216	 * @method
217	 * @returns {Object}
218	 */
219	self.GetResult = function() { return self.result; }
220
221	/**
222	 * Get the search matches from the result data
223	 * @method
224	 * @returns {Object[]}
225	 */
226	self.GetSearchMatches = function() {
227		if (!self.result.SearchMatches) { return false; }
228		return self.result.SearchMatches;
229	};
230
231	/**
232	 * Get a specific search match by its index in the SearchMatches array
233	 * @method
234	 * @param {number} n - The index of the search match
235	 * @returns {Object}
236	 */
237	self.GetSearchMatch = function(n) {
238		n = n || 0;
239
240		if (!self.result.SearchMatches[n]) { return false; }
241		return self.result.SearchMatches[n];
242	};
243
244	/**
245	 * Execute the find call again, returns a promise
246	 * @method
247	 * @returns {Promise}
248	 */
249	self.Find = function() {
250		var promise = new Promise(function(resolve, reject) {
251			var searchClient = new IntelliSearch(self.result.serviceUrl);
252			searchClient.Find(self.result.query, self.result.params).then( function(result) {
253				resolve(result);
254			});
255		});
256
257		return promise;
258	};
259
260	/**
261	 * Fetch a specific page of search results, returns a promise
262	 * @method
263	 * @param {number} n - Page number to get, pages start from 0
264	 * @returns {Promise}
265	 */
266	self.FetchPage = function(n) {
267		n = n || 0;
268		self.result.params.pageNum = n;
269
270		var promise = new Promise(function(resolve, reject) {
271			self.Find().then( function(result) {
272				resolve(result);
273			});
274		});
275
276		return promise;
277	};
278
279	/**
280	 * Fetch the next page of search results, returns a promise
281	 * @method
282	 * @returns {Promise}
283	 */
284	self.FetchNextPage = function() {
285		self.result.params.pageNum = self.result.NextPageRef;
286
287		var promise = new Promise(function(resolve, reject) {
288			self.Find().then( function(result) {
289				resolve(result);
290			});
291		});
292
293		return promise;
294	};
295	/**
296	 * Get bestbets
297	 */
298	self.GetBestBets = function() {
299		return self.result.BestBets;
300		};
301
302	/**
303	 * Get didyoumeanlist
304	 */
305	self.GetDidYouMeanList = function() {
306		return self.result.DidYouMeanList;
307		};
308	
309	
310	/**
311	 * Get count of searchmatches
312	 */
313	self.GetEstimatedMatchCount = function() {
314		return self.result.EstimatedMatchCount;
315		};
316	/**

317	 * Detects if the current search results has a next page
318	 * @method
319	 * @returns {Boolean}
320	 */
321	self.HasNextPage = function() {
322		if (self.result.params.pageNum + 1 > self.result.EstimatedPageCount) {
323			return false;
324		}
325		return true;
326	};
327
328	/**
329	 * Fetch the previous page of search results, returns a promise
330	 * @method
331	 * @returns {Promise}
332	 */
333	self.FetchPreviousPage = function() {
334		self.result.params.pageNum--;
335
336		var promise = new Promise(function(resolve, reject) {
337			self.Find().then( function(result) {
338				resolve(result);
339			});
340		});
341
342		return promise;
343	};
344
345	/**
346	 * Detects if the current search results has a previous page
347	 * @method
348	 * @returns {Boolean}
349	 */
350	self.HasPreviousPage = function() {
351		if (self.result.params.pageNum - 1 < 0) {
352			return false;
353		}
354		return true;
355	};
356
357	/**
358	 * Fetchthe last page of search results, returns a promise
359	 * @method
360	 * @returns {Promise}
361	 */
362	self.FetchLastPage = function() {
363		self.result.params.pageNum = self.result.EstimatedPageCount;
364
365		var promise = new Promise(function(resolve, reject) {
366			self.Find().then( function(result) {
367				resolve(result);
368			});
369		});
370
371		return promise;
372	};
373
374	/**
375	 * Fetch the first page of search results, returns a promise
376	 * @method
377	 * @returns {Promise}
378	 */
379	self.FetchFirstPage = function() {
380		self.result.params.pageNum = 0;
381
382		var promise = new Promise(function(resolve, reject) {
383			self.Find().then( function(result) {
384				resolve(result);
385			});
386		});
387
388		return promise;
389	};
390
391};
392
393/**
394 * The categorize result object
395 * @class
396 * @param {Object}

396 result - an object containing data from the categorize call
397 */
398var CategorizeResult = function(result) {
399
400	var self = this;
401
402	self.result = result;
403
404	/**
405	 * Get the raw result data
406	 * @method
407	 * @returns {Object}
408	 */
409	self.GetResult = function() { return self.result; }
410
411};
412
413/**
414 * The autocomplete result object
415 * @class
416 * @param {Object} result - an object containing data from the autocomplete call
417 */
418var AutocompleteResult = function(result) {
419
420	var self = this;
421
422	self.result = result;
423
424	/**
425	 * Get the raw result data
426	 * @method
427	 * @returns {Object}
428	 */
429	self.GetResult = function() { return self.result; }
430
431};
432
433/**
434 * The error result object
435 * @class
436 * @param {Object} result - an object containing failed data
437 */
438var ErrorResult = function(result) {
439
440	var self = this;
441
442	self.result = result;
443
444	/**
445	 * Get the raw result data
446	 * @method
447	 * @returns {Object}
448	 */
449	self.GetResult = function() { return self.result; }
450
451};