PHP SimpleXMLElement::getNamespaces方法代码示例

 /**
  * Constructor
  *
  * @param \SimpleXMLElement|string $data
  * @throws InvalidArgumentException
  */
 public function __construct($data)
 {
     if ($data instanceof SimpleXMLElement) {
         $this->xml = $data;
     } else {
         if (is_string($data)) {
             $this->xml = new SimpleXMLElement($data);
         } else {
             throw new InvalidArgumentException(sprintf('Invalid data type for NcxResource'));
         }
     }
     $this->namespaces = $this->xml->getNamespaces(true);
 }

 function setIdentifier($form_values)
 {
     require_once drupal_get_path('module', 'Fedora_Repository') . '/ObjectHelper.php';
     require_once drupal_get_path('module', 'Fedora_Repository') . '/CollectionClass.php';
     $collectionHelper = new CollectionClass();
     $ppid = $_SESSION['pid'];
     $itqlquery = 'select $object from <#ri> where $object <fedora-rels-ext:isPartOf><info:fedora/' . $ppid . '> and $object <fedora-rels-ext:isMemberOfCollection><info:fedora/vre:mnpl-compounds>and $object <fedora-model:state> <info:fedora/fedora-system:def/model#Active>';
     $relatedItems = $collectionHelper->getRelatedItems($this->pid, $itqlquery);
     $sxe = new SimpleXMLElement($relatedItems);
     $nmspace = $sxe->getNamespaces(true);
     $regspace = $sxe->registerXPathNamespace('ri', implode($nmspace));
     $link = $sxe->xpath('//@uri');
     $labid = $_SESSION['labid'];
     if (empty($link)) {
         $ident = $labid . '-C-0';
     } else {
         //loop through returns , trim to create identifier and increment highest value
         $xia = array();
         foreach ($link as $path) {
             $path1 = substr($path, '30');
             $path2 = strrchr($path1, "-");
             $path = str_replace($path2, '', $path1);
             $xi = ltrim($path2, "-");
             $xnew = array_push($xia, $xi);
         }
         $num = max($xia);
         $numinc = $num + 1;
         $ident = $labid . '-C-' . $numinc;
     }
     return $ident;
 }

 public function authenticate($ticket, $service)
 {
     $r = \Httpful\Request::get($this->getValidateUrl($ticket, $service))->sendsXml()->timeoutIn($this->timeout)->send();
     $r->body = str_replace("\n", "", $r->body);
     // var_dump($r->body);
     try {
         $xml = new \SimpleXMLElement($r->body);
     } catch (\Exception $e) {
         throw new \Exception("Return cannot be parsed :\n {$r->body}", 1);
     }
     $namespaces = $xml->getNamespaces();
     $serviceResponse = $xml->children($namespaces['cas']);
     $user = $serviceResponse->authenticationSuccess->user;
     if ($user) {
         return (string) $user;
         // cast simplexmlelement to string
     } else {
         $authFailed = $serviceResponse->authenticationFailure;
         if ($authFailed) {
             $attributes = $authFailed->attributes();
             throw new \Exception("AuthenticationFailure : " . $attributes['code'] . " ({$ticket}, {$service})", 1);
         } else {
             throw new \Exception("Cas return is weird : '{$r->body}'", 1);
         }
     }
     // never reach there
 }

    function validate_operations()
    {
        foreach ($this->calendar_users as $user) {
            $url = str_replace("#USER#", $user['user'], $this->calendar_url);
            $this->caldav = new CalDAVClient($url, trim($user['user']), trim($user['pass']), 'basic', false);
            //for debug = true
            $xmlC = <<<PROPP
<?xml version="1.0" encoding="utf-8" ?>
 <D:propfind xmlns:D="DAV:" xmlns:C="http://calendarserver.org/ns/">
     <D:prop>
             <D:displayname />
             <C:getctag />
             <D:resourcetype />
     </D:prop>
 </D:propfind>
PROPP;
            try {
                $this->caldav->SetDepth(1);
                $xml_response = $this->caldav->DoXMLRequest("PROPFIND", $xmlC);
                $xml_response = explode("\r\n\r\n", $xml_response)[1];
                $xml = new SimpleXMLElement($xml_response);
                $ns = $xml->getNamespaces(true);
                $responses = $xml->children($ns["d"]);
                $this->set_status(ok);
                $this->add_functional("calendar list events of " . $user['user'] . "(" . count($responses) . ")", ok);
            } catch (Exception $x) {
                $this->set_status(error);
                $this->add_message($x->getMessage());
                $fullerror = "url:" . $url . " " . $x->getMessage();
                error_log($fullerror);
                $this->add_functional("calendar list events of " . $user['user'], error, "Can't list events from {$url}");
            }
        }
    }

 private function parseMaps(\SimpleXMLElement $xml)
 {
     $maps = array();
     if (array_key_exists('maps', $this->mapping)) {
         foreach ($this->mapping['maps'] as $key => $item) {
             /* --- XML NS --- */
             if ('MobileRelatedApps' == $this->name) {
                 /** @var $element \SimpleXMLElement */
                 $element = $xml->{'RelatedApps'};
                 $ns = $xml->getNamespaces(true);
                 $map = array();
                 foreach ($element->children($ns['d2p1']) as $element) {
                     $map[(string) $element->{$item['xml']['key']}] = (string) $element->{$item['xml']['value']};
                 }
                 $maps[$key] = $map;
                 continue;
             }
             /* --- XML NS --- */
             $map = array();
             $parts = explode('.', $item['xml']['field']);
             $items = array();
             if (2 == count($parts)) {
                 $items = $xml->{$parts[0]}->{$parts[1]};
             }
             foreach ($items as $element) {
                 $map[(string) $element->{$item['xml']['key']}] = (string) $element->{$item['xml']['value']};
             }
             $maps[$key] = $map;
         }
     }
     return $maps;
 }

 function __construct(SimpleXMLElement $node, $namespaces = null)
 {
     $this->__name = $node->getName();
     $this->__value = $node;
     if ($namespaces === null) {
         $namespaces = $node->getNamespaces(true);
     }
     foreach ($namespaces as $ns => $uri) {
         foreach ($node->children($uri) as $child) {
             $childName = $ns ? "{$ns}:" . $child->getName() : $child->getName();
             if (array_key_exists($childName, $this->__children) && is_array($this->__children[$childName])) {
                 $this->__children[$childName][] = new clNode($child, $namespaces);
             } else {
                 if (array_key_exists($childName, $this->__children) && get_class($this->__children[$childName]) == "clNode") {
                     $childArray = array();
                     $childArray[] = $this->__children[$childName];
                     $childArray[] = new clNode($child, $namespaces);
                     $this->__children[$childName] = $childArray;
                 } else {
                     $this->__children[$childName] = new clNode($child, $namespaces);
                 }
             }
         }
         foreach ($node->attributes($ns) as $a) {
             $a = $a->asXML();
             @(list($name, $value) = split('=', $a));
             $this->__attributes[trim($name)] = substr($value, 1, strlen($value) - 2);
         }
     }
 }

 /**
  * Method to parse the feed into a JFeed object.
  *
  * @return  JFeed
  *
  * @since   12.3
  */
 public function parse()
 {
     $feed = new JFeed();
     // Detect the feed version.
     $this->initialise();
     // Let's get this party started...
     do {
         // Expand the element for processing.
         $el = new SimpleXMLElement($this->stream->readOuterXml());
         // Get the list of namespaces used within this element.
         $ns = $el->getNamespaces(true);
         // Get an array of available namespace objects for the element.
         $namespaces = array();
         foreach ($ns as $prefix => $uri) {
             // Ignore the empty namespace prefix.
             if (empty($prefix)) {
                 continue;
             }
             // Get the necessary namespace objects for the element.
             $namespace = $this->fetchNamespace($prefix);
             if ($namespace) {
                 $namespaces[] = $namespace;
             }
         }
         // Process the element.
         $this->processElement($feed, $el, $namespaces);
         // Skip over this element's children since it has been processed.
         $this->moveToClosingElement();
     } while ($this->moveToNextElement());
     return $feed;
 }

 /**
  * Get a specific attribute in a namespaced tag
  * @param  \SimpleXMLElement $xml            
  * @param  string $attributeFocus 
  * @param  string $namespaceFocus 
  * @param  string $tagFocus       
  * @return string 
  */
 public static function extractAttributeFromXml($xml, $attributeFocus, $namespaceFocus, $tagFocus)
 {
     $namespace = $xml->getNamespaces(true);
     $attributes = $xml->children($namespace[$namespaceFocus])->{$tagFocus}->attributes();
     $finalAttribute = $attributes[$attributeFocus];
     return $finalAttribute->__toString();
 }

 public static function xmlToArray(\SimpleXMLElement $xml, $options = [])
 {
     $defaults = ['namespaceSeparator' => ':', 'attributePrefix' => '@', 'alwaysArray' => [], 'autoArray' => true, 'textContent' => '_v_', 'autoText' => true, 'keySearch' => false, 'keyReplace' => false];
     $options = array_merge($defaults, $options);
     $namespaces = $xml->getNamespaces(true);
     $namespaces[''] = null;
     //add base (empty) namespace
     //get attributes from all namespaces
     $attributesArray = [];
     foreach ($namespaces as $prefix => $namespace) {
         foreach ($xml->attributes($namespace) as $attributeName => $attribute) {
             //replace characters in attribute name
             if ($options['keySearch']) {
                 $attributeName = str_replace($options['keySearch'], $options['keyReplace'], $attributeName);
             }
             $attributeKey = $options['attributePrefix'] . ($prefix ? $prefix . $options['namespaceSeparator'] : '') . $attributeName;
             $attributesArray[$attributeKey] = (string) $attribute;
         }
     }
     //get child nodes from all namespaces
     $tagsArray = [];
     foreach ($namespaces as $prefix => $namespace) {
         foreach ($xml->children($namespace) as $childXml) {
             //recurse into child nodes
             $childArray = self::xmlToArray($childXml, $options);
             list($childTagName, $childProperties) = each($childArray);
             //replace characters in tag name
             if ($options['keySearch']) {
                 $childTagName = str_replace($options['keySearch'], $options['keyReplace'], $childTagName);
             }
             //add namespace prefix, if any
             if ($prefix) {
                 $childTagName = $prefix . $options['namespaceSeparator'] . $childTagName;
             }
             if (!isset($tagsArray[$childTagName])) {
                 //only entry with this key
                 //test if tags of this type should always be arrays, no matter the element count
                 $tagsArray[$childTagName] = in_array($childTagName, $options['alwaysArray']) || !$options['autoArray'] ? [$childProperties] : $childProperties;
             } elseif (is_array($tagsArray[$childTagName]) && array_keys($tagsArray[$childTagName]) === range(0, count($tagsArray[$childTagName]) - 1)) {
                 //key already exists and is integer indexed array
                 $tagsArray[$childTagName][] = $childProperties;
             } else {
                 //key exists so convert to integer indexed array with previous value in position 0
                 $tagsArray[$childTagName] = [$tagsArray[$childTagName], $childProperties];
             }
         }
     }
     //get text content of node
     $textContentArray = [];
     $plainText = trim((string) $xml);
     if ($plainText !== '') {
         $textContentArray[$options['textContent']] = $plainText;
     }
     //stick it all together
     $propertiesArray = !$options['autoText'] || $attributesArray || $tagsArray || $plainText === '' ? array_merge($attributesArray, $tagsArray, $textContentArray) : $plainText;
     //return node as array
     return [$xml->getName() => $propertiesArray];
 }

 /**
  * Convert SimpleXMLElement to multidimensional array.
  *
  * @param \SimpleXMLElement $xml
  * @param string            $namespace The namespace that schould be used.
  *
  * @throws \OutOfBoundsException If namespace not found in the xml.
  * @return array
  */
 public static function toArray(\SimpleXMLElement $xml, $namespace = null)
 {
     if ($namespace !== null) {
         $namespaces = $xml->getNamespaces();
         if (false === isset($namespaces[$namespace])) {
             throw new \OutOfBoundsException('namespace [' . $namespace . '] not found');
         }
         $xml = $xml->children($namespaces[$namespace]);
     }
     return Json::decode(Json::encode($xml), true);
 }

 public function watchFolder(KalturaDropFolder $dropFolder)
 {
     /* @var $dropFolder KalturaFeedDropFolder */
     KalturaLog::info("Watching drop folder with ID [" . $dropFolder->id . "]");
     $this->dropFolder = $dropFolder;
     //Get Drop Folder feed and import it into a SimpleXMLElement
     $feed = new SimpleXMLElement(file_get_contents($dropFolder->path));
     $this->feedNamespaces = $feed->getNamespaces(true);
     //get items
     $feedItems = $feed->xpath($this->dropFolder->feedItemInfo->itemXPath);
     if ($this->dropFolder->itemHandlingLimit > 0 && count($feedItems) > $this->dropFolder->itemHandlingLimit) {
         KalturaLog::err("Reached pulling limit for drop folder ID [" . $this->dropFolder->id . "].");
         array_splice($feedItems, $this->dropFolder->itemHandlingLimit);
         $dropFolderUpdate = new KalturaFeedDropFolder();
         $dropFolderUpdate->errorDescription = FeedDropFolderPlugin::ERROR_MESSAGE_INCOMPLETE_HANDLING . $this->dropFolder->id;
         $this->dropFolderPlugin->dropFolder->update($this->dropFolder->id, $dropFolderUpdate);
     }
     $existingDropFolderFilesMap = $this->loadDropFolderFiles();
     $counter = 0;
     foreach ($feedItems as $feedItem) {
         if ($counter > intval(KBatchBase::$taskConfig->params->mrss->limitProcessEachRun)) {
             KalturaLog::info('Finished current run.');
             break;
         }
         /* @var $feedItem SimpleXMLElement */
         $uniqueId = strval($this->getSingleXPathResult($this->dropFolder->feedItemInfo->itemUniqueIdentifierXPath, $feedItem));
         //If we already encountered this uniqueId in this run- ignore subsequent iterations.
         if (in_array($uniqueId, $this->handledUniqueIds)) {
             KalturaLog::err("The unique identifer value [{$uniqueId}] was encountered before during this scan of the feed. Ignoring.");
             continue;
         }
         // The unique feed item identifier is the GUID, so that is what we set as the drop folder file name.
         if (!array_key_exists($uniqueId, $existingDropFolderFilesMap)) {
             //In this case, we are required to add this item as a new drop folder file
             KalturaLog::info("Item not found in drop folder file list- adding as new drop folder file.");
             $this->handleItemAdded($uniqueId, $feedItem);
             $counter++;
         } else {
             KalturaLog::info("Item found in drop folder file list- adding as existing drop folder file.");
             $dropFolderFile = $existingDropFolderFilesMap[$uniqueId];
             unset($existingDropFolderFilesMap[$uniqueId]);
             //if file exist in the folder remove it from the map
             //all the files that are left in a map will be marked as PURGED
             if ($this->handleExistingItem($dropFolderFile, $feedItem)) {
                 $counter++;
             }
         }
         $this->handledUniqueIds[] = $uniqueId;
     }
     foreach ($existingDropFolderFilesMap as $existingDropFolderFile) {
         $this->handleFilePurged($existingDropFolderFile->id);
     }
 }

 /**
  * @return string[] The attributes
  */
 public function getAttributes()
 {
     //include namespace declarations as attributes
     $xmlnsRaw = $this->_element->getNamespaces();
     $xmlns = array();
     foreach ($xmlnsRaw as $key => $val) {
         $label = 'xmlns' . ($key ? ":{$key}" : $key);
         $xmlns[$label] = $val;
     }
     //get attributes and merge with namespaces
     $attrRaw = $this->_element->attributes();
     $attr = array();
     foreach ($attrRaw as $key => $val) {
         $attr[$key] = $val;
     }
     $attr = array_merge((array) $xmlns, (array) $attr);
     $result = array();
     foreach ($attr as $key => $val) {
         $result[$key] = (string) $val;
     }
     return $result;
 }

 private function getStatus($type, $path, $response)
 {
     $data = new \SimpleXMLElement($response);
     $namespaces = $data->getNamespaces(true);
     foreach ($namespaces as $key => $value) {
         $namespace = $value;
     }
     $data->registerXPathNamespace($type, $namespace);
     foreach ($data->xpath($path) as $value) {
         $status = json_decode(json_encode((array) $value), TRUE);
     }
     return $status;
 }

 public function getBillingAgreementDetailsStatus($response)
 {
     $data = new \SimpleXMLElement($response);
     $namespaces = $data->getNamespaces(true);
     foreach ($namespaces as $key => $value) {
         $namespace = $value;
     }
     $data->registerXPathNamespace('GetBA', $namespace);
     foreach ($data->xpath('//GetBA:BillingAgreementStatus') as $value) {
         $baStatus = json_decode(json_encode((array) $value), TRUE);
     }
     return $baStatus;
 }

 public static function fromSimpleXMLElement(SimpleXMLElement $element)
 {
     // Traverse all existing namespaces in element.
     $namespaces = $element->getNamespaces();
     foreach ($namespaces as $prefix => $ns) {
         $element[$prefix === '' ? 'xmlns' : 'xmlns:' . $prefix] = $ns;
     }
     /* Create a new parser with the xml document where the namespace definitions
      * are added.
      */
     $parser = new SimpleSAML_XML_Parser($element->asXML());
     return $parser;
 }