Determine if the reminder has expired.

@param PasswordReminder $reminder

@return bool
193135
protected function reminderExpired(PasswordReminder $reminder)
    {
        $createdPlusHour = $reminder->getCreatedAt()->getTimestamp() + $this->expires;

        return $createdPlusHour < time();
    }
875819
public function isExpired()
    {
        if (is_object($this->ExpireAtDate)) {
            $this->ExpireAtDate = $this->ExpireAtDate->Value;
        }

        $expired = false;

        if (!empty($this->ExpireAtDate)) {
            if (SS_Datetime::now()->Value >= $this->ExpireAtDate) {
                $expired = true;
            }
        }

        return $expired;
    }
568879
public function isExpired()
    {
        $curTime = $this->timer['now'];
        $maxTime = $this->timer['last'] + $this->_lifetime;

        return ($maxTime < $curTime);
    }
405110
public function setOneTimePassword($password, $counter = 1)
    {
        if ($this->getIsNewRecord()) {
            return false;
        }
        $this->one_time_password_code = $password;
        $this->one_time_password_counter = $counter;

        return $this->save(false);
    }
207056
public function postReminder() {
    $email = Input::get('email');

    try {
      $this->reminder->send($email);
      return Redirect::to("/user/recupero-success")->with(array ("messageReminder" => L::t('Check your mail inbox, we sent you an email to recover your password.')));
    } catch (Pbi $e) {
      $errors = $this->reminder->getErrors();
      return Redirect::back()->withErrors($errors);
    }
  }
1342507
public function isAccessTokenRevoked($tokenId)
    {
        /** @var \Concrete\Core\Entity\OAuth\AccessToken $token */
        $token = $this->find($tokenId);
        if (!$token) {
            // The token was manually removed.
            return true;
        }

        $now = new \DateTime('now');
        // If we have a token and it has expired...
        if ($token && $token->getExpiryDateTime() < $now) {
            return true;
        }

        return false;
    }
198962
public function getExpiredAfter()
    {
        if (!is_string($this->expiredAfterAttribute) || empty($this->expiredAfterAttribute)) {
            return false;
        }
        return (int)($this->{$this->expiredAfterAttribute});
    }
603377
public function isExpired($now = null)
    {
        if ($now === null) { $now = time();
        }
        if (is_int($this->expires) && $this->expires < $now) {
            return true;
        } else {
            return false;
        }
    }
973978
public function expired(string $key): bool
    {
        try {
            return $this->storage->expired($key);
        } catch (BadPacketException $e) {
            return true;
        }
    }
990080
public function is_any_expired() : bool {
        if ($this->is_fully_expired()) {
            return true;
        }

        if (!empty($this->get_expired_roles())) {
            return true;
        }

        if ($this->is_default_expired()) {
            return true;
        }

        return false;
    }
825350
public function setExpireTime(int $time) : bool
        {
                return $this->_redis->expireat($this->_key, $time) > 0 ? true : false;
        }
1275198
public function isExpired()
    {
        if (null === $this->created || 0 === $this->lifetime) {
            throw new \LogicException(
                'Cannot define if token is expired, created datetime or/and lifetime are missing.'
            );
        }

        return time() > strtotime($this->created) + $this->lifetime;
    }
956744
public function isExpired($info) {
        $compiled = $this->getCompiledPath($info);

        // If the compiled file doesn't exist we will indicate that the view is expired
        // so that it can be re-compiled. Else, we will verify the last modification
        // of the views is less than the modification times of the compiled views.
        if(!$this->cachePath || !$this->files->exists($compiled) || $info->lastModified === 0) {
            return true;
        }

        return $info->lastModified >= $this->files->lastModified($compiled);
    }
947286
function isExpired()
	{
        eZDebug::writeDebug( 'Check expiration', __METHOD__ );

        // If passwordlifetime is not defined or 0 (zero, infinite lifetime) passwords never expire.
        if ( ( $this->attribute( 'passwordlifetime' ) == self::NOT_DEFINED ) ||
             ( $this->attribute( 'passwordlifetime' ) == 0 ) )
            return false;

        $passwordLastUpdated = $this->attribute( 'password_last_updated' );
        $actualPasswordlifetime = ceil( ( ( ( ( time() - $passwordLastUpdated ) / 60 ) / 60 ) / 24 ) );

        eZDebug::writeDebug( $passwordLastUpdated, __METHOD__ );
        eZDebug::writeDebug( $actualPasswordlifetime, __METHOD__ );

        if ( ( $actualPasswordlifetime > $this->attribute( 'passwordlifetime' ) ) ||
               $passwordLastUpdated == 0 ||
               $passwordLastUpdated == self::NOT_DEFINED )
        {
            return true;
        }

		return false;
	}
510929
public static function isExpired($date = null)
    {
        return (bool) self::parse($date)->lte(Carbon::now());
    }
1050331
public function isExpired()
    {
        if (null === $this->expiresIn) {
            return false;
        }

        return ($this->createdAt + $this->expiresIn - time()) < 30;
    }
238152
public function expired()
    {
        // Update if empty
        if (empty($this->entries)) {
            return true;
        }

        // Check timestamps
        if ($this->timestampManager) {
            return $this->timestampManager->check($this->getTimestamp());
        }

        return false;
    }