<?php
include('Property.php');
include('ClassIPNInterface.php');

// creamos el objeto, automáticamente la clase enviará una notificación a paypal de que recibimos la notificación y eso
$ipn = new ClassIPN();
// vemos si ubo un error al realizar el aviso a paypal
if($ipn->error == true)
{
    // mostramos el error
    echo $ipn->error_msg;
} else { // si no ocurrió ningún error

// aquí guardamos en la base de datos, y actualizamos la tabla que tenga los pagos y le damos la plata al cliente o le ponemos una notificación de que se realizó el pago.

// podemos usar las siguientes variables:

$ipn->item_name(); // nombre del producto
$ipn->payment_status(); // el estado del pago cuando se realizó esta notificacion
$ipn->payment_amount(); // el dinero que pagó por el producto
$ipn->transaction_id(); // el numero de transacción único, recomiendo que revisen en la db antes de hacer nada si ya había un pago con este numero de transacción para no tener duplicados.
$ipn->client_email(); // el email de la persona que pagó

}

<?php 

interface IIPN
{
	
	public function __construct();
	
	public function get_item_name();
	public function set_item_name($value);
	
	public function get_payment_status();
	public function set_payment_status($value);
	
	public function get_payment_amount();
	public function set_payment_amount($value);
	
	public function get_payment_currency();
	public function set_payment_currency($value);
	
	public function get_transaction_id();
	public function set_transaction_id($value);
	
	public function get_receiver_email();
	public function set_receiver_email($value);
	
	public function get_client_email();
	public function set_client_email($value);
	
}

include('ClassIPN.php');

<?php 

class IPN implements IIPN
{
	// usamos mi trait Property 
	use Property;
	
	// atributos privados
	private $notify_validate_request_content = null;
	private $notify_validate_request_header = null;
	
	// variables.
	private $item_name = null; // nombre del producto
	private $payment_status = null; // estado del pago
	private $payment_amount = null; // precio pagado
	private $payment_currency = null; // ?
	private $transaction_id = null; // id de transacción de paypal
	private $receiver_email = null; // nuestro mail
	private $client_email = null; // mail del que compró
	
	private $error = false;
	private $error_msg = null;
	
	
	public function __construct()
	{
		$this->vars_extract();
		$this->notify_validate_request_content = $this->request_content_generate();
		$this->notify_validate_request_header = $this->request_header_generate();
		$this->notify_validate_request();			
	}
	
	private function request_content_generate()
	{
		$req = 'cmd=_notify-validate';
		foreach ($_POST as $key => $value) {
			$value = urlencode(stripslashes($value));
			$req .= "&$key=$value";
		}
		return $req;
	}
	
	private function request_header_generate()
	{
		$header = null;
		$header .= "POST /cgi-bin/webscr HTTP/1.0\r\n";
		$header .= "Content-Type: application/x-www-form-urlencoded\r\n";
		$header .= "Content-Length: " . strlen($this->notify_validate_request_content) . "\r\n\r\n";
		return $header;
	}
	
	private function notify_validate_request()
	{
		try 
		{
			$fp = fsockopen ('www.paypal.com', 80, $errno, $errstr, 30);
			if(!$fp) throw new exception('No es posible conectar con www.paypal.com');
			fputs ($fp, $this->notify_validate_request_header . $this->notify_validate_request_content);
			while (!feof($fp)) 
			{
				$res = fgets ($fp, 1024);
				if (strcmp ($res, "VERIFIED") == 0)
				{
					return true;
				}
				else
				{
					throw new exception('Ocurrió un error con la transaccion');
				}
			}
		} catch(Exception $e)
		{
			$this->error = true;
			$this->error_msg = $e->getMessage();
			return false;
		}		
	}
	
	private function vars_extract()
	{
		$this->item_name = $_REQUEST['item_name'];
		$this->payment_status = $_REQUEST['payment_status'];
		$this->payment_amount = $_REQUEST['mc_gross'];
		$this->payment_currency = $_REQUEST['mc_currency'];
		$this->transaction_id = $_REQUEST['txn_id'];
		$this->receiver_email =  $_REQUEST['receiver_email'];
		$this->client_email = $_REQUEST['payer_email'];
	}
	
