Tratamiento de Fechas Unix Timestamp en Mysql

En Mysql, podemos almacenar fechas en formato Unix Timestamp. La fecha/hora se almacena en número de segundos transcurridos desde el 1 de Enero de 1970 hasta el momento y es utilizado por multitud de plataformas , como por ejemplo Moodle.


Un ejemplo de dato podría ser:

1425580975

que correspondería con la fecha / hora: 2015-03-05 19:42:55

Podemos formatear este campo de fecha, en un formato comprensible, utilizando from_unixtime en Mysql de la siguiente forma:

select  id,denominacion,from_unixtime(time) as fecha from datos;

Utilizando PHP, también podríamos obtener la fecha en curso a partir de una fecha en formato Unix:

<?php
$unixtimestamp= "1425580975";
$anio = date("Y",$unixtimestamp);
$mes = date("m",$unixtimestamp);
$dia = date("d",$unixtimestamp);
echo "$anio-$mes-$dia";
?>


Comprimir y descomprimir archivos ZIP con PHP

En este tip vamos a ver como generar un archivo .zip a partir de uno o una serie de archivos que tengamos en nuestro servidor, mediante la función ZipArchive de PHP. También mostraremos el código, para descomprimir archivos .zip en nuestro servidor utilizando la función extractTo.

ComprimirArchivos.php

<?php
//Creamos un nuevo archivo .zip
$ArchivoZip = new ZipArchive();
//Le asignamos un mombre
$nombreZip = 'archivocomprimido2.zip';
//Abrimos el zip,
if($ArchivoZip->open($nombreZip,ZIPARCHIVE::CREATE)===true) {
//Añadimos el/los archivos que deseamos al .zip
$ArchivoZip->addFile('imagen1.jpg');
$ArchivoZip->addFile('imagen2.jpg');
//Cerramos el archivo .zip y concluimos
$ArchivoZip->close();
echo "Zip creado correctamente";
}
else
{
echo "Error generando el ZIP";
}
?>



Extraer archivos de un fichero comprimido en el servidor

Para descomprimir y extraer archivos de un fichero .zip subido a nuestro servidor, utilizaremos en este caso la función extractTo, de manera casi análoga a la anterior.

<?php $nombreZip = "archivocomprimido2.zip";
$ArchivoZip = new ZipArchive();
if($ArchivoZip->open($nombreZip) === true )
{
$ArchivoZip->extractTo("directoriozip");
echo "El archivo ZIP ha sido descomprimido correctamente";
}
else {
echo "Se ha producido un error al extraer los archivos";
}
?>





Convertir monedas en PHP con el API de Google

Vamos a utilizar el API que no proporciona Google, para convertir importes de una moneda a otra. Para ello, programaremos la siguiente función, ConvertirMoneda, que convierte (en este ejemplo) un EURO a Dólares Americanos:


$valor=ConvertirMoneda("USD","EUR",1);

<?php
function ConvertirMoneda($monedaOrigen,$monedaDestino,$importe) 
{
    $valor = file_get_contents("https://www.google.com/finance/converter?          a=$importe&from=$monedaOrigen&to=$monedaDestino");
    $valor = explode("<span class=bld>",$valor);
    $valor = explode("</span>",$valor[1]);  
    return preg_replace("/[^0-9\.]/", null, $valor[0]);
}
$valor=ConvertirMoneda("USD","EUR",1);
echo "1 Euro=$valor Dólares";
?>

La llamada al API nos devuelve el formulario de conversión y lo que hacemos con esta función es eliminar dicho formulario, para que el dato que nos devuelve sea exactamente el valor deseado.

¿Qué monedas acepta el API?

Los códigos de moneda que acepta el API son los siguientes:

