dms_imp_val.i

<?php
  /**
   *
   *
   *
   */

   /**
    * Used by HCU_FilterInput to search in POST/GET superglobals
    */
   define("HCUFILTER_REQUEST", "REQUEST");
   /**
    * Used by HCU_FilterInput to search in 'ENV' superglobal
    */
   define("HCUFILTER_ENV", "ENV");
   /**
    * Used by HCU_FilterInput to simply filter the value using filter_var
    */
   define("HCUFILTER_VAR", "VAR");
   /**
    * Used by HCU_FilterInput to search in 'COOKIE' superglobal
    */
   define("HCUFILTER_COOKIE", "COOKIE");
   /**
    * Used by HCU_FilterInput to search in 'SERVER' superglobal
    */
   define("HCUFILTER_SERVER", "SERVER");
   /**
    * HomeCU - Filter Input to be ONLY digits 0-9
    */
   define("HCUFILTER_INPUT_DIGITS", "digits");
   /**
    * HomeCU - Filter Input to be ONLY STRING (nothing is sanitized for this type to prevent lost characters)
    * For legacy this alone doesn't specify the type of data being imported
    */
   define("HCUFILTER_INPUT_STRING", "string");
   /**
    * HomeCU - Filter Input to be an array.  This will import all array elements.
    * For legacy this alone doesn't specify the type of data being imported
    */
   define("HCUFILTER_INPUT_ARRAY", "array");



function dms_import($dms_allowed) {
    foreach ($dms_allowed as $key => $type) {
        if (!isset($_REQUEST[$key]) && strpos($type,"prefix_") === false) {
            ${$key} = NULL;
            continue;
        }
    switch ($type) {
        case "digits":
            if (strlen(trim($_REQUEST[$key])) > 0 && ctype_digit((string)trim($_REQUEST[$key]))) {
                global ${$key};
                ${$key} = trim($_REQUEST[$key]);
            }
        break;
        case "string":
            if (is_string($_REQUEST[$key])) {
                global ${$key};
                ${$key} = trim($_REQUEST[$key]);
            }
        break;
        case "array":
            if (is_array($_REQUEST[$key]) && sizeof($_REQUEST[$key])) {
                global ${$key};
                ${$key} = $_REQUEST[$key];
            }
        break;
        case "prefix_d":
            foreach (array_keys($_REQUEST) as $rkey) {
                if (strpos($rkey,$key) !== FALSE) {
                    if (strlen(trim($_REQUEST[$rkey])) > 0 && ctype_digit((string)trim($_REQUEST[$rkey]))) {
                        global ${$rkey};
                        ${$rkey} = trim($_REQUEST[$rkey]);
                    }
                }
            }
        break;
        case "prefix_s":
            foreach (array_keys($_REQUEST) as $rkey) {
                if (strpos($rkey,$key) !== FALSE) {
                    if (is_string($_REQUEST[$rkey])) {
                        global ${$rkey};
                        ${$rkey} = trim($_REQUEST[$rkey]);
                    }
                }
            }
        break;
        case "prefix_a":
            foreach (array_keys($_REQUEST) as $rkey) {
                if (strpos($rkey,$key) !== FALSE) {
                    if (is_array($_REQUEST[$rkey]) && sizeof($_REQUEST[$rkey])) {
                        global ${$rkey};
                        ${$rkey} = $_REQUEST[$rkey];
                    }
                }
            }
        break;
        }
    }
}
/*
 * Function: dms_import_v2
 * Purpose:  This function is the same code as dms_import_val, however, instead of
 *                  putting the values in the form scope, it will add the values to the
 *                  p_hb_env in the $p_hb_key value
 * This function should be called AFTER cu_globals.i, to ensure the values aren't reset
 * Parameters: p_hb_env -- This is a REFERENCE to the HB_ENV variable
 *                       p_hb_key -- This is the name of the key:array where the values will be saved
 *                       dms_allowed -- This is the list of fields to import
 */
