When a user clicks on a link and they get to the next page, it starts a session which long story short, tells the database to make that link unavailable. They only have 30 minutes to do what they are supposed to do on this page, before the database resets making the link available again.. How can I make it so that the user cannot sit and stay on the page keeping the link unavailable or clicking refresh to stay on same page?
So basically, is there a way I can automatically redirect the user to another page WITHOUT them clicking on anything? The page should redirect them to another page when session expires no matter what.
I dont think I can use this because I want the redirect dependent on when the session expires.
header("Refresh: 60; Location: /path/somepage.php");
Any help would be extremely helpful!
** EDIT, the 30 minutes is defined in the session. So its all about the session..
$now = time();
$_SESSION['start'] = time(); // taking now page start time
$_SESSION['expire'] = $_SESSION['start'] + (1 * 60) ; // ending a session in 30
$outOfTime = $_SESSION['expire'] - $_SESSION['start'];
if($now > $_SESSION['expire'])
{
header("Refresh: $outOfTime ; Location: /path/redirect.php");
}
Session timer set to 1 minute for testing purposes.
You should have a system that checks how much longer until the session expires that runs whenever the user enters a page and set the redirect to that long. For example:
<?php
#some code to get expiration date of session. Make sure it is in a datetime object.
#get difference between current time and expiration time:
$timeleft=$expirationTime-new DateTime('now');
header("Refresh: {$timeleft};Location: http://example.com");
?>
I am not good with date/time, so you may have to fix this the code, but the concept is the main intention of this answer.
any way i want you to think about
Ticks
A tick is an event that occurs for every N low-level statements executed by the parser within the declare block. The value for N is specified using ticks=N within the declare blocks's directive section. The event(s) that occur on each tick are specified using the register_tick_function(). See the example below for more details. Note that more than one event can occur for each tick.
register_tick_function -- Register a function for execution on each tick
Description
bool register_tick_function ( callback function [, mixed arg [, mixed ...]] )
Registers the function named by func to be executed when a tick is called. Also, you may pass an array consisting of an object and a method as the func.
register_tick_function() example
<?php
declare(ticks=20);
// using a function as the callback
register_tick_function('my_function', true);
// using an object->method
$object = new my_class();
register_tick_function(array(&$object, 'my_method'), true);
?>
Warning register_tick_function() should not be used with threaded webserver modules. Ticks are not working in ZTS mode and may crash your webserver.
i just copied from my rack hopes it helps any one of our community
<?php
/**
* ************************ NOTICE ***********************************
*
* The use of Timers WILL slow down your script execution time.
* By how much is determined by the user implementation.
*
* *******************************************************************
*
* This pacakge contains one class for handling timers in PHP
* and enables the handling of callback functions at given intervals
* in microseconds (NOT milliseconds like javascript), as well as
* removing said functions from the stack of callable functions.
*
* The class is dependent on the PHP language construct declare(ticks=N);
* where N represents how many "tickable statements" that get processed
* before a registered tick function is called and MUST be declared in the top level script,
* not an included file in order to be effective.
*
* @see http://us.php.net/manual/en/control-structures.declare.php#control-structures.declare.ticks
*
* The value of N determines
* 1) how close to perfect accuracy the timers are (probably never be perfect though)
* 2) how fast the script will be processed
* If N == 1 the script will be very close to perfectly accurate, but will run very slow
* but if N is set TOO high (like 10000) it may not be very effective or accurate.
* It is up to the user to determine what this number should be for their script.
*
* The package also includes 4 functions for simplifying calls to the static methods of the class:
* -- setTimeout, setInterval, clearTimeout, clearInterval
/**
* Just for simplifying the Timers::setTimeout method
*
*
* @param callable | string $func
* @param integer $microseconds - remember this is microseconds NOT milliseconds
*
* @return integer
*/
function setTimeout ($func, $microseconds)
{
return Timers::setTimeout($func, $microseconds);
}
/**
* Just for simplifying the Timers::setInterval method
*
*
* @param callable | string $func
* @param integer $microseconds - remember this is microseconds NOT milliseconds
*
* @return integer
*/
function setInterval ($func, $microseconds)
{
return Timers::setInterval($func, $microseconds);
}
/**
* Just for simplifying the Timers::clearTimeout method
*
*
* @param integer $interval - an integer representing the one returned from a call to setTimeout()
*
* @return boolean
*/
function clearTimeout ($func, $microseconds)
{
return Timers::setTimeout($func, $microseconds);
}
/**
* Just for simplifying the Timers::clearInterval method
*
*
* @param integer $interval - an integer representing the one returned from a call to setInterval()
*
* @return boolean
*/
function clearInterval ($interval)
{
return Timers::clearInterval($interval);
}
/**
* This class contains a series of static properties and functions
* that enable the creation and execution of timers
*
* @author Sam Shull
*/
class Timers
{
/**
* An array of the arrays that represent
* the timer information used by Timers::tick
*
* @access private
* @staticvar array
*/
private static $timers = array();
/**
* Tracker of timers
*
*
* @access private
* @staticvar integer
*/
private static $numTimers = 0;
/**
* An array of the arrays that represent
* the interval information used by Timers::tick
*
* @access private
* @staticvar array
*/
private static $intervals = array();
/**
* Tracker of intervals
*
*
* @access private
* @staticvar integer
*/
private static $numIntervals = 0;
/**
* Used for debugging
*
*
* @access private
* @staticvar integer
*/
//private static $ticks = 0;
/**
* A utility method called after N number of ticks by the engine
* that checks each timer and interval to see if the desired
* number of microseconds have passed and executes the function
* when appropriate
*
* @static
* @return void
*/
public static function tick ()
{
//++self::$ticks;
$time = self::microtime();
foreach (self::$timers as $position => $timer)
{
if ($time >= $timer['time'])
{
call_user_func($timer['function']);
unset(self::$timers[$position]);
}
}
foreach (self::$intervals as $position => $timer)
{
if ($time >= $timer['time'])
{
call_user_func($timer['function']);
self::$intervals[$position]['time'] = self::microtime() + self::$intervals[$position]['microseconds'];
}
}
}
/**
* A utility method for retrieving the most accurate
* microtime available
*
* @static
* @return float
*/
public static function microtime ()
{
list($m, $s) = explode(' ', microtime());
return round(((float)$m + (float)$s) * 1000000);
}
/**
* A utility method that ensures that all the timeouts have been called
* and that calls all the intervals one more time
*
*
* @static
* @return void
*/
public static function shutdown ()
{
foreach (self::$timers as $position => $timer)
{
call_user_func($timer['function']);
unset(self::$timers[$position]);
}
foreach (self::$intervals as $position => $interval)
{
call_user_func($interval['function']);
unset(self::$intervals[$position]);
}
//print "
ticks: " . self::$ticks;
}
/**
* Add a function to the be executed after ($microseconds) microsecond
*
* @static
*
* @param callable | string $func
* @param integer $microseconds - remember microseconds, not miliseconds
*
* @return integer
*/
public static function setTimeout ($func, $microseconds)
{
if (!is_callable($func))
{
if (is_string($func))
{
$func = create_function('', $func);
}
else
{
throw new InvalidArgumentException();
}
}
self::$timers[++self::$numTimers] = array(
'time' => self::microtime() + $microseconds,
'function' => $func,
);
return self::$numTimers;
}
/**
* Add a function to the be executed every ($microseconds) microsecond
*
* @static
*
* @param callable | string $func
* @param integer $microseconds - remember microseconds, not miliseconds
*
* @return integer
*/
public static function setInterval ($func, $microseconds)
{
if (!is_callable($func))
{
if (is_string($func))
{
$func = create_function('', $func);
}
else
{
throw new InvalidArgumentException();
}
}
self::$intervals[++self::$numIntervals] = array(
'time' => self::microtime() + $microseconds,
'function' => $func,
'microseconds' => $microseconds,
);
return self::$numIntervals;
}
/**
* Remove a timeout function from the stack
*
* @static
*
* @param integer $timer
*
* @return boolean
*/
public static function clearTimeout ($timer)
{
if (isset(self::$timers[$timer]))
{
unset(self::$timers[$timer]);
return true;
}
return false;
}
/**
* Remove an interval function from the stack
*
* @static
*
* @param integer $interval
*
* @return boolean
*/
public static function clearInterval ($interval)
{
if (isset(self::$intervals[$interval]))
{
unset(self::$intervals[$interval]);
return true;
}
return false;
}
}
/**
* Register these methods in order to perform polling a specific intervals
* that are set by the user
*/
register_tick_function(array('Timers','tick'));
register_shutdown_function(array('Timers','shutdown'));
?>
Because a hard refresh of the page is not desirable (nor is it nice for the user!), you'll have to have javascript present to periodically query a listener that reports the time remaining on the page, or the unix datetime of the page's expiry.
At the top of the restricted page:
session_start();
if (!isset($_SESSION['page_expiry']) || time() < $_SESSION['page_expiry'])
$_SESSION['page_expiry'] = time() + (60 * 30);
// render page
} else {
echo "time's up!";
}
Inside the page itself will be javascript that makes an ajax call to the following listener.php perhaps every thirty seconds.
session_start();
if (time() > $_SESSION['page_expiry']) echo 'false';
else echo true;
If the ajax call ever returns false, kick them out of the page.