ExternalVendorCode/openmct
1
0
Fork 0
mirror of https://github.com/nasa/openmct.git synced 2025-05-31 06:31:04 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[Search] Revert to earlier commit

Browse Source 
Reverted to before implementing next(). May re add
back some changes, such as removing validType and
then adding web workers.
This commit is contained in:
shale 2015-07-20 17:02:08 -07:00
parent 1891b24bde
commit f4bd7d7a44
5 changed files with 37 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
platform/features/search/bundle.json
View File

@ -42,7 +42,7 @@
"provides": "searchService", "provides": "searchService",
"type": "provider", "type": "provider",
"implementation": "providers/GenericSearchProvider.js", "implementation": "providers/GenericSearchProvider.js",
"depends": [ "$rootScope", "objectService", "workerService" ] "depends": [ "objectService" ]
}, },
{ {
"provides": "searchService", "provides": "searchService",
@ -55,13 +55,6 @@
"type": "aggregator", "type": "aggregator",
"implementation": "SearchAggregator.js" "implementation": "SearchAggregator.js"
} }
],
"workers": [
{
"key": "genericSearchWorker",
"scriptUrl": "workers/GenericSearchWorker.js",
"depends": [ "objectService" ]
}
] ]
} }
} }

127
platform/features/search/src/SearchAggregator.js
View File

