se/SE/se-lib/XML.php

<?php

Lib::loadClass('Core_XmlWriter');
// $zxo = new XMLDiff\Memory;// @require xmldiff pecl package installed

// TODO:TYPE_RECURCE: if type has local prefix - choose:
//   - find recurse typeName and restrictions
//   - find types and save in SystemObjectField table (if simpleType)
//   - ? find types and save in SystemObject table + SystemObjectField table (if complexType)

class XML {

  public static function xmlToArray($xml) {

  }

  public static function readXmlFileToArray($filePath) {
    $z = new XMLReader();
    if (!$z) throw new HttpException("Class XMLReader not installed", 500);
    $fileName = basename($filePath);
    if (!$z->open($filePath)) throw new Exception("Failed to open ant schema file '{$fileName}'", 500);
    return self::xmlReadToArray($z);
  }
  public static function xmlReadToArray($z) {
		while ($z->read()) {
			if (XMLReader::ELEMENT !== $z->nodeType) continue;
			return self::xmlReadRecurse($z);
		}
	}
	public static function xmlReadRecurse($z) {
		$node = [ $z->name, [], [] ];// name, attrs, childrens
		$depth = $z->depth;
		$isEmpty = $z->isEmptyElement;
		if ($z->hasAttributes) {
			while ($z->moveToNextAttribute()) {
				$node[1][$z->name] = $z->value;
			}
		}
		if ($isEmpty) {
			$node[2] = null;
			return $node;
		}
		// switch ($z->name) {
		// 	case 'xsd:complexType': $node[1]['name'] = $z->getAttribute('name'); break;
		// 	case 'xsd:simpleType': $node[1]['name'] = $z->getAttribute('name'); break;
		// 	case 'xsd:restriction': $node[1]['base'] = $z->getAttribute('base'); break;
		// 	case 'xsd:enumeration': $node[1]['value'] = $z->getAttribute('value'); break;
		// 	case 'xsd:element': $node[1] = [
		// 		'type' => $z->getAttribute('type')
		// 	]; break;
		// 	case 'xsd:complexContent': break;
		// 	case 'xsd:sequence': break;
		// 	case 'xsd:attribute': $node[1]['base'] = $z->getAttribute('base'); break;
		// 	case 'xsd:extension': $node[1]['base'] = $z->getAttribute('base'); break;
		// 	default: UI::alert('warning', "TODO: read attributes from: d({$z->depth}) name($z->name)");
		// }
		while ($z->read() && $z->depth > $depth) {
			if (XMLReader::ELEMENT !== $z->nodeType) continue;
			// if ($z->depth == $depth + 2)
			$node[2][] = self::xmlReadRecurse($z);
			// else $node[2][] = "d({$z->depth}) name($z->name)";
		}
		return $node;
	}

  public static function printXmlFromArray($xml) {
    $xmlWriter = new Core_XmlWriter();
    $xmlWriter->openUri('php://output');
    $xmlWriter->setIndent(true);
    $xmlWriter->startDocument('1.0','UTF-8');
    $xmlWriter->h($xml[0], $xml[1], $xml[2]);
    $xmlWriter->endDocument();
  }

  public static function findElementName($docArray, $nodeArray) {
    if (!empty($nodeArray[1]['name'])) return $nodeArray[1]['name'];
    if (!empty($nodeArray[1]['ref'])) return $nodeArray[1]['ref'];
    throw new Exception("Missing xsd:element name");
  }

  public static function findElementType($docArray, $nodeArray) {
    $fieldName = self::findElementName($docArray, $nodeArray);
    if (!empty($nodeArray[1]['type'])) {
      // TODO:TYPE_RECURCE: if local ns prefix then find correct typeName?
      // TODO:TYPE_RECURCE:the same for restrictions
      return $nodeArray[1]['type'];
    }
    if (!empty($nodeArray[1]['ref'])) return 'ref:' . $nodeArray[1]['ref'];
    if (empty($nodeArray[2])) throw new Exception("Missing xsd:element childrens - cannot find type");
    // TODO: find in loop (xsd:annotation may accure)
    if (empty($nodeArray[2][0][0]) || 'xsd:simpleType' != $nodeArray[2][0][0]) throw new Exception("Missing 'xsd:simpleType' for field '{$fieldName}'");
    if (empty($nodeArray[2][0][2][0]) || 'xsd:restriction' != $nodeArray[2][0][2][0][0]) throw new Exception("Missing 'xsd:restriction' for field '{$fieldName}'");
    if (empty($nodeArray[2][0][2][0][1]['base'])) throw new Exception("Missing 'xsd:restriction/@base' for field '{$fieldName}'");
    return $nodeArray[2][0][2][0][1]['base'];
  }

