import.inc

<?php
require_once SQ_FUDGE_PATH.'/general/file_system.inc';

function get_import_actions($import_file)
{
    // parse the import XML file
    if (!is_file($import_file)) {
        trigger_error('Import file "'.$import_file.'" does not exist', E_USER_ERROR);
    }

    // bug fix #5410 "Import Assets from XML Tool" running out of memory
    // if we are on command line then dont worry about memory exhaustion
    // issue do the whole XML file altogether if the request is coming from
    // the web interface as mentioned on the bug report then execute the
    // code block in else statment
    if ((php_sapi_name() == 'cli')) {
        $index              = Array();
        $xml_import_vals    = Array();
        $import_actions     = Array();
        $p                  = xml_parser_create();

        xml_parser_set_option($p, XML_OPTION_CASE_FOLDING, 0);
        xml_parser_set_option($p, XML_OPTION_SKIP_WHITE, 1);

        $xml_file = file_to_string($import_file);
        xml_parse_into_struct($p, $xml_file, $xml_import_vals, $index);

        // print an error if one occured
        if ($error_code = xml_get_error_code($p)) {
            echo 'XML Error: '.xml_error_string($error_code).' Line:'.xml_get_current_line_number($p).' Col:'.xml_get_current_column_number($p)."\n";
            exit();
        }

        reset($xml_import_vals);
        populate_import_action_array($import_actions, $xml_import_vals);

    } else {
        // get few actions at a time from the XML so that while perforing
        // populate_import_action_array() on it we dont run out of memory
        $actions = Array();
        $import_actions = Array();
        $fh = fopen($import_file, 'r');
        $old_exec_time = ini_get('max_execution_time');
        // set higher execution time to allow matrix
        // to read from the xml that might be quiet big
        set_time_limit (200);
        $xml_header = '';
        while(!feof($fh)) {
            $p  = xml_parser_create();
            xml_parser_set_option($p, XML_OPTION_CASE_FOLDING, 0);
            xml_parser_set_option($p, XML_OPTION_SKIP_WHITE, 1);

            $xml_import_vals = Array();
            $chunk_import_action = Array();
            $index = Array();
            $content = '<actions>';
            $count = 0;

            // make Matrix read atleast 500 lines and the last line read must
            // always be end tag </action> so that the xml constructed is valid
            do {
                if (!($line = fgets($fh, 9999))) break;

                // skip the xml declaration and the starting tag for <actions>
                // but if we are on the </actions> that means we are done with file
                // break out or else there will be a infinite looping in this do...while
                if (trim($line) == '') continue;
                if (preg_match('/(<actions>)$/', trim($line))) continue;
                if (preg_match('/(^<\?xml version)/', trim($line))) {
                    $xml_header = $line;
                    continue;
                }
                if (preg_match('/(<\/actions>)$/', trim($line))) break;

                $content = $content.$line;
                $count++;
            } while (!preg_match('/(<\/action>)$/', $content) || $count < 500);
            $content .= '</actions>';

            if ($content != '<actions></actions>') {
                if ($xml_header != '') $content = $xml_header.$content;
                xml_parse_into_struct($p, $content, $xml_import_vals, $index);

                // print an error if one occured
                if ($error_code = xml_get_error_code($p)) {
                    echo 'XML Error: '.xml_error_string($error_code).' Line:'.xml_get_current_line_number($p).' Col:'.xml_get_current_column_number($p)."\n";
                    exit();
                }
            }
            xml_parser_free($p);

            reset($xml_import_vals);
            populate_import_action_array($chunk_import_action, $xml_import_vals);
            if (!empty($chunk_import_action)) $actions = array_merge($actions, $chunk_import_action['actions'][0]['action']);
        }

        // restore the original max execution time
        set_time_limit($old_exec_time);
        $import_actions['actions'][0]['action'] = $actions;
    }

    return $import_actions;

}//end get_import_actions()


function populate_import_action_array(&$store, &$vals)
{
    for (current($vals); NULL !== ($k = key($vals)); next($vals)) {
        $data  = $vals[$k];
        $value = array_get_index($data, 'value', '');
        $tag   = array_get_index($data, 'tag', '');

        switch ($data['type']) {
            case 'complete' : // FOUND A LEAF NODE

                if (isset($store[$tag])) {
                    $max = count($store[$tag]);
                    if (isset($data['attributes']) && count($data['attributes'])) {
                        foreach ($data['attributes'] as $n => $v) {
                            $store[$tag][$max][$n] = $v;
                        }
                    }
                    $store[$tag][$max]['_value'] = $value;
                } else {
                    if (isset($data['attributes']) && count($data['attributes'])) {
                        foreach ($data['attributes'] as $n => $v) {
                            $store[$tag][0][$n] = $v;
                        }
                        $store[$tag][0]['_value'] = $value;
                    } else {
                        $store[$tag][0] = $value;
                    }
                }

            break;

            case 'open' : // OPENING A NEW TAG

                // call next here or it will never be called
                next($vals);

                if (!isset($store[$tag]) || !sizeof($store[$tag])) {
                    $store[$tag] = Array();
                }

                $max = count($store[$tag]);
                if (isset($data['attributes']) && count($data['attributes'])) {
                    foreach ($data['attributes'] as $n => $v) {
                        $store[$tag][$max][$n] = $v;
                    }
                }
                populate_import_action_array($store[$tag][$max], $vals);

            break;

            case 'close' : // CLOSING THE OPENED TAG

                // we return from the function here so
                // we will end up one level up (ie. just after
                // the populate_import_action_array fn call in the open case).
                return;

            break;
        }//end switch

    }//end for

}//end populate_import_action_array()


