Mostrando entradas con la etiqueta clases. Mostrar todas las entradas
Mostrando entradas con la etiqueta clases. Mostrar todas las entradas

viernes, 12 de septiembre de 2014

GrabzIt PHP Library: Tomar capturas de pantalla de páginas Web con la API GrabzIt


GrabzIt PHP Library es una clase PHP que te permite tomar capturas de pantalla de páginas Web usando GrabzIt y devolverlos como imágenes, tablas o documentos PDF.
 
Puede enviar una solicitud HTTP al servidor Web GrabzIt a través de la API GrabzIt para solicitar que el servicio tiene una captura de pantalla de una página determinada.
 
Cuando se envía la imagen que se está solicitando, varias opciones pueden configurarse como el tamaño de la ventana del navegador, el formato de la imagen resultante, si se debe utilizar la versión móvil de una página web, si sólo una parte de la página web debe ser capturada, e incluye una función callback para cuando la imagen de la página está lista. 
 
Descargar: GrabzIt PHP Library
 
Es requisito para que funcione descargar la API GrabzIt aquí

 Es importante configurar correctamente la API en config.php ...


 <?php
//Get this value from http://grabz.it/api
$grabzItApplicationKey = "APPLICATION KEY";
//Get this value from http://grabz.it/api
$grabzItApplicationSecret = "APPLICATION SECRET";
//The absolute path that you have placed the handler.php on your website
$grabzItHandlerUrl = "URL OF YOUR GrabzItHandler.php FILE (http://www.example.com/grabzit/handler.php)";
?> 


También viene con un script de demostración en index.php

<?php
include("lib/GrabzItClient.class.php");
include("config.php");

$message = '';

if (count($_POST) > 0)
{
        if (isset($_POST["delete"]) && $_POST["delete"] == 1)
        {
            $files = glob('results/*');
            foreach($files as $file)
            {
                if(is_file($file))
                    unlink($file);
            }
        }
        else
        {
        $url = $_POST["url"];
        $format = $_POST["format"];
        try
        {
            $grabzIt = new GrabzItClient($grabzItApplicationKey, $grabzItApplicationSecret);
            if ($format == "pdf")
            {
                $grabzIt->SetPDFOptions($url);
            }
            else
            {
                $grabzIt->SetImageOptions($url);
            }
            $grabzIt->Save($grabzItHandlerUrl);
        }
        catch (Exception $e)
        {
            $message =  $e->getMessage();
        }
    }
}
?>
<html>
<head>
<title>GrabzIt Demo</title>
<link rel="stylesheet" type="text/css" href="css/style.css">
<script src="//ajax.googleapis.com/ajax/libs/jquery/1.9.0/jquery.min.js"></script>
<script src="ajax/ui.js"></script>
</head>
<body>
<h1>GrabzIt Demo</h1>
<form method="post" action="index.php" class="inputForms">
<p>Enter the URL of the website you want to take a screenshot of. Then resulting screenshot should be saved in the <a href="results/" target="_blank">results directory</a>. It may take a few seconds for it to appear! If nothing is happening check the <a href="http://grabz.it/account/diagnostics" target="_blank">diagnostics panel</a> to see if there is an error.</p>
<?php
if ($grabzItHandlerUrl == "URL OF YOUR handler.php FILE (http://www.example.com/grabzit/handler.php)")
{
        ?><p><span class="error">You must set your call back to a valid public URL.</span></p><?php
}
if (!is_writable("results"))
{
    ?><span class="error">The "results" directory is not writeable! This directory needs to be made writeable in order for this demo to work.</span><?php
    return;
}
if (count($_POST) > 0 && !isset($_POST["delete"]))
{
    if (!empty($message))
    {
        ?><p><span class="error"><?php echo $message; ?></span></p><?php
    }
    else
    {
        ?><p><span style="color:green;font-weight:bold;">Processing screenshot.</span></p><?php
    }
}
?>
<label style="font-weight:bold;margin-right:1em;">URL </label><input text="input" name="url"/> <select name="format">
  <option value="jpg">JPG</option>
  <option value="pdf">PDF</option>
</select>
<input type="submit" value="Grabz It"></input>
</form>
<form method="post" action="index.php" class="inputForms">
<input type="hidden" name="delete" value="1"></input>
<input type="submit" value="Clear Results"></input>
</form>
    <br />
    <h2>Completed Screenshots</h2>
    <div id="divResults"></div>
</body>
</html>


PHP IP Sorter - Ordenar un array de direcciones IP


PHP IP Sorter es una clase PHP que permite ordenar un array cuyos elementos son direcciones IP.

Se necesita una lista de direcciones IP v4 y los clasifica teniendo en cuenta el número de sus partes separadas por puntos a partir de la primera parte.

