2-Llamar Controladores y sus Métodos

 

1. Controladores - PascalCase

php

// ✅ CORRECTO
class UserController extends Controller
class ProductCategoryController extends Controller
class AdminDashboardController extends Controller

// ❌ INCORRECTO
class userController extends Controller
class product_category_controller extends Controller

Reglas:

• Primera letra en mayúscula

• Cada palabra comienza con mayúscula

• Sufijo Controller

• Extienden de Controller

2. Métodos de Controladores - camelCase

php

class UserController extends Controller
{
    // ✅ CORRECTO
    public function getUserProfile() {}
    public function updateUserSettings() {}
    public function deleteOldRecords() {}
    
    // ❌ INCORRECTO
    public function GetUserProfile() {}
    public function update_user_settings() {}
    public function DeleteOldRecords() {}
}

3. Modelos - PascalCase (Singular)

php

// ✅ CORRECTO
class User extends Model
class ProductCategory extends Model
class PostComment extends Model

// ❌ INCORRECTO
class users extends Model
class product_categories extends Model
class PostComments extends Model

Reglas:

• Primera letra en mayúscula

• Nombre en singular

• Extienden de Model

4. Tablas de Base de Datos - snake_case (Plural)

php

class User extends Model
{
    protected $table = 'users'; // ✅ snake_case plural
}

class ProductCategory extends Model
{
    protected $table = 'product_categories'; // ✅ snake_case plural
}

// ❌ INCORRECTOS
protected $table = 'Users';
protected $table = 'productCategories';
protected $table = 'user';

5. Columnas de Base de Datos - snake_case

php

// ✅ CORRECTO
$table->string('first_name');
$table->integer('product_category_id');
$table->timestamp('created_at');

// ❌ INCORRECTO
$table->string('firstName');
$table->integer('ProductCategoryId');

6. Relaciones en Modelos - camelCase

php

class User extends Model
{
    // ✅ CORRECTO
    public function postComments() {}
    public function productCategories() {}
    public function userProfile() {}
    
    // ❌ INCORRECTO
    public function PostComments() {}
    public function product_categories() {}
    public function UserProfile() {}
}

7. Variables y Parámetros - camelCase

php

// ✅ CORRECTO
$userName = 'John';
$productCategoryId = 1;
$isActive = true;

// ❌ INCORRECTO
$user_name = 'John';
$ProductCategoryId = 1;
$is_active = true;

8. Funciones y Métodos - camelCase

php

// ✅ CORRECTO
public function calculateTotalPrice() {}
private function getUserData() {}
protected function validateInput() {}

// ❌ INCORRECTO
public function Calculate_Total_Price() {}
private function get_user_data() {}

9. Clases y Traits - PascalCase

php

// ✅ CORRECTO
class UserService {}
trait Loggable {}
interface NotificationInterface {}

// ❌ INCORRECTO
class user_service {}
trait loggable {}

10. Constantes - UPPER_SNAKE_CASE

php

// ✅ CORRECTO
const MAX_LOGIN_ATTEMPTS = 5;
const DEFAULT_USER_ROLE = 'member';

// ❌ INCORRECTO
const maxLoginAttempts = 5;
const default_user_role = 'member';

11. Archivos de Clases - Mismo nombre que la clase

text

// ✅ CORRECTO
app/
  ├── Models/User.php
  ├── Controllers/UserController.php
  ├── Services/UserService.php

// ❌ INCORRECTO
app/
  ├── Models/user.php
  ├── Controllers/user_controller.php

12. Vistas (Blade) - snake_case

text

// ✅ CORRECTO
resources/views/
  ├── user_profile.blade.php
  ├── product_categories/
  │   └── index.blade.php

// ❌ INCORRECTO
resources/views/
  ├── userProfile.blade.php
  ├── ProductCategories/
  │   └── Index.blade.php

Resumen de Reglas:

Elemento	Convención	Ejemplo
Clases	PascalCase	UserController
Métodos	camelCase	getUserProfile
Modelos	PascalCase (Singular)	User
Tablas	snake_case (Plural)	users
Columnas	snake_case	first_name
Relaciones	camelCase	postComments
Variables	camelCase	$userName
Constantes	UPPER_SNAKE_CASE	MAX_ATTEMPTS
Archivos	Mismo nombre clase	UserController.php
Vistas	snake_case	user_profile.blade.php

Estas convenciones son importantes para mantener la consistencia en el código y seguir los estándares de la comunidad Laravel

En Rutas (web.php o api.php)

php

// Llamar método específico de un controlador
Route::get('/users', [UserController::class, 'index']);
Route::post('/users', [UserController::class, 'store']);
Route::get('/users/{id}', [UserController::class, 'show']);
Route::put('/users/{id}', [UserController::class, 'update']);
Route::delete('/users/{id}', [UserController::class, 'destroy']);

// Resource route (automáticamente mapea todos los métodos)
Route::resource('users', UserController::class);

// Llamar método invokable (controlador con un solo método)
Route::get('/profile', ProfileController::class);

Desde Otro Controlador

php

