metadata_field_select_edit_fns.inc

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

class Metadata_Field_Select_Edit_Fns extends Metadata_Field_Edit_Fns
{


    function __construct()
    {
        parent::__construct();

    }//end constructor


    public function paintValueInterface(Metadata_Field_Select $asset, Backend_Outputter $o, $value_str, $write_access, $enable_default=TRUE, $print_cascade_values_option = TRUE)
    {
        $prefix = $asset->getPrefix();
        require_once SQ_LIB_PATH.'/html_form/html_form.inc';

        $value = '';
        $value_components = $asset->attr('value_components');

        $select_options = $asset->getContextedSelectOptions();
        $is_default = FALSE;
        if (is_null($value_str)) {
            $value_str = $asset->getDefaultValue();
            $is_default = TRUE;
        }

        Metadata_Field::decodeValueString($value_str, $value, $value_components);

        if ($asset->attr('multiple')) {
            // if there is no value we need a blank array...not an array with one element (a blank string)
            if ($value == '') {
                $value = Array();
            } else {
                $value = explode('; ', $value);
            }
        }
        // If we're OK to edit, get our selection attribute, and paint it
        if ($write_access) {
            $selection = $asset->getSelectionAttribute();
            $selection->value = $value;
            if ($enable_default) {
                $selection->_edit_params['extras'] = 'onclick="document.getElementById(\''.$prefix.'_default\').checked = false;"';
                if ($is_default) {
                    $selection->_edit_params['extras'] .= ' disabled="disabled"';
                }
                echo '<span id="'.$prefix.'_field">';
            }
            $selection->paint($prefix, FALSE);
            if ($enable_default) echo '</span>';
        } else {
            if (!((is_array($value) && empty($value)) || (is_string($value) && $value == ''))) {
                if (!is_array($value)) $value = Array($value);
                $value_output = '';

                foreach ($value as $option) {
                    if (isset($select_options[$option])) {
                        $value_output .= $select_options[$option].'; ';
                    }
                }
                echo trim($value_output, '; ');
            }
        }

        if ($enable_default) {
            if ($write_access) {
                echo ' &nbsp; &nbsp; &nbsp; ';

                // Work out which options we have to set if we have to
                $i = 0;
                $default_keys = explode('; ', $asset->attr('default'));
                $default_selected = Array();

                $default_vals = Array();
                $non_default_vals = Array();
                foreach ($select_options as $key => $select_option) {
                    if (in_array($key, $default_keys)) {
                        $default_vals[] = "'".addslashes(str_replace(' ', '_', $key))."'";
                    } else {
                        $non_default_vals[] = "'".addslashes(str_replace(' ', '_', $key))."'";
                    }
                }
                $default_vals_expr = '['.implode(', ', $default_vals).']';
                $non_default_vals_expr = '['.implode(', ', $non_default_vals).']';
                check_box($prefix.'_default', '1', $is_default, "handleDefaultClick(this, '$prefix', $default_vals_expr, $non_default_vals_expr); ");
                label(translate('use_default'), $prefix.'_default');
                $o->addJsInclude(sq_web_path('data').'/asset_types/metadata_field_select/js/metadata_field_select.js');
            } else {
                if ($is_default) {
                    echo ' <em style="color: #666">('.strtolower(translate('default')).')</em>';
                }
            }
        }

        if ($write_access && $print_cascade_values_option) {
            echo '&nbsp;&nbsp;&nbsp;&nbsp;';
            check_box($prefix.'_cascade_value', '1', FALSE);
            label(translate('cascade_value'), $prefix.'_cascade_value');
        }

        return $write_access;

    }//end paintValueInterface()


    public function processInlineValueInterface(Metadata_Field_Select $asset, &$new_value_str, &$field_cascade_value)
    {
        if (!$asset->attr('editable')) return FALSE; // nothing for us to do

        $processed = FALSE;

        $prefix = $asset->getPrefix();
        if (!empty($_POST[$prefix.'_default'])) {
            // use default
            $new_value_str = NULL;
            $processed = TRUE;
        } else {
            // Default is not checked, so process our select attribute
            $selection = $asset->getSelectionAttribute();
            $selection->process($prefix);
            if ($selection->processed) {
                // Get the string into proper form for the metadata field function
                $value = str_replace('|', '; ', $selection->value);
                $new_value_str = Metadata_Field::encodeValueString(trim($value), Array());
                $processed = TRUE;
            }
        }

        if (isset($_POST[$prefix.'_cascade_value'])) {
            $field_cascade_value = TRUE;
            $processed = TRUE;
        }

        return $processed;

    }//end processInlineValueInterface()