	public function get_item_name() { return $this->item_name; }
	public function set_item_name($value) { ; }
	
	public function get_payment_status() { return $this->payment_status; }
	public function set_payment_status($value) { ; }
	
	public function get_payment_amount() { return $this->payment_amount; }
	public function set_payment_amount($value) { ; }
	
	public function get_payment_currency() { return $this->payment_currency; }
	public function set_payment_currency($value) { ; }
	
	public function get_transaction_id() { return $this->transaction_id; }
	public function set_transaction_id($value) { ; }
	
	public function get_receiver_email() { return $this->receiver_email; }
	public function set_receiver_email($value) { ; }
	
	public function get_client_email() { return $this->client_email; }
	public function set_client_email($value) { ; }
}

<?php 

// se requiere Trait Property

Interface IFileClass
{
	
	/*
	 * @ $location = carpeta donde se guarda el archivo
	 * @ $name = nombre del archivo con extensión incluida 
	 */
	public function __construct($location = null, $name = null);
	
	/*
	 * @ $name = nombre que verá el usuario cuando se le descargue el archivo
	 */
	public function download_file($name);
	
	/*
	 * @ $nombre_campo = nombre del campo file del formulario para cargar archivo
	 * @ $carpeta = carpeta donde se subirá el archivo
	 * @ $uniqid = agregar o no un id único para que no se repitan los archivos
	 * @ $namecrypt = encriptar nombre del archivo para imposibilitar descarga (se encrypta en md5)
	 * @ $extension_valida = arreglo con extensiones válidas
	 * @ $file_type = MIME/TYPE del archivo
	 * @ $kbmax = Máximos kb que se permiten en la subida (dejar en 0 si no se quiere poner limite)
	 * @ $dir = cuando se devuelva la ruta del archivo devolverla con la carpeta o sin la carpeta de su ubicación (osea solo el nombre o toda la ruta completa)
	 * ésta función devuelve falso si ubo algún error, o la dirección o nombre del archivo (según lo especificado) de lo que se subió.
	 */
	public function upload_file($nombre_campo, $carpeta, $uniqid = false, $namecrypt = false, $extension_valida = array('rar'), $file_type = null, $kbmax = 0, $dir = true);
	
	// devuelve si un nombre de archivo tiene o no una extensión X.
	public function validate_extension($filename, $extension);
	
	public function get_name();
	public function set_name($value);
	
	public function get_peso();
	public function set_peso($value);
	
	public function get_type();
	public function set_type($value);
	
	public function get_location();
	public function set_location($value);
	
	public function get_error();
	public function set_error($value);
	
	public function get_error_msg();
	public function set_error_msg($value);
	
}

include('FileClass.php');

<?php

