XavierOliveira/Plataforma-de-Tutoriais
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Estado inicial: frontend React + backend Laravel

Browse Source
This commit is contained in:
Xavier Oliveira
2026-05-15 15:57:54 +01:00
commit 41c5f87d5b
216 changed files with 29916 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

118
plataforma-tutorias/app/Http/Controllers/AuthController.php Normal file
View File

@@ -0,0 +1,118 @@
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Models\User;
use Illuminate\Support\Facades\Hash;
use Tymon\JWTAuth\Facades\JWTAuth;
use Tymon\JWTAuth\Exceptions\JWTException;
use App\Http\Requests\LoginRequest;
class AuthController extends Controller
{
public function register(Request $request)
{
$request->validate([
'name' => 'required|string|max:255',
'email' => 'required|string|email|max:255|unique:users',
'password' => 'required|string|min:6|confirmed',
]);
$user = User::create([
'name' => $request->name,
'email' => $request->email,
'password' => Hash::make($request->password),
'role_id' => 2,
]);
try {
$token = JWTAuth::fromUser($user);
} catch (JWTException $e) {
return response()->json(['error' => 'Could not create token'], 500);
}
$user->load('role');
return response()->json([
'token' => $token,
'user' => $user,
], 201);
}
public function login(LoginRequest $request)
{
$login = JWTAuth::attempt([
"email" => $request->email,
"password" => $request->password
]);
if(!$login) {
return response()->json([
'message' => 'Credenciais inválidas',
'errors' => null,
], 400);
}
$user = auth()->user();
$token = JWTAuth::claims([
"role_id" => $user->role_id
])->fromUser($user);
return response()->json([
"access_token" => $token,
"token_type" => "Bearer",
"expires_in" => JWTAuth::factory()->getTTL() * 60,
"user" => [
"id" => $user->id,
"name" => $user->name,
"email" => $user->email,
"role_id" => $user->role_id,
"password" => $user->password,
"created_at" => $user->created_at,
],
]);
}
public function refresh(Request $request)
{
try {
$newAccessToken = JWTAuth::setToken($request->refresh_token)->refresh();
} catch (JWTException $e) {
return response()->json(['error' => 'Refresh token expirado, faça login novamente'], 401);
}
return response()->json([
'access_token' => $newAccessToken,
'expires_in' => JWTAuth::factory()->getTTL() * 60,
]);
}
public function logout()
{
try {
JWTAuth::invalidate(JWTAuth::getToken());
} catch (JWTException $e) {
return response()->json(['error' => 'Erro ao realizar logout, tente novamente'], 500);
}
return redirect()->route('login');
}
public function me()
{
$user = auth()->user();
return response()->json([
'message' => 'Utilizador obtido com sucesso',
'data' => [
'id' => $user->id,
'name' => $user->name,
'email' => $user->email,
'role_id' => $user->role_id,
],
'errors' => null,
], 200);
}
}

31
plataforma-tutorias/app/Http/Controllers/CategoryController.php Normal file
View File

@@ -0,0 +1,31 @@
<?php
namespace App\Http\Controllers;
use App\Http\Requests\CreateCategoryRequest;
use App\Models\Category;
use Illuminate\Http\Request;
class CategoryController extends Controller
{
public function index()
{
$categories = Category::all();
return response()->json([
'message' => 'Categorias obtidas com sucesso',
'data' => $categories,
'errors' => null,
], 200);
}
public function create(CreateCategoryRequest $request)
{
$category = Category::create($request->all());
return response()->json([
'message' => 'Categoria criada com sucesso',
'data' => $category,
'errors' => null,
], 201);
}
}

47
plataforma-tutorias/app/Http/Controllers/ContactController.php Normal file
View File

@@ -0,0 +1,47 @@
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Mail;
use Illuminate\Validation\ValidationException;
class ContactController extends Controller
{
public function send (Request $request)
{
try {
$validated = $request->validate([
'name' => 'required|string|max:255',
'email' => 'required|email',
'subject' => 'required|string|max:255',
'message' => 'required|string',
], [
'name.required' => 'O nome é obrigatório.',
'email.required' => 'O email é obrigatório.',
'subject.required' => 'Por favor, indique o assunto da mensagem.',
'message.required' => 'A sua mensagem está vazia.',
]);
} catch (ValidationException $e) {
return response()->json([
'message' => $e->validator->errors()->first(),
'errors' => $e->errors(),
], 422);
}
Mail::raw(
"Nome: {$validated['name']}\n Email: {$validated['email']}\n Assunto: {$validated['subject']}\n Mensagem: {$validated['message']}",
function ($mail) use ($validated) {
$mail->to('livetech.estagios@gmail.com')
->from(config('mail.from.address'), config('mail.from.name'))
->subject($validated['subject'])
->replyTo($validated['email'], $validated['name']);
});
return response()->json([
'message' => 'Mensagem enviada com sucesso. Iremos responder o mais brevemente possível.',
], 200);
}
}

