Skip to main content

​
Overview

The AdminController is the primary administrative controller handling CRUD operations for users, menu items, reservations, tables, chefs, and orders. Location: app/Http/Controllers/AdminController.php Route Prefix: /admin Middleware: auth, role:admin

​
User Management

​
user()

Display all users in the system. Route: GET /admin/users Route Name: admin.users Implementation: 
public function user()
{
    $users = User::all();
    return view("admin.users", compact("users"));
}
​
users
Collection
Collection of all User models

​
createUser()

Create a new user in the system. Route: POST /admin/users Route Name: admin.users.store Implementation: 
public function createUser(Request $request)
{
    User::create([
        'name' => $request->name,
        'email' => $request->email,
        'usertype' => $request->usertype,
        'password' => Hash::make($request->password),
    ]);

    return redirect()->route('admin.user')->with('success', 'Usuario creado exitosamente.');
}
Request Parameters:
​
name
string
required
User’s full name
​
email
string
required
User’s email address
​
usertype
string
required
User type/role (admin, chef, mesero, user)
​
password
string
required
User’s password (will be hashed)

​
updateUser()

Update an existing user’s information. Route: POST /admin/users/{id} Route Name: admin.users.update Implementation: 
public function updateUser(Request $request, $id)
{
    $user = User::findOrFail($id);
    $user->fill($request->only('name', 'email', 'usertype'));

    if ($request->password) {
        $user->password = Hash::make($request->password);
    }

    $user->save();
    return redirect()->route('admin.user')->with('success', 'Usuario actualizado correctamente.');
}
Parameters:
​
id
integer
required
User ID to update
​
name
string
User’s full name
​
email
string
User’s email address
​
usertype
string
User type/role
​
password
string
New password (optional - only updates if provided)

​
deleteuser()

Delete a user from the system. Route: DELETE /admin/users/{id} Route Name: admin.users.delete Implementation: 
public function deleteuser($id)
{
    User::findOrFail($id)->delete();
    return redirect()->back()->with('success', 'Usuario eliminado correctamente.');
}
​
id
integer
required
User ID to delete

​
foodmenu()

Display all food menu items with categories. Route: GET /admin/foodmenu Route Name: admin.foodmenu Implementation: 
public function foodmenu()
{
    $foods = Food::all();
    $categories = Category::all();
    return view("admin.foodmenu", compact('foods', 'categories'));
}
​
foods
Collection
Collection of all Food models
​
categories
Collection
Collection of all Category models

​
uploadfood()

Create a new food menu item. Route: POST /admin/foodmenu Route Name: admin.foodmenu.store Implementation: 
public function uploadfood(Request $request)
{
    $food = $this->saveFoodData(new Food(), $request);
    return redirect()->route('foodmenu')->with('success', 'Menú agregado con éxito.');
}

protected function saveFoodData(Food $food, Request $request)
{
    if ($request->hasFile('image')) {
        $image = $request->file('image');
        $food->image = time() . '.' . $image->getClientOriginalExtension();
        $image->move('foodimage', $food->image);
    }

    $food->fill($request->only([
        'title', 'price', 'description', 'ingredients', 'proteins', 'calories', 'size', 'category_id'
    ]));

    $food->save();
    return $food;
}
Request Parameters:
​
title
string
required
Food item name
​
price
decimal
required
Food price
​
description
text
required
Food description
​
ingredients
string
List of ingredients
​
proteins
string
Protein content information
​
calories
integer
Calorie count
​
size
string
Portion size
​
category_id
integer
Category foreign key
​
image
file
Food image file

​
updateview()

Show the edit form for a food item. Route: GET /admin/foodmenu/{id}/edit Route Name: admin.foodmenu.edit Implementation: 
public function updateview($id)
{
    $food = Food::findOrFail($id);
    $categories = Category::all();
    return view("admin.updateview", compact('food', 'categories'));
}

​
update()

Update an existing food menu item. Route: POST /admin/foodmenu/{id} Route Name: admin.foodmenu.update Implementation: 
public function update(Request $request, $id)
{
    $food = Food::findOrFail($id);
    $this->saveFoodData($food, $request);
    return redirect()->route('foodmenu')->with('success', 'Menú actualizado con éxito.');
}

​
deletemenu()

Delete a food menu item. Route: DELETE /admin/foodmenu/{id} Route Name: admin.foodmenu.delete Implementation: 
public function deletemenu($id)
{
    Food::findOrFail($id)->delete();
    return redirect()->back()->with('success', 'Menú eliminado correctamente.');
}

​
Reservation Management

​
reservation()

Create a new reservation. Implementation: 
public function reservation(Request $request)
{
    Reservation::create($request->only('name', 'email', 'phone', 'guest', 'date', 'time', 'message'));
    return redirect()->back()->with('success', 'Reservación creada correctamente.');
}
Request Parameters:
​
name
string
required
Guest name
​
email
string
required
Guest email
​
phone
string
required
Contact phone
​
guest
integer
required
Number of guests
​
date
date
required
Reservation date
​
time
time
required
Reservation time
​
message
text
Special requests or notes

​
viewreservation()

Display all reservations with available tables. Route: GET /admin/reservations Route Name: admin.reservations Implementation: 
public function viewreservation()
{
    $reservations = Reservation::with('table')->get();
    $tables = Table::where('status', 'disponible')->get();
    return view('admin.adminreservation', compact('reservations', 'tables'));
}

​
assignTable()

