PHP Request::only方法代码示例

 /**
  * Reset the given user's password.
  *
  * @param  \Illuminate\Http\Request  $request
  * @return \Illuminate\Http\Response
  */
 public function postReset(Request $request)
 {
     $credentials = $request->only('email', 'password', 'password_confirmation');
     $response = Password::reset($credentials, function ($user, $password) {
         $this->resetPassword($user, $password);
     });
     switch ($response) {
         case Password::PASSWORD_RESET:
             return redirect($this->redirectPath());
         default:
             return redirect()->back()->withInput($request->only('email'))->withErrors(['email' => trans($response)]);
     }
 }

 public function signup()
 {
     $payment_settings = PaymentSetting::first();
     if ($payment_settings->live_mode) {
         User::setStripeKey($payment_settings->live_secret_key);
     } else {
         User::setStripeKey($payment_settings->test_secret_key);
     }
     $token = Input::get('stripeToken');
     $user_data = array('username' => Input::get('username'), 'email' => Input::get('email'), 'password' => Hash::make(Input::get('password')));
     $input = Input::all();
     unset($input['stripeToken']);
     $validation = Validator::make($input, User::$rules);
     if ($validation->fails()) {
         //echo $validation->messages();
         //print_r($validation->errors()); die();
         return Redirect::to('/signup')->with(array('note' => 'Sorry, there was an error creating your account.', 'note_type' => 'error', 'messages'))->withErrors($validation)->withInput(\Request::only('username', 'email'));
     }
     $user = new User($user_data);
     $user->save();
     try {
         $user->subscription('monthly')->create($token, ['email' => $user->email]);
         Auth::loginUsingId($user->id);
         return Redirect::to('/')->with(array('note' => 'Welcome! Your Account has been Successfully Created!', 'note_type' => 'success'));
     } catch (Exception $e) {
         Auth::logout();
         $user->delete();
         return Redirect::to('/signup')->with(array('note' => 'Sorry, there was an error with your card: ' . $e->getMessage(), 'note_type' => 'error'))->withInput(\Request::only('username', 'email'));
     }
 }

 /**
  * Start the creation of a new balance payment
  *   Details get posted into this method
  * @param $userId
  * @throws \BB\Exceptions\AuthenticationException
  * @throws \BB\Exceptions\FormValidationException
  * @throws \BB\Exceptions\NotImplementedException
  */
 public function store($userId)
 {
     $user = User::findWithPermission($userId);
     $this->bbCredit->setUserId($user->id);
     $requestData = \Request::only(['reason', 'amount', 'return_path', 'ref']);
     $amount = $requestData['amount'] * 1 / 100;
     $reason = $requestData['reason'];
     $returnPath = $requestData['return_path'];
     $ref = $requestData['ref'];
     //Can the users balance go below 0
     $minimumBalance = $this->bbCredit->acceptableNegativeBalance($reason);
     //What is the users balance
     $userBalance = $this->bbCredit->getBalance();
     //With this payment will the users balance go to low?
     if ($userBalance - $amount < $minimumBalance) {
         if (\Request::wantsJson()) {
             return \Response::json(['error' => 'You don\'t have the money for this'], 400);
         }
         \Notification::error("You don't have the money for this");
         return \Redirect::to($returnPath);
     }
     //Everything looks gooc, create the payment
     $this->paymentRepository->recordPayment($reason, $userId, 'balance', '', $amount, 'paid', 0, $ref);
     //Update the users cached balance
     $this->bbCredit->recalculate();
     if (\Request::wantsJson()) {
         return \Response::json(['message' => 'Payment made']);
     }
     \Notification::success("Payment made");
     return \Redirect::to($returnPath);
 }

 public function login()
 {
     $data = Request::only('email', 'password');
     $data['password'] = md5($data['password']);
     $rules = array('email' => 'required|email', 'password' => 'required|alphaNum|min:6');
     $validator = Validator::make($data, $rules);
     $result = array('errors' => '', 'result' => '');
     if ($validator->fails()) {
         $messages = $validator->messages();
         foreach ($messages->all() as $message) {
             $result['errors'] .= "<li>{$message}</li>";
         }
         return json_encode($result);
     }
     $user = new User();
     $response = $user->login($data);
     if ($response['status'] === true) {
         $sessionData = array();
         $sessionData['id'] = $response['id'];
         $sessionData['email'] = $response['email'];
         $result['result'] = 'success';
         Session::put('user_data', $sessionData);
     } else {
         $result['errors'] = 'Username or password incorrect. Please try again';
     }
     return json_encode($result);
 }

 public function compose(View $view)
 {
     $documentForm = \Request::only('responsable_id');
     $route = Route::currentRouteName();
     $users = User::orderBy('name', 'ASC')->lists('name', 'id')->toArray();
     $view->with(compact('documentForm', 'users', 'route'));
 }

 /**
  * Start the creation of a new gocardless payment
  *   Details get posted into this method and the redirected to gocardless
  * @param $userId
  * @throws \BB\Exceptions\AuthenticationException
  * @throws \BB\Exceptions\FormValidationException
  * @throws \BB\Exceptions\NotImplementedException
  */
 public function store($userId)
 {
     User::findWithPermission($userId);
     $requestData = \Request::only(['reason', 'amount', 'return_path', 'stripeToken', 'ref']);
     $stripeToken = $requestData['stripeToken'];
     $amount = $requestData['amount'];
     $reason = $requestData['reason'];
     $returnPath = $requestData['return_path'];
     $ref = $requestData['ref'];
     try {
         $charge = Stripe_Charge::create(array("amount" => $amount, "currency" => "gbp", "card" => $stripeToken, "description" => $reason));
     } catch (\Exception $e) {
         \Log::error($e);
         if (\Request::wantsJson()) {
             return \Response::json(['error' => 'There was an error confirming your payment'], 400);
         }
         \Notification::error("There was an error confirming your payment");
         return \Redirect::to($returnPath);
     }
     //Replace the amount with the one from the charge, this prevents issues with variable tempering
     $amount = $charge->amount / 100;
     //Stripe don't provide us with the fee so this should be OK
     $fee = $amount * 0.024 + 0.2;
     $this->paymentRepository->recordPayment($reason, $userId, 'stripe', $charge->id, $amount, 'paid', $fee, $ref);
     if (\Request::wantsJson()) {
         return \Response::json(['message' => 'Payment made']);
     }
     \Notification::success("Payment made");
     return \Redirect::to($returnPath);
 }

 /**
  * Update the specified resource in storage.
  *
  * @param  int  $id
  * @return Response
  */
 public function update($id)
 {
     $role = Role::findOrFail($id);
     $formData = \Request::only(['description', 'title', 'email_public', 'email_private', 'slack_channel']);
     $this->roleValidator->validate($formData);
     $role->update($formData);
     return \Redirect::back();
 }

 public function update($proposalId)
 {
     $this->proposalValidator->validate(\Request::all(), $proposalId);
     $data = \Request::only('title', 'description', 'start_date', 'end_date');
     $this->proposalRepository->update($proposalId, $data);
     \Notification::success("Proposal updated");
     return \Redirect::route('proposals.index');
 }

 /**
  * @param $id
  * @return \Illuminate\Http\RedirectResponse
  */
 public function block($id)
 {
     $shop = Shops::find($id);
     $input = \Request::only('blocked')['blocked'];
     $shop->blocked = $input;
     $shop->update();
     return redirect()->route('admin.shops.index');
 }

 public function store()
 {
     $this->feedbackValidator->validate(\Request::only('comments'));
     $memberName = \Auth::user()->name;
     \Mail::queue('emails.feedback', ['memberName' => $memberName, 'comments' => \Request::get('comments')], function ($message) {
         $message->to('arthur@arthurguy.co.uk', 'Arthur Guy')->subject('BBMS Feedback');
     });
     return \Response::json(['success' => 1]);
 }

 public function store()
 {
     $data = new Kadis();
     dd(Request::only('title', 'zaki'));
     if ($data->fill([])->save()) {
         return redirect()->route('kadis.index');
     }
     return route('kadis.index');
 }

 /**
  * Handle the reauthentication request to the application.
  *
  * @param  \Illuminate\Http\Request  $request
  * @param  \Orchestra\Foundation\Validation\Account  $validator
  *
  * @return mixed
  */
 public function reauth(Request $request, AccountValidator $validator)
 {
     $validation = $validator->on('reauthenticate')->with($request->only(['password']));
     if ($validation->fails()) {
         return $this->userReauthenticateHasFailedValidation($validation->getMessageBag());
     } elseif (!(new ReauthLimiter($request))->attempt($request->input('password'))) {
         return $this->userHasFailedReauthentication();
     }
     return $this->userHasReauthenticated();
 }

 public function in()
 {
     $credentials = \Request::only('email', 'password');
     if ($token = \JWTAuth::attempt($credentials)) {
         $response = response()->json(['token' => $token]);
     } else {
         $response = response()->json(['errors' => ['The email/password is invalid.']], 400);
     }
     return $response;
 }

 /**
  * Store a newly created resource in storage.
  *
  * @return Response
  */
 public function store($roleId)
 {
     $formData = \Request::only(['user_id']);
     $this->roleUserValidator->validate($formData);
     $role = Role::findOrFail($roleId);
     //If the user isnt already a member add them
     if (!$role->users()->get()->contains($formData['user_id'])) {
         $role->users()->attach($formData['user_id']);
     }
     return \Redirect::back();
 }

 public function postLogin()
 {
     $credentials = Request::only('email', 'password');
     $validator = Validator::make($credentials, ['email' => 'required|email', 'password' => 'required']);
     if ($validator->valid()) {
         if (Auth::attempt($credentials)) {
             return Redirect::intended('/');
         }
     }
     return Redirect::to('auth/login')->withInput(Request::only('email'))->withErrors(['email' => 'Invalid credentials']);
 }