12
plataforma-tutorias/app/Http/Controllers/Controller.php Normal file
View File

@@ -0,0 +1,12 @@
<?php
namespace App\Http\Controllers;
use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
use Illuminate\Foundation\Validation\ValidatesRequests;
use Illuminate\Routing\Controller as BaseController;
class Controller extends BaseController
{
use AuthorizesRequests, ValidatesRequests;
}

10
plataforma-tutorias/app/Http/Controllers/RoleController.php Normal file
View File

@@ -0,0 +1,10 @@
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class RoleController extends Controller
{
//
}

239
plataforma-tutorias/app/Http/Controllers/UserController.php Normal file
View File

@@ -0,0 +1,239 @@
<?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);
}
}
}

267
plataforma-tutorias/app/Http/Controllers/VideosController.php Normal file
View File

@@ -0,0 +1,267 @@
<?php
namespace App\Http\Controllers;
use App\Models\Video;
use Illuminate\Http\Request;
use App\Http\Requests\CreateVideoRequest;
use App\Http\Requests\UpdateVideoRequest;
use Illuminate\Support\Facades\Storage;
class VideosController extends Controller
{
public function __construct()
{
// Aumentar limites temporariamente para uploads grandes
// Nota: Estas configurações devem ser feitas antes do PHP processar o POST
// Por isso também estão no public/index.php
@ini_set('upload_max_filesize', '200M');
@ini_set('post_max_size', '200M');
@ini_set('max_execution_time', '300'); // 5 minutos
@ini_set('max_input_time', '300');
@ini_set('memory_limit', '512M');
}
public function index(Request $request)
{
$user = auth()->user();
if (!$user) {
return response()->json([
'message' => 'Utilizador não autenticado',
'data' => null,
'errors' => null,
], 404);
}
$search = trim((string) $request->query('search', ''));
$videosQuery = Video::with('categories');
if ($search !== '') {
$videosQuery->where(function ($query) use ($search) {
$query->where('title', 'like', "%{$search}%")
->orWhere('tags', 'like', "%{$search}%");
});
}
if ($user->role_id !== 1) {
$videosQuery->where('is_active', true);
}
$videos = $videosQuery->get();
if ($videos->isEmpty()) {
return response()->json([
'message' => $search !== '' ? 'Sem resultados para a pesquisa' : 'Não foram encontrados vídeos',
'data' => [],
'errors' => null,
], $search !== '' ? 200 : 404); // 200 se for pesquisa, 404 se for listagem normal
}
return response()->json([
'message' => 'Vídeos obtidos com sucesso',
'data' => $videos,
'errors' => null,
], 200);
}
public function getVideo($id)
{
$user = auth()->user();
if (!$user) {
return response()->json([
'message' => 'Utilizador não autenticado',
'data' => null,
'errors' => null,
], 404);
}
if ($user->role_id !== 1) {
$video = Video::with('categories')->where('is_active', true)->find($id);
/* Para não mostrar vídeos inactivos para utilizadores não administradores */
if (!$video || $video->is_active === false) {
return response()->json([
'message' => 'Acesso negado',
'data' => null,
'errors' => null,
], 404);
}
}
$video = Video::with('categories')->find($id);
if ($video) {
$video->url = Storage::url($video->url);
$video->thumbnail = Storage::url($video->thumbnail);
return response()->json([
'message' => 'Vídeo obtido com sucesso',
'data' => [
'id' => $video->id,
'title' => $video->title,
'description' => $video->description,
'url' => $video->url,
'thumbnail' => $video->thumbnail,
'duration' => $video->duration,
'tags' => $video->tags,
'categories' => $video->categories->map(function ($category) {
return [
'id' => $category->id,
'name' => $category->name,
];
})->values(),
'is_active' => $video->is_active,
],
'errors' => null,
], 200);
} else {
return response()->json([
'message' => 'Vídeo não encontrado',
'data' => null,
'errors' => null,
], 404);
}
}
public function create(CreateVideoRequest $request)
{
$user = auth()->user();
if (!$user) {
return response()->json([
'message' => 'Utilizador não autenticado',
'data' => null,
'errors' => null,
], 404);
}
$validated = $request->validated();
$videoPath = $request->file('url')->store('videos', 'public');
$thumbnailPath = $request->file('thumbnail')->store('thumbnails', 'public');
$video = Video::create([
'title' => $validated['title'],
'description' => $validated['description'],
'url' => $videoPath,
'thumbnail' => $thumbnailPath,
'duration' => $validated['duration'] ?? '00:00',
'tags' => $validated['tags'],
]);
if ($request->filled('category_ids')) {
$video->categories()->sync($request->input('category_ids'));
}
$baseUrl = $request->getSchemeAndHttpHost();
return response()->json([
'message' => 'Vídeo criado com sucesso',
'data' => [
'id' => $video->id,
'title' => $video->title,
'description' => $video->description,
'url' => $baseUrl . Storage::url($video->url),
'thumbnail' => $baseUrl . Storage::url($video->thumbnail),
'duration' => $video->duration,
'tags' => $video->tags,
'categories' => $video->categories->pluck('name'),
'is_active' => $video->is_active,
],
'errors' => null,
], 201);
}
public function update(UpdateVideoRequest $request, $id)
{
$user = auth()->user();
if (!$user) {
return response()->json([
'message' => 'Utilizador não autenticado',
'data' => null,
'errors' => null,
], 404);
}
$videoToUpdate = Video::find($id);
if (!$videoToUpdate) {
return response()->json([
'message' => 'Vídeo não encontrado',
'data' => null,
'errors' => null,
], 404);
}
$validated = $request->validated();
if ($request->hasFile('thumbnail')) {
// Apagar thumbnail antiga
if ($videoToUpdate->thumbnail && Storage::disk('public')->exists($videoToUpdate->thumbnail)) {
Storage::disk('public')->delete($videoToUpdate->thumbnail);
}
$validated['thumbnail'] = $request->file('thumbnail')->store('thumbnails', 'public');
}
try {
$videoToUpdate->update([
'title' => $validated['title'] ?? $videoToUpdate->title,
'description' => $validated['description'] ?? $videoToUpdate->description,
'tags' => $validated['tags'] ?? $videoToUpdate->tags,
'thumbnail' => $validated['thumbnail'] ?? $videoToUpdate->thumbnail,
'is_active' => array_key_exists('is_active', $validated) ? $validated['is_active'] : $videoToUpdate->is_active,
]);
if ($request->has('category_ids')) {
$videoToUpdate->categories()->sync($request->input('category_ids'));
}
return response()->json([
'message' => 'Dados do vídeo atualizados com sucesso',
'data' => $videoToUpdate->load('categories'),
'errors' => null,
], 200);
} catch (\Throwable $th) {
return response()->json([
'message' => 'Não foi possível atualizar o vídeo',
'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);
}
$video = Video::find($id);
if (!$video) {
return response()->json([
'message' => 'Vídeo não encontrado',
'data' => null,
'errors' => null,
], 404);
}
$video->delete();
return response()->json([
'message' => 'Vídeo apagado com sucesso',
'data' => null,
'errors' => null,
], 200);
}
}

343
plataforma-tutorias/app/Http/Controllers/WorkshopsController.php Normal file
View File

@@ -0,0 +1,343 @@
<?php
namespace App\Http\Controllers;
use App\Http\Requests\CreateWorkshopRequest;
use App\Http\Requests\UpdateWorkshopRequest;
use App\Models\Workshop;
use Illuminate\Support\Facades\Storage;
use Illuminate\Http\Request;
class WorkshopsController 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);
}
$search = trim((string) $request->query('search', ''));
$status = trim((string) $request->query('status', ''));
$workshopsQuery = Workshop::with('users');
if ($search !== '') {
$workshopsQuery->where('title', 'like', "%{$search}%")->where('status', 'pending');
}
if ($user->role_id !== 1) {
$workshopsQuery->where(function ($query) use ($user) {
$query->where('status', 'pending')
->orWhere(function ($q) use ($user) {
$q->whereIn('status', ['pending'])
->whereHas('users', function ($q2) use ($user) {
$q2->where('users.id', $user->id);
});
})
->orWhere(function ($q) use ($user) {
$q->whereIn('status', ['realized', 'canceled'])
->whereHas('users', function ($q2) use ($user) {
$q2->where('users.id', $user->id);
});
});
});
}
$workshops = $workshopsQuery->orderBy('date', 'asc')->orderBy('time_start', 'asc')->get();
/* Os workshops são atualizados automaticamente pelo command (app->Console->Commands->UpdateWorkshopStatus.php) 'workshops:update-status' de pending para realized se for uma data passada */
if($workshops->isEmpty()) {
return response()->json([
'message' => $search !== '' ? 'Sem resultados para a pesquisa' : 'Não foram encontrados vídeos',
'data' => [],
'errors' => null,
], $search !== '' ? 200 : 404); // 200 se for pesquisa, 404 se for listagem normal
}
return response()->json([
'message' => 'Workshops obtidos com sucesso',
'data' => $workshops,
'errors' => null,
], 200);
}
public function getWorkshop($id)
{
$workshop = Workshop::with('users')->find($id);
if (!$workshop) {
return response()->json([
'message' => 'Workshop não encontrado',
'data' => null,
'errors' => null,
], 404);
}
return response()->json([
'message' => 'Workshop obtido com sucesso',
'data' => $workshop,
'errors' => null,
], 200);
}
public function create(CreateWorkshopRequest $request)
{
$user = auth()->user();
if (!$user) {
return response()->json([
'message' => 'Utilizador não autenticado',
'data' => null,
'errors' => null,
], 404);
}
$validated = $request->validated();
$imagePath = $request->file('image')->store('imageWorkshops', 'public');
try {
$workshop = Workshop::create([
'title' => $validated['title'],
'description' => $validated['description'],
'status' => 'pending',
'image' => $imagePath,
'date' => $validated['date'],
'time_start' => $validated['time_start'],
'time_end' => $validated['time_end'],
]);
$baseUrl = $request->getSchemeAndHttpHost();
return response()->json([
'message' => 'Workshop criado com sucesso',
'data' => [
'id' => $workshop->id,
'title' => $workshop->title,
'description' => $workshop->description,
'image' => $baseUrl . Storage::url($workshop->image),
'date' => $workshop->date,
'time_start' => $workshop->time_start,
'time_end' => $workshop->time_end,
'status' => $workshop->status,
],
'errors' => null,
], 201);
} catch (\Illuminate\Validation\ValidationException $e) {
return response()->json([
'message' => 'Erro ao criar o workshop',
'data' => null,
'errors' => $e->errors(),
], 422);
} catch (\Throwable $th) {
return response()->json([
'message' => 'Não foi possível criar o workshop',
'data' => null,
'errors' => $th->getMessage(),
], 500);
}
}
public function update(UpdateWorkshopRequest $request, $id)
{
$user = auth()->user();
if (!$user) {
return response()->json([
'message' => 'Utilizador não autenticado',
'data' => null,
'errors' => null,
], 404);
}
$validated = $request->validated();
if ($request->hasFile('image')) {
$imagePath = $request->file('image')->store('imageWorkshops', 'public');
$validated['image'] = $imagePath;
}
$workshop = Workshop::find($id);
if (!$workshop) {
return response()->json([
'message' => 'Workshop não encontrado',
'data' => null,
'errors' => null,
], 404);
}
try {
$workshop->update($validated);
return response()->json([
'message' => 'Workshop atualizado com sucesso',
'data' => $workshop,
'errors' => null,
], 200);
} catch (\Illuminate\Validation\ValidationException $e) {
return response()->json([
'message' => 'Erro ao atualizar o workshop',
'data' => null,
'errors' => [
'message' => 'Erro ao atualizar o workshop',
'errors' => $e->errors(),
],
], 422);
} catch (\Throwable $th) {
return response()->json([
'message' => 'Não foi possível atualizar o workshop',
'data' => null,
'errors' => [
'message' => 'Não foi possível atualizar o workshop',
'errors' => $th->getMessage(),
],
], 500);
}
}
public function destroy($id)
{
$user = auth()->user();
if (!$user) {
return response()->json([
'message' => 'Utilizador não autenticado',
'data' => null,
'errors' => null,
], 404);
}
$workshop = Workshop::find($id);
if (!$workshop) {
return response()->json([
'message' => 'Workshop não encontrado',
'data' => null,
'errors' => null,
], 404);
}
try {
$workshop->delete();
return response()->json([
'message' => 'Workshop apagado com sucesso',
'data' => null,
'errors' => null,
], 200);
} catch (\Throwable $th) {
return response()->json([
'message' => 'Não foi possível apagar o workshop',
'data' => null,
'errors' => $th->getMessage(),
], 500);
}
}
/*
Workshop inexistente - 404
Workshop canceled ou realized - 422 - não aceitar novas inscrições
Utilizador já inscrito - 409 ou 200 com mensagem “já inscrito” (escolher um e mantém em todo o projeto)
Cancelar inscrição sem estar inscrito - 404 ou 422
Admin - Pode inscrever-se como qualquer utilizador autenticado, salvo regra explícita em contrário
is_active === false - Bloquear inscrição se usares este campo na listagem
*/
public function inscrever($id)
{
$user = auth()->user();
if (!$user) {
return response()->json([
'message' => 'Utilizador não autenticado',
'data' => null,
'errors' => null,
], 404);
}
$workshop = Workshop::find($id);
if (!$workshop) {
return response()->json([
'message' => 'Workshop não encontrado',
'data' => null,
'errors' => null,
], 404);
}
if ($workshop->status !== 'pending') {
return response()->json([
'message' => 'Já não é possível inscrever-se neste Workshop',
'data' => null,
'errors' => null,
], 422);
}
if ($workshop->users()->where('user_id', $user->id)->exists()) {
return response()->json([
'message' => 'Já está inscrito neste Workshop',
'data' => null,
'errors' => null,
], 409);
}
$workshop->users()->attach($user->id);
return response()->json([
'message' => 'Inscrição realizada',
'data' => null,
'errors' => null,
], 200);
}
public function cancelarInscricao($id)
{
$user = auth()->user();
if (!$user) {
return response()->json([
'message' => 'Utilizador não autenticado',
'data' => null,
'errors' => null,
], 404);
}
$workshop = Workshop::find($id);
if (!$workshop) {
return response()->json([
'message' => 'Workshop não encontrado',
'data' => null,
'errors' => null,
], 404);
}
if (!$workshop->users()->where('user_id', $user->id)->exists()) {
return response()->json([
'message' => 'Não está inscrito neste Workshop',
'data' => null,
'errors' => null,
], 404);
}
$workshop->users()->detach($user->id);
return response()->json([
'message' => 'Inscrição anulada',
'data' => null,
'errors' => null,
], 200);
}
}

