Skip to content
Projects
Groups
Snippets
Help
This project
Loading...
Sign in / Register
Toggle navigation
U
UserAdminV2
Overview
Overview
Details
Activity
Cycle Analytics
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
Issues
0
Issues
0
List
Board
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Charts
Wiki
Wiki
Members
Collapse sidebar
Close sidebar
Activity
Graph
Charts
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
庄欣
UserAdminV2
Commits
a986b010
Commit
a986b010
authored
13 years ago
by
Taylor Otwell
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
deprecated the session payload class.
parent
c4eb6c94
Hide whitespace changes
Inline
Side-by-side
Showing
1 changed file
with
0 additions
and
259 deletions
+0
-259
laravel/session/payload.php
+0
-259
No files found.
laravel/session/payload.php
deleted
100644 → 0
View file @
c4eb6c94
<?php
namespace
Laravel\Session
;
use
Laravel\Str
;
use
Laravel\Config
;
use
Laravel\Cookie
;
use
Laravel\Session\Drivers\Driver
;
use
Laravel\Session\Drivers\Sweeper
;
class
Session
{
/**
* The session array that is stored by the driver.
*
* @var array
*/
protected
static
$session
;
/**
* Indicates if the session already exists in storage.
*
* @var bool
*/
protected
static
$exists
=
true
;
/**
* Start the session handling for the current request.
*
* @param Driver $driver
* @return void
*/
public
static
function
start
(
Driver
$driver
)
{
if
(
!
is_null
(
$id
=
Cookie
::
get
(
Config
::
$items
[
'session'
][
'cookie'
])))
{
static
::
$session
=
$driver
->
load
(
$id
);
}
if
(
static
::
invalid
())
{
static
::
$exists
=
false
;
// A CSRF token is stored in every session. The token is used by the
// Form class and the "csrf" filter to protect the application from
// cross-site request forgery attacks. The token is simply a long,
// random string which should be posted with each request.
$token
=
Str
::
random
(
40
);
static
::
$session
=
array
(
'id'
=>
Str
::
random
(
40
),
'data'
=>
compact
(
'token'
));
}
}
/**
* Deteremine if the session payload instance is valid.
*
* The session is considered valid if it exists and has not expired.
*
* @return bool
*/
protected
static
function
invalid
()
{
$lifetime
=
Config
::
$items
[
'session'
][
'lifetime'
];
return
is_null
(
static
::
$session
)
or
(
time
()
-
static
::
$session
[
'last_activity'
]
>
(
$lifetime
*
60
));
}
/**
* Determine if the session or flash data contains an item.
*
* @param string $key
* @return bool
*/
public
static
function
has
(
$key
)
{
return
(
!
is_null
(
static
::
get
(
$key
)));
}
/**
* Get an item from the session.
*
* The session flash data will also be checked for the requested item.
*
* <code>
* // Get an item from the session
* $name = Session::get('name');
*
* // Return a default value if the item doesn't exist
* $name = Session::get('name', 'Taylor');
* </code>
*
* @param string $key
* @param mixed $default
* @return mixed
*/
public
static
function
get
(
$key
,
$default
=
null
)
{
foreach
(
array
(
$key
,
':old:'
.
$key
,
':new:'
.
$key
)
as
$possibility
)
{
if
(
array_key_exists
(
$possibility
,
static
::
$session
[
'data'
]))
{
return
static
::
$session
[
'data'
][
$possibility
];
}
}
return
(
$default
instanceof
Closure
)
?
call_user_func
(
$default
)
:
$default
;
}
/**
* Write an item to the session.
*
* @param string $key
* @param mixed $value
* @return void
*/
public
static
function
put
(
$key
,
$value
)
{
static
::
$session
[
'data'
][
$key
]
=
$value
;
}
/**
* Write an item to the session flash data.
*
* Flash data only exists for the next request to the application.
*
* @param string $key
* @param mixed $value
* @return void
*/
public
static
function
flash
(
$key
,
$value
)
{
static
::
put
(
':new:'
.
$key
,
$value
);
}
/**
* Keep all of the session flash data from expiring at the end of the request.
*
* @return void
*/
public
static
function
reflash
()
{
static
::
keep
(
array_keys
(
static
::
$session
[
'data'
]));
}
/**
* Keep a session flash item from expiring at the end of the request.
*
* @param string|array $key
* @return void
*/
public
static
function
keep
(
$keys
)
{
foreach
((
array
)
$keys
as
$key
)
static
::
flash
(
$key
,
static
::
get
(
$key
));
}
/**
* Remove an item from the session data.
*
* @param string $key
* @return Driver
*/
public
static
function
forget
(
$key
)
{
unset
(
static
::
$session
[
'data'
][
$key
]);
}
/**
* Remove all of the items from the session.
*
* @return void
*/
public
static
function
flush
()
{
static
::
$session
[
'data'
]
=
array
();
}
/**
* Assign a new, random ID to the session.
*
* @return void
*/
public
static
function
regenerate
()
{
static
::
$session
[
'id'
]
=
Str
::
random
(
40
);
static
::
$exists
=
false
;
}
/**
* Store the session payload in storage.
*
* @param Driver $driver
* @return void
*/
public
static
function
save
(
Driver
$driver
)
{
static
::
$session
[
'last_activity'
]
=
time
();
static
::
age
();
$config
=
Config
::
$items
[
'session'
];
// To keep the session persistence code clean, session drivers are
// responsible for the storage of the session array to the various
// available persistent storage mechanisms.
$driver
->
save
(
static
::
$session
,
$config
,
static
::
$exists
);
static
::
cookie
();
// Some session drivers implement the Sweeper interface, meaning that they
// must clean up expired sessions manually. If the driver is a sweeper, we
// need to determine if garbage collection should be run for the request.
// Since garbage collection can be expensive, the probability of it
// occuring is controlled by the "sweepage" configuration option.
if
(
$driver
instanceof
Sweeper
and
(
mt_rand
(
1
,
$config
[
'sweepage'
][
1
])
<=
$config
[
'sweepage'
][
0
]))
{
$driver
->
sweep
(
time
()
-
(
$config
[
'lifetime'
]
*
60
));
}
}
/**
* Age the session flash data.
*
* Session flash data is only available during the request in which it
* was flashed, and the request after that. To "age" the data, we will
* remove all of the :old: items and re-address the new items.
*
* @return void
*/
protected
static
function
age
()
{
foreach
(
static
::
$session
[
'data'
]
as
$key
=>
$value
)
{
if
(
strpos
(
$key
,
':old:'
)
===
0
)
static
::
forget
(
$key
);
}
// Now that all of the "old" keys have been removed from the session data,
// we can re-address all of the newly flashed keys to have old addresses.
// The array_combine method uses the first array for keys, and the second
// array for values to construct a single array from both.
$keys
=
str_replace
(
':new:'
,
':old:'
,
array_keys
(
static
::
$session
[
'data'
]));
static
::
$session
[
'data'
]
=
array_combine
(
$keys
,
array_values
(
static
::
$session
[
'data'
]));
}
/**
* Send the session ID cookie to the browser.
*
* @return void
*/
protected
static
function
cookie
()
{
$config
=
Config
::
$items
[
'session'
];
$minutes
=
(
!
$config
[
'expire_on_close'
])
?
$config
[
'lifetime'
]
:
0
;
Cookie
::
put
(
$cookie
,
static
::
$session
[
'id'
],
$minutes
,
$config
[
'path'
],
$config
[
'domain'
],
$config
[
'secure'
]);
}
}
\ No newline at end of file
This diff is collapsed.
Click to expand it.
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment