422 lines
13 KiB
PHP
422 lines
13 KiB
PHP
<?php
|
|
|
|
namespace App\Http\Controllers;
|
|
|
|
use App\Events;
|
|
use App\Exceptions\PrettyPageException;
|
|
use App\Mail\ForgotPassword;
|
|
use App\Models\Player;
|
|
use App\Models\User;
|
|
use App\Rules;
|
|
use Auth;
|
|
use Blessing\Filter;
|
|
use Blessing\Rejection;
|
|
use Cache;
|
|
use Carbon\Carbon;
|
|
use Illuminate\Contracts\Events\Dispatcher;
|
|
use Illuminate\Http\Request;
|
|
use Laravel\Socialite\Facades\Socialite;
|
|
use Mail;
|
|
use Session;
|
|
use URL;
|
|
use Vectorface\Whip\Whip;
|
|
|
|
class AuthController extends Controller
|
|
{
|
|
public function login(Filter $filter)
|
|
{
|
|
$whip = new Whip();
|
|
$ip = $whip->getValidIpAddress();
|
|
$ip = $filter->apply('client_ip', $ip);
|
|
|
|
return view('auth.login', [
|
|
'extra' => [
|
|
'tooManyFails' => cache(sha1('login_fails_'.$ip)) > 3,
|
|
'recaptcha' => option('recaptcha_sitekey'),
|
|
'invisible' => (bool) option('recaptcha_invisible'),
|
|
],
|
|
]);
|
|
}
|
|
|
|
public function handleLogin(
|
|
Request $request,
|
|
Rules\Captcha $captcha,
|
|
Dispatcher $dispatcher,
|
|
Filter $filter
|
|
) {
|
|
$request->validate([
|
|
'identification' => 'required',
|
|
'password' => 'required|min:6|max:32',
|
|
]);
|
|
$identification = $request->input('identification');
|
|
$password = $request->input('password');
|
|
|
|
$can = $filter->apply('can_login', null, [$identification, $password]);
|
|
if ($can instanceof Rejection) {
|
|
return json($can->getReason(), 1);
|
|
}
|
|
|
|
// Guess type of identification
|
|
$authType = filter_var($identification, FILTER_VALIDATE_EMAIL) ? 'email' : 'username';
|
|
|
|
$dispatcher->dispatch('auth.login.attempt', [$identification, $password, $authType]);
|
|
event(new Events\UserTryToLogin($identification, $authType));
|
|
|
|
if ($authType == 'email') {
|
|
$user = User::where('email', $identification)->first();
|
|
} else {
|
|
$player = Player::where('name', $identification)->first();
|
|
$user = optional($player)->user;
|
|
}
|
|
|
|
// Require CAPTCHA if user fails to login more than 3 times
|
|
$whip = new Whip();
|
|
$ip = $whip->getValidIpAddress();
|
|
$ip = $filter->apply('client_ip', $ip);
|
|
$loginFailsCacheKey = sha1('login_fails_'.$ip);
|
|
$loginFails = (int) Cache::get($loginFailsCacheKey, 0);
|
|
|
|
if ($loginFails > 3) {
|
|
$request->validate(['captcha' => ['required', $captcha]]);
|
|
}
|
|
|
|
if (!$user) {
|
|
return json(trans('auth.validation.user'), 2);
|
|
}
|
|
|
|
$dispatcher->dispatch('auth.login.ready', [$user]);
|
|
|
|
if ($user->verifyPassword($request->input('password'))) {
|
|
Session::forget('login_fails');
|
|
Cache::forget($loginFailsCacheKey);
|
|
|
|
Auth::login($user, $request->input('keep'));
|
|
|
|
$dispatcher->dispatch('auth.login.succeeded', [$user]);
|
|
event(new Events\UserLoggedIn($user));
|
|
|
|
return json(trans('auth.login.success'), 0, [
|
|
'redirectTo' => $request->session()->pull('last_requested_path', url('/user')),
|
|
]);
|
|
} else {
|
|
$loginFails++;
|
|
Cache::put($loginFailsCacheKey, $loginFails, 3600);
|
|
$dispatcher->dispatch('auth.login.failed', [$user, $loginFails]);
|
|
|
|
return json(trans('auth.validation.password'), 1, [
|
|
'login_fails' => $loginFails,
|
|
]);
|
|
}
|
|
}
|
|
|
|
public function logout(Dispatcher $dispatcher)
|
|
{
|
|
$user = Auth::user();
|
|
|
|
$dispatcher->dispatch('auth.logout.before', [$user]);
|
|
Auth::logout();
|
|
$dispatcher->dispatch('auth.logout.after', [$user]);
|
|
|
|
return json(trans('auth.logout.success'), 0);
|
|
}
|
|
|
|
public function register()
|
|
{
|
|
if (option('user_can_register')) {
|
|
return view('auth.register', [
|
|
'site_name' => option_localized('site_name'),
|
|
'extra' => [
|
|
'player' => (bool) option('register_with_player_name'),
|
|
'recaptcha' => option('recaptcha_sitekey'),
|
|
'invisible' => (bool) option('recaptcha_invisible'),
|
|
],
|
|
]);
|
|
} else {
|
|
throw new PrettyPageException(trans('auth.register.close'), 7);
|
|
}
|
|
}
|
|
|
|
public function handleRegister(
|
|
Request $request,
|
|
Rules\Captcha $captcha,
|
|
Dispatcher $dispatcher,
|
|
Filter $filter
|
|
) {
|
|
if (!option('user_can_register')) {
|
|
return json(trans('auth.register.close'), 7);
|
|
}
|
|
|
|
$can = $filter->apply('can_register', null);
|
|
if ($can instanceof Rejection) {
|
|
return json($can->getReason(), 1);
|
|
}
|
|
|
|
$rule = option('register_with_player_name') ?
|
|
['player_name' => [
|
|
'required',
|
|
new Rules\PlayerName(),
|
|
'min:'.option('player_name_length_min'),
|
|
'max:'.option('player_name_length_max'),
|
|
]] :
|
|
['nickname' => 'required|max:255'];
|
|
$data = $request->validate(array_merge([
|
|
'email' => 'required|email|unique:users',
|
|
'password' => 'required|min:8|max:32',
|
|
'captcha' => ['required', $captcha],
|
|
], $rule));
|
|
|
|
$dispatcher->dispatch('auth.registration.attempt', [$data]);
|
|
|
|
if (
|
|
option('register_with_player_name') &&
|
|
Player::where('name', $request->input('player_name'))->count() > 0
|
|
) {
|
|
return json(trans('user.player.add.repeated'), 2);
|
|
}
|
|
|
|
// If amount of registered accounts of IP is more than allowed amounts,
|
|
// then reject the register.
|
|
$whip = new Whip();
|
|
$ip = $whip->getValidIpAddress();
|
|
$ip = $filter->apply('client_ip', $ip);
|
|
if (User::where('ip', $ip)->count() >= option('regs_per_ip')) {
|
|
return json(trans('auth.register.max', ['regs' => option('regs_per_ip')]), 7);
|
|
}
|
|
|
|
$dispatcher->dispatch('auth.registration.ready', [$data]);
|
|
|
|
$user = new User();
|
|
$user->email = $data['email'];
|
|
$user->nickname = $data[option('register_with_player_name') ? 'player_name' : 'nickname'];
|
|
$user->score = option('user_initial_score');
|
|
$user->avatar = 0;
|
|
$user->password = $user->getEncryptedPwdFromEvent($data['password'])
|
|
?: app('cipher')->hash($data['password'], config('secure.salt'));
|
|
$user->ip = $ip;
|
|
$user->permission = User::NORMAL;
|
|
$user->register_at = Carbon::now();
|
|
$user->last_sign_at = Carbon::now()->subDay();
|
|
|
|
$user->save();
|
|
|
|
$dispatcher->dispatch('auth.registration.completed', [$user]);
|
|
event(new Events\UserRegistered($user));
|
|
|
|
if (option('register_with_player_name')) {
|
|
$player = new Player();
|
|
$player->uid = $user->uid;
|
|
$player->name = $request->get('player_name');
|
|
$player->tid_skin = 0;
|
|
$player->save();
|
|
|
|
event(new Events\PlayerWasAdded($player));
|
|
}
|
|
|
|
$dispatcher->dispatch('auth.login.ready', [$user]);
|
|
Auth::login($user);
|
|
$dispatcher->dispatch('auth.login.succeeded', [$user]);
|
|
|
|
return json(trans('auth.register.success'), 0);
|
|
}
|
|
|
|
public function forgot()
|
|
{
|
|
if (config('mail.default') != '') {
|
|
return view('auth.forgot', [
|
|
'extra' => [
|
|
'recaptcha' => option('recaptcha_sitekey'),
|
|
'invisible' => (bool) option('recaptcha_invisible'),
|
|
],
|
|
]);
|
|
} else {
|
|
throw new PrettyPageException(trans('auth.forgot.disabled'), 8);
|
|
}
|
|
}
|
|
|
|
public function handleForgot(
|
|
Request $request,
|
|
Rules\Captcha $captcha,
|
|
Dispatcher $dispatcher,
|
|
Filter $filter
|
|
) {
|
|
$data = $request->validate([
|
|
'email' => 'required|email',
|
|
'captcha' => ['required', $captcha],
|
|
]);
|
|
|
|
if (!config('mail.default')) {
|
|
return json(trans('auth.forgot.disabled'), 1);
|
|
}
|
|
|
|
$email = $data['email'];
|
|
$dispatcher->dispatch('auth.forgot.attempt', [$email]);
|
|
|
|
$rateLimit = 180;
|
|
$whip = new Whip();
|
|
$ip = $whip->getValidIpAddress();
|
|
$ip = $filter->apply('client_ip', $ip);
|
|
$lastMailCacheKey = sha1('last_mail_'.$ip);
|
|
$remain = $rateLimit + Cache::get($lastMailCacheKey, 0) - time();
|
|
if ($remain > 0) {
|
|
return json(trans('auth.forgot.frequent-mail'), 2);
|
|
}
|
|
|
|
$user = User::where('email', $email)->first();
|
|
|
|
if (!$user) {
|
|
return json(trans('auth.forgot.unregistered'), 1);
|
|
}
|
|
|
|
$dispatcher->dispatch('auth.forgot.ready', [$user]);
|
|
|
|
$url = URL::temporarySignedRoute(
|
|
'auth.reset',
|
|
now()->addHour(),
|
|
['uid' => $user->uid],
|
|
false
|
|
);
|
|
try {
|
|
Mail::to($email)->send(new ForgotPassword(url($url)));
|
|
} catch (\Exception $e) {
|
|
report($e);
|
|
$dispatcher->dispatch('auth.forgot.failed', [$user, $url]);
|
|
|
|
return json(trans('auth.forgot.failed', ['msg' => $e->getMessage()]), 2);
|
|
}
|
|
|
|
$dispatcher->dispatch('auth.forgot.sent', [$user, $url]);
|
|
Cache::put($lastMailCacheKey, time(), 3600);
|
|
|
|
return json(trans('auth.forgot.success'), 0);
|
|
}
|
|
|
|
public function reset(Request $request, $uid)
|
|
{
|
|
abort_unless($request->hasValidSignature(false), 403, trans('auth.reset.invalid'));
|
|
|
|
return view('auth.reset')->with('user', User::find($uid));
|
|
}
|
|
|
|
public function handleReset(Dispatcher $dispatcher, Request $request, $uid)
|
|
{
|
|
abort_unless($request->hasValidSignature(false), 403, trans('auth.reset.invalid'));
|
|
|
|
['password' => $password] = $request->validate([
|
|
'password' => 'required|min:8|max:32',
|
|
]);
|
|
$user = User::find($uid);
|
|
|
|
$dispatcher->dispatch('auth.reset.before', [$user, $password]);
|
|
$user->changePassword($password);
|
|
$dispatcher->dispatch('auth.reset.after', [$user, $password]);
|
|
|
|
return json(trans('auth.reset.success'), 0);
|
|
}
|
|
|
|
public function captcha(\Gregwar\Captcha\CaptchaBuilder $builder)
|
|
{
|
|
$builder->build(100, 34);
|
|
session(['captcha' => $builder->getPhrase()]);
|
|
|
|
return response($builder->output(), 200, [
|
|
'Content-Type' => 'image/jpeg',
|
|
'Cache-Control' => 'no-store',
|
|
]);
|
|
}
|
|
|
|
public function fillEmail(Request $request)
|
|
{
|
|
$email = $request->validate(['email' => 'required|email|unique:users'])['email'];
|
|
$user = $request->user();
|
|
$user->email = $email;
|
|
$user->save();
|
|
|
|
return redirect('/user');
|
|
}
|
|
|
|
public function verify(Request $request, $uid)
|
|
{
|
|
if (!option('require_verification')) {
|
|
throw new PrettyPageException(trans('user.verification.disabled'), 1);
|
|
}
|
|
|
|
abort_unless($request->hasValidSignature(false), 403, trans('auth.verify.invalid'));
|
|
|
|
$user = User::find($uid);
|
|
|
|
if (!$user || $user->verified) {
|
|
throw new PrettyPageException(trans('auth.verify.invalid'), 1);
|
|
}
|
|
|
|
$user->verified = true;
|
|
$user->save();
|
|
|
|
return view('auth.verify', ['site_name' => option_localized('site_name')]);
|
|
}
|
|
|
|
public function jwtLogin(Request $request)
|
|
{
|
|
$token = Auth::guard('jwt')->attempt([
|
|
'email' => $request->input('email'),
|
|
'password' => $request->input('password'),
|
|
]) ?: '';
|
|
|
|
return json(compact('token'));
|
|
}
|
|
|
|
public function jwtLogout()
|
|
{
|
|
Auth::guard('jwt')->logout();
|
|
|
|
return response('', 204);
|
|
}
|
|
|
|
public function jwtRefresh()
|
|
{
|
|
return json(['token' => Auth::guard('jwt')->refresh()]);
|
|
}
|
|
|
|
public function oauthLogin($driver)
|
|
{
|
|
return Socialite::driver($driver)->redirect();
|
|
}
|
|
|
|
public function oauthCallback(Dispatcher $dispatcher, Filter $filter, $driver)
|
|
{
|
|
$remoteUser = Socialite::driver($driver)->user();
|
|
|
|
$email = $remoteUser->email;
|
|
if (empty($email)) {
|
|
abort(500, 'Unsupported OAuth Server which does not provide email.');
|
|
}
|
|
|
|
$user = User::where('email', $email)->first();
|
|
if (!$user) {
|
|
$whip = new Whip();
|
|
$ip = $whip->getValidIpAddress();
|
|
$ip = $filter->apply('client_ip', $ip);
|
|
|
|
$user = new User();
|
|
$user->email = $email;
|
|
$user->nickname = $remoteUser->nickname ?? $remoteUser->name ?? $email;
|
|
$user->score = option('user_initial_score');
|
|
$user->avatar = 0;
|
|
$user->password = '';
|
|
$user->ip = $ip;
|
|
$user->permission = User::NORMAL;
|
|
$user->register_at = Carbon::now();
|
|
$user->last_sign_at = Carbon::now()->subDay();
|
|
$user->verified = true;
|
|
|
|
$user->save();
|
|
$dispatcher->dispatch('auth.registration.completed', [$user]);
|
|
}
|
|
|
|
$dispatcher->dispatch('auth.login.ready', [$user]);
|
|
Auth::login($user);
|
|
$dispatcher->dispatch('auth.login.succeeded', [$user]);
|
|
|
|
return redirect('/user');
|
|
}
|
|
}
|