PHP eZContentObjectTreeNode::unhideSubTree方法代码示例

    function execute( $xmlNode )
    {
        $action = $xmlNode->getAttribute( 'action' );
        $xmlNodeID = $xmlNode->getAttribute( 'nodeID' );

        $nodeID = $this->getReferenceID( $xmlNodeID );
        if ( !$nodeID )
        {
            $this->writeMessage( "\tInvalid node $nodeID does not exist.", 'warning' );
            return false;
        }

        if ( !$action )
        {
            $action = 'toogle';
        }
        $node = eZContentObjectTreeNode::fetch( $nodeID );
        if ( !$node )
        {
            $this->writeMessage( "\tNo node defined.", 'error' );
            return false;
        }

        switch ( $action )
        {
            case 'unhide':
            {
                if ( $node->attribute( 'is_hidden' ) )
                {
                    eZContentObjectTreeNode::unhideSubTree( $node );
                    $this->writeMessage( "\tNode " . $node->attribute( 'name' ) . " has be unhidden.", 'error' );
                }
            } break;
            case 'hide':
            {
                if ( !$node->attribute( 'is_hidden' ) )
                {
                    eZContentObjectTreeNode::hideSubTree( $node );
                    $this->writeMessage( "\tNode " . $node->attribute( 'name' ) . " has be hidden.", 'error' );
                }
            } break;
            case 'toogle':
            {
                if ( $node->attribute( 'is_hidden' ) )
                {
                    eZContentObjectTreeNode::unhideSubTree( $node );
                    $this->writeMessage( "\tNode " . $node->attribute( 'name' ) . " has be unhidden.", 'error' );
                }
                else
                {
                    eZContentObjectTreeNode::hideSubTree( $node );
                    $this->writeMessage( "\tNode " . $node->attribute( 'name' ) . " has be hidden.", 'error' );
                }
            } break;
        }
    }

 function runOperation(&$node)
 {
     if (!$node->canHide()) {
         return false;
     }
     if ($this->hidden) {
         eZContentObjectTreeNode::hideSubTree($node);
     } else {
         eZContentObjectTreeNode::unhideSubTree($node);
     }
     // We have no result value, so assume the operation worked
     return true;
 }

 /**
  * Changes an contentobject's status
  *
  * @param int $nodeID
  *
  * @return array An array with operation status, always true
  */
 public static function changeHideStatus($nodeID)
 {
     $action = 'hide';
     $curNode = eZContentObjectTreeNode::fetch($nodeID);
     if (is_object($curNode)) {
         if ($curNode->attribute('is_hidden')) {
             eZContentObjectTreeNode::unhideSubTree($curNode);
             $action = 'show';
         } else {
             eZContentObjectTreeNode::hideSubTree($curNode);
         }
     }
     //call appropriate method from search engine
     eZSearch::updateNodeVisibility($nodeID, $action);
     return array('status' => true);
 }

