/** * date validator * * @param Validation $validation * @param string $field * @param string $value * @throws Validation_Exception * @return void */ public function validate_date(Validation $validation, $field, $value) { $stamp = strtotime($value); if ($stamp < time() - 31556926) { $validation->error($field, 'invalid_date', array($validation[$field])); } if ($field == "start") { // if it is a new reservation, check if time is in the future if ($this->id == null && $stamp < time()) { $validation->error($field, 'past', array($validation[$field], $value)); } // check if the resaurant is opened on that day if (in_array(date("N", $stamp), Kohana::$config->load('smacky.closed'))) { $validation->error($field, 'closed', array($validation[$field])); } } if ($field == "end") { // check if the end-stamp is after the start-stamp if ($value <= $this->start) { $validation->error($field, 'invalid_timespan', array($validation[$field], $value)); } // check if max reservation time is not exceeded if ($stamp - strtotime($this->start) > Kohana::$config->load('smacky.max-reservation') * 3600) { $validation->error($field, 'max_time', array($validation[$field], $value)); } } }
/** * Triggers error if identity exists. * Validation callback. * * @param Validation Validation object * @param string field name * @return void */ public function unique_identity(Validation $validation, $field) { $identity_exists = (bool) DB::select(array('COUNT("*")', 'total_count'))->from($this->_table_name)->where('identity', '=', $validation['identity'])->and_where('provider', '=', $validation['provider'])->execute($this->_db)->get('total_count'); if ($identity_exists) { $validation->error($field, 'identity_available', array($validation[$field])); } }
public function checkAdminRoleLimit(Validation $validation, $role) { $config = \Kohana::$config->load('features.limits'); if ($config['admin_users'] > 1 && $role == 'admin') { $total = $this->repo->getTotalCount(['role' => 'admin']); if ($total >= $config['admin_users']) { $validation->error('role', 'adminUserLimitReached'); } } }
public function checkPostTypeLimit(Validation $validation) { $config = \Kohana::$config->load('features.limits'); if ($config['forms'] !== TRUE) { $total_forms = $this->repo->getTotalCount(); if ($total_forms >= $config['forms']) { $validation->error('name', 'postTypeLimitReached'); } } }
public function checkPermissions(Validation $validation, $permissions) { if (!$permissions) { return; } foreach ($permissions as $permission) { if (!$this->permission_repo->exists($permission)) { $validation->error('permissions', 'permissionDoesNotExist', [$permission]); return; } } }
/** * * @param array $post * @return boolean * @throws Installer_Exception */ public function install(array $post) { if (empty($post)) { throw new Installer_Exception('No install data!'); } if (isset($post['password_generate'])) { $post['password_field'] = Text::random(); } if (isset($post['admin_dir_name'])) { $post['admin_dir_name'] = URL::title($post['admin_dir_name']); } if (isset($post['db_port'])) { $post['db_port'] = (int) $post['db_port']; } date_default_timezone_set($post['timezone']); $this->_session->set('install_data', $post); $this->_validation = $this->_valid($post); try { $this->_db_instance = $this->connect_to_db($post); } catch (Database_Exception $exc) { $validation = FALSE; switch ($exc->getCode()) { case 1049: $this->_validation->error('db_name', 'incorrect'); $validation = TRUE; break; case 2: $this->_validation->error('db_server', 'incorrect')->error('db_user', 'incorrect')->error('db_password', 'incorrect'); $validation = TRUE; break; } if ($validation === TRUE) { throw new Validation_Exception($this->_validation, $exc->getMessage(), NULL, $exc->getCode()); } else { throw new Database_Exception($exc->getMessage(), NULL, $exc->getCode()); } } Database::$default = 'install'; Observer::notify('before_install', $post, $this->_validation); if (isset($post['empty_database'])) { $this->_reset(); } define('TABLE_PREFIX_TMP', Arr::get($post, 'db_table_prefix', '')); $this->_import_shema($post); $this->_import_dump($post); $this->_install_modules($post); Observer::notify('install', $post); $this->_create_site_config($post); $this->_create_config_file($post); return TRUE; }
public function valid_range(Validation $validation, $field) { $start = $validation['startDate']; $end = $validation['endDate']; if (!$start || !$end || $start >= $end) { $validation->error($field, 'valid_range', array($validation[$field])); } }
/** * Validation callback * * @param string $name Validation name * @param Validation $validation Validation object * @param string $field Field name * * @uses Valid::numeric * @uses Config::get */ public function is_valid($name, Validation $validation, $field) { // Make sure we have a valid term id set if ($name == 'category') { if (isset($this->categories) and is_array($this->categories)) { foreach ($this->categories as $id => $term) { if ($term == 'last' or !Valid::numeric($term)) { $validation->error('categories', 'invalid', array($validation[$field])); } } } } elseif ($name == 'created') { if (!empty($this->author_date) and !($date = strtotime($this->author_date))) { $validation->error($field, 'invalid', array($this->author_date)); } else { if (isset($date)) { $this->created = $date; } } } elseif ($name == 'author') { if (!empty($this->author_name) and !($account = User::lookup_by_name($this->author_name))) { $validation->error($field, 'invalid', array($this->author_name)); } else { if (isset($account)) { $this->author = $account->id; } } } elseif ($name == 'pubdate') { if (!empty($this->author_pubdate) and !($date = strtotime($this->author_pubdate))) { $validation->error($field, 'invalid', array($validation[$field])); } else { if (isset($date)) { $this->pubdate = $date; } } } elseif ($name == 'image') { if (isset($_FILES['image']['name']) and !empty($_FILES['image']['name'])) { $allowed_types = Config::get('media.supported_image_formats', array('jpg', 'png', 'gif')); $data = Validation::factory($_FILES)->rule('image', 'Upload::not_empty')->rule('image', 'Upload::valid')->rule('image', 'Upload::type', array(':value', $allowed_types)); if (!$data->check()) { $validation->error($field, 'invalid', array($validation[$field])); } } } }
/** * @param Validation $validation * @param string $field * @param string $value */ public function user_has_avatar($validation, $field, $value) { if (!$this->user->has('avatars', $value)) { $validation->error($field, 'You do not own that avatar'); } }
/** * Check required attributes are completed before completing stages * * @param Validation $validation * @param Array $attributes * @param Array $data */ public function checkRequiredAttributes(Validation $validation, $attributes, $data) { if (empty($data['completed_stages'])) { return; } // If a stage is being marked completed // Check if the required attribute have been completed foreach ($data['completed_stages'] as $stage_id) { // Load the required attributes $required_attributes = $this->attribute_repo->getRequired($stage_id); // Check each attribute has been completed foreach ($required_attributes as $attr) { if (!array_key_exists($attr->key, $attributes)) { $stage = $this->stage_repo->get($stage_id); // If a required attribute isn't completed, throw an error $validation->error('values', 'attributeRequired', [$attr->key, $stage->label]); } } } }
/** * Validate item command input when creating an item * * @param Validation $validation Validation objec * @param JSON $value Command to validate */ public static function validate_commands($validation, $value) { $values = json_decode($value, TRUE); foreach ($values as $command) { $cmd = Item_Command::factory($command['name']); if (!$cmd->validate($command['param'])) { $validation->error('commands', $command['name']); } } }
/** * Validation callback * * @param Validation $validation Validation object * @param string $field Field name * @uses Valid::numeric * @return void */ public function is_valid(Validation $validation, $field) { if (empty($this->name) and empty($this->title)) { $validation->error('title', 'not_empty', array($this->title)); } else { $text = empty($this->name) ? $this->title : $this->name; $this->name = $this->_unique_slug(URL::title($text)); } }
/** * @static * @param string $field * @param string $value * @param Model $model * @param Validation $validation */ public static function check_measures($field, $value, $model, $validation) { if ($value == 'E-Total' and $model->min == 0) { $validation->error($field, "E-Total's MIN cannot be zero."); } }
/** * Callback for validating that a field is unique. * * @param Validation $data * @param Jelly_Model $model * @param string $field * @param string $value * @return void */ public function _is_unique(Validation $data, Jelly_Model $model, $field, $value) { // According to the SQL standard NULL is not checked by the unique constraint // We also skip this test if the value is the same as the default value if ($value !== NULL and $value !== $this->default) { // Build query $query = Jelly::query($model)->where($field, '=', $value); // Limit to one $query->limit(1); if ($query->count()) { // Add error if duplicate found $data->error($field, 'unique'); } } }
/** * @param Validation $validation * @param string $field * @param string $value */ public function valid_avatar_type($validation, $field, $value) { $avatars = $this->get_avatar_drivers(); $ids = array(); foreach ($avatars as $avatar) { $ids[] = $avatar->id; } if (!in_array($value, $ids)) { $validation->error($field, 'Unknown avatar type'); } }
/** * Validate callback wrapper for checking email uniqueness * * @static * @param Validate $array * @param string $field */ public static function _unique(Validation $array, $field) { if (Model_User::find_user($array[$field])) { $array->error($field, 'unique', array('param1' => $field)); } }
/** * Check to ensure the entered password matches the users password. * * @param Validation $validation * @param string $value */ public function check_current_password($validation, $field, $value) { if (Auth::instance()->hash($value) !== $this->user->password) { $validation->error($field, 'Wrong password'); } }
/** * Check by triggering error if name exists * * Validation callback. * * @param Validation $validation Validation object * @param string $field Field name * * @uses DB::select * @uses Validation::error */ public function term_available(Validation $validation, $field) { $query = DB::select(array(DB::expr('COUNT(*)'), 'total_count'))->from($this->_table_name)->where('name', '=', $validation[$field])->where($this->_primary_key, '!=', $this->pk())->where($this->scope_column, '=', $this->scope())->execute($this->_db)->get('total_count'); if ($query > 0) { $validation->error($field, 'term_available', array($validation[$field])); } }
public function username_available(Validation $validation, $field) { if (in_array($validation[$field], user::reservednames())) { $validation->error($field, 'username_available', array($validation[$field])); } if ($this->unique_key_exists($validation[$field], 'username')) { $validation->error($field, 'username_available', array($validation[$field])); } }
/** * Checks whether recipient user exists with the specified name * * Validation callback. * * @param Validation $validation An validation object * @param string $field Field name * @return boolean */ public function toExists(Validation $validation, $field) { if ($this->status != PM::STATUS_DRAFT and empty($validation[$field])) { $validation->error($field, 'not_empty', array($validation[$field])); } elseif ($this->status != PM::STATUS_DRAFT and $this->exists($validation[$field])) { $validation->error($field, 'exists', array($validation[$field])); } }
public function name_available(Validation $validation, $field) { if ($this->unique_key_exists($validation[$field], 'name')) { $validation->error($field, 'name_available', array($validation[$field])); } }
/** * Validate callback wrapper for checking password match * * @static * @param Validation $array * @param string $field */ public static function _check_password_matches(Validation $array, $field) { if (empty($array['password_kohana']) || $array['password_kohana'] !== $array[$field]) { $array->error($field, 'matches', array('param1' => 'password_kohana')); } }
public function valid_option(Validation $validation, $option) { if (!in_array($option, $this->_accepted_options)) { $validation->error($option, 'minion_option'); } }
/** * Check by triggering error if post exists * * Validation callback. * * @param Validation $validation Validation object * @param string $field Field name * * @uses DB::select */ public function valid_post(Validation $validation, $field) { $result = DB::select(array(DB::expr('COUNT(*)'), 'total_count'))->from('posts')->where('id', '=', $this->post_id)->execute($this->_db)->get('total_count'); if ($result != 1) { $validation->error($field, 'invalid', array($validation[$field])); } }
/** * Check by triggering error if process * * Validation callback. * * @param Validation $validation Object for validation * @param string $field Field name * @return void * * @uses Module::event */ public function process_alias(Validation $validation, $field) { // always set unique alias if its set $alias = $this->_unique_slug(trim($this->alias)); // make sure only one alias exists for home page <front> if ($this->alias === Path::FRONT_ALIAS) { $alias = Path::FRONT_ALIAS; } $this->type = empty($this->type) ? NULL : $this->type; // allow other modules to interact with alias Module::event('path_aliases', $this); $source = trim($this->source, '/'); $this->lang = empty($this->lang) ? $this->_language_none : $this->lang; if ($params = $this->_process_uri($source)) { if (isset($params['directory'])) { $this->route_directory = $params['directory']; } if (isset($params['controller'])) { $this->route_controller = $params['controller']; } if (isset($params['action'])) { $this->route_action = $params['action']; } if (isset($params['id'])) { $this->route_id = $params['id']; } if (isset($params['route'])) { $this->route_name = $params['route']; } $this->alias = $alias; } elseif (!isset($params['controller']) or !isset($params) or empty($params['controller']) or empty($params)) { $validation->error($field, 'invalid_source', array($validation[$field])); } }
/** * Triggers an error if the email does not exist * * Validation callback. * * @param Validation $validation And Validation object * @param string $field Field name */ public function email_not_available(Validation $validation, $field) { if (!$this->unique_key_exists($validation[$field], 'mail')) { $validation->error($field, 'email_not_available', array($validation[$field])); } }
public function _validation_callback(Validation $object) { // Simply add the error $object->error('foo', '_validation_callback'); }
/** * Check by triggering error if name exists. * Validation callback. * * @param Validation $validation Validation object * @param string $field Field name * * @uses DB::select * @uses DB::expr * @uses Validation::error */ public function tag_available(Validation $validation, $field) { $result = DB::select(array(DB::expr('COUNT(*)'), 'total_count'))->from($this->_table_name)->where('name', '=', $validation[$field])->where($this->_primary_key, '!=', $this->pk())->where('type', '=', $this->type)->execute($this->_db)->get('total_count'); if ($result > 0) { $validation->error($field, 'tag_available', array($validation[$field])); } }