Tutorial como crear un carro de compras con PHP y MySQL

A través de este tutorial veremos cómo podemos crear un carro de compra para permitir a nuestros clientes comprar uno o múltiples productos en nuestro sitio. 

La creación del sistema la haremos utilizando PHP y MySQL. Necesitaremos la base de datos para almacenar la información de los productos, los datos de la compra como así también información del cliente que realizo la compra.

Antes de comenzar a programar, necesitamos hacer una estudio o análisis del sistema para tener claro con cuantos modules contara nuestro carro de compras online. Es muy cierto que como programadores muchas veces queremos ir directamente a la codificación, pero es muy importante que adoptemos una metodología a la hora de comenzar a construir nuestros sistemas.

Análisis del Sistema: 

Habitualmente un carrito de compras se programa teniendo en cuenta los módulos: productos, clientes, categorías y compras.
Como ya hemos visto en el tutorial de Programación Orientada a Objetos en PHP, podemos decir que los modules se pueden interpretar como clases, lo que implica que vamos a tener cuatro clases primarias: Producto, Cliente, Categoria y Venta.

Modulo Productos: 
Este módulo es el encargado de controla todo lo relacionado a un producto, usualmente un producto tienen un nombre, una descripción, un costo y está asociado a una categoría.

Modulo Clientes: 
Por definición lógica una compra está asociada a un cliente, por lo tanto vamos a necesitar una clase que se encargue de administrar a los clientes, sus datos y sus compras.

Modulo Ventas: 
La venta es el resultado final de todo el proceso y está relacionada a un cliente, como así también a uno o varios artículos.

Módulo Categorías:
Las categorías son una forma de clasificar y ordenar los productos en nuestro sitio. Por ejemplo: en un sitio de ventas de electrodomésticos un monitor estaría asociado a la categoría “Computación”, un televisor estaría en “electrodomésticos”.

Para nuestro tutorial usaremos como ejemplo una librería, para lo cual podemos decir que los productos serían los libros y las categorías los géneros: por ejemplo: terror, historia, drama etc.

Estructura de la Base de Datos: 

En la Programación Orientada a Objetos la estructura de la base de datos puede ser deducida mayoritariamente del diagrama de clases o lo que se conoce como UML. Por lo tanto, basándonos en las clases que tendrá el sistema podemos decir que tendremos 5 tablas primarias en nuestro sistema.

Las tablas de nuestro carrito de compra serán las siguientes: Productos, Categorias, Ventas y Clientes.

Comenzamos a Programar El Carro de Compras: 

Para el desarrollo de nuestro carrito de compras utilizaremos variables de sesión las cuales nos permiten almacenar los artículos seleccionas por el cliente a través de todas las paginas mientras este en nuestro sitio.

En una variable de sesión almacenaremos nuestra clase “Cart” la cual tienen los métodos básicos de un carrito de compra, estos son: agregar producto, borrar producto del carrito, obtener total de la compra.

Análisis de Clases: 

Clase Cart.php:

class Cart 
{
 var $colProducts;
 function calcTotal(){
  $sTotal=0;
 
  for ($i=1; $i <= count($this->colProducts); $i++){
 
   $sTotal=$sTotal + $this->colProducts[$i]->mCost;
  }
  $sTotal = number_format($sTotal,2,".",",") ;
  return $sTotal;
 }
 
 function borrarProduct($linea){
  $pos = 0;
  $colAux;
  for ($i=1; $i <= count($this->colProducts); $i++){
   if ($i != $linea){
    $pos++;
    $colAux[$pos] = $this->colProducts[$i];
   }
  }
  $this->colProducts = $colAux;
 } 
 
 function agregarProduct($unProducto){
  $this->colProducts[count($this->colProducts)+1]=$unProducto;
 } 
 function mostrarProduct($line){
  return $this->colProducts[$line];
 }
}

Como ya hemos visto PHP soporta encapsulamiento, de esta manera la clase Cart tendrá dentro una colección de productos. Lo que se traduce en una colección de objetos “Producto”. De no comprender estos conceptos te recomiendo veas el curso de Programación Orientada a Objetos en PHP. Lo vas a encontrar en la sección cursos.

Clase Producto.php:

require("ProductoPersistent.php");
 
class Producto  
{
 var $mPer; 
 var $mIdOrden;
 var $mId;
 var $mQty;
 var $mCost;
 var $mStatus;
 
 function Producto() //constructor
 {
  $this->mPer = new ProductoPersistent(); 
    }
 
   function guardarProdOrder() //guardar el producto en la tabla de ordenes
 {     
     return $this->mPer->guardarProdOrder($this);
   }
 
 function darTodosDeCategoria($cod) //me da todos los productos dependiendo de la categoria
 {     
        return $this->mPer->darTodosDeCategoria($cod);
   }
 
 function darNombreProd($name) //optimiza el nombre del producto
 {     
  $name = ucwords($name);
  return $name;  
   }
 
 function darUno($cod) //me da una producto con el ID
 {     
        return $this->mPer->darUno($cod);
   } 
}

En la primera línea incluimos la clase “ProductoPersistent” que es la encargada de interactuar con la base de datos, es ahí donde se encontraran todas las sentencias SQL.

Recuerda siempre mantener el orden y la prolijidad en tu código fuente, te va a pasar muchas veces que tenga que reutilizar el código y cuanto más claro este más rápido lo comprenderás.