Class FileClass implements IFileClass
{
	use Property;
	
	protected $kb = 1024;
	protected $mb = 1024;
	protected $gb = 1024;
	private $name = null;
	private $peso = null;
	private $type = null;
	private $location = null;
	
	private $error = false;
	private $error_msg = null;
	
	public function __construct($location = null, $name = null)
	{
		try
		{
			if(!empty($location))
			{
				if(empty($name)) throw new exception('El nombre del fichero es requerido');
				if(!file_exists($location.$name)) throw new exception('El fichero no existe');
				$this->name = $name;
				$this->location = $location;
				$this->peso = filesize($location.$name);
			}
		} catch(Exception $e) 
		{
			$this->error = true;
			$this->error_msg = $e->getMessage();	
		}
	}
	
	public function download_file($name)
	{
		header("Content-type: application/octet-stream");
		header("Content-Disposition: attachment; filename=\"{$name}\"\n");
		$fp=fopen($this->location.$this->name, "r");
		fpassthru($fp);
		die();
	}
	
	public function upload_file($nombre_campo, $carpeta, $uniqid = false, $namecrypt = false, $extension_valida = array('rar'), $file_type = null, $kbmax = 0, $dir = true)
	{
		try 
		{
			$this->name = $_FILES[$nombre_campo]['name'];
			$this->size = $_FILES[$nombre_campo]['size'];
			$this->type = $_FILES[$nombre_campo]['type'];
			$this->location = $carpeta;
			if(empty($_FILES[$nombre_campo])) throw new exception('Archivo no seleccionado');
			$id = null;
			if($uniqid) $id = uniqid(microtime());
			$this->name = $id.$this->name;
			// verificamos si la extensión es válida
			$valido = false;
			for($i = 0; $i<count($extension_valida); $i++)
				if($this->validate_extension($this->name, $extension_valida[$i]))
					$valido = true;
			if(!$valido) throw new exception('El archivo es de una extensión inválida');
			// verificamos si el tipo de archivo es valido
			if(!empty($file_type) && $this->type!=$file_type) throw new exception('El tipo de archivo es inválido');
			// verificamos si tiene el tamaño correcto
			if($kbmax>0 && $this->size > $kbmax*$this->kb) throw new exception('El archivo pesa demaciado');
			// lo encryptamos si es preciso
			if($namecrypt)
				$this->name = 'file_'.md5($this->name).'.cab';
			// verificamos que el directorio tenga los permisos
			//------------ TODO
			// ahora lo vamos a mover
			if (!move_uploaded_file($_FILES[$nombre_campo]['tmp_name'], $this->location.$this->name)) throw new exception('No se puede mover fichero subido a carpeta especificada');
			// retornamos el directorio donde se guardó
			if($dir)
				return $this->location.$this->name;
			else
				return $this->name;
		} catch (Exception $e)
		{
			$this->error = true;
			$this->error_msg = $e->getMessage();
			return false;
		}
	}
	
	public Function validate_extension($filename, $extension)
	{
		$ext_init = strlen($filename) - strlen($extension);
		$last_ext = null;
		for($i=$ext_init; $i<strlen($filename); $i++)
			$last_ext.=$filename[$i];
		if($last_ext == $extension) 
			return true;
		else
			return false;
	}
	
	public function get_name() { return $this->name; }
	public function set_name($value) { $this->name = $value; }
	
	public function get_peso() { return $this->peso; }
	public function set_peso($value) { ; }
	
	public function get_type() { return $this->type; }
	public function set_type($value) { ; }
	
	public function get_location() { return $this->location; }
	public function set_location($value) { $this->location = $value; }
	
	public function get_error() { return $this->error; }
	public function set_error($value) { ; }
	
	public function get_error_msg() { return $this->error_msg; }
	public function set_error_msg($value) { ; }

}

// INCLUIMOS LOS ARCHIVOS NECESARIOS
include('Property.php');
include('ClassMailerInterface.php');

$emisor = '[email protected]'; // mi mail
$emisor_alias = 'Roberto Gomez';

$receptor = '[email protected]'; // el mail de la persona que recibirá el mail xD
$receptor_alias = 'José perez';

$asunto = 'Hola josé';
$mensaje = 'Hola josé, como andas? todo bien? saludos!';

// creamos un nuevo mail
$mail = new ClassMailer($emisor, $receptor, $asunto, $mensaje, $emisor_alias, $receptor_alias);
// si no hay error
if(!$mail->error)
 {
    $mail->send(); // enviamos el mail
 }
else // si hay error
 {
    echo $mail->error_message; // mostramos el error
 }

<?php

interface IClassMailer
{
	
	// devuelve verdadero si $email es válido, o falso si $email no es válido
	public function validar_email($email);
	
	// enviar email preconfigurado
	public function send();
	// retorna verdadero o falso dependiendo de si se envió el email
	
	// setters and getters
	public function get_receptor();
	public function set_receptor($value);
	
	public function get_receptor_alias();
	public function set_receptor_alias($value);
	
	public function get_emisor();
	public function set_emisor($value);
	
	public function get_emisor_alias();
	public function set_emisor_alias($value);
	
	public function get_asunto();
	public function set_asunto($value);
	
	public function get_charset();
	public function set_charset($value);
	
	public function get_content_type();
	public function set_content_type($value);
	
	public function get_mime_version();
	public function set_mime_version($value);
	
	public function get_mensaje();
	public function set_mensaje($value);
	
	public function get_error();
	public function set_error($value);
	
	public function get_error_message();
	public function set_error_message($value);
	
}

include('ClassMailer.php');

<?php