public function someMethod()
{
    // Llamar método de otro controlador
    $userController = new UserController();
    $result = $userController->index();
    
    // O usando app()
    $result = app(UserController::class)->index();
    
    return $result;
}

2. Trabajar con Modelos

Definición del Modelo

php

// app/Models/User.php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    protected $table = 'users';
    protected $fillable = ['name', 'email', 'password'];
    protected $hidden = ['password'];
    
    // Relaciones
    public function posts()
    {
        return $this->hasMany(Post::class);
    }
    
    // Métodos personalizados
    public function getFullNameAttribute()
    {
        return $this->first_name . ' ' . $this->last_name;
    }
}

Usar Modelos en Controladores

php

use App\Models\User;
use App\Models\Post;

class UserController extends Controller
{
    // Obtener todos los registros
    public function index()
    {
        $users = User::all();
        return view('users.index', compact('users'));
    }
    
    // Obtener un registro específico
    public function show($id)
    {
        $user = User::find($id);
        // o con fail que lanza 404 si no existe
        $user = User::findOrFail($id);
        
        return view('users.show', compact('user'));
    }
    
    // Crear nuevo registro
    public function store(Request $request)
    {
        $user = User::create([
            'name' => $request->name,
            'email' => $request->email,
            'password' => bcrypt($request->password)
        ]);
        
        return redirect()->route('users.show', $user->id);
    }
    
    // Actualizar registro
    public function update(Request $request, $id)
    {
        $user = User::findOrFail($id);
        $user->update([
            'name' => $request->name,
            'email' => $request->email
        ]);
        
        return redirect()->route('users.show', $user->id);
    }
    
    // Eliminar registro
    public function destroy($id)
    {
        $user = User::findOrFail($id);
        $user->delete();
        
        return redirect()->route('users.index');
    }
    
    // Consultas con condiciones
    public function activeUsers()
    {
        $users = User::where('active', true)
                    ->orderBy('name')
                    ->get();
        
        return view('users.active', compact('users'));
    }
}

3. Métodos Comunes de Modelos

CRUD Operations

php

// Crear
$user = new User();
$user->name = 'John';
$user->email = 'john@example.com';
$user->save();

// o usando create (necesita fillable)
$user = User::create([
    'name' => 'John',
    'email' => 'john@example.com'
]);

// Actualizar
$user = User::find(1);
$user->name = 'Jane';
$user->save();

// o usando update
$user->update(['name' => 'Jane']);

// Eliminar
$user->delete();

// Eliminar por ID
User::destroy(1);
User::destroy([1, 2, 3]);

Consultas con Eloquent

php

// Obtener todos
$users = User::all();

// Obtener con condiciones
$users = User::where('age', '>', 18)
            ->orderBy('name', 'desc')
            ->get();

// Primer registro que cumpla condición
$user = User::where('email', 'john@example.com')->first();

// Paginación
$users = User::paginate(10);

// Contar registros
$count = User::where('active', true)->count();

// Relaciones eager loading
$users = User::with('posts')->get();

4. Variables y Paso de Datos a Vistas

Desde Controladores

php

public function show($id)
{
    $user = User::findOrFail($id);
    $posts = $user->posts()->latest()->get();
    
    // Pasar variables a la vista
    return view('users.show', [
        'user' => $user,
        'posts' => $posts,
        'title' => 'Perfil de Usuario'
    ]);
    
    // Alternativa con compact()
    return view('users.show', compact('user', 'posts'));
    
    // Con with()
    return view('users.show')
            ->with('user', $user)
            ->with('posts', $posts)
            ->with('title', 'Perfil de Usuario');
}

En Vistas (Blade)

blade

<h1>{{ $title }}</h1>
<p>Usuario: {{ $user->name }}</p>
<p>Email: {{ $user->email }}</p>

@if($user->isAdmin())
    <span class="badge bg-success">Administrador</span>
@endif

@foreach($posts as $post)
    <div class="post">
        <h3>{{ $post->title }}</h3>
        <p>{{ $post->content }}</p>
    </div>
@endforeach

5. Inyección de Dependencias

php

use App\Models\User;
use App\Services\UserService;
use Illuminate\Http\Request;

class UserController extends Controller
{
    protected $userService;
    
    // Inyección en constructor
    public function __construct(UserService $userService)
    {
        $this->userService = $userService;
    }
    
    // Inyección en método
    public function store(Request $request, UserService $userService)
    {
        $user = $userService->createUser($request->all());
        
        return response()->json($user, 201);
    }
}

6. Métodos de Relaciones

php

// Obtener relaciones
$user = User::find(1);
$posts = $user->posts; // Colección de posts

// Filtrar relaciones
$publishedPosts = $user->posts()
                    ->where('published', true)
                    ->get();

// Contar relaciones
$postCount = $user->posts()->count();

// Crear a través de relación
$post = $user->posts()->create([
    'title' => 'Nuevo Post',
    'content' => 'Contenido del post'
]);

Este resumen cubre la sintaxis más común para trabajar con controladores, modelos y sus métodos en Laravel. ¿Te gustaría que profundice en algún aspecto específico?