PHP Guard::getUser方法代码示例

 /**
  * Handle an incoming request.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  \Closure  $next
  * @return mixed
  */
 public function handle($request, Closure $next)
 {
     if (!$this->auth->getUser()->can(Route::currentRouteAction())) {
         return abort(403);
     }
     return $next($request);
 }

 /**
  * Handle an incoming request.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  \Closure  $next
  * @return mixed
  */
 public function handle($request, Closure $next)
 {
     $user = $this->auth->getUser();
     $confirmed = $user['confirmed'];
     if (isset($confirmed) && $confirmed == "0") {
         // If the user has not had an activation token set
         $confirmation_code = $user->confirmation_code;
         if (empty($confirmation_code)) {
             // generate a confirmation code
             $key = \Config::get('app.key');
             do {
                 $confirmation_code = hash_hmac('sha256', str_random(40), $key);
             } while (User::where('confirmation_code', $confirmation_code)->exists());
             $user->confirmation_code = $confirmation_code;
             $user->save();
             \Mail::send('emails.activate', ['token' => $confirmation_code, 'name' => $user->name], function ($message) use($user) {
                 $message->from($user->email);
                 $message->to("hpapms@gmail.com", "Admin")->subject('Account Verification');
             });
         }
         \Session::put('alertMessage', 'Your email needs confirmation from admin!');
         return redirect()->guest('auth/logout');
     }
     return $next($request);
 }

 /**
  * Handle an incoming request.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  \Closure  $next
  * @return mixed
  */
 public function handle($request, Closure $next)
 {
     if ($this->auth->guest() || !$this->auth->getUser()->is_admin) {
         if ($request->ajax()) {
             return response('Unauthorized.', 401);
         } else {
             return redirect()->guest(route('admin.login'));
         }
     }
     return $next($request);
 }

 /**
  * Handle an incoming request.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  \Closure  $next
  * @return mixed
  */
 public function handle($request, Closure $next)
 {
     if ($this->auth->guest() || $this->auth->getUser()->is_admin <= 1) {
         if ($request->ajax()) {
             return response('Unauthorized.', 401);
         } else {
             return redirect()->back()->withErrors('Unauthorized Access');
         }
     }
     return $next($request);
 }

 /**
  * Handle an incoming request.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  \Closure  $next
  * @return mixed
  */
 public function handle($request, Closure $next)
 {
     if ($this->auth->guest()) {
         if ($request->ajax()) {
             return response('Unauthorized.', 401);
         } else {
             return redirect()->guest('auth/login');
         }
     }
     App::setLocale($this->auth->getUser()->language_code);
     return $next($request);
 }

 /**
  * Handle an incoming request.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  \Closure  $next
  * @return mixed
  */
 public function handle($request, Closure $next)
 {
     if ($this->auth->guest()) {
         if ($request->ajax()) {
             return response('Unauthorized.', 401);
         } else {
             return redirect()->guest('auth/login');
         }
     }
     if ($this->auth->getUser()->role_id !== 1) {
         return redirect()->guest('auth/login');
     }
     return $next($request);
 }

 /**
  * Update the specified resource in storage.
  *
  * @param  int  $id
  * @return Response
  */
 public function update($id, UpdateAccountRequest $request, Guard $auth, AccountRepository $account_respository, APIControllerHelper $helper)
 {
     $user = $auth->getUser();
     if (!$user) {
         throw new Exception("User not found", 1);
     }
     // get non null attributes only
     $attributes = $request->only(array_keys($request->rules()));
     $non_null_attributes = [];
     foreach ($attributes as $k => $v) {
         if ($v !== null) {
             $non_null_attributes[$k] = $v;
         }
     }
     if (!$non_null_attributes) {
         return $helper->buildJSONResponse(['message' => 'nothing to update'], 400);
     }
     // update
     try {
         return $helper->update($account_respository, $id, $non_null_attributes, $user);
     } catch (Exception $e) {
         if ($e->getCode() >= 400 and $e->getCode() < 500) {
             throw new HttpResponseException(new JsonResponse(['message' => $e->getMessage()], 400));
         }
         throw $e;
     }
 }

 /**
  * Handle delete account request
  *
  * @return \Illuminate\Http\Response
  */
 public function destroy()
 {
     $user = $this->auth->getUser();
     $this->repo->destroy($user->id);
     event('UserDeleted', [$user]);
     return $this->respondDeleteSuccess();
 }

 public function transfer($address_uuid, Guard $auth, AccountTransferRequest $request, APIControllerHelper $helper, PaymentAddressRepository $payment_address_repository, APICallRepository $api_call_repository)
 {
     $user = $auth->getUser();
     if (!$user) {
         throw new Exception("User not found", 1);
     }
     $payment_address = $helper->requireResourceOwnedByUser($address_uuid, $user, $payment_address_repository);
     $params = $helper->getAttributesFromRequest($request);
     $api_call = $api_call_repository->create(['user_id' => $user['id'], 'details' => ['method' => 'api/v1/accounts/transfer/' . $address_uuid, 'args' => $params]]);
     try {
         if (isset($params['close']) and $params['close']) {
             AccountHandler::close($payment_address, $params['from'], $params['to'], $api_call);
         } else {
             if (isset($params['quantity']) and isset($params['asset'])) {
                 AccountHandler::transfer($payment_address, $params['from'], $params['to'], $params['quantity'], $params['asset'], isset($params['txid']) ? $params['txid'] : null, $api_call);
             } else {
                 // transfer all
                 AccountHandler::transferAllByTIXD($payment_address, $params['from'], $params['to'], $params['txid'], $api_call);
             }
         }
         // done
         return $helper->buildJSONResponse([], 204);
     } catch (AccountException $e) {
         return $helper->buildJSONResponse(['message' => $e->getMessage(), 'errorName' => $e->getErrorName()], $e->getStatusCode());
     } catch (HttpException $e) {
         return $helper->buildJSONResponse(['message' => $e->getMessage()], $e->getStatusCode());
     }
 }

 /**
  * Prime the address with UTXOs of a certain size
  *   only if needed
  * 
  *
  * @return Response
  */
 public function primeAddress($address_uuid, Guard $auth, Request $request, APIControllerHelper $helper, PaymentAddressRepository $payment_address_repository, TXORepository $txo_repository, TXOChooser $txo_chooser, PaymentAddressSender $payment_address_sender)
 {
     try {
         $user = $auth->getUser();
         if (!$user) {
             throw new Exception("User not found", 1);
         }
         $payment_address = $helper->requireResourceOwnedByUser($address_uuid, $user, $payment_address_repository);
         $size = floatval($request->input('size'));
         if ($size <= 0) {
             throw new Exception("Invalid size", 400);
         }
         $size_satoshis = CurrencyUtil::valueToSatoshis($size);
         $desired_prime_count = floatval($request->input('count'));
         if ($desired_prime_count <= 0) {
             throw new Exception("Invalid count", 400);
         }
         $fee = $request->input('fee');
         if ($fee !== null) {
             $fee = floatval($fee);
             if ($fee <= 0) {
                 throw new Exception("Invalid fee", 400);
             }
         }
         // get the UTXOs
         //   [TXO::UNCONFIRMED, TXO::CONFIRMED]
         $txos = $this->filterGreenOrConfirmedUTXOs($txo_repository->findByPaymentAddress($payment_address, null, true));
         // count the number that match the size
         $current_primed_count = 0;
         foreach ($txos as $txo) {
             if ($txo['amount'] == $size_satoshis) {
                 ++$current_primed_count;
             }
         }
         $txid = null;
         $new_primed_count = $current_primed_count;
         if ($desired_prime_count > $current_primed_count) {
             // create a new priming transaction...
             $desired_new_primes_count_to_create = $desired_prime_count - $current_primed_count;
             $actual_new_primes_count_to_create = $this->findMaximumNewPrimeCountTXOs($txo_chooser, $payment_address, $desired_new_primes_count_to_create, $size, $fee);
             if ($actual_new_primes_count_to_create > 0) {
                 $txid = $this->sendPrimingTransaction($payment_address_sender, $payment_address, $size, $actual_new_primes_count_to_create, $fee);
                 $new_primed_count = $current_primed_count + $actual_new_primes_count_to_create;
             }
         }
         $output = ['oldPrimedCount' => $current_primed_count, 'newPrimedCount' => $new_primed_count, 'txid' => $txid, 'primed' => $txid ? true : false];
         return $helper->buildJSONResponse($output);
     } catch (Exception $e) {
         if ($e->getCode() >= 400 and $e->getCode() < 500) {
             throw new HttpResponseException(new JsonResponse(['errors' => [$e->getMessage()]], 400));
         }
         throw $e;
     }
 }

 /**
  * Handle an incoming request.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  \Closure  $next
  * @return mixed
  */
 public function handle($request, Closure $next)
 {
     $user = $this->auth->getUser();
     $confirmed = $user->confirmed;
     if (isset($confirmed) && $confirmed == "0") {
         // If the user has not had an activation token set
         $confirmation_code = $user->confirmation_code;
         if (empty($confirmation_code)) {
             // generate a confirmation code
             $key = \Config::get('app.key');
             $confirmation_code = hash_hmac('sha256', str_random(40), $key);
             $user->confirmation_code = $confirmation_code;
             $user->save();
             \Mail::send('emails.activate', ['token' => $confirmation_code, 'name' => $user->name], function ($message) use($user) {
                 $message->to($user->getEmailForPasswordReset(), $user->name)->subject('Activate your Notify account');
             });
         }
         return redirect()->guest('/activate');
     }
     return $next($request);
 }

 /**
  * Store a newly created resource in storage.
  *
  * @return Response
  */
 public function store(APIControllerHelper $helper, CreateMonitorRequest $request, MonitoredAddressRepository $address_respository, Guard $auth)
 {
     $user = $auth->getUser();
     if (!$user) {
         throw new Exception("User not found", 1);
     }
     $attributes = $request->only(array_keys($request->rules()));
     $attributes['user_id'] = $user['id'];
     $address = $address_respository->create($attributes);
     EventLog::log('monitor.created', json_decode(json_encode($address)));
     return $helper->transformResourceForOutput($address);
 }

 /**
  * Store a newly created resource in storage.
  *
  * @return Response
  */
 public function store(APIControllerHelper $helper, CreatePaymentAddressRequest $request, PaymentAddressRepository $payment_address_respository, Guard $auth)
 {
     $user = $auth->getUser();
     if (!$user) {
         throw new Exception("User not found", 1);
     }
     $attributes = $request->only(array_keys($request->rules()));
     $attributes['user_id'] = $user['id'];
     $address = $payment_address_respository->create($attributes);
     EventLog::log('paymentAddress.created', $address->toArray());
     // create a default account
     AccountHandler::createDefaultAccount($address);
     return $helper->transformResourceForOutput($address);
 }

 /**
  * Handle a login request to the application.
  *
  * @param AuthRequest $request
  * @return \Illuminate\Http\Response
  */
 public function postLogin(AuthRequest $request)
 {
     $throttles = in_array(ThrottlesLogins::class, class_uses_recursive(get_class($this)));
     if ($throttles && $this->hasTooManyLoginAttempts($request)) {
         return $this->respondThrottled($request);
     }
     if (!$this->auth->once($request->only('email', 'password'))) {
         if ($throttles) {
             $this->incrementLoginAttempts($request);
         }
         return $this->respondLoginFail($request);
     }
     $user = $this->auth->getUser();
     if (!$user->activated) {
         $this->auth->logout();
         return $this->respondNotActivated($request, $user->activation_code);
     }
     $this->auth->loginUsingId($user->id, $request->has('remember'));
     if ($throttles) {
         $this->clearLoginAttempts($request);
     }
     event('UserHasLoggedIn', [$this->auth->user()]);
     return $this->respondLoginSuccess($request, $user);
 }

 /**
  * @param UserRepository $userRepository
  * @param ShiftRepository $shiftRepository
  * @param Shift $shift
  * @param Guard $auth
  * @return Shift
  */
 public function handle(UserRepository $userRepository, ShiftRepository $shiftRepository, Shift $shift, Guard $auth)
 {
     $shift->setBreak($this->break);
     $shift->setStartTime($this->start_time);
     $shift->setEndTime($this->end_time);
     if ($this->employee_id) {
         $shift->setEmployee($userRepository->getOneById($this->employee_id));
     }
     if ($this->manager_id) {
         $shift->setManager($userRepository->getOneById($this->manager_id));
     } else {
         $shift->setManager($auth->getUser());
     }
     $shiftRepository->store($shift);
     $shiftRepository->update($shift);
     return $shift;
 }