function dms_import_v2(&$p_hb_env, $p_hb_key, $dms_allowed) {
    foreach ($dms_allowed as $key => $type) {
        if (!isset($_REQUEST[$key]) && strpos($type, "prefix_") === false) {
            $p_hb_env[$p_hb_key][$key] = NULL;
            continue;
        }
    switch ($type) {
        case "digits":
            if (strlen(trim($_REQUEST[$key])) > 0 && ctype_digit((string)trim($_REQUEST[$key]))) {
                $p_hb_env[$p_hb_key][$key] = $_REQUEST[$key];
            }
        break;
        case "string":
            if (is_string($_REQUEST[$key])) {
                $p_hb_env[$p_hb_key][$key] = $_REQUEST[$key];
            }
        break;
        case "array":
            if (is_array($_REQUEST[$key]) && sizeof($_REQUEST[$key])) {
                $p_hb_env[$p_hb_key][$key] = $_REQUEST[$key];
            }
        break;
        case "prefix_d":
            foreach (array_keys($_REQUEST) as $rkey) {
                if (strpos($rkey,$key) !== FALSE) {
                    if (strlen(trim($_REQUEST[$rkey])) > 0 && ctype_digit((string)trim($_REQUEST[$rkey]))) {
                        $p_hb_env[$p_hb_key][$key] = trim($_REQUEST[$key]);
                    }
                }
            }
        break;
        case "prefix_s":
            foreach (array_keys($_REQUEST) as $rkey) {
                if (strpos($rkey,$key) !== FALSE) {
                    if (is_string($_REQUEST[$rkey])) {
                        $p_hb_env[$p_hb_key][$rkey] = trim($_REQUEST[$rkey]);
                    }
                }
            }
        break;
        case "prefix_a":
            foreach (array_keys($_REQUEST) as $rkey) {
                if (strpos($rkey,$key) !== FALSE) {
                    if (is_array($_REQUEST[$rkey]) && sizeof($_REQUEST[$rkey])) {
                        $p_hb_env[$p_hb_key][$key] = $_REQUEST[$rkey];
                    }
                }
            }
        break;
        }
    }
}


/**
 *
 * Import Variables From the POST or GET and put into the HB_ENV array
 * If a variable is NOT in the _POST or _GET, then be sure to set the value to NULL
 *
 * @param class $pHbEnv      - (by reference)
 * @param string $pHbKey     -
 * @param array[] $pVarAllowed - This is the colname=>datatype array list that defines the
 *                                values to fetch.
 *                               Allowed datatypes
 *                                  {digits, string, array, prefix_d, prefix_s, prefix_a}
 *
 *                               LEGACY FORMAT -- This should work by replacing dms_import_v2 with HCU_ImportVars
 *                                 $input_array = array("col1"=>"digits", "col2"=>"string", "col3"=>"array", "col4"=>"prefix_d");
 *                                 HCU_ImportVars($HB_ENV, "HCUPOST", $input_array)
 *                               ** NOTE: THERE IS NOT prefix_d comparable option with the filter_input functionality
 *                               PHP FILTER INPUT FORMAT
 *                                 layout
 *                                    the column name is the key of the associative array.
 *                                    the value MUST be an array with at least the filter option set.
 *                                    to use the raw value use FILTER_DEFAULT
 *                                 examples
 *                                 $input_array = array("col1"=>array('filter'=>FILTER_VALIDATE_INT),
 *                                                      "col2"=>array('filter'=>FILTER_SANITIZE_FULL_SPECIAL_CHARS),
 *                                                      "col3"=>array('filter'=>FILTER_VALIDATE_INT, 'options' => array('flags'=>FILTER_REQUIRE_ARRAY)),
 *                                                      "col4"=>array('filter'=>FILTER_VALIDATE_REGEXP), 'options' => array('options'=>array('regexp'=>'/[0-9]* /')))
 *
 * @return true                 - Always returns true
 *
 */
function HCU_ImportVars (&$pHbEnv, $pHbKey, $pVarAllowed) {

  $newValues = '';

  try {
    /*
     *
     * LOOP THROUGH THE dms_allowed
     *  When I determine the name to look for , then I can call the HCU_FilterInput
     *
     *
     */
    if (!is_array($pVarAllowed)) {
      throw new exception('Not an Array', '900');
    }

    // * It's an array -- Loop through the values
    foreach ($pVarAllowed as $fieldName => $fieldType) {

      $fieldValue = false;
      if (!is_array($fieldType)) {
        /**
         * LEGACY FILTERING
         */
        $prefixType = '';     // ** Reset prefix type
        $prefixArray = false; // ** Reset prefix array flag
        switch ($fieldType) {
          case HCUFILTER_INPUT_DIGITS:
            $fieldValue = HCU_FilterInput(HCUFILTER_REQUEST, $fieldName, FILTER_VALIDATE_INT);
            // ** DO NOT ALLOW [+/-] - In Legacy it would Fail for this reason
            $fieldValue = (strpos($fieldValue, "-") !== false ? NULL : $fieldValue);
            $fieldValue = (strpos($fieldValue, "+") !== false ? NULL : $fieldValue);
            break;
          case HCUFILTER_INPUT_STRING:
            /*
             * LEGACY FILTER STRING should let values in with a similar fashion as in mammoth.
             *   Added the 'flags' array so single quotes would not be encoded
             */
            $fieldValue = HCU_FilterInput(HCUFILTER_REQUEST, $fieldName, FILTER_SANITIZE_STRING, false, array('flags' => FILTER_FLAG_NO_ENCODE_QUOTES));

            break;
          case HCUFILTER_INPUT_ARRAY:
            $fieldValue = HCU_FilterInput(HCUFILTER_REQUEST, $fieldName, FILTER_DEFAULT, true);
            break;
          case "prefix_a":
            // if I use HCU_FilterInput $prefixType = ($prefixType == '' ? FILTER_VALIDATE_INT : $prefixType);
            $prefixType = ($prefixType == '' ? HCUFILTER_INPUT_ARRAY: $prefixType);
            $prefixArray = true;
          case "prefix_d":
            // if I use HCU_FilterInput $prefixType = ($prefixType == '' ? FILTER_VALIDATE_INT : $prefixType);
            $prefixType = ($prefixType == '' ? HCUFILTER_INPUT_DIGITS : $prefixType);
          case "prefix_s":
          // if I use HCU_FilterInput   $prefixType = ($prefixType == '' ? FILTER_SANITIZE_STRING : $prefixType);
            $prefixType = ($prefixType == '' ? HCUFILTER_INPUT_STRING : $prefixType);
            // ** FOR PREFIX TYPES, maybe I should use a recursive call...
              // * to call this function again with correct parameters for the variables found...
            foreach (array_keys($_REQUEST) as $reqKey) {
              // ** Loop through each Value in request.
              if (strpos($reqKey, $fieldName) !== FALSE) {
                //$fieldValue = HCU_FilterInput(HCUFILTER_REQUEST, $fieldName, $prefixType, $prefixArray);
                $prefixArray = array($reqKey => $prefixType);
                $retPrefix = HCU_ImportVars($pHbEnv, $pHbKey, $prefixArray);
                // In this instance the HB_ENV is going to be populated with the subsequent calls
              }
            }
            break;
        }

      } else {
        /**
         * NEW FILTER OPTIONS
         * THEY can use the filter_options directly
         *
         * fieldType should be an array. With at least
         *      'filter' required
         *      'options' optional
         */
        // ** Return the results from filter_input_array and determine how to convert to our standard response
        $fieldFilter = HCU_array_key_value('filter', $fieldType);
        $fieldFilter = ($fieldFilter == 0 ? FILTER_DEFAULT : $fieldFilter);

        $fieldFlags = HCU_array_key_value('flags', $fieldType);
        $fieldIsArray = ($fieldFlags == FILTER_REQUIRE_ARRAY ? true : false);

        $fieldOptions = HCU_array_key_value('options', $fieldType);
        $fieldValue = HCU_FilterInput(HCUFILTER_REQUEST, $fieldName, $fieldFilter, $fieldIsArray, $fieldOptions);
      }
      if ($fieldValue !== false) {
        // ** set with without the hb_env key
        if ($pHbKey == '') {
          $pHbEnv[$fieldName] = $fieldValue;
        } else {
          $pHbEnv[$pHbKey][$fieldName] = $fieldValue;
        }
      }
    }

    /*
     * SET DEFAULT KEY ARRAY
     *   If there will be an array key used and it is NOT already set
     *   Setting this prevents undefined variable references to the KEY when nothing was imported
     */
    if ($pHbKey != '' && !isset($pHbEnv[$pHbKey])) {
      $pHbEnv[$pHbKey] = Array();
    }

  } catch (exception $e) {
    // * what to do on Error?
    exit;
  }

  return true;
}