    public function paintSelection(Metadata_Field_Select $asset, Backend_Outputter $o, $prefix)
    {
        $write_access = $asset->writeAccess('attributes');
        $is_contextable = (boolean)$asset->attr('is_contextable');

        $contextid = $GLOBALS['SQ_SYSTEM']->getContextId();
        $is_default_context = ($contextid === 0) ? TRUE : FALSE;

        if ($is_contextable === TRUE) {
            $select_options = $asset->getContextedSelectOptions();
        } else {
            $select_options = $GLOBALS['SQ_SYSTEM']->am->getAttributeValuesByName('select_options', 'metadata_field_select', Array($asset->id), 0);
            $select_options = unserialize($select_options[$asset->id]);
        }

        if (!empty($select_options)) {
            ?>
            <table class="sq-backend-table">
                <tr>
                    <td class="sq-backend-table-header"><?php echo translate('option_key'); ?></td>
                    <td class="sq-backend-table-header"><?php echo translate('option_value'); ?></td>
                    <?php
                    if (($write_access  === TRUE) && (($is_default_context === TRUE) || ($is_contextable === FALSE))) {
                        ?><td class="sq-backend-table-header"><?php echo translate('delete_question'); ?></td><?php
                    }
                    ?>
                </tr>
                <?php
                $i = 0;
                // Base this on the default values because then any new
                // option not already in a modified context can be set to the
                // default context's value for it

                foreach ($select_options as $option_key => $option_value) {
                    ?>
                    <tr>
                        <td class="sq-backend-table-cell">
                            <?php
                            if ($write_access  === TRUE) {
                                if (($is_default_context === TRUE) || ($is_contextable === FALSE)) {
                                    text_box($prefix.'_options[key]['.$i.']', $option_key, 20);
                                } else {
                                    echo $option_key;
                                    hidden_field($prefix.'_options[key]['.$i.']', $option_key);
                                }
                            } else {
                                echo $option_key;
                            }
                            ?>
                        </td>
                        <td class="sq-backend-table-cell" align="left">
                            <?php
                            if ($write_access) {
                                text_box($prefix.'_options[val]['.$i.']', $option_value, 20);
                            } else {
                                echo $option_value;
                            }
                            ?>
                        </td>
                        <?php
                        if (($write_access  === TRUE) && (($is_default_context === TRUE) || ($is_contextable === FALSE))) {
                            ?>
                            <td class="sq-backend-table-cell">
                                <?php check_box($prefix.'_options[del]['.$i.']', $option_key); ?>
                            </td>
                            <?php
                        }
                        ?>
                    </tr>
                    <?php
                    $i++;
                }//end foreach select_options
                ?>
            </table>
            <?php

        } else {
            echo translate('no_select_box_options');
        }//end if empty

        // now adding two fields for new entry (key => value)
        if (($write_access === TRUE) && (($is_default_context === TRUE) || ($is_contextable === FALSE))) {
            $o->openField(translate('new_option'));
                echo '<b>'.translate('key').'</b> ';
                text_box($prefix.'_new_key','');
                echo ' <b>'.translate('value').'</b> ';
                text_box($prefix.'_new_val','');
            $o->closeField();
        }

        if (!empty($select_options)) {
            // displaying default value if any values were actually saved in the array
            $o->openField(translate('default_value'));
                $selection = $asset->getSelectionAttribute();
                $selection->paint($prefix.'_default', !$write_access);
            $o->closeField();
        }

        return TRUE;

    }//end paintSelection()


