Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:37
📄 AdvancedUserInterface.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Security\Core\User; use Symfony\Component\Security\Core\Exception\AccountStatusException; use Symfony\Component\Security\Core\Exception\AccountExpiredException; use Symfony\Component\Security\Core\Exception\LockedException; use Symfony\Component\Security\Core\Exception\CredentialsExpiredException; use Symfony\Component\Security\Core\Exception\DisabledException; /* * Adds extra features to a user class related to account status flags. * * This interface can be implemented in place of UserInterface if you'd like * the authentication system to consider different account status flags * during authentication. If any of the methods in this interface return * false, authentication will fail. * * If you need to perform custom logic for any of these situations, then * you will need to register an exception listener and watch for the specific * exception instances thrown in each case. All exceptions are a subclass * of AccountStatusException * * @see UserInterface * @see AccountStatusException * * @author Fabien Potencier <fabien@symfony.com> / interface AdvancedUserInterface extends UserInterface { /* * Checks whether the user's account has expired. * * Internally, if this method returns false, the authentication system * will throw an AccountExpiredException and prevent login. * * @return Boolean true if the user's account is non expired, false otherwise * * @see AccountExpiredException / public function isAccountNonExpired(); /* * Checks whether the user is locked. * * Internally, if this method returns false, the authentication system * will throw a LockedException and prevent login. * * @return Boolean true if the user is not locked, false otherwise * * @see LockedException / public function isAccountNonLocked(); /* * Checks whether the user's credentials (password) has expired. * * Internally, if this method returns false, the authentication system * will throw a CredentialsExpiredException and prevent login. * * @return Boolean true if the user's credentials are non expired, false otherwise * * @see CredentialsExpiredException / public function isCredentialsNonExpired(); /* * Checks whether the user is enabled. * * Internally, if this method returns false, the authentication system * will throw a DisabledException and prevent login. * * @return Boolean true if the user is enabled, false otherwise * * @see DisabledException */ public function isEnabled(); }	2.84 KB	2024-07-17 10:22
📄 ChainUserProvider.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Security\Core\User; use Symfony\Component\Security\Core\Exception\UnsupportedUserException; use Symfony\Component\Security\Core\Exception\UsernameNotFoundException; /* * Chain User Provider. * * This provider calls several leaf providers in a chain until one is able to * handle the request. * * @author Johannes M. Schmitt <schmittjoh@gmail.com> / class ChainUserProvider implements UserProviderInterface { private $providers; public function __construct(array $providers) { $this->providers = $providers; } /* * @return array / public function getProviders() { return $this->providers; } /* * {@inheritDoc} / public function loadUserByUsername($username) { foreach ($this->providers as $provider) { try { return $provider->loadUserByUsername($username); } catch (UsernameNotFoundException $notFound) { // try next one } } $ex = new UsernameNotFoundException(sprintf('There is no user with name "%s".', $username)); $ex->setUsername($username); throw $ex; } /* * {@inheritDoc} / public function refreshUser(UserInterface $user) { $supportedUserFound = false; foreach ($this->providers as $provider) { try { return $provider->refreshUser($user); } catch (UnsupportedUserException $unsupported) { // try next one } catch (UsernameNotFoundException $notFound) { $supportedUserFound = true; // try next one } } if ($supportedUserFound) { $ex = new UsernameNotFoundException(sprintf('There is no user with name "%s".', $user->getUsername())); $ex->setUsername($user->getUsername()); throw $ex; } else { throw new UnsupportedUserException(sprintf('The account "%s" is not supported.', get_class($user))); } } /* * {@inheritDoc} */ public function supportsClass($class) { foreach ($this->providers as $provider) { if ($provider->supportsClass($class)) { return true; } } return false; } }	2.53 KB	2024-07-17 10:22
📄 EquatableInterface.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Security\Core\User; /* * EquatableInterface used to test if two objects are equal in security * and re-authentication context. * * @author Dariusz Górecki <darek.krk@gmail.com> / interface EquatableInterface { /* * The equality comparison should neither be done by referential equality * nor by comparing identities (i.e. getId() === getId()). * * However, you do not need to compare every attribute, but only those that * are relevant for assessing whether re-authentication is required. * * Also implementation should consider that $user instance may implement * the extended user interface `AdvancedUserInterface`. * * @param UserInterface $user * * @return Boolean */ public function isEqualTo(UserInterface $user); }	1.05 KB	2024-07-17 10:22
📄 InMemoryUserProvider.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Security\Core\User; use Symfony\Component\Security\Core\Exception\UsernameNotFoundException; use Symfony\Component\Security\Core\Exception\UnsupportedUserException; /* * InMemoryUserProvider is a simple non persistent user provider. * * Useful for testing, demonstration, prototyping, and for simple needs * (a backend with a unique admin for instance) * * @author Fabien Potencier <fabien@symfony.com> / class InMemoryUserProvider implements UserProviderInterface { private $users; /* * Constructor. * * The user array is a hash where the keys are usernames and the values are * an array of attributes: 'password', 'enabled', and 'roles'. * * @param array $users An array of users / public function __construct(array $users = array()) { foreach ($users as $username => $attributes) { $password = isset($attributes['password']) ? $attributes['password'] : null; $enabled = isset($attributes['enabled']) ? $attributes['enabled'] : true; $roles = isset($attributes['roles']) ? $attributes['roles'] : array(); $user = new User($username, $password, $roles, $enabled, true, true, true); $this->createUser($user); } } /* * Adds a new User to the provider. * * @param UserInterface $user A UserInterface instance * * @throws \LogicException / public function createUser(UserInterface $user) { if (isset($this->users[strtolower($user->getUsername())])) { throw new \LogicException('Another user with the same username already exists.'); } $this->users[strtolower($user->getUsername())] = $user; } /* * {@inheritdoc} / public function loadUserByUsername($username) { if (!isset($this->users[strtolower($username)])) { $ex = new UsernameNotFoundException(sprintf('Username "%s" does not exist.', $username)); $ex->setUsername($username); throw $ex; } $user = $this->users[strtolower($username)]; return new User($user->getUsername(), $user->getPassword(), $user->getRoles(), $user->isEnabled(), $user->isAccountNonExpired(), $user->isCredentialsNonExpired(), $user->isAccountNonLocked()); } /* * {@inheritDoc} / public function refreshUser(UserInterface $user) { if (!$user instanceof User) { throw new UnsupportedUserException(sprintf('Instances of "%s" are not supported.', get_class($user))); } return $this->loadUserByUsername($user->getUsername()); } /* * {@inheritDoc} */ public function supportsClass($class) { return $class === 'Symfony\Component\Security\Core\User\User'; } }	3.02 KB	2024-07-17 10:22
📄 User.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Security\Core\User; /* * User is the user implementation used by the in-memory user provider. * * This should not be used for anything else. * * @author Fabien Potencier <fabien@symfony.com> / final class User implements AdvancedUserInterface { private $username; private $password; private $enabled; private $accountNonExpired; private $credentialsNonExpired; private $accountNonLocked; private $roles; public function __construct($username, $password, array $roles = array(), $enabled = true, $userNonExpired = true, $credentialsNonExpired = true, $userNonLocked = true) { if (empty($username)) { throw new \InvalidArgumentException('The username cannot be empty.'); } $this->username = $username; $this->password = $password; $this->enabled = $enabled; $this->accountNonExpired = $userNonExpired; $this->credentialsNonExpired = $credentialsNonExpired; $this->accountNonLocked = $userNonLocked; $this->roles = $roles; } /* * {@inheritdoc} / public function getRoles() { return $this->roles; } /* * {@inheritdoc} / public function getPassword() { return $this->password; } /* * {@inheritdoc} / public function getSalt() { return null; } /* * {@inheritdoc} / public function getUsername() { return $this->username; } /* * {@inheritdoc} / public function isAccountNonExpired() { return $this->accountNonExpired; } /* * {@inheritdoc} / public function isAccountNonLocked() { return $this->accountNonLocked; } /* * {@inheritdoc} / public function isCredentialsNonExpired() { return $this->credentialsNonExpired; } /* * {@inheritdoc} / public function isEnabled() { return $this->enabled; } /* * {@inheritdoc} */ public function eraseCredentials() { } }	2.32 KB	2024-07-17 10:22
📄 UserChecker.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Security\Core\User; use Symfony\Component\Security\Core\Exception\CredentialsExpiredException; use Symfony\Component\Security\Core\Exception\LockedException; use Symfony\Component\Security\Core\Exception\DisabledException; use Symfony\Component\Security\Core\Exception\AccountExpiredException; /* * UserChecker checks the user account flags. * * @author Fabien Potencier <fabien@symfony.com> / class UserChecker implements UserCheckerInterface { /* * {@inheritdoc} / public function checkPreAuth(UserInterface $user) { if (!$user instanceof AdvancedUserInterface) { return; } if (!$user->isAccountNonLocked()) { $ex = new LockedException('User account is locked.'); $ex->setUser($user); throw $ex; } if (!$user->isEnabled()) { $ex = new DisabledException('User account is disabled.'); $ex->setUser($user); throw $ex; } if (!$user->isAccountNonExpired()) { $ex = new AccountExpiredException('User account has expired.'); $ex->setUser($user); throw $ex; } } /* * {@inheritdoc} */ public function checkPostAuth(UserInterface $user) { if (!$user instanceof AdvancedUserInterface) { return; } if (!$user->isCredentialsNonExpired()) { $ex = new CredentialsExpiredException('User credentials have expired.'); $ex->setUser($user); throw $ex; } } }	1.79 KB	2024-07-17 10:22
📄 UserCheckerInterface.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Security\Core\User; /* * UserCheckerInterface checks user account when authentication occurs. * * This should not be used to make authentication decisions. * * @author Fabien Potencier <fabien@symfony.com> / interface UserCheckerInterface { /* * Checks the user account before authentication. * * @param UserInterface $user a UserInterface instance / public function checkPreAuth(UserInterface $user); /* * Checks the user account after authentication. * * @param UserInterface $user a UserInterface instance */ public function checkPostAuth(UserInterface $user); }	901 B	2024-07-17 10:22
📄 UserInterface.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Security\Core\User; use Symfony\Component\Security\Core\Role\Role; /* * Represents the interface that all user classes must implement. * * This interface is useful because the authentication layer can deal with * the object through its lifecycle, using the object to get the encoded * password (for checking against a submitted password), assigning roles * and so on. * * Regardless of how your user are loaded or where they come from (a database, * configuration, web service, etc), you will have a class that implements * this interface. Objects that implement this interface are created and * loaded by different objects that implement UserProviderInterface * * @see UserProviderInterface * @see AdvancedUserInterface * * @author Fabien Potencier <fabien@symfony.com> / interface UserInterface { /* * Returns the roles granted to the user. * * <code> * public function getRoles() * { * return array('ROLE_USER'); * } * </code> * * Alternatively, the roles might be stored on a ``roles`` property, * and populated in any number of different ways when the user object * is created. * * @return Role[] The user roles / public function getRoles(); /* * Returns the password used to authenticate the user. * * This should be the encoded password. On authentication, a plain-text * password will be salted, encoded, and then compared to this value. * * @return string The password / public function getPassword(); /* * Returns the salt that was originally used to encode the password. * * This can return null if the password was not encoded using a salt. * * @return string\|null The salt / public function getSalt(); /* * Returns the username used to authenticate the user. * * @return string The username / public function getUsername(); /* * Removes sensitive data from the user. * * This is important if, at any given point, sensitive information like * the plain-text password is stored on this object. */ public function eraseCredentials(); }	2.42 KB	2024-07-17 10:22
📄 UserProviderInterface.php <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. / namespace Symfony\Component\Security\Core\User; use Symfony\Component\Security\Core\Exception\UsernameNotFoundException; use Symfony\Component\Security\Core\Exception\UnsupportedUserException; /* * Represents a class that loads UserInterface objects from some source for the authentication system. * * In a typical authentication configuration, a username (i.e. some unique * user identifier) credential enters the system (via form login, or any * method). The user provider that is configured with that authentication * method is asked to load the UserInterface object for the given username * (via loadUserByUsername) so that the rest of the process can continue. * * Internally, a user provider can load users from any source (databases, * configuration, web service). This is totally independent of how the authentication * information is submitted or what the UserInterface object looks like. * * @see UserInterface * * @author Fabien Potencier <fabien@symfony.com> / interface UserProviderInterface { /* * Loads the user for the given username. * * This method must throw UsernameNotFoundException if the user is not * found. * * @param string $username The username * * @return UserInterface * * @see UsernameNotFoundException * * @throws UsernameNotFoundException if the user is not found * / public function loadUserByUsername($username); /* * Refreshes the user for the account interface. * * It is up to the implementation to decide if the user data should be * totally reloaded (e.g. from the database), or if the UserInterface * object can just be merged into some internal array of users / identity * map. * @param UserInterface $user * * @return UserInterface * * @throws UnsupportedUserException if the account is not supported / public function refreshUser(UserInterface $user); /* * Whether this provider supports the given user class * * @param string $class * * @return Boolean */ public function supportsClass($class); }	2.33 KB	2024-07-17 10:22

Terminal