PHP FinderIndexer类代码示例

 protected function index(FinderIndexerResult $item, $format = 'html')
 {
     // Check if the extension is enabled
     if (JComponentHelper::isEnabled($this->extension) == false) {
         return;
     }
     $item->body = FinderIndexerHelper::prepareContent($item->getElement('body'));
     $item->summary = FinderIndexerHelper::prepareContent($item->getElement('body'));
     $item->addTaxonomy('Type', 'FSF_FINDER_GLOSSARY');
     $word = $item->title;
     $anchor = strtolower(preg_replace("/[^A-Za-z0-9]/", '-', $word));
     $letter = strtolower(substr($word, 0, 1));
     $item->url = 'index.php?option=com_fsf&view=glossary&letter=' . $letter . '#' . $anchor;
     $item->route = $item->url;
     $item->state = $item->published;
     $item->access = 1;
     // Get content extras.
     FinderIndexerHelper::getContentExtras($item);
     // Index the item.
     if (FSFJ3Helper::IsJ3()) {
         $this->indexer->index($item);
     } else {
         FinderIndexer::index($item);
     }
 }

 /**
  * Method to index an item. The item must be a FinderIndexerResult object.
  *
  * @param	object		The item to index as an FinderIndexerResult object.
  * @throws	Exception on database error.
  */
 protected function _index(FinderIndexerResult $item)
 {
     // Build the necessary route and path information.
     $item->url = $this->_getURL($item->topic);
     $item->itemid = '100065';
     $item->route = $item->url . '&post=' . $item->id . '&Itemid=' . $item->itemid . '#p' . $item->id;
     $item->path = FinderIndexerHelper::getContentPath($item->route);
     // Add the meta-data processing instructions.
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'display_name');
     // Strip slashes!
     $item->title = stripslashes($item->title);
     $item->summary = stripslashes($item->summary);
     $item->display_name = stripslashes($item->display_name);
     $item->text = FinderIndexerHelper::prepareContent($item->summary);
     // Translate the access group to an access level.
     //$item->cat_access = $this->_getAccessLevel($item->cat_access);
     // Inherit state and access form the category.
     $item->state = 1;
     $item->access = 0;
     // Set the language.
     $item->language = FinderIndexerHelper::getDefaultLanguage();
     // Add the type taxonomy data.
     $item->addTaxonomy('Type', 'Forum Post');
     // Add the author taxonomy data.
     if (!empty($item->author)) {
         $item->addTaxonomy('Forum User', $item->display_name);
     }
     // Index the item.
     FinderIndexer::index($item);
 }

 protected function index(FinderIndexerResult $item, $format = 'html')
 {
     // Check if the extension is enabled
     if (JComponentHelper::isEnabled($this->extension) == false) {
         return;
     }
     $item->body = FinderIndexerHelper::prepareContent($item->getElement('body'));
     $item->summary = FinderIndexerHelper::prepareContent($item->getElement('body'));
     $item->addTaxonomy('Type', 'FSS_FINDER_KB_ARTICLE');
     $item->url = 'index.php?option=com_fss&view=kb&kbartid=' . $item->getElement('id');
     $item->route = $item->url;
     $item->state = $item->getElement('pub');
     // Get content extras.
     FinderIndexerHelper::getContentExtras($item);
     // Index the item.
     if (FSSJ3Helper::IsJ3()) {
         $this->indexer->index($item);
     } else {
         FinderIndexer::index($item);
     }
 }

 protected function index(FinderIndexerResult $item, $format = 'html')
 {
     // Check if the extension is enabled
     if (JComponentHelper::isEnabled($this->extension) == false || !$item->id) {
         return;
     }
     if (!($zoo_item = $this->app->table->item->get($item->id, true))) {
         return;
     }
     $registry = new JRegistry();
     $registry->loadArray($zoo_item->getParams()->get("metadata."));
     $item->metadata = $registry;
     $item->metaauthor = $zoo_item->getParams()->get("metadata.author");
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'link');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metakey');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metadesc');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metaauthor');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'author');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'created_by_alias');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'element_data');
     $item->summary = $this->renderer->render('item.default', array('item' => $zoo_item));
     $item->url = $this->getURL($item->id, $this->extension, $this->layout);
     $item->route = $this->app->route->item($zoo_item, false);
     $item->path = FinderIndexerHelper::getContentPath($item->route);
     $item->state = $zoo_item->searchable == 1 && $zoo_item->state == 1;
     $item->element_data = $this->app->database->queryResultArray('SELECT value FROM ' . ZOO_TABLE_SEARCH . ' WHERE item_id = ' . (int) $item->id);
     $item->addTaxonomy('Type', $zoo_item->getType()->name);
     foreach ($zoo_item->getRelatedCategories(true) as $category) {
         $item->addTaxonomy('Category', $category->name);
     }
     foreach ($zoo_item->getTags() as $tag) {
         $item->addTaxonomy('Tag', $tag);
     }
     FinderIndexerHelper::getContentExtras($item);
     if ($this->app->joomla->version->isCompatible('3.0')) {
         $this->indexer->index($item);
     } else {
         FinderIndexer::index($item);
     }
 }

 /**
  * Main index function run when indexing happens
  *
  * @param FinderIndexerResult $item
  * @return bool|void
  */
 protected function index(FinderIndexerResult $item)
 {
     // Check if the extension is enabled
     if (JComponentHelper::isEnabled($this->extension) == false) {
         return;
     }
     //Add the instructions
     foreach ($this->instructions as $type => $instructions) {
         foreach ($instructions as $instruction) {
             $item->addInstruction($type, $instruction);
         }
     }
     // Add the type taxonomy data.
     $item->addTaxonomy('Type', $this->type_title);
     FinderIndexerHelper::getContentExtras($item);
     // Index the item.
     if (method_exists('FinderIndexer', 'getInstance')) {
         FinderIndexer::getInstance()->index($item);
     } else {
         FinderIndexer::index($item);
     }
 }

 /**
  * Tests the resetState method
  *
  * @return  void
  *
  * @since   3.0
  */
 public function testResetState()
 {
     // Reset the state
     FinderIndexer::resetState();
     // Test we get a null object
     $this->assertNull(JFactory::getSession()->get('_finder.state', null));
 }

 /**
  * Method to optimize the index and perform any necessary cleanup.
  *
  * @return  void
  *
  * @since   2.5
  */
 public function optimize()
 {
     // We don't want this form to be cached.
     header('Pragma: no-cache');
     header('Cache-Control: no-cache');
     header('Expires: -1');
     // Check for a valid token. If invalid, send a 403 with the error message.
     JSession::checkToken('request') or $this->sendResponse(new Exception(JText::_('JINVALID_TOKEN'), 403));
     // Put in a buffer to silence noise.
     ob_start();
     // Import the finder plugins.
     JPluginHelper::importPlugin('finder');
     try {
         // Optimize the index
         FinderIndexer::getInstance()->optimize();
         // Get the indexer state.
         $state = FinderIndexer::getState();
         $state->start = 0;
         $state->complete = 1;
         // Send the response.
         $this->sendResponse($state);
     } catch (Exception $e) {
         $this->sendResponse($e);
     }
 }

 protected function index(FinderIndexerResult $item, $format = 'html')
 {
     // Check if the extension is enabled
     if (JComponentHelper::isEnabled($this->extension) == false) {
         return;
     }
     // Initialize the item parameters.
     $registry = new JRegistry();
     $registry->loadString($item->params);
     $item->params = JComponentHelper::getParams('com_k2', true);
     $item->params->merge($registry);
     $registry = new JRegistry();
     $registry->loadString($item->metadata);
     $item->metadata = $registry;
     // Trigger the onContentPrepare event.
     $item->summary = FinderIndexerHelper::prepareContent($item->summary, $item->params);
     $item->body = FinderIndexerHelper::prepareContent($item->body, $item->params);
     // Build the necessary route and path information.
     $item->url = $this->getURL($item->id, $this->extension, $this->layout);
     $item->route = K2HelperRoute::getItemRoute($item->slug, $item->catslug);
     $item->path = FinderIndexerHelper::getContentPath($item->route);
     // Get the menu title if it exists.
     $title = $this->getItemMenuTitle($item->url);
     // Adjust the title if necessary.
     if (!empty($title) && $this->params->get('use_menu_title', true)) {
         $item->title = $title;
     }
     // Add the meta-author.
     $item->metaauthor = $item->metadata->get('author');
     // Add the meta-data processing instructions.
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metakey');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metadesc');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metaauthor');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'author');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'created_by_alias');
     // Translate the state. Articles should only be published if the category is published.
     $item->state = $this->translateState($item->state, $item->cat_state);
     // Translate the trash state. Articles should only be accesible if the category is accessible.
     if ($item->trash || $item->cat_trash) {
         $item->state = 0;
     }
     // Add the type taxonomy data.
     $item->addTaxonomy('Type', 'K2 Item');
     // Add the author taxonomy data.
     if (!empty($item->author) || !empty($item->created_by_alias)) {
         $item->addTaxonomy('Author', !empty($item->created_by_alias) ? $item->created_by_alias : $item->author);
     }
     // Add the category taxonomy data.
     $item->addTaxonomy('K2 Category', $item->category, $item->cat_state, $item->cat_access);
     // Add the language taxonomy data.
     $item->addTaxonomy('Language', $item->language);
     // Get content extras.
     FinderIndexerHelper::getContentExtras($item);
     // Index the item.
     FinderIndexer::index($item);
 }

	/**
	 * Method to index an item. The item must be a FinderIndexerResult object.
	 *
	 * @param   FinderIndexerResult  $item    The item to index as an FinderIndexerResult object.
	 * @param   string               $format  The item format
	 *
	 * @return  void
	 *
	 * @throws  Exception on database error.
	 */
	protected function index(FinderIndexerResult $item, $format = 'html')
	{
		// Check if the extension is enabled
		if (JComponentHelper::isEnabled($this->extension) == false)
		{
			return;
		}

		if ($this->jVer == 3) {
			$item->setLanguage();
		}

		// Initialize the item parameters.
		$registry = new JRegistry;
		$registry->loadString($item->params);
		$item->params = JComponentHelper::getParams('com_jem', true);
		$item->params->merge($registry);

		$registry = new JRegistry;
		$registry->loadString($item->metadata);
		$item->metadata = $registry;

		// Trigger the onContentPrepare event.
		$item->summary = FinderIndexerHelper::prepareContent($item->summary, $item->params);
		$item->body = FinderIndexerHelper::prepareContent($item->fulltext, $item->params);

		// Build the necessary route and path information.
		$item->url = $this->getURL($item->id, $this->extension, $this->layout);
		$item->route = JEMHelperRoute::getEventRoute($item->slug, $item->catslug);
		$item->path = FinderIndexerHelper::getContentPath($item->route);

		// Get the menu title if it exists.
		$title = $this->getItemMenuTitle($item->url);

		// Adjust the title if necessary.
		if (!empty($title) && $this->params->get('use_menu_title', true))
		{
			$item->title = $title;
		}

		// Add the meta-author.
		$item->metaauthor = $item->metadata->get('author');

		// Add the meta-data processing instructions.
		// TODO:
// 		$item->addInstruction(FinderIndexer::META_CONTEXT, 'meta_description');

		// Translate the state. Articles should only be published if the category is published.
		$item->state = $this->translateState($item->state, $item->cat_state);

		// Add the type taxonomy data.
		$item->addTaxonomy('Type', 'Event');

		// Add the author taxonomy data.
		if (!empty($item->author) || !empty($item->created_by_alias))
		{
			$item->addTaxonomy('Author', !empty($item->created_by_alias) ? $item->created_by_alias : $item->author);
		}

		// Add the category taxonomy data.
		$item->addTaxonomy('Category', $item->category, $item->cat_state, $item->cat_access);

		// Add the language taxonomy data.
		$item->addTaxonomy('Language', $item->language);

		// Add the venue taxonomy data.
		if(!empty($item->venue)) {
			$item->addTaxonomy('Venue', $item->venue, $item->loc_published);
		}

		// Get content extras.
		FinderIndexerHelper::getContentExtras($item);

		// Index the item.
		// On J! 3.x we must use indexer member which doesn't exist on J! 2.5
		if ($this->jVer == 3) {
			$this->indexer->index($item);
		} else {
			FinderIndexer::index($item);
		}
	}

 /**
  * Run the indexer
  *
  * @return  void
  *
  * @since   2.5
  */
 private function _index()
 {
     // initialize the time value
     $this->_time = microtime(true);
     // import library dependencies
     require_once JPATH_ADMINISTRATOR . '/components/com_finder/helpers/indexer/indexer.php';
     jimport('joomla.application.component.helper');
     // fool the system into thinking we are running as JSite with Finder as the active component
     JFactory::getApplication('site');
     $_SERVER['HTTP_HOST'] = 'domain.com';
     define('JPATH_COMPONENT_ADMINISTRATOR', JPATH_ADMINISTRATOR . '/components/com_finder');
     // Disable caching.
     $config = JFactory::getConfig();
     $config->set('caching', 0);
     $config->set('cache_handler', 'file');
     // Reset the indexer state.
     FinderIndexer::resetState();
     // Import the finder plugins.
     JPluginHelper::importPlugin('finder');
     // Starting Indexer.
     $this->out(JText::_('FINDER_CLI_STARTING_INDEXER'), true);
     // Trigger the onStartIndex event.
     JDispatcher::getInstance()->trigger('onStartIndex');
     // Remove the script time limit.
     @set_time_limit(0);
     // Get the indexer state.
     $state = FinderIndexer::getState();
     // Setting up plugins.
     $this->out(JText::_('FINDER_CLI_SETTING_UP_PLUGINS'), true);
     // Trigger the onBeforeIndex event.
     JDispatcher::getInstance()->trigger('onBeforeIndex');
     // Startup reporting.
     $this->out(JText::sprintf('FINDER_CLI_SETUP_ITEMS', $state->totalItems, round(microtime(true) - $this->_time, 3)), true);
     // Get the number of batches.
     $t = (int) $state->totalItems;
     $c = (int) ceil($t / $state->batchSize);
     $c = $c === 0 ? 1 : $c;
     // Process the batches.
     for ($i = 0; $i < $c; $i++) {
         // Set the batch start time.
         $this->_qtime = microtime(true);
         // Reset the batch offset.
         $state->batchOffset = 0;
         // Trigger the onBuildIndex event.
         JDispatcher::getInstance()->trigger('onBuildIndex');
         // Batch reporting.
         $this->out(JText::sprintf('FINDER_CLI_BATCH_COMPLETE', $i + 1, round(microtime(true) - $this->_qtime, 3)), true);
     }
     // Total reporting.
     $this->out(JText::sprintf('FINDER_CLI_PROCESS_COMPLETE', round(microtime(true) - $this->_time, 3)), true);
     // Reset the indexer state.
     FinderIndexer::resetState();
 }

 /**
  * Method to index an item. The item must be a FinderIndexerResult object.
  *
  * @param   FinderIndexerResult  $item    The item to index as an FinderIndexerResult object.
  * @param   string               $format  The item format
  *
  * @return  void
  *
  * @since   2.5
  * @throws  Exception on database error.
  */
 protected function index(FinderIndexerResult $item, $format = 'html')
 {
     // Check if the extension is enabled
     if (JComponentHelper::isEnabled($this->extension) == false) {
         return;
     }
     // Initialize the item parameters.
     $registry = new JRegistry();
     $registry->loadString($item->params);
     $item->params = JComponentHelper::getParams('com_jshopping', true);
     $item->params->merge($registry);
     // Trigger the onContentPrepare event.
     $item->summary = FinderIndexerHelper::prepareContent($item->summary, $item->params);
     $item->body = FinderIndexerHelper::prepareContent($item->body, $item->params);
     // Build the necessary route and path information.
     $item->url = 'index.php?option=com_jshopping&controller=product&task=view&category_id=' . $item->category_id . '&product_id=' . $item->product_id;
     $item->route = 'index.php?option=com_jshopping&controller=product&task=view&category_id=' . $item->category_id . '&product_id=' . $item->product_id;
     $item->path = FinderIndexerHelper::getContentPath($item->route);
     // Get the menu title if it exists.
     $title = $this->getItemMenuTitle($item->url);
     // Adjust the title if necessary.
     if (!empty($title) && $this->params->get('use_menu_title', true)) {
         $item->title = $title;
     }
     // Add the meta-author.
     // Add the meta-data processing instructions.
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metakey');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metadesc');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'link');
     // Add the type taxonomy data.
     $item->addTaxonomy('Type', 'Product');
     // Add the category taxonomy data.
     $item->addTaxonomy('Category', $item->category, $item->cat_state, $item->cat_access);
     // Get content extras.
     FinderIndexerHelper::getContentExtras($item);
     // Index the item.
     if (version_compare(JVERSION, '3.0.0', 'ge')) {
         $this->indexer->index($item);
     } else {
         FinderIndexer::index($item);
     }
 }

 /**
  * Indexes a post on the site
  *
  * @since	5.0
  * @access	public
  * @param	FinderIndexerResult		The item to index
  * @param	string	The item's format
  * @return	void
  */
 protected function index(FinderIndexerResult $item, $format = 'html')
 {
     // Check if the extension is enabled
     if (!$this->exists()) {
         return;
     }
     // Build the necessary route and path information.
     $item->url = 'index.php?option=com_easyblog&view=entry&id=' . $item->id;
     $item->route = EBR::getRoutedURL($item->url, false, true);
     // Remove any /administrator/ segments from the url since the indexer could be executed from the back end
     $item->route = $this->removeAdminSegment($item->route);
     // Get the content path
     $item->path = FinderIndexerHelper::getContentPath($item->route);
     // If there is access defined, just set it to 2 which is special privileges.
     if (!$item->access || $item->access == 0) {
         $item->access = 1;
     } else {
         if ($item->access > 0) {
             $item->access = 2;
         }
     }
     // Load up the post item
     $post = EB::post();
     $post->load($item->id);
     // Get the intro text of the content
     $item->summary = $post->getIntro();
     // Get the contents
     $item->body = $post->getContent('entry', false);
     // If the post is password protected, we do not want to display the contents
     if ($post->isPasswordProtected()) {
         $item->summary = JText::_('PLG_FINDER_EASYBLOG_PASSWORD_PROTECTED');
     } else {
         // we want to get custom fields values.
         $fields = $post->getCustomFields();
         $fieldlib = EB::fields();
         $customfields = array();
         if ($fields) {
             foreach ($fields as $field) {
                 if ($field->group->hasValues($post)) {
                     foreach ($field->fields as $customField) {
                         $eachField = $fieldlib->get($customField->type);
                         $customfields[] = $eachField->text($customField, $post);
                     }
                 }
             }
             $customfieldvalues = implode(' ', $customfields);
             $item->body = $item->body . ' ' . $customfieldvalues;
         }
     }
     // Add the author's meta data
     $item->metaauthor = !empty($item->created_by_alias) ? $item->created_by_alias : $item->author;
     $item->author = !empty($item->created_by_alias) ? $item->created_by_alias : $item->author;
     // If the post has an image, use it
     $image = $post->getImage('thumbnail', false, true);
     // If there's no image, try to scan the contents for an image to be used
     if (!$image && $post->isLegacy()) {
         $image = EB::string()->getImage($item->body);
     }
     // If we still can't locate any images, use the placeholder image
     if (!$image) {
         $image = EB::getPlaceholderImage();
     }
     $registry = new JRegistry();
     $registry->set('image', $image);
     $item->params = $registry;
     // Add the meta-data processing instructions.
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metakey');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metadesc');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metaauthor');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'author');
     // Add the type taxonomy data.
     $item->addTaxonomy('Type', 'EasyBlog');
     // Add the author taxonomy data.
     if (!empty($item->author) || !empty($item->created_by_alias)) {
         $item->addTaxonomy('Author', !empty($item->created_by_alias) ? $item->created_by_alias : $item->author);
     }
     // Add the category taxonomy data.
     $item->addTaxonomy('Category', $item->category, $item->cat_state, $item->cat_access);
     // Add the language taxonomy data.
     if (empty($item->language)) {
         $item->language = '*';
     }
     $item->addTaxonomy('Language', $item->language);
     // Get content extras.
     FinderIndexerHelper::getContentExtras($item);
     // For Joomla 3.0, the indexer is assigned to the property
     // Index the item.
     if (EB::isJoomla30()) {
         return $this->indexer->index($item);
     }
     return FinderIndexer::index($item);
//.........这里部分代码省略.........

 /**
  * Method to index an item. The item must be a FinderIndexerResult object.
  *
  * @param   FinderIndexerResult  $item    The item to index as an FinderIndexerResult object.
  * @param   string               $format  The item format
  *
  * @return  void
  *
  * @since   2.5
  * @throws  Exception on database error.
  */
 protected function index(FinderIndexerResult $item, $format = 'html')
 {
     // Check if the extension is enabled
     if (JComponentHelper::isEnabled($this->extension) == false) {
         return;
     }
     // Initialize the item parameters.
     $registry = new JRegistry();
     $registry->loadString($item->params);
     $item->params = JComponentHelper::getParams('com_jevents', true);
     $item->params->merge($registry);
     $registry = new JRegistry();
     $registry->loadString($item->metadata);
     $item->metadata = $registry;
     // Trigger the onContentPrepare event.
     $item->summary = FinderIndexerHelper::prepareContent($item->summary, $item->params);
     $item->body = FinderIndexerHelper::prepareContent($item->body, $item->params);
     // Build the necessary route and path information.
     $itemid = $this->params->get("target_itemid", 0);
     $item->url = "index.php?option=com_jevents&task=icalevent.detail&evid=" . $item->eventid . "&Itemid=" . $itemid;
     //$this->getURL($item->id, $this->extension, $this->layout);
     $item->route = "index.php?option=com_jevents&task=icalevent.detail&evid=" . $item->eventid . "&Itemid=" . $itemid;
     $item->path = FinderIndexerHelper::getContentPath($item->route);
     // title is already set
     //$item->title;
     // Events should only be published if the category is published.etc. - do this later
     //$item->state;
     // Add the type taxonomy data.
     $item->addTaxonomy('Type', 'Event');
     // Add the creator taxonomy data.
     if (!empty($item->creator) || !empty($item->created_by_alias)) {
         $item->addTaxonomy('Creator', !empty($item->created_by_alias) ? $item->created_by_alias : $item->creator);
     }
     // Add the category taxonomy data. - can we do multiple categories?
     $item->addTaxonomy('Category', $item->category, $item->cat_state, $item->cat_access);
     // Add the language taxonomy data.
     //$item->addTaxonomy('Language', $item->language);
     // Get jevents extras.
     FinderIndexerHelper::getContentExtras($item);
     // Index the item.
     if (JevJoomlaVersion::isCompatible("3.0.0")) {
         $this->indexer->index($item);
     } else {
         FinderIndexer::index($item);
     }
 }

 /**
  * Method to index an item. The item must be a FinderIndexerResult object.
  *
  * @param   FinderIndexerResult  $item    The item to index as an FinderIndexerResult object.
  * @param   string               $format  The item format
  *
  * @return  void
  *
  * @since   2.5
  * @throws  Exception on database error.
  */
 protected function index(FinderIndexerResult $item, $format = 'html')
 {
     // Check if the extension is enabled
     if (JComponentHelper::isEnabled($this->extension) == false) {
         return;
     }
     $access = 1;
     if (is_null($item->privacy)) {
         $privacy = FD::privacy($item->user_id);
         $privacyValue = $privacy->getValue('albums', 'view');
         $item->privacy = $privacyValue;
     }
     if ($item->privacy == SOCIAL_PRIVACY_PUBLIC) {
         $access = 1;
     } else {
         if ($item->privacy == SOCIAL_PRIVACY_MEMBER) {
             $access = 2;
         } else {
             // this is not public / member items. do not index this item
             return;
         }
     }
     // $sql->select('a.id, a.title, a.alias, a.introtext AS summary, a.fulltext AS body');
     // $sql->select('a.state, a.catid, a.created AS start_date, a.created_by');
     // $sql->select('a.created_by_alias, a.modified, a.modified_by, a.attribs AS params');
     // $sql->select('a.metakey, a.metadesc, a.metadata, a.language, a.access, a.version, a.ordering');
     // $sql->select('a.publish_up AS publish_start_date, a.publish_down AS publish_end_date');
     // $sql->select('c.title AS category, c.published AS cat_state, c.access AS cat_access');
     // album onwer
     $user = FD::user($item->user_id);
     $userAlias = $user->getAlias(false);
     $album = FD::table('Album');
     $album->load($item->id);
     $albumAlias = $album->getAlias();
     // Build the necessary route and path information.
     // we need to pass in raw url so that smart search will not create another duplicate item.
     // index.php?option=com_easysocial&view=albums&id=171:collection&layout=item&uid=84:jenny-siew&type=user
     $item->url = 'index.php?option=com_easysocial&view=albums&id=' . $albumAlias . '&layout=item&uid=' . $userAlias . '&type=' . $album->type;
     $item->route = $album->getPermalink();
     $item->route = $this->removeAdminSegment($item->route);
     $item->path = FinderIndexerHelper::getContentPath($item->route);
     $category = '';
     if ($album->core == SOCIAL_ALBUM_PROFILE_PHOTOS) {
         $category = 'avatar album';
     } else {
         if ($album->core == SOCIAL_ALBUM_PROFILE_COVERS) {
             $category = 'cover album';
         } else {
             if ($album->core == SOCIAL_ALBUM_STORY_ALBUM) {
                 $category = 'story album';
             } else {
                 $category = 'user album';
             }
         }
     }
     $item->access = $access;
     $item->alias = $albumAlias;
     $item->state = 1;
     $item->catid = $album->core;
     $item->start_date = $album->created;
     $item->created_by = $album->user_id;
     $item->created_by_alias = $userAlias;
     $item->modified = $album->assigned_date;
     $item->modified_by = $album->user_id;
     $item->params = '';
     $item->metakey = $category . ' ' . $album->title;
     $item->metadesc = $album->title . ' ' . $album->caption;
     $item->metadata = '';
     $item->publish_start_date = $album->assigned_date;
     $item->category = $category;
     $item->cat_state = 1;
     $item->cat_access = 0;
     $item->summary = empty($album->caption) ? $album->title : $album->caption;
     $item->body = $album->title . ' ' . $album->caption;
     // Add the meta-author.
     $item->metaauthor = $userAlias;
     $item->author = $userAlias;
     // add image param
     $registry = FD::registry();
     $registry->set('image', $album->getCover());
     $item->params = $registry;
     // Add the meta-data processing instructions.
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metakey');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metadesc');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'metaauthor');
     $item->addInstruction(FinderIndexer::META_CONTEXT, 'author');
     // Add the type taxonomy data.
     $item->addTaxonomy('Type', 'EasySocial.Albums');
     // Add the author taxonomy data.
