public function attribute($key) { switch ($key) { case 'start_timestamp': return $this->start->format('U'); break; case 'start_js': return $this->start->format('U') * 1000; break; case 'start_solr': return ezfSolrDocumentFieldBase::preProcessValue($this->start->format('U'), 'date'); break; case 'end_timestamp': return $this->end->format('U'); break; case 'end_js': return $this->end->format('U') * 1000; break; case 'end_solr': return ezfSolrDocumentFieldBase::preProcessValue($this->end->format('U'), 'date'); break; default: return false; } }
/** * @return array */ protected function getValues() { if ($this->values === null) { $this->values = array(); if ($this->contentClassAttribute->attribute('data_type_string') == 'ezobjectrelationlist') { //$field = ezfSolrDocumentFieldBase::generateSubattributeFieldName( $this->contentClassAttribute, 'name', 'string' ); //@todo errore nella definzione del nome del sottoattributo? verifaicare vedi anche in self::buildFetch //$field = ezfSolrDocumentFieldBase::$DocumentFieldName->lookupSchemaName( // ezfSolrDocumentFieldBase::SUBMETA_FIELD_PREFIX . $this->contentClassAttribute->attribute( 'identifier' ) . ezfSolrDocumentFieldBase::SUBATTR_FIELD_SEPARATOR . 'name', // 'string'); $field = ezfSolrDocumentFieldBase::$DocumentFieldName->lookupSchemaName(ezfSolrDocumentFieldBase::SUBATTR_FIELD_PREFIX . $this->contentClassAttribute->attribute('identifier') . ezfSolrDocumentFieldBase::SUBATTR_FIELD_SEPARATOR . 'name' . ezfSolrDocumentFieldBase::SUBATTR_FIELD_SEPARATOR, 'string'); } else { $field = ezfSolrDocumentFieldBase::generateAttributeFieldName($this->contentClassAttribute, 'string'); } $facets = array('field' => $field, 'name' => $this->attributes['name'], 'limit' => 300, 'sort' => 'alpha'); $fetchParameters = array('SearchContentClassID' => array($this->contentClassAttribute->attribute('contentclass_id')), 'Facet' => array($facets)); $data = $this->client->fetchRemoteNavigationList($fetchParameters); if (isset($data[$this->attributes['name']])) { $this->values = $data[$this->attributes['name']]; // setto i valori attivi e inietto il conto nel nome foreach ($this->values as $index => $value) { $current = (array) $this->attributes['value']; if (in_array($value['query'], $current)) { $this->values[$index]['active'] = true; } $this->values[$index]['query'] = OCFacetNavgationHelper::encodeValue($this->values[$index]['query']); if (isset($value['count']) && $value['count'] > 0) { $this->values[$index]['name'] = $value['name'] . ' (' . $value['count'] . ')'; } } } } return $this->values; }
protected function getBounds($includeCurrentParameters = false) { $start = $end = false; $sortField = ezfSolrDocumentFieldBase::getFieldName($this->contentClassAttribute, null, 'sort'); $currentParameters = array(); if ($includeCurrentParameters) { $currentParameters = OCClassSearchFormHelper::result()->getCurrentParameters(); } $fieldName = ezfSolrDocumentFieldBase::getFieldName($this->contentClassAttribute, null, 'search'); $params = array_merge(OCClassSearchFormHelper::result()->getBaseParameters(), $currentParameters, array('SearchContentClassID' => $this->contentClassAttribute->attribute('contentclass_id'), 'SearchLimit' => 1, 'SortBy' => array($sortField => 'asc'))); $startSearch = OCFacetNavgationHelper::fetch($params, OCClassSearchFormHelper::result()->searchText); /** @var $startSearchResults eZFindResultNode[] */ $startSearchResults = $startSearch['SearchResult']; if (isset($startSearchResults[0])) { $dataMap = $startSearchResults[0]->attribute('object')->attribute('data_map'); $start = $dataMap[$this->contentClassAttribute->attribute('identifier')]; } $params['SortBy'] = array($sortField => 'desc'); $endSearch = OCFacetNavgationHelper::fetch($params, OCClassSearchFormHelper::result()->searchText); /** @var $endSearchResults eZFindResultNode[] */ $endSearchResults = $endSearch['SearchResult']; if (isset($endSearchResults[0])) { $dataMap = $endSearchResults[0]->attribute('object')->attribute('data_map'); $end = $dataMap[$this->contentClassAttribute->attribute('identifier')]; } $className = $this->getBoundsClassName(); /** @var OCClassSearchFormFieldBoundsInterface $bounds */ $bounds = new $className(); $bounds->setStart($start); $bounds->setEnd($end); return $bounds; }
/** * Returns the list of field names this handler sends to Solr backend * * @static * * @param eZContentClassAttribute $classAttribute * @param array $exclusiveTypeFilter * * @return array */ public static function getFieldNameList(eZContentClassAttribute $classAttribute, $exclusiveTypeFilter = array()) { $fieldsList = array(); if (empty($exclusiveTypeFilter) || !in_array('lckeyword', $exclusiveTypeFilter)) { $fieldsList[] = parent::generateAttributeFieldName($classAttribute, 'lckeyword'); } if (empty($exclusiveTypeFilter) || !in_array('text', $exclusiveTypeFilter)) { $fieldsList[] = parent::generateAttributeFieldName($classAttribute, 'text'); } if (empty($exclusiveTypeFilter) || !in_array('sint', $exclusiveTypeFilter)) { $fieldsList[] = parent::generateSubattributeFieldName($classAttribute, 'tag_ids', 'sint'); } return $fieldsList; }
public static function getFieldName(eZContentClassAttribute $classAttribute, $subAttribute = null, $context = 'search') { switch ($classAttribute->attribute('data_type_string')) { case 'ezmatrix': if ($subAttribute and $subAttribute !== '') { // A subattribute was passed return parent::generateSubattributeFieldName($classAttribute, $subAttribute, self::DEFAULT_SUBATTRIBUTE_TYPE); } else { // return the default field name here. return parent::generateAttributeFieldName($classAttribute, self::getClassAttributeType($classAttribute, null, $context)); } break; } return null; }
public function getData() { $contentClassAttribute = $this->ContentObjectAttribute->attribute('contentclass_attribute'); switch ($contentClassAttribute->attribute('data_type_string')) { case 'ezinteger': $returnArray = array(); $value = $this->ContentObjectAttribute->metaData(); $fieldName = parent::generateAttributeFieldName($contentClassAttribute, self::DEFAULT_ATTRIBUTE_TYPE); $returnArray[$fieldName] = intval($value); return $returnArray; break; default: break; } }
public function buildFetch(OCClassSearchFormFetcher $fetcher, $requestKey, $requestValue, &$filters) { if (is_array($requestValue) && count($requestValue) == 1) { $requestValue = array_shift($requestValue); } $fieldName = ezfSolrDocumentFieldBase::getFieldName($this->contentClassAttribute, null, 'search'); if (is_array($requestValue)) { $values = array('or'); foreach ($requestValue as $v) { $values[] = $fieldName . ':' . $fetcher->encode($v, true); } $filters[] = $values; } else { $filters[] = $fieldName . ':' . $fetcher->encode($requestValue, true); } $fetcher->addFetchField(array('name' => $this->contentClassAttribute->attribute('name'), 'value' => $requestValue, 'remove_view_parameters' => $fetcher->getViewParametersString(array($requestKey)))); }
/** * @return array */ public function getData() { $contentClassAttribute = $this->ContentObjectAttribute->attribute( 'contentclass_attribute' ); switch( $contentClassAttribute->attribute( 'identifier' ) ) { case 'additional_keywords': $data = parent::getData(); $content = $data['attr_' . $contentClassAttribute->attribute('identifier') . '_t']; $data['attr_' . $contentClassAttribute->attribute('identifier') . '_lk'] = $content[0]; unset($data['attr_' . $contentClassAttribute->attribute('identifier') . '_t']); return $data; break; default: return parent::getData(); break; } }
public static function getFieldNameList(eZContentClassAttribute $classAttribute, $exclusiveTypeFilter = array()) { // Generate the list of subfield names. $subfields = array(); // Handle first the default subattribute $subattributesDefinition = self::$subattributesDefinition; if (!in_array($subattributesDefinition[self::DEFAULT_SUBATTRIBUTE], $exclusiveTypeFilter)) { $subfields[] = parent::generateAttributeFieldName($classAttribute, $subattributesDefinition[self::DEFAULT_SUBATTRIBUTE]); } unset($subattributesDefinition[self::DEFAULT_SUBATTRIBUTE]); // Then hanlde all other subattributes foreach ($subattributesDefinition as $name => $type) { if (empty($exclusiveTypeFilter) or !in_array($type, $exclusiveTypeFilter)) { $subfields[] = parent::generateSubattributeFieldName($classAttribute, $name, $type); } } return $subfields; }
/** * @see ezfSolrDocumentFieldBase::getData() */ public function getData() { $returnArray = parent::getData(); $contentClassAttributeIdentifier = $this->ContentObjectAttribute->ContentClassAttributeIdentifier; $eZType = eZDataType::create( $this->ContentObjectAttribute->DataTypeString ); $attributeContent = $eZType->getValues( $this->ContentObjectAttribute->ID ); foreach( $attributeContent as $key => $value ) { if ( $value > 0 ) { $suffix = self::getPostFix( $contentClassAttributeIdentifier ); $attribute = 'attr_'.$contentClassAttributeIdentifier.'_'.$key.$suffix; $returnArray[$attribute] = $value; } } return $returnArray; }
/** * Get an array of class attribute identifiers based on either a class attribute * list, or a content classes list * * @param array $classIDArray * Classes to search in. Either an array of class ID, class identifiers, * a class ID or a class identifier. * Using numerical attribute/class identifiers for $classIDArray is more efficient. * @param array $classAttributeID * Class attributes to search in. Either an array of class attribute id, * or a single class attribute. Literal identifiers are not allowed. * @param array $fieldTypeExcludeList * filter list. List of field types to exclude. ( set to empty array by default ). * * @return array List of solr field names. */ protected function getClassAttributes($classIDArray = false, $classAttributeIDArray = false, $fieldTypeExcludeList = null) { eZDebug::createAccumulator('Class attribute list', 'eZ Find'); eZDebug::accumulatorStart('Class attribute list'); $fieldArray = array(); $classAttributeArray = array(); // classAttributeIDArray = simple integer (content class attribute ID) if (is_numeric($classAttributeIDArray) and $classAttributeIDArray > 0) { $classAttributeArray[] = eZContentClassAttribute::fetch($classAttributeIDArray); } else { if (is_array($classAttributeIDArray)) { foreach ($classAttributeIDArray as $classAttributeID) { $classAttributeArray[] = eZContentClassAttribute::fetch($classAttributeID); } } } // no class attribute list given, we need a class list // this block will create the class attribute array based on $classIDArray if (empty($classAttributeArray)) { // Fetch class list. $condArray = array("is_searchable" => 1, "version" => eZContentClass::VERSION_STATUS_DEFINED); if (!$classIDArray) { $classIDArray = array(); } else { if (!is_array($classIDArray)) { $classIDArray = array($classIDArray); } } // literal class identifiers are converted to numerical ones $tmpClassIDArray = $classIDArray; $classIDArray = array(); foreach ($tmpClassIDArray as $key => $classIdentifier) { if (!is_numeric($classIdentifier)) { if (!($contentClass = eZContentClass::fetchByIdentifier($classIdentifier, false))) { eZDebug::writeWarning("Unknown content class identifier '{$classIdentifier}'", __METHOD__); } else { $classIDArray[] = $contentClass['id']; } } else { $classIDArray[] = $classIdentifier; } } if (!empty($classIDArray)) { $condArray['contentclass_id'] = array($classIDArray); } $classAttributeArray = eZContentClassAttribute::fetchFilteredList($condArray); } // $classAttributeArray now contains a list of eZContentClassAttribute // we can use to construct the list of fields solr should search in // @TODO : retrieve sub attributes here. Mind the types ! foreach ($classAttributeArray as $classAttribute) { $fieldArray = array_merge(ezfSolrDocumentFieldBase::getFieldNameList($classAttribute, $fieldTypeExcludeList), $fieldArray); } // the array is unified + sorted in order to make it consistent $fieldArray = array_unique($fieldArray); sort($fieldArray); eZDebug::accumulatorStop('Class attribute list'); return $fieldArray; }
} // Ultimo giorno (Default) if (!isset($days)) { $days = 1; } // Tutte le tematiche in OR $tag_filters = array('or'); foreach ($tematiche as $tag) { $tag_filters[] = 'attr_tematica_lk: "' . $tag . '"'; } // Data inizio è di $days giorni indietro $_startDate = new DateTime(); $_endDate = new DateTime(); $_startDate->modify("-" . $days . " day"); $startDate = ezfSolrDocumentFieldBase::preProcessValue($_startDate->format('U'), 'date'); $endDate = ezfSolrDocumentFieldBase::preProcessValue($_endDate->format('U'), 'date'); // Composizione del filtro $filters = array('and', 'meta_published_dt:[' . $startDate . ' TO ' . $endDate . ']', $tag_filters); $params = array('SortBy' => array('meta_published_dt' => 'desc'), 'Filter' => $filters, 'SearchContentClassID' => array($class_id), 'SearchSubTreeArray' => array(eZINI::instance('content.ini')->variable('NodeSettings', 'RootNode'))); // Esecuzione query Solr $solrSearch = new eZSolr(); $result = $solrSearch->search('', $params); // Estrazione del NodeID $node_ids = array(); foreach ($result['SearchResult'] as $object) { $node_ids[] = $object->ContentObject->mainNodeID(); } // Output in JSON header('Content-Type: application/json'); echo json_encode($node_ids); // echo json_encode( $result['SearchResult'] ); // DEBUG
/** * Get ezfSolrDocumentFieldBase instances for all attributes of specified eZContentObjectVersion * * @param eZContentObjectVersion Instance of eZContentObjectVersion to fetch attributes from. * * @return array List of ezfSolrDocumentFieldBase instances. */ function getBaseList( eZContentObjectVersion $objectVersion ) { $returnList = array(); // Get ezfSolrDocumentFieldBase instance for all attributes in related object if ( eZContentObject::recursionProtect( $this->ContentObjectAttribute->attribute( 'contentobject_id' ) ) ) { foreach ( $objectVersion->contentObjectAttributes( $this->ContentObjectAttribute->attribute( 'language_code' ) ) as $attribute ) { if ( $attribute->attribute( 'contentclass_attribute' )->attribute( 'is_searchable' ) ) { $returnList[] = ezfSolrDocumentFieldBase::getInstance( $attribute ); } } } return $returnList; }
private static function appendData($indexType, $attribute, $targets, $ngIndexerFieldName, &$data) { if ($indexType != 'object' && empty($attribute)) { return; } if ($indexType == 'object') { $handlerData = array(); foreach ($targets as $target) { foreach ($target->dataMap() as $key => $value) { if ($value->attribute('data_type_string') != 'ngindexer') { $handler = ezfSolrDocumentFieldBase::getInstance($value); $handlerData[$key][] = $handler->getData(); } } } foreach ($handlerData as $handlerDataArray) { foreach ($handlerDataArray as $dataFields) { self::appendDataFields($dataFields, $ngIndexerFieldName, $data); } } } else { if ($indexType == 'object_attribute') { foreach ($targets as $target) { $fieldName = self::NGINDEXER_FIELD_PREFIX . $ngIndexerFieldName . '_' . $attribute . '____t'; $data[$fieldName][] = $target->object()->attribute($attribute); } } else { if ($indexType == 'node_attribute') { foreach ($targets as $target) { $fieldName = self::NGINDEXER_FIELD_PREFIX . $ngIndexerFieldName . '_' . $attribute . '____t'; $data[$fieldName][] = $target->attribute($attribute); } } else { if ($indexType == 'data_map_attribute') { $handlerData = array(); foreach ($targets as $target) { $dataMap = $target->dataMap(); if (isset($dataMap[$attribute]) && $dataMap[$attribute]->attribute('data_type_string') != 'ngindexer') { $handler = ezfSolrDocumentFieldBase::getInstance($dataMap[$attribute]); $handlerData[] = $handler->getData(); } } foreach ($handlerData as $dataFields) { self::appendDataFields($dataFields, $ngIndexerFieldName, $data); } } } } } }
$subtreeArray = explode(',', $ParentNodes); $defaultFilters = $DefaultFilters !== null ? explode(',', $DefaultFilters) : array(); $fieldsToReturn = $fields; $iDisplayStart = $http->hasGetVariable('iDisplayStart') ? $http->getVariable('iDisplayStart') : 10; $iDisplayLength = $http->hasGetVariable('iDisplayLength') ? $http->getVariable('iDisplayLength') : 100; /* * Ordering */ $sortBy = array(ezfSolrDocumentFieldBase::generateMetaFieldName('sort_name') => 'asc'); if ($http->hasGetVariable('iSortCol_0')) { for ($i = 0; $i < intval($http->getVariable('iSortingCols')); $i++) { $sortBy = array(); if ($http->getVariable('bSortable_' . intval($http->getVariable('iSortCol_' . $i))) == "true") { $sortKey = $fields[intval($http->getVariable('iSortCol_' . $i))]; if ($sortKey == 'name_t' || $sortKey == 'name') { $sortKey = ezfSolrDocumentFieldBase::generateMetaFieldName('sort_name'); } $sortBy[] = array($sortKey, $http->getVariable('sSortDir_' . $i)); } } } $query = ''; if ($http->getVariable('sSearch') != "") { $query = str_replace(' ', ' AND ', $http->getVariable('sSearch')) . '*'; } /* * Individual column filtering */ $filters = array(); if (!empty($defaultFilters)) { if ($DefaultFilters > 1) {
/** * Clean up search index for current installation. * @return bool true if cleanup was successful * @todo: handle multicore configs (need a parameter for it) for return values **/ function cleanup( $allInstallations = false, $optimize = false ) { if ( $allInstallations === true ) { $optimize = true; $deleteQuery = '*:*'; } else { $deleteQuery = ezfSolrDocumentFieldBase::generateMetaFieldName( 'installation_id' ) . ':' . self::installationID(); } if ( $this->UseMultiLanguageCores == true ) { foreach ( $this->SolrLanguageShards as $shard ) { $shard->deleteDocs( array(), $deleteQuery, true, $optimize ); } return true; } else { return $this->Solr->deleteDocs( array(), $deleteQuery, true ); } }
* * @example * Metadata attributes of a related object will be indexed * as submetas in a Solr document, their names starting * with 'submeta_' instead of '_meta' */ const SUBMETA_FIELD_PREFIX = 'submeta_'; /** * Prefix for attribute field names in Solr. */ const ATTR_FIELD_PREFIX = 'attr_'; /** * Prefix for subattribute field names in Solr. * * @example * Content attributes of a related object will be indexed * as subattributes in a Solr document, their names starting * with 'subattr_' instead of '_attr' */ const SUBATTR_FIELD_PREFIX = 'subattr_'; /** * Separator for sub attributes * Since eZ Find 2.3, this is changed to a lucene query syntax friendly string * which is important for function queries and some internal Solr calls * as well */ const SUBATTR_FIELD_SEPARATOR = '___'; } ezfSolrDocumentFieldBase::$FindINI = eZINI::instance('ezfind.ini'); ezfSolrDocumentFieldBase::$DocumentFieldName = new ezfSolrDocumentFieldName();
/** * test for getData() */ public function testGetData() { $providerArray = array(); #start 1 : the simplest attribute $content1 = "Hello world"; $ezcca1 = new eZContentClassAttribute(array('identifier' => 'title', 'data_type_string' => 'ezstring')); $ezcoa1 = new eZContentObjectAttributeTester(array("data_type_string" => 'ezstring', "id" => 100123, "data_text" => $content1, "contentclass_attribute" => $ezcca1)); $fieldName1 = ezfSolrDocumentFieldBase::getFieldName($ezcca1); $expectedData1 = array($fieldName1 => $content1); $providerArray[] = array($expectedData1, $ezcoa1); #end 1 #start 2 : attribute with subattributes $ezcca2 = new eZContentClassAttribute(array('identifier' => 'dummy', 'data_type_string' => 'dummy_example')); $ezcoa2 = new eZContentObjectAttributeTester(array("data_type_string" => 'dummy_example', "id" => 100124, "contentclass_attribute" => $ezcca2)); $fieldList2 = ezfSolrDocumentFieldBase::getFieldNameList($ezcca2); $expectedData2 = array(); foreach ($fieldList2 as $fieldName) { $expectedData2[$fieldName] = 'DATA_FOR_' . $fieldName; } $fieldName2 = ezfSolrDocumentFieldBase::getFieldName($ezcca2); $providerArray[] = array($expectedData2, $ezcoa2); #end 2 #start 3 : object relations $expectedData3 = array(); $tester3 = new ezfSolrDocumentFieldObjectRelationTester(new eZContentObjectAttribute(array())); $time3 = time(); $image3 = new ezpObject("image", 2); $image3->name = __METHOD__ . $time3; $image3->caption = __METHOD__ . $time3; $imageId3 = $image3->publish(); // $image3->object->clearCache(); $dataMapImage3 = $image3->dataMap; // eZContentObjectAttribute objects, attributes of the related Image $imageName3 = $dataMapImage3['name']; $imageCaption3 = $dataMapImage3['caption']; $article3 = new ezpObject("article", 2); $articleId3 = $article3->publish(); // Create object relation $article3->object->addContentObjectRelation($imageId3, $article3->current_version, 154, eZContentObject::RELATION_ATTRIBUTE); $dataMapArticle3 = $article3->attribute('data_map'); $ezcoa3 = $dataMapArticle3['image']; $ezcoa3->setAttribute('data_int', $imageId3); $ezcoa3->store(); $ezcca3 = $ezcoa3->attribute('contentclass_attribute'); $defaultFieldName3 = ezfSolrDocumentFieldBase::generateAttributeFieldName($ezcca3, ezfSolrDocumentFieldObjectRelation::$subattributesDefinition[ezfSolrDocumentFieldObjectRelation::DEFAULT_SUBATTRIBUTE]); $expectedData3[$defaultFieldName3] = $tester3->getPlainTextRepresentation($ezcoa3); // required to allow another call to metaData() // on $ezcoa3 in getPlainTextRepresentation, called from the getData() method : eZContentObject::recursionProtectionEnd(); $fieldNameImageName3 = ezfSolrDocumentFieldBase::generateSubattributeFieldName($ezcca3, $imageName3->attribute('contentclass_attribute_identifier'), ezfSolrDocumentFieldObjectRelation::getClassAttributeType($imageName3->attribute('contentclass_attribute'))); $expectedData3[$fieldNameImageName3] = trim(implode(' ', array_values(ezfSolrDocumentFieldBase::getInstance($imageName3)->getData())), "\t\r\n "); $fieldNameImageCaption3 = ezfSolrDocumentFieldBase::generateSubattributeFieldName($ezcca3, $imageCaption3->attribute('contentclass_attribute_identifier'), ezfSolrDocumentFieldObjectRelation::getClassAttributeType($imageCaption3->attribute('contentclass_attribute'))); $expectedData3[$fieldNameImageCaption3] = trim(implode(' ', array_values(ezfSolrDocumentFieldBase::getInstance($imageCaption3)->getData())), "\t\r\n "); $image3 = eZContentObject::fetch($imageId3); $metaAttributeValues = eZSolr::getMetaAttributesForObject($image3); foreach ($metaAttributeValues as $metaInfo) { $expectedData3[ezfSolrDocumentFieldBase::generateSubmetaFieldName($metaInfo['name'], $ezcca3)] = ezfSolrDocumentFieldBase::preProcessValue($metaInfo['value'], $metaInfo['fieldType']); } $providerArray[] = array($expectedData3, $ezcoa3); #end 3 // Let's perform the actual testing : foreach ($providerArray as $input) { $expected = $input[0]; $contentObjectAttribute = $input[1]; $instance = ezfSolrDocumentFieldBase::getInstance($contentObjectAttribute); self::assertEquals($expected, $instance->getData()); } }
protected function getDateFilter() { $startDateTime = DateTime::createFromFormat('H i s n j Y', implode(' ', $this->startDateArray), self::timezone()); $startTimeStamp = $startDateTime->format('U'); $endDateTime = clone $startDateTime; $this->addInterval($endDateTime); $endTimeStamp = $endDateTime->format('U'); $endDateTime = $endTimeStamp > $startTimeStamp ? $endTimeStamp-- : $startTimeStamp--; $startDate = ezfSolrDocumentFieldBase::preProcessValue($startTimeStamp, 'date'); $endDate = ezfSolrDocumentFieldBase::preProcessValue($endTimeStamp, 'date'); if ($endTimeStamp > $startTimeStamp) { return array('meta_published_dt:[' . $startDate . ' TO ' . $endDate . ']'); } else { return array('meta_published_dt:[' . $endDate . ' TO ' . $startDate . ']'); } }
/** * Translates a solr response into result objects or a slightly modified array. * The $asObjects parameter controls which of the 2 return formats get send back. * @see eZSolrBase::search * @see eZSolrBase::moreLikeThis */ protected function buildResultObjects($resultArray, &$searchCount, $asObjects = true, $fieldsToReturn = array()) { $objectRes = array(); $highLights = array(); if (!empty($resultArray['highlighting'])) { foreach ($resultArray['highlighting'] as $id => $highlight) { $highLightStrings = array(); //implode apparently does not work on associative arrays that contain arrays //$element being an array as well foreach ($highlight as $key => $element) { $highLightStrings[] = implode(' ', $element); } $highLights[$id] = implode(' ... ', $highLightStrings); } } if (!empty($resultArray)) { $result = $resultArray['response']; $maxScore = $result['maxScore']; $docs = $result['docs']; $localNodeIDList = array(); $nodeRowList = array(); // Loop through result, and get eZContentObjectTreeNode ID foreach ($docs as $idx => $doc) { if ($doc[ezfSolrDocumentFieldBase::generateMetaFieldName('installation_id')] == self::installationID()) { $localNodeIDList[] = $this->getNodeID($doc); } } if (!empty($localNodeIDList)) { $tmpNodeRowList = eZContentObjectTreeNode::fetch($localNodeIDList, false, false); // Workaround for eZContentObjectTreeNode::fetch behaviour if (count($localNodeIDList) === 1) { $tmpNodeRowList = array($tmpNodeRowList); } if ($tmpNodeRowList) { foreach ($tmpNodeRowList as $nodeRow) { $nodeRowList[$nodeRow['node_id']] = $nodeRow; } } unset($tmpNodeRowList); } //need refactoring from the moment Solr has globbing in fl parameter foreach ($docs as $idx => $doc) { if (!$asObjects) { $emit = array(); foreach ($doc as $fieldName => $fieldValue) { // check if field is not in the explicit field list, to keep explode from generating notices. if (strpos($fieldName, '_') !== false) { list($prefix, $rest) = explode('_', $fieldName, 2); // get the identifier for meta, binary fields $inner = implode('_', explode('_', $rest, -1)); if ($prefix === 'meta') { $emit[$inner] = $fieldValue; } elseif ($prefix === 'as') { $emit['data_map'][$inner] = ezfSolrStorage::unserializeData($fieldValue); } } elseif (in_array($fieldName, $fieldsToReturn)) { $emit['fields'][$fieldName] = $fieldValue; } } $emit['highlight'] = isset($highLights[$doc[ezfSolrDocumentFieldBase::generateMetaFieldName('guid')]]) ? $highLights[$doc[ezfSolrDocumentFieldBase::generateMetaFieldName('guid')]] : null; $objectRes[] = $emit; unset($emit); continue; } elseif ($doc[ezfSolrDocumentFieldBase::generateMetaFieldName('installation_id')] == self::installationID()) { // Search result document is from current installation $nodeID = $this->getNodeID($doc); // Invalid $nodeID // This can happen if a content has been deleted while Solr was not running, provoking desynchronization if (!isset($nodeRowList[$nodeID])) { $searchCount--; eZDebug::writeError("Node #{$nodeID} (/{$doc[ezfSolrDocumentFieldBase::generateMetaFieldName('main_url_alias')]}) returned by Solr cannot be found in the database. Please consider reindexing your content", __METHOD__); continue; } $resultTree = new eZFindResultNode($nodeRowList[$nodeID]); $node = $nodeRowList[$nodeID]; $resultTree->setContentObject(new eZContentObject(array("id" => $node["id"], "section_id" => $node["section_id"], "owner_id" => $node["owner_id"], "contentclass_id" => $node["contentclass_id"], "name" => $node["name"], "published" => $node["published"], "modified" => $node["modified"], "current_version" => $node["current_version"], "status" => $node["status"], "remote_id" => $node["object_remote_id"], "language_mask" => $node["language_mask"], "initial_language_id" => $node["initial_language_id"], "class_identifier" => $node["class_identifier"], "serialized_name_list" => $node["class_serialized_name_list"]))); $resultTree->setAttribute('is_local_installation', true); // can_read permission must be checked as they could be out of sync in Solr, however, when called from template with: // limitation, hash( 'accessWord', ... ) this check should not be performed as it has precedence. // See: http://issues.ez.no/15978 if (!isset($params['Limitation'], $params['Limitation']['accessWord']) && !$resultTree->attribute('object')->attribute('can_read')) { $searchCount--; eZDebug::writeNotice('Access denied for eZ Find result, node_id: ' . $nodeID, __METHOD__); continue; } $urlAlias = $this->getUrlAlias($doc); $globalURL = $urlAlias . '/(language)/' . $doc[ezfSolrDocumentFieldBase::generateMetaFieldName('language_code')]; eZURI::transformURI($globalURL); } else { $resultTree = new eZFindResultNode(); $resultTree->setAttribute('is_local_installation', false); $globalURL = $doc[ezfSolrDocumentFieldBase::generateMetaFieldName('installation_url')] . $doc[ezfSolrDocumentFieldBase::generateMetaFieldName('main_url_alias')] . '/(language)/' . $doc[ezfSolrDocumentFieldBase::generateMetaFieldName('language_code')]; } $resultTree->setAttribute('name', $doc[ezfSolrDocumentFieldBase::generateMetaFieldName('name')]); $resultTree->setAttribute('published', $doc[ezfSolrDocumentFieldBase::generateMetaFieldName('published')]); $resultTree->setAttribute('global_url_alias', $globalURL); $resultTree->setAttribute('highlight', isset($highLights[$doc[ezfSolrDocumentFieldBase::generateMetaFieldName('guid')]]) ? $highLights[$doc[ezfSolrDocumentFieldBase::generateMetaFieldName('guid')]] : null); /** * $maxScore may be equal to 0 when the QueryElevationComponent is used. * It returns as first results the elevated documents, with a score equal to 0. In case no * other document than the elevated ones are returned, maxScore is then 0 and the * division below raises a warning. If maxScore is equal to zero, we can safely assume * that only elevated documents were returned. The latter have an articifial relevancy of 100%, * which must be reflected in the 'score_percent' attribute of the result node. */ $maxScore != 0 ? $resultTree->setAttribute('score_percent', (int) ($doc['score'] / $maxScore * 100)) : $resultTree->setAttribute('score_percent', 100); $resultTree->setAttribute('language_code', $doc[ezfSolrDocumentFieldBase::generateMetaFieldName('language_code')]); $objectRes[] = $resultTree; } } return $objectRes; }
/** * Get ezfSolrDocumentFieldBase instances for all attributes of specified eZContentObjectVersion * * @param eZContentObjectVersion $objectVersion Instance of eZContentObjectVersion to fetch attributes from. * @return ezfSolrDocumentFieldBase[]|ocSolrDocumentFieldObjectRelation[] List of ezfSolrDocumentFieldBase instances. */ function getBaseList(eZContentObjectVersion $objectVersion) { $returnList = array(); // Get ezfSolrDocumentFieldBase instance for all attributes in related object /** @var eZContentObjectAttribute $attribute */ foreach ($objectVersion->contentObjectAttributes($this->ContentObjectAttribute->attribute('language_code')) as $attribute) { /** @var eZContentClassAttribute $classAttribute */ $classAttribute = $attribute->attribute('contentclass_attribute'); if ($classAttribute->attribute('is_searchable')) { $returnList[] = ezfSolrDocumentFieldBase::getInstance($attribute); } } return $returnList; }
public function fetch() { $startDateArray = array('hour' => '00', 'minute' => '00', 'second' => '00', 'month' => $this->parameters['month'], 'day' => $this->parameters['day'], 'year' => $this->parameters['year']); $originalStartDateTime = DateTime::createFromFormat('H i s n j Y', implode(' ', $startDateArray), self::timezone()); $this->parameters['picker_date'] = date(self::PICKER_DATE_FORMAT, $originalStartDateTime->getTimestamp()); if ($this->parameters['interval'] == self::INTERVAL_MONTH) { $startDateArray['day'] = 1; } $startDateTime = DateTime::createFromFormat('H i s n j Y', implode(' ', $startDateArray), self::timezone()); if (!$startDateTime instanceof DateTime) { throw new Exception("Data non valida"); } $interval = new DateInterval($this->parameters['interval']); if (!$interval instanceof DateInterval) { throw new Exception("Intervallo non valido"); } // start day $this->parameters['timestamp'] = $startDateTime->getTimestamp(); $this->parameters['days_of_month'] = date('t', $startDateTime->getTimestamp()); $this->parameters['start_weekday'] = date('w', $startDateTime->getTimestamp()); $endOfMonthArray = array_merge($startDateArray, array('day' => $this->parameters['days_of_month'])); $endOfMonthDateTime = DateTime::createFromFormat('H i s n j Y', implode(' ', $endOfMonthArray), self::timezone()); $this->parameters['end_weekday'] = date('w', $endOfMonthDateTime->getTimestamp()); $fromTimeStamp = $startDateTime->format('U'); $this->parameters['search_from_solr'] = ezfSolrDocumentFieldBase::preProcessValue($startDateTime->getTimestamp(), 'date'); $this->parameters['search_from_timestamp'] = $startDateTime->getTimestamp(); // end day $endDateTime = clone $startDateTime; $endDateTime->add($interval); $endTimeStamp = $endDateTime->format('U'); $this->parameters['search_to_solr'] = ezfSolrDocumentFieldBase::preProcessValue($endDateTime->getTimestamp() - 1, 'date'); $this->parameters['search_to_timestamp'] = $endDateTime->getTimestamp(); $this->parameters['search_to_picker_date'] = date(self::PICKER_DATE_FORMAT, $endDateTime->getTimestamp()); // filter $this->filters[] = array('or', 'attr_from_time_dt:[' . $this->parameters['search_from_solr'] . ' TO ' . $this->parameters['search_to_solr'] . ']', 'attr_to_time_dt:[' . $this->parameters['search_from_solr'] . ' TO ' . $this->parameters['search_to_solr'] . ']', array('and', 'attr_from_time_dt:[* TO ' . $this->parameters['search_from_solr'] . ']', 'attr_to_time_dt:[' . $this->parameters['search_to_solr'] . ' TO *]')); $facets = array(); //esempio: $this->parameters['Materia'] = '"Economia e diritto"'; foreach (self::relatedParameters() as $fieldIdentifier => $fieldName) { if (isset($this->parameters[$fieldName]) && $this->parameters[$fieldName] !== false) { if (is_array($this->parameters[$fieldName])) { $orFilter = array('or'); foreach ($this->parameters[$fieldName] as $value) { $filterValue = addcslashes($value, '"'); $orFilter[] = "subattr_{$fieldIdentifier}___name____s:\"{$filterValue}\""; } $this->filters[] = $orFilter; } else { $filterValue = addcslashes($this->parameters[$fieldName], '"'); $this->filters[] = "subattr_{$fieldIdentifier}___name____s:\"{$filterValue}\""; } } $facets[] = array('field' => "subattr_{$fieldIdentifier}___name____s", 'name' => $fieldName, 'limit' => 100, 'sort' => 'alpha'); } if (is_array($this->parameters['filter'])) { $this->filters = array_merge($this->filters, $this->parameters['filter']); } $sortBy = array('attr_priority_si' => 'desc', 'attr_special_b' => 'desc'); if (class_exists('ezfIndexEventDuration')) { $sortBy['extra_event_duration_s'] = 'asc'; } $sortBy['attr_from_time_dt'] = 'asc'; $solrFetchParams = array('SearchOffset' => 0, 'SearchLimit' => 1000, 'Facet' => $facets, 'SortBy' => $sortBy, 'Filter' => $this->filters, 'SearchContentClassID' => null, 'SearchSectionID' => null, 'SearchSubTreeArray' => $this->parameters['subtree'], 'AsObjects' => false, 'SpellCheck' => null, 'IgnoreVisibility' => null, 'Limitation' => null, 'BoostFunctions' => null, 'QueryHandler' => 'ezpublish', 'EnableElevation' => true, 'ForceElevation' => true, 'SearchDate' => null, 'DistributedSearch' => null, 'FieldsToReturn' => self::fieldsToReturn(), 'SearchResultClustering' => null, 'ExtendedAttributeFilter' => array()); $solrSearch = new OCSolr(); $solrResult = $solrSearch->search($this->parameters['query'], $solrFetchParams); //eZDebug::writeNotice( $this->filters, __METHOD__ ); //eZDebug::writeNotice( $solrResult, __METHOD__ ); $this->data['parameters'] = $this->parameters; $this->data['fetch_parameters'] = $solrFetchParams; $facetFields = $solrResult['SearchExtras']->attribute('facet_fields'); //eZDebug::writeNotice( $solrResult['SearchExtras'], __METHOD__ ); $resultFacets = array(); foreach ($facets as $index => $facet) { if (isset($facetFields[$index]['queryLimit']) && !empty($facetFields[$index]['queryLimit'])) { if (isset($facetFields[$index]['fieldList'])) { foreach ($facetFields[$index]['fieldList'] as $key => $value) { $resultFacets[$facet['name']][] = $key; } } else { foreach ($facetFields[$index]['nameList'] as $key => $value) { $resultFacets[$facet['name']][] = $key; } } } } $this->data['search_facets'] = $this->sortFacets($resultFacets); $events = array(); foreach ($solrResult['SearchResult'] as $item) { $event = OCCalendarItem::fromEzfindResultArray($item); if ($event->isValid()) { $events[] = $event; } } $timeTableEvents = $this->fetchTimeTableEvents(); if (count($timeTableEvents)) { $events = self::reorderEvents(array_merge($events, $timeTableEvents)); } //eZDebug::writeNotice( $events, __METHOD__ ); $this->data['search_count'] = count($events); $eventsByDay = array(); $byDayInterval = new DateInterval('P1D'); $byDayPeriod = new DatePeriod($startDateTime, $byDayInterval, $endDateTime); foreach ($byDayPeriod as $date) { $identifier = $date->format(self::FULLDAY_IDENTIFIER_FORMAT); $calendarDay = new OCCalendarDay($identifier); $calendarDay->addEvents($events); $eventsByDay[$identifier] = $calendarDay; } $this->data['events'] = $events; $this->data['day_by_day'] = $eventsByDay; //eZDebug::writeNotice( $eventsByDay, __METHOD__ ); //eZDebug::writeNotice( $this->data['search_facets'], __METHOD__ ); }
/** * Sets the static DocumentFieldName instance * * @return ezfSolrDocumentFieldName */ public static function getDocumentFieldName() { return self::$DocumentFieldName = self::$DocumentFieldName instanceof ezfSolrDocumentFieldName ? self::$DocumentFieldName : new ezfSolrDocumentFieldName(); }
function fakeAddObject($contentObject) { $eZSolr = new eZSolr(); // Add all translations to the document list $docList = array(); // Check if we need to index this object after all // Exclude if class identifier is in the exclude list for classes $excludeClasses = $eZSolr->FindINI->variable('IndexExclude', 'ClassIdentifierList'); if ($excludeClasses && in_array($contentObject->attribute('class_identifier'), $excludeClasses)) { return false; } // Get global object values $mainNode = $contentObject->attribute('main_node'); if (!$mainNode) { eZDebug::writeError('Unable to fetch main node for object: ' . $contentObject->attribute('id'), __METHOD__); return false; } $mainNodePathArray = $mainNode->attribute('path_array'); // initialize array of parent node path ids, needed for multivalued path field and subtree filters $nodePathArray = array(); //included in $nodePathArray //$pathArray = $mainNode->attribute( 'path_array' ); $currentVersion = $contentObject->currentVersion(); // Get object meta attributes. $metaAttributeValues = eZSolr::getMetaAttributesForObject($contentObject); // Get node attributes. $nodeAttributeValues = array(); foreach ($contentObject->attribute('assigned_nodes') as $contentNode) { foreach (eZSolr::nodeAttributes() as $attributeName => $fieldType) { $nodeAttributeValues[] = array('name' => $attributeName, 'value' => $contentNode->attribute($attributeName), 'fieldType' => $fieldType); } $nodePathArray[] = $contentNode->attribute('path_array'); } // Check anonymous user access. if ($eZSolr->FindINI->variable('SiteSettings', 'IndexPubliclyAvailable') == 'enabled') { $anonymousUserID = $eZSolr->SiteINI->variable('UserSettings', 'AnonymousUserID'); $currentUserID = eZUser::currentUserID(); $user = eZUser::instance($anonymousUserID); eZUser::setCurrentlyLoggedInUser($user, $anonymousUserID); $anonymousAccess = $contentObject->attribute('can_read'); $user = eZUser::instance($currentUserID); eZUser::setCurrentlyLoggedInUser($user, $currentUserID); $anonymousAccess = $anonymousAccess ? 'true' : 'false'; } else { $anonymousAccess = 'false'; } // Load index time boost factors if any //$boostMetaFields = $eZSolr->FindINI->variable( "IndexBoost", "MetaField" ); $boostClasses = $eZSolr->FindINI->variable('IndexBoost', 'Class'); $boostAttributes = $eZSolr->FindINI->variable('IndexBoost', 'Attribute'); $boostDatatypes = $eZSolr->FindINI->variable('IndexBoost', 'Datatype'); $reverseRelatedScale = $eZSolr->FindINI->variable('IndexBoost', 'ReverseRelatedScale'); // Initialise default doc boost $docBoost = 1.0; $contentClassIdentifier = $contentObject->attribute('class_identifier'); // Just test if the boost factor is defined by checking if it has a numeric value if (isset($boostClasses[$contentClassIdentifier]) && is_numeric($boostClasses[$contentClassIdentifier])) { $docBoost += $boostClasses[$contentClassIdentifier]; } // Google like boosting, using eZ Publish reverseRelatedObjectCount $reverseRelatedObjectCount = $contentObject->reverseRelatedObjectCount(); $docBoost += $reverseRelatedScale * $reverseRelatedObjectCount; // Create the list of available languages for this version : $availableLanguages = $currentVersion->translationList(false, false); // Loop over each language version and create an eZSolrDoc for it foreach ($availableLanguages as $languageCode) { $doc = new eZSolrDoc($docBoost); // Set global unique object ID $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('guid'), $eZSolr->guid($contentObject, $languageCode)); // Set installation identifier $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('installation_id'), eZSolr::installationID()); $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('installation_url'), $eZSolr->FindINI->variable('SiteSettings', 'URLProtocol') . $eZSolr->SiteINI->variable('SiteSettings', 'SiteURL') . '/'); // Set Object attributes $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('name'), $contentObject->name(false, $languageCode)); // Also add value to the "sort_name" field as "name" is unsortable, due to Solr limitation (tokenized field) $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('sort_name'), $contentObject->name(false, $languageCode)); $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('anon_access'), $anonymousAccess); $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('language_code'), $languageCode); $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('available_language_codes'), $availableLanguages); if ($owner = $contentObject->attribute('owner')) { // Set owner name $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('owner_name'), $owner->name(false, $languageCode)); // Set owner group ID foreach ($owner->attribute('parent_nodes') as $groupID) { $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('owner_group_id'), $groupID); } } // from eZ Publish 4.1 only: object states // so let's check if the content object has it if (method_exists($contentObject, 'stateIDArray')) { $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('object_states'), $contentObject->stateIDArray()); } // Set content object meta attribute values. foreach ($metaAttributeValues as $metaInfo) { $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName($metaInfo['name']), ezfSolrDocumentFieldBase::preProcessValue($metaInfo['value'], $metaInfo['fieldType'])); } // Set content node meta attribute values. foreach ($nodeAttributeValues as $metaInfo) { $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName($metaInfo['name']), ezfSolrDocumentFieldBase::preProcessValue($metaInfo['value'], $metaInfo['fieldType'])); } // Add main url_alias $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('main_url_alias'), $mainNode->attribute('url_alias')); // Add main path_string $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('main_path_string'), $mainNode->attribute('path_string')); // add nodeid of all parent nodes path elements foreach ($nodePathArray as $pathArray) { foreach ($pathArray as $pathNodeID) { $doc->addField(ezfSolrDocumentFieldBase::generateMetaFieldName('path'), $pathNodeID); } } // Since eZ Fnd 2.3 // cannot call metafield field bame constructor as we are creating multiple fields foreach ($mainNodePathArray as $key => $pathNodeID) { $doc->addField('meta_main_path_element_' . $key . '_si', $pathNodeID); } eZContentObject::recursionProtectionStart(); // Loop through all eZContentObjectAttributes and add them to the Solr document. // @since eZ Find 2.3: look for the attribute storage setting $doAttributeStorage = $eZSolr->FindINI->variable('IndexOptions', 'EnableSolrAttributeStorage') === 'true' ? true : false; if ($doAttributeStorage) { $allAttributeData = array(); } foreach ($currentVersion->contentObjectAttributes($languageCode) as $attribute) { $metaDataText = ''; $classAttribute = $attribute->contentClassAttribute(); $attributeIdentifier = $classAttribute->attribute('identifier'); $combinedIdentifier = $contentClassIdentifier . '/' . $attributeIdentifier; $boostAttribute = false; if (isset($boostAttributes[$attributeIdentifier]) && is_numeric($boostAttributes[$attributeIdentifier])) { $boostAttribute = $boostAttributes[$attributeIdentifier]; } if (isset($boostAttributes[$combinedIdentifier]) && is_numeric($boostAttributes[$combinedIdentifier])) { $boostAttribute += $boostAttributes[$combinedIdentifier]; } if ($classAttribute->attribute('is_searchable') == 1) { $documentFieldBase = ezfSolrDocumentFieldBase::getInstance($attribute); $eZSolr->addFieldBaseToDoc($documentFieldBase, $doc, $boostAttribute); } if ($doAttributeStorage) { $storageFieldName = ezfSolrStorage::getSolrStorageFieldName($attributeIdentifier); $attributeData = ezfSolrStorage::getAttributeData($attribute); $allAttributeData['data_map'][$attributeIdentifier] = $attributeData; $doc->addField($storageFieldName, ezfSolrStorage::serializeData($attributeData)); } } eZContentObject::recursionProtectionEnd(); if ($doAttributeStorage) { $doc->addField('as_all_bst', ezfSolrStorage::serializeData($allAttributeData)); } $docList[$languageCode] = $doc; $generalPlugins = (array) eZINI::instance('ezfind.ini')->variable('IndexPlugins', 'General'); $classPlugins = (array) eZINI::instance('ezfind.ini')->variable('IndexPlugins', 'Class'); if (!empty($generalPlugins)) { foreach ($generalPlugins as $pluginClassString) { if (!class_exists($pluginClassString)) { eZDebug::writeError("Unable to find the PHP class '{$pluginClassString}' defined for index time plugins for eZ Find", __METHOD__); continue; } $plugin = new $pluginClassString(); if ($plugin instanceof ezfIndexPlugin) { $plugin->modify($contentObject, $docList); } } } if (array_key_exists($contentObject->attribute('class_identifier'), $classPlugins)) { $pluginClassString = $classPlugins[$contentObject->attribute('class_identifier')]; if (class_exists($pluginClassString)) { $plugin = new $pluginClassString(); if ($plugin instanceof ezfIndexPlugin) { $plugin->modify($contentObject, $docList); } } } } return $docList; }