Plataforma-de-Tutoriais/plataforma-tutorias/app/Http/Controllers/UserController.php

<?php

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use App\Http\Requests\CreateUserRequest;
use App\Http\Requests\UpdateUserRequest;

class UserController extends Controller
{
    public function index(Request $request)
    {
        $user = auth()->user();

        if (!$user) {
            return response()->json([
                'message' => 'Utilizador não autenticado',
                'data' => null,
                'errors' => null,
            ], 404);
        }

        if ($user->role_id === 1) {
            $search = trim((string) $request->query('search', ''));
            $filter = $request->query('filter', 'all');
            $usersQuery = User::query();

            if ($search !== '') {
                $usersQuery->where(function ($q) use ($search) {
                    $q->where('name', 'like', "%{$search}%")
                      ->orWhere('email', 'like', "%{$search}%");
                });
            }

            if ($filter === 'admin') {
                $usersQuery->where('role_id', 1);
            } elseif ($filter === 'user') {
                $usersQuery->where('role_id', 2);
            }

            $users = $usersQuery->paginate(10)->appends(['filter' => $filter, 'search' => $search]);

            return response()->json([
                'message' => 'Utilizadores obtidos com sucesso',
                'data' => $users,
                'errors' => null,
            ], 200);
        } else {
            return response()->json([
                'message' => 'Não foi possível obter os utilizadores',
                'data' => null,
                'errors' => null,
            ], 500);
        }
    }

    public function getUser($id)
    {
        $user = User::find($id);

        if (!$user) {
            return response()->json([
                'message' => 'Utilizador não encontrado',
                'data' => null,
                'errors' => null,
            ], 404);
        }

        return response()->json([
            'message' => 'Utilizador obtido com sucesso',
            'data' => $user,
            'errors' => null,
        ], 200);
    }

    public function create(CreateUserRequest $request)
    {
        $validated = $request->validated();

        try {
            $user = User::create([
                'name' => $validated['name'],
                'email' => $validated['email'],
                'password' => Hash::make($validated['password']),
                'role_id' => $validated['role_id'],
            ]);

            return response()->json([
                'message' => 'Utilizador criado com sucesso',
                'data' => $user,
                'errors' => null,
            ], 201);
        } catch (\Illuminate\Validation\ValidationException $e) {
            return response()->json([
                'message' => 'Erro ao criar o utilizador',
                'data' => null,
                'errors' => $e->errors(),
            ], 422);
        } catch (\Throwable $th) {
            return response()->json([
                'message' => 'Não foi possível criar o utilizador',
                'data' => null,
                'errors' => null,
            ], 500);
        }
    }

    public function update(UpdateUserRequest $request, $id)
    {
        $user = auth()->user();

        if (!$user) {
            return response()->json([
                'message' => null,
                'data' => null,
                'errors' => [
                    'message' => "Utilizador não autenticado",
                ],
            ], 404);
        }

        $userToUpdate = User::find($id);

        if (!$userToUpdate) {
            return response()->json([
                'message' => 'Utilizador não encontrado',
                'data' => null,
                'errors' => null,
            ], 404);
        }

        $request = request();

        try {
            $data = [
                'name'    => $request->name ?: $userToUpdate->name,
                'email'   => $request->email ?: $userToUpdate->email,
                'role_id' => $request->role_id ?: $userToUpdate->role_id,
            ];

            if ($request->filled('novaPassword')) {
                if (! Hash::check($request->passwordAtual, $userToUpdate->password)) {
                    return response()->json([
                        'message' => 'Password atual incorreta',
                        'data' => null,
                        'errors' => [
                            'message' => 'A password atual não está correta',
                        ],
                    ], 422);
                }

                if ($request->novaPassword !== $request->confirmarPassword) {
                    return response()->json([
                        'message' => 'As passwords não coincidem',
                        'data' => null,
                        'errors' => [
                            'message' => 'A nova password e a confirmação devem coincidir',
                        ],
                    ], 422);
                }

                $data['password'] = Hash::make($request->novaPassword);
            }

            $userToUpdate->update($data);

            $userUpdated = User::find($id);

            return response()->json([
                'message' => 'Utilizador atualizado com sucesso',
                'data' => $userUpdated,
                'errors' => null,
            ], 201);
        } catch (\Throwable $th) {
            return response()->json([
                'message' => 'Não foi possível atualizar o utilizador',
                'data' => null,
                'errors' => null,
            ], 500);
        }
    }

    public function destroy($id)
    {
        $user = auth()->user();

        if (!$user) {
            return response()->json([
                'message' => 'Utilizador não autenticado',
                'data' => null,
                'errors' => null,
            ], 404);
        }

        if ($user->role_id !== 1) {
            return response()->json([
                'message' => 'Utilizador não autorizado',
                'data' => null,
                'errors' => null,
            ], 403);
        }

        if ($user->id === (int) $id) {
            return response()->json([
                'message' => 'Não pode apagar a sua própria conta de administrador',
                'data' => null,
                'errors' => null,
            ], 403);
        }

        $userToDelete = User::find($id);

        if (!$userToDelete) {
            return response()->json([
                'message' => 'Utilizador não encontrado',
                'data' => null,
                'errors' => null,
            ], 404);
        }

        try {
            $userToDelete->delete();

            return response()->json([
                'message' => 'Utilizador apagado com sucesso',
                'data' => null,
                'errors' => null,
            ], 200);
        } catch (\Throwable $th) {
            return response()->json([
                'message' => 'Não foi possível apagar o utilizador',
                'data' => null,
                'errors' => null,
            ], 500);
        }
    }
}