/**
 *
 * Get the value of a variable
 *   This routine will search for a variable in one of the superglobals
 *     If it is being sought with REQUEST then the order will be
 *        POST
 *        GET
 *
 *   In this manner it should perform similar to use _REQUEST
 *
 * @param const $pInputType - These are custom made, to handle instances when we want to search for both POST/GET, but also want to search individual ENV
 *                              HCUFILTER_REQUEST (search POST/GET) HCUFILTER_ENV (search ENV)
 * @param mixed $pKeyName  - This is the name of the variable for which we are searching the value (for HCUFILTER_REQUEST, HCUFILTER_ENV)
 * @param int   $pFilterType - This is the PHP validation {filter / sanitize} option to apply
 *
 *
 * @return mixed             - NULL - Returns NULL if values was
 *
 */
function HCU_FilterInput ($pInputType, $pKeyName, $pFilterType, $pIsArray=false, $pAddOptions=false) {

  // Start the value as false
  $retVal = false;
  $filterOptions = Array();
  $filterType = 0;


  if (is_array($pAddOptions)) {
    /* Pass through the value in pAddOptions to the filter_input function */
     $filterOptions = $pAddOptions;
  }

  if ($pIsArray) {
    // * Add the Require attribute to any flags value that is already set
    $filterOptions['flags'] = intval(HCU_array_key_value('flags', $filterOptions)) + FILTER_REQUIRE_ARRAY;
  }

  // -- OLD STYLE DEPRECATED $filterOptions = ($pAddOptions !== false ? $pAddOptions : NULL);
  // ** For Arrays, it will override the pAddOptions?? Possible to combine later
  // -- OLD STYLE DEPRECATED $filterOptions = ($pIsArray ? FILTER_REQUIRE_ARRAY : $filterOptions);

  switch ($pInputType) {
    case HCUFILTER_REQUEST:
      /*
       * GET VALUE FROM EITHER _POST or _GET SUPERGLOBAL
       */
      /* First Look in the _POST SUPERGLOBAL */
      if (HCU_array_key_exists($pKeyName, $_POST)) {
        $retVal = filter_input(INPUT_POST, $pKeyName, $pFilterType, $filterOptions);
      } elseif (HCU_array_key_exists($pKeyName, $_GET)) {
        $retVal = filter_input(INPUT_GET, $pKeyName, $pFilterType, $filterOptions);
      }

      break;
    case HCUFILTER_ENV: /* ENV SUPERGLOBAL */
      $filterType = INPUT_ENV;
    case HCUFILTER_COOKIE: /* COOOKIE SUPERGLOBAL */
      $filterType = ($filterType == 0 ? INPUT_COOKIE : $filterType);
    case HCUFILTER_SERVER: /* SERVER SUPERGLOBAL */
      $filterType = ($filterType == 0 ? INPUT_SERVER : $filterType);
      /*
       * GET VALUE FROM _ENV SUPERGLOBAL
       */
      $retVal = filter_input($filterType, $pKeyName, $pFilterType, $filterOptions);
      break;
    case HCUFILTER_VAR:
      /*
       * USE filter_var to filter the variable
       */
      $retVal = filter_var($pKeyName, $pFilterType, $filterOptions);
      break;
    default:
      // ** DO NOTHING
  }
  return $retVal;
}

/**
 *
 * Get the value of a variable using the php filters. The value is passed in.
 *
 *
 * @param mixed $pValue  - This is the value of the variable we want to filter
 * @param int   $pFilterType - This is the PHP validation {filter / sanitize} option to apply
 *
 *
 * @return mixed             - NULL - Returns NULL if values was
 *
 */
