metadata_field_select.inc

<?php
require_once dirname(__FILE__).'/../../metadata_field/metadata_field.inc';
require_once SQ_FUDGE_PATH.'/csv/csv.inc';


class Metadata_Field_Select extends Metadata_Field
{


    function __construct($assetid=0)
    {
        parent::__construct($assetid);

    }//end constructor


    public function setAttrValue($name, $value)
    {
        if ($name === 'select_options') {
            $this->_clearContextedSelectOptionsCache();
        }
        return parent::setAttrValue($name, $value);

    }//end setAttrValue()


    public function getSelectionAttribute()
    {
        require_once SQ_ATTRIBUTES_PATH.'/selection/selection.inc';

        $selection = new Asset_Attribute_Selection();
        $edit_params = $this->attr('edit_params');
        if (!empty($edit_params)) {
            $selection->_edit_params = array_merge($selection->_edit_params, $edit_params);
        }

        $selection->_params['options'] = $this->getContextedSelectOptions();
        $selection->_params['multiple'] = $this->attr('multiple');
        $selection->_params['allow_empty'] = $this->attr('allow_empty');

        $default = $this->attr('default');
        if ($this->attr('multiple')) {
            $default = explode('; ', $default);
        }
        if ($selection->validateValue($default)) {
            $selection->setValue($default);
        }

        return $selection;

    }//end getSelectionAttribute()


    public function getMetadataValue(Asset $asset, $value_str)
    {
        // If we are showing the value, then pass it up
        if ($this->attr('visible_part') === 'value') {
            $value_str = $this->getValueFromKey($value_str);
        }
        return str_replace('\\;', ';', parent::getMetadataValue($asset, $value_str));

    }//end getMetadataValue()


    public function getValueFromKey($option_str)
    {
        $option_keys = explode('\\; ', $option_str);
        if (empty($option_keys)) {
            return $option_str;
        }

        $value_str = '';
        $options = $this->getContextedSelectOptions();

        foreach ($option_keys as $key) {
            $key = str_replace('\\;', ';', $key);
            $key = str_replace('\\=', '=', $key);
            $key = str_replace('\\\\', '\\', $key);
            if (isset($options[$key])) {
                $value_str .= $options[$key].'; ';
            }
        }
        if (strlen($value_str) == 0) {
            // no corresponding values found
            return $option_str;
        }

        // trim the last separator
        $value_str = substr($value_str, 0, -2);
        $value_str = Metadata_Field::encodeValueString($value_str, Array());

        return $value_str;

    }//end getValueFromKey()


    public function getContextedSelectOptions()
    {
        // Create the cache array if it doesn't exist yet
        if (array_key_exists('cached_select_options', $this->_tmp) === FALSE) {
            $this->_tmp['cached_select_options'] = Array();
        }

        $contextid = $GLOBALS['SQ_SYSTEM']->getContextId();

        if ($contextid === 0) {
            // Don't really need to cache the select options in the default
            // context, because it is it's our own law to itself
            return $this->attr('select_options');
        } else {
            // Alternate context
            if (array_key_exists($contextid, $this->_tmp['cached_select_options']) === FALSE) {
                // Get the base
                $select_options = $this->attr('select_options');

                // Get ourselves in default context form, and get the current
                // default keys and values
                $default_options = $GLOBALS['SQ_SYSTEM']->am->getAttributeValuesByName('select_options', 'metadata_field_select', Array($this->id), 0);
                $default_options = unserialize($default_options[$this->id]);

                // Banish any keys that don't exist in the default version
                foreach ($select_options as $select_key => $select_value) {
                    if (array_key_exists($select_key, $default_options) === FALSE) {
                        unset($select_options[$select_key]);
                    }
                }

                // Add any keys that don't exist in the contexted version,
                // with the value added from the default context
                foreach ($default_options as $default_key => &$default_value) {
                    if (array_key_exists($default_key, $select_options) === FALSE) {
                        $select_options[$default_key] = $default_value;
                    }
                }

                $this->_tmp['cached_select_options'][$contextid] = $select_options;
            }

            return $this->_tmp['cached_select_options'][$contextid];
        }

    }//end getContextedSelectOptions()


    protected function _clearContextedSelectOptionsCache()
    {
        // Create the cache array if it doesn't exist yet
        if (array_key_exists('cached_select_options', $this->_tmp) === TRUE) {
            $contextid = $GLOBALS['SQ_SYSTEM']->getContextId();

            if ($contextid === 0) {
                $this->_tmp['cached_select_options'] = Array();
            } else {
                if (array_key_exists($contextid, $this->_tmp['cached_select_options']) === TRUE) {
                    unset($this->_tmp['cached_select_options'][$contextid]);
                }
            }
        }

    }//end _clearContextedSelectOptionsCache()


    public function getKeyFromValue($option_str)
    {
        $option_keys = explode('\\; ', $option_str);
        if (empty($option_keys)) return $option_keys;

        $value_str = '';
        $options = $this->attr('select_options');

        foreach ($option_keys as $key) {
            foreach($options as $index => $element) {
                if ($index === $key) {
                    $value_str .= $element.'\\; ';
                }
            }
        }
        if (strlen($value_str) == 0) {
            // no corresponding values found
            return $option_str;
        }

        // trim the last separator
        $value_str = substr($value_str, 0, -3);

        return $value_str;

    }//end getKeyFromValue()


