/**
* Adds object $contentObject to the search database.
*
* @param eZContentObject $contentObject Object to add to search engine
* @param bool $commit Whether to commit after adding the object.
If set, run optimize() as well every 1000nd time this function is run.
* @return bool True if the operation succeed.
*/
function addObject( $contentObject, $commit = true )
{
// 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 = $this->FindINI->variable( 'IndexExclude', 'ClassIdentifierList' );
if ( $excludeClasses && in_array( $contentObject->attribute( 'class_identifier' ), $excludeClasses ) )
{
return true;
}
// 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' );
$mainNodeID = $mainNode->attribute( 'node_id' );
// 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 = self::getMetaAttributesForObject( $contentObject );
// Get node attributes.
$nodeAttributeValues = array();
foreach ( $contentObject->attribute( 'assigned_nodes' ) as $contentNode )
{
$nodeID = $contentNode->attribute( 'node_id' );
foreach ( eZSolr::nodeAttributes() as $attributeName => $fieldType )
{
$nodeAttributeValues[$nodeID][] = array( 'name' => $attributeName,
'value' => $contentNode->attribute( $attributeName ),
'fieldType' => $fieldType );
}
$nodePathArray[] = $contentNode->attribute( 'path_array' );
}
// Check anonymous user access.
if ( $this->FindINI->variable( 'SiteSettings', 'IndexPubliclyAvailable' ) == 'enabled' )
{
$anonymousUserID = $this->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 = $this->FindINI->variable( "IndexBoost", "MetaField" );
$boostClasses = $this->FindINI->variable( 'IndexBoost', 'Class' );
$boostAttributes = $this->FindINI->variable( 'IndexBoost', 'Attribute' );
$boostDatatypes = $this->FindINI->variable( 'IndexBoost', 'Datatype' );
$reverseRelatedScale = $this->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' ), $this->guid( $contentObject, $languageCode ) );
// Set installation identifier
$doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'installation_id' ), self::installationID() );
$doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( 'installation_url' ),
$this->FindINI->variable( 'SiteSettings', 'URLProtocol' ) . $this->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 $nodeID => $metaInfoArray )
{
foreach( $metaInfoArray as $metaInfo)
{
$doc->addField( ezfSolrDocumentFieldBase::generateMetaFieldName( $metaInfo['name'] ),
ezfSolrDocumentFieldBase::preProcessValue( $metaInfo['value'], $metaInfo['fieldType'] ) );
}
}
// Main node gets single valued fields for sorting, using a dedicated prefix
foreach ( $nodeAttributeValues[$mainNodeID] as $metaInfo )
{
$fieldName = 'main_node_' . ezfSolrDocumentFieldBase::generateMetaFieldName( $metaInfo['name'] );
$doc->addField( $fieldName,
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 = ( ( $this->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 );
$this->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;
}
// Since eZFind 2.7: indexhooks
$generalPlugins = $this->FindINI->variable( 'IndexPlugins', 'General' );
$classPlugins = $this->FindINI->variable( 'IndexPlugins', 'Class' );
if ( !empty( $generalPlugins ) )
{
foreach ( $generalPlugins as $pluginClassString )
{
if( !class_exists( $pluginClassString ) )
{
eZDebug::writeError( "Unable to find the PHP class '$classname' 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 );
}
}
}
$optimize = false;
if ( $this->FindINI->variable( 'IndexOptions', 'DisableDirectCommits' ) === 'true' )
{
$commit = false;
}
$commitWithin = 0;
if ( $this->FindINI->variable( 'IndexOptions', 'CommitWithin' ) > 0 )
{
$commitWithin = $this->FindINI->variable( 'IndexOptions', 'CommitWithin' );
}
if ( $commit && ( $this->FindINI->variable( 'IndexOptions', 'OptimizeOnCommit' ) === 'enabled' ) )
{
$optimize = true;
}
if ( $this->UseMultiLanguageCores === true)
{
$result = true;
foreach ( $availableLanguages as $languageCode )
{
$languageResult = $this->SolrLanguageShards[$languageCode]->addDocs( array( $docList[$languageCode] ), $commit, $optimize, $commitWithin );
if ( !$languageResult )
{
$result = false;
}
}
return $result;
}
else
{
return $this->Solr->addDocs( $docList, $commit, $optimize, $commitWithin );
}
}
/**
* @see ezfSolrDocumentFieldBase::getData()
*/
public function getData()
{
/** @var eZContentClassAttribute $contentClassAttribute */
$contentClassAttribute = $this->ContentObjectAttribute->attribute('contentclass_attribute');
switch ($contentClassAttribute->attribute('data_type_string')) {
case 'ezobjectrelation':
$returnArray = array();
/** @var eZContentObject $relatedObject */
$relatedObject = $this->ContentObjectAttribute->content();
if ($relatedObject) {
$returnArray = $this->getArrayRelatedObject($relatedObject, $contentClassAttribute);
eZContentObject::clearCache(array($relatedObject->attribute('id')));
}
return $returnArray;
break;
case 'ezobjectrelationlist':
$returnArray = array();
$returnArrayRelatedObject = array();
$content = $this->ContentObjectAttribute->content();
$relationCount = count($content['relation_list']);
foreach ($content['relation_list'] as $relationItem) {
$subObjectID = $relationItem['contentobject_id'];
if (!$subObjectID) {
continue;
}
/** @var eZContentObjectVersion $subObject */
$subObject = eZContentObjectVersion::fetchVersion($relationItem['contentobject_version'], $subObjectID);
if (!$subObject instanceof eZContentObjectVersion) {
$subObjectWrapper = eZContentObject::fetch($subObjectID);
if ($subObjectWrapper instanceof eZContentObject) {
$subObject = $subObjectWrapper->currentVersion();
} else {
continue;
}
}
/** @var eZContentObject $subContentObject */
$subContentObject = $subObject->attribute('contentobject');
if (intval($subContentObject->attribute('main_node_id')) == 0) {
continue;
}
$metaAttributeValues = eZSolr::getMetaAttributesForObject($subContentObject);
foreach ($metaAttributeValues as $metaInfo) {
$submetaFieldName = ezfSolrDocumentFieldBase::generateSubmetaFieldName($metaInfo['name'], $contentClassAttribute);
if (isset($returnArray[$submetaFieldName])) {
$returnArray[$submetaFieldName] = array_merge($returnArray[$submetaFieldName], array(ezfSolrDocumentFieldBase::preProcessValue($metaInfo['value'], $metaInfo['fieldType'])));
} else {
$returnArray[$submetaFieldName] = array(ezfSolrDocumentFieldBase::preProcessValue($metaInfo['value'], $metaInfo['fieldType']));
}
}
$nodeAttributeValues = array();
$nodePathArray = array();
/** @var eZContentObjectTreeNode $contentNode */
foreach ($subContentObject->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');
}
//@todo questo non va... occorre correggere schema.xml?
//foreach ( $nodeAttributeValues as $metaInfo )
//{
// $submetaFieldName = ezfSolrDocumentFieldBase::generateSubmetaFieldName( $metaInfo['name'], $contentClassAttribute );
// if ( isset( $returnArray[$submetaFieldName] ) )
// {
// $returnArray[$submetaFieldName] = array_merge( $returnArray[$submetaFieldName],
// array( ezfSolrDocumentFieldBase::preProcessValue( $metaInfo['value'], $metaInfo['fieldType'] ) ) );
// }
// else
// {
// $returnArray[$submetaFieldName] = array( ezfSolrDocumentFieldBase::preProcessValue( $metaInfo['value'], $metaInfo['fieldType'] ) );
// }
//}
foreach ($nodePathArray as $pathArray) {
$submetaFieldName = ezfSolrDocumentFieldBase::generateSubmetaFieldName('path', $contentClassAttribute);
foreach ($pathArray as $pathNodeID) {
if (isset($returnArray[$submetaFieldName])) {
$returnArray[$submetaFieldName] = array_merge($returnArray[$submetaFieldName], array($pathNodeID));
} else {
$returnArray[$submetaFieldName] = array($pathNodeID);
}
}
}
if ($relationCount < 200) {
$returnArrayRelatedObject = $this->getArrayRelatedObject($subContentObject, $contentClassAttribute, $returnArrayRelatedObject);
} else {
$objectName = $subContentObject->name(false, $this->ContentObjectAttribute->attribute('language_code'));
$fieldName = parent::generateSubattributeFieldName($contentClassAttribute, 'name', self::DEFAULT_SUBATTRIBUTE_TYPE);
if (isset($returnArrayRelatedObject[$fieldName])) {
$returnArrayRelatedObject[$fieldName][] = $objectName;
} else {
$returnArrayRelatedObject[$fieldName] = array($objectName);
}
}
$returnArray = array_merge_recursive($returnArray, $returnArrayRelatedObject);
eZContentObject::clearCache(array($subContentObject->attribute('id')));
}
$defaultFieldName = parent::generateAttributeFieldName($contentClassAttribute, self::$subattributesDefinition[self::DEFAULT_SUBATTRIBUTE]);
$stringFieldName = parent::generateAttributeFieldName($contentClassAttribute, 'string');
$returnArray[$defaultFieldName] = $this->getPlainTextRepresentation();
$returnArray[$stringFieldName] = $this->getPlainTextRepresentation();
$result = array();
foreach ($returnArray as $key => $value) {
if (is_array($value)) {
$value = array_unique($value);
}
$result[$key] = $value;
}
return $result;
break;
}
return array();
}