71
plataforma-tutorias/app/Http/Kernel.php Normal file
View File

@@ -0,0 +1,71 @@
<?php
namespace App\Http;
use Illuminate\Foundation\Http\Kernel as HttpKernel;
class Kernel extends HttpKernel
{
/**
* The application's global HTTP middleware stack.
*
* These middleware are run during every request to your application.
*
* @var array<int, class-string|string>
*/
protected $middleware = [
// \App\Http\Middleware\TrustHosts::class,
\App\Http\Middleware\TrustProxies::class,
\Illuminate\Http\Middleware\HandleCors::class,
\App\Http\Middleware\PreventRequestsDuringMaintenance::class,
\Illuminate\Foundation\Http\Middleware\ValidatePostSize::class,
\App\Http\Middleware\TrimStrings::class,
\Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class,
];
/**
* The application's route middleware groups.
*
* @var array<string, array<int, class-string|string>>
*/
protected $middlewareGroups = [
'web' => [
\App\Http\Middleware\EncryptCookies::class,
\Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
\Illuminate\Session\Middleware\StartSession::class,
\Illuminate\View\Middleware\ShareErrorsFromSession::class,
\App\Http\Middleware\VerifyCsrfToken::class,
\Illuminate\Routing\Middleware\SubstituteBindings::class,
],
'api' => [
// \Laravel\Sanctum\Http\Middleware\EnsureFrontendRequestsAreStateful::class,
\Illuminate\Routing\Middleware\ThrottleRequests::class.':api',
\Illuminate\Routing\Middleware\SubstituteBindings::class,
],
];
/**
* The application's middleware aliases.
*
* Aliases may be used instead of class names to conveniently assign middleware to routes and groups.
*
* @var array<string, class-string|string>
*/
protected $middlewareAliases = [
'auth' => \App\Http\Middleware\Authenticate::class,
'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
'auth.session' => \Illuminate\Session\Middleware\AuthenticateSession::class,
'cache.headers' => \Illuminate\Http\Middleware\SetCacheHeaders::class,
'can' => \Illuminate\Auth\Middleware\Authorize::class,
'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
'password.confirm' => \Illuminate\Auth\Middleware\RequirePassword::class,
'precognitive' => \Illuminate\Foundation\Http\Middleware\HandlePrecognitiveRequests::class,
'signed' => \App\Http\Middleware\ValidateSignature::class,
'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
'verified' => \Illuminate\Auth\Middleware\EnsureEmailIsVerified::class,
/* Adicionamos o alias do middleware AdminMiddleware */
'admin' => \App\Http\Middleware\AdminMiddleware::class,
/* Próximo passo é adicionar o middleware ao routes/api.php */
];
}

