solocla/casadoc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First complete upload CasaDoc

Browse Source
This commit is contained in:
Claudio
2024-09-18 10:42:19 +02:00
commit 2ab3e52df3
3042 changed files with 407823 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/Http/Controllers/Web/Auth/ForgotPasswordController.php
+45
View File
@@ -0,0 +1,45 @@
<?php
namespace Vanguard\Http\Controllers\Web\Auth;
use Illuminate\Http\Request;
use Vanguard\Http\Controllers\Controller;
use Illuminate\Foundation\Auth\SendsPasswordResetEmails;
class ForgotPasswordController extends Controller
{
/*
|--------------------------------------------------------------------------
| Password Reset Controller
|--------------------------------------------------------------------------
|
| This controller is responsible for handling password reset emails and
| includes a trait which assists in sending these notifications from
| your application to your users. Feel free to explore this trait.
|
*/
use SendsPasswordResetEmails;
/**
* Create a new controller instance.
*
* @return void
*/
public function __construct()
{
$this->middleware('guest');
}
/**
* Get the response for a successful password reset link.
*
* @param \Illuminate\Http\Request $request
* @param string $response
* @return \Illuminate\Http\RedirectResponse|\Illuminate\Http\JsonResponse
*/
protected function sendResetLinkResponse(Request $request, $response)
{
return back()->with('success', trans($response));
}
}
app/Http/Controllers/Web/Auth/LoginController.php
+139
View File
@@ -0,0 +1,139 @@
<?php
namespace Vanguard\Http\Controllers\Web\Auth;
use Auth;
use Authy;
use Illuminate\Contracts\Container\BindingResolutionException;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Vanguard\Events\User\LoggedIn;
use Vanguard\Events\User\LoggedOut;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Http\Requests\Auth\LoginRequest;
use Vanguard\Repositories\User\UserRepository;
use Vanguard\Services\Auth\ThrottlesLogins;
use Vanguard\Services\Auth\TwoFactor\Contracts\Authenticatable;
class LoginController extends Controller
{
use ThrottlesLogins;
public function __construct(private UserRepository $users)
{
$this->middleware('guest')->except('logout');
$this->middleware('auth')->only('logout');
}
/**
* Show the application login form.
*
* @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
*/
public function show()
{
return view('auth.login', [
'socialProviders' => config('auth.social.providers')
]);
}
/**
* @param LoginRequest $request
* @return RedirectResponse|Response
* @throws BindingResolutionException
*/
public function login(LoginRequest $request)
{
// In case that request throttling is enabled, we have to check if user can perform this request.
// We'll key this by the username and the IP address of the client making these requests into this application.
$throttles = setting('throttle_enabled');
//Redirect URL that can be passed as hidden field.
$to = $request->has('to') ? "?to=" . $request->get('to') : '';
if ($throttles && $this->hasTooManyLoginAttempts($request)) {
return $this->sendLockoutResponse($request);
}
$credentials = $request->getCredentials();
if (! Auth::validate($credentials)) {
// If the login attempt was unsuccessful we will increment the number of attempts
// to login and redirect the user back to the login form. Of course, when this
// user surpasses their maximum number of attempts they will get locked out.
if ($throttles) {
$this->incrementLoginAttempts($request);
}
return redirect()->to('login' . $to)
->withErrors(trans('auth.failed'));
}
$user = Auth::getProvider()->retrieveByCredentials($credentials);
if ($user->isBanned()) {
return redirect()->to('login' . $to)
->withErrors(__('Your account is banned by administrator.'));
}
Auth::login($user, setting('remember_me') && $request->get('remember'));
return $this->authenticated($request, $throttles, $user);
}
/**
* Send the response after the user was authenticated.
*
* @param Request $request
* @param bool $throttles
* @param $user
* @return RedirectResponse|Response
*/
protected function authenticated(Request $request, $throttles, $user)
{
if ($throttles) {
$this->clearLoginAttempts($request);
}
if (setting('2fa.enabled') && Authy::isEnabled($user)) {
return $this->logoutAndRedirectToTokenPage($request, $user);
}
event(new LoggedIn);
if ($request->has('to')) {
return redirect()->to($request->get('to'));
}
return redirect()->to("userportal/index.php");
}
/**
* @param Request $request
* @param Authenticatable $user
* @return RedirectResponse
*/
protected function logoutAndRedirectToTokenPage(Request $request, Authenticatable $user)
{
Auth::logout();
$request->session()->put('auth.2fa.id', $user->id);
return redirect()->route('auth.token');
}
/**
* Log the user out of the application.
*
* @return RedirectResponse|\Illuminate\Routing\Redirector
*/
public function logout()
{
event(new LoggedOut);
Auth::logout();
return redirect('login');
}
}
app/Http/Controllers/Web/Auth/RegisterController.php
+54
View File
@@ -0,0 +1,54 @@
<?php
namespace Vanguard\Http\Controllers\Web\Auth;
use Illuminate\Auth\Events\Registered;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Http\Requests\Auth\RegisterRequest;
use Vanguard\Repositories\Role\RoleRepository;
use Vanguard\Repositories\User\UserRepository;
use Vanguard\Support\Enum\UserStatus;
class RegisterController extends Controller
{
public function __construct(private UserRepository $users)
{
$this->middleware('registration')->only('show', 'register');
}
/**
* Show the application registration form.
*
* @return \Illuminate\Http\Response
*/
public function show()
{
return view('auth.register', [
'socialProviders' => config('auth.social.providers')
]);
}
/**
* Handle a registration request for the application.
*
* @param RegisterRequest $request
* @param RoleRepository $roles
* @return \Illuminate\Http\Response
*/
public function register(RegisterRequest $request, RoleRepository $roles)
{
$user = $this->users->create(
array_merge($request->validFormData(), ['role_id' => $roles->findByName('User')->id])
);
event(new Registered($user));
$message = setting('reg_email_confirmation')
? __('Your account is created successfully! Please confirm your email.')
: __('Your account is created successfully!');
\Auth::login($user);
return redirect('/')->with('success', $message);
}
}
app/Http/Controllers/Web/Auth/ResetPasswordController.php
+61
View File
@@ -0,0 +1,61 @@
<?php
namespace Vanguard\Http\Controllers\Web\Auth;
use Illuminate\Auth\Events\PasswordReset;
use Illuminate\Support\Str;
use Vanguard\Http\Controllers\Controller;
use Illuminate\Foundation\Auth\ResetsPasswords;
class ResetPasswordController extends Controller
{
/*
|--------------------------------------------------------------------------
| Password Reset Controller
|--------------------------------------------------------------------------
|
| This controller is responsible for handling password reset requests
| and uses a simple trait to include this behavior. You're free to
| explore this trait and override any methods you wish to tweak.
|
*/
use ResetsPasswords;
/**
* Where to redirect users after resetting their password.
*
* @var string
*/
protected $redirectTo = '/';
/**
* Create a new controller instance.
*
* @return void
*/
public function __construct()
{
$this->middleware('guest');
}
/**
* Reset the given user's password.
*
* @param \Illuminate\Contracts\Auth\CanResetPassword $user
* @param string $password
* @return void
*/
protected function resetPassword($user, $password)
{
$user->password = $password;
$user->setRememberToken(Str::random(60));
$user->save();
event(new PasswordReset($user));
$this->guard()->login($user);
}
}
app/Http/Controllers/Web/Auth/SocialAuthController.php
+107
View File
@@ -0,0 +1,107 @@
<?php
namespace Vanguard\Http\Controllers\Web\Auth;
use Auth;
use Authy;
use Laravel\Socialite\Contracts\User as SocialUser;
use Socialite;
use Vanguard\Events\User\LoggedIn;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Repositories\User\UserRepository;
use Vanguard\Services\Auth\Social\SocialManager;
class SocialAuthController extends Controller
{
public function __construct(private UserRepository $users, private SocialManager $socialManager)
{
$this->middleware('guest');
}
/**
* Redirect user to specified provider in order to complete the authentication process.
*
* @param $provider
* @return \Illuminate\Http\RedirectResponse
*/
public function redirectToProvider($provider)
{
if (strtolower($provider) == 'facebook') {
return Socialite::driver('facebook')->with(['auth_type' => 'rerequest'])->redirect();
}
return Socialite::driver($provider)->redirect();
}
/**
* Handle response authentication provider.
*
* @param $provider
* @return \Illuminate\Http\RedirectResponse
*/
public function handleProviderCallback($provider)
{
if (request()->get('error')) {
return redirect('login')
->withErrors(__('Something went wrong during the authentication process. Please try again.'));
}
$socialUser = $this->getUserFromProvider($provider);
$user = $this->users->findBySocialId($provider, $socialUser->getId());
if (! $user) {
if (! setting('reg_enabled')) {
return redirect('login')
->withErrors(__('Only users who already created an account can log in.'));
}
if (! $socialUser->getEmail()) {
return redirect('login')
->withErrors(__('You have to provide your email address.'));
}
$user = $this->socialManager->associate($socialUser, $provider);
event(new \Illuminate\Auth\Events\Registered($user));
}
return $this->loginAndRedirect($user);
}
/**
* Get user from authentication provider.
*
* @param $provider
* @return SocialUser
*/
private function getUserFromProvider($provider)
{
return Socialite::driver($provider)->user();
}
/**
* Log provided user in and redirect him to intended page.
*
* @param $user
* @return \Illuminate\Http\RedirectResponse
*/
private function loginAndRedirect($user)
{
if ($user->isBanned()) {
return redirect()->to('login')
->withErrors(__('Your account is banned by administrator.'));
}
if (setting('2fa.enabled') && Authy::isEnabled($user)) {
session()->put('auth.2fa.id', $user->id);
return redirect()->route('auth.token');
}
Auth::login($user);
event(new LoggedIn);
return redirect()->intended('/');
}
}
app/Http/Controllers/Web/Auth/TwoFactorTokenController.php
+65
View File
@@ -0,0 +1,65 @@
<?php
namespace Vanguard\Http\Controllers\Web\Auth;
use Auth;
use Authy;
use Illuminate\Http\Request;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Vanguard\Events\User\LoggedIn;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Repositories\User\UserRepository;
use Vanguard\Services\Auth\ThrottlesLogins;
class TwoFactorTokenController extends Controller
{
use ThrottlesLogins;
public function __construct(private UserRepository $users)
{
}
/**
* Show Two-Factor Token form.
* @return \Illuminate\Http\RedirectResponse|\Illuminate\View\View
*/
public function show()
{
return session('auth.2fa.id') ? view('auth.token') : redirect('login');
}
/**
* Handle Two-Factor token form submission.
*
* @param Request $request
* @return \Illuminate\Http\RedirectResponse|\Illuminate\Routing\Redirector
* @throws \Illuminate\Validation\ValidationException
*/
public function update(Request $request)
{
$this->validate($request, ['token' => 'required']);
if (! session('auth.2fa.id')) {
return redirect('login');
}
$user = $this->users->find(
$request->session()->pull('auth.2fa.id')
);
if (! $user) {
throw new NotFoundHttpException;
}
if (! Authy::tokenIsValid($user, $request->token)) {
return redirect()->to('login')
->withErrors(__('2FA Token is invalid!'));
}
Auth::login($user);
event(new LoggedIn);
return redirect()->intended('/');
}
}
app/Http/Controllers/Web/Auth/VerificationController.php
+41
View File
@@ -0,0 +1,41 @@
<?php
namespace Vanguard\Http\Controllers\Web\Auth;
use Vanguard\Http\Controllers\Controller;
use Illuminate\Foundation\Auth\VerifiesEmails;
class VerificationController extends Controller
{
/*
|--------------------------------------------------------------------------
| Email Verification Controller
|--------------------------------------------------------------------------
|
| This controller is responsible for handling email verification for any
| user that recently registered with the application. Emails may also
| be re-sent if the user didn't receive the original email message.
|
*/
use VerifiesEmails;
/**
* Where to redirect users after verification.
*
* @var string
*/
protected $redirectTo = '/';
/**
* Create a new controller instance.
*
* @return void
*/
public function __construct()
{
$this->middleware('auth');
$this->middleware('signed')->only('verify');
$this->middleware('throttle:6,1')->only('verify', 'resend');
}
}
app/Http/Controllers/Web/Authorization/PermissionsController.php
+110
View File
@@ -0,0 +1,110 @@
<?php
namespace Vanguard\Http\Controllers\Web\Authorization;
use Exception;
use Illuminate\Contracts\View\Factory;
use Illuminate\View\View;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Http\Requests\Permission\CreatePermissionRequest;
use Vanguard\Http\Requests\Permission\UpdatePermissionRequest;
use Vanguard\Permission;
use Vanguard\Repositories\Permission\PermissionRepository;
use Vanguard\Repositories\Role\RoleRepository;
/**
* Class PermissionsController
* @package Vanguard\Http\Controllers
*/
class PermissionsController extends Controller
{
public function __construct(private RoleRepository $roles, private PermissionRepository $permissions)
{
}
/**
* Displays the page with all available permissions.
*
* @return Factory|View
*/
public function index()
{
return view('permission.index', [
'roles' => $this->roles->all(),
'permissions' => $this->permissions->all()
]);
}
/**
* Displays the form for creating new permission.
*
* @return Factory|View
*/
public function create()
{
return view('permission.add-edit', ['edit' => false]);
}
/**
* Store permission to database.
*
* @param CreatePermissionRequest $request
* @return mixed
*/
public function store(CreatePermissionRequest $request)
{
$this->permissions->create($request->all());
return redirect()->route('permissions.index')
->withSuccess(__('Permission created successfully.'));
}
/**
* Displays the form for editing specific permission.
*
* @param Permission $permission
* @return Factory|View
*/
public function edit(Permission $permission)
{
return view('permission.add-edit', [
'edit' => true,
'permission' => $permission
]);
}
/**
* Update specified permission.
*
* @param Permission $permission
* @param UpdatePermissionRequest $request
* @return mixed
*/
public function update(Permission $permission, UpdatePermissionRequest $request)
{
$this->permissions->update($permission->id, $request->all());
return redirect()->route('permissions.index')
->withSuccess(__('Permission updated successfully.'));
}
/**
* Destroy the permission if it is removable.
*
* @param Permission $permission
* @return mixed
* @throws Exception
*/
public function destroy(Permission $permission)
{
if (! $permission->removable) {
throw new NotFoundHttpException;
}
$this->permissions->delete($permission->id);
return redirect()->route('permissions.index')
->withSuccess(__('Permission deleted successfully.'));
}
}
app/Http/Controllers/Web/Authorization/RolePermissionsController.php
+43
View File
@@ -0,0 +1,43 @@
<?php
namespace Vanguard\Http\Controllers\Web\Authorization;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;
use Vanguard\Events\Role\PermissionsUpdated;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Repositories\Role\RoleRepository;
/**
* Class RolePermissionsController
* @package Vanguard\Http\Controllers
*/
class RolePermissionsController extends Controller
{
public function __construct(private RoleRepository $roles)
{
}
/**
* Update permissions for each role.
*
* @param Request $request
* @return mixed
*/
public function update(Request $request)
{
$roles = $request->get('roles');
$allRoles = $this->roles->lists('id');
foreach ($allRoles as $roleId) {
$permissions = Arr::get($roles, $roleId, []);
$this->roles->updatePermissions($roleId, $permissions);
}
event(new PermissionsUpdated);
return redirect()->route('permissions.index')
->withSuccess(__('Permissions saved successfully.'));
}
}
app/Http/Controllers/Web/Authorization/RolesController.php
+113
View File
@@ -0,0 +1,113 @@
<?php
namespace Vanguard\Http\Controllers\Web\Authorization;
use Cache;
use Illuminate\Contracts\View\Factory;
use Illuminate\View\View;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Http\Requests\Role\CreateRoleRequest;
use Vanguard\Http\Requests\Role\UpdateRoleRequest;
use Vanguard\Repositories\Role\RoleRepository;
use Vanguard\Repositories\User\UserRepository;
use Vanguard\Role;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
/**
* Class RolesController
* @package Vanguard\Http\Controllers
*/
class RolesController extends Controller
{
public function __construct(private RoleRepository $roles)
{
}
/**
* Display page with all available roles.
*
* @return Factory|View
*/
public function index()
{
return view('role.index', ['roles' => $this->roles->getAllWithUsersCount()]);
}
/**
* Display form for creating new role.
*
* @return Factory|View
*/
public function create()
{
return view('role.add-edit', ['edit' => false]);
}
/**
* Store newly created role to database.
*
* @param CreateRoleRequest $request
* @return mixed
*/
public function store(CreateRoleRequest $request)
{
$this->roles->create($request->all());
return redirect()->route('roles.index')
->withSuccess(__('Role created successfully.'));
}
/**
* Display for for editing specified role.
*
* @param Role $role
* @return Factory|View
*/
public function edit(Role $role)
{
return view('role.add-edit', [
'role' => $role,
'edit' => true
]);
}
/**
* Update specified role with provided data.
*
* @param Role $role
* @param UpdateRoleRequest $request
* @return mixed
*/
public function update(Role $role, UpdateRoleRequest $request)
{
$this->roles->update($role->id, $request->all());
return redirect()->route('roles.index')
->withSuccess(__('Role updated successfully.'));
}
/**
* Remove specified role from system.
*
* @param Role $role
* @param UserRepository $userRepository
* @return mixed
*/
public function destroy(Role $role, UserRepository $userRepository)
{
if (! $role->removable) {
throw new NotFoundHttpException;
}
$userRole = $this->roles->findByName('User');
$userRepository->switchRolesForUsers($role->id, $userRole->id);
$this->roles->delete($role->id);
Cache::flush();
return redirect()->route('roles.index')
->withSuccess(__('Role deleted successfully.'));
}
}
app/Http/Controllers/Web/DashboardController.php
+24
View File
@@ -0,0 +1,24 @@
<?php
namespace Vanguard\Http\Controllers\Web;
use Illuminate\Contracts\View\Factory;
use Illuminate\View\View;
use Vanguard\Http\Controllers\Controller;
class DashboardController extends Controller
{
/**
* Displays the application dashboard.
*
* @return Factory|View
*/
public function index()
{
if (session()->has('verified')) {
session()->flash('success', __('E-Mail verified successfully.'));
}
return view('dashboard.index');
}
}
app/Http/Controllers/Web/InstallController.php
+240
View File
@@ -0,0 +1,240 @@
<?php
namespace Vanguard\Http\Controllers\Web;
use Artisan;
use DB;
use Illuminate\Contracts\View\View;
use Illuminate\Foundation\Bootstrap\LoadEnvironmentVariables;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;
use Session;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Vanguard\Http\Controllers\Controller;
class InstallController extends Controller
{
public function index(): View
{
return view('install.start');
}
public function requirements(): View
{
$requirements = $this->getRequirements();
$allLoaded = $this->allRequirementsLoaded();
return view('install.requirements', compact('requirements', 'allLoaded'));
}
public function permissions(): View|RedirectResponse
{
if (! $this->allRequirementsLoaded()) {
return redirect()->route('install.requirements');
}
$folders = $this->getPermissions();
$allGranted = $this->allPermissionsGranted();
return view('install.permissions', compact('folders', 'allGranted'));
}
public function databaseInfo(): View|RedirectResponse
{
if (! $this->allRequirementsLoaded()) {
return redirect()->route('install.requirements');
}
if (! $this->allPermissionsGranted()) {
return redirect()->route('install.permissions');
}
return view('install.database');
}
public function installation(Request $request): View|RedirectResponse
{
if (! $this->allRequirementsLoaded()) {
return redirect()->route('install.requirements');
}
if (! $this->allPermissionsGranted()) {
return redirect()->route('install.permissions');
}
$dbCredentials = $request->only('host', 'username', 'password', 'database', 'prefix');
if (! $this->dbCredentialsAreValid($dbCredentials)) {
return redirect()->route('install.database')
->withInput(Arr::except($dbCredentials, 'password'))
->withErrors("Connection to your database cannot be established.
Please provide correct database credentials.");
}
Session::put('install.db_credentials', $dbCredentials);
return view('install.installation');
}
public function install(): RedirectResponse
{
try {
$db = Session::pull('install.db_credentials');
copy(base_path('.env.example'), base_path('.env'));
$this->reloadEnv();
$path = base_path('.env');
$env = file_get_contents($path);
$env = str_replace('DB_HOST='.env('DB_HOST'), sprintf('DB_HOST="%s"', $db['host']), $env);
$env = str_replace('DB_DATABASE='.env('DB_DATABASE'), sprintf('DB_DATABASE="%s"', $db['database']), $env);
$env = str_replace('DB_USERNAME='.env('DB_USERNAME'), sprintf('DB_USERNAME="%s"', $db['username']), $env);
$env = str_replace('DB_PASSWORD='.env('DB_PASSWORD'), sprintf('DB_PASSWORD="%s"', $db['password']), $env);
$env = str_replace('DB_PREFIX='.env('DB_PREFIX'), sprintf('DB_PREFIX="%s"', $db['prefix']), $env);
file_put_contents($path, $env);
$this->setDatabaseCredentials($db);
config(['app.debug' => true]);
\Setting::set('app_name', \request('app_name'));
\Setting::save();
Artisan::call('key:generate', ['--force' => true]);
Artisan::call('migrate', ['--force' => true]);
Artisan::call('db:seed', ['--force' => true]);
Artisan::call('db:seed', [
'--force' => true,
'--quiet' => true,
'--class' => '\\Vanguard\\Announcements\\Database\\Seeders\\AnnouncementsDatabaseSeeder'
]);
return redirect()->route('install.complete');
} catch (\Exception $e) {
@unlink(base_path('.env'));
\Log::error($e->getMessage());
\Log::error($e->getTraceAsString());
return redirect()->route('install.error');
}
}
private function reloadEnv(): void
{
(new LoadEnvironmentVariables)->bootstrap(app());
}
public function complete(): View
{
return view('install.complete');
}
public function error(): View
{
return view('install.error');
}
/**
* @return array
*/
private function getRequirements(): array
{
$requirements = [
'PHP Version (>= 8.1.0)' => version_compare(phpversion(), '8.0.2', '>='),
'BCMath Extension' => extension_loaded('bcmath'),
'OpenSSL Extension' => extension_loaded('openssl'),
'PDO Extension' => extension_loaded('PDO'),
'PDO MySQL Extension' => extension_loaded('pdo_mysql'),
'Mbstring Extension' => extension_loaded('mbstring'),
'Tokenizer Extension' => extension_loaded('tokenizer'),
'XML Extension' => extension_loaded('xml'),
'Ctype PHP Extension' => extension_loaded('ctype'),
'JSON PHP Extension' => extension_loaded('json'),
'GD Extension' => extension_loaded('gd'),
'Fileinfo Extension' => extension_loaded('fileinfo')
];
if (extension_loaded('xdebug')) {
$requirements['Xdebug Max Nesting Level (>= 500)'] = (int)ini_get('xdebug.max_nesting_level') >= 500;
}
return $requirements;
}
/**
* @return bool
*/
private function allRequirementsLoaded(): bool
{
$allLoaded = true;
foreach ($this->getRequirements() as $loaded) {
if ($loaded == false) {
$allLoaded = false;
}
}
return $allLoaded;
}
/**
* @return array
*/
private function getPermissions(): array
{
return [
'public/upload/users' => is_writable(public_path('upload/users')),
'storage/app' => is_writable(storage_path('app')),
'storage/framework/cache' => is_writable(storage_path('framework/cache')),
'storage/framework/sessions' => is_writable(storage_path('framework/sessions')),
'storage/framework/views' => is_writable(storage_path('framework/views')),
'storage/logs' => is_writable(storage_path('logs')),
'bootstrap/cache' => is_writable(base_path('bootstrap/cache')),
'Base Directory' => is_writable(base_path('')),
];
}
private function allPermissionsGranted(): bool
{
$allGranted = true;
foreach ($this->getPermissions() as $permission => $granted) {
if ($granted == false) {
$allGranted = false;
}
}
return $allGranted;
}
private function dbCredentialsAreValid($credentials): bool
{
$this->setDatabaseCredentials($credentials);
try {
DB::statement("SHOW TABLES");
} catch (\Exception $e) {
\Log::info($e->getMessage());
return false;
}
return true;
}
/**
* @param $credentials
*/
private function setDatabaseCredentials($credentials)
{
$default = config('database.default');
config([
"database.connections.{$default}.host" => $credentials['host'],
"database.connections.{$default}.database" => $credentials['database'],
"database.connections.{$default}.username" => $credentials['username'],
"database.connections.{$default}.password" => $credentials['password'],
"database.connections.{$default}.prefix" => $credentials['prefix']
]);
}
}
app/Http/Controllers/Web/Profile/AvatarController.php
+75
View File
@@ -0,0 +1,75 @@
<?php
namespace Vanguard\Http\Controllers\Web\Profile;
use Illuminate\Http\Request;
use Vanguard\Events\User\ChangedAvatar;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Repositories\User\UserRepository;
use Vanguard\Services\Upload\UserAvatarManager;
/**
* Class ProfileController
* @package Vanguard\Http\Controllers
*/
class AvatarController extends Controller
{
public function __construct(private UserRepository $users)
{
}
/**
* Upload and update user's avatar.
*
* @param Request $request
* @param UserAvatarManager $avatarManager
* @return mixed
*/
public function update(Request $request, UserAvatarManager $avatarManager)
{
$request->validate(['avatar' => 'image']);
$name = $avatarManager->uploadAndCropAvatar(
$request->file('avatar'),
$request->get('points')
);
if ($name) {
return $this->handleAvatarUpdate($name);
}
return redirect()->route('profile')
->withErrors(__('Avatar image cannot be updated. Please try again.'));
}
/**
* Update avatar for currently logged in user
* and fire appropriate event.
*
* @param $avatar
* @return mixed
*/
private function handleAvatarUpdate($avatar)
{
$this->users->update(auth()->id(), ['avatar' => $avatar]);
event(new ChangedAvatar);
return redirect()->route('profile')
->withSuccess(__('Avatar changed successfully.'));
}
/**
* Update user's avatar from external location/url.
*
* @param Request $request
* @param UserAvatarManager $avatarManager
* @return mixed
*/
public function updateExternal(Request $request, UserAvatarManager $avatarManager)
{
$avatarManager->deleteAvatarIfUploaded(auth()->user());
return $this->handleAvatarUpdate($request->get('url'));
}
}
app/Http/Controllers/Web/Profile/DetailsController.php
+35
View File
@@ -0,0 +1,35 @@
<?php
namespace Vanguard\Http\Controllers\Web\Profile;
use Vanguard\Events\User\UpdatedProfileDetails;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Http\Requests\User\UpdateProfileDetailsRequest;
use Vanguard\Repositories\User\UserRepository;
/**
* Class DetailsController
* @package Vanguard\Http\Controllers
*/
class DetailsController extends Controller
{
public function __construct(private UserRepository $users)
{
}
/**
* Update profile details.
*
* @param UpdateProfileDetailsRequest $request
* @return mixed
*/
public function update(UpdateProfileDetailsRequest $request)
{
$this->users->update(auth()->id(), $request->except('role_id', 'status'));
event(new UpdatedProfileDetails);
return redirect()->back()
->withSuccess(__('Profile updated successfully.'));
}
}
app/Http/Controllers/Web/Profile/LoginDetailsController.php
+41
View File
@@ -0,0 +1,41 @@
<?php
namespace Vanguard\Http\Controllers\Web\Profile;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Http\Requests\User\UpdateProfileLoginDetailsRequest;
use Vanguard\Repositories\User\UserRepository;
/**
* Class LoginDetailsController
* @package Vanguard\Http\Controllers
*/
class LoginDetailsController extends Controller
{
public function __construct(private UserRepository $users)
{
}
/**
* Update user's login details.
*
* @param UpdateProfileLoginDetailsRequest $request
* @return mixed
*/
public function update(UpdateProfileLoginDetailsRequest $request)
{
$data = $request->except('role', 'status');
// If password is not provided, then we will
// just remove it from $data array and do not change it
if (! data_get($data, 'password')) {
unset($data['password']);
unset($data['password_confirmation']);
}
$this->users->update(auth()->id(), $data);
return redirect()->route('profile')
->withSuccess(__('Login details updated successfully.'));
}
}
app/Http/Controllers/Web/Profile/ProfileController.php
+47
View File
@@ -0,0 +1,47 @@
<?php
namespace Vanguard\Http\Controllers\Web\Profile;
use Illuminate\Contracts\View\Factory;
use Illuminate\View\View;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Repositories\Country\CountryRepository;
use Vanguard\Repositories\Role\RoleRepository;
use Vanguard\Repositories\User\UserRepository;
use Vanguard\Support\Enum\UserStatus;
/**
* Class ProfileController
* @package Vanguard\Http\Controllers
*/
class ProfileController extends Controller
{
public function __construct(
private UserRepository $users,
private RoleRepository $roles,
private CountryRepository $countries
)
{
}
/**
* Display user's profile page.
*
* @return Factory|View
*/
public function show()
{
$roles = $this->roles->all()->filter(function ($role) {
return $role->id == auth()->user()->role_id;
})->pluck('name', 'id');
return view('user.profile', [
'user' => auth()->user(),
'edit' => true,
'roles' => $roles,
'countries' => [0 => __('Select a Country')] + $this->countries->lists()->toArray(),
'socialLogins' => $this->users->getUserSocialLogins(auth()->id()),
'statuses' => UserStatus::lists()
]);
}
}
app/Http/Controllers/Web/Profile/SessionsController.php
+43
View File
@@ -0,0 +1,43 @@
<?php
namespace Vanguard\Http\Controllers\Web\Profile;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Repositories\Session\SessionRepository;
/**
* Class SessionsController
* @package Vanguard\Http\Controllers\Web\Profile
*/
class SessionsController extends Controller
{
public function __construct(private SessionRepository $sessions)
{
}
/**
* Get sessions for specified user.
*/
public function index()
{
return view('user.sessions', [
'profile' => true,
'user' => auth()->user(),
'sessions' => $this->sessions->getUserSessions(auth()->id())
]);
}
/**
* Invalidate user's session.
*
* @param $session \stdClass Session object.
* @return mixed
*/
public function destroy($session)
{
$this->sessions->invalidateSession($session->id);
return redirect()->route('profile.sessions')
->withSuccess(__('Session invalidated successfully.'));
}
}
app/Http/Controllers/Web/SettingsController.php
+129
View File
@@ -0,0 +1,129 @@
<?php
namespace Vanguard\Http\Controllers\Web;
use Illuminate\Contracts\View\Factory;
use Illuminate\View\View;
use Vanguard\Events\Settings\Updated as SettingsUpdated;
use Illuminate\Http\Request;
use Setting;
use Vanguard\Http\Controllers\Controller;
/**
* Class SettingsController
* @package Vanguard\Http\Controllers
*/
class SettingsController extends Controller
{
public function __construct()
{
$this->middleware('auth');
}
/**
* Display general settings page.
*
* @return Factory|View
*/
public function general()
{
return view('settings.general');
}
/**
* Display Authentication & Registration settings page.
*
* @return Factory|View
*/
public function auth()
{
return view('settings.auth');
}
/**
* Handle application settings update.
*
* @param Request $request
* @return mixed
*/
public function update(Request $request)
{
$this->updatesetting($request->except("_token"));
return back()->withSuccess(__('Settings updated successfully.'));
}
/**
* Update settings and fire appropriate event.
*
* @param $input
*/
private function updatesetting($input)
{
foreach ($input as $key => $value) {
Setting::set($key, $value);
}
Setting::save();
event(new SettingsUpdated);
}
/**
* Enable system 2FA.
*
* @return mixed
*/
public function enableTwoFactor()
{
$this->updatesetting(['2fa.enabled' => true]);
return back()->withSuccess(__('Two-Factor Authentication enabled successfully.'));
}
/**
* Disable system 2FA.
*
* @return mixed
*/
public function disableTwoFactor()
{
$this->updatesetting(['2fa.enabled' => false]);
return back()->withSuccess(__('Two-Factor Authentication disabled successfully.'));
}
/**
* Enable registration captcha.
*
* @return mixed
*/
public function enableCaptcha()
{
$this->updatesetting(['registration.captcha.enabled' => true]);
return back()->withSuccess(__('reCAPTCHA enabled successfully.'));
}
/**
* Disable registration captcha.
*
* @return mixed
*/
public function disableCaptcha()
{
$this->updatesetting(['registration.captcha.enabled' => false]);
return back()->withSuccess(__('reCAPTCHA disabled successfully.'));
}
/**
* Display notification settings page.
*
* @return Factory|View
*/
public function notifications()
{
return view('settings.notifications');
}
}
app/Http/Controllers/Web/TwoFactorController.php
+137
View File
@@ -0,0 +1,137 @@
<?php
namespace Vanguard\Http\Controllers\Web;
use Vanguard\Events\User\TwoFactorDisabled;
use Vanguard\Events\User\TwoFactorEnabled;
use Vanguard\Events\User\TwoFactorEnabledByAdmin;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Http\Requests\TwoFactor\DisableTwoFactorRequest;
use Vanguard\Http\Requests\TwoFactor\EnableTwoFactorRequest;
use Vanguard\Http\Requests\TwoFactor\ReSendTwoFactorTokenRequest;
use Vanguard\Http\Requests\TwoFactor\VerifyTwoFactorTokenRequest;
use Authy;
use Vanguard\Repositories\User\UserRepository;
/**
* Class ProfileController
* @package Vanguard\Http\Controllers
*/
class TwoFactorController extends Controller
{
public function __construct(UserRepository $users)
{
$this->middleware('auth');
$this->middleware(function ($request, $next) use ($users) {
$user = $request->get('user')
? $users->find($request->get('user'))
: auth()->user();
return Authy::isEnabled($user) ? abort(404) : $next($request);
})->only('enable', 'verification', 'resend', 'verify');
}
/**
* Enable 2FA for currently logged user.
*
* @param EnableTwoFactorRequest $request
* @return \Illuminate\Http\RedirectResponse
*/
public function enable(EnableTwoFactorRequest $request)
{
$user = $request->theUser();
$user->setAuthPhoneInformation($request->country_code, $request->phone_number);
Authy::register($user);
$user->save();
Authy::sendTwoFactorVerificationToken($user);
return $user->is(auth()->user())
? redirect()->route('two-factor.verification')
: redirect()->route('two-factor.verification', ['user' => $user->id]);
}
/**
* Show the phone verification page.
*
* @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
*/
public function verification()
{
return view('user.two-factor-verification', [
'user' => request('user')
]);
}
/**
* Re-send phone verification token.
* @param ReSendTwoFactorTokenRequest $request
*/
public function resend(ReSendTwoFactorTokenRequest $request)
{
Authy::sendTwoFactorVerificationToken($request->theUser());
}
/**
* Verify 2FA token and enable 2FA if token is valid.
*
* @param VerifyTwoFactorTokenRequest $request
* @return \Illuminate\Http\RedirectResponse
*/
public function verify(VerifyTwoFactorTokenRequest $request)
{
$user = $request->theUser();
if (! Authy::tokenIsValid($user, $request->token)) {
return redirect()->route('two-factor.verification')
->withErrors(['token' => 'Invalid 2FA token.']);
}
$user->setTwoFactorAuthProviderOptions(array_merge(
$user->getTwoFactorAuthProviderOptions(),
['enabled' => true]
));
$user->save();
$message = __('Two-Factor Authentication enabled successfully.');
if ($user->is(auth()->user())) {
event(new TwoFactorEnabled);
return redirect()->route('profile')->withSuccess($message);
}
event(new TwoFactorEnabledByAdmin($user));
return redirect()->route('users.edit', $user)->withSuccess($message);
}
/**
* Disable 2FA for currently logged user.
*
* @param DisableTwoFactorRequest $request
* @return \Illuminate\Http\RedirectResponse
*/
public function disable(DisableTwoFactorRequest $request)
{
$user = $request->theUser();
if (! Authy::isEnabled($user)) {
abort(404);
}
Authy::delete($user);
$user->save();
event(new TwoFactorDisabled);
return redirect()->back()
->withSuccess(__('Two-Factor Authentication disabled successfully.'));
}
}
app/Http/Controllers/Web/Users/AvatarController.php
+71
View File
@@ -0,0 +1,71 @@
<?php
namespace Vanguard\Http\Controllers\Web\Users;
use Illuminate\Http\Request;
use Illuminate\Validation\ValidationException;
use Vanguard\Events\User\UpdatedByAdmin;
use Vanguard\Http\Controllers\Api\ApiController;
use Vanguard\Repositories\User\UserRepository;
use Vanguard\Services\Upload\UserAvatarManager;
use Vanguard\User;
/**
* Class AvatarController
* @package Vanguard\Http\Controllers\Api\Users
*/
class AvatarController extends ApiController
{
public function __construct(private UserRepository $users, private UserAvatarManager $avatarManager)
{
}
/**
* Update user's avatar from uploaded image.
*
* @param User $user
* @param Request $request
* @return mixed
* @throws ValidationException
*/
public function update(User $user, Request $request)
{
$this->validate($request, ['avatar' => 'image']);
$name = $this->avatarManager->uploadAndCropAvatar(
$request->file('avatar'),
$request->get('points')
);
if ($name) {
$this->users->update($user->id, ['avatar' => $name]);
event(new UpdatedByAdmin($user));
return redirect()->route('users.edit', $user)
->withSuccess(__('Avatar changed successfully.'));
}
return redirect()->route('users.edit', $user)
->withErrors(__('Avatar image cannot be updated. Please try again.'));
}
/**
* Update user's avatar from some external source (Gravatar, Facebook, Twitter...)
*
* @param User $user
* @param Request $request
* @return mixed
*/
public function updateExternal(User $user, Request $request)
{
$this->avatarManager->deleteAvatarIfUploaded($user);
$this->users->update($user->id, ['avatar' => $request->get('url')]);
event(new UpdatedByAdmin($user));
return redirect()->route('users.edit', $user)
->withSuccess(__('Avatar changed successfully.'));
}
}
app/Http/Controllers/Web/Users/DetailsController.php
+66
View File
@@ -0,0 +1,66 @@
<?php
namespace Vanguard\Http\Controllers\Web\Users;
use Illuminate\Http\Request;
use Vanguard\Events\User\Banned;
use Vanguard\Events\User\UpdatedByAdmin;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Http\Requests\User\UpdateDetailsRequest;
use Vanguard\Repositories\User\UserRepository;
use Vanguard\Support\Enum\UserStatus;
use Vanguard\User;
/**
* Class UserDetailsController
* @package Vanguard\Http\Controllers\Users
*/
class DetailsController extends Controller
{
public function __construct(private UserRepository $users)
{
}
/**
* Updates user details.
*
* @param User $user
* @param UpdateDetailsRequest $request
* @return mixed
*/
public function update(User $user, UpdateDetailsRequest $request)
{
$data = $request->all();
if (! data_get($data, 'country_id')) {
$data['country_id'] = null;
}
$this->users->update($user->id, $data);
$this->users->setRole($user->id, $request->role_id);
event(new UpdatedByAdmin($user));
// If user status was updated to "Banned",
// fire the appropriate event.
if ($this->userWasBanned($user, $request)) {
event(new Banned($user));
}
return redirect()->back()
->withSuccess(__('User updated successfully.'));
}
/**
* Check if user is banned during last update.
*
* @param User $user
* @param Request $request
* @return bool
*/
private function userWasBanned(User $user, Request $request)
{
return $user->status != $request->status
&& $request->status == UserStatus::BANNED;
}
}
app/Http/Controllers/Web/Users/LoginDetailsController.php
+44
View File
@@ -0,0 +1,44 @@
<?php
namespace Vanguard\Http\Controllers\Web\Users;
use Vanguard\Events\User\UpdatedByAdmin;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Http\Requests\User\UpdateLoginDetailsRequest;
use Vanguard\Repositories\User\UserRepository;
use Vanguard\User;
/**
* Class UserDetailsController
* @package Vanguard\Http\Controllers\Users
*/
class LoginDetailsController extends Controller
{
public function __construct(private UserRepository $users)
{
}
/**
* Update user's login details.
*
* @param User $user
* @param UpdateLoginDetailsRequest $request
* @return mixed
*/
public function update(User $user, UpdateLoginDetailsRequest $request)
{
$data = $request->all();
if (! $data['password']) {
unset($data['password']);
unset($data['password_confirmation']);
}
$this->users->update($user->id, $data);
event(new UpdatedByAdmin($user));
return redirect()->route('users.edit', $user->id)
->withSuccess(__('Login details updated successfully.'));
}
}
app/Http/Controllers/Web/Users/SessionsController.php
+51
View File
@@ -0,0 +1,51 @@
<?php
namespace Vanguard\Http\Controllers\Web\Users;
use Illuminate\Contracts\View\Factory;
use Illuminate\View\View;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Repositories\Session\SessionRepository;
use Vanguard\User;
/**
* Class SessionsController
* @package Vanguard\Http\Controllers\Web\Users
*/
class SessionsController extends Controller
{
public function __construct(private SessionRepository $sessions)
{
$this->middleware('permission:users.manage');
}
/**
* Displays the list with all active sessions for the selected user.
*
* @param User $user
* @return Factory|View
*/
public function index(User $user)
{
return view('user.sessions', [
'adminView' => true,
'user' => $user,
'sessions' => $this->sessions->getUserSessions($user->id)
]);
}
/**
* Invalidate specified session for selected user.
*
* @param User $user
* @param $session
* @return mixed
*/
public function destroy(User $user, $session)
{
$this->sessions->invalidateSession($session->id);
return redirect()->route('user.sessions', $user->id)
->withSuccess(__('Session invalidated successfully.'));
}
}
app/Http/Controllers/Web/Users/UsersController.php
+153
View File
@@ -0,0 +1,153 @@
<?php
namespace Vanguard\Http\Controllers\Web\Users;
use Illuminate\Contracts\View\Factory;
use Illuminate\Http\Request;
use Illuminate\View\View;
use Vanguard\Events\User\Deleted;
use Vanguard\Http\Controllers\Controller;
use Vanguard\Http\Requests\User\CreateUserRequest;
use Vanguard\Repositories\Activity\ActivityRepository;
use Vanguard\Repositories\Country\CountryRepository;
use Vanguard\Repositories\Role\RoleRepository;
use Vanguard\Repositories\User\UserRepository;
use Vanguard\Support\Enum\UserStatus;
use Vanguard\User;
/**
* Class UsersController
* @package Vanguard\Http\Controllers
*/
class UsersController extends Controller
{
public function __construct(private UserRepository $users)
{
}
/**
* Display paginated list of all users.
*
* @param Request $request
* @return Factory|View
*/
public function index(Request $request)
{
$users = $this->users->paginate($perPage = 20, $request->search, $request->status);
$statuses = ['' => __('All')] + UserStatus::lists();
return view('user.list', compact('users', 'statuses'));
}
/**
* Displays user profile page.
*
* @param User $user
* @return Factory|View
*/
public function show(User $user)
{
return view('user.view', compact('user'));
}
/**
* Displays form for creating a new user.
*
* @param CountryRepository $countryRepository
* @param RoleRepository $roleRepository
* @return Factory|View
*/
public function create(CountryRepository $countryRepository, RoleRepository $roleRepository)
{
return view('user.add', [
'countries' => $this->parseCountries($countryRepository),
'roles' => $roleRepository->lists(),
'statuses' => UserStatus::lists()
]);
}
/**
* Parse countries into an array that also has a blank
* item as first element, which will allow users to
* leave the country field unpopulated.
*
* @param CountryRepository $countryRepository
* @return array
*/
private function parseCountries(CountryRepository $countryRepository)
{
return [0 => __('Select a Country')] + $countryRepository->lists()->toArray();
}
/**
* Stores new user into the database.
*
* @param CreateUserRequest $request
* @return mixed
*/
public function store(CreateUserRequest $request)
{
// When user is created by administrator, we will set his
// status to Active by default.
$data = $request->all() + [
'status' => UserStatus::ACTIVE,
'email_verified_at' => now()
];
if (! data_get($data, 'country_id')) {
$data['country_id'] = null;
}
// Username should be updated only if it is provided.
if (! data_get($data, 'username')) {
$data['username'] = null;
}
$this->users->create($data);
return redirect()->route('users.index')
->withSuccess(__('User created successfully.'));
}
/**
* Displays edit user form.
*
* @param User $user
* @param CountryRepository $countryRepository
* @param RoleRepository $roleRepository
* @return Factory|View
*/
public function edit(User $user, CountryRepository $countryRepository, RoleRepository $roleRepository)
{
return view('user.edit', [
'edit' => true,
'user' => $user,
'countries' => $this->parseCountries($countryRepository),
'roles' => $roleRepository->lists(),
'statuses' => UserStatus::lists(),
'socialLogins' => $this->users->getUserSocialLogins($user->id)
]);
}
/**
* Removes the user from database.
*
* @param User $user
* @return $this
*/
public function destroy(User $user)
{
if ($user->is(auth()->user())) {
return redirect()->route('users.index')
->withErrors(__('You cannot delete yourself.'));
}
$this->users->delete($user->id);
event(new Deleted($user));
return redirect()->route('users.index')
->withSuccess(__('User deleted successfully.'));
}
}