function HCU_FilterVar( $pValue, $pFilterType, $pIsArray=false, $pAddOptions=false ) {

  // Start the value as false
  $retVal = false;
  $filterOptions = Array();

  if (is_array($pAddOptions)) {
    /* Pass through the value in pAddOptions to the filter_input function */
    $filterOptions = $pAddOptions;
  }

  if ($pIsArray) {
    // * Add the Require attribute to any flags value that is already set
    $filterOptions['flags'] = intval(HCU_array_key_value('flags', $filterOptions)) + FILTER_REQUIRE_ARRAY;
  }

  // -- OLD STYLE DEPRECATED $filterOptions = ($pAddOptions !== false ? $pAddOptions : NULL);
  // ** For Arrays, it will override the pAddOptions?? Possible to combine later
  // -- OLD STYLE DEPRECATED $filterOptions = ($pIsArray ? FILTER_REQUIRE_ARRAY : $filterOptions);

  /*
   * USE filter_var to filter the variable
   */
  $retVal = filter_var( $pValue, $pFilterType, $filterOptions );

  return $retVal;
}

/**
 * HCU_ImportArray
 *
 * Import Variables from the given input array to the given output array, using the fitler instructions
 * in the Allowed array.
 * If a variable is NOT in the input array, but is in the Allowed array, then be sure to set the value to NULL
 *
 * @param array $pOutput     - (by reference) output array
 * @param array $pInput      - input array
 * @param array[] $pVarAllowed - This is the colname=>datatype array list that defines the
 *                                values to fetch.
 *                               PHP FILTER INPUT FORMAT
 *                                 layout
 *                                    the column name is the key of the associative array.
 *                                    the value MUST be an array with at least the filter option set.
 *                                    to use the raw value use FILTER_DEFAULT
 *                                 examples
 *                                 $allowedArray = array("col1"=>array('filter'=>FILTER_VALIDATE_INT),
 *                                                       "col2"=>array('filter'=>FILTER_SANITIZE_FULL_SPECIAL_CHARS),
 *                                                       "col3"=>array('filter'=>FILTER_VALIDATE_INT, 'options' => array('flags'=>FILTER_REQUIRE_ARRAY)),
 *                                                       "col4"=>array('filter'=>FILTER_VALIDATE_REGEXP), 'options' => array('options'=>array('regexp'=>'/[0-9]* /')))
 *
 * @return boolean                 - Returns true on success, false on error
 *
 */
function HCU_ImportArray( &$pOutput, $pInput, $pVarAllowed ) {

  try {
    // make sure returning to an array
    if ( !is_array($pOutput) ) {
      $pOutput = array();
    }

    // loop through the Allowed array
    if ( !is_array($pVarAllowed) ) {
      throw new exception('Not an Array', '901');
    }

    // * It's an array -- Loop through the values
    foreach ($pVarAllowed as $fieldName => $fieldType) {
      /**
       * NEW FILTER OPTIONS
       * Callers can use the filter_options directly
       *
       * fieldType should be an array. With at least
       *      'filter' required
       *      'options' optional
       */
      // ** Return the results from filter_input_array and determine how to convert to our standard response
      $fieldFilter = HCU_array_key_value('filter', $fieldType);
      $fieldFilter = ($fieldFilter == 0 ? FILTER_DEFAULT : $fieldFilter);

      $fieldFlags = HCU_array_key_value('flags', $fieldType);
      $fieldIsArray = ($fieldFlags == FILTER_REQUIRE_ARRAY ? true : false);

      $fieldOptions = HCU_array_key_value('options', $fieldType);

      $fieldValue = HCU_FilterVar($pInput[$fieldName], $fieldFilter, $fieldIsArray, $fieldOptions);

      if ($fieldValue !== false) {
        // ** set with without the hb_env key
        $pOutput[$fieldName] = $fieldValue;
      } else {
        // provide a null returned
        $pOutput[$fieldName] = null;
      }
    }

    $returnVal = true;
  } catch (exception $e) {
    // * what to do on Error?
    $returnVal = false;
  }

  return $returnVal;
} // end HCU_ImportArray