serialization_manager.inc

Go to the documentation of this file.

<?php
Fakoli::using("component");
 
interface SerializationHandler
{
     function export();
     
     function import($doc, $tx);
}
 
class SerializationManager
{
     static $map;
     
     function __construct()
     {
          if (!SerializationManager::$map)
          {
               SerializationManager::$map = array();
               ComponentManager::fireEvent("RegisterSerializationHandler");
               asort(SerializationManager::$map);
          }
     }
     
     function registerHandler($component, $title, $handler)
     {
          SerializationManager::$map[$component] = array('title' => $title, 'handler' => $handler);
     }
     
     function export($components)
     {
          global $config;
          
          $components = explode(",", $components);
 
          $default_charset = $config["default_charset"];
          if (!$default_charset) $default_charset = "iso-8859-1";
          
          $xml = "<?xml version=\"1.0\" encoding=\"{$default_charset}\"?>";
          $xml .= "\n<Fakoli>";
          
          foreach($components as $component)
          {
               $handler = SerializationManager::$map[$component]['handler'];
               $xml .= $handler->export();
          }
          
          $xml .= "\n</Fakoli>";
          return $xml;
     }
     
     function exportAll()
     {
          $components = implode(",", array_keys(SerializationManager::$map));
          return $this->export($components);
     }
     
     function import($xml, $components)
     {
          $components = explode(",", $components);
          $this->processImport($xml, $components);          
     }
     
     function importBackground()
     {
          global $process;
          if (!$process)
          {
               throw new FakoliException("Not running as a background process");
          }
          
          $xml = file_get_contents($process->get("xml_import_file_path"));
          $components = $process->get("xml_import_components");
          
          trace("Importing $components from $xml", 3);
          $process->setProgress("Running", "Starting import", 0);
          
          $components = explode(",", $components);
          $this->processImport($xml, $components);
     }
     
     private function processImport($xml, $components)
     {
          $doc = new DOMDocument();
          if (!$doc->loadXML($xml))
          {
               throw new FakoliException("Failed to load XML data file");
          };
          
          
          $tx = new DataTransaction();
          
          try
          {
               foreach($components as $component)
               {
                    $handler = SerializationManager::$map[$component]['handler'];
                    $xml .= $handler->import($doc, $tx);
               }
               
               $tx->commit();
          }
          catch(Exception $e)
          {
               $tx->rollback();
               throw $e;
          }
     }
     
     function importAll($xml)
     {
          $components = implode(",", array_keys(SerializationManager::$map));
          return $this->import($xml, $components);
     }
     
     static function unserialize($class, $doc, $tx, $save = true)
     {
          global $process;
          trace("== Instantiating $class Records", 3);
          
          // Check to see if there are any list tags for the class present.
          // If not, the class was not serialized in this document, so return
          // without processing. If there is a list tag (even if it is empty)
          // we continue processing. This allows for correct deletion of items
          // as part of the import process.
          
          $lists = $doc->getElementsByTagName($class . "List");
          if ($lists->length == 0) return;
          
          $nodes = $doc->getElementsByTagName($class);
     
          $count = count($nodes);
          
          
          if ($process)
          {
               $process->setProgress("Running", pluralize("Reading $count {$class}", $count), 0);
          }
          
          $objects = array();
          
          $c = 0;
          
          foreach($nodes as $node)
          {
               $object = new $class;
               $object->fromXML($node);
               $objects[] = $object;
               ++$c;
               
               if ($process)
               {
                    $process->setProgress("Running", pluralize("Reading $c of $count {$class}", $count), intval((100*$c)/$count));
               }
               
          }
                    
          if ($save)
          {
               $o = new $class;
               $o->joinTransaction($tx);
               $o->deleteAll();
               
               $c = 0;
               
               foreach($objects as $object)
               {
                    $object->_disablePK = true;
                    $object->joinTransaction($tx);
                    $object->save();
                    ++$c;
                    if ($process)
                    {
                         $process->setProgress("Running", pluralize("Imported $c of $count {$class}", $count), intval((100*$c)/$count));
                    }
               }
          }
          
          return $objects;
     }
     
     
     static function store($class, $doc, $tx)
     {
          global $process;
          trace("== Instantiating $class Records", 3);
          
          // Check to see if there are any list tags for the class present.
          // If not, the class was not serialized in this document, so return
          // without processing. If there is a list tag (even if it is empty)
          // we continue processing. This allows for correct deletion of items
          // as part of the import process.
          
          $lists = $doc->getElementsByTagName($class . "List");
          if ($lists->length == 0) return;
          
          $nodes = $doc->getElementsByTagName($class);
          
          $count = count($nodes);  
          
          if ($process)
          {
               $process->setProgress("Running", pluralize("Reading $count {$class}", $count), 0);
          }
          
          $objects = array();
          
          $c = 0;
          
          $object = new $class;
          
          foreach($nodes as $node)
          {
               $object->fromXML($node);
               $object->_disablePK = true;
               $object->joinTransaction($tx);
               $object->save();
               ++$c;
               if ($process)
               {
                    $process->setProgress("Running", pluralize("Imported $c of $count {$class}", $count), intval((100*$c)/$count));
               }
          }         
     }
     
