public function post()
{
$file = array('users' => Request::all());
// setting up rules
$rules = array('users' => 'required', 'mimes' => 'jpeg,jpg,png', 'max' => '200px');
//mimes:jpeg,bmp,png and for max size max:10000
// doing the validation, passing post data, rules and the messages
$validator = Validator::make($file, $rules);
if ($validator->fails()) {
// send back to the page with the input data and errors
return redirect('settings')->withInput()->withErrors($validator);
} else {
// checking file is valid.
if (Input::file('user_image')->isValid()) {
$extension = Input::file('user_image')->getClientOriginalExtension();
// getting image extension
$fileName = rand(11111, 99999) . '.' . $extension;
// renaming image
Input::file('user_image')->move('uploads/', $fileName);
// uploading file to given path
$file->user_image = $fileName;
\Auth::user()->post->save();
// sending back with message
\Session::flash('flash_message', 'You have successfully updated your codename!');
return redirect('settings');
} else {
// sending back with error message.
\Session::flash('error', 'uploaded file is not valid');
return redirect('home');
}
}
}
public function validate($data)
{
// make a new validator object
$v = Validator::make($data, $this->rules);
// return the result
return $v->passes();
}
public static function validar($dados)
{
if (array_key_exists('id', $dados)) {
static::$restricoes['nome'] .= ',nome,' . $dados['id'];
}
return \Validator::make($dados, static::$restricoes, static::$mensagens);
}
/**
* Validate
* @return validator
*/
public static function validate($input, $id = null)
{
$rules = array("name" => "required|min:2|max:255", "featureproject_id" => "required", "status_id" => "required", "priority_id" => "required", "category_feature_id" => "required", "done" => "required|numeric", "startdate" => "required", "enddate" => "required");
if ($id == null) {
$rules['name'] = "required|min:2|max:255|unique:detailfeature,name";
}
return \Validator::make($input, $rules);
}
public static function validar($dados)
{
if (array_key_exists('id', $dados)) {
static::$restricoes['registro'] .= ',registro,' . $dados['id'];
static::$restricoes['email'] .= ',email,' . $dados['id'];
}
return \Validator::make($dados, static::$restricoes, static::$mensagens);
}
public function validate()
{
$v = \Validator::make($this->attributes, $this->rules);
if ($v->passes()) {
return true;
}
$this->errors = $v->messages();
return false;
}
public function validate($data)
{
$v = \Validator::make($data, $this->rules);
if ($v->fails()) {
$this->errors = $v->errors();
return false;
}
return true;
}
/**
* Model validator
* @return bool
*/
public function validate()
{
$this->propertyErrors = [];
Validator::required($this, 'name', ['create']);
Validator::required($this, 'email', ['create', 'login']);
Validator::required($this, 'password', ['create', 'login']);
Validator::isUnique($this, 'email', ['create']);
Validator::strMaxLength($this, 'name', 30, ['create']);
Validator::strMaxLength($this, 'surname', 45, ['create']);
Validator::strMaxLength($this, 'email', 255, ['create']);
return empty($this->propertyErrors);
}
/**
* Model validator
* @return bool
*/
public function validate($clearErrors = true)
{
if ($clearErrors) {
$this->propertyErrors = [];
}
Validator::required($this, 'uid', ['create']);
Validator::required($this, 'path', ['create']);
Validator::required($this, 'date', ['create']);
Validator::required($this, 'description', ['create']);
Validator::strMaxLength($this, 'path', 512, ['create']);
Validator::strMaxLength($this, 'description', 255, ['create']);
return empty($this->propertyErrors);
}
public function validate($data)
{
// make a new validator object
$v = \Validator::make($data, $this->rules, $this->messages);
// check for failure
if ($v->fails()) {
// set errors and return false
$this->errors = $v->errors();
return false;
}
// validation pass
return true;
}
public static function validateUser($data, $type = 'C')
{
$maxDate = date('Y-m-d');
$minDate = date('Y-m-d', mktime(0, 0, 0, date('m'), date('d'), date('Y') - 100));
$rules = array('email' => 'required|email|unique:users', 'password' => 'required|min:8|confirmed', 'name' => 'required|regex:/^([a-zà-úÀ-Ú\\x20])+$/i');
if ($type == 'U') {
$rules['id_users'] = 'required|integer|exists:users,id_users';
$rules['email'] = 'email|unique:users,email,' . $data['id_users'] . ',id_users';
$rules['password'] = '******';
} elseif ($type == 'I') {
unset($rules['password']);
}
return \Validator::make($data, $rules);
}
/**
* validation
* @param $fields array this is field need remove in rules
*/
public function validate($fields = array())
{
$rules = array();
if (count($fields) > 0) {
$rules = array_except($this->rules, $fields);
} else {
$rules = $this->rules;
}
$v = \Validator::make($this->attributes, $rules, $this->messages);
$v->setAttributeNames($this->attributeNames);
if ($v->passes()) {
return true;
}
$this->errors = $v->messages();
return false;
}
protected function save_contact($title, $content)
{
$post = $request->all();
$v = \Validator::make($request->all(), ['firstname' => 'required', 'lastname' => 'required', 'email' => 'required', 'comment' => 'required']);
if ($v->fails()) {
return redirect()->back()->withErrors($v->errors());
} else {
$user = new contactus();
$user->firstname = $firstname;
$user->lastname = $lastname;
$user->email = $email;
$user->comment = $comment;
$user->save();
return true;
}
}
/**
*
* @param \Request $input
* @return static
*/
public static function createFromInput(Request $input, $id = null, $save = true)
{
$validator = \Validator::make($input->all(), static::$validationRules, static::$validationMessages);
if ($validator->fails()) {
throw new \App\Exceptions\Validation($validator);
}
$obj = static::findOrNew($id);
foreach (static::$availableFields as $fieldName) {
if ($input->has($fieldName)) {
$obj->setAttribute($fieldName, $input->get($fieldName));
}
}
$imageFields = static::$imageFields;
foreach ($imageFields as $fieldName) {
if ($input->hasFile($fieldName)) {
try {
$file = $input->file($fieldName);
if (!$file->isValid()) {
$validator->errors()->add($fieldName, "Invalid Image");
continue;
}
$dbFile = Image::createFromInput($file);
$obj->setAttribute($fieldName, $dbFile->hash);
} catch (\Exception $ex) {
$validator->errors()->add($fieldName, "Invalid Image");
}
}
}
if ($validator->fails()) {
throw new \App\Exceptions\Validation($validator);
}
if ($save) {
$obj->save();
}
return $obj;
}
/**
* [validate description]
* @param [type] $input [description]
* @param [type] $id [description]
* @return [type] [description]
*/
public static function validate($input, $id = null)
{
$rules = array('name_feature' => 'required|unique:features,name_feature,' . $id, 'url_action' => 'required', 'module_id' => 'required|exists:modules,id');
return \Validator::make($input, $rules);
}
/**
* [validate description]
* @param [type] $input [description]
* @param [type] $id [description]
* @return [type] [description]
*/
public static function validate($input, $id = null)
{
$rules = array('groupname' => 'required|unique:groups,groupname,' . $id);
return \Validator::make($input, $rules);
}
/**
* [validate description]
* @param [type] $input [description]
* @param [type] $id [description]
* @return [type] [description]
*/
public static function validate($input, $id = null)
{
$rules = array('name' => 'required|unique:category_feature,name');
return \Validator::make($input, $rules);
}
/**
* @param input array
* @param id int
* @return validator
*/
public static function validate($input, $id = null)
{
$rules = array("type_name" => "required|min:3|max:255|unique:type_devices,type_name," . $id);
return \Validator::make($input, $rules);
}
<?php
use App\Validator;
require_once "vendor/autoload.php";
$getModel = new \App\Models\UserModel();
$message = "";
if (!empty($_GET)) {
if (isset($_GET['id'], $_GET['validation_key'])) {
if (!empty($_GET['id']) && !empty($_GET['validation_key'])) {
$validator = new Validator();
if ($validator->alreadyActif($_GET['id'])) {
$message = "Votre compte est déjà actif";
} else {
if ($getModel->confirmUser($_GET['id'], $_GET['validation_key'])) {
$message = "Votre compte a bien été confirmé. Vous pouvez dorénavant vous connecter !";
}
}
}
}
}
?>
<!DOCTYPE html>
<html>
<head>
<meta charset = "utf-8" />
<title>Confirmation de l'email</title >
</head>
<body>
<?php
public static function validate($input, $id = null)
{
$rules = array('category_id' => 'required|exists:category_skills,id', 'skill' => 'required');
return \Validator::make($input, $rules);
}
/**
* validate
* @return validator
*/
public static function validate($input, $id = null)
{
$rules = array("name" => "required|min:2|max:255|unique:modules,name," . $id, "version" => "required|min:3|max:255", "order" => "required|numeric");
return \Validator::make($input, $rules);
}
/**
* @param input array
* @param id int
* @return Validator
*/
public static function validate($input, $id = null)
{
$rules = array('user_id' => 'required|exists:users,id', 'project_id' => 'required|exists:projects,id', 'group_id' => 'required|exists:groups,id', 'joined' => 'required');
return \Validator::make($input, $rules);
}
/**
* Validate category name skill
*
* @param [type] $input
* @param [int] $id
* @return Validator
*/
public static function validate($input, $id = null)
{
$rules = array('category_name' => 'required');
return \Validator::make($input, $rules);
}
/**
* Simple validator
*
* @param $data
*
* @return mixed
*
* @author Kondratenko Alexander (Xander)
*/
public static function validate($data)
{
$v = \Validator::make($data, self::$rules);
return $v->passes();
}
/**
* Fonction permettant d'update le sexe et la date de naissance d'un utilisateur
* @param string $token
* @param string $id
* @param string $gender
* @param string $birthday_date
* @param Validator $validator
* @return array
*/
public function updateGender($token, $id, $gender, $birthday_date, Validator $validator)
{
if (!$validator->checkGender($gender)) {
$validator->setErrors("error", true);
$validator->setErrors("gender", "Erreur lors de la selection du sexe");
}
if (!$validator->checkBirthdayDate($birthday_date)) {
$validator->setErrors("error", true);
$validator->setErrors("birthday_date", "Erreur avec la date de naissance");
}
if (!$validator->isTokenValid($token, $id)) {
$validator->setErrors("error", true);
$validator->setErrors("token", "Token non valide");
}
if (count($validator->getErrors()) === 0) {
$sql = $this->db->prepare("UPDATE users SET gender = ?, birthday_date = ? WHERE users.id = ?");
$sql->execute([$gender, $birthday_date, $id]);
if (!$sql->rowCount() > 0) {
$validator->setErrors("error", true);
$validator->setErrors("insert", "Erreur lors de l'insertion");
$validator->setErrors("date", $birthday_date);
}
}
return $validator->getErrors();
}
public function validate()
{
$validator = \Validator::make($this->toArray(), $this->rules());
return $validator->passes();
}
/**
* validate
* @param $input
* @param [int] $id
* @return validator
*/
public static function validate($input, $id = null)
{
$rules = array("device_name" => "required|max:255|unique:kind_devices,device_name," . $id, "quantity" => "required|max:255");
return \Validator::make($input, $rules);
}
public static function registrationValidation()
{
return Validator::make($data, ['name' => 'required|max:255', 'email' => 'required|email|max:255|unique:users', 'password' => 'required|confirmed|min:6']);
}
public static function validate($input, $id = null)
{
$rules = array('project_name' => 'required', 'start_date' => 'required|date', 'end_date' => 'required|date', 'user_id' => 'required|exists:users,id', 'status_id' => 'required|exists:statusprojects,id');
return \Validator::make($input, $rules);
}
public function validate()
{
$v = \Validator::make($this->attributes, $this->getRules());
return $v->fails() ? $v->errors() : true;
}