La clase devuelve un array con los elementos  ya ordenados.

Descargar:  PHP IP Sorter

Entre los archivos descargados viene un script de demostración, demo.php ...

 <?php

//
// +---------------------------------------------+
// |     SORTER IP | V1.0                |
// |     http://www.SysTurn.com                  |
// +---------------------------------------------+
//
//
//   This program is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 2, or (at your option)
//   any later version.
//
//   This program is distributed in the hope that it will be useful,
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//   GNU General Public License for more details.
//
//   You should have received a copy of the GNU General Public License
//   along with this program; if not, write to the Free Software Foundation,
//   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
//

include_once ('SorterIp.php');

$ip1 = array('ip' => '192.168.10.1');
$ip2 = array('ip' => '192.168.10.10');
$ip3 = array('ip' => '10.0.0.10');
$ip4 = array('ip' => '10.0.0.5');
$ip5 = array('ip' => '176.10.0.90');
$ip6 = array('ip' => '176.18.10.1');
$ip7 = array('ip' => '132.18.19.128');

$list = array();
$i = 0;
for ($i = 1; $i < 8; $i++) {
    $var = "ip$i";
    $list[$i] = $$var;
}

$objSorter = new SorterIP();
$data = $objSorter -> sort($list);
var_dump($data);

?> 


jueves, 31 de julio de 2014

Propiedades y métodos estáticos en PHP


Bienvenid@s, crear clases con el tiempo se convierte en algo fundamental para mantener una estructura y un orden en la aplicación. Para crear clases en PHP existen variantes que a veces pueden ayudar a tener una cierta eficiencia y accesibilidad, de hecho los frameworks PHP, se basan en esto, en ser sumamente flexibles y asumen en buena parte de sus clases propiedades y métodos estáticos. ¿por qué?, una de las grandes ventajas de utilizar propiedades y métodos estáticos es que los hacen accesibles sin tener que crear una instancia de la clase. De lo contrario, a las propiedades y métodos estáticos no podremos acceder a través de un objeto instanciado.

Si has utilizado en alguna ocasión algún framework PHP habrás utilizado en más de una ocasión las propiedades y métodos estáticos:

print CLASE::$propiedad;
print CLASE::metodo();

Pero también habrás observado que al quererlo hacer a través de una instancia, has obtenido un error:

Strict Standards: Accessing static property CLASE::$propiedad as non static

$clase = new CLASE();
print $clase->propiedad;
print $clase->metodo();

Script de ejemplo:

class CLASE
 {
  public static $propiedad = "Hola Mundo";
 
  public static function metodo()
  {
   return self::$propiedad;
  }
 }
 
/* Es válido */
print CLASE::$propiedad;
print CLASE::metodo();

/* 
Regresa un error:

$clase = new CLASE();
print $clase->propiedad;
print $clase->metodo();

*/


En las propiedades y métodos estáticos no utilizaremos $this-> para referenciar a la clase utilizaremos self, como se puede ver en la clase del ejemplo.


lunes, 28 de julio de 2014

Como listar todos los métodos de una clase con PHP


Bienvenid@s, hoy veremos como listar todos los métodos pertenecientes a una clase determinada, para ello utilizaremos la función get_class_methods('class'), esta función retorna un array con todos los métodos que integran la clase.

Veamos un ejemplo. Suponiendo que tenemos una clase llamada numeros con tres métodos, uno(), dos(), tres():

class numeros {

public static function uno()
{
return "uno";
}

public static function dos()
{
return "dos";
}

public static function tres()
{
return "tres";
}

}

Ahora si queremos obtener los métodos de la clase podemos hacer lo siguiente:

foreach (get_class_methods('numeros') as $val)
{
   echo "<p>$val</p>"; 
}


Clase PHP HTML Constructor para construir contenido HTML


Con la clase ModelHtml.php se puede construir contenido HTML de un modo bastante fácil, se pueden incluir la mayorías de etiquetas HTML, incluyendo las últimas etiquetas HTML5. Construir formularios ya que se puede tener acceso a prácticamente todos los elementos disponibles.

Link para descargar php-html-constructor

