示例#1
0
文件: Query.php 项目: levmorozov/mii
 /**
  * Creates a new "OR WHERE" condition for the query.
  *
  * @param   mixed $column column name or array($column, $alias) or object
  * @param   string $op logic operator
  * @param   mixed $value column value
  * @return  $this
  */
 public function or_filter($column, $op, $value)
 {
     if ($value === null || $value === "" || !Rules::not_empty(is_string($value) ? trim($value) : $value)) {
         return $this;
     }
     return $this->or_where($column, $op, $value);
 }
示例#2
0
 /**
  * Executes all validation rules. This should
  * typically be called within an if/else block.
  *
  *     if ($validation->check())
  *     {
  *          // The data is valid, do something here
  *     }
  *
  * @return  boolean
  */
 public function check()
 {
     $benchmark = false;
     if (config('debug')) {
         // Start a new benchmark
         $benchmark = \mii\util\Profiler::start('Validation', __FUNCTION__);
     }
     $this->_errors = [];
     // Get a list of the expected fields
     $expected = Arr::merge(array_keys($this->_data), array_keys($this->_labels));
     // Import the rules locally
     $rules = $this->_rules;
     $data = [];
     foreach ($expected as $field) {
         // Use the submitted value or NULL if no data exists
         $data[$field] = isset($this->_data[$field]) ? $this->_data[$field] : null;
     }
     // Overload the current array with the new one
     $this->_data = $data;
     // Execute the rules
     foreach ($rules as $field => $set) {
         // Get the field value
         $value = $this->_data[$field];
         foreach ($set as $array) {
             // Rules are defined as array($rule, $params)
             list($rule, $params) = $array;
             array_unshift($params, $value);
             // Default the error name to be the rule (except array and lambda rules)
             $error_name = $rule;
             if (is_array($rule)) {
                 // Allows rule('field', array(':model', 'some_rule'));
                 if (is_string($rule[0]) and array_key_exists($rule[0], $this->_bound)) {
                     // Replace with bound value
                     $rule[0] = $this->_bound[$rule[0]];
                 }
                 // This is an array callback, the method name is the error name
                 $error_name = $rule[1];
                 $passed = call_user_func_array($rule, $params);
             } elseif (!is_string($rule)) {
                 // This is a lambda function, there is no error name (errors must be added manually)
                 $error_name = FALSE;
                 array_unshift($params, $field);
                 array_unshift($params, $this);
                 $passed = call_user_func_array($rule, $params);
             } elseif (method_exists('mii\\valid\\Rules', $rule)) {
                 // Use a method in this object
                 $method = new \ReflectionMethod('mii\\valid\\Rules', $rule);
                 // Call static::$rule($this[$field], $param, ...) with Reflection
                 $passed = $method->invokeArgs(NULL, $params);
             } elseif (strpos($rule, '::') === FALSE) {
                 // Use a function call
                 $function = new \ReflectionFunction($rule);
                 // Call $function($this[$field], $param, ...) with Reflection
                 $passed = $function->invokeArgs($params);
             } else {
                 // Split the class and method of the rule
                 list($class, $method) = explode('::', $rule, 2);
                 // Use a static method call
                 $method = new \ReflectionMethod($class, $method);
                 // Call $Class::$method($this[$field], $param, ...) with Reflection
                 $passed = $method->invokeArgs(NULL, $params);
             }
             // Ignore return values from rules when the field is empty
             if (!in_array($rule, $this->_empty_rules) and !Rules::not_empty($value)) {
                 continue;
             }
             if ($passed === FALSE and $error_name !== FALSE) {
                 // Add the rule to the errors
                 $this->error($field, $error_name, $params);
                 // This field has an error, stop executing rules
                 break;
             } elseif (isset($this->_errors[$field])) {
                 // The callback added the error manually, stop checking rules
                 break;
             }
         }
     }
     if ($benchmark) {
         // Stop benchmarking
         \mii\util\Profiler::stop($benchmark);
     }
     return empty($this->_errors);
 }