ElasticSearchPage_Controller::dealWithAggregation() - Code Metrics - gordonbanderson/silverstripe-elastica - Measure and Improve Code Quality continuously with Scrutinizer

dealWithAggregation() A
last analyzed 2016-01-04 04:20 UTC

↳ Parent: ElasticSearchPage_Controller

Complexity

Conditions	4
Paths	6

Size

Total Lines	18
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Metric	Value
dl	0
loc	18
ccs	0
cts	14
cp	0
rs	9.2
cc	4
eloc	10
nc	6
nop	1
crap	20

<?php

use Elastica\Document;
use Elastica\Query;
use \SilverStripe\Elastica\ResultList;
use Elastica\Query\QueryString;
use Elastica\Aggregation\Filter;
use Elastica\Filter\Term;
use Elastica\Filter\BoolAnd;
use Elastica\Aggregation\Terms;
use Elastica\Query\Filtered;
use Elastica\Query\Range;
use \SilverStripe\Elastica\ElasticSearcher;
use \SilverStripe\Elastica\Searchable;
use \SilverStripe\Elastica\QueryGenerator;
use \SilverStripe\Elastica\ElasticaUtil;

class ElasticSearchPage_Controller extends Page_Controller {


	private static $allowed_actions = array('SearchForm', 'submit', 'index', 'similar');

	public function init() {
		parent::init();

		Requirements::javascript(THIRDPARTY_DIR . '/jquery/jquery.js');
		Requirements::javascript("elastica/javascript/jquery.autocomplete.js");
		Requirements::javascript("elastica/javascript/elastica.js");
		Requirements::css("elastica/css/elastica.css");

		$this->SearchPage = Controller::curr()->dataRecord;
	}



	/*
	Find DataObjects in Elasticsearch similar to the one selected.  Note that aggregations are not
	taken into account, merely the text of the selected document.
	 */
	public function similar() {
		//FIXME double check security, ie if escaping needed
		$class = $this->request->param('ID');
		$instanceID = $this->request->param('OtherID');

		$es = $this->primeElasticSearcherFromRequest();
		$data = $this->initialiseDataArray();
		$this->setMoreLikeThisParamsFromRequest($es);
		$this->addSiteTreeFilterIfRequired($es);
		$this->getSelectedSearchFields('SimilarSearchable');

		try {
			$this->checkForSimulatedServerDown();
			if(class_exists($class)) {
				$instance = \DataObject::get_by_id($class, $instanceID);
				print_r($this->FieldsToSearch);
				$paginated = $es->moreLikeThis($instance, $this->FieldsToSearch);
				$this->Aggregations = $es->getAggregations();
				$this->successfulSearch($data, $paginated);
				$data['SimilarTo'] = $instance;
				$this->getSimilarTerms($data, $paginated);

			} else {
				// class does not exist
				$data['ErrorMessage'] = "Class $class is either not found or not searchable\n";
			}
		} catch (\InvalidArgumentException $e) {
			$data['ErrorMessage'] = "Class $class is either not found or not searchable\n";
		} catch (Elastica\Exception\Connection\HttpException $e) {
			$data['ErrorMessage'] = 'Unable to connect to search server';
		}
		return $this->renderResults($data);
	}


	private function getSimilarTerms(&$data, &$paginated) {
		$moreLikeThisTerms = $paginated->getList()->MoreLikeThisTerms;
		$fieldToTerms = new ArrayList();
		foreach(array_keys($moreLikeThisTerms) as $fieldName) {
			$readableFieldName = str_replace('.standard', '', $fieldName);
			$fieldTerms = new ArrayList();
			foreach($moreLikeThisTerms[$fieldName] as $value) {
				$do = new DataObject();
				$do->Term = $value;
				$fieldTerms->push($do);
			}

			$do = new DataObject();
			$do->FieldName = $readableFieldName;
			$do->Terms = $fieldTerms;
			$fieldToTerms->push($do);
		}

		$data['SimilarSearchTerms'] = $fieldToTerms;
	}

