La W3C esta trabajando en el draft del nivel 2 en la especificación XMLHttpRequest, también conocido como AJAX 2.

Entre las principales nuevas características del segundo nivel de esta especificación se destaca:

* Tracking progress. El desarrollador tendra metodos y funciones para obtener la cantidad de bytes enviados al servidor y cuanto tiempo remanente falta para terminar de procesar.
* File upload. Esta nueva especificación soporta una de las grandes debilidades de Ajax, que es la de subir archivos. Gracias a la File API que tambien esta desarrollandose se tendrán nuevas funciones para subir archivos.
* Cross-Domain AJAX requests. Otra de las grandes debilidades de AJAX sera superada con esta nueva especificación, ya que se podrá realizar peticiones entre diferentes dominios.

Cabe destacar que esta especificación esta en draft, pero vale la pena ir estudiandola: http://www.w3.org/TR/XMLHttpRequest2/

En este Post vamos a ver como podemos  orientar a objetos nuestro código JS  y como organizarlo apropiadamente.

Crear un objeto:

var myObject = new Object();

También podemos usar la forma literal:

var myObject = {};

Ahora vamos a ver como podríamos agregar una propiedad:

var myObject = {

name: ‘Pepe’;

}

Vamos a ver como agregar dos métodos a nuestro objeto:

var myObject = {

name : ‘Pepe’,

setName : function(name){

this.name = name;

},

getName : function(){

return this.name;

}

}

Y así tenemos creado nuestro objeto en JS. Por último vamos a ver como extender nuestro objeto con jQuery:

var extendedObject = function() {

…
// En el caso que queramos sobreescribir un método lo hacemos aquí

…

};

var p = extendedObject.prototype;
$.extend(p, myObject);

La función $.extend de jQuery lo que hace es extender al primer objeto que se pasa como parámetro ( en este caso p) con los otros objetos que se colocan después separados por comas. Finalmente para acceder a cualquier metodo lo haría de la siguiente forma:

var myNewObject= new extendedObject();

alert(myNewObject.getName());

En el próximio post vamos a ver como podemos estructurar este código de una mejor manera para sacarle mayor provecho a la OOP con JS.

En mi post anterior vimos como crear una aplicación e integrarla con una aplicación realizada en symfony.

Siguiendo con esta temática (y suponiendo que ya tienes creada la aplicación y descargada la clase facebook.php ed los repositorios de facebook) vamos a implementar un formulario para postar mensajes en lo muros (Wall) de los usuarios de nuestra aplicación.

Comenzaremos creando una pagina que contenga un formulario simple.
Agregamos las rutas del formulario y del procesador del form en le routing.yml:

form:
  url:   /form/
  param: { module: form, action: form }

process_form:
  url:   /process-form/
  param: { module: form, action: processForm }

(recordar cambiar el modulo por el que estemos desarrollando)
En el action de nuestro modulo agregamos la acción que muestre este formulario

public function executeForm(sfWebRequest $request)
{
}

Simple ¿no?

Ahora en el Template formSucces.php:

<form action="<?php echo url_for("@process_form")?>" method="post">
	<textarea name="message" id="message">
	<input type="submit" name="submit" value="Send" />
</form>

Luego agregamos en el action la función que procesa el formulario:

public function executeProcessForm(sfWebRequest $request)
{
  if($request->isMethod('post'))
  {
    $message = $request->getParameter('message');
    try {
      $this->facebook = new Facebook(array(
          'appId'  => "Your APP ID",
          'secret' => "Your APP Sectret",
          'cookie' => true,
      ));
      $this->fbSession     = $this->facebook->getSession(); // the session validated, get the object and token
      $post['access_token']  = $this->facebook->getAccessToken();
      $post['message']         = $message;
      $post['privacy']            = "{'value': 'ALL_FRIENDS'}";  

      $sendPost = $this->facebook->api('/me/feed', 'post', $post);
      $this->message = 'Your post was sent successfully';

    } catch (FacebookApiException $e) {
            	error_log($e);
    }
  }
}

Aquí nos faltaría el template que debería mostrar la función proccesForm() en la que podríamos mostrar un mensaje de éxito/error del envio. Pero básicamente estos son lo pasos.

Ejemplos dialog

Cuando se necesita algo mejor para correr scripts en consola es bueno usar DIALOG

ejemplos:

crear menu:

