Send another verification email.

@param  \Illuminate\Http\Request  $request
@return \Illuminate\Http\Response
431194
public function resend(Request $request)
    {
        $user = Auth::user();

        if ($user->getVerified()) {
            return redirect()->back();
        }

        $response = VerifyEmail::sendVerificationLink($user, function (Message $message) use ($user) {
            $message->subject($user->getVerifyEmailSubject());
        });

        switch ($response) {
            case VerifyEmail::VERIFY_LINK_SENT:
                return redirect()->back()->with('status', trans($response));
        }
    }
667783
public function send(Request $request)
    {
        $request->configure($this->config);

        $httpClient = new \GuzzleHttp\Client();

        $r = $httpClient->request('POST', $this->getUrl(), [
            'body' => \GuzzleHttp\Psr7\stream_for((string) $request),
        ]);

        return Response::create($r->getBody()->getContents());
    }
527377
public function authenticated(Request $request, Contracts\RequiresEmailVerification $user)
    {
        if (config('verification.verify') && !$user->isUserEmailVerified()) {
            Auth::guard($this->getGuard())->logout();

            return redirect($this->verificationRedirectPath());
        }

        return redirect()->intended($this->redirectPath());
    }
86228
def handle_verification_form(form):
    """"""
    form.process(formdata=request.form)

    if form.validate_on_submit():
        send_confirmation_instructions(current_user)
        # NOTE: Flash message.
        flash(_("Verification email sent."), category="success")
370560
public function sendMailout(Request $request)
    {
        $this->validate(
            $request,
            [
                'users'   => 'required|array',
                'subject' => 'required|min:4',
                'body'    => 'required|min:10',
            ]
        );

        $count = 0;

        foreach (User::all() as $user) {
            if (in_array($user->userId, $request->input('users'))) {
                $user->sendEmail(
                    $request->input('subject'),
                    'mustard::emails.mailout',
                    [
                        'body'     => $request->input('body'),
                        'username' => $user->username,
                    ]
                );

                $count++;
            }
        }

        return redirect()->back()->withStatus(trans('mustard::admin.mailout_sent', ['count' => $count]));
    }
901491
public function verify(Request $request, $token = null)
    {
        if (is_null($token)) {
            return $this->showVerifyMessage();
        }

        $credentials = ['email' => $request->get('email'), 'token' => $token];

        $broker = $this->getBroker();

        $response = Verification::broker($broker)->verify($credentials, function ($user) {
            $this->verifyUser($user);
        });

        switch ($response) {
            case Contracts\VerificationBroker::VERIFIED:
                return $this->getVerificationSuccessResponse($response);

            default:
                return $this->getVerificationFailureResponse($request, $response);
        }
    }
580699
public function register(Request $request)
    {

        $request->request->add(
            [
            'password_confirmation' => $request->has('passwordConfirmation') ? $request->passwordConfirmation : '']
        );
        $request->validate(
            [
            'name' => 'required|string|max:255',
            'email' => 'required|string|email|max:255|unique:users',
            'password' => 'required|string|min:6|confirmed',
            ]
        );

        event(new Registered($user = $this->create($request->all())));

        $this->guard()->login($user);

        return $this->registered($request, $user)
            ?: redirect($this->redirectPath());
    }
1145103
public function request(Request $request)
    {
        $user = User::whereEmail($request->email)->firstOrFail();
        $user->sendResetPasswordNotification($this->broker()->createToken($user), $request);

        return response()->json('Password request successful', 200);
    }
1235425
public function confirmationAction(Request $request)
    {
        /** @var \Ekyna\Component\Sale\Order\OrderInterface $order */
        $order = $this->get('ekyna_order.order.repository')->findOneByKey(
            $request->attributes->get('orderKey')
        );

        if (null === $order) {
            throw new NotFoundHttpException('Order not found.');
        }

        if (null !== $user = $order->getUser()) {
            if ($user !== $this->getUser()) {
                throw new AccessDeniedHttpException('You are not allowed to view this resource.');
            }
        }

        if (null === $payment = $order->findPaymentById($request->attributes->get('paymentId'))) {
            throw new NotFoundHttpException('Payment not found.');
        }

        /** @var \Ekyna\Bundle\PaymentBundle\Model\MethodInterface $method */
        $method = $payment->getMethod();
        $message = $method->getMessageByState($payment->getState());
        if (null === $message || 0 == strlen($message->getFlash())) {
            $message = null;
        }

        return $this->render('EkynaCartBundle:Cart:confirmation.html.twig', [
            'order'   => $order,
            'payment' => $payment,
            'message' => $message,
        ]);
    }
382546
public function store(Request $request)
    {
        $this->authorize('create', Notification::class);

        $this->validate($request, [
            'email'   => 'required|email|exists:users,email',
            'subject' => 'required|min:10|max:30',
            'message' => 'required|max:1500',
        ]);

        $me = User::findOrFail(Auth::id());

        User::where(['email' => $request->email])->first()
                    ->notify(new MessageNotification($request->subject, $request->message, $me));

        return redirect()->route('laralum::notifications.index')->with('success', __('laralum_notifications::general.notification_sent'));
    }
79715
public function send(Request $request)
    {
        $response   = new PutResponse();
        $rpbPutReq  = $this->createRpbMessage($request);

        $this->client->send($rpbPutReq, RiakMessageCodes::SET_BUCKET_REQ, RiakMessageCodes::SET_BUCKET_RESP);

        return $response;
    }
469673
public function register(Request $request)
  {
    $request->rules = $this->rules();
    $request->validate();

    Events::trigger('user.registered', [$user = $this->create($request)]);

    if (Auth::provider($this->provider)::login($user)->status == 'success') {
      $this->sendNotification($user);
      Redirect::to($this->redirectPath(), 200);
    }
  }
1305804
public function send(Request $request)
    {
        $response     = new GetSchemaResponse();
        $httpRequest  = $this->createHttpRequest($request);
        $httpResponse = $this->client->send($httpRequest);

        $response->name    = $request->name;
        $response->content = (string) $httpResponse->getBody();

        return $response;
    }
845515
public function send(Request $request)
    {
        $rpbGetReq  = $this->createRpbMessage($request);
        $rpbGetResp = $this->client->send($rpbGetReq, RiakMessageCodes::GET_BUCKET_REQ, RiakMessageCodes::GET_BUCKET_RESP);
        $rpbProps   = $rpbGetResp->getProps();
        $response   = $this->createGetResponse($rpbProps);

        $response->name = $request->bucket;

        return $this->createGetResponse($rpbProps);
    }
11158
protected function send(Request $request)
    {
        try {
            $response = $this->client->send($request);
        } catch (ClientException $e) {
            $response = $e->getResponse();
        } catch (ServerException $e) {
            $response = $e->getResponse();
        }

        return $response;
    }
957001
public function twoStepVerification($request)
    {
        $user = Auth::User();

        if ($user) {
            $twoStepAuthStatus = $this->checkTwoStepAuthStatus($user->id);

            if ($twoStepAuthStatus->authStatus !== true) {
                return false;
            } else {
                if ($this->checkTimeSinceVerified($twoStepAuthStatus)) {
                    return false;
                }
            }

            return true;
        }

        return true;
    }
743424
public function send(Request $request)
    {
        $this->logger()->debug('Sending request. {request}', [
            'request'  => $request,
        ]);

        $response = $this->sendOrRetry($request, $request->getRetries());

        $this->logger()->debug('Response received. {response}', [
            'request'  => $request,
            'response' => $response,
        ]);

        return $response;
    }