	/*
	Display the search form. If the query parameter exists, search against Elastica
	and render results accordingly.
	 */
	public function index() {
		$es = $this->primeElasticSearcherFromRequest();
		$data = $this->initialiseDataArray();
		$this->dealWithAggregation($es);
		$this->addSiteTreeFilterIfRequired($es);
		$this->getSelectedSearchFields();

		$paginated = null;
		try {
			$this->checkForSimulatedServerDown();

			// now actually perform the search using the original query
			$paginated = $es->search($this->QueryText, $this->FieldsToSearch,$this->TestMode);

			// Deal with a possible suggested query
			$this->dealWithSuggestedQuery($es, $data, $paginated);

			$this->Aggregations = $es->getAggregations();
			$this->successfulSearch($data, $paginated);
		} catch (Elastica\Exception\Connection\HttpException $e) {
			$data['ErrorMessage'] = 'Unable to connect to search server';
		}

		return $this->renderResults($data);
	}


	private function dealWithSuggestedQuery(&$es, &$data, &$paginated) {
		// This is the case of the original query having a better one suggested.  Do a
		// second search for the suggested query, throwing away the original
		if($es->hasSuggestedQuery() && !$this->IgnoreSuggestions) {
			$data['SuggestedQuery'] = $es->getSuggestedQuery();
			$data['SuggestedQueryHighlighted'] = $es->getSuggestedQueryHighlighted();
			//Link for if the user really wants to try their original query
			$sifLink = rtrim($this->Link(), '/') . '?q=' . $this->QueryText . '&is=1';
			$data['SearchInsteadForLink'] = $sifLink;
			$paginated = $es->search($es->getSuggestedQuery(), $this->FieldsToSearch);
		}
	}


	private function successfulSearch(&$data, $paginated) {
		$data['SearchResults'] = $paginated;
		$data['SearchPerformed'] = true;
		$data['NumberOfResults'] = $paginated->getTotalItems();
		$data['SearchPageLink'] = $this->SearchPage->Link();
		$data['ElapsedTime'] = $this->calculateTime();
	}


	/*
	Return true if the query is not empty
	 */
	public function QueryIsEmpty() {
		return empty($this->request->getVar('q'));
	}


	/**
	 * Process submission of the search form, redirecting to a URL that will render search results
	 * @param  array $data form data
	 * @param  Form $form form
	 */
	public function submit($data, $form) {
		$queryText = $data['q'];
		$url = $this->Link();
		$url = rtrim($url, '/');
		$link = rtrim($url, '/') . '?q=' . $queryText . '&sfid=' . $data['identifier'];
		$this->redirect($link);
	}


	/*
	Obtain an instance of the form
	*/
	public function SearchForm() {
		$form = new ElasticSearchForm($this, 'SearchForm');
		$fields = $form->Fields();
		$elasticaSearchPage = Controller::curr()->dataRecord;
		$identifierField = new HiddenField('identifier');
		$identifierField->setValue($elasticaSearchPage->Identifier);

		$fields->push($identifierField);
		$queryField = $fields->fieldByName('q');

		 if($this->isParamSet('q') && $this->isParamSet('sfid')) {
		 	$sfid = $this->request->getVar('sfid');
			if($sfid == $elasticaSearchPage->Identifier) {

				$queryText = $this->request->getVar('q');
				$queryField->setValue($queryText);
			}

		}

		if($this->action == 'similar') {
			$queryField->setDisabled(true);
			$actions = $form->Actions();
			if(!empty($actions)) {
				foreach($actions as $field) {
					$field->setDisabled(true);
				}
			}

		}

		if($this->AutoCompleteFieldID > 0) {
			ElasticaUtil::addAutocompleteToQueryField(
				$queryField,
				$this->ClassesToSearch,
				$this->SiteTreeOnly,
				$this->Link(),
				$this->AutocompleteFunction()->Slug
			);
		}
		return $form;
	}


	/**
	 * @param string $paramName
	 */
	private function isParamSet($paramName) {
		return !empty($this->request->getVar($paramName));
	}


	/**
	 * Set the start page from the request and results per page for a given searcher object
	 */
	private function primeElasticSearcherFromRequest() {
		$elasticSearcher = new ElasticSearcher();
		// start, and page length, i.e. pagination
		$startParam = $this->request->getVar('start');
		$start = isset($startParam) ? $startParam : 0;
		$elasticSearcher->setStart($start);
		$this->StartTime = microtime(true);
		$elasticSearcher->setPageLength($this->SearchPage->ResultsPerPage);

		// Do not show suggestions if this flag is set
		$this->IgnoreSuggestions = null !== $this->request->getVar('is');

		// query string
		$queryTextParam = $this->request->getVar('q');
		$queryText = !empty($queryTextParam) ? $queryTextParam : '';
		$this->QueryText = $queryText;

		$this->TestMode = !empty($this->request->getVar('TestMode'));
		return $elasticSearcher;
	}


	/**
	 * Set the admin configured similarity parameters
	 * @param \SilverStripe\Elastica\ElasticSearcher &$elasticSearcher ElasticaSearcher object
	 */
	private function setMoreLikeThisParamsFromRequest(&$elasticSearcher) {
		$elasticSearcher->setMinTermFreq($this->MinTermFreq);
		$elasticSearcher->setMaxTermFreq($this->MaxTermFreq);
		$elasticSearcher->setMinDocFreq($this->MinDocFreq);
		$elasticSearcher->setMaxDocFreq($this->MaxDocFreq);
		$elasticSearcher->setMinWordLength($this->MinWordLength);
		$elasticSearcher->setMaxWordLength($this->MaxWordLength);
		$elasticSearcher->setMinShouldMatch($this->MinShouldMatch);
		$elasticSearcher->setSimilarityStopWords($this->SimilarityStopWords);
	}


	private function dealWithAggregation(&$es) {
		$ignore = \Config::inst()->get('Elastica', 'BlackList');
		foreach($this->request->getVars() as $key => $value) {
			if(!in_array($key, $ignore)) {
				$es->addFilter($key, $value);
			}
		}

		// set the optional aggregation manipulator
		// In the event of a manipulator being present, show all the results for search
		// Otherwise aggregations are all zero
		if($this->SearchHelper) {
			$es->setQueryResultManipulator($this->SearchHelper);
			$es->showResultsForEmptySearch();
		} else {
			$es->hideResultsForEmptySearch();
		}
	}


	private function addSiteTreeFilterIfRequired(&$es) {
		// filter by class or site tree
		if($this->SearchPage->SiteTreeOnly) {
			$es->addFilter('IsInSiteTree', true);
		} else {
			$es->setClasses($this->SearchPage->ClassesToSearch);
		}
	}


	private function getSelectedSearchFields($selectionField = 'Searchable') {
		// get the edited fields to search from the database for this search page
		// Convert this into a name => weighting array
		$fieldsToSearch = array();
		$editedSearchFields = $this->ElasticaSearchableFields()->filter(array(
			'Active' => true,
			$selectionField => true
		));

		foreach($editedSearchFields->getIterator() as $searchField) {
			$fieldsToSearch[$searchField->Name] = $searchField->Weight;
		}

		// For a 'more like this' search, use the original unstemmed words
		// This means using the .standard named field of text
		if ($this->action == 'similar') {
			// Use the standard field for more like this, ie not stemmed
			foreach($fieldsToSearch as $field => $value) {
				$fieldsToSearch[$field . '.standard'] = $value;
				unset($fieldsToSearch[$field]);
			}
		}
		$this->FieldsToSearch = $fieldsToSearch;
	}


	private function initialiseDataArray() {
		return array(
			'Content' => $this->Content,
			'Title' => $this->Title,
			'SearchPerformed' => false,
			'OriginalQuery' => $this->QueryText,
			'IgnoreSuggestions' => $this->IgnoreSuggestions
		);
	}


	private function renderResults($data) {
		// allow the optional use of overriding the search result page, e.g. for photos, maps or facets
		if($this->hasExtension('PageControllerTemplateOverrideExtension')) {
			return $this->useTemplateOverride($data);
		} else {
			return $data;
		}
	}


	private function calculateTime() {
		$endTime = microtime(true);
		$elapsed = round(100 * ($endTime - $this->StartTime)) / 100;
		return $elapsed;
	}


	private function checkForSimulatedServerDown() {
		// Simulate server being down for testing purposes
		if(!empty($this->request->getVar('ServerDown'))) {
			throw new Elastica\Exception\Connection\HttpException('Unable to reach search server');
		}
	}
}


