/**
* 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]));
}
}