La metodología recomendada es la llamada en tres capas, UI o interface del usuario, el dominio que sería la capa intermediaria y la capa persistente, la encargada de comunicarse con la base de datos. Pero, para no entreverarnos, prosigamos con el carro de compras.

Clase ProductoPersistent.php: 

Esta clase controla todas las sentencias SQL, realiza consultas, actualiza registros y borra. Las tareas básicas de cualquier carrito de compras.

require_once("Persistent.php");
class ProductoPersistent extends Persistent {
 
 function guardarProdOrder($unPerm) 
 {
  $result = "";  
 
  $sql = "INSERT INTO orden_detalles(detalle_orden_id , detalle_producto_id , detalle_cant , detalle_precio )
 
   VALUES(";
  $sql.= "'".$unPerm->mIdOrden."', ";
  $sql.= "'".$unPerm->mId."', ";
  $sql.= "'".$unPerm->mQty."', ";
  $sql.= "'".$unPerm->mCost."') ";   
 
  $this->setSql($sql);
  $result = $this->save();
  return  $result;
     } 
 
  function darUno($cod) 
  {
        $sql = " SELECT pro.*, cat.cat_id , cat.cat_name ";
 
  $sql .= " FROM productos pro";  
  $sql .= " RIGHT JOIN categorias  cat ON (cat.cat_id = pro.prod_cat_id)";
  $sql .= " WHERE cat.cat_id = pro.prod_cat_id  AND pro.id = '$cod'"; 
 
  //echo $sql;
 
        $this->setSql($sql);
        return $this->obtain();
    }
 
  function darTodosDeCategoria($cat) 
  {
        $sql = " SELECT pro.*, cat.cat_id , cat.cat_name  ";
 
  $sql .= " FROM productos pro";  
  $sql .= " RIGHT JOIN categorias  cat ON (cat.cat_id = pro.prod_cat_id)";
  $sql .= " WHERE cat.cat_id = pro.prod_cat_id  AND pro.prod_cat_id = '$cat'"; 
 
        $this->setSql($sql);
        return $this->obtain();
    }   
}

 Clase Orden: 

Esta clase es una de las más importantes, pero, en este tutorial solo agregaremos un método, el encargado de crear la orden en la tabla correspondiente.

require("OrdenPersistent.php");
 
class Orden  
{
 var $mPer;
 var $m_orden_cliente_id;
 var $m_orden_total; 
 function Orden() //constructor
 {
  $this->mPer = new OrdenPersistent(); 
    }
 
   function guardar() 
 {     
     return $this->mPer->guardar($this);
   }    
}

require_once("Persistent.php");
class OrdenPersistent extends Persistent {
 
 function guardar($Obj) {
  $result = "";  
 
  $sql = "INSERT INTO  ordenes 
 
  (orden_cliente_id, orden_total ,  orden_fecha )
 
   VALUES(";
  $sql.= "'".$Obj->m_orden_cliente_id."', ";
  $sql.= "'".$Obj->m_orden_total."', ";     
  $sql.= "'".date("Y-m-d")."') ";      
  $this->setSql($sql);
  $result = $this->save();
  return  $result;
     }    
}

Una clase secundaria es la que administra las categorías. Solo necesitamos dos métodos, uno para recuperar todas las categorías de la base de datos y otro para recuperar solo una teniendo en cuenta el ID de la misma.

require("CategoriaPersistent.php");
 
class Categoria  {
 function Categoria() 
 {
  $this->mPer = new CategoriaPersistent(); 
     }  
 
 function giveAll($catid) 
 {       
       return $this->mPer->giveAll($catid);
   }
 
 function getOne($cod) 
 {     
        return $this->mPer->getOne($cod);
   } 
}

Básicamente, ya tenemos programado lo que será el corazón de nuestro carro de compras en PHP. Ahora solo tenemos que empezar a integrar las clases con la interface gráfica del usuario.

Puesta en marcha de nuestro Carro de Compras: 

Para comenzar necesitamos una página donde mostrar todos los productos, los cuales podrán ser elegidos para comprar.

Usualmente, una lista de artículos son desplegados en la primera página de un sitio de compras online la cual puede ser filtrada seleccionado criterios que son mostrados en la columna izquierda.

También, cada producto debe tener la opción de “agregar”, la cual, al ser clickeada agrega el producto a la cesta. Una foto en miniatura tiene que ser mostrada también al igual que el precio.

Para la demostración de todo lo que hemos aprendido he creado una demo la cual puede ser vista haciendo clic aquí:

[Link caído]* Instalación del Carrito de Compra de Ejemplo: 

1. Descarga el archivo comprimido aquí. 
2. Descomprímelo. 
3. Edita el archivo de conexión a la base de datos “db_conection.php” que está en la carpeta “classesfra” 
4. Abre el documento “db_estructura.txt” para crear las tablas en tu servidor. 
5. Sube todo los archivos a tu servidor. 
6. Listo 

Recordar: 

El carrito de compras de ejemplos esta tan solo eso, un ejemplo. Con el cual se pretenden mostrar las funcionalidades básicas. La intención de este tutorial es darte las herramientas y guiarte para que tú puedas construir tu propio sistema.

Buena suerte amigos.

*Queremos aclarar que actualmente no poseemos los archivos como se muestran en el post. Trataremos de actualizarlo lo más antes posible ya que por ciertos problemas, no se ha podido subir contenido al blog.
Muchas gracias.