function execute_import_action($action, &$outputs, $input_values=array())
{
    $settings = Array();
    $state = Array();

    $action_class = 'trigger_action_'.$action['action_type'][0];
    $GLOBALS['SQ_SYSTEM']->am->includeAsset($action_class);

    // we call execute as a static method, but instantiate for method_exists
    $class_instance = new $action_class;

    // gather settings required for the action
    foreach ($action as $key => $value) {
        // skip action metadata
        if ($key == 'action_id') continue;
        if ($key == 'action_type') continue;

        $value = get_import_action_input_value($action, $key, $outputs, $input_values);

        if (strtolower(SQ_CONF_DEFAULT_CHARACTER_SET) != 'utf-8') {
            $pattern = '/((&#[0-9]*;))/';
            preg_match_all($pattern, $value, $matches);

            $matches = $matches[0];
            $replacement = Array();

            foreach ($matches as $match) {
                $str = str_replace('&#', '', $match);
                $str= intval(str_replace(';', '', $str));
                if ($str > 126 && $str < 256) {
                    $new_value = chr($str);
                } else {
                    $new_value = $match;
                }
                $replacement[] = $new_value;
            }
            $value = str_replace($matches, $replacement, $value);
            $value = preg_replace('|<br/>|', chr(13), $value);
        }

        if ($key == 'asset') {
            // this is a special case where the value populates
            // the state array for the trigger action so it knows what
            // asset to perform the action on (if any)
            $state['assetid'] = $value;
            continue;
        }

        $function_name = 'addSetting'.ucfirst($key);

        if (method_exists($class_instance, $function_name)) {
            eval('$settings = '.$action_class.'::'.$function_name.'($value, $settings);');
            continue;
        }

        $settings[$key] = $value;

    }

    eval('$output = '.$action_class.'::execute($settings, $state);');
    if ($output === FALSE) return FALSE;

    $outputs[$action['action_id'][0]] = $output;

    if ($action_class == 'trigger_action_set_attribute_value' && isset($output['attribute']) && $output['attribute'] == 'varieties'){
        if (isset($output['assetid'])) {
            $image = $GLOBALS['SQ_SYSTEM']->am->getAsset($output['assetid']);
            if ($image && $image->type() == 'image'){
                $edit_fns = $image->getEditFns();
                $edit_fns->_recreateVarietyImages($image);
                $GLOBALS['SQ_SYSTEM']->am->forgetAsset($image);
            }
        }
    }

    if ($action_class == 'trigger_action_create_asset' && isset($output['assetid'])) {
        // lets see if the asset we just imported is a design_customisation..
        $asset_imported = $GLOBALS['SQ_SYSTEM']->am->getAsset($output['assetid']);

        // .. and if it was update the design areas under it
        if ($asset_imported && $asset_imported->type() == 'design_customisation') {
            $parent_design = $asset_imported->getParentDesign();
            $asset_imported->updateFromParent($parent_design);
            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($parent_design);

        } else if ($asset_imported && strpos($asset_imported->type(), 'design_area') !== FALSE) {
            // okie we just imported a design_area, we know its parent is design_customisation because
            // a regular design's design_areas are created out of our parse file
            // in this case we need to find the design_customisation first
            // and then update it w.r.t its parent Design
            $design_customisation = $GLOBALS['SQ_SYSTEM']->am->getAsset($settings['parentid'], 'design_customisation', TRUE);
            if ($design_customisation) {
                $parent_design = $design_customisation->getParentDesign();

                $custom_da_links = $design_customisation->getDesignAreaLink();
                $data = Array();

                // get all the design_area on our customisations, and remove the ones that are
                // already 'customised' by out customisation
                foreach ($custom_da_links as $custom_da_link) {
                    $parent_da = $parent_design->getDesignAreaLink($custom_da_link['value']);
                    if (empty($parent_da)) continue;

                    $data[$custom_da_link['value']] = Array($custom_da_link['minorid'], $custom_da_link['minor_type_code']);
                }
                $design_customisation_edit_fns = $design_customisation->getEditFns();

                if ($data && !$design_customisation_edit_fns->_updateDesignAreaLink($design_customisation, $data)) {
                    $design_customisation->updateFromParent($parent_design);
                }

                $GLOBALS['SQ_SYSTEM']->am->forgetAsset($design_customisation);
                $GLOBALS['SQ_SYSTEM']->am->forgetAsset($parent_design);
            }

        }// end if/else

        $GLOBALS['SQ_SYSTEM']->am->forgetAsset($asset_imported);

    }//end if (trigger_action_create_asset)

    return TRUE;

}//end execute_import_action()