32
plataforma-tutorias/app/Http/Middleware/AdminMiddleware.php Normal file
View File

@@ -0,0 +1,32 @@
<?php
namespace App\Http\Middleware;
use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;
class AdminMiddleware
{
/**
* Handle an incoming request.
*
* @param \Closure(\Illuminate\Http\Request): (\Symfony\Component\HttpFoundation\Response) $next
*/
public function handle(Request $request, Closure $next): Response
{
/* Funciona porque o JWT Middleware já foi executado e o user está autenticado */
$user = auth()->user();
if($user->role_id !== 1){
return response()->json([
'message' => 'Acesso negado. Apenas administradores podem aceder a esta página',
'data' => null,
'errors' => null,
], 403);
}
return $next($request);
/* Em cima o middleware já foi criado e agora temos que registar o alias no kernel.php */
}
}

17
plataforma-tutorias/app/Http/Middleware/Authenticate.php Normal file
View File

@@ -0,0 +1,17 @@
<?php
namespace App\Http\Middleware;
use Illuminate\Auth\Middleware\Authenticate as Middleware;
use Illuminate\Http\Request;
class Authenticate extends Middleware
{
/**
* Get the path the user should be redirected to when they are not authenticated.
*/
protected function redirectTo(Request $request): ?string
{
return $request->expectsJson() ? null : route('login');
}
}