@ -41,8 +41,6 @@ define(
* aggregated * aggregated
*/ */
function SearchAggregator(providers) { function SearchAggregator(providers) {
var compiledResults = [];
// Determines if a searchResult object is a valid type // Determines if a searchResult object is a valid type
// to be displayed as a final result. Is passed to the // to be displayed as a final result. Is passed to the
@ -54,64 +52,21 @@ define(
// Remove extra objects that have the same ID // Remove extra objects that have the same ID
function filterRepeats(results) { function filterRepeats(results) {
var ids = [], var ids = [];
idToIndicies = {}, // 'dictionary' mapping IDs to a list of indicies
filteredResults = [];
// Create a list of indicies of objects that correspond to any object ID
for (var i = 0; i < results.length; i++) {
var id = results[i].id;
if (idToIndicies[id]) {
// If the ID already exists in the dictionary, push this index to
// the end of the array it points to
idToIndicies[id].push(i);
} else {
// Else make a new entry in the dictionary with this ID, pointing
// to this index
idToIndicies[id] = [i];
// And also add this ID to the list of IDs that we have seen
ids.push(id);
}
}
// Now for each ID in the dictionary, we want to use the version of
// the object that has a higher score
for (var i = 0; i < ids.length; i++) {
var id = ids[i],
indicies = idToIndicies[id],
highestScoringObject;
highestScoringObject = results[ indicies[0] ];
for (var j = 0; j < indicies.length; j++) {
// If the score of the object corresponding to this index of the results
// list has a higher score than the one we have, choose it instead
if (results[indicies[j]].score > highestScoringObject.score) {
highestScoringObject = results[indicies[j]];
}
}
filteredResults.push(highestScoringObject);
}
/*
for (var i = 0; i < results.length; i += 1) { for (var i = 0; i < results.length; i += 1) {
if (results[i] === undefined) { if (ids.indexOf(results[i].id) !== -1) {
// Catch any leftover undefined objects
results.splice(i, 1);
i--;
} else if (ids.indexOf(results[i].id) !== -1) {
// If this result's ID is already there, remove the object // If this result's ID is already there, remove the object
results.splice(i, 1); results.splice(i, 1);
// Reduce loop index because we shortened the array // Reduce loop index because we shortened the array
i--; i -= 1;
} else { } else {
// Otherwise add the ID to the list of the ones we have seen // Otherwise add the ID to the list of the ones we have seen
ids.push(results[i].id); ids.push(results[i].id);
} }
} }
*/
return filteredResults; return results;
} }
// Order the objects from highest to lowest score in the array // Order the objects from highest to lowest score in the array
@ -136,8 +91,6 @@ define(
return results; return results;
} }
// 'Loop' over the promises using recursion so that the promises are fufilled by the
// time that we are done
function getPromisedResults(resultsPromises, promiseIndex, finalResults) { function getPromisedResults(resultsPromises, promiseIndex, finalResults) {
if (promiseIndex >= resultsPromises.length) { if (promiseIndex >= resultsPromises.length) {
return finalResults; return finalResults;
@ -149,60 +102,6 @@ define(
} }
} }
function getPromisedItems(promises, index, fufilledPromises) {
if (index >= promises.length) {
return fufilledPromises;
} else {
return promises[index].then(function (results) {
fufilledPromises = fufilledPromises.concat(results);
return getPromisedItems(promises, index + 1, fufilledPromises);
});
}
}
// Add more results to compiledResults
// (As if the user presed 'load more results')
function loadMore() {
}
// Add x number of items to the compiledResults as the initial number of results that
// we display
function initialLoad(firstPromises) {
return getPromisedItems(firstPromises, 0, []).then(function (current) {
// Push the firsts onto the compiledResults
for (var i = 0; i < current.length; i++) {
if (current[i]) {
compiledResults.push(current[i]);
}
}
// Look for more results n times and add them to compiledResults
var outOfResults = [];
for (var i = 0; i < DEFAULT_MAX_RESULTS; i++) {
// If all of the providers are returning undefined, there are
// no more results to load
if (current.every(function (c) {
return c === undefined;
})) {
break;
}
// For each provider, load the next result and add it to compiledResults
for (var j = 0; j < current.length; j++) {
if (current[j]) {
var nextResult = current[j].next();
if (nextResult) {
compiledResults.push(nextResult);
}
current[j] = nextResult;
}
}
}
return compiledResults;
});
}
// Recieves results in the format of a serachResult object. It // Recieves results in the format of a serachResult object. It
// has the members id, object, and score. It has a function // has the members id, object, and score. It has a function
// next() which returns the next highest score search result // next() which returns the next highest score search result
@ -212,15 +111,11 @@ define(
// merges the results lists so that there are not redundant // merges the results lists so that there are not redundant
// results // results
function mergeResults(inputID) { function mergeResults(inputID) {
//var resultsPromises = []; var resultsPromises = [];
// The first result from each provider. Each should have a next() function. // Get result list promises
var firstPromises = [];
// Get the initial result promises
for (var i = 0; i < providers.length; i += 1) { for (var i = 0; i < providers.length; i += 1) {
//resultsPromises.push( resultsPromises.push(
firstPromises.push(
providers[i].query( providers[i].query(
inputID, validType, DEFAULT_MAX_RESULTS, DEFUALT_TIMEOUT inputID, validType, DEFAULT_MAX_RESULTS, DEFUALT_TIMEOUT
) )
@ -228,20 +123,12 @@ define(
} }
// Wait for the promises to fufill // Wait for the promises to fufill
return initialLoad(firstPromises).then(function (c) {
// Get rid of the repeated objects and put in correct order
c = filterRepeats(c);
c = orderByScore(c);
return c;
});
/*
return getPromisedResults(resultsPromises, 0, []).then(function (c) { return getPromisedResults(resultsPromises, 0, []).then(function (c) {
// Get rid of the repeated objects and put in correct order // Get rid of the repeated objects and put in correct order
c = filterRepeats(c); c = filterRepeats(c);
c = orderByScore(c); c = orderByScore(c);
return c; return c;
}); });
*/
} }
return { return {

62
platform/features/search/src/providers/ElasticsearchSearchProvider.js
View File

@ -48,8 +48,6 @@ define(
*/ */
function ElasticsearchSearchProvider($http, objectService, ROOT) { function ElasticsearchSearchProvider($http, objectService, ROOT) {
// TODO: Fix the above docstring // TODO: Fix the above docstring
var latestSearchResults = [],
currentResultIndex = 0;
// Check to see if the input has any special options // Check to see if the input has any special options
function isDefaultFormat(searchTerm) { function isDefaultFormat(searchTerm) {
@ -69,6 +67,7 @@ define(
return searchTerm.split(' ').map(function (s) { return searchTerm.split(' ').map(function (s) {
if (s.includes('"')) { if (s.includes('"')) {
console.log('true');
return s; return s;
} else { } else {
return s + '~' + editDistance; return s + '~' + editDistance;
@ -98,28 +97,6 @@ define(
return searchTerm; return searchTerm;
} }
// Get the next search result
function next() {
// Because elasticsearch only returns matching things, we just
// need to step through the array
currentResultIndex++;
if (currentResultIndex > latestSearchResults.length) {
// If we go past the end of the array, we return undefined
return undefined;
} else {
return latestSearchResults[currentResultIndex];
}
}
function first() {
// Since next() immeditely does 'i++', start before the start of the array
currentResultIndex = -1;
var n = next();
return n;
}
// Processes results from the format that elasticsearch returns to // Processes results from the format that elasticsearch returns to
// a list of objects in the format that mct-representation can use // a list of objects in the format that mct-representation can use
function processResults(rawResults, validType) { function processResults(rawResults, validType) {
@ -127,7 +104,8 @@ define(
resultsLength = results.length, resultsLength = results.length,
ids = [], ids = [],
scores = {}, scores = {},
searchResults = []; searchResults = [],
i;
if (rawResults.data.hits.total > resultsLength) { if (rawResults.data.hits.total > resultsLength) {
// TODO: Somehow communicate this to the user // TODO: Somehow communicate this to the user
@ -135,23 +113,24 @@ define(
} }
// Get the result objects' IDs // Get the result objects' IDs
for (var i = 0; i < resultsLength; i += 1) { for (i = 0; i < resultsLength; i += 1) {
ids.push(results[i][ID]); ids.push(results[i][ID]);
} }
// Get the result objects' scores // Get the result objects' scores
for (var i = 0; i < resultsLength; i += 1) { for (i = 0; i < resultsLength; i += 1) {
//scores.push(results[i][SCORE]);
scores[ ids[i] ] = results[i][SCORE]; scores[ ids[i] ] = results[i][SCORE];
} }
//console.log('scores {}', scores);
// Get the domain objects from their IDs // Get the domain objects from their IDs
return objectService.getObjects(ids).then(function (objects) { return objectService.getObjects(ids).then(function (objects) {
var id,
j;
// Filter by search term // Filter by search term
for (var j = 0; j < resultsLength; j += 1) { for (j = 0; j < resultsLength; j += 1) {
var id = ids[j]; id = ids[j];
// Include items we can get models for // Include items we can get models for
if (objects[id].getModel) { if (objects[id].getModel) {
@ -161,21 +140,13 @@ define(
searchResults.push({ searchResults.push({
id: id, id: id,
object: objects[id], object: objects[id],
score: scores[id], score: scores[id]
next: next
}); });
} }
} }
} }
/* //console.log('searchResults (in ES provider)', searchResults);
for (var k = 0; k < searchResults.length; k++) {
console.log('ES score', searchResults[k].score, 'for', searchResults[k].object.getModel().name);
}
*/
//console.log('setting latest search results with', searchResults);
latestSearchResults = searchResults;
return searchResults; return searchResults;
}); });
} }
@ -220,7 +191,8 @@ define(
searchTerm = processSearchTerm(searchTerm); searchTerm = processSearchTerm(searchTerm);
// Create the query to elasticsearch // Create the query to elasticsearch
esQuery = ROOT + "/_search/?q=" + searchTerm + "&size=" + maxResults; esQuery = ROOT + "/_search/?q=" + searchTerm +
"&size=" + maxResults;
if (timeout) { if (timeout) {
esQuery += "&timeout=" + timeout; esQuery += "&timeout=" + timeout;
} }
@ -231,11 +203,7 @@ define(
url: esQuery url: esQuery
}).then(function (rawResults) { }).then(function (rawResults) {
// ...then process the data // ...then process the data
processResults(rawResults, validType); return processResults(rawResults, validType);
// and return the first result
var f = first();
// console.log('ES return', f);
return f;
}); });
} }

85
platform/features/search/src/providers/GenericSearchProvider.js
View File

@ -44,12 +44,6 @@ define(
* more easy creation of web workers. * more easy creation of web workers.
*/ */
function GenericSearchProvider($rootScope, objectService, workerService) { function GenericSearchProvider($rootScope, objectService, workerService) {
var latestItems = [],
currentResultIndex = 0,
currentSeachInput = '',
curentSearchTerms = [],
validType = function () {return true;};
/* /*
var worker = workerService.run('genericSearchWorker'), var worker = workerService.run('genericSearchWorker'),
lastestItems; lastestItems;
@ -83,19 +77,21 @@ define(
}); });
//counter += 1; //counter += 1;
} }
*/
function handleResponse(event) { function handleResponse(event) {
latest = event.data; latest = event.data;
$rootScope.$apply(); $rootScope.$apply();
//requestNext(); //requestNext();
} }
*/
// Recursive helper function for getItems() // Recursive helper function for getItems()
function itemsHelper(children, i) { function itemsHelper(children, i) {
var date = new Date; var date = new Date;
if (stopTime && date.getTime() >= stopTime) { if (stopTime && date.getTime() >= stopTime) {
// This indexing of items has timed out // This indexing of items has timed out
console.log('timed out');
console.log('returning', children);
return children; return children;
} else if (i >= children.length) { } else if (i >= children.length) {
// Done! // Done!
@ -135,8 +131,7 @@ define(
searchResultItems.push({ searchResultItems.push({
id: items[i].getId(), id: items[i].getId(),
object: items[i], object: items[i],
score: 0, // Assign actual score when filtering for term score: 0 // Assign actual score when filtering for term
next: next
}); });
} }
@ -146,6 +141,8 @@ define(
}); });
} }
// Process the search input. Makes an array of search terms // Process the search input. Makes an array of search terms
// by splitting up the input at spaces. // by splitting up the input at spaces.
function process(input) { function process(input) {
@ -182,9 +179,8 @@ define(
return score * weight; return score * weight;
} }
/*
// Filter through a list of searchResults based on a search term // Filter through a list of searchResults based on a search term
function filterResults(results, originalInput, resultsLength) { function filterResults(results, originalInput, resultsLength, validType) {
var terms, var terms,
searchResults = [], searchResults = [],
itemModel; itemModel;
@ -206,51 +202,6 @@ define(
return searchResults; return searchResults;
} }
*/
// Get the next item from latestItems
function next() {
var i = currentResultIndex,
gotNext = false,
nextResult;
// Look for the next item that qualifies as a search result
while (!gotNext) {
i++;
if (i > latestItems.length) {
// If we go past the end of the array, we return undefined
gotNext = true;
nextResult = undefined;
//currentResultIndex = i;
} else if (latestItems[i]) {
// Prevent errors from getModel not being defined
if (latestItems[i].object.getModel) {
latestItems[i].score = score(latestItems[i], curentSearchTerms, currentSeachInput);
//console.log('item', latestItems[i].object.getModel().name, 'score', latestItems[i].score);
// Include any items that match the terms and are of valid type
if (latestItems[i].score > 0 && validType(latestItems[i].object.getModel())) {
// Add the result to the result list
nextResult = latestItems[i];
//nextResult.next = next;
currentResultIndex = i;
gotNext = true;
}
}
}
}
return nextResult;
}
// Get the first result in latestItems that is a search result
function first(input) {
// Set up the global variables
currentSeachInput = input;
curentSearchTerms = process(input);
// Since next() immeditely does 'i++', start before the start of the array
currentResultIndex = -1;
return next();
}
/** /**
* Searches through the filetree for domain objects which match * Searches through the filetree for domain objects which match
@ -265,15 +216,15 @@ define(
* *
* @param inputID the name of the ID property of the html text * @param inputID the name of the ID property of the html text
* input where this funcion should find the search term * input where this funcion should find the search term
* @param passedValidType (optional) a function which takes a model * @param validType a function which takes a model for an object
* for an object and determines if it is of a valid type to include * and determines if it is of a valid type to include in the
* in the final list of results; default returns true * final list of results
* @param maxResults (optional) the maximum number of results * @param maxResults (optional) the maximum number of results
* that this function should return * that this function should return
* @param timeout (optional) the time after which the search should * @param timeout (optional) the time after which the search should
* stop calculations and return partial results * stop calculations and return partial results
*/ */
function queryGeneric(inputID, passedValidType, maxResults, timeout) { function queryGeneric(inputID, validType, maxResults, timeout) {
var input, var input,
terms = [], terms = [],
searchResults = [], searchResults = [],
@ -286,8 +237,6 @@ define(
maxResults = DEFAULT_MAX_RESULTS; maxResults = DEFAULT_MAX_RESULTS;
} }
// Set the global validType function with the passed one
validType = passedValidType;
// Get the user input // Get the user input
input = document.getElementById(inputID).value; input = document.getElementById(inputID).value;
@ -295,9 +244,6 @@ define(
// Get items list // Get items list
//requestItems(); // Test out the worker //requestItems(); // Test out the worker
return getItems(timeout).then(function (searchResultItems) { return getItems(timeout).then(function (searchResultItems) {
// Set global items variable
latestItems = searchResultItems;
// Keep track of the number of results to display // Keep track of the number of results to display
if (searchResultItems.length < maxResults) { if (searchResultItems.length < maxResults) {
resultsLength = searchResultItems.length; resultsLength = searchResultItems.length;
@ -306,13 +252,10 @@ define(
} }
// Then filter through the items list // Then filter through the items list
//searchResults = filterResults(searchResultItems, input, resultsLength); searchResults = filterResults(searchResultItems, input, resultsLength, validType);
// Get the first search result //console.log('filtered searchResults (in Everything)', searchResults);
var firstResult = first(input); return searchResults;
//console.log('generic return', firstResult);
return firstResult;
}); });
} }

74
platform/features/search/src/workers/GenericSearchWorker.js
View File

@ -1,74 +0,0 @@
/*****************************************************************************
* Open MCT Web, Copyright (c) 2014-2015, United States Government
* as represented by the Administrator of the National Aeronautics and Space
* Administration. All rights reserved.
*
* Open MCT Web is 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.
*
* Open MCT Web includes source code licensed under additional open source
* licenses. See the Open Source Licenses file (LICENSES.md) included with
* this source code distribution or the Licensing information page available
* at runtime from the About dialog for additional information.
*****************************************************************************/
/*global self*/
(function () {
"use strict";
// Recursive helper function for getItems()
function itemsHelper(children, i) {
if (i >= children.length) {
// Done!
return children;
} else if (children[i].hasCapability('composition')) {
// This child has children
return children[i].getCapability('composition').invoke().then(function (grandchildren) {
// Add grandchildren to the end of the list
// They will also be checked for composition
return itemsHelper(children.concat(grandchildren), i + 1);
});
} else {
// This child is a leaf
return itemsHelper(children, i + 1);
}
}
// Converts the filetree into a list
function getItems(objectService) {
// Aquire My Items (root folder)
return objectService.getObjects(['mine']).then(function (objects) {
// Get all of its descendents
return itemsHelper([objects.mine], 0).then(function (items) {
// Turn them into searchResult objects (object, id, and score)
var searchResultItems = [];
for (var i = 0; i < items.length; i += 1) {
searchResultItems.push({
id: items[i].getId(),
object: items[i],
score: 0 // Assign actual score when filtering for term
});
}
//console.log('searchResultItems (in Everything)', searchResultItems);
return searchResultItems;
});
});
}
self.onmessage = function (event) {
//console.log('in worker .. 1');
//console.log('event.data', event.data);
//console.log('objects 0', objects[0]);
self.postMessage(itemsHelper(event.data, 0));
};
}());