function get_import_action_input_value($action, $attribute, $outputs=Array(), $input_values=array())
{
    // first make sure the attribute exists for this action
    if (!isset($action[$attribute])) {
        trigger_error('Failed getting '.$attribute.' for '.$action['action_type'][0].' action "'.$action['action_id'][0].'" - attribute is not defined for action', E_USER_ERROR);
    } else {
        $value = $action[$attribute][0];
    }

    if (isset($input_values[(string)$value]) === true) return $input_values[$value];

    // loop until there are no more changes
    do {
        $current_value = $value;

        // if the value is an array, just return it
        if (is_array($value)) return $value;
        $matches = Array();
        preg_match_all('|\[\[output://([^\]]+)\]\]|', $value, $matches);
        foreach ($matches[0] as $key => $match) {
            list($action_id, $output) = explode('.', $matches[1][$key], 2);
            if (!isset($outputs[$action_id])) {
                trigger_error('Failed getting '.$attribute.' for '.$action['action_type'][0].' action "'.$action['action_id'][0].'" - attribute references action "'.$action_id.'" that has not yet been run', E_USER_ERROR);
            }
            if (!isset($outputs[$action_id][$output])) {
                trigger_error('Failed getting '.$attribute.' for '.$action['action_type'][0].' action "'.$action['action_id'][0].'" - attribute references action output "'.$output.'" that was not generated by action "'.$action_id.'"', E_USER_ERROR);
            }
            $value = str_replace($match, $outputs[$action_id][$output], $value);
        }

        $matches = Array();
        preg_match_all('|\[\[system://([^\]]+)\]\]|', $value, $matches);
        foreach ($matches[0] as $key => $match) {
            $system_asset = substr($match, 11, -2);
            $assetid = $GLOBALS['SQ_SYSTEM']->am->getSystemAssetid($system_asset);
            if (!$assetid) {
                trigger_error('Failed getting system asset "'.$system_asset.'"', E_USER_ERROR);
            }
            $value = str_replace($match, $assetid, $value);
        }

        $matches = Array();
        preg_match_all('|\[\[conf://([^\]]+)\]\]|', $value, $matches);
        $orig = (isset($matches[0][0]) ? $matches[0][0] : '');
        foreach ($matches[1] as $key => $match) {
            eval('$conf_value = SQ_CONF_'.strtoupper($match).';');
            if ($match == 'system_root_urls') {
                $tmp = explode("\n", $conf_value);
                $conf_value = $tmp[0];
            }
            $value = str_replace($orig, $conf_value, $value);
        }

        $matches = Array();
        preg_match_all('|\[\[dal://([^\]_]+)_([^\]]+)\]\]|', $value, $matches);
        if (!empty($matches[1]) && !empty($matches[2])) {
            include SQ_DATA_PATH.'/private/conf/db.inc';
            if (isset($db_conf[$matches[1][0]])) {
                // DB name is correct
                $dsn = $db_conf[$matches[1][0]];
                // 'db' connection can be configured with multiple DSNs. But we only get the first DSN in the list for now.
                if (($matches[1][0] == 'db') && !isset($dsn['DSN']) && isset($dsn[0])) {
                    $dsn = $dsn[0];
                }
                if (isset($dsn[$matches[2][0]])) {
                    // DSN section name is correct
                    $value = $dsn[$matches[2][0]];
                }
            }
        }

        // construct-specific calls - will not work on a regular import
        $matches = Array();
        preg_match_all('|\[\[construct://([^\]]+)\]\]|', $value, $matches);
        for ($ii = 0; $ii < count($matches[0]); $ii++) {
            $construct_value = '';
            switch ($matches[1][$ii]) {
                case 'unit_test_path':
                    $construct_value = (defined('TC_CONF_UNIT_TEST_PATH') ? TC_CONF_UNIT_TEST_PATH : '');
                break;
                case 'construct_path':
                    $construct_value = (defined('TC_CONF_CONSTRUCT_PATH') ? TC_CONF_CONSTRUCT_PATH : '');
                break;
                case 'simpletest_path':
                    $construct_value = (defined('TC_CONF_SIMPLETEST_PATH') ? TC_CONF_SIMPLETEST_PATH : '');
                break;
                case 'matrix_url':
                    $construct_value = (defined('TC_CONF_MATRIX_URL') ? strip_url(TC_CONF_MATRIX_URL, TRUE): '');
                break;
                case 'time':
                    $construct_value = time();
                break;
            }
            $value = str_replace($matches[0][$ii], $construct_value, $value);
        }

    } while ($current_value != $value);

    return $value;

}//end get_import_action_input_value()


function print_import_action_output_as_xml($action_id, $outputs, $indent='')
{
    echo "$indent<output>\n";
    echo "$indent\t<action_id>$action_id</action_id>\n";
    foreach ($outputs as $key => $value) {
        echo "$indent\t<$key>$value</$key>\n";
    }
    echo "$indent</output>\n";

}//end print_import_action_output_as_xml()


?>