17
plataforma-tutorias/app/Http/Middleware/EncryptCookies.php Normal file
View File

@@ -0,0 +1,17 @@
<?php
namespace App\Http\Middleware;
use Illuminate\Cookie\Middleware\EncryptCookies as Middleware;
class EncryptCookies extends Middleware
{
/**
* The names of the cookies that should not be encrypted.
*
* @var array<int, string>
*/
protected $except = [
//
];
}

22
plataforma-tutorias/app/Http/Middleware/JwtMiddleware.php Normal file
View File

@@ -0,0 +1,22 @@
<?php
namespace App\Http\Middleware;
use Closure;
use Tymon\JWTAuth\Facades\JWTAuth;
use Exception;
use Illuminate\Http\Request;
class JwtMiddleware
{
public function handle(Request $request, Closure $next)
{
try {
JWTAuth::parseToken()->authenticate();
} catch (Exception $e) {
return redirect()->route('login');
}
return $next($request);
}
}

17
plataforma-tutorias/app/Http/Middleware/PreventRequestsDuringMaintenance.php Normal file
View File

@@ -0,0 +1,17 @@
<?php
namespace App\Http\Middleware;
use Illuminate\Foundation\Http\Middleware\PreventRequestsDuringMaintenance as Middleware;
class PreventRequestsDuringMaintenance extends Middleware
{
/**
* The URIs that should be reachable while maintenance mode is enabled.
*
* @var array<int, string>
*/
protected $except = [
//
];
}