//.........这里部分代码省略.........

 /**
  * Run the indexer.
  *
  * @return  void
  *
  * @since   2.5
  */
 private function index()
 {
     require_once JPATH_ADMINISTRATOR . '/components/com_finder/helpers/indexer/indexer.php';
     // Disable caching.
     $config = JFactory::getConfig();
     $config->set('caching', 0);
     $config->set('cache_handler', 'file');
     // Reset the indexer state.
     FinderIndexer::resetState();
     // Import the finder plugins.
     JPluginHelper::importPlugin('finder');
     // Starting Indexer.
     $this->out(JText::_('FINDER_CLI_STARTING_INDEXER'), true);
     // Trigger the onStartIndex event.
     JFactory::getApplication()->triggerEvent('onStartIndex');
     // Remove the script time limit.
     @set_time_limit(0);
     // Get the indexer state.
     $state = FinderIndexer::getState();
     // Setting up plugins.
     $this->out(JText::_('FINDER_CLI_SETTING_UP_PLUGINS'), true);
     // Trigger the onBeforeIndex event.
     JFactory::getApplication()->triggerEvent('onBeforeIndex');
     // Startup reporting.
     $this->out(JText::sprintf('FINDER_CLI_SETUP_ITEMS', $state->totalItems, round(microtime(true) - $this->time, 3)), true);
     // Get the number of batches.
     $t = (int) $state->totalItems;
     $c = (int) ceil($t / $state->batchSize);
     $c = $c === 0 ? 1 : $c;
     try {
         // Process the batches.
         for ($i = 0; $i < $c; $i++) {
             // Set the batch start time.
             $this->qtime = microtime(true);
             // Reset the batch offset.
             $state->batchOffset = 0;
             // Trigger the onBuildIndex event.
             JFactory::getApplication()->triggerEvent('onBuildIndex');
             // Batch reporting.
             $this->out(JText::sprintf('FINDER_CLI_BATCH_COMPLETE', $i + 1, round(microtime(true) - $this->qtime, 3)), true);
         }
     } catch (Exception $e) {
         // Display the error
         $this->out($e->getMessage(), true);
         // Reset the indexer state.
         FinderIndexer::resetState();
         // Close the app
         $this->close($e->getCode());
     }
     // Reset the indexer state.
     FinderIndexer::resetState();
 }