Métodos disponibles de la clase:

  • add
  • add_audio
  • add_li
  • add_option
  • add_row
  • addslashes
  • add_video
  • b
  • blockquote
  • br
  • button
  • charset
  • checkbox
  • cite
  • close_address
  • close_article
  • close_aside
  • close_audio
  • close_body
  • close_canvas
  • close_center
  • close_details
  • close_div
  • close_figure
  • close_footer
  • close_form
  • close_head
  • close_header
  • close_html
  • close_main
  • close_nav
  • close_section
  • close_script
  • close_select
  • close_style
  • close_table
  • close_ul
  • close_video
  • color
  • date
  • datetime
  • datetime_local
  • dialog
  • entities
  • entities_decode
  • div
  • email
  • favicon
  • figcaption
  • file
  • h1
  • h2
  • h3
  • h4
  • h5
  • h6
  • hidden
  • hr
  • iframe
  • image
  • input
  • i
  • label
  • a
  • link_style
  • mark
  • meta
  • month
  • number
  • object
  • open_address
  • open_article
  • open_aside
  • open_audio
  • open_body
  • open_canvas
  • open_center
  • open_details
  • open_div
  • open_figure
  • open_footer
  • open_form
  • open_head
  • open_header
  • open_html
  • open_main
  • open_nav
  • open_section
  • open_script
  • open_select
  • open_style
  • open_table
  • open_ul
  • open_video
  • p
  • password
  • pre
  • progress
  • radio
  • range
  • script
  • search
  • small
  • span
  • specialchars
  • specialchars_decode
  • strong
  • submit
  • summary
  • tel
  • text
  • textarea
  • title
  • time
  • token
  • url
  • url_encode
  • url_dedoce
  • week

martes, 22 de julio de 2014

PIMF - Framework para el desarrollo de aplicaciones web


PIMF es un Framework PHP para el desarrollo de aplicaciones web.

Proporciona una serie de clase para usos generales útiles en el desarrollo web como clases base para MVC, asignador de datos y clases de utilidad para muchos tipos de análisis de datos y la generación de los mismos.

PIMF provee una aplicación de ejemplo concretamente con un blog que puede ser descargado desde el siguiente enlace https://github.com/gjerokrsteski/pimf-blog-mysql

Web oficial: http://gjerokrsteski.github.io/pimf-framework/

Autor: Gjero Krsteski

Descargar: PIMF Framework

Vista previa de la aplicación blog de ejemplo:


PIMF - Framework para el desarrollo de aplicaciones web




Clase Time Profiler - Obtener el tiempo de ejecución de una función PHP


Con la clase Time Profiler se puede medir el tiempo que tarda en ejecutarse una determinada función.

La clase regresa el resultado de la función y el tiempo que se necesitó para ejecutar la función en cuestión de segundos y milisegundos.

Autor: Tony L. Requena

Descargar: Time Profiler

Código de la clase class.timeprofiler.php


<?php
/*------------------------------------------------------------------------------
** File:            class.timeprofiler.php
** Class:           Time Profiler
** Description:     
** Version:         1.0.1
** Created:         11-Jul-2014
** Author:          Tony L. Requena
** Homepage:        www.phpmyipcam.com 
**------------------------------------------------------------------------------
** COPYRIGHT (c) 2014 Tony L. Requena
**
** The source code included in this package is free software; you can
** redistribute it and/or modify it under the terms of the GNU General Public
** License as published by the Free Software Foundation. This license can be
** read at:
**
** http://www.opensource.org/licenses/gpl-license.php
**
** This program is distributed in the hope that it will be useful, but WITHOUT 
** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
** FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. 
**------------------------------------------------------------------------------
**
** Usage:
** 
    function imprime(){
        sha1(md5("Hello"));
    }
    
    
    function blah($n=1){
     for($i = 0; $i<= $n; $i++){
      $a = $i;
     }
    }
    
    function getContent($url){
        return file_get_contents($url);
    }

    $timer = new TimeProfiler("blah", 500, array(100));
    echo "".$timer->getMicro()." µs (".$timer->getMili()." ms)";
    
    echo "<br />";
    
    $timer = new TimeProfiler("imprime");
    echo $timer->getMicro()." µs (".$timer->getMili()." ms)";

    $timer = new TimeProfiler("getContent",1,array('http://server.sivu.es/testfile.txt'));
    echo $timer->getMicro()." µs (".$timer->getMili()." ms)<br />";
    var_dump($timer->funcOutput()); /*** NEW  NEW NEW **/
**
**------------------------------------------------------------------------------ */

class TimeProfiler{ 
    private $microseconds = 0; 
    public $start = 0; 
    public $function; 
    public $end = 0; 
    public $miliseconds; 
    function __construct($func, $iterations=1, $arguments = NULL){ 
        $this->function = $func; 
        $this->microseconds = 0; 
        $this->start = microtime(true); 
         
        for($n=0;$n<$iterations;$n++){ 
            if($arguments==NULL){ 
                $this->val = call_user_func_array($func,array()); 
            }else{ 
                $this->val = call_user_func_array($func, $arguments); 
            } 
        } 
        $this->end = microtime(true); 
        $this->microseconds = $this->end - $this->start; 
        $this->miliseconds = round($this->microseconds * 1000);
        
        return $this->val; 
     
    }
    function funcOutput(){
        return $this->val;
    }
    function getMicro(){ 
        return $this->function.": ".sprintf('%f', $this->microseconds); 
    } 
    function getMili(){ 
        return $this->miliseconds; 
    } 
}
?>



