pixelfed/app/Http/Controllers/AdminInviteController.php

<?php

namespace App\Http\Controllers;

use App\Models\AdminInvite;
use App\Models\User;
use App\Rules\ValidUsername;
use App\Services\EmailService;
use App\Services\EmailVerificationService;
use Illuminate\Auth\Events\Registered;
use Illuminate\Contracts\View\View;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Validator;
use Purify;

class AdminInviteController extends Controller
{
    public function __construct()
    {
        abort_if(! config('instance.admin_invites.enabled'), 404);
    }

    public function index(Request $request, $code): RedirectResponse|View
    {
        if ($request->user()) {
            return redirect('/');
        }

        return view('invite.admin_invite', ['code' => $code]);
    }

    public function apiVerifyCheck(Request $request): JsonResponse
    {
        $this->validate($request, [
            'token' => 'required',
        ]);

        $invite = AdminInvite::whereInviteCode($request->input('token'))->first();
        abort_if(! $invite, 404);
        abort_if($invite->expires_at && $invite->expires_at->lt(now()), 400, 'Invite has expired.');
        abort_if($invite->max_uses && $invite->uses >= $invite->max_uses, 400, 'Maximum invites reached.');
        $res = [
            'message' => $invite->message,
            'max_uses' => $invite->max_uses,
            'sev' => $invite->skip_email_verification,
        ];

        return response()->json($res);
    }

    public function apiUsernameCheck(Request $request): JsonResponse
    {
        $this->validate($request, [
            'token' => 'required',
            'username' => 'required',
        ]);

        $invite = AdminInvite::whereInviteCode($request->input('token'))->first();
        abort_if(! $invite, 404);
        abort_if($invite->expires_at && $invite->expires_at->lt(now()), 400, 'Invite has expired.');
        abort_if($invite->max_uses && $invite->uses >= $invite->max_uses, 400, 'Maximum invites reached.');

        $usernameRules = [
            'required',
            'min:2',
            'max:30',
            'unique:users',
            new ValidUsername,
        ];

        $rules = ['username' => $usernameRules];
        $validator = Validator::make($request->all(), $rules);

        if ($validator->fails()) {
            return response()->json($validator->errors(), 400);
        }

        return response()->json([]);
    }

    public function apiEmailCheck(Request $request): JsonResponse
    {
        $this->validate($request, [
            'token' => 'required',
            'email' => 'required',
        ]);

        $invite = AdminInvite::whereInviteCode($request->input('token'))->first();
        abort_if(! $invite, 404);
        abort_if($invite->expires_at && $invite->expires_at->lt(now()), 400, 'Invite has expired.');
        abort_if($invite->max_uses && $invite->uses >= $invite->max_uses, 400, 'Maximum invites reached.');

        $emailRules = [
            'required',
            'string',
            'email:strict,rfc,dns,spoof,filter',
            'max:255',
            'unique:users',
            function ($attribute, $value, $fail) {
                $banned = EmailService::isBanned($value);
                if ($banned) {
                    return $fail('Email is invalid.');
                }
            },
        ];

        $rules = ['email' => $emailRules];
        $validator = Validator::make($request->all(), $rules);

        if ($validator->fails()) {
            return response()->json($validator->errors(), 400);
        }

        return response()->json([]);
    }

    public function apiRegister(Request $request): JsonResponse|RedirectResponse
    {
        $this->validate($request, [
            'token' => 'required',
            'username' => [
                'required',
                'min:2',
                'max:30',
                'unique:users',
                new ValidUsername,
            ],
            'name' => 'nullable|string|max:'.config('pixelfed.max_name_length'),
            'email' => [
                'required',
                'string',
                'email:strict,rfc,dns,spoof,filter',
                'max:255',
                'unique:users',
                function ($attribute, $value, $fail) {
                    $banned = EmailService::isBanned($value);
                    if ($banned) {
                        return $fail('Email is invalid.');
                    }
                },
            ],
            'password' => 'required|string|min:'.config('pixelfed.min_password_length'),
            'password_confirm' => 'required',
        ]);

        $invite = AdminInvite::whereInviteCode($request->input('token'))->firstOrFail();
        abort_if($invite->expires_at && $invite->expires_at->lt(now()), 400, 'Invite expired');
        abort_if($invite->max_uses && $invite->uses >= $invite->max_uses, 400, 'Maximum invites reached.');

        $invite->uses = $invite->uses + 1;

        event(new Registered($user = User::create([
            'name' => Purify::clean($request->input('name')) ?? $request->input('username'),
            'username' => $request->input('username'),
            'email' => $request->input('email'),
            'password' => Hash::make($request->input('password')),
        ])));

        sleep(5);

        $invite->used_by = array_merge($invite->used_by ?? [], [[
            'user_id' => $user->id,
            'username' => $user->username,
        ]]);
        $invite->save();

        if ($invite->skip_email_verification) {
            $user->email_verified_at = now();
            $user->save();
        } else {
            EmailVerificationService::send($user);
        }

        if (Auth::attempt([
            'email' => $request->input('email'),
            'password' => $request->input('password'),
        ])) {
            $request->session()->regenerate();

            return redirect()->intended('/');
        }

        return response()->json([], 400);
    }
}