PHP Helpers::is_array_ne方法代码示例

 /**
  * Login constructor.
  *
  * @param array $params
  */
 public function __construct($params = array())
 {
     $this->Log->write(__METHOD__, Log::LOG_LEVEL_SYSTEM_INFORMATION);
     if (Helpers::is_array_ne($params)) {
         if (array_key_exists('log_level', $params)) {
             $this->logLevel($params['log_level']);
         }
         $this->Log->write('params', Log::LOG_LEVEL_USER, $params);
         // set properties based on parameters using magic method
         foreach ($params as $name => $value) {
             $this->__set($name, $value);
         }
     }
     parent::__construct($params);
 }

 /**
  * Replace bound parameter placeholders with parameters and write query to a file.
  * WARNING: This method uses more memory and time. Only use it if necessary and NOT on production.
  *
  * @param string $sql
  * @param array $params
  * @return string
  * @see http://php.net/manual/en/pdostatement.debugdumpparams.php#113400
  */
 private function writeQueryParameters($sql = '', $params = array())
 {
     // @todo: ONLY ENABLE THIS METHOD IF NEEDED FOR DEBUGGING
     if (true) {
         return true;
     }
     $this->Log->write(__METHOD__, Log::LOG_LEVEL_SYSTEM_INFORMATION);
     if (Helpers::is_array_ne($params)) {
         foreach ($params as $v) {
             $v = str_replace('?', '~', $this->quote($v));
             $sql = preg_replace('/\\?/', $v, $sql, 1);
         }
         // free some memory
         unset($params);
     }
     // check for comment
     if (substr($sql, 0, 2) === '/*' && substr($sql, -2) === '*/') {
         // this is a multi-line comment
         $mult = strstr($sql, 'SQLSTATE') ? 4 : 2;
         $query = $sql . str_repeat(PHP_EOL, $mult);
     } else {
         $query = rtrim($sql, ';' . PHP_EOL) . ';' . PHP_EOL . PHP_EOL;
     }
     // free some memory
     unset($sql);
     return file_put_contents(ASSETS_DIR . 'sql/queries_' . date('Y-m-d') . '.sql', $query, FILE_APPEND);
 }

 /**
  * Validate path, size, extension with post_file.
  *
  * @return bool
  */
 private function validateFile()
 {
     // make sure there is a post file
     if (!Helpers::is_array_ne($this->post_file)) {
         $this->Log->write('The $_FILES array has not been saved. Please call init() first.', Log::LOG_LEVEL_WARNING);
         return false;
     }
     // verify output directory exists
     if (!is_dir($this->output_path)) {
         $this->Log->write('Output path not specified or does not exist. Please set the output path with Upload::outputPath() and process again.', Log::LOG_LEVEL_WARNING);
         return false;
     }
     // check max file size
     if (!$this->validateMaxSize()) {
         $this->Log->write('File size {' . $this->humanSize($this->post_file['size']) . '} is greater than max file size {' . $this->humanSize($this->max_size) . '}.', Log::LOG_LEVEL_WARNING);
         return false;
     }
     // validate extension
     $ext = pathinfo($this->post_file['name'], PATHINFO_EXTENSION);
     if (!in_array($ext, $this->accepted_exts)) {
         $this->Log->write('extension {' . $ext . '} is not allowed. Please upload a file with one of these extensions', Log::LOG_LEVEL_WARNING, $this->accepted_exts);
         return false;
     }
     return true;
 }

 /**
  * Get the user from the database and store in a property.
  *
  * @return array|bool|mixed
  */
 private function getUser()
 {
     $this->Log->write(__METHOD__, Log::LOG_LEVEL_SYSTEM_INFORMATION);
     // use cached version
     if (Helpers::is_array_ne($this->user_data)) {
         return $this->user_data;
     }
     // determine which field and value to use in the query
     if (Helpers::is_valid_int($this->id, true)) {
         $where_field = $this->id_field;
         $value = $this->id;
     } elseif (Helpers::is_string_ne($this->name)) {
         $where_field = $this->name_field;
         $value = $this->name;
     } elseif (array_key_exists('user_id', $_SESSION)) {
         $where_field = $this->id_field;
         $value = $_SESSION['user_id'];
     } elseif (array_key_exists('user_name', $_SESSION)) {
         $where_field = $this->name_field;
         $value = $_SESSION['user_name'];
     } else {
         $this->Log->write('cannot determine user data to use', Log::LOG_LEVEL_WARNING);
         return false;
     }
     // build query
     $sql = 'SELECT *' . PHP_EOL;
     $sql .= '  FROM ' . $this->table . PHP_EOL;
     $sql .= '  WHERE ' . $where_field . ' = ?';
     $row = $this->query($sql, array($value), 'first');
     if (!Helpers::is_array_ne($row)) {
         return false;
     }
     $this->user_data = $row;
     $this->id = $row['id'];
     $this->name = $row['name'];
     return $row;
 }

 /**
  * Log constructor.
  *
  * @param array $params
  */
 public function __construct($params = array())
 {
     // set defaults
     $this->log_level = $this::LOG_LEVEL_ERROR;
     if (defined('LOG_DIR')) {
         $this->logDirectory(LOG_DIR);
     }
     // set values from parameters
     if (Helpers::is_array_ne($params)) {
         if (array_key_exists('log_directory', $params)) {
             $this->logDirectory($params['log_directory']);
         }
         if (array_key_exists('log_level', $params) && Helpers::is_valid_int($params['log_level'])) {
             $this->logLevel($params['log_level']);
         }
         if (array_key_exists('file', $params) && Helpers::is_string_ne($params['file'])) {
             $this->file($params['file']);
         }
         if (array_key_exists('date_format', $params) && Helpers::is_string_ne($params['date_format'])) {
             $this->date_format = $params['date_format'];
         }
         if (array_key_exists('separator', $params) && Helpers::is_string_ne($params['separator'])) {
             $this->separator = $params['separator'];
         }
     }
 }

 /**
  * Insert values into to table.
  *
  * @param string $table
  * @return bool|string
  * @uses DatabaseMap::$to_values
  * @uses Db::buildInsert()
  * @uses Db::begin()
  * @uses Db::query()
  * @uses Db::commit()
  */
 private function insertValues($table = '')
 {
     $this->Log->write(__METHOD__, Log::LOG_LEVEL_SYSTEM_INFORMATION);
     // input validation
     if (!Helpers::is_string_ne($table) || !Helpers::is_array_ne($this->to_values[$table])) {
         $this->Log->write('table is invalid or to values does not contain table ' . $table, Log::LOG_LEVEL_WARNING);
         return false;
     }
     // get values for table
     $values = $this->to_values[$table];
     // build insert query and parameters
     $result = $this->buildInsert($table, $values, true, true);
     if ($result === false) {
         $this->Log->write('could not build insert for ' . $table, Log::LOG_LEVEL_WARNING);
         return false;
     }
     list($sql, $parameters) = $result;
     $this->Log->write('trying insert query in transaction', Log::LOG_LEVEL_USER);
     $this->begin();
     $this->query($sql, $parameters, 'insert');
     if ($this->debug) {
         $this->Log->write('rolling back transaction due to debug', Log::LOG_LEVEL_USER);
         $this->rollback();
         $output = $sql . PHP_EOL . Helpers::get_string($parameters);
     } else {
         $this->Log->write('committing transaction', Log::LOG_LEVEL_USER);
         $this->commit();
         $output = true;
     }
     return $output;
 }

 /**
  * Set and/or get user password for PDF file. If this is set, the PDF file will be encrypted.
  *
  * @return string
  */
 public function userPassword()
 {
     $args = func_get_args();
     if (Helpers::is_array_ne($args)) {
         if (Helpers::is_string_ne($args[0])) {
             $this->user_password = $args[0];
         } else {
             $this->Log->write('invalid type for user password', Log::LOG_LEVEL_WARNING);
         }
     }
     return $this->user_password;
 }

 /**
  * Generate PHP string for this table and field.
  *
  * @param array $array Row of results from constant list
  * @return bool|int
  * @uses Db::query()
  * @uses Db::quote()
  */
 protected function generate($array = array())
 {
     $this->Log->write(__METHOD__, Log::LOG_LEVEL_SYSTEM_INFORMATION);
     // input validation
     if (!Helpers::is_array_ne($array)) {
         $this->Log->write('array is invalid', Log::LOG_LEVEL_WARNING, Helpers::get_call_string());
         return false;
     }
     // these fields need to be present in the array
     $fields = array('table_name', 'name_field', 'value_field', 'type');
     $valid = true;
     // check for the existence of each field in the array and break if one of them does not exist
     foreach ($fields as $field) {
         if (!array_key_exists($field, $array)) {
             $valid = false;
             break;
         }
     }
     if (!$valid) {
         $this->Log->write('input invalid', Log::LOG_LEVEL_WARNING);
         return false;
     }
     // assign parameters to variables
     $table = $array['table_name'];
     $field = $array['name_field'];
     $value_field = $array['value_field'];
     $type = $array['type'];
     $prefix = array_key_exists('prefix', $array) ? $array['prefix'] : $table;
     // build SELECT query for field and value
     $sql = 'SELECT ' . $field . ', ' . $value_field . PHP_EOL;
     $sql .= '  FROM ' . $table . PHP_EOL;
     $this->Log->write('generate SQL', Log::LOG_LEVEL_USER, $sql);
     // get rows from table
     $rows = $this->query($sql, array(), 'iterator');
     if (!$rows instanceof DbIterator) {
         $this->Log->write('could not find rows from query', Log::LOG_LEVEL_WARNING);
         return false;
     }
     $this->Log->write('found rows for generate query', Log::LOG_LEVEL_USER);
     // build PHP string with comments to indicate table and field used in generation
     $php = PHP_EOL . '/**' . PHP_EOL;
     $php .= ' * ' . $table . '.' . $field . PHP_EOL;
     $php .= ' */' . PHP_EOL;
     foreach ($rows as $row) {
         if ($row === null || !array_key_exists($field, $row)) {
             continue;
         }
         // prepare constant name (upper case, underscores instead of spaces, no multiple underscores together)
         $val = strtoupper(Helpers::space_to_underscore($prefix . '_' . $row[$field]));
         // add define statement to string
         $php .= 'define(\'' . $val . '\', ' . $this->quote($row[$value_field], $type) . ');' . PHP_EOL;
     }
     $php .= '// END ' . $table . '.' . $field . PHP_EOL . PHP_EOL;
     $this->Log->write('built PHP string with ' . strlen($php) . ' characters', Log::LOG_LEVEL_USER);
     if (!Helpers::is_string_ne($php)) {
         $this->Log->write('There was an issue building the PHP.', Log::LOG_LEVEL_WARNING, Helpers::get_type_size($php));
         return false;
     }
     // append string to global string
     $this->php .= $php;
     return strlen($php);
 }

 /**
  * Upload a file to convert and pass the output name to inputFile.
  *
  * @param string $form_file
  * @param string $expected_type
  * @return bool|mixed|string
  * @uses Convert::$extensions
  * @uses Upload::uniqueName()
  * @uses Upload::process()
  * @uses Upload::lastMessage()
  * @uses Upload::outputPath()
  * @uses Convert::inputFile()
  * @see Log::last()
  */
 public function uploadFile($form_file = 'upload_file', $expected_type = 'text')
 {
     $this->Log->write('Convert::uploadFile()', Log::LOG_LEVEL_SYSTEM_INFORMATION);
     if (!Helpers::is_string_ne($form_file)) {
         $this->Log->write('Form file name must be provided.', Log::LOG_LEVEL_WARNING);
         return false;
     }
     $exts = $this->extensions[$expected_type];
     if (!Helpers::is_array_ne($exts)) {
         $this->Log->write('Expected type {' . $expected_type . '} is not valid.', Log::LOG_LEVEL_WARNING);
         return false;
     }
     $message = '';
     $target_dir = '~/uploads/';
     $Upload = new Upload(['form_file' => 'upload_file', 'output_file' => $target_dir, 'exts' => $exts]);
     $name = $Upload->uniqueName();
     if ($name !== false) {
         $processed = $Upload->process();
         if (!$processed) {
             $message = $Upload->lastMessage();
         } else {
             $this->inputFile($Upload->outputPath() . $name);
         }
     } else {
         $message = $Upload->lastMessage();
     }
     return $message;
 }