  public static function findElementRestrictions($docArray, $nodeArray) {
    $restrictions = [];
    $fieldName = self::findElementName($docArray, $nodeArray);
    // TODO:TYPE_RECURCE: if type has local prefix then find retriction recurse?
    if (!empty($nodeArray[1]['nillable']) && 'true' === $nodeArray[1]['nillable']) $restrictions['nillable'] = true;
    if (!empty($nodeArray[2])) {
      foreach ($nodeArray[2] as $c) {
        switch (XML::getTagName($c[0])) {
          case 'annotation': break; // skip xsd:element/xsd:annotation @see findElementAppInfo
          case 'simpleType': { // xsd:element/xsd:simpleType
            if (empty($c[2][0]) || 'restriction' != XML::getTagName($c[2][0][0])) throw new Exception("Missing 'xsd:restriction' for field '{$fieldName}'");
            if (empty($c[2][0][1]['base'])) throw new Exception("Missing 'xsd:restriction/@base' for field '{$fieldName}'");
            // xsd:element/xsd:simpleType/xsd:restriction/xsd:string
            foreach ($c[2][0][2] as $tagRestriction) {
              // xsd:string/xsd:maxLength
              $val = $tagRestriction[1]['value'];
              if ('enumeration' == XML::getTagName($tagRestriction[0])) {
                $restrictions['enumeration'][$val] = $val;
              } else {
                $restrictions[XML::getTagName($tagRestriction[0])] = $val;
              }
            }
          } break;
          default: {
            DBG::log($c, 'array', "Not imeplemented element child '{$c[0]}'");
          }
        }
      }
    }
    return $restrictions;
  }
  public static function findElementAppInfo($docArray, $nodeArray) {
    $appInfo = [];
    $fieldName = self::findElementName($docArray, $nodeArray);
    if (!empty($nodeArray[2])) {
      foreach ($nodeArray[2] as $c) {
        switch (XML::getTagName($c[0])) {
          case 'annotation': { // skip xsd:element/xsd:annotation
            DBG::nicePrint($c, "TODO: xsd:annotation/xsd:appinfo '{$fieldName}'");
            // <xsd:annotation>
            //    <xsd:appinfo>
            //       <system_cache__appinfo:flat_relation_cache>
            //          <system_cache__appinfo:source system_cache__appinfo:name="ID"
            //                                        system_cache__appinfo:xpath="default_db__x3A__CRM_WSKAZNIK:CRM_WSKAZNIK/ID_PROCES"/>
            $prefix = 'system_cache__appinfo';
            foreach ($c[2] as $cc) {
              if ('appinfo' == XML::getTagName($cc[0])) {
                foreach ($cc[2] as $appTag) {
                  $appInfo[XML::getTagName($appTag[0])] = XML::readAppInfoRecurse($docArray, $appTag);
                }
              }
            }
          } break;
          case 'simpleType': break; // skip xsd:element/xsd:simpleType @see findElementRestrictions
          default: {
            DBG::log($c, 'array', "Not imeplemented element child '{$c[0]}'");
          }
        }
      }
    }
    DBG::log($fieldName, 'array', "findElementAppInfo fieldName='{$fieldName}'");
    return $appInfo;
  }

  public static function getTagName($xsdName) {
    return (false !== ($pos = strpos($xsdName, ':')))
      ? substr($xsdName, $pos + 1)
      : $xsdName;
  }

  public static function readAppInfoRecurse($docArray, $nodeArray) {
    $appInfo = [];
    if (!empty($nodeArray[1])) foreach ($nodeArray[1] as $attrName => $attrVal) {
      $appInfo['@' . XML::getTagName($attrName)] = $attrVal;
    }
    if (!empty($nodeArray[2])) foreach ($nodeArray[2] as $appTag) {
      $appInfo[XML::getTagName($appTag[0])] = XML::readAppInfoRecurse($docArray, $appTag);
    }
    // TODO: text nodes
    return $appInfo;
  }