Clase Upload Files para la validación de subida de archivos


Con la clase Upload Files se puede validar y procesar los archivos que son enviados a través de los formularios.

Los archivos válidos son guardados en un directorio de destino determinado. El archivo subido puede ser eliminado si se requiere esta opción.

Autor: vasinsky

Descargar: Upload Files

Código de la clase Upload.class.php


<?php
   /**
    * @author Vasinsky Igor
    * @email igor.vasinsky@gmail.com
    * @copyright 2013
    *  
    * Class files upload
    * Features: 
    *  -check the validity of the file types 
    *  -check the file size 
    *  -loading files 
    *  -modify the file name
    */    
    /**  Example of use
     * ---------------------------------------------------------------------------
      if(isset($_POST['send'])){
          //Permitted file types
          $validTypes = array('image/jpg','image/jpeg','image/gif','image/bmp'); 
          Upload::validType($validTypes);
          
          //name of input type="file"
          Upload::$index = 'images';
          //Maximum upload size
          Upload::$size = 15000;
          
          //Validation of file types  
          $files = Upload::validate();
          
          //Uploading files to a specified directory
          $result = Upload::uploadFiles($files, 'tmp',1);
          
          echo '<pre>' . print_r($result, 1) . '</pre>'; 
      }      
      
      $ result - two-dimensional array with elementamimi 'valid' (downloaded) and error ('not downloaded')
    * ---------------------------------------------------------------------------
    */

   class Upload{
        /**
         * name of input type="file"
         */ 
        static $index = 'images';
        /**
         * the maximum file size
         */ 
        static $size = 600;
        /**
         * Internal variable storage dopustipyh mime types
         */ 
        static $validType = array();
        
        public function __construct(){
            
        }
        /**
         * Setting mime types of files
         * http://www.spravkaweb.ru/php/pril/mime 
         * @param array  
         *  array('mime/type1', 'mime/type1')
         *  empty array - no restrictions
         */ 
        static public function validType($type){
            self::$validType = $type;
        }
        
        /**
         * Retrieving Data downloadable files
         * @return array
         */  
        static public function getFiles(){
             if(empty($_FILES)){
                
               return false;
             }
             else{
                foreach($_FILES[self::$index]['name'] as $key=>$name){
                    $pathinfo = pathinfo($name);
                    
                    
                    
                    if($pathinfo['basename'] !=''){
                        $filename = $pathinfo['filename'];
                        $ext = $pathinfo['extension'];
                  
                        $hashname = sha1($_FILES[self::$index]['tmp_name'][$key].$pathinfo['basename'].microtime());
                        
                        $errors = array(
                            0=>'',
                            1=>'When the file size exceeded the maximum size that is specified 
                                upload_max_filesize directive configuration file',
                            2=>'Upload file size exceeded the value MAX_FILE_SIZE, specified in the form of HTML',
                            3=>'Uploaded file was only partially',
                            4=>'No file was uploaded',
                            6=>'Missing a temporary folder',
                            7=>'Failed to write file to disk',
                            8=>'PHP-stop downloading the file extension. PHP does not provide a way 
                                determine what extension stop file upload'
                        );
                        
                        $filesdata[] = array(
                                'name'=>$filename,
                                'ext'=>isset($ext) ? $ext : '-',
                                'type'=>$_FILES[self::$index]['type'][$key],
                                'hashname'=>$hashname,
                                'tmpname'=>isset($_FILES[self::$index]['tmp_name'][$key])
                                           ? $_FILES[self::$index]['tmp_name'][$key]
                                           : '-',
                                'error'=>$errors[$_FILES[self::$index]['error'][$key]],
                                'size'=>ceil($_FILES[self::$index]['size'][$key]/1024)
                        );
                    }
                }
                return isset($filesdata) ? $filesdata : false;
             } 
        }
        
        /**
         * Checking validity of uploaded files
         * @return array/bool
         */ 
        public static function validate(){
            if(self::getFiles() === false){
                return false;
            }
            else{
                if(empty(self::$validType)){
                    return self::getFiles();
                }
                else{
                    
                    foreach(self::getFiles() as $k=>$v){
                       if(!empty($v['error'])){
                           if($returnOnlyValidFiles = 1)
                               $files[] = $v; 
                       } 
                       elseif(!in_array($v['type'], self::$validType)){
                           $v['error'] = 'It is not permissible to download a file type: '.$v['type'];
                           $files[] = $v;
                       }
                       elseif($v['size']>self::$size){
                           $v['error'] = 'Unacceptable load a file type '.self::$size .' kb';
                           $files[] = $v;                
                       }
                       else{
                           $files[] = $v;
                       }
                    } 
                    return empty($files) ? false : $files;                 
                }
            }
        }
        
        /**
         * The file upload 
         * @ Param array - then returned Upload :: validate () 
         * @ Param string directory download 
         * @ Param bool 
         * False - use the original file names 
         * True - use the hash of the file name getFiles () element hashname 
         * Use only after stage Upload :: validate ())
         * 
         * @return array/bool
         */ 
        public static function uploadFiles($validate_files, $dir, $rename=false, $prefix=false){

            if(!is_array($validate_files)){
                return false;
            }
            
            if($prefix !== false){
                $validate_files = self::setPrefix($validate_files, $prefix);
            }
            
            
            
            $files['valid'] = array();
            $files['error'] = array();
                
            foreach($validate_files as $k=>$file){
                
                $name = ($rename === false) ? $file['name'] : $file['hashname'];

                if($file['error'] == ''){
                     
                    $file['uploaddir'] = $dir;
                    
                    if(move_uploaded_file($file['tmpname'], $dir.'/'.$name.'.'.$file['ext'])){
                        $file['fullpath'] = $dir.'/'.$name.'.'.$file['ext'];
                        $files['valid'][] = $file;
                    }    
                    else{
                        $file['error'] = 'Не получилось скопировать файл';
                        $files['error'][] = $file;
                    }
                } 
                else{
                    $files['error'][] = $file;
                }
            }
            
            return isset($files) ? $files : false;
        }
        
        /**
         *  Method of modifying the file name - add a prefix
         *  @param array
         *  @param string
         *  return array
         */ 
         public function setPrefix($files, $prefix){
              foreach($files as $k=>$f){
                  $mod_files[] = array(
                                     'name'=>$prefix.'_'.$f['name'],
                                     'ext'=>$f['ext'],
                                     'type'=>$f['type'],
                                     'hashname'=>$f['hashname'],
                                     'tmpname'=>$f['tmpname'],
                                     'error'=>$f['error'],
                                     'size'=>$f['size'],
                                        
                                     );
              }
            
             return $mod_files;
         }
        
        /**
         * Deleting a file from a directory
         * @param string
         * @return bool
         */ 
        static public function deleteFile($pathtofile){
            return (!unlink($pathtofile)) ? false : true;
        }
        
        static public function move_file($pathtofile, $dir, $del = true){
            $pathinfo = pathinfo($pathtofile);
            
            $result = copy($pathtofile, $dir.'/'.$pathinfo['basename']);

            if($del === true)
                Upload::deleteFile($pathtofile);
            
            return $result;
        }
        
        
   }