AED=United Arab Emirates Dirham (AED)
AFN=Afghan Afghani (AFN)
ALL=Albanian Lek (ALL)
AMD=Armenian Dram (AMD)
ANG=Netherlands Antillean Guilder (ANG)
AOA=Angolan Kwanza (AOA)
ARS=Argentine Peso (ARS)
AUD=Australian Dollar (A$)
AWG=Aruban Florin (AWG)
AZN=Azerbaijani Manat (AZN)
BAM=Bosnia-Herzegovina Convertible Mark (BAM)
BBD=Barbadian Dollar (BBD)
BDT=Bangladeshi Taka (BDT)
BGN=Bulgarian Lev (BGN)
BHD=Bahraini Dinar (BHD)
BIF=Burundian Franc (BIF)
BMD=Bermudan Dollar (BMD)
BND=Brunei Dollar (BND)
BOB=Bolivian Boliviano (BOB)
BRL=Brazilian Real (R$)
BSD=Bahamian Dollar (BSD)
BTC=Bitcoin (&#3647;)
BTN=Bhutanese Ngultrum (BTN)
BWP=Botswanan Pula (BWP)
BYR=Belarusian Ruble (BYR)
BZD=Belize Dollar (BZD)
CAD=Canadian Dollar (CA$)
CDF=Congolese Franc (CDF)
CHF=Swiss Franc (CHF)
CLF=Chilean Unit of Account (UF) (CLF)
CLP=Chilean Peso (CLP)
CNH=CNH (CNH)
CNY=Chinese Yuan (CN¥)
COP=Colombian Peso (COP)
CRC=Costa Rican Colón (CRC)
CUP=Cuban Peso (CUP)
CVE=Cape Verdean Escudo (CVE)
CZK=Czech Republic Koruna (CZK)
DEM=German Mark (DEM)
DJF=Djiboutian Franc (DJF)
DKK=Danish Krone (DKK)
DOP=Dominican Peso (DOP)
DZD=Algerian Dinar (DZD)
EGP=Egyptian Pound (EGP)
ERN=Eritrean Nakfa (ERN)
ETB=Ethiopian Birr (ETB)
EUR=Euro (€)
FIM=Finnish Markka (FIM)
FJD=Fijian Dollar (FJD)
FKP=Falkland Islands Pound (FKP)
FRF=French Franc (FRF)
GBP=British Pound Sterling (£)
GEL=Georgian Lari (GEL)
GHS=Ghanaian Cedi (GHS)
GIP=Gibraltar Pound (GIP)
GMD=Gambian Dalasi (GMD)
GNF=Guinean Franc (GNF)
GTQ=Guatemalan Quetzal (GTQ)
GYD=Guyanaese Dollar (GYD)
HKD=Hong Kong Dollar (HK$)
HNL=Honduran Lempira (HNL)
HRK=Croatian Kuna (HRK)
HTG=Haitian Gourde (HTG)
HUF=Hungarian Forint (HUF)
IDR=Indonesian Rupiah (IDR)
IEP=Irish Pound (IEP)
ILS=Israeli New Sheqel (&#8362;)
INR=Indian Rupee (Rs.)
IQD=Iraqi Dinar (IQD)
IRR=Iranian Rial (IRR)
ISK=Icelandic Króna (ISK)
ITL=Italian Lira (ITL)
JMD=Jamaican Dollar (JMD)
JOD=Jordanian Dinar (JOD)
JPY=Japanese Yen (¥)
KES=Kenyan Shilling (KES)
KGS=Kyrgystani Som (KGS)
KHR=Cambodian Riel (KHR)
KMF=Comorian Franc (KMF)
KPW=North Korean Won (KPW)
KRW=South Korean Won (&#8361;)
KWD=Kuwaiti Dinar (KWD)
KYD=Cayman Islands Dollar (KYD)
KZT=Kazakhstani Tenge (KZT)
LAK=Laotian Kip (LAK)
LBP=Lebanese Pound (LBP)
LKR=Sri Lankan Rupee (LKR)
LRD=Liberian Dollar (LRD)
LSL=Lesotho Loti (LSL)
LTL=Lithuanian Litas (LTL)
LVL=Latvian Lats (LVL)
LYD=Libyan Dinar (LYD)
MAD=Moroccan Dirham (MAD)
MDL=Moldovan Leu (MDL)
MGA=Malagasy Ariary (MGA)
MKD=Macedonian Denar (MKD)
MMK=Myanmar Kyat (MMK)
MNT=Mongolian Tugrik (MNT)
MOP=Macanese Pataca (MOP)
MRO=Mauritanian Ouguiya (MRO)
MUR=Mauritian Rupee (MUR)
MVR=Maldivian Rufiyaa (MVR)
MWK=Malawian Kwacha (MWK)
MXN=Mexican Peso (MX$)
MYR=Malaysian Ringgit (MYR)
MZN=Mozambican Metical (MZN)
NAD=Namibian Dollar (NAD)
NGN=Nigerian Naira (NGN)
NIO=Nicaraguan Córdoba (NIO)
NOK=Norwegian Krone (NOK)
NPR=Nepalese Rupee (NPR)
NZD=New Zealand Dollar (NZ$)
OMR=Omani Rial (OMR)
PAB=Panamanian Balboa (PAB)
PEN=Peruvian Nuevo Sol (PEN)
PGK=Papua New Guinean Kina (PGK)
PHP=Philippine Peso (Php)
PKG=PKG (PKG)
PKR=Pakistani Rupee (PKR)
PLN=Polish Zloty (PLN)
PYG=Paraguayan Guarani (PYG)
QAR=Qatari Rial (QAR)
RON=Romanian Leu (RON)
RSD=Serbian Dinar (RSD)
RUB=Russian Ruble (RUB)
RWF=Rwandan Franc (RWF)
SAR=Saudi Riyal (SAR)
SBD=Solomon Islands Dollar (SBD)
SCR=Seychellois Rupee (SCR)
SDG=Sudanese Pound (SDG)
SEK=Swedish Krona (SEK)
SGD=Singapore Dollar (SGD)
SHP=St. Helena Pound (SHP)
SLL=Sierra Leonean Leone (SLL)
SOS=Somali Shilling (SOS)
SRD=Surinamese Dollar (SRD)
STD=São Tomé &amp; Príncipe Dobra (STD)
SVC=Salvadoran Colón (SVC)
SYP=Syrian Pound (SYP)
SZL=Swazi Lilangeni (SZL)
THB=Thai Baht (THB)
TJS=Tajikistani Somoni (TJS)
TMT=Turkmenistani Manat (TMT)
TND=Tunisian Dinar (TND)
TOP=Tongan Pa&#699;anga (TOP)
TRY=Turkish Lira (TRY)
TTD=Trinidad &amp; Tobago Dollar (TTD)
TWD=New Taiwan Dollar (NT$)
TZS=Tanzanian Shilling (TZS)
UAH=Ukrainian Hryvnia (UAH)
UGX=Ugandan Shilling (UGX)
USD=US Dollar ($)
UYU=Uruguayan Peso (UYU)
UZS=Uzbekistan Som (UZS)
VEF=Venezuelan Bolívar (VEF)
VND=Vietnamese Dong (&#8363;)
VUV=Vanuatu Vatu (VUV)
WST=Samoan Tala (WST)
XAF=CFA Franc BEAC (FCFA)
XCD=East Caribbean Dollar (EC$)
XDR=Special Drawing Rights (XDR)
XOF=CFA Franc BCEAO (CFA)
XPF=CFP Franc (CFPF)
YER=Yemeni Rial (YER)
ZAR=South African Rand (ZAR)
ZMK=Zambian Kwacha (1968–2012) (ZMK)
ZMW=Zambian Kwacha (ZMW)
ZWL=Zimbabwean Dollar (2009) (ZWL)

Leer y mostrar un archivo externo con PHP

Vamos a leer el contenido de un archivo (ya esté en nuestro servidor o en otro externo que disponga de permisos) y mostrarlo dentro de nuestra web.

Imaginemos que tenemos un archivo alojado en el servidor x:

http://www.webexterna.com/index.php

(este archivo puede ser cualquier cosa, un txt, un php....)

vamos a acceder al mismo mediante la función fopen , la cual permite abrir un archivo o una URL .

A continuación, leemos hasta el final del archivo con la función fread, cerramos el archivo y mostramos el resultado.

El código PHP sería el siguiente:

<?php
$url = "http://www.webexterna.com/index.php";
$contenido = '';
$archivo = fopen($url, "r");
while (!feof($archivo)) 
       {
 $contenido .= fread($archivo, 8192);
}
fclose($archivo);
echo "$contenido";
?>

Acortar URL en PHP con el API url shortener de Google

En este tip vamos a ver cómo acortar direcciones URL a través del API de Google en dos simples pasos. Primero activaremos el servicio en Google y obtendremos la clave necesaria para su uso, y a continuación programaremos dos sencillos scripts para echarlo a andar.

Lo primero que debemos hacer es disponer de una cuenta en Google y acceder al Área de Desarrolladores para conseguir nuestra API Key:

https://console.developers.google.com/project

En el menú "Proyectos", hacemos clic sobre "Crear Proyecto". En la pantalla emergente que nos aparece a continuación, introducimos el nombre que vamos a dar a nuestro proyecto y hacemos clic en "Crear".

Una vez creado el proyecto, accedemos al menú "APIs y autenticación" y a continuación "APIs" y buscamos "URL Shortener API".

En la siguiente pantalla, activamos el servicio. Dispondremos de un límite de 1.000.000 (un millón) de solicitudes diarias.

Una vez activado el servicio, y dentro del menú de la izquierda "APIs y autenticación", accedemos a "Credenciales" y a continuación hacemos clic en "Crear clave nueva" dentro "Acceso a API pública".

En la siguiente ventana emergente, seleccionamos "Clave de Servidor" e introducimos la IP del servidor (que podremos modificar más adelante) donde instalaremos el servicio.

Aceptamos y ya tenemos disponible nuestra API Key, del estilo:

AIzURixuB9d-deRq3_xIKUEYQoxUSTEz82osxYcTA


Con esta API Key, ya podemos programar nuestro servicio. Para ello vamos a crear dos páginas "acortador.php" (que se conectará al API de Google para acortar la URL) y "acortar.php" (que mostrará un formulario donde introduciremos la URL a  acortar).

acortar.php


<?php
include("acortador.php");
$api = new GoogleURL('AIzURixuB9d-deRq3_xIKUEYQoxUSTEz82osxYcTA');
if($_POST[url]!="")
{
$acortada=$api->encode($_POST[url]);
}
?>
<style>
body{font-family:arial;size:11px;}
input{border: solid 1px #BEBEBE;background-color:#ffffff;height:20px;padding-left:1%;padding-right:1%;font-family:'arial';}
</style>
<form name='formx2ac' method='post' action='acortar.php'>
Acortar URL: <input type='text' name='url' id='url'> <input type='submit' value='Acortar'><br>
</form>
<?php
if($acortada!="")
{
echo "<b>$acortada</b>";
}
?>



Como vemos, acortar.php no es más que un sencillo formulario que se envía a si mismo. Comprueba si ha sido introducida una URL y si es así, realiza una solicitud al API de Google:

$acortada=$api->encode($_POST[url]);


Recordad modificar el valor de esta variable, con el API Key obtenido en los pasos anteriores:
$api = new GoogleURL('AIzURixuB9d-deRq3_xIKUEYQoxUSTEz82osxYcTA');


almacenando el resultado en la variable "$acortada", que mostraremos a continuación.

acortador.php

<?php

class GoogleURL

{

 

private $apiURL = 'https://www.googleapis.com/urlshortener/v1/url';

 

function __construct($apiKey)

{

  //creamos la url de solicitud con nuestra key pública

  $this->apiURL = $this->apiURL . '?key=' . $apiKey;

}

 

//convierte una url larga en una corta

public function encode($url)

{

  $data = $this->cURL($url, true);

  return isset($data->id) ? $data->id : '' ;

}

 

//convierte una url corta en la real (larga)

public function decode($url)

{

  $data = $this->cURL($url, false);

  return isset($data->longUrl) ? $data->longUrl : '' ;

}

 

//enviamos y recogemos los datos del api de google

private function cURL($url, $post = true)

{

  $ch = curl_init();

  if ($post) {

   curl_setopt( $ch, CURLOPT_URL, $this->apiURL );

   curl_setopt( $ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json') );

   curl_setopt( $ch, CURLOPT_POST, true );

   curl_setopt( $ch, CURLOPT_POSTFIELDS, json_encode(array('longUrl' => $url)) );

  }

  else {

   curl_setopt( $ch, CURLOPT_URL, $this->apiURL . '&shortUrl=' . $url );

  }

  curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );

  curl_setopt( $ch, CURLOPT_SSL_VERIFYPEER, false );

  $json = curl_exec($ch);

  curl_close($ch);

  return (object) json_decode($json);

}

}

?>

Y ya estaría montado nuestro sistema para acortar URLs

Podéis obtener  más información en:
https://developers.google.com/url-shortener/

Herramientas para verificar si los servidores nos consideran SPAM

Habitualmente los proveedores de servicio de correo se basan en listas de spammers para bloquear el acceso de correos entrantes a los mismos. Si nuestro host se encuentra en una de estas listas, podemos tener un pequeño problema.

Si nos encontramos en esta tesitura o si simplemente queremos asegurarnos de que nuestros correos no son considerados como spam, lo primero que debemos comprobar es que no nos encontramos en estas listas.

Como primer paso, vamos a verificar que nuestro dominio no se encuentra en la lista de Spamhaus.

Spamhaus es una base de datos de direcciones IP consideradas como ilícitas o generadoras de spam.

Accedemos a spamharus.org y a continuación, hacemos click sobre Blocklist Removal Center, donde introduciremos nuestro nombre de host o IP y nos mostrará si hemos sido incluidos en la lista negra o no. En el caso de encontrarnos incluidos, podremos solicitar el desbloqueo desde el formulario destinado a tal efecto en esta pantalla.

Otra utilidad muy interesante es http://mxtoolbox.com/.

Podemos chequear nuestro dominio introduciendo en el navegador:

http://mxtoolbox.com/SuperTool.aspx?action=blacklist:tu_nombre_de_dominio.com

Nnos mostrará una relación de las principales listas negras de spamers y si nuestro dominio se encuentra incluido en ellas o no.

En el peor de los casos, deberemos acceder a cada lista en la que nos encontremos y tratar de "salir" de las mismas (a parte de todas las acciones que tengamos que definir en nuestro dominio para no volver a entrar).

Mostrar número de archivos de un directorio en Linux

Conocemos el comando ls en linux, para mostrar el contenido de un determinado directorio y ls -la para mostrar, a parte del nombre de los archivos, alguna de sus características como los permisos asignados a cada uno.

Utilizando la opción -R, el listado se convierte en recursivo:

 ls -la -R nos mostrará el contenido de nuestro directorio y de todos los que contenga.

Si queremos contar el número de archivos que contiene nuestro directorio (o de forma recursiva con el modificador -R) utilizaremos el comando wc de la siguiente forma:

ls  | wc -l

mostrará el número de archivos del directorio donde nos encontramos.

Si deseamos mostrar el número de archivos de un determinado directorio de forma recursiva, utilizaremos:

ls -R /home/llercia/Escritorio/ejemplo  | wc -l