golden hour

/home/phakp/public_html/formtools/global/code

File/Folder	Size	Actions
Accounts.class.php	14.56 KB
Administrator.class.php	32.41 KB
Clients.class.php	19.25 KB
Constants.class.php	51 B
Core.class.php	23.23 KB
CoreFieldTypes.class.php	11.16 KB
Database.class.php	6.34 KB
DatabaseSessions.class.php	3.09 KB
Emails.class.php	60.66 KB
Errors.class.php	4.78 KB
FieldOptions.class.php	1.1 KB
FieldSettings.class.php	1.25 KB
FieldSizes.class.php	2.9 KB
FieldTypes.class.php	61.04 KB
FieldValidation.class.php	11.7 KB
Fields.class.php	57.75 KB
Files.class.php	18.61 KB
Forms.class.php	63.07 KB
General.class.php	47.2 KB
Hooks.class.php	21.66 KB
Installation.class.php	57.45 KB
ListGroups.class.php	2.35 KB
Menus.class.php	36.83 KB
Module.abstract.class.php	8.29 KB
ModuleMenu.class.php	3.84 KB
Modules.class.php	30.52 KB
OmitLists.class.php	2.4 KB
OptionLists.class.php	28.04 KB
Pages.class.php	8.61 KB
Schemas.class.php	814 B
SecureSmarty.class.php	403 B
Sessions.class.php	4.01 KB
Settings.class.php	23.12 KB
Submissions.class.php	70.8 KB
Templates.class.php	6.64 KB
Themes.class.php	14.04 KB
Translations.class.php	3.54 KB
Upgrade.class.php	6.81 KB
User.class.php	14.47 KB
ViewColumns.class.php	3.06 KB
ViewFields.class.php	19.39 KB
ViewFilters.class.php	15.07 KB
ViewTabs.class.php	3.46 KB
Views.class.php	47.25 KB
actions.php	17.92 KB
field_types	-
index.php	35 B
polyfills.php	5.07 KB
validation.php	15.79 KB

Edit: FieldValidation.class.php

<?php

/**
 * FieldValidation.
 */

// -------------------------------------------------------------------------------------------------

namespace FormTools;

use PDO, Exception;