    public function processSelection(Metadata_Field_Select $asset, Backend_Outputter $o, $prefix)
    {
        // need to have write access to make any changes
        if (!$asset->writeAccess('attributes')) return FALSE;
        $is_contextable = (boolean)$asset->attr('is_contextable');

        if ($is_contextable === FALSE) {
            // If we are not contextable, we might as well be in the default
            // context... so change to it, and reload our asset
            $GLOBALS['SQ_SYSTEM']->changeContext(0);
            $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($asset->id);
        }

        $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');

        $select_options = Array();
        if (isset($_POST[$prefix.'_options'])) {
            $option_changes = $_POST[$prefix.'_options'];
            foreach ($option_changes['key'] as $i => $key) {
                if (isset($option_changes['del'][$i])) continue;
                $select_options[trim($key)] = trim($option_changes['val'][$i]);
            }
        }

        // now get the new submitted values (if any) and add them to array
        if (array_key_exists($prefix.'_new_key', $_POST) === TRUE) {
            if (strlen(trim($_POST[$prefix.'_new_key']))>0 && strlen(trim($_POST[$prefix.'_new_val']))>0) {
                $new_select_key  = trim($_POST[$prefix.'_new_key']);
                $new_select_val  = trim($_POST[$prefix.'_new_val']);
                $select_options[$new_select_key] = $new_select_val;
            }
        }

        // updating asset attribute value
        $asset->setAttrValue('select_options', $select_options);

        // saving default value
        $new_default = '';
        if (!empty($select_options) && isset($_POST[$prefix.'_default'])) {
            $new_default = $_POST[$prefix.'_default'];
            if (is_array($new_default)) {
                $new_default = implode('; ', $new_default);
            }
        }
        if (!$asset->attr('multiple')) {
            if (!isset($select_options[$new_default])) {
                $new_default = '';
            }
        }
        $asset->setAttrValue('default', $new_default);
        if ($asset->saveAttributes() === TRUE) {
            $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        } else {
            $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
        }

        if ($is_contextable === FALSE) {
            // If we are not contextable, we might as well be in the default
            // context... so change to it, and reload our asset
            $GLOBALS['SQ_SYSTEM']->restoreContext();
            $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($asset->id);
        }

        // Don't require our own saving of attributes
        return FALSE;

    }//end processSelection()


    public function paintEditParams(Metadata_Field_Select $asset, Backend_Outputter $o, $prefix)
    {
        $selection = $asset->getSelectionAttribute();
        $selection->paintEditParams($prefix.'_style', $asset->writeAccess('attributes'));

    }//end paintEditParams()


    public function processEditParams(Metadata_Field_Select $asset, Backend_Outputter $o, $prefix)
    {
        if (!$asset->writeAccess('attributes')) return FALSE;

        $selection = $asset->getSelectionAttribute();
        $edit_params = $selection->processEditParams($prefix.'_style');
        return $asset->setAttrValue('edit_params', $edit_params);

    }//end processEditParams()


    public function generateMetadata(Metadata_Field_Select $asset, $value_str, &$tag_value, Array &$keywords)
    {
        if (is_null($value_str)) {
            $value_str = Metadata_Field::encodeValueString($asset->attr('default'), Array());
        }

        // If we are showing the value, then go fetch it
        if ($asset->attr('visible_part') === 'value') {
            $value_str = $asset->getValueFromKey($value_str);
        }

        return parent::generateMetadata($asset, $value_str, $tag_value, $keywords);

    }//end generateMetadata()


    public function paintOptionUpload(Metadata_Field_Select $asset, Backend_Outputter $o, $prefix)
    {
        $write_access = $asset->writeAccess();
        file_upload($prefix.'_option_upload');
        return $write_access;

    }//end paintOptionUpload()


    public function paintOptionUploadHeader(Metadata_Field_Select $asset, Backend_Outputter $o, $prefix)
    {
        $write_access = $asset->writeAccess();
        check_box($prefix.'_csv_header', '1');
        return $write_access;

    }//end paintOptionUploadHeader()


    public function processOptionUpload(Metadata_Field_Select $asset, Backend_Outputter $o, $prefix)
    {
        if (isset($_FILES[$prefix.'_option_upload'])) {
            $file = $_FILES[$prefix.'_option_upload'];

            $header = FALSE;
            if (isset($_POST[$prefix.'_csv_header'])) {
                $header = TRUE;
            }

            if ($file['error'] === UPLOAD_ERR_OK) {
                $asset->importOptionsFromCSV($file['tmp_name'], $header);
            }
        }

    }//end processOptionUpload()


}//end class

?>