?>



PHP Random Number Generator - Generador de cadenas aleatorias


La clase PHP Random Number Generator puede generar una cadena aleatoria en base al algoritmo Mersenne Twister.

Se puede generar una cadena de texto aleatoria de una determinada longitud y creada a partir de dígitos o letras en mayúsculas y minúsculas.

La clase también permite la inclusión de una lista de caracteres dados que se agregarán a la cadena generada.

Entre los archivos encontrarás una demostración a través del archivo example.php

Autor: Er. Rochak Chauhan

Descargar: PHP Random Number Generator


PhpRandomNumberGenerator.inc.php

<?php
/**
 * Class to generate random unique string and/or numbers.
 * 
 * @author Rochak Chauhan <rochakchauhan@gmail.com>
 */
class PhpRandomNumberGenerator {

    private $charLimit = 8;
    private $charArray = array();

    function generateNumber() {        
        $bits = $this->charLimit * 5;
        $nos = (int) $bits / 25;
        $random = "";
        for ($i = 0; $i <= $nos; $i++) {
            $random.=$this->getRandomBinaryNumbers();
        }
       $random = chunk_split($random, 5, "#*#");
        //Set default char set
        if (count($this->charArray) < (($this->charLimit)*2) ) {
            $this->setDefaultCharArray();
        }      
        $number = "";
        $tmpArray = explode("#*#", $random);
        foreach ($tmpArray as $ref => $b) {
            $b = bindec($b);
            $b = (int) $b;
            if ($b >= 0) {
                $c = $this->charArray[$b];
                $number.= $c;
            }
        }
        $strlen = strlen($number);
        $diff = $strlen - $this->charLimit;
        if ($diff < 0) {
            $diff = abs($diff);
            $pre = "";
            for ($i = 0; $i < $diff; $i++) {
                $pre.="0";
            }
            $number = $pre . $number;
        }
        $number = substr($number, 0, $this->charLimit);
        return $number;      
    }

