When a log in fails, increment the failed count.

@param string $email The email the user tried to log in as.

@return bool
13146
public static function failedLogin($email)
    {
        $user = self::where('email', $email)->first();

        if (! is_null($user)) {
            $user->increment('failed_login_attempts');
        }

        $rules = config('jumpgate.users.blocking', null);

        if (is_null($rules)) {
            return true;
        }

        supportCollector($rules)
            ->each(function ($limit, $column) use ($user) {
                if ($limit === 0) {
                    return true;
                }

                $attempts = $user->{$column};

                if ($attempts >= $limit) {
                    $user->blocked();
                }
            });
    }
898772
public static function isEmail($email)
    {
        $pattern = "/^([0-9A-Za-z\\-_\\.]+)@([0-9a-z]+\\.[a-z]{2,3}(\\.[a-z]{2})?)$/i";
        if (is_string($email) && preg_match($pattern, $email)) {
            return true;
        }

        return false;
    }
365026
public function checkEmail($user, $email)
    {
        // missing email address (user login name) ?
        if (!$email) {
            $exception = oxNew(\OxidEsales\Eshop\Core\Exception\InputException::class);
            $exception->setMessage(\OxidEsales\Eshop\Core\Registry::getLang()->translateString('ERROR_MESSAGE_INPUT_NOTALLFIELDS'));

            return $this->addValidationError("oxuser__oxusername", $exception);
        }

        // invalid email address ?
        if (!oxNew(\OxidEsales\Eshop\Core\MailValidator::class)->isValidEmail($email)) {
            $exception = oxNew(\OxidEsales\Eshop\Core\Exception\InputException::class);
            $exception->setMessage(\OxidEsales\Eshop\Core\Registry::getLang()->translateString('ERROR_MESSAGE_INPUT_NOVALIDEMAIL'));

            return $this->addValidationError("oxuser__oxusername", $exception);
        }
    }
1240168
private function isEmailValid($email)
    {
        $constraints = array(
            new \Symfony\Component\Validator\Constraints\Email(),
            new \Symfony\Component\Validator\Constraints\NotBlank()
        );

        $errors = $this->validator->validate($email, $constraints);
        return count($errors) === 0;
    }
567035
public function forgotPassword($email)
    {
        $account = $this->findByEmail($email);

        //if($account instanceof UserInterface){

            return app('account.password')->requestChangePassword($account);
        //}

        return false;
    }
1278396
public function is_valid_login_domain($email) {
        if (empty($this->get('alloweddomains'))) {
            return true;
        }

        $validdomains = explode(',', $this->get('alloweddomains'));

        $parts = explode('@', $email, 2);
        $emaildomain = '';
        if (count($parts) > 1) {
            $emaildomain = $parts[1];
        }

        return \core\ip_utils::is_domain_in_allowed_list($emaildomain, $validdomains);
    }
355344
public function getUser($email)
    {
        $user = $this->userMapper->findByEmail($email);

        if (!$user) {
            return false;
        }

        return $user;
    }
852036
public function exists($email)
    {
        $url = $this->gravatar->buildGravatarURL($email);
        $headers = get_headers($url, 1);
	    
        return (boolean) strpos($headers[0], '200');
    }
737597
public function verifyEmailIdentity($email)
    {
        $this->_action = 'VerifyEmailIdentity';
        $this->_method = 'GET';
        $this->_refreshDate();

        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            throw new Exception('Invalid email');
            return;
        }

        $parameters = array(
            'EmailAddress' => $email
        );

        $this->_generateSignature($parameters);
        $res = $this->_request();
        if ($res['code'] == 200) {
            return (string) $res['body']->ResponseMetadata->RequestId;
        } else {
            return new SimpleEmailServiceError((string) $res['body']->Error->Code);
        }
    }
543169
protected function isEmailValid($email)
    {
        $constraint = new EmailConstraint();
        $result = $this->get('validator')->validate($email, $constraint);

        return 0 === count($result);
    }
178273
public function loadByEmail($email)
    {
        try {
            return $this->innerGateway->loadByEmail($email);
        } catch (\DBALException $e) {
            throw new \RuntimeException('Database error', 0, $e);
        } catch (\PDOException $e) {
            throw new \RuntimeException('Database error', 0, $e);
        }
    }
916816
public static function validate($email)
    {
        $validate = new Email();
        foreach ($validate->getFilters() as $filter) {
            $v = $validate->{'check' . ucfirst($filter)}($email);
            if ($v) {
                $validate->setValid(true);
            } else {
                $validate->setValid(false);
                break;
            }
        }

        return $validate->isValid();
    }
354682
public static function email($email)
    {
        $email = Str::trim($email);
        $cleaned = filter_var($email, FILTER_VALIDATE_EMAIL);

        if (Email::isValid($cleaned)) {
            return $cleaned;
        }

        return false;
    }
567383
public function isValid($email)
    {
        // Does it look like an email address?
        if (! $this->isEmail($email)) {
            return false;
        }

        // Is is an example domain?
        if ($this->isExample($email)) {
            return false;
        }

        // Is is a it disposable?
        if ($this->isDisposable($email)) {
            return false;
        }

        // Is it role based?
        if ($this->isRole($email)) {
            return false;
        }

        // Does it have an MX record?
        if (! $this->hasMx($email)) {
            return false;
        }

        return true;
    }
1238709
public function validateEmail($email)
    {
        if (empty($email)) {
            $this->addError('email', 'Email cannot be empty');
            return false;
        }

        if (mb_strlen($email, 'UTF-8') > 255) {
            $this->addError('email', 'Email length has to be less or equal to 255');
            return false;
        }

        $emailValidator = new EmailValidator();
        if (!$emailValidator->isValid($email, new RFCValidation())) {
            $this->addError('email', 'Email must be an email address');
            return false;
        }

        return true;
    }
100878
public static function isValidEmail($email)
    {
        /*
         * Not a string?
         * Nothing to do
         */
        if (!is_string($email)) {
            return false;
        }

        $pattern = self::getEmailPattern();

        return (bool)preg_match($pattern, $email);
    }
103029
public static function _Authenticate ($email, $password)
	{
		
		// Get user
		
		$user	= static::_readFromEmail ($email);
		
		if (!$user)
		{
			return FALSE;
		}
		
		// Check password
		
		return $user->checkPassword ($password);
		
	}