<?php

/*
Copyright (C) Hannon Hill Corporation, hannonhill.com, July 2006
This is a script from hannonhill.com. You will find this and many other
scripts at our website as part of our content management system.

Terms of use:
You are free to use this script as long as the copyright message is kept
intact. However, you may not redistribute, sell or repost it without
our permission. There are no warranties and you use it at your own risk.
*/

parse_and_import();

parse_and_import() {
  global $pages;
  global $quotes;

  parse_xml();
  import_web_pages($pages);
  import_quotes($quotes);

}


/* This function will be called by the XML parser when it
 * finds an opening tag */
function start_element($parser, $name, $attrs) {
  global $tagstack;
  global $pages;
  global $quotes;

  /* Push the current tag name onto our tag stack */
  array_unshift($tagstack, $name);

  /* If we have just entered the context of the web_pages table
   * push a new web page data structure onto our $pages array */
  if ($name == "web_pages")
    array_push($pages, array());

  /* If we have just entered the context of the quotes table
   * push a new web page data structure onto our $quotes array */
  if ($name == "quotes")
    array_push($quotes, array());
}

/* This function will be called by the XML parser when it
 * finds a closing tag */
function end_element($parser, $name) {
  global $tagstack;

  /* We are exiting a tag, so we want to pop it off of our
   * tag stack */
  array_shift($tagstack);
}

/* This function will be called by the XML parser when it
 * finds character data between the opening and the closing
 * of a tag */
function character_data($parser, $data) {
  global $tagstack;
  global $pages;
  global $quotes;

  /* If we aren't deep enough to be in "web_pages" or "quotes"
   * don't do anything */
  if (count($tagstack) < 2)
    return;

  /* The tag we are currently looking at will be the first element
   * on the tag stack. */
  $current_tag = $tagstack[0];

  /* If we are in the context of the web_pages table and
   * are inside of a child tag (notice we check the second element
   * of the stack */
  if ($tagstack[1] == "web_pages") {
    $last = count($pages) - 1;

    /* If this is the first character data for this tag, then
     * initialize the entry in this page's array */
    if (!isset($pages[$last][$current_tag]))
      $pages[$last][$current_tag] = "";

    /* Append the character data to the current page's tag */
    $pages[$last][$current_tag] .= $data;
  }

  /* If we are in the context of the web_pages table and
   * are inside of a tag */
  if ($tagstack[1] == "quotes") {
    $last = count($quotes) - 1;

    /* If this is the first character data for this tag, then
     * initialize the entry in this quotes's array */
    if (!isset($quotes[$last][$current_tag]))
      $quotes[$last][$current_tag] = "";

    /* Append the character data to the current page's tag */
    $quotes[$last][$current_tag] .= $data;
  }
}

function parse_xml() {
  global $pages;
  global $quotes;
  global $tagstack;

  /* The file that we will read our XML from */
  $file = "data.xml";

  /* Initialize the arrays that will hold all of our pages and
   * quotes. */
  $pages = array();
  $quotes = array();

  /* Initialize the tag stack. This will be a stack of the tag
   * structure we are currently in */
  $tagstack = array();

  /* Create an XML Parser object */
  $xml_parser = xml_parser_create();

  /* Turn off case folding on the XML Parser object, this
   * will ensure that the parser will be case sensitive */
  xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, 0);

  /* Set the callback functions for the XML Parser object. The object
   * will call these functions when various actions happen */
  xml_set_element_handler($xml_parser, "start_element", "end_element");
  xml_set_character_data_handler($xml_parser, "character_data");

  /* Try to open the XML file */
  if (!($fp = fopen($file, "r"))) {
    die("could not open XML input");
  }

  /* Read the data a bit at a a time */
  while ($data = fread($fp, 4096)) {

    /* Try to parse that bit */
    if (!xml_parse($xml_parser, $data, feof($fp))) { 
       
      /* Give and error and quit if the parsing fails */
      die(sprintf("XML error: %s at line %d",
                 xml_error_string(xml_get_error_code($xml_parser)),
                 xml_get_current_line_number($xml_parser)));
    }
  }


  /* Free the parser data */
  xml_parser_free($xml_parser);
}