    /**
     * Function to set Default Char Array
     */
    private function setDefaultCharArray() {
        $numbersArray = $this->generateNumbersArray();
        $this->charArray = array_merge($this->charArray, $numbersArray);
        $upperCaseArray = $this->generateUpperCaseArray();
        $this->charArray = array_merge($this->charArray, $upperCaseArray);
        $lowerCaseArray = $this->generateLowerCaseArray();
        $this->charArray = array_merge($this->charArray, $lowerCaseArray);        
    }

    /**
     * Function to generate lowercase alphbets array
     * 
     * @return array
     */
    private function generateLowerCaseArray() {
        $return = array();
        for ($i = 97; $i <= 122; $i++) {
            $return[] = chr($i);
        }
        return $return;
    }

    /**
     * Function to generate uppercase alphbets array
     * 
     * @return array
     */
    private function generateUpperCaseArray() {
        $return = array();
        for ($i = 65; $i <= 90; $i++) {
            $return[] = chr($i);
        }
        return $return;
    }

    /**
     * Function to generate Numbers array
     * 
     * @return array
     */
    private function generateNumbersArray() {
        $return = array();
        for ($i = 48; $i <= 57; $i++) {
            $return[] = chr($i);
        }
        return $return;
    }

    /**
     * Function to Generate Randaom Binary Numbers (between 25-30 chars)
     * 
     * @return string   
     */
    private function getRandomBinaryNumbers() {
        $rand = mt_rand();
        return decbin($rand);
    }

    /**
     * Function to set Char Limit 
     * 
     * @param int $char_limit
     * @return void
     */
    function setCharLimit($char_limit) {
        $this->charLimit = $char_limit;
    }

    /**
     * Function to set CharArray
     * 
     * @param int $charArray
     * @return void
     */
    function setType($charArray) {
        $this->charArray = array_merge($this->charArray, $charArray);
    }

}

?>



HtmlForm PHP 5




Autor: Sebastian Schlapkohl

Descargar: HtmlForm PHP 5

A través del modelo HtmlForm PHP 5 se pueden crear, validar y procesar formularios HTML.

Proporciona una serie de clases que contienen la mayoría de tipos de elementos HTML que se pueden utilizar, proporcionando una interfaz fluida que permite definir muchos aspectos de cada elemento, incluyendo las reglas de validación.

También contiene la opción de poder validar el formulario con Javascript, muy útil y aconsejable hacerlo antes de enviar los datos al servidor.

Entre los archivos de descarga se encuentra index.php desde el cual podrá ver en una demo de como utilizar HtmlForm PHP 5.




lunes, 12 de mayo de 2014

ip2Country - Clase PHP para obtener el continente, código del país y la dirección IP.


ip2Country es una clase que te permite obtener el continente, código del país y la dirección IP de los visitantes web, útil para llevar un control o estadísticas de los usuarios que visitan un sitio web.

Autor: Anish Karim C

Descargar: ip2Country



Para ver el ejemplo,  ejecutas el archivo index.php que viene entre los archivos descargados ...

<?php
error_reporting(E_ALL);
include 'ip2Country.class.php';
$region = new ip2country();
?>
<html>
  <body>
    <h3>ip2Country</h3>
    <h4>Tu estás en:  <i><?php echo $region->getRegion(); ?></i></h4>
 <h4>El código de tu país es: <?php echo $region->countryCode; ?></h4>
 <h4>Tu dirección IP es: <?php echo $region->getIpAddress(); ?></h4>
  </body>
</html>


Encryption Class BCA - Clase para cifrar y descifrar datos utilizando el cifrado Rijndael 256


Encryption Class BCA puede cifrar y descifrar datos utilizando el cifrado Rijndael 256. 

Autor:  Gabriel Almeida

Descargar:  Encryption Class BCA

Se puede tomar una cadena de datos y cifrarla a través de una clave secreta, incluirle un separador e indicar el tipo de algoritmo deseado, los recomendados son sha384, sha512, ripemd256, ripemd320, whirlpool o salsa20. El resultado cifrado se devuelve codificado con el algoritmo Base64.

La clase también puede hacer lo contrario, es decir, descifrar una cadena de datos previamente cifrados con la misma clase utilizando la misma clave secreta.

Ejemplo de uso ...


<?php


# - Incluir la clase 
 require_once('Encryption.php');

# - clave secreta
 $secureKey   = 'SECRET_KEY';
# - Nombres de los algoritmos de encriptación; Algoritmos recomendados: sha384, sha512, ripemd256, ripemd320, whirlpool o salsa20; 
# - http://www.php.net/manual/pt_BR/function.hash.php#104987
 $typeEncryption = 'sha512';