30
plataforma-tutorias/app/Http/Middleware/RedirectIfAuthenticated.php Normal file
View File

@@ -0,0 +1,30 @@
<?php
namespace App\Http\Middleware;
use App\Providers\RouteServiceProvider;
use Closure;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Symfony\Component\HttpFoundation\Response;
class RedirectIfAuthenticated
{
/**
* Handle an incoming request.
*
* @param \Closure(\Illuminate\Http\Request): (\Symfony\Component\HttpFoundation\Response) $next
*/
public function handle(Request $request, Closure $next, string ...$guards): Response
{
$guards = empty($guards) ? [null] : $guards;
foreach ($guards as $guard) {
if (Auth::guard($guard)->check()) {
return redirect(RouteServiceProvider::HOME);
}
}
return $next($request);
}
}

19
plataforma-tutorias/app/Http/Middleware/TrimStrings.php Normal file
View File

@@ -0,0 +1,19 @@
<?php
namespace App\Http\Middleware;
use Illuminate\Foundation\Http\Middleware\TrimStrings as Middleware;
class TrimStrings extends Middleware
{
/**
* The names of the attributes that should not be trimmed.
*
* @var array<int, string>
*/
protected $except = [
'current_password',
'password',
'password_confirmation',
];
}

20
plataforma-tutorias/app/Http/Middleware/TrustHosts.php Normal file
View File

@@ -0,0 +1,20 @@
<?php
namespace App\Http\Middleware;
use Illuminate\Http\Middleware\TrustHosts as Middleware;
class TrustHosts extends Middleware
{
/**
* Get the host patterns that should be trusted.
*
* @return array<int, string|null>
*/
public function hosts(): array
{
return [
$this->allSubdomainsOfApplicationUrl(),
];
}
}

28
plataforma-tutorias/app/Http/Middleware/TrustProxies.php Normal file
View File

@@ -0,0 +1,28 @@
<?php
namespace App\Http\Middleware;
use Illuminate\Http\Middleware\TrustProxies as Middleware;
use Illuminate\Http\Request;
class TrustProxies extends Middleware
{
/**
* The trusted proxies for this application.
*
* @var array<int, string>|string|null
*/
protected $proxies;
/**
* The headers that should be used to detect proxies.
*
* @var int
*/
protected $headers =
Request::HEADER_X_FORWARDED_FOR |
Request::HEADER_X_FORWARDED_HOST |
Request::HEADER_X_FORWARDED_PORT |
Request::HEADER_X_FORWARDED_PROTO |
Request::HEADER_X_FORWARDED_AWS_ELB;
}

22
plataforma-tutorias/app/Http/Middleware/ValidateSignature.php Normal file
View File

@@ -0,0 +1,22 @@
<?php
namespace App\Http\Middleware;
use Illuminate\Routing\Middleware\ValidateSignature as Middleware;
class ValidateSignature extends Middleware
{
/**
* The names of the query string parameters that should be ignored.
*
* @var array<int, string>
*/
protected $except = [
// 'fbclid',
// 'utm_campaign',
// 'utm_content',
// 'utm_medium',
// 'utm_source',
// 'utm_term',
];
}