//.........这里部分代码省略.........
                        else if ( isset( $operationResult['result'] ) )
                        {
                            $result = $operationResult['result'];
                            $resultContent = false;
                            if ( is_array( $result ) )
                            {
                                if ( isset( $result['content'] ) )
                                {
                                    $resultContent = $result['content'];
                                }
                                if ( isset( $result['path'] ) )
                                {
                                    $Result['path'] = $result['path'];
                                }
                            }
                            else
                            {
                                $resultContent = $result;
                            }
                            // Temporary fix to make approval workflow work with edit.
                            if ( strpos( $resultContent, 'Deffered to cron' ) === 0 )
                            {
                                $Result = null;
                            }
                            else
                            {
                                $Result['content'] = $resultContent;
                            }
                        }
                    }break;
                    case eZModuleOperationInfo::STATUS_CANCELLED:
                    {
                        $Result = array();
                        $Result['content'] = "Content publish cancelled<br/>";
                    }
                }

                /* If we already have a correct module result
                 * we don't need to continue module execution.
                 */
                if ( is_array( $Result ) )
                    return eZModule::HOOK_STATUS_CANCEL_RUN;
            }

            // update content object attributes array by refetching them from database
            $object = eZContentObject::fetch( $object->attribute( 'id' ) );
            $contentObjectAttributes = $object->attribute( 'contentobject_attributes' );

            // set chosen hidden/invisible attributes for object nodes
            $http          = eZHTTPTool::instance();
            $assignedNodes = $object->assignedNodes( true );
            foreach ( $assignedNodes as $node )
            {
                $nodeID               = $node->attribute( 'node_id' );
                $parentNodeID         = $node->attribute( 'parent_node_id' );
                $updateNodeVisibility =  false;
                $postVarName          = "FutureNodeHiddenState_$parentNodeID";

                if ( !$http->hasPostVariable( $postVarName ) )
                    $updateNodeVisibility = true;
                else
                {
                    $futureNodeHiddenState = $http->postVariable( $postVarName );
                    $db = eZDB::instance();
                    $db->begin();
                    if ( $futureNodeHiddenState == 'hidden' )
                        eZContentObjectTreeNode::hideSubTree( $node );
                    else if ( $futureNodeHiddenState == 'visible' )
                        eZContentObjectTreeNode::unhideSubTree( $node );
                    else if ( $futureNodeHiddenState == 'unchanged' )
                        $updateNodeVisibility = true;
                    else
                        eZDebug::writeWarning( "Unknown value for the future node hidden state: '$futureNodeHiddenState'" );
                    $db->commit();
                }

                if ( $updateNodeVisibility )
                {
                    // this might be redundant
                    $db = eZDB::instance();
                    $db->begin();
                    $parentNode = eZContentObjectTreeNode::fetch( $parentNodeID );
                    eZContentObjectTreeNode::updateNodeVisibility( $node, $parentNode, /* $recursive = */ false );
                    $db->commit();
                    unset( $node, $parentNode );
                }
            }
            unset( $assignedNodes );

            $object = eZContentObject::fetch( $object->attribute( 'id' ) );

            $newObjectName = $object->name();

            $http = eZHTTPTool::instance();

            computeRedirect( $module, $object, $version, $EditLanguage );
            // we have set redirection URI for module so we don't need to continue module execution
            return eZModule::HOOK_STATUS_CANCEL_RUN;
        }
    }

    public function execute( $process, $event )
    {
        $parameters = $process->attribute( 'parameter_list' );
        $object = eZContentObject::fetch( $parameters['object_id'] );
        $attribute = false;

        $dataMap = $object->attribute( 'data_map' );
        foreach ( $dataMap as $attr )
        {
            $dataType = $attr->attribute( 'data_type_string' );
            if ( $dataType == 'ezfeatureselect' )
            {
                $attribute = $attr;
                continue;
            }
        }

        // if object does not have a featureselect attribute.
        if ( $attribute == false )
        {
            return eZWorkflowType::STATUS_ACCEPTED;
        }

        // if we have not the first version published, we only need to enable/disable features
        if ( $object->attribute( 'modified' ) != $object->attribute( 'published' ) )
        {
            $attributeContent = $attribute->attribute( 'content' );
            $installedFeatureList = $attributeContent['installed_feature_list'];
            $availibleFeatureList = $attributeContent['availible_feature_list'];

            $mainNodeID = $object->attribute( 'main_node_id' );

            foreach( $availibleFeatureList as $feature => $featureName )
            {
                $featureObject = eZContentObject::fetchByRemoteID( $mainNodeID . '_' . $feature );
                if( !$featureObject )
                {
                    eZDebug::writeError( "Cannot find feature object", "eZXMLPublisherType::execute" );
                    continue;
                }
                $featureNode = $featureObject->attribute( 'main_node' );
                if( !$featureNode )
                {
                    eZDebug::writeError( "Cannot find feature node", "eZXMLPublisherType::execute" );
                    continue;
                }
                if ( in_array( $feature, $installedFeatureList ) )
                {
                    if ( $featureNode->attribute( 'is_hidden' ) )
                    {
                        eZContentObjectTreeNode::unhideSubTree( $featureNode );
                    }
                    $featureObject = $featureNode->attribute( 'object' );
                    $list          = $featureObject->reverseRelatedObjectList( false, 0, false,
                                                                               array( 'AllRelations' => eZContentObject::RELATION_ATTRIBUTE, 'IgnoreVisibility' => true )
                                                                             );
                    if ( is_array( $list ) )
                    {
                        foreach ( $list as $reverseRelatedContentObject )
                        {
                            $reverseRelatedMainNode = $reverseRelatedContentObject->attribute( 'main_node' );
                            eZContentObjectTreeNode::unhideSubTree( $reverseRelatedMainNode );
                        }
                    }
                }
                elseif ( !in_array( $feature, $installedFeatureList ) && !$featureNode->attribute( 'is_hidden' ) )
                {
                    if ( !$featureNode->attribute( 'is_hidden' ) )
                    {
                        eZContentObjectTreeNode::hideSubTree( $featureNode );
                    }
                    $featureObject = $featureNode->attribute( 'object' );
                    $list          = $featureObject->reverseRelatedObjectList( false, 0, false,
                                                                               array( 'AllRelations' => eZContentObject::RELATION_ATTRIBUTE, 'IgnoreVisibility' => true )
                                                                             );
                    if ( is_array( $list ) )
                    {
                        foreach ( $list as $reverseRelatedContentObject )
                        {
                            $reverseRelatedMainNode = $reverseRelatedContentObject->attribute( 'main_node' );
                            eZContentObjectTreeNode::hideSubTree( $reverseRelatedMainNode );
                        }
                    }
                }
            }
        }

        // defer to cron, this is safer because we might do a lot of things here
        include_once( 'lib/ezutils/classes/ezsys.php' );
        if ( eZSys::isShellExecution() == false )
        {
            return eZWorkflowType::STATUS_DEFERRED_TO_CRON_REPEAT;
        }

        // if we have the first version published, we need to set up the related things.
        if ( $object->attribute( 'modified' ) == $object->attribute( 'published' ) )
        {
            $classAttribute = $attribute->attribute( 'contentclass_attribute' );
            $templateName = $classAttribute->attribute( 'data_text1' );

//.........这里部分代码省略.........

 /**
  * Depending on the new parent node visibility, recompute "is_invisible" attribute for the given node and
  * its children. (used after content/move or content/copy)
  *
  * @param eZContentObjectTreeNode $node
  * @param eZContentObjectTreeNode $parentNode
  * @param bool $recursive
  */
 static function updateNodeVisibility($node, $parentNode, $recursive = true)
 {
     if (!$node) {
         eZDebug::writeWarning('No such node to update visibility for.');
         return;
     }
     if (!$parentNode) {
         eZDebug::writeWarning('No parent node found when updating node visibility');
         return;
     }
     if ($node->attribute('is_hidden') == 0 && $parentNode->attribute('is_invisible') != $node->attribute('is_invisible')) {
         $parentNodeIsVisible = $parentNode->attribute('is_invisible');
         $nodeID = $node->attribute('node_id');
         $db = eZDB::instance();
         $db->begin();
         $db->query("UPDATE ezcontentobject_tree SET is_invisible={$parentNodeIsVisible} WHERE node_id={$nodeID}");
         if ($recursive) {
             // update visibility for children of the node
             if ($parentNodeIsVisible) {
                 eZContentObjectTreeNode::hideSubTree($node, $modifyRootNode = false);
             } else {
                 eZContentObjectTreeNode::unhideSubTree($node, $modifyRootNode = false);
             }
         }
         $db->commit();
     }
 }

 function execute($process, $event)
 {
     // Get some information about the object being passed
     $parameters = $process->attribute('parameter_list');
     $object = eZContentObject::fetch($parameters['object_id']);
     // Because this is also run by the cronjob, check to make sure the object hasn't been deleted
     if (!$object) {
         eZDebugSetting::writeError('workflow-hideuntildate', 'The object with ID ' . $parameters['object_id'] . ' does not exist.', 'eZApproveType::execute() object is unavailable');
         return eZWorkflowType::STATUS_WORKFLOW_CANCELLED;
     }
     // if the current version of an object is not the version the workflow pertains to, cancel the workflow
     $currentVersion = $object->attribute('current_version');
     $version = $parameters['version'];
     if ($currentVersion != $version) {
         return eZWorkflowType::STATUS_WORKFLOW_CANCELLED;
     }
     // Get the data map for this object
     $objectAttributes = $object->attribute('data_map');
     // Get the user configuration with class and attribute mapping and the boolean modify publish date setting
     $workflowSettings = $this->getWorkflowSettings($event);
     foreach ($objectAttributes as $objectAttribute) {
         if (in_array($objectAttribute->attribute('contentclassattribute_id'), $workflowSettings['classattribute_map'])) {
             // Make sure this is of a date or datetime attribute
             if (in_array($objectAttribute->attribute('data_type_string'), array('ezdate', 'ezdatetime'))) {
                 // If the publish date is in the future, hide the node
                 if (time() < $objectAttribute->toString()) {
                     // Set a time for when this workflow should be tested again via the cronjob
                     // Store a description to be displayed in the Setup > Workflow processes list
                     // This must also be accompanied by overriding the workflow/processlist.tpl template
                     $parameters = array_merge($parameters, array('event_description' => 'Publishing of object delayed until ' . $objectAttribute->attribute('content')->toString(true)));
                     $process->setParameters($parameters);
                     $process->store();
                     // Hide the object's nodes
                     $nodes = $object->attribute('assigned_nodes');
                     foreach ($nodes as $node) {
                         if (!$node->attribute('is_hidden')) {
                             eZContentObjectTreeNode::hideSubTree($node);
                         }
                     }
                     return eZWorkflowType::STATUS_DEFERRED_TO_CRON_REPEAT;
                 } elseif ($objectAttribute->hasContent()) {
                     if ($workflowSettings['modify_publish_date']) {
                         $object->setAttribute('published', $objectAttribute->toString());
                         $object->store();
                     }
                     $nodes = $object->attribute('assigned_nodes');
                     foreach ($nodes as $node) {
                         eZContentObjectTreeNode::unhideSubTree($node);
                         eZContentCacheManager::clearContentCache($parameters['object_id']);
                         eZContentCacheManager::clearObjectViewCache($parameters['object_id']);
                     }
                     return eZWorkflowType::STATUS_ACCEPTED;
                 }
             } else {
                 // Attribute that matched was not a valid date or datetime attribute, so ignore
                 return eZWorkflowType::STATUS_ACCEPTED;
             }
         }
     }
     // No attributes matched the workflow configured by the user
     return eZWorkflowType::STATUS_ACCEPTED;
 }

        break;
    
    foreach ( $results as $result )
    {
        if ( ($i+1)%100 == 0 )
            $cli->notice( "$i nodes have been treated." );

        $node = eZContentObjectTreeNode::fetch($result['node_id']);
        
        if ( !($node instanceof eZContentObjectTreeNode) )
        {
            $cli->warning("{$result['node_id']} is not a valid node.");
            $offset+=1;
            continue;
        }
        else
        {
            $i++;
        }

        eZContentObjectTreeNode::unhideSubTree( $node );
        eZContentObject::clearCache();
    }

    // We don't need to increment the offset as is_hidden of unhidden nodes will change to 0 !!
    //$offset+= $limit;
}

$script->shutdown (0, "Treatment completed successfully; $i nodes treated." );

 /**
  * Change node`s visibility
  *
  * @private
  * @param eZContentObject $object
  * @param bool $visibility
  * @return void
  */
 private function updateVisibility($object, $visibility = true)
 {
     $action = $visibility ? 'show' : 'hide';
     $nodeAssigments = eZPersistentObject::fetchObjectList(eZNodeAssignment::definition(), null, array('contentobject_id' => $object->attribute('id'), 'contentobject_version' => $object->attribute('current_version')), null, null, true);
     foreach ($nodeAssigments as $nodeAssigment) {
         $node = $nodeAssigment->attribute('node');
         if ($node instanceof eZContentObjectTreeNode === false) {
             continue;
         }
         if ((bool) (!$node->attribute('is_hidden')) === (bool) $visibility) {
             continue;
         }
         if ($action == 'show') {
             eZContentObjectTreeNode::unhideSubTree($node);
         } else {
             eZContentObjectTreeNode::hideSubTree($node);
         }
         eZSearch::updateNodeVisibility($node->attribute('node_id'), $action);
     }
 }