Class ClassMailer implements IClassMailer
{	
	// uses
	use Property;
	
	// atributes
	private $receptor = null;
	private $receptor_alias = null;
	private $emisor = null;
	private $emisor_alias = null;
	private $asunto = null;
	private $charset = 'UTF-8';
	private $content_type = 'text/html';
	protected $mime_version = '1.0';
	private $mensaje = null;
	
	protected $error = false;
	protected $error_message = null;
	
	public function __construct($emisor, $receptor, $asunto, $mensaje, $emisor_alias = null, $receptor_alias = null)
	{
		try 
		{
			if(!$this->validar_email($emisor)) Throw new exception('Invalid mail $emisor');
			if(!$this->validar_email($receptor)) Throw new exception('Invalid mail $receptor');
			$asunto = trim($asunto);
			if(empty($asunto) && strlen($asunto)<3) throw new exception('Invalid subject $asunto');
			$mensaje = trim(utf8_encode($mensaje));
			if(empty($mensaje) && strlen($mensaje)<10) throw new exception('Invalid menssage $mensaje');
			$this->receptor = $receptor;
			$this->emisor = $emisor;
			$this->asunto = $asunto;
			$this->mensaje = $mensaje;
			if(!empty($emisor_alias))
			{
				$emisor_alias = trim($emisor_alias);
				if(strlen($emisor_alias)>3)
					$this->emisor_alias = $emisor_alias;
				else 
					throw new exception('Emisor Alias is invalid');
			}
			if(!empty($receptor_alias))
			{
				$emisor_alias = trim($receptor_alias);
				if(strlen($receptor_alias)>3)
					$this->receptor_alias = $receptor_alias;
				else
					throw new exception('Receptor Alias is invalid');
			}
		} catch (Exception $e) { $this->error = true; $this->error_message = $e->getMessage(); }
	}
	
	public function validar_email($email)
	{
		return preg_match('/^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i',$email);
	}
	
	public function send()
	{
		if(!$this->error)
		{
			mail($this->receptor, $this->asunto, $this->mensaje, $this->fabricar_cabeceras());
		} else { return false; }	
	}
	
	private function fabricar_cabeceras()
	{
		$cabeceras = null;
		$cabeceras  = 'MIME-Version: ' . $this->mime_version . "\r\n";
		$cabeceras .= 'Content-type: ' . $this->content_type . '; charset=' . $this->charset . "\r\n";
		if(!empty($this->receptor_alias)) 
		{
			$cabeceras .= 'To: ' . $this->receptor_alias . ' <' . $this->receptor . '>' . "\r\n";
		} else {
			$cabeceras .= 'To: ' . $this->receptor . "\r\n";
		}
		if(!empty($this->emisor_alias))
		{
			$cabeceras .= 'From: ' . $this->emisor_alias . ' <' . $this->emisor . '>' . "\r\n";
		} else {
			$cabeceras .= 'From: ' . $this->emisor . "\r\n";
		}
		return $cabeceras;
	}
	
	public function get_receptor() { return $this->receptor; }
	public function set_receptor($value)
	{
		try 
		{
			$receptor = $value;
			if(!$this->validar_email($receptor)) Throw new exception('Invalid mail $receptor');
			$this->receptor = $receptor;
		} catch (Exception $e) { $this->error = true; $this->error_message = $e->getMessage(); }
	}
	
	public function get_receptor_alias() { return $this->receptor_alias;}
	public function set_receptor_alias($value)
	{
		try
		{
			$receptor_alias = $value;
			$receptor_alias = trim($receptor_alias);
			if(!strlen($receptor_alias)>3) throw new exception('Receptor Alias is invalid');
			$this->receptor_alias = $receptor_alias;
		} catch (Exception $e) { $this->error = true; $this->error_message = $e->getMessage(); }
	}
	
	public function get_emisor() { return $this->emisor; }
	public function set_emisor($value)
	{
		try 
		{
			$emisor = $value;
			if(!$this->validar_email($emisor)) Throw new exception('Invalid mail $emisor');
			$this->emisor = $emisor;
		} catch (Exception $e) { $this->error = true; $this->error_message = $e->getMessage(); }
	}
	
	public function get_emisor_alias() { return $this->emisor_alias; }
	public function set_emisor_alias($value)
	{
		try 
		{
			$emisor_alias = $value;
			$emisor_alias = trim($emisor_alias);
			if(!strlen($emisor_alias)>3) throw new exception('Emisor Alias is invalid');
			$this->emisor_alias = $emisor_alias;	
		} catch (Exception $e) { $this->error = true; $this->error_message = $e->getMessage(); }
	}
	
	public function get_asunto() { return $this->asunto; }
	public function set_asunto($value)
	{
		try 
		{
			$asunto = value;
			$asunto = trim($asunto);
			if(empty($asunto) && strlen($asunto)<3) throw new exception('Invalid subject $asunto');
		} catch (Exception $e) { $this->error = true; $this->error_message = $e->getMessage(); }
	}
	
	public function get_charset() { return $this->charset; }
	public function set_charset($value)
	{
		$this->charset = $value;
	}
	
	public function get_content_type() { return $this->content_type; }
	public function set_content_type($value)
	{
		$this->content_type = $value;
	}
	
	public function get_mime_version() { return $this->mime_version; }
	public function set_mime_version($value) { ; } // no podemos cambiar el mime_version
	
	public function get_mensaje() { return $this->mensaje; }
	public function set_mensaje($value) 
	{ 
		try 
		{
			$mensaje = $value;
			$mensaje = trim(utf8_encode($mensaje));
			if(empty($mensaje) && strlen($mensaje)<10) throw new exception('Invalid menssage $mensaje');
			$this->mensaje = $mensaje;
		} catch (Exception $e) { $this->error = true; $this->error_message = $e->getMessage(); }
	}
	
	public function get_error() { return $this->error; }
	public function set_error($value) { ; } // no permitimos setear un error
	
	public function get_error_message() { return $this->error_message; }
	public function set_error_message($value) { ; } // no permitimos setear un mensaje de error
	
}