17
plataforma-tutorias/app/Http/Middleware/VerifyCsrfToken.php Normal file
View File

@@ -0,0 +1,17 @@
<?php
namespace App\Http\Middleware;
use Illuminate\Foundation\Http\Middleware\VerifyCsrfToken as Middleware;
class VerifyCsrfToken extends Middleware
{
/**
* The URIs that should be excluded from CSRF verification.
*
* @var array<int, string>
*/
protected $except = [
//
];
}

37
plataforma-tutorias/app/Http/Requests/CreateCategoryRequest.php Normal file
View File

@@ -0,0 +1,37 @@
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class CreateCategoryRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*/
public function authorize(): bool
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
*/
public function rules(): array
{
return [
'name' => 'required|string|max:50|unique:categories,name',
];
}
public function messages(): array
{
return [
'name.required' => 'O nome é obrigatório',
'name.max' => 'O nome deve ter no máximo 50 caracteres',
'name.unique' => 'A categoria já existe',
];
}
}

49
plataforma-tutorias/app/Http/Requests/CreateUserRequest.php Normal file
View File

@@ -0,0 +1,49 @@
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class CreateUserRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*/
public function authorize(): bool
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
*/
public function rules(): array
{
return [
'name' => 'required|string|max:50|min:3',
'email' => 'required|email|unique:users,email',
'password' => 'required|string|min:6|confirmed',
'role_id' => 'required|exists:roles,id',
];
}
public function messages(): array
{
return [
'name.required' => 'O nome é obrigatório',
'name.max' => 'O nome deve ter no máximo 50 caracteres',
'name.min' => 'O nome deve ter pelo menos 3 caracteres',
'email.required' => 'O email é obrigatório',
'email.email' => 'O email deve ser um email válido',
'email.unique' => 'O email já está em uso',
'role_id.required' => 'Obrigatório selecionar um cargo',
'role_id.exists' => 'Cargo não encontrado',
'password.required' => 'A password é obrigatória',
'password.min' => 'A password deve ter pelo menos 6 caracteres',
'password.confirmed' => 'As passwords não coincidem',
];
}
}

52
plataforma-tutorias/app/Http/Requests/CreateVideoRequest.php Normal file
View File

@@ -0,0 +1,52 @@
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class CreateVideoRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*/
public function authorize(): bool
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
*/
public function rules(): array
{
return [
'title' => 'required|string|max:255',
'description' => 'required|string|max:3000',
'url' => 'required|file|mimes:mp4,mov,avi,wmv,flv,mpeg,mpg,m4v,3gp,3g2,mj2|max:512000', // 500MB
'thumbnail' => 'required|image|mimes:jpg,jpeg,png,webp|max:4000',
'duration' => 'nullable|string|max:10',
'tags' => 'nullable|string|max:255', // nullable para não ser obrigatório
'category_ids' => 'nullable|array|exists:categories,id', // nullable caso não selecione
];
}
public function messages(): array
{
return [
'title.required' => 'O título é obrigatório',
'title.max' => 'O título deve ter no máximo 255 caracteres',
'description.required' => 'A descrição é obrigatória',
'description.max' => 'A descrição deve ter no máximo 3000 caracteres',
'url.required' => 'A URL é obrigatória',
'url.mimes' => 'A URL deve ser um arquivo de vídeo',
'url.max' => 'A URL deve ter no máximo 500 caracteres',
'thumbnail.required' => 'A thumbnail é obrigatória',
'thumbnail.mimes' => 'Ficheiro de imagem inválido: deve ser jpg, jpeg, png ou webp',
'thumbnail.max' => 'A thumbnail deve ter no máximo 4MB',
'tags.max' => 'As tags devem ter no máximo 50 caracteres',
'category_id.exists' => 'A categoria não existe',
];
}
}

50
plataforma-tutorias/app/Http/Requests/CreateWorkshopRequest.php Normal file
View File

@@ -0,0 +1,50 @@
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class CreateWorkshopRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*/
public function authorize(): bool
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
*/
public function rules(): array
{
return [
'title' => 'required|string|max:255',
'description' => 'required|string|max:3000',
'image' => 'required|image|mimes:jpg,jpeg,png,webp|max:2048',
'date' => 'required|date',
'time_start' => 'required|date_format:H:i',
'time_end' => 'required|date_format:H:i',
];
}
public function messages(): array
{
return [
'title.required' => 'O título é obrigatório',
'title.max' => 'O título deve ter no máximo 255 caracteres',
'description.max' => 'A descrição deve ter no máximo 3000 caracteres',
'image.mimes' => 'O ficheiro deve ser do formato jpg, jpeg, png ou webp',
'image.max' => 'A imagem deve ter no máximo 2MB',
'date.required' => 'A data é obrigatória',
'date.date' => 'A data deve ser uma data válida',
'time_start.required' => 'A hora de início é obrigatória',
'time_start.time' => 'A hora de início deve ser uma hora válida',
'time_end.required' => 'A hora de término é obrigatória',
'time_end.time' => 'A hora de término deve ser uma hora válida',
];
}
}