    public function getAdditionalKeywordReplacement($host_assetid, $additional_keyword, $contextid=NULL)
    {
        $replacement = NULL;

        if ($contextid === NULL) {
            $contextid = $GLOBALS['SQ_SYSTEM']->getContextId();
        }

        switch ($additional_keyword) {
            case 'key':
            case 'value':
                // Go directly to the database, and get what it has (which
                // will be the key)
                // We need to narrow the host asset ID where it is because
                // if a default value needs to be used, the custom values table
                // will be all nulls - so we can't narrow by host asset ID by then

                // We need to get custom values from the metadata value table,
                // then default values from the default value table where they
                // don't exist in the custom value table.
                $sql = 'SELECT value FROM '.SQ_TABLE_RUNNING_PREFIX.'ast_mdata_val ';
                $where = 'assetid = :host_assetid AND fieldid = :fieldid AND contextid = :contextid';
                $where = $GLOBALS['SQ_SYSTEM']->constructRollbackWhereClause($where);
                $sql .= $where;

                // Now build the default values query (and sub-query).
                $sub_sql = 'SELECT fieldid, contextid FROM '.SQ_TABLE_RUNNING_PREFIX.'ast_mdata_val WHERE assetid = :host_assetid_1 ';
                $sub_where = $GLOBALS['SQ_SYSTEM']->constructRollbackWhereClause('', 'ast_mdata_val');

                $union_sql = 'SELECT default_val FROM '.SQ_TABLE_RUNNING_PREFIX.'ast_mdata_dflt_val';
                $union_where = '%tuple_keyword%(assetid, contextid) NOT IN ('.$sub_sql.$sub_where.') AND assetid = :fieldid_1 AND contextid = :contextid_1';
                $union_where = $GLOBALS['SQ_SYSTEM']->constructRollbackWhereClause($union_where, 'ast_mdata_dflt_val');

                // Oracle uses '(field, field)' for tuples, PgSQL uses 'ROW(field, field)'.
                if (MatrixDAL::getDbType() === 'oci') {
                    $union_where = str_replace('%tuple_keyword%', '', $union_where);
                } else {
                    $union_where = str_replace('%tuple_keyword%', 'ROW', $union_where);
                }
                $union_sql .= $union_where;
                $sql = '('.$sql.') UNION ALL ('.$union_sql.')';

                // Go go go!
                $bind_vars = Array(
                                'host_assetid'      => (string)$host_assetid,
                                'fieldid'           => (string)$this->id,
                                'contextid'         => (int)$contextid,
                                'host_assetid_1'    => (string)$host_assetid,
                                'fieldid_1'         => (string)$this->id,
                                'contextid_1'       => (int)$contextid,
                             );

                $query = MatrixDAL::preparePdoQuery($sql);
                foreach ($bind_vars as $bind_var => $bind_value) {
                    MatrixDAL::bindValueToPdo($query, $bind_var, $bind_value);
                }

                $key = MatrixDAL::executePdoOne($query);

                // Does the metadata field value (or a default value) exist?
                if ($key !== FALSE) {
                    if ($additional_keyword === 'key') {
                        $replacement = $key;
                    } else if ($additional_keyword === 'value') {
                        // Turn it into a value
                        $replacement = $this->getValueFromKey($key);
                    }
                }

            break;

        }//end switch
        
        if (is_null($replacement)){
            return $replacement;
        } else {
            $value='';
            $value_components = $this->attr('value_components');
            $this->decodeValueString($replacement, $value, $value_components);
            return $value;
        }

    }//end getAdditionalKeywordReplacement()


    public function importOptionsFromCSV($filename, $header=FALSE)
    {
        $csv = new CSV($filename);

        $start_line = 1;
        if ($header == TRUE) {
            $start_line = 2;
        }
        $csv->import($start_line);

        $values = $csv->values;
        $options = Array();
        $defaults = Array();

        if (!empty($values)) {
            // We will assume that the number of columns in the first row
            // is representative of the entire list
            $num_columns = count($values[0]);
            $index = 0;

            foreach ($values as $row) {
                // if the very first bit for us is not populated
                if (trim($row[0]) === '') continue;
                if ($num_columns === 1) {
                    // If we haven't provided a first column, then key and value
                    // are the same
                    $value = htmlentities($row[0], ENT_NOQUOTES, SQ_CONF_DEFAULT_CHARACTER_SET);
                    $options[$index] = $value;
                    $index++;
                } else {
                    $key = htmlentities($row[0], ENT_NOQUOTES, SQ_CONF_DEFAULT_CHARACTER_SET);
                    $value = htmlentities($row[1], ENT_NOQUOTES, SQ_CONF_DEFAULT_CHARACTER_SET);
                    $options[$key] = $value;

                    if ($num_columns === 3) {
                        if ($row[2] == 1) {
                            $defaults[] = $key;
                        }
                    }
                }
            }

            $this->setAttrValue('select_options', $options);
            if ($num_columns === 3) {
                if (!$this->attr('multiple')) {
                    if (count($defaults) > 1) {
                        trigger_localised_error('CORE0309', E_USER_NOTICE);
                    }
                    if (count($defaults) > 0) {
                        $defaults = Array($defaults[0]);
                    } else {
                        $defaults = Array();
                    }
                }

                $this->setAttrValue('default', implode('; ', $defaults));
            } else {
                // What happens if it gets overwritten?
                $current_default = $this->attr('default');
                if (!is_array($current_default)) {
                    $current_default = Array($current_default);
                }
                foreach ($current_default as $default_key) {
                    // Remove any default options that are not choices in this
                    // particular situation
                    if (!isset($options[$default_key])) {
                        unset($current_default[$default_key]);
                    }
                }
                $this->setAttrValue('default', implode('; ', $current_default));
            }
            $this->saveAttributes();
        }

    }//end importOptionsFromCSV()


}//end class

?>