class FieldValidation {

/**
     * Returns all defined validation rules for a field.
     *
     * @param integer $field_id
     */
    public static function get($field_id)
    {
        $db = Core::$db;
        $db->query("
            SELECT *
            FROM   {PREFIX}field_validation fv, {PREFIX}field_type_validation_rules ftvr
            WHERE  fv.field_id = :field_id AND
                ftvr.rule_id = fv.rule_id
        ");
        $db->bind("field_id", $field_id);
        $db->execute();

return $db->fetchAll();
    }

/**
     * Deletes any validation defined for a particular field. This is called on the main Edit Form -> Fields tab, after a
     * field has it's field type changed.
     *
     * @param integer $field_id
     */
    public static function deleteValidation($field_id)
    {
        $db = Core::$db;
        $db->query("DELETE FROM {PREFIX}field_validation WHERE field_id = :field_id");
        $db->bind("field_id", $field_id);
        $db->execute();
    }

public static function getPHPValidationRules($field_ids)
    {
        $db = Core::$db;
        if (empty($field_ids)) {
            return array();
        }

$field_ids = implode(",", $field_ids);
        try {
            $db->query("
                SELECT *
                FROM   {PREFIX}field_validation fv, {PREFIX}field_type_validation_rules ftvr
                WHERE  fv.field_id IN ($field_ids) AND
                       fv.rule_id = ftvr.rule_id AND
                       ftvr.custom_function_required != 'yes'
                ORDER BY fv.field_id, ftvr.list_order
            ");
            $db->execute();
        } catch (Exception $e) {
            Errors::queryError(__CLASS__, __FILE__, __LINE__, $e->getMessage());
            exit;
        }

$rules = array();
        foreach ($db->fetchAll() as $row) {
            $rules[] = $row;
        }

return $rules;
    }

/**
     * Called after a form submission is made, but it fails server-side validation. This merges the original content
     * with whatever is in the POST request.
     *
     * @param array $grouped_fields
     * @param array $request
     */
    public static function mergeFormSubmission($grouped_fields, $request)
    {
        $multi_val_delimiter = Core::getMultiFieldValDelimiter();

$updated_grouped_fields = array();
        foreach ($grouped_fields as $group_info) {
            $group  = $group_info["group"];
            $fields = $group_info["fields"];

$updated_fields = array();
            foreach ($fields as $field_info) {
                if (array_key_exists($field_info["field_name"], $request)) {
                    // TODO! This won't work for phone_number fields, other fields
                    $value = (is_array($request[$field_info["field_name"]])) ? implode($multi_val_delimiter, $request[$field_info["field_name"]]) : $request[$field_info["field_name"]];
                    $field_info["submission_value"] = $value;
                }
                $updated_fields[] = $field_info;
            }

$updated_grouped_fields[] = array(
                "group"  => $group,
                "fields" => $updated_fields
            );
        }

return $updated_grouped_fields;
    }

/**
     * This is the main server-side validation function, called whenever updating a submission. The current version (Core 2.1.9)
     * only performs a subset of the total validation rules; namely, those non-custom ones that
     *
     * @param array $editable_field_ids - this contains ALL editable field IDs in the form
     * @param array $request
     * @return array an array of errors, or an empty array if no errors
     */
    public static function validateSubmission($editable_field_ids, $request)
    {
        if (empty($editable_field_ids)) {
            return array();
        }

// get the validation rules for the current page. The use of $request["field_ids"] is a fix for bug #339; this should be handled
        // a lot better. The calling page (edit_submission.php amongst other) should be figuring out what fields are editable on that particular
        // page and passing THAT info as $editable_field_ids
        $editable_field_ids_on_tab = explode(",", $request["field_ids"]);

// return all validation rules for items on tab, including those marked as editable == "no"
        $rules = FieldValidation::getPHPValidationRules($editable_field_ids_on_tab);

// gets all form fields in this View
        $form_fields = ViewFields::getViewFields($request["view_id"]);

// reorganize $form_fields to be a hash of field_id => array(form_name => "", field_field => "")
        $field_info = array();
        foreach ($form_fields as $curr_field_info) {
            $field_info[$curr_field_info["field_id"]] = array(
                "field_name"  => $curr_field_info["field_name"],
                "field_title" => $curr_field_info["field_title"],
                "is_editable" => $curr_field_info["is_editable"]
            );
        }

// construct the RSV-friendly validation
        $validation = array();
        foreach ($rules as $rule_info) {
            $rule          = $rule_info["rsv_rule"];
            $field_id      = $rule_info["field_id"];
            $field_name    = $field_info[$field_id]["field_name"];
            $field_title   = $field_info[$field_id]["field_title"];
            $error_message = $rule_info["error_message"];

// if this field is marked as non-editable, ignore it. We don't need to validate it
            if ($field_info[$field_id]["is_editable"] == "no") {
                continue;
            }

$placeholders = array(
                "field"      => $field_title,
                "field_name" => $field_name
            );
            $error_message = General::evalSmartyString($error_message, $placeholders);

$validation[] = "$rule,$field_name,$error_message";
        }

$errors = array();
        if (!empty($validation)) {
            $errors = validate_fields($request, $validation);
        }

return $errors;
    }

public static function getFieldTypeValidationRules() {
        Core::$db->query("
            SELECT *
            FROM   {PREFIX}field_type_validation_rules
            ORDER BY field_type_id, list_order
        ");
        Core::$db->execute();
        return Core::$db->fetchAll();
    }

/**
     * Added in 2.1.4 to return all field type validation information.
     *
     * @param $options
     */
    public static function generateFieldTypeValidationJs($options = array())
    {
        // for use in dev work
        $minimize = false;

$delimiter = "\n";
        if ($minimize) {
            $delimiter = "";
        }

$namespace = isset($options["page_ns"]) ? $options["page_ns"] : "page_ns";

$validation_rules = self::getFieldTypeValidationRules();
        $grouped_rules = array();
        foreach ($validation_rules as $row) {
            $field_type_id = $row["field_type_id"];
            if (!array_key_exists($field_type_id, $grouped_rules)) {
                $grouped_rules[$field_type_id] = array();
            }

$grouped_rules[$field_type_id][] = array(
                "rule_id"    => $row["rule_id"],
                "rule_label" => General::evalSmartyString($row["rule_label"]),
                "default_error_message" => General::evalSmartyString($row["default_error_message"])
            );
        }

$curr_js = array("{$namespace}.field_validation = {};");
		foreach ($grouped_rules as $field_type_id => $rules) {
            $curr_js[] = "{$namespace}.field_validation[\"field_type_{$field_type_id}\"] = [";
            $curr_rules = array();
            foreach ($rules as $rule_info) {
                $error = html_entity_decode($rule_info["default_error_message"]);
                $curr_rules[] = "{ rule_id: {$rule_info["rule_id"]}, label: \"{$rule_info["rule_label"]}\", error: \"$error\" }";
            }
            $curr_js[] = implode(",$delimiter", $curr_rules);
            $curr_js[] = "];";
        }

$rows[] = implode("$delimiter", $curr_js);

return implode("$delimiter", $rows);
    }

/**
     * Used on the Edit Submission pages, Form Builder - and anywhere that's actually displaying the fields for editing. This
     * generates the JS used for the RSV validation, according to whatever rules the user has specified.
     *
     * @param array $grouped_fields
     */
    public static function generateSubmissionJsValidation($grouped_fields, $settings = array())
    {
        // overridable settings
        $custom_error_handler     = isset($settings["custom_error_handler"]) ? $settings["custom_error_handler"] : "ms.submit_form";
        $form_element_id          = isset($settings["form_element_id"]) ? $settings["form_element_id"] : "edit_submission_form";
        $omit_non_editable_fields = isset($settings["omit_non_editable_fields"]) ? $settings["omit_non_editable_fields"] : true;

$js_lines = array();
        $custom_func_errors = array();
        foreach ($grouped_fields as $group_info) {
            foreach ($group_info["fields"] as $field_info) {
                if (empty($field_info["validation"])) {
                    continue;
                }
                if ($omit_non_editable_fields && $field_info["is_editable"] == "no") {
                    continue;
                }

$field_name  = $field_info["field_name"];
                $field_title = $field_info["field_title"];
                $field_id    = $field_info["field_id"];

foreach ($field_info["validation"] as $rule_info) {
                    $rsv_rule = $rule_info["rsv_rule"];
                    $placeholders = array(
                        "field"      => $field_title,
                        "field_name" => $field_name
                    );
                    $message = General::evalSmartyString($rule_info["error_message"], $placeholders);

if ($rsv_rule == "function") {
                        $custom_function = $rule_info["custom_function"];
                        $new_rule = "rules.push(\"function,$custom_function\")";
                        if (!in_array($new_rule, $js_lines)) {
                            $js_lines[] = $new_rule;
                        }
                        $custom_func_errors[] = "{field:\"$field_name\",field_id:$field_id,func:\"$custom_function\",err:\"$message\"}";
                    } else {
                        $rsv_field_name = General::evalSmartyString($rule_info["rsv_field_name"], $placeholders);
                        $js_lines[] = "rules.push(\"$rsv_rule,$rsv_field_name,$message\")";
                    }
                }
            }
        }

// kind of a hack, but passable. The RSV custom function string doesn't pass the error string in the rule; so
        // we just store it in a JS object in the page for use by the functions
        if (!empty($custom_func_errors)) {
            $js_lines[] = "var rsv_custom_func_errors = []";
            foreach ($custom_func_errors as $js_obj) {
                $js_lines[] = "rsv_custom_func_errors.push($js_obj)";
            }
        }

$js = "";
        if (!empty($js_lines)) {
            $rules = implode(";\n", $js_lines);
            $custom_error_handler_str = (!empty($custom_error_handler)) ? "rsv.customErrorHandler = $custom_error_handler;" : "";
            $js =<<< END
$(function() {
  $("#{$form_element_id}").bind("submit", function() { return rsv.validate(this, rules); });
  $custom_error_handler_str
});
var rules = [];
$rules
END;
        }

return $js;
    }

}