39
plataforma-tutorias/app/Http/Requests/LoginRequest.php Normal file
View File

@@ -0,0 +1,39 @@
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class LoginRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*/
public function authorize(): bool
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
*/
public function rules(): array
{
return [
'email' => 'required|email',
'password' => 'required|min:6',
];
}
public function messages(): array
{
return [
'email.required' => 'O email é obrigatório',
'email.email' => 'O email deve ser um email válido',
'password.required' => 'A password é obrigatória',
'password.min' => 'A password deve ter pelo menos 6 caracteres',
];
}
}

36
plataforma-tutorias/app/Http/Requests/UpdateCategoryRequest.php Normal file
View File

@@ -0,0 +1,36 @@
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class UpdateCategoryRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*/
public function authorize(): bool
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
*/
public function rules(): array
{
return [
'name' => 'sometimes|string|max:50|unique:categories,name',
];
}
public function messages(): array
{
return [
'name.max' => 'O nome deve ter no máximo 50 caracteres',
'name.unique' => 'A categoria já existe',
];
}
}

48
plataforma-tutorias/app/Http/Requests/UpdateUserRequest.php Normal file
View File

@@ -0,0 +1,48 @@
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Validation\Rule;
class UpdateUserRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*/
public function authorize(): bool
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
*/
public function rules(): array
{
$userId = $this->route('id');
return [
'name' => 'sometimes|string|max:50|min:3',
'email' => [
'sometimes',
'email',
Rule::unique('users', 'email')->ignore($userId),
],
'role_id' => 'sometimes|exists:roles,id',
];
}
public function messages(): array
{
return [
'name.max' => 'O nome deve ter no máximo 50 caracteres',
'name.min' => 'O nome deve ter pelo menos 3 caracteres',
'email.email' => 'O email deve ser um email válido',
'email.unique' => 'O email já está em uso',
'role_id.exists' => 'Cargo não encontrado',
];
}
}

47
plataforma-tutorias/app/Http/Requests/UpdateVideoRequest.php Normal file
View File

@@ -0,0 +1,47 @@
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class UpdateVideoRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*/
public function authorize(): bool
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
*/
public function rules(): array
{
return [
'title' => 'sometimes|string|max:255',
'description' => 'sometimes|string|max:3000',
'url' => 'sometimes|string|max:500',
'thumbnail' => 'sometimes|file|mimes:jpg,jpeg,png,webp|max:4000',
'tags' => 'sometimes|string|max:100',
'category_ids' => 'sometimes|array',
'category_ids.*' => 'exists:categories,id',
'is_active' => 'sometimes|boolean',
];
}
public function messages(): array
{
return [
'title.max' => 'O título deve ter no máximo 255 caracteres',
'description.max' => 'A descrição deve ter no máximo 3000 caracteres',
'url.max' => 'A URL deve ter no máximo 500 caracteres',
'thumbnail.mimes' => 'O ficheiro deve ser do formato jpg, jpeg, png ou webp',
'thumbnail.max' => 'A thumbnail deve ter no máximo 4MB',
'category_id.exists' => 'A categoria não existe',
];
}
}

48
plataforma-tutorias/app/Http/Requests/UpdateWorkshopRequest.php Normal file
View File

@@ -0,0 +1,48 @@
<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class UpdateWorkshopRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*/
public function authorize(): bool
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
*/
public function rules(): array
{
return [
'title' => 'sometimes|string|max:255',
'description' => 'sometimes|string|max:3000',
'image' => 'sometimes|image|mimes:jpg,jpeg,png,webp|max:2048',
'date' => 'sometimes|date',
'time_start' => 'sometimes|date_format:H:i',
'time_end' => 'sometimes|date_format:H:i',
'is_active' => 'sometimes|boolean',
'status' => 'sometimes|string|in:pending,realized,canceled',
];
}
public function messages(): array
{
return [
'title.max' => 'O título deve ter no máximo 255 caracteres',
'description.max' => 'A descrição deve ter no máximo 3000 caracteres',
'image.mimes' => 'O ficheiro deve ser do formato jpg, jpeg, png ou webp',
'image.max' => 'A imagem deve ter no máximo 2MB',
'date.date' => 'A data deve ser uma data válida',
'time_start.date_format' => 'A hora de início deve ser uma hora válida',
'time_end.date_format' => 'A hora de término deve ser uma hora válida',
];
}
}