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.

Seguir leyendo

Distintas formas de enviar emails con PHP

El envío de emails es una de las funciones principales de cualquier sistema en internet, ya sea un sitio de usuarios, carros de compras, facturación, membresías etc.

Podemos enviar emails utilizando PHP de dos formas principalmente. Utilizando el servidor donde se ejecuta nuestro sitio, o bien utilizando un servidor externo SMTP.

Envió de emails utilizando la función mail()

La función “mail()” de php nos permite enviar emails tal como lo hacemos con nuestra aplicación de escritorio o web, como puede ser Outlook, Hotmail, Gmail y otras. 

La sintaxis básica de a función es la siguiente:

mail($para, $asunto, $mensaje, $header);

Destinatario: es el primer parámetro de la función y debe ser una dirección de correo electrónico. Puedes especificar más de uno separados por comas, ejemplo: email@dominio.com, email2@dominio.com, email2@dominio.com

Asunto, segundo parámetro.

Mensaje: tercer parámetro, es en si lo que leerá el destinatario de tu email, puede ser texto plano o bien texto enriquecido HTML.

Header, este es un parámetro importante, es necesario que este parámetro este bien configurado, muchas veces, de no estarlo nuestros emails serán filtradas y enviados directamente a la bandeja de spam de nuestros usuarios.

Teniendo estos conceptos claro, podemos realizar nuestra prueba utilizando el siguiente código:

$nombre = $_POST['nombre'];
$empresa = $_POST['empresa'];
$envia_desde_nombre = “”;
$envia_desde_email= “”;
$mensaje_tipo= “text/html”; //o puedes usar text/plain
 
$header ="MIME-Version: 1.0\n"; 
$header .= "Content-type: ".$mensaje_tipo."; charset=iso-8859-1\n";  
$header .= "From: ".$envia_desde_nombre." <".$envia_desde_email.">\n"; 
$header .= "Organization: “.$empresa.” \n";
$header .=" X-Mailer: PHP/". phpversion()."\n"; 
 
$mensaje = "Este mensaje fue enviado por " . $nombre . ", de la empresa " . $empresa . " \r\n";
$mensaje .= "Su e-mail es: " . $mail . " \r\n";
$mensaje .= "Mensaje: " . $_POST['mensaje'] . " \r\n";
$mensaje .= "Enviado el " . date('d/m/Y', time());
 
$para = 'info@tusitio.com';
$asunto = 'Contacto desde Tu sitio web';
mail($para, $asunto, $mensaje, $header);

Envió de email con HTML usando PHP. 

El procedimiento es básicamente el mismo. Solo tenemos que tener en cuenta que el tipo este configurado como “text/html”.

$mensaje = "<h1>Probando con html</h1>
<p>esta es una prueba de texto con html</p>";

Incluso podemos enviar una página completa HTML, con los tags de body, header etc. Esto ayuda a que tus emails se visualicen correctamente en la bandeja de entrada del que recibe el email.

$mensaje = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Untitled Document</title>
</head>
 
<body>
<h1>Probando con html</h1>
<p>esta es una prueba de texto con html</p>
</body>
</html>';

 Envió de Email Usando un Servidor SMTP con PHP.

Utilizaremos la librería “phpmailer” la cual la podemos bajar de sourceforge.net . Esta librería para el envio de correos electrónicos utilizando SMTP con php ha sido probada y es muy conocida en la comunidad de programadores. 

Podemos enviar emails ajustando algunos parámetros, como por ejemplo, servidor de salida, puerto, usuario, contraseña etc. 

En nuestra PHP de ejemplo agregamos lo siguiente:

include("phpmailer/class.phpmailer.php");
 
$mail = new phpmailer();
//Definimos las propiedades y llamamos a los métodos 
//correspondientes del objeto mail
 
 
//este ejemplo va a estar en el subdirectorio includes
$mail->PluginDir = "/phpmailer/";
 
//Con la propiedad Mailer le indicamos que vamos a usar un 
//servidor smtp
$mail->Mailer = "smtp";
 
//Asignamos a Host el nombre de nuestro servidor smtp
$mail->Host = "ssl://smtp.gmail.com";
$mail->Port =465;
 
//Le indicamos que el servidor smtp requiere autenticación
$mail->SMTPAuth = true;
$mail->IsHTML(true); 
 
//Le decimos cual es nuestro nombre de usuario y password
$mail->Username =  "usuario smtp" ; 
$mail->Password = "contraseña";
 
//Indicamos cual es nuestra dirección de correo y el nombre que 
//queremos que vea el usuario que lee nuestro correo
$mail->From = "email que ve el usuario";
$mail->FromName = "Nombre de envio";
 
//el valor por defecto 10 de Timeout es un poco escaso dado que voy a usar 
//una cuenta gratuita, por tanto lo pongo a 30  
$mail->Timeout=30;
 
//Indicamos cual es la dirección de destino del correo
$email_to_sent = "email donde va dirigido el email";
$mail->AddAddress("$email_to_sent");
 
//Asignamos asunto y cuerpo del mensaje
//El cuerpo del mensaje lo ponemos en formato html, haciendo 
//que se vea en negrita
$mail->Subject = "texto subject aqui";
$mail->Body = "aca asignamos el texto, el mensaje que ve la persona a la que enviamos el email";
 
//Definimos AltBody por si el destinatario del correo no admite email con formato html 
$mail->AltBody = "";
 
//se envia el mensaje, si no ha habido problemas 
//la variable $exito tendra el valor true
$exito = $mail->Send();
 
$intentos=1; 
while ((!$exito) && ($intentos < 5)) 
{
  sleep(5);
   //echo $mail->ErrorInfo;
   $exito = $mail->Send();
   $intentos=$intentos+1; 
 
}
 
 
 if(!$exito)
 {
  echo "Problema enviando email ".$valor;
  echo "<br/>".$mail->ErrorInfo; 
 }
 else
 {
  echo "Email enviado!";
 }

Espero que este tutorial de como enviar emails con PHP haya sido útil. 

Seguir leyendo