PHP AuthManager::user方法代码示例

 /**
  * @param $request
  * @param callable $next
  * @return mixed
  */
 public function handle($request, \Closure $next)
 {
     if ($this->auth->check()) {
         $this->app->setLocale($this->auth->user()->getLocale());
     }
     return $next($request);
 }

 public function postFork($hash)
 {
     $parent = $this->repository->getByHash($hash);
     $command = new Commands\CreateForkCommand($this->request->get('code'), $this->auth->user(), $parent);
     $fork = $this->bus->execute($command);
     return $this->redirector->action('BinController@getShow', [$fork->hash]);
 }

 public function getIndex()
 {
     $user = $this->auth->user();
     $threads = $this->threadRepository->getRecentByMember($user);
     $replies = $this->replyRepository->getRecentByMember($user);
     $this->render('dashboard.index', compact('user', 'threads', 'replies'));
 }

 /**
  * Authenticate request with Basic.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  \Illuminate\Routing\Route  $route
  * @return mixed
  */
 public function authenticate(Request $request, Route $route)
 {
     $this->validateAuthorizationHeader($request);
     if ($response = $this->auth->onceBasic($this->identifier) and $response->getStatusCode() === 401) {
         throw new UnauthorizedHttpException('Basic', 'Invalid authentication credentials.');
     }
     return $this->auth->user();
 }

 /**
  * composing the view
  *
  * @param \Illuminate\View\View $view
  */
 public function compose(\Illuminate\View\View $view)
 {
     $notifications = [];
     if (null !== ($user = $this->authManager->user())) {
         $notifications = $this->notificationManager->getForUser($user, [NotificationActivity::CREATED, NotificationActivity::READ]);
     }
     $view->with('notifications', $notifications);
 }

 public function postDelete($replyId)
 {
     $reply = $this->replies->requireById($replyId);
     $thread = $reply->thread;
     $command = new Commands\DeleteReplyCommand($reply, $this->auth->user());
     $reply = $this->bus->execute($command);
     return $this->redirector->action('ForumController@getViewThread', [$thread->slug]);
 }

 /**
  * @param array $data
  * @return \HorseStories\Models\Events\Event
  */
 public function create($data = [])
 {
     $event = new Event();
     $event->name = $data['event_name'];
     $event->creator_id = $this->auth->user()->id;
     $event->save();
     return $event;
 }

 /**
  * Get the prepared validation rules.
  *
  * @return array
  */
 protected function getPreparedRules()
 {
     $forbidden = implode(',', $this->config->get('config.forbidden_usernames', []));
     $userId = $this->auth->user()->id;
     $this->rules['username'] .= '|not_in:' . $forbidden;
     $this->rules['username'] .= '|unique:users,username,' . $userId;
     return $this->rules;
 }

 /**
  * @param \HorseStories\Models\Statuses\Status $status
  * @param string $body
  * @return \HorseStories\Models\Comments\Comment
  */
 public function create(Status $status, $body)
 {
     $comment = new Comment();
     $comment->status_id = $status->id;
     $comment->body = $body;
     $comment->user_id = $this->auth->user()->id;
     $comment->save();
     return $comment;
 }

 /**
  * @{inheritDoc}
  */
 public function collect()
 {
     try {
         $user = $this->auth->user();
     } catch (\Exception $e) {
         $user = null;
     }
     return $this->getUserInformation($user);
 }

 /**
  * Create an instance of the Manager
  *
  * @param  \Illuminate\Routing\Router 			 $router
  * @param  \Illuminate\Database\DatabaseManager  $db
  * @param  \Illuminate\Auth\AuthManager 		 $auth
  * @param  \Illuminate\Config\repository 		 $config
  * @return void
  */
 public function __construct(Router $router, IlluminateDatabaseManager $db, AuthManager $auth, Repository $config)
 {
     $this->db = $db;
     $this->router = $router;
     $this->auth = $auth;
     $this->config = $config;
     // Set the user object
     $this->user = $this->auth->user();
     // Set the role control identifier from config
     $this->roleControlIdentifier = $this->config->get('role::role.control.identifier');
 }

 public function filter(Route $route, Request $request)
 {
     /** @var \anlutro\Core\Auth\Users\UserModel $user */
     if (!($user = $this->auth->user())) {
         throw new \RuntimeException('auth filter must precede access filter');
     }
     // get an array of function arguments #3 and up
     $params = array_slice(func_get_args(), 2);
     foreach ($params as $access) {
         if (!$user->hasAccess($access)) {
             return $this->makeResponse($request);
         }
     }
 }

 /**
  * Log in the user.
  * 
  * @return \Response
  */
 public function store()
 {
     $input = Input::only('email', 'password');
     $remember = Input::has('remember');
     $this->logInForm->validate($input);
     if (!$this->auth->once($input)) {
         return json(['errors' => trans('errors.credentials')]);
     }
     if (!$this->auth->user()->confirmed) {
         return json(['errors' => trans('errors.not_confirmed')]);
     }
     $this->auth->login($this->auth->user(), $remember);
     return json(true);
 }

 public function __construct(DriverLocationTransformer $driverLocationTransformer, AuthManager $authManager, JsonRespond $jsonRespond)
 {
     parent::__construct($jsonRespond);
     $this->user = $authManager->user();
     $this->jsonRespond = $jsonRespond;
     $this->driverLocationTransformer = $driverLocationTransformer;
 }

 /**
  * DriversController constructor.
  * @param AuthManager $auth
  * @param User $users
  * @param JsonRespond $jsonRespond
  * @param UserTransformer $userTransformer
  */
 public function __construct(AuthManager $auth, User $users, JsonRespond $jsonRespond, UserTransformer $userTransformer)
 {
     $this->user = $auth->user();
     $this->userTransformer = $userTransformer;
     $this->users = $users;
     parent::__construct($jsonRespond);
 }