# - Separador para la cadena encriptada; Permitidos: !@#%&*=+/~?
 $separator   = '=';


# - Empezar la clase incluyéndole los parámetros
 $encrypt = new Encryption( $secureKey, $typeEncryption, $separator);

# - Cadena a encriptar
 $encodeTXT = 'password12345678';


# - Encriptar
 $crypt = $encrypt->encode( $encodeTXT );
# - Desencriptar
 $decrypt = $encrypt->decode( $crypt );


# - Mostrar el texto encriptado
 print('<p>Encriptado: ' . $crypt . '</p>');


# - Mostrar el texto desencriptado
 print('<p>Desencriptado: ' . $decrypt . '</p>');
?>


SlimDb PHP - Clase para conectar a diferentes tipos de gestores de bases de datos usando PDO


SlimDb es una clase que te permite conectar a diferentes tipos de gestores de bases de datos usando las extensiones PDO.

Autor:  Marcelo entraigas

Descargar:  SlimDb

En la clase puedes incluir a través de parámetros de configuración el driver al que se debe llamar. Soporta operaciones como ejecutar consultas SQL arbitrarias usando comandos preparados, recuperar resultados en arrays, obtener el último identificador de registro de la tabla insertada u obtener cualquier información de una tabla.

Puedes realizar operaciones CRUD comunes como CREATE, READ, UPDATE y DELETE a través de una lista de parámetros que definen las tablas, campos, valores de los campos, las condiciones, etc.

En el archivo README.md puedes encontrar distintos ejemplos de como utilizar la clase SlimDb para conectar y generar consultas.

 




viernes, 9 de mayo de 2014

Simple HTML DOM Parser - Clase para extraer y modificar el contenido HTML


Simple HTML DOM Parse es una clase que te permite extraer y modificar el DOM HTML de un modo muy fácil, para su uso es requerida una versión PHP 5 o mayor. Puedes trabajar accediendo a  los selectores y atributos como si se tratase del framework jquery.


A continuación veremos algunos ejemplo de uso:

1 - Buscar el valor del atributo src de todas las imágenes del sitio web ...


require "simple_html_dom.php";
/* Sitio a analizar */
$html = file_get_html('https://www.google.com/search?hl=es&site=imghp&tbm=isch&source=hp&biw=&bih=&q=google&btnG=Buscar+por+imagen');

// Buscar todas las imágenes
foreach($html->find('img') as $element)
       {
    //Muestra el valor del atributo src de cada imagen
       echo "<p>".$element->src."</p>";
    }



2 - Buscar el valor del atributo href de todos los links del sitio web ...


<?php
require "simple_html_dom.php";
/* Sitio a analizar */
$html = file_get_html('https://www.google.com/');

// Buscar todas los links
foreach($html->find('a') as $element)
       {
    //Muestra el valor del atributo href de cada link
       echo "<p>".$element->href."</p>";
    }


3 - Buscar el contenido del atributo content de las metaetiquetas ...


require "simple_html_dom.php";
/* Sitio a analizar */
$html = file_get_html('https://www.google.com/');

// Buscar todas la etiquetas meta description
$descripcion = $html->find('meta[name="description"]');

/*$descripcion es un array, por eso accedemos al index 0,
normalmente un documento html sólo tiene una metaetiqueta description */
echo $descripcion[0]->content;


4 - Modificar el DOM HTML ...


require "simple_html_dom.php";
/* HTML a modificar */
$html = str_get_html('<div id="contenedor"></div>');

/* Buscar el id y agregarle texto */
$html->find('div[id="contenedor"]', 0)->innertext = "Hola Mundo";

/* Mostrar el resultado */
echo $html;


jueves, 8 de mayo de 2014

PHP Image cURL - Clase para obtener información de imágenes remotamente


La Clase PHP Image cURL te permite obtener información de imágenes remotamente con cURL emulando la función getimagesize().

Descargar: PHP Image cURL

Se puede recuperar información de un archivo de imagen alojado en un servidor remoto mediante la extensión cURL enviando peticiones HTTP al servidor.

No sólo recupera los metadatos igual que la función getimagesize() original, sino que también devuelve el tamaño del archivo de imagen.

Esta clase es útil cuando se requiere información de las imágenes alojadas en servidores remotos para comprobar el tamaño del archivo de imagen, las dimensiones y el tipo de extensión de imagen para posibles restricciones de publicación. 

Para el correcto funcionamiento de la clase se requiere:

    * PHP 5.4+
    * Activar la extensión GD
    * Activar la extensión cURL 

Al descargar el fichero, podrás testearlo a través del archivo test_img_info.php, que si tu servidor cumple con todos los requerimientos citados anteriormente, regresará un array con la información de la imagen remota ...




