/**
     * Test that saving a content class in DEFINED version status
     * correctly manipulate associated class groups
     *
     * @link http://issues.ez.no/16197
     */
    public function testContentClassStillInGroupAfterEdition()
    {
        $class = eZContentClass::fetch( $this->class->id );
        // This is logic contained in kernel/class/edit.php
        foreach ( eZContentClassClassGroup::fetchGroupList( $class->attribute( 'id' ),
                                                            eZContentClass::VERSION_STATUS_DEFINED )  as $classGroup )
        {
            eZContentClassClassGroup::create( $class->attribute( 'id' ),
                                              eZContentClass::VERSION_STATUS_TEMPORARY,
                                              $classGroup->attribute( 'group_id' ),
                                              $classGroup->attribute( 'group_name' ) )
                ->store();
        }

        $attributes = $class->fetchAttributes();
        $class->setAttribute( 'version', eZContentClass::VERSION_STATUS_TEMPORARY );
        $class->NameList->setHasDirtyData();

        foreach ( $attributes as $attribute )
        {
            $attribute->setAttribute( 'version', eZContentClass::VERSION_STATUS_TEMPORARY );
            if ( $dataType = $attribute->dataType() )
                $dataType->initializeClassAttribute( $attribute );
        }

        $class->store( $attributes );
        $db = eZDB::instance();
        $db->begin();
        $class->storeVersioned( $attributes, eZContentClass::VERSION_STATUS_DEFINED );
        $db->commit();

        $this->assertTrue( eZContentClassClassGroup::classInGroup( $class->attribute( 'id' ),
                                                                   eZContentClass::VERSION_STATUS_DEFINED,
                                                                   1 ) );
    }

 static function remove($classID)
 {
     $contentClass = eZContentClass::fetch($classID);
     if ($contentClass == null or !$contentClass->isRemovable()) {
         return false;
     }
     // Remove all objects
     $contentObjects = eZContentObject::fetchSameClassList($classID);
     foreach ($contentObjects as $contentObject) {
         eZContentObjectOperations::remove($contentObject->attribute('id'));
     }
     if (count($contentObjects) == 0) {
         eZContentObject::expireAllViewCache();
     }
     eZContentClassClassGroup::removeClassMembers($classID, 0);
     eZContentClassClassGroup::removeClassMembers($classID, 1);
     // Fetch real version and remove it
     $contentClass->remove(true);
     // Fetch temp version and remove it
     $tempDeleteClass = eZContentClass::fetch($classID, true, 1);
     if ($tempDeleteClass != null) {
         $tempDeleteClass->remove(true, 1);
     }
     return true;
 }

    static function removeGroup( $classID, $classVersion, $selectedGroup )
    {
        $class = eZContentClass::fetch( $classID, true, eZContentClass::VERSION_STATUS_DEFINED );
        if ( !$class )
            return false;
        $groups = $class->attribute( 'ingroup_list' );
        foreach ( array_keys( $groups ) as $key )
        {
            if ( in_array( $groups[$key]->attribute( 'group_id' ), $selectedGroup ) )
            {
                unset( $groups[$key] );
            }
        }

        if ( count( $groups ) == 0 )
        {
            return false;
        }
        else
        {
            foreach(  $selectedGroup as $group_id )
            {
                eZContentClassClassGroup::removeGroup( $classID, $classVersion, $group_id );
            }
        }
        return true;
    }

 /**
  * Initialize ezpClass object
  *
  * @param string $name
  * @param string $identifier
  * @param string $contentObjectName
  * @param int $creatorID
  * @param string $language
  * @param int $groupID
  * @param string $groupName
  */
 public function __construct($name = 'Test class', $identifier = 'test_class', $contentObjectName = '<test_attribute>', $creatorID = 14, $language = 'eng-GB', $groupID = 1, $groupName = 'Content')
 {
     if (eZContentLanguage::fetchByLocale($language) === false) {
         $topPriorityLanguage = eZContentLanguage::topPriorityLanguage();
         if ($topPriorityLanguage) {
             $language = $topPriorityLanguage->attribute('locale');
         }
     }
     $this->language = $language;
     $this->class = eZContentClass::create($creatorID, array(), $this->language);
     $this->class->setName($name, $this->language);
     $this->class->setAttribute('contentobject_name', $contentObjectName);
     $this->class->setAttribute('identifier', $identifier);
     $this->class->store();
     $languageID = eZContentLanguage::idByLocale($this->language);
     $this->class->setAlwaysAvailableLanguageID($languageID);
     $this->classGroup = eZContentClassClassGroup::create($this->id, $this->version, $groupID, $groupName);
     $this->classGroup->store();
 }

 public static function getGroupedClasses()
 {
     /** @var ContainerInterface $container */
     $container = ezpKernel::instance()->getServiceContainer();
     $params = $container->getParameter('kaliop_class_select');
     $classInclude = $classExclude = $groupInclude = $groupExclude = false;
     $cgparams = array();
     if (!empty($params['classes']['include'])) {
         $classInclude = true;
         $cgparams = $params['classes']['include'];
     } elseif (!empty($params['classes']['exclude'])) {
         $classExclude = true;
         $cgparams = $params['classes']['exclude'];
     } elseif (!empty($params['class_groups']['include'])) {
         $groupInclude = true;
         $cgparams = $params['class_groups']['include'];
     } elseif (!empty($params['class_groups']['exclude'])) {
         $groupExclude = true;
         $cgparams = $params['class_groups']['exclude'];
     }
     $groups = eZContentClassGroup::fetchList(false, true);
     $return = array();
     $count = 0;
     foreach ($groups as $group) {
         if ($groupInclude and (in_array($group->attribute('id'), $cgparams) or in_array($group->attribute('name'), $cgparams)) or !$groupInclude and $groupExclude and (!in_array($group->attribute('id'), $cgparams) or !in_array($group->attribute('name'), $cgparams)) or !$groupInclude and !$groupExclude) {
             $array = array('name' => $group->attribute('name'), 'classes' => array());
             $count++;
             $classes = eZContentClassClassGroup::fetchClassList(0, $group->attribute('id'), true);
             foreach ($classes as $class) {
                 if ($classInclude and (in_array($class->attribute('id'), $cgparams) or in_array($class->attribute('identifier'), $cgparams)) or !$classInclude and $classExclude and (!in_array($class->attribute('id'), $cgparams) or !in_array($class->attribute('identifier'), $cgparams)) or !$classInclude and !$classExclude) {
                     $array['classes'][] = array('identifier' => $class->attribute('identifier'), 'name' => $class->attribute('name'));
                     $count++;
                 }
             }
             $return[] = $array;
         }
     }
     return array('result' => array('groups' => $return, 'total' => $count));
 }

 /**
  * Stores the current class as a modified version, updates the contentobject_name
  * attribute and recreates the class group entries.
  *
  * @note It will remove classes in the previous and specified version before storing.
  *
  * @param array $attributes array of attributes
  * @param int $version version status
  * @since Version 4.3
  */
 public function storeVersioned($attributes, $version)
 {
     $previousVersion = $this->attribute('version');
     $db = eZDB::instance();
     $db->begin();
     // Before removing anything from the attributes, load attribute information
     // which might otherwise not accessible when recreating them below.
     // See issue #18164
     foreach ($attributes as $attribute) {
         $attribute->content();
     }
     $this->removeAttributes(false, $version);
     $this->removeAttributes(false, $previousVersion);
     $this->remove(false);
     $this->setVersion($version, $attributes);
     $this->setAttribute("modifier_id", eZUser::currentUser()->attribute("contentobject_id"));
     $this->setAttribute("modified", time());
     $this->adjustAttributePlacements($attributes);
     foreach ($attributes as $attribute) {
         $attribute->storeVersioned($version);
     }
     // Set contentobject_name to something sensible if it is missing
     if (count($attributes) > 0 && trim($this->attribute('contentobject_name')) == '') {
         $this->setAttribute('contentobject_name', '<' . $attributes[0]->attribute('identifier') . '>');
     }
     // Recreate class member entries
     eZContentClassClassGroup::removeClassMembers($this->ID, $version);
     foreach (eZContentClassClassGroup::fetchGroupList($this->ID, $previousVersion) as $classgroup) {
         $classgroup->setAttribute('contentclass_version', $version);
         $classgroup->store();
     }
     eZContentClassClassGroup::removeClassMembers($this->ID, $previousVersion);
     eZExpiryHandler::registerShutdownFunction();
     $handler = eZExpiryHandler::instance();
     $time = time();
     $handler->setTimestamp('user-class-cache', $time);
     $handler->setTimestamp('class-identifier-cache', $time);
     $handler->setTimestamp('sort-key-cache', $time);
     $handler->store();
     eZContentCacheManager::clearAllContentCache();
     $this->setAttribute('serialized_name_list', $this->NameList->serializeNames());
     $this->setAttribute('serialized_description_list', $this->DescriptionList->serializeNames());
     eZPersistentObject::store();
     $this->NameList->store($this);
     $db->commit();
 }

 function appendClass($class, $version = false)
 {
     if ($class instanceof eZContentClass) {
         $classID = $class->attribute('id');
         $version = $class->attribute('version');
     } else {
         $classID = $class;
     }
     $classGroupLink = eZContentClassClassGroup::create($classID, $version, $this->attribute('id'), $this->attribute('name'));
     $classGroupLink->store();
     return $classGroupLink;
 }

                $deletedClassName .= " '" . $className . "'";
                $deleteClassIDList[] = $classID;
                $groupClassesInfo[] = array('class_name' => $className, 'object_count' => $classObject->objectCount());
            }
        }
        if ($deletedClassName == '') {
            $deletedClassName = ezpI18n::tr('kernel/class', '(no classes)');
        }
        $deleteResult[] = array('groupName' => $GroupName, 'deletedClassName' => $deletedClassName);
        $groupsInfo[] = array('group_name' => $GroupName, 'class_list' => $groupClassesInfo);
    }
}
if ($http->hasPostVariable("ConfirmButton")) {
    foreach ($deleteIDArray as $deleteID) {
        eZContentClassGroup::removeSelected($deleteID);
        eZContentClassClassGroup::removeGroupMembers($deleteID);
        foreach ($deleteClassIDList as $deleteClassID) {
            $deleteClass = eZContentClass::fetch($deleteClassID);
            if ($deleteClass) {
                $deleteClass->remove(true);
            }
            $deleteClass = eZContentClass::fetch($deleteClassID, true, eZContentClass::VERSION_STATUS_TEMPORARY);
            if ($deleteClass) {
                $deleteClass->remove(true);
            }
        }
    }
    $Module->redirectTo('/class/grouplist/');
}
if ($http->hasPostVariable("CancelButton")) {
    $Module->redirectTo('/class/grouplist/');

if (isset($Params["GroupID"])) {
    $GroupID = $Params["GroupID"];
}
$class = eZContentClass::fetch($ClassID);
$ClassName = $class->attribute('name');
$classObjects = eZContentObject::fetchSameClassList($ClassID);
$ClassObjectsCount = count($classObjects);
if ($ClassObjectsCount == 0) {
    $ClassObjectsCount .= " object";
} else {
    $ClassObjectsCount .= " objects";
}
$http = eZHTTPTool::instance();
if ($http->hasPostVariable("ConfirmButton")) {
    $class->remove(true);
    eZContentClassClassGroup::removeClassMembers($ClassID, 0);
    ezpEvent::getInstance()->notify('content/class/cache', array($ClassID));
    $Module->redirectTo('/class/classlist/' . $GroupID);
}
if ($http->hasPostVariable("CancelButton")) {
    $Module->redirectTo('/class/classlist/' . $GroupID);
}
$Module->setTitle("Deletion of class " . $ClassID);
$tpl = eZTemplate::factory();
$tpl->setVariable("module", $Module);
$tpl->setVariable("GroupID", $GroupID);
$tpl->setVariable("ClassID", $ClassID);
$tpl->setVariable("ClassName", $ClassName);
$tpl->setVariable("ClassObjectsCount", $ClassObjectsCount);
$Result = array();
$Result['content'] = $tpl->fetch("design:class/delete.tpl");

$Module->setTitle( ezpI18n::tr( 'kernel/class', 'Class list of group' ) . ' ' . $GroupID );
$tpl = eZTemplate::factory();

$user = eZUser::currentUser();
foreach( $TemplateData as $tpldata )
{
    $tplname = $tpldata["name"];

    $groupInfo =  eZContentClassGroup::fetch( $GroupID );

    if( !$groupInfo )
    {
       return $Module->handleError( eZError::KERNEL_NOT_AVAILABLE, 'kernel' );
    }

    $list = eZContentClassClassGroup::fetchClassList( 0, $GroupID, $asObject = true );
    $groupModifier = eZContentObject::fetch( $groupInfo->attribute( 'modifier_id') );
    $tpl->setVariable( $tplname, $list );
    $tpl->setVariable( "class_count", count( $list ) );
    $tpl->setVariable( "GroupID", $GroupID );
    $tpl->setVariable( "group", $groupInfo );
    $tpl->setVariable( "group_modifier", $groupModifier );
}

$group = eZContentClassGroup::fetch( $GroupID );
$groupName = $group->attribute( 'name' );


$tpl->setVariable( "module", $Module );

$Result = array();

 static function classInGroup($contentclassID, $contentclassVersion, $groupID)
 {
     $rows = eZPersistentObject::fetchObjectList(eZContentClassClassGroup::definition(), null, array('group_id' => $groupID, "contentclass_id" => $contentclassID, "contentclass_version" => $contentclassVersion), null, null, false);
     return count($rows) > 0;
 }

 protected function syncGroups()
 {
     $remote = $this->getRemote();
     if ($remote === null) {
         throw new Exception("Classe remota non trovata");
     }
     $this->syncAllGroups($remote);
     $locale = $this->currentClass;
     /** @var eZContentClassClassGroup[] $localGroups */
     $localGroups = $locale->fetchGroupList();
     //$localGroupsNames = array();
     //$remoteGroupsNames = array();
     foreach ($localGroups as $group) {
         /** @var eZContentClassGroup $classGroup */
         $classGroup = eZContentClassGroup::fetchByName($group->attribute('group_name'));
         if ($classGroup) {
             eZContentClassClassGroup::removeGroup($this->currentClass->attribute('id'), $this->currentClass->attribute('version'), $classGroup->attribute('id'));
         }
     }
     foreach ($remote->InGroups as $group) {
         /** @var eZContentClassGroup $classGroup */
         $classGroup = eZContentClassGroup::fetchByName($group->GroupName);
         if ($classGroup) {
             $ingroup = eZContentClassClassGroup::create($this->currentClass->attribute('id'), $this->currentClass->attribute('version'), $classGroup->attribute('id'), $classGroup->attribute('name'));
             $ingroup->store();
         }
     }
     //$groups = $this->currentClass->attribute( 'ingroup_list' );
     //if ( count( $groups ) == 0 )
     //{
     //    //@todo
     //}
 }

 private function createClass($displayName, $classIdentifier, $groupIdentifier, $groupId)
 {
     $adminUserObject = eZUser::fetchByName("admin");
     $adminUserObject->loginCurrent();
     $adminUserId = $adminUserObject->attribute('contentobject_id');
     $language = eZContentLanguage::topPriorityLanguage();
     $editLanguage = $language->attribute('locale');
     $class = eZContentClass::create($adminUserId, array(), $editLanguage);
     // this is the display name, ez automatically creates the content-class-identifier from it
     $class->setName($displayName, $editLanguage);
     $class->setAttribute("identifier", $classIdentifier);
     // default naming for objects - content classes should update this value once they have attributes added
     $class->setAttribute('contentobject_name', 'eep-created-content-class');
     $class->store();
     $editLanguageID = eZContentLanguage::idByLocale($editLanguage);
     $class->setAlwaysAvailableLanguageID($editLanguageID);
     $ClassID = $class->attribute('id');
     $ClassVersion = $class->attribute('version');
     $ingroup = eZContentClassClassGroup::create($ClassID, $ClassVersion, $groupId, $groupIdentifier);
     $ingroup->store();
     // clean up the content class status
     $class->storeDefined(array());
     $adminUserObject->logoutCurrent();
 }

 static function fetchUserGroupClassNames()
 {
     // Get names of user classes
     $userClassNames = array();
     $userClasses = eZUser::fetchUserClassList(false, array('identifier'));
     foreach ($userClasses as $class) {
         $userClassNames[] = $class['identifier'];
     }
     // Get names of all allowed content-classes for the Users subtree
     $contentIni = eZINI::instance("content.ini");
     $userGroupClassNames = array();
     if ($contentIni->hasVariable('ClassGroupIDs', 'Users') and is_numeric($usersClassGroupID = $contentIni->variable('ClassGroupIDs', 'Users')) and count($usersClassList = eZContentClassClassGroup::fetchClassList(eZContentClass::VERSION_STATUS_DEFINED, $usersClassGroupID)) > 0) {
         foreach ($usersClassList as $userClass) {
             $userGroupClassNames[] = $userClass->attribute('identifier');
         }
     }
     // Get names of user-group classes
     $groupClassNames = array_diff($userGroupClassNames, $userClassNames);
     return $groupClassNames;
 }

}
// Find out the group where class is created or edited from.
if ($http->hasSessionVariable('FromGroupID')) {
    $fromGroupID = $http->sessionVariable('FromGroupID');
} else {
    $fromGroupID = false;
}
$ClassID = $class->attribute('id');
$ClassVersion = $class->attribute('version');
$validation = array('processed' => false, 'groups' => array(), 'attributes' => array(), 'class_errors' => array());
$unvalidatedAttributes = array();
if ($http->hasPostVariable('DiscardButton')) {
    $http->removeSessionVariable('ClassCanStoreTicket');
    $class->setVersion(eZContentClass::VERSION_STATUS_TEMPORARY);
    $class->remove(true, eZContentClass::VERSION_STATUS_TEMPORARY);
    eZContentClassClassGroup::removeClassMembers($ClassID, eZContentClass::VERSION_STATUS_TEMPORARY);
    if ($fromGroupID === false) {
        $Module->redirectToView('grouplist');
    } else {
        $Module->redirectTo($Module->functionURI('classlist') . '/' . $fromGroupID . '/');
    }
    return;
}
if ($http->hasPostVariable('AddGroupButton') && $http->hasPostVariable('ContentClass_group')) {
    eZClassFunctions::addGroup($ClassID, $ClassVersion, $http->postVariable('ContentClass_group'));
    $lastChangedID = 'group';
}
if ($http->hasPostVariable('RemoveGroupButton') && $http->hasPostVariable('group_id_checked')) {
    if (!eZClassFunctions::removeGroup($ClassID, $ClassVersion, $http->postVariable('group_id_checked'))) {
        $validation['groups'][] = array('text' => ezpI18n::tr('kernel/class', 'You have to have at least one group that the class belongs to!'));
        $validation['processed'] = true;

if ($http->hasPostVariable("DiscardButton")) {
    $Module->redirectTo($Module->functionURI("grouplist"));
    return;
}
if ($http->hasPostVariable("StoreButton")) {
    if ($http->hasPostVariable("Group_name")) {
        $name = $http->postVariable("Group_name");
    }
    $classgroup->setAttribute("name", $name);
    // Set new modification date
    $date_time = time();
    $classgroup->setAttribute("modified", $date_time);
    $user = eZUser::currentUser();
    $user_id = $user->attribute("contentobject_id");
    $classgroup->setAttribute("modifier_id", $user_id);
    $classgroup->store();
    eZContentClassClassGroup::update(null, $GroupID, $name);
    $Module->redirectToView('classlist', array($classgroup->attribute('id')));
    return;
}
$Module->setTitle("Edit class group " . $classgroup->attribute("name"));
// Template handling
$tpl = eZTemplate::factory();
$res = eZTemplateDesignResource::instance();
$res->setKeys(array(array("classgroup", $classgroup->attribute("id"))));
$tpl->setVariable("http", $http);
$tpl->setVariable("module", $Module);
$tpl->setVariable("classgroup", $classgroup);
$Result = array();
$Result['content'] = $tpl->fetch("design:class/groupedit.tpl");
$Result['path'] = array(array('url' => '/class/grouplist/', 'text' => ezpI18n::tr('kernel/class', 'Class groups')), array('url' => false, 'text' => $classgroup->attribute('name')));

 private function renamegroup($groupIdentifier, $newGroupIdentifier)
 {
     $groupObject = eZContentClassGroup::fetchByName($groupIdentifier, true);
     if ($groupObject == null) {
         echo "Invalid group identifier\n";
         return;
     }
     $date_time = time();
     $groupObject->setAttribute("modified", $date_time);
     $groupObject->setAttribute("modifier_id", false);
     $groupObject->setAttribute("name", $newGroupIdentifier);
     $groupObject->store();
     eZContentClassClassGroup::update(null, $groupObject->ID, $newGroupIdentifier);
     echo "Successfully renamed group {$groupIdentifier} to {$newGroupIdentifier}\n";
 }

 static function classDOMTree($class)
 {
     if (!$class) {
         $retValue = false;
         return $retValue;
     }
     $dom = new DOMDocument('1.0', 'utf-8');
     $classNode = $dom->createElement('content-class');
     $dom->appendChild($classNode);
     $serializedNameListNode = $dom->createElement('serialized-name-list');
     $serializedNameListNode->appendChild($dom->createTextNode($class->attribute('serialized_name_list')));
     $classNode->appendChild($serializedNameListNode);
     $identifierNode = $dom->createElement('identifier');
     $identifierNode->appendChild($dom->createTextNode($class->attribute('identifier')));
     $classNode->appendChild($identifierNode);
     $serializedDescriptionListNode = $dom->createElement('serialized-description-list');
     $serializedDescriptionListNode->appendChild($dom->createTextNode($class->attribute('serialized_description_list')));
     $classNode->appendChild($serializedDescriptionListNode);
     $remoteIDNode = $dom->createElement('remote-id');
     $remoteIDNode->appendChild($dom->createTextNode($class->attribute('remote_id')));
     $classNode->appendChild($remoteIDNode);
     $objectNamePatternNode = $dom->createElement('object-name-pattern');
     $objectNamePatternNode->appendChild($dom->createTextNode($class->attribute('contentobject_name')));
     $classNode->appendChild($objectNamePatternNode);
     $urlAliasPatternNode = $dom->createElement('url-alias-pattern');
     $urlAliasPatternNode->appendChild($dom->createTextNode($class->attribute('url_alias_name')));
     $classNode->appendChild($urlAliasPatternNode);
     $isContainer = $class->attribute('is_container') ? 'true' : 'false';
     $classNode->setAttribute('is-container', $isContainer);
     $classNode->setAttribute('always-available', $class->attribute('always_available') ? 'true' : 'false');
     $classNode->setAttribute('sort-field', eZContentObjectTreeNode::sortFieldName($class->attribute('sort_field')));
     $classNode->setAttribute('sort-order', $class->attribute('sort_order'));
     // Remote data start
     $remoteNode = $dom->createElement('remote');
     $classNode->appendChild($remoteNode);
     $ini = eZINI::instance();
     $siteName = $ini->variable('SiteSettings', 'SiteURL');
     $classURL = 'http://' . $siteName . '/class/view/' . $class->attribute('id');
     $siteURL = 'http://' . $siteName . '/';
     $siteUrlNode = $dom->createElement('site-url');
     $siteUrlNode->appendChild($dom->createTextNode($siteURL));
     $remoteNode->appendChild($siteUrlNode);
     $urlNode = $dom->createElement('url');
     $urlNode->appendChild($dom->createTextNode($classURL));
     $remoteNode->appendChild($urlNode);
     $classGroupsNode = $dom->createElement('groups');
     $classGroupList = eZContentClassClassGroup::fetchGroupList($class->attribute('id'), $class->attribute('version'));
     foreach ($classGroupList as $classGroupLink) {
         $classGroup = eZContentClassGroup::fetch($classGroupLink->attribute('group_id'));
         if ($classGroup) {
             unset($groupNode);
             $groupNode = $dom->createElement('group');
             $groupNode->setAttribute('id', $classGroup->attribute('id'));
             $groupNode->setAttribute('name', $classGroup->attribute('name'));
             $classGroupsNode->appendChild($groupNode);
         }
     }
     $remoteNode->appendChild($classGroupsNode);
     $idNode = $dom->createElement('id');
     $idNode->appendChild($dom->createTextNode($class->attribute('id')));
     $remoteNode->appendChild($idNode);
     $createdNode = $dom->createElement('created');
     $createdNode->appendChild($dom->createTextNode($class->attribute('created')));
     $remoteNode->appendChild($createdNode);
     $modifiedNode = $dom->createElement('modified');
     $modifiedNode->appendChild($dom->createTextNode($class->attribute('modified')));
     $remoteNode->appendChild($modifiedNode);
     $creatorNode = $dom->createElement('creator');
     $remoteNode->appendChild($creatorNode);
     $creatorIDNode = $dom->createElement('user-id');
     $creatorIDNode->appendChild($dom->createTextNode($class->attribute('creator_id')));
     $creatorNode->appendChild($creatorIDNode);
     $creator = $class->attribute('creator');
     if ($creator) {
         $creatorLoginNode = $dom->createElement('user-login');
         $creatorLoginNode->appendChild($dom->createTextNode($creator->attribute('login')));
         $creatorNode->appendChild($creatorLoginNode);
     }
     $modifierNode = $dom->createElement('modifier');
     $remoteNode->appendChild($modifierNode);
     $modifierIDNode = $dom->createElement('user-id');
     $modifierIDNode->appendChild($dom->createTextNode($class->attribute('modifier_id')));
     $modifierNode->appendChild($modifierIDNode);
     $modifier = $class->attribute('modifier');
     if ($modifier) {
         $modifierLoginNode = $dom->createElement('user-login');
         $modifierLoginNode->appendChild($dom->createTextNode($modifier->attribute('login')));
         $modifierNode->appendChild($modifierLoginNode);
     }
     // Remote data end
     $attributesNode = $dom->createElementNS('http://ezpublish/contentclassattribute', 'ezcontentclass-attribute:attributes');
     $classNode->appendChild($attributesNode);
     $attributes = $class->fetchAttributes();
     foreach ($attributes as $attribute) {
         $attributeNode = $dom->createElement('attribute');
         $attributeNode->setAttribute('datatype', $attribute->attribute('data_type_string'));
         $required = $attribute->attribute('is_required') ? 'true' : 'false';
         $attributeNode->setAttribute('required', $required);
         $searchable = $attribute->attribute('is_searchable') ? 'true' : 'false';
         $attributeNode->setAttribute('searchable', $searchable);
//.........这里部分代码省略.........

//
$Module = $Params['Module'];
$ClassID = null;
if (isset($Params["ClassID"])) {
    $ClassID = $Params["ClassID"];
}
$class = eZContentClass::fetch($ClassID, true, 0);
if (!$class) {
    return $Module->handleError(eZError::KERNEL_NOT_AVAILABLE);
}
$classCopy = clone $class;
$classCopy->initializeCopy($class);
$classCopy->setAttribute('version', eZContentClass::VERSION_STATUS_MODIFIED);
$classCopy->store();
$mainGroupID = false;
$classGroups = eZContentClassClassGroup::fetchGroupList($class->attribute('id'), $class->attribute('version'));
for ($i = 0; $i < count($classGroups); ++$i) {
    $classGroup =& $classGroups[$i];
    $classGroup->setAttribute('contentclass_id', $classCopy->attribute('id'));
    $classGroup->setAttribute('contentclass_version', $classCopy->attribute('version'));
    $classGroup->store();
    if ($mainGroupID === false) {
        $mainGroupID = $classGroup->attribute('group_id');
    }
}
$classAttributeCopies = array();
$classAttributes = $class->fetchAttributes();
foreach (array_keys($classAttributes) as $classAttributeKey) {
    $classAttribute =& $classAttributes[$classAttributeKey];
    $classAttributeCopy = clone $classAttribute;
    if ($datatype = $classAttributeCopy->dataType()) {