function import_web_pages($pages) {

  /* Initialize a Tidy object, notice that we tell Tidy to
   * turn indenting off, output valid XHTML, only show the
   * body and turn all entities into their UTF-8 numeric
   * equivalents. We want to ensure that Cascade will accept
   * our XHTML */
  $tidy_config = array('indent' => false,
                       'output-xhtml' => true,
                       'show-body-only' => true,
                       'numeric-entities' => true);
  $tidy = new tidy;

  /* Initialize some arrays to hold all the pages and paths we've
   * seen. In this case the path of each web page is stored in the
   * database. */
  $paths = array();

  /* Here we iterate over each line of the table that this query returns.
   * Each line will be an associative array which has keys equal to the
   * field names and value equal to the field values */
  foreach ($pages as $key => $page) {

    /* Now we use the Tidy object to clean up the "content" field
     * which contains the content for the main block of each page.
     * We save this cleaned content back into the content field. */
    $tidy->parseString($page["content"], $tidy_config, 'utf8');
    $tidy->cleanRepair();
    $page["content"] = tidy_get_output($tidy);
      
    /* Cascade requires that the content we use be well-formed XML,
     * thus we need to wrap the XML in a single root tag before
     * delivering it to the CMS */
    $line["content"] =
         '<system-xml xmlns:cascade="http://www.hannonhill.com/CascadeServer/">'
         . $line["content"] . "</system-xml>";

    /* Finally we want to end the HTML tag to complete the markup */
     $page["content"] . '</html>';

    /* The old CMS had a field named "path" which stored the complete
     * path of the page, including directory structure and filename.
     * We want to separate this path out into these two parts, so
     * that we can add the pages to Cascade */

    /* We want to find the string length of the path */
    $pathlen = strlen($page["path"]);

    /* Next we find the position of the last (notice the use of strrpos)
     * directory seperator (the old CMS used a "/"). */
    $filename_loc = strrpos($page["path"], "/");

    /* Now we grab the part of the string after this last "/" so we can use
     * that as the page's system name */
    $system_name = substr($page["path"],
                          $filename_loc + 1,
                          $pathlen - $filename_loc - 1);

    /* Because Cascade does not use page extensions in the CMS, we
     * want to remove the extension from the system name. In this case,
     * the old CMS used the ".htm" extension */
    $system_name = str_replace(".htm", "", $system_name);

    /* We store the system name in the associative array, so that we
     * can use it later. */
    $page["__system_name"] = $system_name;
    
    /* Now we want to transform the path into the part before the
     * page name */
    $page["path"] = substr($page["path"], 0, $filename_loc);

    /* We are going to have to add all the paths we've seen on-the-fly,
     * so we add them to an associative array (the paths are the keys) */
    $paths[$page["path"]] = true;


    if (!isset($page["metaDesc"])) $page["metaDesc"] = "";
    if (!isset($page["keywords"])) $page["keywords"] = "";
    if (!isset($page["title"])) $page["title"] = "";

    /* Replace the old element in the array with this new one.
     * This is a safer method than doing foreach with references */
    $pages[$key] = $page;

  }

  /* We want to add parent paths before children, so we sort them by
   * their string length. We use uksort, because we are using the array
   * like a hash table and we want to sort on the keys */
  uksort($paths, "comp_length");

  /* Open up a SOAP client to the Cascade server. We give the URI of
   * the WSDL document describing Cascade Web Services */
  $client =
    new SoapClient("http://localhost:8080/ws/services/AssetOperationService?wsdl",
                  array('trace' => 1));

  /* Iterate through the keys (each one is a single, unique path) of
   * $paths and add it to Cascade */
  foreach ($paths as $path => $i)
    add_folder($path, $client);

  /* Iterate through the elements of $pages (each one is a an associative
   * array containing the page data) and add it to Cascade */
  foreach ($pages as $page)
    add_page($page, $client);
}

function add_folder($path, $client) {
  /* We need to find the last element on the path, which will
   * be the directory we want to create. We do this similarly to
   * the way we separated the page name from the path */

  /* Find the string length of the path */
  $pathlen = strlen($path);

  /* Find the position of the last path separator */
  $folder_loc = strrpos($path, "/");

  /* The folder name will be the substring after this separator */
  $folder_name = substr($path,
                        $folder_loc + 1,
                        $pathlen - $folder_loc - 1);

  /* The parent folder for our new folder will be the parent directory */
  $path = substr($path, 0, $folder_loc + 1);

  /* Now we fill an associative array that we will pass to the PHP
   * SOAP functions. The structure of this array will be determined
   * by the WSDL specification. PHP will interpret the structure
   * and create appropriate XML to pass to the Web Services */
  $create_params = array (
   'authentication' => array( 
    'password' => "admin",
    'username' => "admin"
    ),

   'asset' => array(
    'folder' => array(
      'name' => $folder_name,
      'metadataSetPath' => "/Default",
      'parentFolderPath' => $path)));

  try {
    /* Pass the create parameters through the PHP SOAP client. */
    $response = $client->create($create_params);
  
    /* If something goes wrong, it will be reported with 
     * __getLastResponse, so be sure to take a look at the 
     * message it returns. */
    //print($client->__getLastResponse() . "\n");

  } catch (Exception $e) {

    /* The request will throw an exception when parameters do
     * not conform to the WSDL. This will *not* catch errors
     * in the parameters themselves */
    print("Folder creation request failed to conform to the WSDL.\n");

  }
}