miércoles, 7 de mayo de 2014

Clase PHP Image Editor - Edición de imágenes


Autor: Trev Tune

PHP Image Editor permite editar y crear imágenes mediante plugins.

La clase principal puede cargar y guardar imágenes en los formatos PNG, GIF o JPEG.

Descargar: PHP Image Editor

La clase principal puede interactuar con otras clases de plugins que pueden proporcionar un extra de funcionalidad para la manipulación de las imágenes.

Actualmente las clases de plugin pueden realizar operaciones de imagen como lanzar, cambiar el tamaño, añadir texto y aplicar filtros como afilar, relieve, negar, gray_scale, brillo, contraste, colores, detección de bordes, boceto, y el efecto de la sepia, que como se comentó anteriormente pueden ser completados añadiéndole más funcionalidad.

Nosotros vamos a ver un ejemplo de como utilizar PHP Image Editor con la clase plugin que viene por defecto, el código del plugin lo puedes ver entrando en la carpeta plugins y abriendo el archivo, SE_effects.php, que contiene una serie de métodos ya predefinidos como afilar, relieve, etc, ya comentado anteriormente.

Por ejemplo, como imagen voy a utilizar la siguiente imagen la cual he guardado en la carpeta donde tengo alojado PHP Image Editor ...





     
    include 'image_editor.php';
    //Iniciamos la clase
      $se=new SImEdi('bootstrap.jpg');
    //Cargamos la clase plugin con los efectos: SE_effects.php
        $se->plugin('effects');
    //Aplicamos un efecto blur a la imagen
       $se->effects->blur(50);
    //Guardamos la imagen
       $se->save('bootstrap-blur.jpg');

El resultado de la imagen es un efecto blur al 50% ...





Todos los efectos son métodos que podéis ver en el archivo que se encuentra en la ruta plugins/SE_effects.php, ahora veremos como aplicar un efecto sepia ...


    
         include 'image_editor.php';
    //Iniciamos la clase
      $se=new SImEdi('bootstrap.jpg');
    //Cargamos la clase plugin con los efectos: SE_effects.php
        $se->plugin('effects');
    //Aplicamos un efecto sepia
    $se->effects->sepia(); //Este método no acepta parámetros ver la clase SE_effects.php
    //Guardamos la imagen
    $se->save('bootstrap-sepia.jpg');





Ok, como podemos ver estamos aplicando efectos a la imagen de un modo bastante práctico, ahora vamos a ver otro efecto llamado emboss este efecto al igual que el anterior no acepta parámetros ...


     include 'image_editor.php';
    //Iniciamos la clase
      $se=new SImEdi('bootstrap.jpg');
    //Cargamos la clase plugin con los efectos SE_effects.php
        $se->plugin('effects');
   //Aplicamos un efecto emboss
       $se->effects->emboss(); //Este método no acepta parámetros ver la clase SE_effects.php
    //Guardamos la imagen
       $se->save('bootstrap-emboss.jpg');






Todos los métodos para efectos disponibles en el plugin SE_effects.php son los siguientes ...

blur($level)
sharpen($level)
emboss()
negate()
gray_scale()
brightness($level)
contrast($level)
colorize($red,$green,$blue)
edge()
sketch()
sepia()




martes, 6 de mayo de 2014

Clase PHP MPEG Audio Data Extractor (lectura de metadatos de archivos MPEG)


Esta clase puede analizar y extraer información de los metadatos de los archivos MPEG.

Descargar  mpeg-audio-tags-meta-2014-05-04

Se puede analizar vídeo audio MPEG y extraer información sobre el stream y las etiquetas.

La clase es compatible con los formatos MPEG 1 y MPEG 2 con etiquetas en los formatos ID3v1, ID3v2, VBR, CBR. Es compatible con audio layer 1, layer 2 y layer 3 (MP3).

Puede extraer las etiquetas de metadatos como el nombre de la canción, duración, nombre del artista, tasa de bits, álbum, frecuencia de muestreo, el año, la versión mpeg, comentario, versión del layer, los canales de género, modo, etc.

Para ver un ejemplo de como utilizar esta clase, una vez descargado y extraído, copia una archivo de audio mp3 y guárdalo en la misma carpeta donde se aloja el proyecto, luego abre con un editor de código el archivo index.php que viene como ejemplo e incluye el nombre de la canción en la siguiente línea ...

$file = dirname(__FILE__)."/Bob Marley - Bad boys.mp3"; 

Al ejecutar en el navegador el script index.php debemos ver un array con todas las propiedades y metadatos del archivo de audio mp3 ...


En el archivo README.md puedes encontrar todas las propiedades que puedes utilizar en esta clase.