     static function serialize($class, $constraint = "")
     {
          $objects = IteratedQuery::create($class, $constraint)->execute();
          return toXML($class."List", $objects, "");
     }
     
}
 
class SerializationForm
{
     var $mgr;
     var $mode;
     var $action;
     
     function SerializationForm($mode, $action = "")
     {
          $this->mode = $mode;
          $this->action = $action;
          $this->mgr = new SerializationManager();
     }
     
     function getSelected()
     {
          global $_POST;
          return implode(",", $_POST["content_type"]);
     }
     
     function writeScript()
     {
     }
     
     function drawForm()
     {
          global $config;
          
          if ($this->mode == "Import")
          {
               $onsubmit = " onsubmit=\"return confirm('WARNING! Importing site content WILL overwrite existing content in your database.\\nThis CANNOT be undone.\\nDo you wish to continue?');\"";
          }
          
?>
     <form method="POST" action="<?echo $this->action?>" enctype="multipart/form-data"<?echo $onsubmit?>>
<?
          foreach(SerializationManager::$map as $component => $handler)
          {
?>
     <input type="checkbox" value="<?echo $component?>" name="content_type[]"/>&nbsp;<?echo $handler['title'];?><br/>
<?
          }
?>
     <br/>
<?
          if ($this->mode == "Import")
          {
?>
     <label for="import_file">Import File </label><input type="file" name="import_file"/><br/><br/>
<?
          }
          else
          {
               $file = codify($config["sitename"]."_".date("Ymd")).".xml";
?>
     <label for="export_file">Export File Name </label><input type="text" size="50" name="export_file" value="<?echo $file?>"/><br/><br/>
<?
          }    
?>
     <input type="submit" class="button" value="<?echo $this->mode?> Configuration"/>
     </form>
<?
     }
}
 
class SimpleSerializationHandler
{
     var $class;
     var $constraint;
     
     function __construct($class, $constraint = "")
     {
          $this->class = $class;
          
          if ($constraint)
          {
               $this->constraint = $constraint;
          }
          else
          {
               $obj = new $class;
               $this->constraint = "ORDER BY ".$obj->getPrimaryKey();
          }
     }
     
     function export()
     {
          return SerializationManager::serialize($this->class, $this->constraint);
     }
     
     function import($doc, $tx)
     {
          global $process;
          SerializationManager::unserialize($this->class, $doc, $tx);
          if ($process)
          {
               $process->setProgress("Completed", "Import successful", 100);
          }
     }         
}
 
class CompoundSerializationHandler
{
     var $groupTag;
     var $classes = array();
     var $constraints = array();
     
     function __construct($groupTag)
     {
          if (!$groupTag)
          {
               throw new FakoliException("No group tag specified for compound serialization handler");
          }
          
          $this->groupTag = $groupTag;
          for($i = 1; $i < func_num_args(); ++$i)
          {
               $arg = func_get_arg($i);
               if (is_array($arg))
               {
                    $this->classes[] = $arg;
               }
               else
               {
                    $this->classes[] = array($arg, "");
               }
          }
     }
 
     function addTarget($class, $constraint = "")
     {
          $this->classes[] = array($class, $constraint);
     }
     
     function export()
     {
          $xml  = "\n<{$this->groupTag}>";
          foreach($this->classes as $class)
          {
               $xml.= SerializationManager::serialize($class[0], $class[1]);
          }
          
          $xml .= "\n</{$this->groupTag}>";
          return $xml;
     }
 
     function import($doc, $tx)
     {
          global $process;
          
          foreach($this->classes as $class)
          {
               SerializationManager::store($class[0], $doc, $tx);
          }
          
          if ($process)
          {
               $process->setProgress("Completed", "Import successful", 100);
          }
     }
     
     function retrieve($doc, $class)
     {
          return SerializationManager::unserialize($class, $doc, null, false);
     }
}?>