1			<?php
2
3			use Elastica\Document;
4			use Elastica\Query;
5			use \SilverStripe\Elastica\ResultList;
6			use Elastica\Query\QueryString;
7			use Elastica\Aggregation\Filter;
8			use Elastica\Filter\Term;
9			use Elastica\Filter\BoolAnd;
10			use Elastica\Aggregation\Terms;
11			use Elastica\Query\Filtered;
12			use Elastica\Query\Range;
13			use \SilverStripe\Elastica\ElasticSearcher;
14			use \SilverStripe\Elastica\Searchable;
15			use \SilverStripe\Elastica\QueryGenerator;
16			use \SilverStripe\Elastica\ElasticaUtil;
17
18			class ElasticSearchPage_Controller extends Page_Controller {
			0 ignored issues – show Coding Style introduced 2015-12-29 09:15 UTC by Report Bug Copy Issue Report This class is not in CamelCase format. Classes in PHP are usually named in CamelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. The whole name starts with a capital letter as well. Thus the name database provider becomes `DatabaseProvider`. Loading history...
19
20			private static $allowed_actions = array('SearchForm', 'submit', 'index', 'similar');
21
22			public function init() {
23			parent::init();
24
25			Requirements::javascript(THIRDPARTY_DIR . '/jquery/jquery.js');
26			Requirements::javascript("elastica/javascript/jquery.autocomplete.js");
27			Requirements::javascript("elastica/javascript/elastica.js");
28			Requirements::css("elastica/css/elastica.css");
29
30			$this->SearchPage = Controller::curr()->dataRecord;
31			}
32
33
34
35			/*
36			Find DataObjects in Elasticsearch similar to the one selected. Note that aggregations are not
37			taken into account, merely the text of the selected document.
38			*/
39			public function similar() {
40			//FIXME double check security, ie if escaping needed
41			$class = $this->request->param('ID');
42			$instanceID = $this->request->param('OtherID');
43
44			$es = $this->primeElasticSearcherFromRequest();
45			$data = $this->initialiseDataArray();
46			$this->setMoreLikeThisParamsFromRequest($es);
47			$this->addSiteTreeFilterIfRequired($es);
48			$this->getSelectedSearchFields('SimilarSearchable');
49
50			try {
51			$this->checkForSimulatedServerDown();
52			if(class_exists($class)) {
53			$instance = \DataObject::get_by_id($class, $instanceID);
54			print_r($this->FieldsToSearch);
55			$paginated = $es->moreLikeThis($instance, $this->FieldsToSearch);
56			$this->Aggregations = $es->getAggregations();
57			$this->successfulSearch($data, $paginated);
58			$data['SimilarTo'] = $instance;
59			$this->getSimilarTerms($data, $paginated);
60
61			} else {
62			// class does not exist
63			$data['ErrorMessage'] = "Class $class is either not found or not searchable\n";
64			}
65			} catch (\InvalidArgumentException $e) {
66			$data['ErrorMessage'] = "Class $class is either not found or not searchable\n";
67			} catch (Elastica\Exception\Connection\HttpException $e) {
68			$data['ErrorMessage'] = 'Unable to connect to search server';
69			}
70			return $this->renderResults($data);
71			}
72
73
74			private function getSimilarTerms(&$data, &$paginated) {
75			$moreLikeThisTerms = $paginated->getList()->MoreLikeThisTerms;
76			$fieldToTerms = new ArrayList();
77			foreach(array_keys($moreLikeThisTerms) as $fieldName) {
78			$readableFieldName = str_replace('.standard', '', $fieldName);
79			$fieldTerms = new ArrayList();
80			foreach($moreLikeThisTerms[$fieldName] as $value) {
81			$do = new DataObject();
82			$do->Term = $value;
83			$fieldTerms->push($do);
84			}
85
86			$do = new DataObject();
87			$do->FieldName = $readableFieldName;
88			$do->Terms = $fieldTerms;
89			$fieldToTerms->push($do);
90			}
91
92			$data['SimilarSearchTerms'] = $fieldToTerms;
93			}
94
95			/*
96			Display the search form. If the query parameter exists, search against Elastica
97			and render results accordingly.
98			*/
99			public function index() {
100			$es = $this->primeElasticSearcherFromRequest();
101			$data = $this->initialiseDataArray();
102			$this->dealWithAggregation($es);
103			$this->addSiteTreeFilterIfRequired($es);
104			$this->getSelectedSearchFields();
105
106			$paginated = null;
107			try {
108			$this->checkForSimulatedServerDown();
109
110			// now actually perform the search using the original query
111			$paginated = $es->search($this->QueryText, $this->FieldsToSearch,$this->TestMode);
112
113			// Deal with a possible suggested query
114			$this->dealWithSuggestedQuery($es, $data, $paginated);
115
116			$this->Aggregations = $es->getAggregations();
117			$this->successfulSearch($data, $paginated);
118			} catch (Elastica\Exception\Connection\HttpException $e) {
119			$data['ErrorMessage'] = 'Unable to connect to search server';
120			}
121
122			return $this->renderResults($data);
123			}
124
125
126			private function dealWithSuggestedQuery(&$es, &$data, &$paginated) {
127			// This is the case of the original query having a better one suggested. Do a
128			// second search for the suggested query, throwing away the original
129			if($es->hasSuggestedQuery() && !$this->IgnoreSuggestions) {
130			$data['SuggestedQuery'] = $es->getSuggestedQuery();
131			$data['SuggestedQueryHighlighted'] = $es->getSuggestedQueryHighlighted();
132			//Link for if the user really wants to try their original query
133			$sifLink = rtrim($this->Link(), '/') . '?q=' . $this->QueryText . '&is=1';
134			$data['SearchInsteadForLink'] = $sifLink;
135			$paginated = $es->search($es->getSuggestedQuery(), $this->FieldsToSearch);
136			}
137			}
138
139
140			private function successfulSearch(&$data, $paginated) {
141			$data['SearchResults'] = $paginated;
142			$data['SearchPerformed'] = true;
143			$data['NumberOfResults'] = $paginated->getTotalItems();
144			$data['SearchPageLink'] = $this->SearchPage->Link();
145			$data['ElapsedTime'] = $this->calculateTime();
146			}
147
148
149			/*
150			Return true if the query is not empty
151			*/
152			public function QueryIsEmpty() {
153			return empty($this->request->getVar('q'));
154			}
155
156
157			/**
158			* Process submission of the search form, redirecting to a URL that will render search results
159			* @param array $data form data
160			* @param Form $form form
161			*/
162			public function submit($data, $form) {
163			$queryText = $data['q'];
164			$url = $this->Link();
165			$url = rtrim($url, '/');
166			$link = rtrim($url, '/') . '?q=' . $queryText . '&sfid=' . $data['identifier'];
167			$this->redirect($link);
168			}
169
170
171			/*
172			Obtain an instance of the form
173			*/
174			public function SearchForm() {
175			$form = new ElasticSearchForm($this, 'SearchForm');
176			$fields = $form->Fields();
177			$elasticaSearchPage = Controller::curr()->dataRecord;
178			$identifierField = new HiddenField('identifier');
179			$identifierField->setValue($elasticaSearchPage->Identifier);
180
181			$fields->push($identifierField);
182			$queryField = $fields->fieldByName('q');
183
184			if($this->isParamSet('q') && $this->isParamSet('sfid')) {
185			$sfid = $this->request->getVar('sfid');
186			if($sfid == $elasticaSearchPage->Identifier) {
187
188			$queryText = $this->request->getVar('q');
189			$queryField->setValue($queryText);
190			}
191
192			}
193
194			if($this->action == 'similar') {
195			$queryField->setDisabled(true);
196			$actions = $form->Actions();
197			if(!empty($actions)) {
198			foreach($actions as $field) {
199			$field->setDisabled(true);
200			}
201			}
202
203			}
204
205			if($this->AutoCompleteFieldID > 0) {
206			ElasticaUtil::addAutocompleteToQueryField(
207			$queryField,
208			$this->ClassesToSearch,
209			$this->SiteTreeOnly,
210			$this->Link(),
211			$this->AutocompleteFunction()->Slug
212			);
213			}
214			return $form;
215			}
216
217
218			/**
219			* @param string $paramName
220			*/
221			private function isParamSet($paramName) {
222			return !empty($this->request->getVar($paramName));
223			}
224
225
226			/**
227			* Set the start page from the request and results per page for a given searcher object
228			*/
229			private function primeElasticSearcherFromRequest() {
230			$elasticSearcher = new ElasticSearcher();
231			// start, and page length, i.e. pagination
232			$startParam = $this->request->getVar('start');
233			$start = isset($startParam) ? $startParam : 0;
234			$elasticSearcher->setStart($start);
235			$this->StartTime = microtime(true);
236			$elasticSearcher->setPageLength($this->SearchPage->ResultsPerPage);
237
238			// Do not show suggestions if this flag is set
239			$this->IgnoreSuggestions = null !== $this->request->getVar('is');
240
241			// query string
242			$queryTextParam = $this->request->getVar('q');
243			$queryText = !empty($queryTextParam) ? $queryTextParam : '';
244			$this->QueryText = $queryText;
245
246			$this->TestMode = !empty($this->request->getVar('TestMode'));
247			return $elasticSearcher;
248			}
249
250
251			/**
252			* Set the admin configured similarity parameters
253			* @param \SilverStripe\Elastica\ElasticSearcher &$elasticSearcher ElasticaSearcher object
254			*/
255			private function setMoreLikeThisParamsFromRequest(&$elasticSearcher) {
256			$elasticSearcher->setMinTermFreq($this->MinTermFreq);
257			$elasticSearcher->setMaxTermFreq($this->MaxTermFreq);
258			$elasticSearcher->setMinDocFreq($this->MinDocFreq);
259			$elasticSearcher->setMaxDocFreq($this->MaxDocFreq);
260			$elasticSearcher->setMinWordLength($this->MinWordLength);
261			$elasticSearcher->setMaxWordLength($this->MaxWordLength);
262			$elasticSearcher->setMinShouldMatch($this->MinShouldMatch);
263			$elasticSearcher->setSimilarityStopWords($this->SimilarityStopWords);
264			}
265
266
267			private function dealWithAggregation(&$es) {
268			$ignore = \Config::inst()->get('Elastica', 'BlackList');
269			foreach($this->request->getVars() as $key => $value) {
270			if(!in_array($key, $ignore)) {
271			$es->addFilter($key, $value);
272			}
273			}
274
275			// set the optional aggregation manipulator
276			// In the event of a manipulator being present, show all the results for search
277			// Otherwise aggregations are all zero
278			if($this->SearchHelper) {
279			$es->setQueryResultManipulator($this->SearchHelper);
280			$es->showResultsForEmptySearch();
281			} else {
282			$es->hideResultsForEmptySearch();
283			}
284			}
285
286
287			private function addSiteTreeFilterIfRequired(&$es) {
288			// filter by class or site tree
289			if($this->SearchPage->SiteTreeOnly) {
290			$es->addFilter('IsInSiteTree', true);
291			} else {
292			$es->setClasses($this->SearchPage->ClassesToSearch);
293			}
294			}
295
296
297			private function getSelectedSearchFields($selectionField = 'Searchable') {
298			// get the edited fields to search from the database for this search page
299			// Convert this into a name => weighting array
300			$fieldsToSearch = array();
301			$editedSearchFields = $this->ElasticaSearchableFields()->filter(array(
302			'Active' => true,
303			$selectionField => true
304			));
305
306			foreach($editedSearchFields->getIterator() as $searchField) {
307			$fieldsToSearch[$searchField->Name] = $searchField->Weight;
308			}
309
310			// For a 'more like this' search, use the original unstemmed words
311			// This means using the .standard named field of text
312			if ($this->action == 'similar') {
313			// Use the standard field for more like this, ie not stemmed
314			foreach($fieldsToSearch as $field => $value) {
315			$fieldsToSearch[$field . '.standard'] = $value;
316			unset($fieldsToSearch[$field]);
317			}
318			}
319			$this->FieldsToSearch = $fieldsToSearch;
320			}
321
322
323			private function initialiseDataArray() {
324			return array(
325			'Content' => $this->Content,
326			'Title' => $this->Title,
327			'SearchPerformed' => false,
328			'OriginalQuery' => $this->QueryText,
329			'IgnoreSuggestions' => $this->IgnoreSuggestions
330			);
331			}
332
333
334			private function renderResults($data) {
335			// allow the optional use of overriding the search result page, e.g. for photos, maps or facets
336			if($this->hasExtension('PageControllerTemplateOverrideExtension')) {
337			return $this->useTemplateOverride($data);
338			} else {
339			return $data;
340			}
341			}
342
343
344			private function calculateTime() {
345			$endTime = microtime(true);
346			$elapsed = round(100 * ($endTime - $this->StartTime)) / 100;
347			return $elapsed;
348			}
349
350
351			private function checkForSimulatedServerDown() {
352			// Simulate server being down for testing purposes
353			if(!empty($this->request->getVar('ServerDown'))) {
354			throw new Elastica\Exception\Connection\HttpException('Unable to reach search server');
355			}
356			}
357			}
358

gordonbanderson / silverstripe-elastica

dealWithAggregation() A last analyzed 2016-01-04 04:20 UTC

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like

dealWithAggregation() A
last analyzed 2016-01-04 04:20 UTC