<?php

include('Property.php');

// esta clase requiere Property!

// Interface

interface IErrorClass
{

    // arrojar error
    public function error_dispatch();
    
    // setters y getters
    public function get_message();
    public function set_message($value);
    public function get_error_level();
    public function set_error_level($value);
    

}

class ErrorClass implements IErrorClass
{
    use Property;

    private $message = null;
    private $errors = array( NULL, 1024, 512, 256 );
    private $error_level = 1;
    
    public function __construct($message = null, $error_level = 1)
    {
        $this->error_level_control($error_level);
        $this->message_control($message);
        $this->message = $message;
        $this->error_level = $error_level;
    }
    
    private function error_level_control($lvl)
    {
        if(!isset($this->errors[$lvl]))
        {
          $this->error_level = 3;
          $this->message = 'Invalid error type specified';
          $this->error_dispatch();
        }
        return true;
    }
    
    private function message_control(&$message)
    {
        $message = htmlentities($message);
        $message = utf8_encode($message);
        return true;
    }
    
    public function error_dispatch()
    {
        trigger_error($this->message, $this->errors[$this->error_level]);
    }
    
    public function get_message()
    {
        return $this->message;
    }
    
    public function set_message($value)
    {
        $this->message_control($value);
        $this->message = $value;
    }
    
    public function get_error_level()
    {
        return $this->error_level;
    }
    
    public function set_error_level($value)
    {
        $this->error_level_control($value);
        $this->error_level = $value;
    }

}

// ejemplo de uso

$error = new ErrorClass();

$error->error_level = 1; // solo se pueden asignar valores de 1 a 3, cuanto mayor es el numero el error va a ser de mayor tipo (E_NOTICE = 1, E_WARNING = 2, E_FATAL = 3)
// si se asigna un valor no permitido tirará FATAL ERROR

$error->message = 'Probando errores';

$error->error_dispatch();

<?php

trait Singleton
{

    static private $instancia = null;
    
    static public function GetInstancia()
    {
        if(!(self::$instancia instanceof __CLASS__))
        {
            self::$instancia = new __CLASS__;
        }
        return self::$instancia;
    }
    
    public function __clone()
    {
        trigger_error('No es posible realizar la clonación', E_USER_ERROR);
    }

}

class miclase
{
use Singleton;

    ... resto del código

}

class miclase
{
use Singleton, Property;

    ... resto del código

}

$row = mysql_fetch_array($result)
echo $row['titulo_noticia'];
echo $row['contenido_noticia'];