Assign a table to a reservation. Validates that guest count matches table seats. Route: POST /admin/reservations/{reservationId}/assign-table Route Name: admin.reservations.assign Implementation: 
public function assignTable(Request $request, $reservationId)
{
    $reservation = Reservation::findOrFail($reservationId);
    $table = Table::findOrFail($request->table_id);

    if ($reservation->guest == $table->seats) {
        $reservation->table_id = $table->id;
        $reservation->save();

        $table->status = 'reservada';
        $table->save();

        return response()->json([
            'success' => true,
            'table_name' => $table->name,
            'user_name' => $reservation->name,
        ]);
    }

    return response()->json([
        'success' => false,
        'message' => 'El número de invitados no coincide con los asientos de la mesa.',
    ]);
}
Request:
​
table_id
integer
required
ID of the table to assign
JSON Response (Success): 
{
  "success": true,
  "table_name": "Mesa 5",
  "user_name": "John Doe"
}
JSON Response (Error): 
{
  "success": false,
  "message": "El número de invitados no coincide con los asientos de la mesa."
}

​
Table Management

​
viewTables()

Display all tables. Route: GET /admin/tables Route Name: admin.tables Implementation: 
public function viewTables()
{
    $tables = Table::all();
    return view('admin.adminmesas', compact('tables'));
}

​
storeTable()

Create a new table. Route: POST /admin/tables Route Name: admin.tables.store Implementation: 
public function storeTable(Request $request)
{
    $request->validate([
        'name' => 'required|string|max:255',
        'number' => 'required|integer|unique:tables,number',
        'type' => 'required|string',
        'seats' => 'required|integer',
        'status' => 'required|string',
    ]);

    Table::create($request->all());
    return redirect()->route('adminmesas')->with('success', 'Mesa agregada correctamente.');
}
Validation Rules:
​
name
string
required
Table name (max 255 characters)
​
number
integer
required
Unique table number
​
type
string
required
Table type (e.g., interior, exterior, VIP)
​
seats
integer
required
Number of seats
​
status
string
required
Table status

​
updateTable()

Update an existing table. Route: PUT /admin/tables/{id} Route Name: admin.tables.update Implementation: 
public function updateTable(Request $request, $id)
{
    $request->validate([
        'name' => 'required|string|max:255',
        'number' => 'required|integer|unique:tables,number,' . $id,
        'type' => 'required|string',
        'seats' => 'required|integer',
        'status' => 'required|string|in:available,occupied,reservada',
    ]);

    $table = Table::findOrFail($id);
    $table->fill($request->only('name', 'number', 'type', 'seats', 'status'));
    $table->save();

    return redirect()->route('adminmesas')->with('success', 'Mesa actualizada correctamente.');
}
Status Values:
  • available - Table is available
  • occupied - Table is currently in use
  • reservada - Table is reserved

​
deleteTable()

Delete a table. Route: DELETE /admin/tables/{id} Route Name: admin.tables.delete Implementation: 
public function deleteTable($id)
{
    Table::findOrFail($id)->delete();
    return redirect()->route('adminmesas')->with('success', 'Mesa eliminada correctamente.');
}

​
Chef Management

​
viewchef()

Display all chefs. Route: GET /admin/chefs Route Name: admin.chefs Implementation: 
public function viewchef()
{
    $foodchefs = Foodchef::all();
    $chefs = Chef::all();
    return view("admin.adminchef", compact('foodchefs','chefs'));
}

​
uploadchef()

Create a new chef profile. Route: POST /admin/chefs Route Name: admin.chefs.store Implementation: 
public function uploadchef(Request $request)
{
    $this->saveChefData(new Foodchef(), $request);
    return redirect()->back()->with('success', 'Chef agregado correctamente.');
}

protected function saveChefData($chef, Request $request)
{
    if ($request->hasFile('image')) {
        $image = $request->file('image');
        $imagename = time() . '.' . $image->getClientOriginalExtension();
        $image->move('chefimage', $imagename);
        $chef->image = $imagename;
    }

    $chef->fill($request->only('name','speciality'));
    $chef->save();
    return $chef;
}

​
updateChef()

Update an existing chef profile. Route: PUT /admin/chefs/{id} Route Name: admin.chefs.update Implementation: 
public function updateChef(Request $request, $id)
{
    $chef = Chef::findOrFail($id);
    if ($request->hasFile('image')) {
        $chef->image = $request->file('image')->store('chefs', 'public');
    }
    $chef->fill($request->only('first_name','last_name','specialty','description','area'));
    $chef->save();

    return redirect()->back()->with('success', 'Perfil actualizado correctamente.');
}
Request Parameters:
​
first_name
string
Chef’s first name
​
last_name
string
Chef’s last name
​
specialty
string
Chef’s specialty
​
description
text
Chef bio/description
​
area
string
Work area (preparacion, cocinar, servir, etc.)
​
image
file
Chef profile image

​
deleteChef()

Delete a chef. Route: DELETE /admin/chefs/{id} Route Name: admin.chefs.delete Implementation: 
public function deleteChef($id)
{
    $chef = Chef::find($id);
    if ($chef) {
        $chef->delete();
        return redirect()->back()->with('success', 'Chef eliminado correctamente.');
    }
    return redirect()->back()->with('error', 'Chef no encontrado.');
}

​
Order Management

​
orders()

Display all orders. Route: GET /admin/orders Route Name: admin.orders Implementation: 
public function orders()
{
    $orders = Order::all();
    return view('admin.orders', compact('orders'));
}
Search orders by customer name. Route: GET /admin/orders/search Route Name: admin.orders.search Implementation: 
public function search(Request $request)
{
    $orders = Order::where('name','LIKE','%'.$request->search.'%')->get();
    return view('admin.orders', compact('orders'));
}
​
search
string
required
Search term to filter orders by customer name

Build docs developers (and LLMs) love

Get started for freeTalk to us