dialog --backtitle "Consola Administrativa" --nocancel --menu "Elija una opcion"  15 40 7 1 backup 2 "asegurar sitio" 3 Restore  4 Acceso 5 estado 6 salir 2

usar simpre el parametro = ” –stdout ” para poder tomar el retorno.

esto se vera asi:

el retorno de este menu se puede tomar asi:

DATA=´dialog --backtitle "Consola Administrativa" --nocancel --menu "Elija una opcion"  15 40 7 1 backup 2 "asegurar sitio" 3 Restore  4 Acceso 5 estado 6 salir 2´

echo $DATA;

———————————————————————————————–

#!/bin/bash

DATA=´dialog --backtitle "Consola Administrativa" --nocancel --menu "Elija una opcion"  15 40 7 1 backup 2 "asegurar sitio" 3 Restore  4 Acceso 5 estado 6 salir 2´

echo $DATA ;

nota: DATA lleva el valor del menu y la variable $? lleva 0 o 1 si aceptas o cancelas.
———————————————————————————————–

cajas de mensajes

dialog  --title 'Advertencia' --backtitle "Consola Administrativa" --stdout --yesno "n n crear BACKUP  del sitio  n ¿esta  seguro?"   14 40

retorno:

if [ $? -ne 0 ]; then  #  variable $? lleva el valor de retorno 1 para SI y 0 para NO

iniciarbackup;

 else

 salirbackup;

 fi

—————————————————————————————————

Mensajes

dialog --msgbox "Operacion terminada" 5 30

simple. se acepta y continua la ejecucion.

————————————————————————————————–
Gauges

dialog --gauge "Total completado" 6 30 20

recuerda que se debe refrescar para cambiar el valor.

#!/bin/bash

for var in 0 10 30 50 70 80 90 ;

do sleep 1; echo $var; done | dialog --gauge "Total completado" 6 30 0

————————————————————————————————————————–

Archivos

FILE=`$DIALOG --stdout --backtitle "Consola Administrativa" --title "Seleccione un archivo de backup" --fselect "$HOME/backup/" 15 100`

—

if [ $? = 1 ]; then

iniciarbackup

 fi

echo $FILE;   # path completo del archivo seleccionado.

——————————————————————————–

crear backup

#!/bin/bash

hora=$(date +"%H-%M-%S")

fecha=$(date +%d_%m_%Y)

backup=$fecha-$hora

tar cf $backup.tar *       # crea backup

tar cf $backup.tar * --exclude /carpeta-a-excluir   # crear backup con exclusion de una carpeta.

———

fin.

saludos.

Existen numerosas fórmulas para el cálculo de distancias entre dos puntos cardinales.

Si queremos ver las distancias entre un punto cardinal y otro podemos utilizar alguna de las fórmulas para el cálculo de la distancia ortodrómica [1][2].
Si poseemos una tabla en una base de datos relacional con ciudades y sus puntos cardinales podemos calcular la distancia desde una de ellas al resto utilizando SQL.
La consulta quedaría como sigue:

SELECT c.*,
(2 * ATAN2(
   SQRT(
    (SIN((43.239  * PI( ) /180 - c.latitude * PI( ) /180) / 2) *
      SIN((43.239  * PI( ) /180 - c.latitude * PI( ) /180) / 2))
		+
     COS (43.239 * PI( ) / 180 ) * COS (c.latitude * PI( ) /180) *
     (SIN((-73.597 * PI( ) /180 - c.longitude * PI( ) /180) / 2) *
      SIN((-73.597 * PI( ) /180 - c.longitude * PI( ) /180) / 2)
    ),
    SQRT(
      1 - (
       (SIN((43.239  * PI( ) /180 - c.latitude * PI( ) /180) / 2) * 
        SIN((43.239  * PI( ) /180 - c.latitude * PI( ) /180) / 2))
	+ COS (43.239 * PI( ) / 180) * COS (c.latitude * PI( ) /180) *
       (SIN((-73.597 * PI( ) /180 - c.longitude * PI( ) /180) / 2) * 
        SIN((-73.597 * PI( ) /180 - c.longitude * PI( ) /180) / 2))
    )
   )
) * 3959) AS miles
FROM ciudades c
WHERE latitude IS NOT NULL AND longitude IS NOT NULL
ORDER BY miles ASC;

En este ejemplo asumimos que poseemos nos interesan las distancias desde una ciudad que se encuentra en el punto de latitud 43,239º y lingitud -73,597º. Y retornamos el valor en millas, por lo eso el factor 3959 que es el radio de La Tierra en millas, si deseamos las distancias en kilómetros debemos reemplazar ese factor por 6353.

1.Distancia Ortodrómica
2.Calculador de distancias en javascript

Highcharts[1] es una herramienta muy útil para realizar gráficos en javascript. Se configura utilizando json y renderiza los gráficos utilizando SVG.
Para facilitar su uso con Symfony y no llenar nuestro template de lógica o harcoding podemos utilizar una librería al estilo de HighCharts Wrapper[2]. Que es justamente eso: Un Wrapper, un envoltorio que nos permite encapsular la configuración de Highcharts.
Lo que nosotros necesitamos es crear distintos tipos de gráficos, para los cuales existen ciertas tareas básicas que vamos a hacer para cada uno de ellos. No va a ser lo mismo construir un gráfico de tortas, que un gráfico de lineas.
Para lograr cohesión y comodidad para reutilizar la construcción de gráficos vamos a implementar el Patrón de Diseño Abstract Factory[3].
De esta manera tenemos una clase abstracta que posee los métodos getChart() y getFactory().
El primer método es abstracto y esta destinado a ser sobreesctrito por las clases Factory concretas; el segundo es un método estático y que en base a un parámetro indicando el tipo de gráfico nos devuelve la clase Factory indicada para lo que pedimos.
La clase abstracta nos quedaría como sigue:

//AbstractChartFactory.class.php
abstract class AbstractChartFactory
{
    public static function creatChartFactory($chartType)
    {
        $factoryRet = null;
        switch($chartType)
        {
            case 'line':
                $factoryRet = new LineChartFactory();
                break;
            case 'pie':
                $factoryRet = new PieChartFactory();
                break;
        }
        return $factoryRet;
    }
    abstract public function getChart($container,$params = array());
}

Como ejemplo creamos una clase Factory concreta que recibe el nombre del div donde se renderiza el chart y los parametros para crearlo.
El ejemplo es para un gráfico de lineas.

class LineChartFactory extends AbstractChartFactory
{
    public function getChart($container,$params = array())
    {
        $oChart = new CHCChart($container);
        $oSerie = new CHCSeries();
        $oSerie->setType('line');

        if(key_exists("chart_title", $params))
            $oChart->setTitle($params['chart_title']);
        if(key_exists("serie_name", $params))
            $oSerie->setName($params['serie_name']);

        if(key_exists("serie_data", $params))
            $oSerie->addDataSerie($params['serie_data']);

        if(key_exists("xaxis_categories", $params))
            $oChart->setXAxis
                 ->setCategories($params['xaxis_categories']);

        $oChart->addSerie($oSerie);
        return $oChart;
    }
}

Creadas las clases las podemos utilizar en un action de la siguiente forma:

//Parametros para el Factory
$ops = array(
     "char_title" => "Gráfico de líneas"
     "serie_data" => array(55,22,55,33,55,)
);
//Utilizamos el factory
$oChart = AbstractChartFactory::creatChartFactory('line')
                         ->getChart("line-chart-div", $ops);
//Pasamos el gráfico al template
$this->graph = $oChart->getDisplay();

Ahora en el template solo nos queda mostrar el json y javascript generados.

<?php
echo $sf_data->getRaw('graph);
?>

Este conjunto de clases se puede extender mucho más, para una mayor cantidad de tipos de gráficos y también para la obtención de datos de nuestra base de datos.

Referencias utilizadas.
1. HighCharts
2. HighCharts Wrapper
3. Abstract Factory Pattern

facebook-php-sdk es una alternativa oficial para conectar nuestra aplicación con Facebook.com utilizando php.
Para comenzar debemos registrar una aplicación Facebook. Una vez que allas llenado la información básica de la aplicación, dirígete a “Facebook Integration” y especifica la “Página de trabajo” y “Canvas URL”, la dirección donde esta tu aplicación. Esta dirección debería ser preferentemente accesible desde fuera, pero también puede usar una dirección local para el desarrollo y luego cambiar por la de producción.

Para la integración utilizaremos la clase oicial de Facebook escrita en php (http://github.com/facebook/php-sdk/).

Colocamos los archivos descargados en la carpeta lib del proyecto.

Colocamos en el archivo app.yml los datos que nos genera facebook para nuestra aplicación.

facebook_app_id: xxxxxxxxxxxxxxx
facebook_secret: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
facebook_api_id: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Para este ejemplo se crearon dos direcciones en el archivo routing.yml

app_init:
  url:   /app/
  param: { module: app, action: initFacebookSession }

app_home:
  url:   /app/home/
  param: { module: app, action: home }

luego, en el action declaramos as siguientes acciones.

class appActions extends sfActions
{
	public $fbSession;

    public function preExecute()
	{
	    $this->facebook = new Facebook(array(
          'appId'  => sfConfig::get('app_facebook_app_id'),
          'secret' => sfConfig::get('app_facebook_secret'),
          'cookie' => true,
        ));
        $this->fbSession = $this->facebook->getSession(); // the session validated, get the object and token

	}

	/**
	 * Executes index action
	 *
	 * @param sfRequest $request A request object
	 */
	public function executeIndex(sfWebRequest $request)
	{
	    $this->forward('app', 'initFacebookSession');
	}

	public function executeHome(sfWebRequest $request)
	{

        $this->facebook_user = null;
        $this->offerts = array();
        if(!$this->fbSession)
        {
            $this->forward('app', 'initFacebookSession');
        }
        else{
            try {
                $this->facebook_user = $this->facebook->api('/me');
                $this->uid = $this->facebook->getUser();
                $this->getUser()->setAttribute('facebook_user', $this->facebook_user);

                }

            } catch (FacebookApiException $e) {
                error_log($e);
            }
        }
	}

    public function executeInitFacebookSession(sfWebRequest $request)
    {
        if(!$this->fbSession)
        {
            $loginUrl = $this->facebook->getLoginUrl(array(
                'canvas' => 1,
                'fbconnect' => 0,
                'display' => 'page',
                'cancel_url' => '',
                'return_session'  => 1,
                'next' => sfConfig::get('app_facebook_app_url').'dashboard/'
            ));
            echo "top.location.href = '" . $loginUrl. "';";
        }else{
            $this->redirect('@app_home');
        }

        return sfView::NONE;
    }
}

 #!/bin/bash
 iptables --flush
 iptables --table nat --flush
 iptables --delete-chain
 iptables --table nat --delete-chain

  echo 1 > /proc/sys/net/ipv4/ip_forward

  INTERNAL=eth0

  EXTERNAL=ppp0

  iptables -t nat -A POSTROUTING -o $EXTERNAL -j MASQUERADE
  iptables -A FORWARD -i $INTERNAL -o $EXTERNAL -m state --state RELATED,ESTABLISHED -j ACCEPT
  iptables -A FORWARD -i $INTERNAL -o $EXTERNAL -j ACCEPT

Aveces queremos escuchar música con algún equipo remoto, así que se me ocurrió
hacer algo básico de como escuchar música con un par de scripts php.

Aqui les dejo mi experiencia

Es muy simple y funciona bien.

—–
1- instalar primero

sudo apt-get install mpg123

2- descargar ejemplo

http://www.excedesoft.com/blog/wp-content/uploads/2010/10/reproductor-php.zip

3- darles permiso de ejecucion
ojo dentro de la carpeta donde descomprimieron el zip.
sudo chmod -R 777 *

4- pongan musica en formato mp3 dentro de la carpeta mp3

5- listo para usar.

——————————–

algunos tips que se utilizaron en este mini reproductor :

//cargar todos los archivos de una carpeta

    foreach(glob("lib/*.php") as $class_filename) {
        require_once($class_filename);
    }

—–

//si el archivo es mp3
   if (preg_match('/.mp3/i', $file)) {
      $data[] = $file ;
   }

–

// ejecutar bash para escuchar un mp3

exec("mpg123  -q $song > /dev/null 2>&1 &");
nota: con "> /dev/null 2>&1 &" evitamos esperar el retorno.

//matamos el proseso mpg123
system("killall mpg123 ");

//buscamos el proceso mpg123
  exec('ps x | grep mpg123',$out);

// y nos fijamos que archivo esta ejecutando
if(substr_count($out[0], $archivoListado){
//algo
}

—-

Nota: mpg123 es muy avanzado, aqui solo se una el 1% del poder.

saludos !!!