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

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

 /**
  * @param User $user
  * @param Hasher $hash
  * @param Dispatcher $events
  * @return User
  * @throws Exception
  */
 public function handle(User $user, Hasher $hash, Dispatcher $events)
 {
     $connection = $user->getConnection();
     $connection->beginTransaction();
     //we already have a user with this email.
     try {
         if (!$this->user) {
             $this->user = $user;
             $this->user->email = $this->email;
             $this->user->password = $hash->make($this->password);
             $this->user->save();
         }
         $events->fire(new UserRegistered($this->user, $this->invitation));
         $connection->commit();
         return $this->user;
     } catch (Exception $e) {
         $connection->rollBack();
         throw $e;
     }
 }

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

 public function fire(array $data)
 {
     $this->validator->setScenario('login')->validate($data);
     $user = $this->user->where('email', $data['email'])->first();
     if (!$this->hasher->check($data['password'], $user->password)) {
         throw new LoginFailedException();
     }
     return $user;
 }

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

 /**
  * Handle an incoming request.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  \Closure  $next
  * @return mixed
  */
 public function handle($request, Closure $next)
 {
     $post = $this->post->bySlug($request->segment(2));
     if ($post->visibility_id == 2) {
         if (!$this->hash->check(Input::get('password'), $post->password)) {
             return redirect()->route('blog.askPassword', [$post->slug])->with('wrong_password', 'Please provide a valid password to view this post');
         }
     }
     return $next($request);
 }

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

 /**
  * 비회원 작성 글 인증 확인
  *
  * @param ItemEntity $item       board item entity
  * @param string     $email      email
  * @param string     $certifyKey 인증 암호
  * @return bool
  */
 public function verify(ItemEntity $item, $email, $certifyKey)
 {
     if ($email != $item->email) {
         return false;
     }
     return $this->hasher->check($certifyKey, $item->certifyKey);
 }

 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;
 }

 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 Board  $board      board model
  * @param string $email      email
  * @param string $certifyKey 인증 암호
  * @return bool
  */
 public function verify(Board $board, $email, $certifyKey)
 {
     if ($email != $board->email) {
         return false;
     }
     return $this->hasher->check($certifyKey, $board->certifyKey);
 }

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

 /**
  * Validate a user against the given credentials.
  *
  * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
  * @param  array  $credentials
  * @return bool
  */
 public function validateCredentials(UserContract $user, array $credentials)
 {
     $credentialsValidated = false;
     // If the user is set AND, either of auth_type 'internal' or with
     // auth_type unset or null, then validate against the stored
     // password hash. Otherwise if the LDAP authentication
     // method is enabled, try it.
     if (isset($user) && (isset($user->auth_type) && $this->ldapConfig['label_internal'] === $user->auth_type || !isset($user->auth_type))) {
         $plain = $credentials['password'];
         $credentialsValidated = $this->hasher->check($plain, $user->getAuthPassword());
     } else {
         if ($this->ldapConfig['enabled'] && $this->ldapConfig['label_ldap'] === $user->auth_type) {
             // Validate credentials against LDAP/AD server.
             $credentialsValidated = $this->validateLDAPCredentials($credentials);
             // If validated and config set to resync group membership on login.
             if ($credentialsValidated && $this->ldapConfig['resync_on_login']) {
                 // First, revoke membership to all groups marked to 'resync_on_login'.
                 $this->revokeMembership($user);
                 // Then replicate group membership.
                 $this->replicateMembershipFromLDAP($user);
             }
         }
     }
     return $credentialsValidated;
 }

 /**
  * Should generate a password if none given.
  */
 public function testGeneratesPasswordIfNoneGiven()
 {
     $this->hasher->expects($this->atLeastOnce())->method('make')->with($this->isType('string'))->willReturn($this->generator()->anyString());
     $this->userResource->expects($this->atLeastOnce())->method('setAttribute')->withConsecutive($this->anything(), ['password', $this->isType('string')]);
     $tester = $this->commandTester($this->makeUser);
     $tester->execute([]);
 }

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