Knowledge Base

update_field()

Description

Updates resource field. Works out the previous value, so this is
not efficient if we already know what this previous value is (hence
it is not used for edit where multiple fields are saved)

Parameters

Column	Type	Default	Description
$resource	integer		Resource ID
$field	integer		Field ID
$value	string		The new value
&$errors	array	array	Any errors that may occur during update
$log	boolean	true	Log this change in the resource log?
$nodevalues	boolean	false	Set to TRUE to process the value as a comma separated list of node IDs

Return

boolean

Location

include/resource_functions.php lines 2587 to 2993

Definition

 
function update_field($resource, $field, $value, array &$errors = array(), $log=true, $nodevalues=false)
    {
    global $category_tree_add_parents, $userref, $FIXED_LIST_FIELD_TYPES, $lang;

    $resource_data = get_resource_data($resource);
    if ($resource_data === false)
        {
        $errors[] = $lang["resourcenotfound"] . " " . (string) $resource;
        return false;
        }
    if ($resource_data["lock_user"] > 0 && $resource_data["lock_user"] != $userref)
        {
        $errors[] = get_resource_lock_message($resource_data["lock_user"]);
        return false;
        }

    // accept shortnames in addition to field refs
    if(!is_int_loose($field))
        {
        $field = ps_value("SELECT ref AS `value` FROM resource_type_field WHERE name = ?", ["s",$field], '', "schema");
        }

    // Fetch some information about the field
    $fieldinfo = get_resource_type_field($field);

    if(!$fieldinfo)
        {
        $errors[] = "No field information about field ID '{$field}'";
        return false;
        }

    if ($fieldinfo["global"]==0 && !in_array($resource_data['resource_type'],ps_array("SELECT resource_type value FROM resource_type_field_resource_type WHERE resource_type_field=?",array("i",$field))))
        {
        $errors[] = "Field is not valid for this resource type";
        return false;
        }

    $value = $data_joins_field_value = trim((string)$value);
    if($value === '' && $fieldinfo['required'])
        {
        $errors[] = i18n_get_translated($fieldinfo['title']) . ": {$lang['requiredfield']}";
        return false;
        }
    
    // Create arrays that will be passed to hook function later
    $newnodes        = [];
    $newvalues       = [];

    if (in_array($fieldinfo['type'], array_merge($FIXED_LIST_FIELD_TYPES,[FIELD_TYPE_DATE_RANGE])))
        {
        // Standard node fields
        // Set up arrays of node ids to add/remove and all new nodes.
        $nodes_to_add    = [];
        $nodes_to_remove = [];

        // Get currently selected nodes for this field
        $current_field_nodes = get_resource_nodes($resource, $field, true);
        $current_field_node_ids = array_column($current_field_nodes,"ref");
        // Get an 'existing' value
        $existing = implode(",",array_column($current_field_nodes,"path"));

        // Get all node values into an array to search, not for dynamic keyword fields as these can be very long
        if ($fieldinfo['type'] != FIELD_TYPE_DYNAMIC_KEYWORDS_LIST) {
            $fieldnodes = get_nodes($field,null,$fieldinfo['type'] == FIELD_TYPE_CATEGORY_TREE);
            $nodes_by_ref = [];
            foreach ($fieldnodes as $fieldnode) {
                $nodes_by_ref[$fieldnode["ref"]] = $fieldnode;
            }
        }

        if($nodevalues)
            {
            // List of node IDs has been passed in comma separated form, use them directly
            $sent_nodes = explode(",",$value);
            if (
                in_array($fieldinfo['type'],[FIELD_TYPE_RADIO_BUTTONS,FIELD_TYPE_DROP_DOWN_LIST])
                && count($sent_nodes) > 1
            ) {
                // Only a single value allowed
                return false;
            }

            // Validate each node
            foreach($sent_nodes as $sent_node) {
                $node_details = [];
                $valid_node = get_node($sent_node,$node_details);
                if (!$valid_node || $node_details["resource_type_field"] !== $field) {
                    return false;
                }
                $nodes_to_add[] = $sent_node;
                if (!in_array($sent_node,$current_field_node_ids)) {
                    $newnodes[] = $sent_node;
                }
            }

            $nodes_to_remove = array_diff($nodes_to_add,$current_field_node_ids);
            if(count($nodes_to_add) != count($sent_nodes)) {
                // Unable to find all node values that were passed
                return false;
                }
            }
        else
            {
            // Not a list of node IDs; value has been passed as normal string value
            // Get all the new values into an array
            if(strpos($value,NODE_NAME_STRING_SEPARATOR) != false)
                {
                $newvalues = array_map('trim', explode(NODE_NAME_STRING_SEPARATOR, $value));
                }
            else
                {
                if (strlen($value) > 0 && (($value[0] == "'" && $value[strlen($value)-1] == "'")
                    ||
                    ($value[0] == "\"" && $value[strlen($value)-1] == "\""))
                    )
                    {
                    // Quoted value - don't attempt to split on comma.
                    $newvalues[] = substr($value,1,-1);
                    }
                else
                    {
                    $newvalues = trim_array(str_getcsv($value));
                    }
                }

            if($fieldinfo['type'] == FIELD_TYPE_DATE_RANGE)
                {
                // Check it is in the correct format
                $rangeregex="/^(\d{4})(-\d{2})?(-\d{2})?\/(\d{4})(-\d{2})?(-\d{2})?/";
                // If this is a date range field we need to add values to the field options
                if(!preg_match($rangeregex,$value,$matches))
                    {
                    debug("ERROR - Invalid date range submitted: '" . $value . "'");
                    return false;
                    }

                $rangedates = array_map('trim', explode('/', $value));
                $rangestart=str_pad($rangedates[0],  10, "-00");
                $rangeendparts=explode("-",$rangedates[1]);
                $rangeendyear=$rangeendparts[0];
                $rangeendmonth=isset($rangeendparts[1])?$rangeendparts[1]:12;
                $rangeendday=isset($rangeendparts[2])?$rangeendparts[2]:cal_days_in_month(CAL_GREGORIAN, $rangeendmonth, $rangeendyear);
                $rangeend=$rangeendyear . "-" . $rangeendmonth . "-" . $rangeendday;   
                
                $current_dates = array_column($fieldnodes,"ref","name");
                $nodes_to_add[] = $current_dates[$rangestart] ?? set_node(null, $fieldinfo["ref"], $rangestart, null, null);
                $nodes_to_add[] = $current_dates[$rangeend] ?? set_node(null, $fieldinfo["ref"], $rangeend, null, null);

                $value = $rangestart . DATE_RANGE_SEPARATOR . $rangeend;
                }
            elseif($fieldinfo['type'] == FIELD_TYPE_CATEGORY_TREE)
                {
                // Create array with indexes as the values to look for
                $nodes_available_keys   = [];         
                foreach($fieldnodes as $fieldnode)
                    {
                    $nodes_available_keys[mb_strtolower($fieldnode["path"])] = $fieldnode["ref"];
                    $nodes_available_keys[mb_strtolower($fieldnode["translated_path"])] = $fieldnode["ref"];
                    $nodes_available_keys[mb_strtolower($fieldnode["name"])] = $fieldnode["ref"];
                    $nodes_available_keys[mb_strtolower($fieldnode["translated_name"])] = $fieldnode["ref"];
                    }                

                $lowernewvalues = array_map('mb_strtolower', $newvalues);
                foreach($lowernewvalues as $newvalue)
                    {
                    $validval = false;
                    // Check if a full node path has been passed
                    if(isset($nodes_available_keys[$newvalue]))
                        {
                        debug("update_field: Found node #" . $newvalue  . " for tree value: '" . trim($newvalue) . "'");
                        $nodes_to_add[] = $nodes_available_keys[$newvalue];
                        $validval = true;
                        }
                    
                    if(!$validval)
                        {
                        // Check for separate name values
                        $splitvalues = array_map('trim', explode('/', $newvalue));
                        foreach($splitvalues as $splitvalue)
                            {
                            # Check if each new value exists in current options list
                            if(isset($nodes_available_keys[$splitvalue]))
                                {
                                debug("update_field: Found node # " . $nodes_available_keys[$splitvalue]  . " for tree value: '" . trim($splitvalue) . "'");
                                $nodes_to_add[] = $nodes_available_keys[$splitvalue];
                                $validval = true;
                                }
                            }
                        }
                    if(!$validval)
                        {
                        // Still not found - invalid option passed
                        debug("update_field: " . $newvalue . " not found: in field tree");
                        return false;
                        }

                    // Add all parent nodes
                    if($category_tree_add_parents)
                        {
                        foreach($nodes_to_add as $node_to_add)
                            {
                            $parent = $nodes_by_ref[$node_to_add]["parent"];
                            while((int)$parent > 0)
                                {
                                if(isset($nodes_by_ref[$parent]))
                                    {
                                    $nodes_to_add[] = $nodes_by_ref[$parent]["ref"];
                                    $parent = $nodes_by_ref[$parent]["parent"];
                                    }
                                else
                                    {
                                    $parent = 0;
                                    }
                                }
                            }
                        }
                    }
                }
            else
                {
                // Check to see other nodes that need to be added
                foreach ($newvalues as $newvalue) {
                    $valuenode = get_node_id($newvalue,$field);
                    if ($valuenode) {
                        // Add to array of nodes, unless it has been added to array already as a parent for a previous node
                        if(!in_array($valuenode, $nodes_to_add)) {
                            $nodes_to_add[] = $valuenode;
                        }
                        if (!in_array($valuenode,$current_field_node_ids)) {
                            $newnodes[] = $valuenode;
                        }
                    } elseif ($fieldinfo['type'] !== FIELD_TYPE_DYNAMIC_KEYWORDS_LIST) {
                        // Check for translated versions and different cases
                        // This is not performed for dynamic keyword fields as there are likely to be too many
                        $matchnode = 0;
                        foreach($fieldnodes as $fieldnode) {
                            if (
                                i18n_get_translated($fieldnode["name"]) == i18n_get_translated($newvalue)
                                && !in_array($fieldnode["ref"], $nodes_to_add)
                            ) {
                                $matchnode = $fieldnode["ref"];
                                break;
                            } elseif (
                                mb_strtolower(i18n_get_translated($fieldnode["name"])) == mb_strtolower(i18n_get_translated($newvalue))
                                && !in_array($fieldnode["ref"], $nodes_to_add)
                            ) {
                                // Check for node with same text in different case
                                $matchnode = $fieldnode["ref"];
                                break;
                            }
                        }
                        if ($matchnode > 0) {
                            if(!in_array($matchnode, $nodes_to_add)) {
                                $nodes_to_add[] = $matchnode;
                            }
                            if (!in_array($matchnode,$current_field_node_ids)) {
                                $newnodes[] = $matchnode;
                            }
                        }
                    } elseif (!checkperm('bdk' . $field)) {
                        // Dynamic keyword, add as new node
                        // Append the option and update the field
                        $newnode            = set_node(null, $field, trim($newvalue), null, null);
                        $nodes_to_add[]     = $newnode;
                        debug("update_field: field option added: '" . trim($newvalue));
                        clear_query_cache("schema");
                    }
                } // End of foreach $newvalue
            }
            $nodes_to_remove = array_diff($current_field_node_ids,$nodes_to_add);
        } // End of $nodevalues test


        // Now carry out the node additions and removals
        if(count($nodes_to_add) > 0 || count($nodes_to_remove) > 0)
            {
            # Work out what nodes need to be added/removed/kept
            $nodes_to_add       = array_unique($nodes_to_add);
            $added_nodes        = array_diff($nodes_to_add,$current_field_node_ids);
            if(in_array($fieldinfo['type'],[FIELD_TYPE_RADIO_BUTTONS,FIELD_TYPE_DROP_DOWN_LIST])
                &&
                (count($added_nodes) + count($current_field_node_ids) - count($nodes_to_remove)) > 1)
                {
                // Only a single value allowed
                return false;
                }

            // Update resource_node table and log
            db_begin_transaction("update_field_{$field}");
            if(count($nodes_to_remove)>0)
                {
                delete_resource_nodes($resource,$nodes_to_remove,false);
                }
            if(count($nodes_to_add)>0)
                {
                add_resource_nodes($resource,$nodes_to_add, false,false);
                }

            // Update log
            if($log && (count($nodes_to_add)>0 || count($nodes_to_remove)>0))
                {
                log_node_changes($resource,$nodes_to_add,$current_field_node_ids);
                // Don't need to log this later
                $log = false;
                }

            db_end_transaction("update_field_{$field}");

            if($fieldinfo['type']==FIELD_TYPE_CATEGORY_TREE)
                {
                $all_treenodes = get_cattree_nodes_ordered($field, $resource, false); # True means get all nodes; False means get selected nodes
                $treenodenames = get_cattree_node_strings($all_treenodes, true); # True means names are paths to nodes; False means names are node names
                $value = implode(",",$treenodenames);
                $data_joins_field_value = implode($GLOBALS['field_column_string_separator'], $treenodenames);
                }
            else
                {
                $node_names=[];
                foreach($nodes_to_add as $ref)
                    {
                    $returned_node = [];
                    if(get_node($ref,$returned_node))
                        {
                        $node_names[] = $returned_node["name"];
                        }
                    }
                $value = implode(",",$node_names);
                $data_joins_field_value = implode($GLOBALS['field_column_string_separator'], $node_names);
                }
            } // End of adding/removing nodes
        }
    else
        {
        # Fetch previous value
        $existing_resource_node = get_resource_nodes($resource, $field, true)[0] ?? [];
        $existing = $existing_resource_node["name"] ?? "";
        if ($value === $existing)
            {
            // Nothing to do
            return true;
            }

        if (
            $GLOBALS['use_native_input_for_date_field']
            && $fieldinfo['type'] === FIELD_TYPE_DATE
            && $value !== ''
        ) {
            // Establish whether date is a valid date or a valid date time
            $value_valid_date_part=false;  
            if(validateDatetime($value, 'Y-m-d')) {
                $value_valid_date_part=true;  
            }
            elseif(validateDatetime($value, 'Y-m-d H:i:s')) {
                $value_valid_date_part=true;  
            }
            // Return if there is no valid date part
            if(!$value_valid_date_part) {
                $errors[] = sprintf('%s: %s', i18n_get_translated($fieldinfo['title']), $lang['invalid_date_generic']);
                return false;
            }
            // We only use the valid date part, so discard the time part if any
            if($value_valid_date_part) {
                $value_parts=explode(" ",$value);
                $value=$value_parts[0];
            }
        }

        $curnode = $existing_resource_node["ref"] ?? 0 ;
        if ($curnode > 0 && get_nodes_use_count([$curnode]) == 1)
            {
            // Reuse same node
            set_node($curnode,$field,$value,null,0);
            }
        else
            {
            // Remove node from resource and create new node
            delete_resource_nodes($resource,[$curnode],false);
            $savenode = set_node(null,$field,$value,null,0);
            add_resource_nodes($resource,[$savenode], true, false);
            }
        }

    # If this is a 'joined' field we need to add it to the resource column
    $joins = get_resource_table_joins();
    if(in_array($fieldinfo['ref'],$joins))
        {
        update_resource_field_column($resource,$field, $data_joins_field_value);
        }

    # Add any onchange code
    if($fieldinfo["onchange_macro"]!="")
        {
        $macro_resource_id=$resource;
        eval(eval_check_signed($fieldinfo["onchange_macro"]));
        }

    # Allow plugins to perform additional actions.
    // Log this update
    if ($log && $value != $existing)
        {
        resource_log($resource,LOG_CODE_EDITED,$field,"",$existing,unescape($value));
        }

    # Allow plugins to perform additional actions.
    hook("update_field","",array($resource,$field,$value,$existing,$fieldinfo,$newnodes,$newvalues));
    return true;
    }


This article was last updated 18th May 2024 21:35 Europe/London time based on the source file dated 17th May 2024 18:10 Europe/London time.