  public static function findFieldsFromSequence($docArray, $nodeArray) {
    if ($nodeArray[0] != 'xsd:sequence') throw new Exception("Error Parsing Schema - expected 'sequence'");
    $fields = [];
    foreach ($nodeArray[2] as $f) {
      if ($f[0] !== 'xsd:element') {
        DBG::log($n, 'array', "Schema xsd parse error - Not implemented node type '{$f[0]}'");
        continue;
      }
      $fieldName = XML::findElementName($docArray, $f); // V::get('name', '', $f[1]);
      if (!$fieldName) throw new Exception("Error Parsing Schema - expected 'element[@name]'");
      if ('__' === substr($fieldName, 0, 2)) continue;
      if (!V::get('type', '', $f[1]) && !V::get('ref', '', $f[1]) && empty($f[2])) {
        UI::alert('danger', "Skipping not implemented field structure '{$fieldName}'");
        DBG::log($f, 'array', "Skipping not implemented field structure '{$fieldName}'");
        continue;
      }
      $fields[$fieldName] = [
        'type' => XML::findElementType($docArray, $f),
        'minOccurs' => V::get('minOccurs', 0, $f[1], 'int'),
        'maxOccurs' => V::get('maxOccurs', '1', $f[1]),
        'restrictions' => XML::findElementRestrictions($docArray, $f),
        'appInfo' => XML::findElementAppInfo($docArray, $f),
      ];
    }
    return $fields;
  }

  public static function findFieldsFromComplexContent($docArray, $nodeArray) {
    // xsd:complexType / xsd:complexContent / xsd:restriction [ @base = "default_db__x3A__CRM_PROCES:CRM_PROCES" ]
    // xsd:complexType / xsd:complexContent / xsd:extension [ @base = "default_db__x3A__CRM_PROCES:CRM_PROCES" ]
    switch (XML::getTagName($nodeArray[2][0][0])) {
      case 'extension': return XML::findFieldsFromExtension($docArray, $nodeArray[2][0]);
      case 'restriction': return XML::findFieldsFromRestriction($docArray, $nodeArray[2][0]);
    }
    // TODO:? $xsdType['extensionBase'] = V::get('base', '', $nodeArray[1]);
    // TODO:? $xsdType['restrictionBase'] = V::get('base', '', $nodeArray[1]);
  }
  public static function findFieldsFromExtension($docArray, $nodeArray) {
    $fields = [];
    if ($nodeArray[2][0][0] != 'xsd:sequence') throw new Exception("Error Parsing Schema - expected 'complexType/complexContent/extension/sequence'");
    foreach ($nodeArray[2][0][2] as $f) {
      if ($f[0] !== 'xsd:element') {
        DBG::log($n, 'array', "Schema xsd parse error - Not implemented node type '{$f[0]}'");
        continue;
      }
      $fieldName = XML::findElementName($docArray, $f); // V::get('name', '', $f[1]);
      if (!$fieldName) throw new Exception("Error Parsing Schema - expected 'element[@name]'");
      if ('__' === substr($fieldName, 0, 2)) continue;
      if (!V::get('type', '', $f[1]) && !V::get('ref', '', $f[1]) && empty($f[2])) {
        UI::alert('danger', "Skipping not implemented field structure '{$fieldName}'");
        continue;
      }
      $fields[$fieldName] = [
        'type' => XML::findElementType($docArray, $f),
        'minOccurs' => V::get('minOccurs', 0, $f[1], 'int'),
        'maxOccurs' => V::get('maxOccurs', '1', $f[1]),
        'restrictions' => XML::findElementRestrictions($docArray, $f),
        'appInfo' => XML::findElementAppInfo($docArray, $f),
      ];
    }
    return $fields;
  }
  public static function findFieldsFromRestriction($docArray, $nodeArray) {
    $fields = [];
    if ($nodeArray[2][0][0] != 'xsd:sequence') throw new Exception("Error Parsing Schema - expected 'complexType/complexContent/restriction/sequence'");
    foreach ($nodeArray[2][0][2] as $f) {
      if ($f[0] !== 'xsd:element') {
        DBG::log($n, 'array', "Schema xsd parse error - Not implemented node type '{$f[0]}'");
        continue;
      }
      $fieldName = XML::findElementName($docArray, $f); // V::get('name', '', $f[1]);
      if (!$fieldName) throw new Exception("Error Parsing Schema - expected 'element[@name]'");
      if ('__' === substr($fieldName, 0, 2)) continue;
      if (!V::get('type', '', $f[1]) && !V::get('ref', '', $f[1]) && empty($f[2])) {
        UI::alert('danger', "Skipping not implemented field structure '{$fieldName}'");
        continue;
      }
      $fields[$fieldName] = [
        'type' => XML::findElementType($docArray, $f),
        'minOccurs' => V::get('minOccurs', 0, $f[1], 'int'),
        'maxOccurs' => V::get('maxOccurs', '1', $f[1]),
        'restrictions' => XML::findElementRestrictions($docArray, $f),
        'appInfo' => XML::findElementAppInfo($docArray, $f),
      ];
    }
    return $fields;
  }

}