/* This function adds a page to the Cascade server with web
 * services. The page information should be stored in an
 * associative array, $pdata. */
function add_page($pdata, $client) {

  /* Ensure that all the metadata is encoded in UTF-8 */
  $pdata["title"] = utf8_encode($pdata["title"]);
  $pdata["keywords"] = utf8_encode($pdata["keywords"]);
  $pdata["metaDesc"] = utf8_encode($pdata["metaDesc"]);

  /* Costruct the parameters in the same way that we 
   * constructucted them for the folder, though creating
   * a page requires a bit more information */
  $create_params = array (
   'authentication' => array( 
    'password' => "admin",
    'username' => "admin"
    ),

   'asset' => array(
    'page' => array(
      'name' => $pdata["__system_name"],
      'parentFolderPath' => $pdata["path"],
      'metadataSetPath' => "/Default",
      'configurationSetPath' => "/General/Simple Full HTML",
      'xhtml' => $pdata["content"],
      'metadata' => array(
        'title' => $pdata["title"],
        'keywords' => $pdata["keywords"],
        'metaDescription' =>$pdata["metaDesc"]))));

  try {
    $response = $client->create($create_params);

    /* If something goes wrong, uncomment this line to read 
     * the server's response to your SOAP request */
    //print($client->__getLastResponse());

  } catch (Exception $e) {
    print("Page creation request failed to conform to the WSDL.\n");
  }

}

/* Compare the string lengths of two strings. This is
 * used by the uksort above */
function comp_length($astring, $bstring) {
  if (strlen($astring) == strlen($bstring))
    return 0;

  if (strlen($astring) > strlen($bstring))
    return 1;

  else
    return -1;
}


function import_quotes($quotes) {


  /* Construct a SOAP client connecting to Cascade instance */
  $client =
    new SoapClient("http://localhost:8080/ws/services/AssetOperationService?wsdl",
                   array('trace' => 1));

  /* Create a folder to hold our quotes */
  add_folder("//quotes", $client);

  /* Iterate thruogh each quote */
  foreach ($quotes as $quote) {


    /* Convert the quote body to UTF-8 encoding */
    $quote["body"] = utf8_encode($quote["body"]);
    $quote["type"] = utf8_encode($quote["type"]);
    $quote["source"] = utf8_encode($quote["source"]);

    /* construct the parameters to create pages that use 
      * data definitions. Notice the structure of the 
      * structuredDataNodes. Each node is an array of the
      * elements of each data defintion */
    $create_params = array (
     'authentication' => array( 
      'password' => "admin",
      'username' => "admin"
      ),

     'asset' => array(
      'page' => array(
        'name' => $quote["id"],
        'parentFolderPath' => "/quotes",
        'metadataSetPath' => "/Default",
        'configurationSetPath' => "/General/Simple XML",

        'structuredData' => array(
         'definitionPath' => "/Quote",
          'structuredDataNodes' => array(

            'structuredDataNode' => array(
             array(
              'type' => "text",
              'identifier' => "type",
              'text' => $quote["type"]),

            array(
              'type' => "text",
              'identifier' => "source",
              'text' => $quote["source"]),

            array(
              'type' => "text",
              'identifier' => "body",
              'text' => $quote["body"]) ))) ) ));

    try {

      /* Pass this request to Web Services */
      $response = $client->create($create_params);

      /* If something goes wrong check the value of 
       * __getLastResponse() */
      print("\n". $client->__getLastResponse() . "\n");

    } catch (Exception $e) {

      /* The request will throw an exception when parameters do
       * not conform to the WSDL. This will *not* catch errors
       * in the parameters themselves */
      print("Page creation request failed to conform to the WSDL.\n");
    }
  }
}

?>