PHP Hasher::make方法代码示例

 /**
  * @param array $attributes
  *
  * @return array
  */
 protected function hashPassword(array $attributes)
 {
     if (isset($attributes['password']) && isset($attributes['password_confirmation']) && $attributes['password'] == $attributes['password_confirmation']) {
         $attributes['password'] = $attributes['password_confirmation'] = $this->hasher->make($attributes['password']);
     }
     return $attributes;
 }

 public function fire(array $data)
 {
     $this->validator->setScenario('register')->validate($data);
     $data['password'] = $this->hasher->make($data['password']);
     $user = $this->userModel->create($data);
     event(new UserRegistered($user));
     return $user;
 }

 /**
  * Return a hash that has no / in it suited for url generated.
  *
  * @param $value
  * @return string
  */
 protected function hash($value)
 {
     $hash = $this->hasher->make($value);
     while (strpos($hash, '/') !== false) {
         $hash = $this->hasher->make($value);
     }
     return $hash;
 }

 /**
  * Create a new user in the database.
  *
  * @param  array $data
  * @return \Begin\User
  */
 public function create(array $data)
 {
     $user = $this->getNew();
     $user->name = $data['name'];
     $user->email = $data['email'];
     $user->password = $this->hasher->make($data['password']);
     $user->save();
     return $user;
 }

 /**
  * @param string $email
  * @param string $password
  * @param bool   $isStaff
  *
  * @throws \DomainException
  * @throws \Illuminate\Database\Eloquent\ModelNotFoundException
  *
  * @return User
  */
 public function make(string $email, string $password, bool $isStaff) : User
 {
     if (!$this->validate($email, $password)) {
         throw new DomainException();
     }
     $user = new User();
     $user->email = $email;
     $user->password = $this->hasher->make($password);
     if ($isStaff) {
         $staffRole = $this->roleResource->mustFindByName(Role::STAFF);
         $staffRole->users()->save($user);
     }
     return $user;
 }

 public function fire(array $data)
 {
     $this->validator->setScenario('recoverPassword')->validate($data);
     $token = $this->tokenHelper->validate($data['token']);
     if ($token === false) {
         $this->response()->errorBadRequest(trans('messages.token_invalid'));
     }
     $user = $token->tokenable->first();
     if ($user === NULL) {
         $this->response()->errorBadRequest(trans('messages.token_invalid'));
     }
     $user->password = $this->hasher->make($data['password']);
     $user->save();
     $token->delete();
     return $user;
 }

 /**
  * Execute the command.
  *
  * @return void
  */
 public function handle(UserRepositoryInterface $users, Hasher $hasher)
 {
     if (!($user = $users->findByResetToken($this->token))) {
         throw new DisplayException('auth::reset.error');
     }
     $users->resetPassword($user, $hasher->make($this->password));
 }

 public function postReset()
 {
     $credentials = $this->request->only('email', 'password', 'password_confirmation', 'token');
     $response = $this->password->reset($credentials, function ($user, $password) {
         $user->password = $this->hasher->make($password);
         $user->save();
     });
     switch ($response) {
         case $this->password->INVALID_PASSWORD:
         case $this->password->INVALID_TOKEN:
         case $this->password->INVALID_USER:
             return $this->redirector->back()->with('error', $this->translator->get($response));
         case $this->password->PASSWORD_RESET:
             return $this->redirector->to('/');
     }
 }

 /**
  * @param Request $request
  * @param Hasher $hasher
  * @return mixed|string
  */
 protected function getNewHash(Request $request, Hasher $hasher)
 {
     $email = $request->get('email');
     $hash = $hasher->make(time() . 'someRandome123string' . $email);
     $hash = str_replace('/', '_', $hash);
     return $hash;
 }

 /**
  * Resets a given users password
  *
  * @param User $user
  * @param $pwd
  * @return User
  */
 public function resetPassword(User $user, $pwd)
 {
     $hashed = $this->hasher->make($pwd);
     $user->setPassword(new HashedPassword($hashed));
     $this->userRepo->update($user);
     return $user;
 }

 /**
  * @return \jorenvanhocht\Blogify\Models\Post
  */
 private function storeOrUpdatePost()
 {
     if (!empty($this->data->hash)) {
         $post = $this->post->byHash($this->data->hash);
     } else {
         $post = new Post();
         $post->hash = $this->blogify->makeHash('posts', 'hash', true);
     }
     $post->slug = $this->data->slug;
     $post->title = $this->data->title;
     $post->content = $this->data->post;
     $post->status_id = $this->status->byHash($this->data->status)->id;
     $post->publish_date = $this->data->publishdate;
     $post->user_id = $this->user->byHash($this->auth_user->hash)->id;
     $post->reviewer_id = $this->user->byHash($this->data->reviewer)->id;
     $post->visibility_id = $this->visibility->byHash($this->data->visibility)->id;
     $post->category_id = $this->category->byHash($this->data->category)->id;
     $post->being_edited_by = null;
     if (!empty($this->data->password)) {
         $post->password = $this->hash->make($this->data->password);
     }
     $post->save();
     $post->tag()->sync($this->tags);
     return $post;
 }

 /**
  * Reset the given user's password.
  *
  * @param  \Illuminate\Contracts\Auth\CanResetPassword  $user
  * @param  string  $password
  * @return void
  */
 protected function resetPassword($user, $password)
 {
     /** @var $user User */
     $user->setPassword($this->hasher->make($password));
     $this->em->persist($user);
     $this->em->flush();
     Auth::guard($this->getGuard())->login($user);
 }

 /**
  * @param string $hash
  * @param \jorenvanhocht\Blogify\Requests\ProfileUpdateRequest $request
  * @return \Illuminate\Http\RedirectResponse
  */
 public function update($hash, ProfileUpdateRequest $request)
 {
     $user = $this->user->byHash($hash);
     $user->lastname = $request->name;
     $user->firstname = $request->firstname;
     $user->username = $request->username;
     $user->email = $request->email;
     if ($request->has('newpassword')) {
         $user->password = $this->hash->make($request->newpassword);
     }
     if ($request->hasFile('profilepicture')) {
         $this->handleImage($request->file('profilepicture'), $user);
     }
     $user->save();
     $this->tracert->log('users', $user->id, $this->auth_user->id, 'update');
     $message = trans('blogify::notify.success', ['model' => 'User', 'name' => $user->fullName, 'action' => 'updated']);
     session()->flash('notify', ['success', $message]);
     return redirect()->route('admin.dashboard');
 }

 public function changePassword(ChangePasswordRequest $request, Auth $auth, Hasher $hash)
 {
     $user = $auth->user();
     if ($hash->check($request->password, $user->password) == false) {
         return redirect('changePassword')->withErrors('Senha atual incorreta.');
     }
     $user->password = $hash->make($request->new_password);
     $user->save();
     return redirect('/');
 }

 /**
  * Execute the command.
  *
  * @param Hasher $hasher
  * @param UserRepository $users
  * @return User
  * @throws UserAlreadyExistsException
  */
 public function handle(Hasher $hasher, UserRepository $users)
 {
     try {
         $users->findByEmail($this->email);
         throw new UserAlreadyExistsException($this->email);
     } catch (ModelNotFoundException $e) {
         $user = User::register($this->name, $this->email, $hasher->make($this->password), 'admin');
         $users->save($user);
         event(new UserWasRegistered($user));
         return $user;
     }
 }