Tienda online a medida y servicios web

Esta tienda online de una pastelería andaluza está hecha “de cero” como una aplicación PHP + MySQL con un diseño y maquetación en XHTML + CSS de Joan Carles Muñoz y una gestión de la arquitectura de la información y posicionamiento de Massimo Grani.

Entre las opciones que posibilita el hacer una aplicación a medida para construir tu tienda online, podemos encontrar la libertad de hacer las cosas a nuestra manera, en este caso era necesario porque los mecanismos de generación de datos de los productos eran dependientes de herramientas externas, es decir, los datos llegaban desde servicios web que podrían tener varias categorías y subcategorías, cada producto tiene diferentes campos, entre los que cabe destacar el precio por litro o kilo o unidad, que tiene diferentes formas de calcularse a la hora de gestionar los pedidos y el stock.

Los stocks además son controlados por medio de llamadas al software residente en la tienda física, en el ordenador del administrador que recibe los pedidos pudiendo corregirlos antes de procesarlos y enviarlos, comunicando los cambios directamente a la web que refleja la información para que el usuario final pueda estar informado.

Entre las tecnologías usadas podemos destacar:

  • AJAX para gestión de stock, carrito, pedidos, etc.
  • Cuentas de diferentes roles, que deben ser confirmadas por el software del administrador para ser válidos en la web, por ejemplo, un tipo de usuario distribuidor puede realizar pedidos de más cantidades,etc. y para eso necesita permisos especiales, estas comprobaciones de usuario se realizan con servicios web
  • Scripts automatizados y meta-programación: cuando se administran contenidos multimedia se pre-configuran para que la información que esté asociada a ella como meta-etiquetas, thumbnails, etc., tengan cabida en su contexto, hay un seguimiento en el back-end para que el administrador lo tenga todo más fácil
  • El front-end dispone de varios efectos realizados en la maqueta, se pueden especificar diferentes temas para la tienda
  • etc

iPasteleria :: app web 2.0

Crear una aplicación productiva y social para iOs con interfaz web

En este artículo cuento mi experiencia de creación de la aplicación de iOs TimeBox ,desde el estudio de mercado, diseño, y elaboración de la interfaz gráfica  hasta la programación, creación de la base de datos y la aplicación web para redes sociales.

Lo primero que debemos hacer es tener claro qué tipo de aplicación queremos crear, para eso hay que tener una buena idea, y si la tenéis pero la aplicación ya está hecha, entonces comprar/bajaros todas las aplicaciones que han implementado vuestra idea y estudiarlas para encontrar en qué fallan, cómo las podéis mejorar y combinar, es decir, encontrad una motivación para programar, porque esto es duro amigos jeje (más…)

Persistencia de datos en iOS y Google Web Toolkit

En esta tercera entrega se explica brevemente como crear un modelo de datos usando XCode (internamente la gente de la manzana se ha apropiado de SQLite para hacerlo, han aprendido de la comunidad otra vez,al igual que en la época NeXT jeje) y cómo crear un servidor en la Google App Engine con las herramientas de Google Web Toolkit que nos proporcionará mediante servicios web la comunicación con una base de datos externa que desplegará datos a todos los dispositivos…lo que quiere decir es que puedes replicar un cambio desde cualquier lugar hacia todos a la vez de forma atómica…apasionante no?
Como no todo en esta vida es un camino de rosas, tratar con punteros y tipos de datos complejos tiene sus cosas, en XCode, o mejor dicho, con la versión de Objective C privativa que usamos para compilar nuestras aplicaciones para los dispositivos, tratar con la memoria es como jugar con granadas, desde que lanzas la granada al aire (reservas memoria) hasta que la recoges (liberas memoria), la parábola que surca en el aire podría ser un tanto extraña, también puede perderse la granada o ser reemplazada, meterse entre nubes o chocar con un avión que pasa jaja…con lo cual, nuestra tarea consiste en tratarla como a una mujer,delicadamente…para que no nos explote en la cara…Jugando con la memoria
Conceptos básicos para almacenar datos en iOS:

Core Data Foundation

  • Es un framework que garantiza la persistencia de los datos de nuestra aplicación
  • Genera una abstracción con clases que facilitan la implementación final del almacenamiento
  • Conecta la parte lógica con el modelo físico (ficheros, etc.)

Core Data Stack

  • El objeto que utilizaremos para gestionar colecciones de objetos es el Managed Object Context, también conocido en la jerga NeXT como NSManagedObjectContext, y representa el espacio de un único objeto, es decir, vamos  a utilizar este objeto para recuperar todo lo que tiene que ver con una entidad (una entidad es una tabla de la base de datos, también puede contener atributos en relaciones cuyos tipos sean otras entidades o tablas)
  • Con Managed Object Model (esquema de base de datos) guardaremos una colección de descripciones de entidades (nombres de tablas) pertenece a la clase NSManagedObjectContext  que relaciona Managed Object Context con el siguiente objeto que hace de puente:
  • Persistent Store Coordinator: guarda una colección de almacenes (Persistent Object Stores)

    en un conjunto de ficheros de datos persistentes (los ficheros de la base de datos, como en MySQL), su clase es NSPersistentStoreCoordinator y asocia los objetos de la aplicación con los registros de la BD.

Guía de uso del Modelo de Datos de iOS:

  1. Para hacer una consulta primero necesitamos crear las tablas, para ello lo que hacemos es crear un proyecto de tipo datos o bien añadimos un fichero al actual proyecto que sea XCode -> Core Data -> Data Model, en la pantalla de creación de entidades añadimos una tabla o entidad y la llamamos “Event”, por ejemplo. Dentro añadimos sus atributos con distintos tipos. Veréis que podéis usar un tipo “Transformable” que sirve para guardar Arrays, siempre y cuando los tipos que guarde el array sean soportamos por el protocolo del modelo de datos, además podemos crear relaciones como atributos que se conectan con otras entidades, aunque esto es más complejo, por ahora sólo veremos los casos simples. (ver más información >>)
    Podéis ver que el editor trae un soporte para la vista de un bonito Diagrama de Entidad/Relación de nuestra BD.
    Una vez creado el modelo vamos a New file -> Core Data -> NSManagedObject subclass (si lo que queremos es una clase que se encargue de realizar todas las operaciones setter & getter por nosotros y así asociemos el contenido al modelo de datos fácilmente con funciones, aunque también podemos hacerlo aún más automático con un framework como este: Fremont)
  2. Para crear objetos es necesario invocar a NSEntityDescriptor con el tipo de objeto y el contexto, veamos un ejemplo:(os recomiendo siempre escribir el código el inglés ;) . Supongamos que nuestra tabla (modelo de datos) event tiene los campos, longitud y latitud de tipo Float, un título (NSString -> String en Modelo de Datos), y una fecha de tipo date:
    //Crear y configurar una instancia de una entidad Event
    - (void) createEvent {
    Event *event = (Event *) [NSEntityDescription insertNewObjectForEntityForName:
    @"Event" inManagedObjectContext: managedObjectContext];
    //Crear un tipo de dato coordenada para mapas de google, así nos acostumbramos a usarlos:
    CLLocationCoordinate2D coordinate = CLLocationCoordinate2DMake(37.123123, -3.321321);
    //Ahora lo tenemos muy fácil ,sólo tenemos que usar los setters y getters generados por XCode:
    [event setLatitude:[NSNumberWithFloat:coordinate.latitude]];
    [event setLongitude:[NSNumberWithFloat:coordinate.longitude]];
    [event setCreationDate:[NSDate date]]; //"date" es la fecha de hoy
    [event setTitle:@"Mi primer evento"];
    }

    y eso sería todo el código, ahora pasamos a grabar los datos para hacerlos persistentes

  3. Para guardar un objeto se utiliza el método savede NSManagedObjectContext, si ocurre algún error se guardará la información del mismo (el motivo por ejemplo) en la variable NSError dispuesta a tal efecto.
    NSError *error;
    if ([managedObjectContext save:&error]){ 
    //prestar especial atención al ampersand...
    //referencia de memoria!
    //Gestión del error aquí
    }

    Podemos intentar capturar errores con una captura de excepciones (@try { } @catch (NSException *exception) { } @finally { } ) pero esto no es recomendable, además de que debemos recordar la cadena de respondedores, aquí se aplica el mismo cuento y tendríamos que ir hacia arriba en la lógica de la programación para capturar la verdadera excepción de la pila de llamadas…cosa que es bastante tediosa, por eso es mejor pensar las cosas bien y hacerlas mejor jeje, con la práctica todo se consigue ;)
    Fetch Request -> execute!

    Si queremos recuperar el objeto no tenemos más que usar, como se hace en php y mysql una petición tipo “fetch”, es decir, con NSFetchRequest especificamos la entidad, aquí tenéis un ejemplo completo.
    En resumidas cuentas, hay que crear un objeto NSFetchRequest, reutilizamos el objeto de la descripción de una entidad y asociamos esta al primero con setEntity:

    NSFetchRequest *request = [[NSFetchRequest alloc] init]; 
    //cuidado que esto no se libera. lo hace sólo...:O
    NSEntityDescription *entity = [NSEntityDescription 
    entityForName:@"Event" inManagedObjectContext: managedObjectContext];
    [request setEntity:entity];
    //Para realizar un ORDER BY fecha típico usamos un descriptor de ordenación:
    NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc] initWithKey:
      @"creationDate" ascending:NO];
    NSArray *sortDescriptors = [[NSArray alloc] initWithObjects:sortDescriptor, nil];
    [request setSortDescriptors:sortDescriptors];
    //ahora sí, liberamos los descriptores
    [sortDescriptor  release];
    [sortDescriptors release];
    //Con todo configurado, vamos a ejecutar la consulta y
    // guardar el resultado en una matriz modificable:
    NSError *error1;
    //Atención al parámetro "mutableCopy"!!
    NSMutableArray *results = [[managedObjectContext 
       executeFetchRequest:request &error1] mutableCopy];
    if ( results == nil ){
        //Manejar el error!
    }
    //Para borrar necesitamos un NSError igual que cuando guardamos con save
    NSError *error2;
    [managedObjectContext deleteObject:objetoEventoParaBorrar];
    if (![managedObjectContext save:&error2){
     //error...
    }

    Nunca os asustéis de un error como éste: significa que no habéis asociado bien el tipo de dato al diccionario usado para realizar una inserción en masa, ánimo!

Que los robots escriban código por nosotros: Servicios Web

Recordamos del curso de servicios web que escribir XML y código de un servicio web no es tarea de humanos, para eso existen frameworks que harán el trabajo duro por nosostros, Fremont es la parte cliente, en Objective C, para la parte del servidor tenemos los transformadores que ya vimos, BPEL, etc.

Gracias al uso de un servidor asociado a Google App Engine, crearemos un conjunto de servicios usando Google Web Toolkit 2.3.0 , que una vez probados en red local podremos desplegar en el servidor Java de GAE asociado a nuestra cuenta de usuario.

Pasos para la creación de un servidor de datos por medio de servicios web con Eclipse:

  1. Descargar el IDE Eclipse (Hellios SR2 por ejemplo) y el plugin para GWT.
  2. Crear un proyecto de prueba y ejecutarlo
    Ir a File -> New – > Project … -> Google -> Web Application Project . Le dáis un nombre al proyecto y al package sencillos, os recomiendo usar un área de trabajo nueva para no mezclar, aseguraos de que la opción de Google Web Toolkit está marcada y que estamos usando el SDK de GWT – 2.3.0 asó como el Google App Engine con su SDK (el que sea, en mi caso el 1.5.0) y marcad que genere el código de ejemplo para que todo fluya :) . Si todo ha ido bien debéis poder desplegar la aplicación en vuestra cuenta de google sobre el App Engine y ver el producto generado…ya podéis ser un 3% más felices hoy jeje
  3. Crear un paquete de servicios para nuestro servidor de aplicaciones de iPhone.
  • Pasos:
    • Crear paquete
      En el directorio src pinchamos con el segundo botón y hacemos New -> Package ,de nombre le damos servicios_iOS, por ejemplo. El primer servicio que vamos a crear es un servicio simple, que muestre una lista de eventos, pero antes debemos crear el modelo de datos que ha de persistir (guardarse) en el Data Store de Google Web Toolkit.
    • Crear modelo de datos
      Dentro de nuestro paquete hacemos click con el botón secundario del ratón y -> New -> Class, de nombre “Evento”, claro ,jeje…me gusta escribir todo el código de un servidor en inglés ya que es algo que veremos poco y puede que solamente nosotros…como opciones pues, es una clase pública, etc. Dentro de la clase añadimos ,como os imaginaréis,
      private Key id; private String titulo; private float latitud; private float longitud;
      y luego usaremos los generadores de setters y getters que tanto nos gustan de Java en Eclipse, así como los constructores.

      Hay un caso curioso, como veréis he puesto Key, en lugar de un int o un Long para la llave principal, esto es debido a que si queremos usar el objeto como algo persistente y almacenable dentro de otra clase, esta llave le permite indexar al objeto por lo que puede serializarse, convertirse en una cadena y quedar guardado en las bases de datos de Google.
      A cada campo le debéis añadir los protocolos antes de su declaración “@Persistent“, y a la llave principal le añadimos @Primary Key , y también: @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY).
      A la clase Evento además le añadimos el siguiente prefijo: @PersistenceCapable(indetityType = IdentityType.APPLICATION)
    • Añadir complejidad al modelo de datos
      Para aquellos que no se contentan con un modelo de datos simple y quieren asociar una lista de cosas (vaya usté a saber qué más cosas…) pueden usar el prefijo: @Persistent(embedded=”true”) para variables del tipo private List<TipoDeDatosPropio> miListaDeCosas; Sin olvidarse,claro, de que el tipo de datos propio ha de llevar nuestro querido prefijo @PersistenceCapable(indetityType = IdentityType.APPLICATION) y que ha de contener una llave o Key id para poder serializarse y empaquetarse dentro de un atributo persistente de otra clase persistente
    • Crear servicios que usen el modelo de datos
      Tenemos un modelo donde almacenar datos, utilizaremos un fichero HTML en el directorio /war/ sencillo donde colocar un formulario con los campos título, longitud,latitud, fecha y cuya acción (o action, con method=”POST”) irá a “/nombreProyecto/nombreAccionServicio”.
      Para crear el servicio que atenderá la petición vamos a nuestro paquete y -> new -> class -> “nombreAccionServicio”.  A la clase, le ponemos el prefijo @ServiceName(value=”nombreAccionServicio”) y hereda (con la palabra clave extends) de la clase HttpServlet, de modo que debemos sobrecargar la función
      public doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException, DatastoreFailureException { //… },
      para que atienda la petición enviada desde el fichero HTML por el método POST. Igual que en PHP.
      Importante que la respuesta se haga de una manera parecida a esta:

      resp.setContentType("text/html");
      PrintWriter out = resp.getWriter();
      out.println("< !DOCTYPE HTML PUBLIC \"-W3C//DTD....."); //etc

      Una vez que hayamos creado nuestras inicializaciones de datos de nuestro modelo (instanciado las clases oportunas), debemos guardarlos usando un gestor de Persistencia, lo que viene a ser una clase de JDOHelper.getPersistenceManagerFactory(“transactions-optional”); que por medio de la función makePersistent(clase_instanciada) se almacenará (después debemos hacer un close(), claro jeje)

    • Añadir las rutas al war/WEB-INF/web.xml –> este es el enrutador de acciones, asocia un nombre de ruta en una url (con un patrón) a un servicio web (con una clase que extiende de HttpServlet). Para ello,abrimos el fichero y creamos dentro del web-app un hijo servlet que especifica la asociación con el programa usando la palabra clave servlet-name:nombreServicio y servlet-class: nuestra clase nombreAccionServicio.
      Por último, para el mapeado, es decir, la forma en que un patrón o expresión regular asocia una ruta url a nuestro servlet, añadimos un hijo de “web-app” llamado servlet-mapping con el mismo servlet-name:nombreServicio y url-pattern:/nombreAccionServicio
  • Repetir operación para crear servicios que generen listas de datos, en nuestro caso nos hará falta que se genere un listado XML de todos los <eventos> con sus etiquetas para cada campo que tiene el modelo de datos. Para ello, añadimos una función a la clase Evento que genere la cadena XML como un string en UTF8 y un Servlet que la muestre por pantalla, en este caso la cabecera ha de ser text/xml ;)
  • Más información en este tutorial >>

Análisis sintáctico: XML – Servicio Web – iOS

Como ya hemos visto antes el funcionamiento de la persistencia de datos en iOS con un Modelo de Datos, pasaré directamente al análisis de un XML, aunque esto debería hacerse automáticamente con un framework como Fremont, lo importante es que os quedéis con que las clases que permiten estas tareas son NSURL, NS/Mutable\URLRequest,y NSURLConnection. Estas descargan los datos y podemos realizar el análisis sintáctico con varios tipos de “parser”, SAX: envío de notificaciones a medida que el analizador sintáctico va leyendo la cadena XML recibida por NSURL, o bien DOM:  es un analizador que lee toda la cadena XML y construye su representación completa. Para utilizar estos analizadores debemos incluir al proyecto el fichero libxml2 de las librerías del SDK (tanto SAX como DOM), o bien NSXMLParser (sólo SAX). Aunque existen alternativas como TBXML, TouchXML, KissXML, TinyXML, GDataXML, etc. –> ver comparativa >>

Pasos para utilizar NSXMLParser:

  1. Crear el parser con la información recibida de NSURL.
    NSXMLParser *parser  = [[NSXMLParser alloc] 
    initWithData:xmlData];
     //recibidos por NSURL
  2. Asignar un delegado (delegate), una clase que se encarga de recibir los eventos,i.e., que hereda de <NSXMLParserDelegate>
    [parser setDelegate:self];
  3. Comenzar a parsear con [parser parse];

A partir de aquí, se trata de usar los eventos del delegado (eventos de NSXMLParserDelegate) que son: didStartElement -> empieza un elemento, didEndelement, didStartDocument, etc. de forma que al principio del documento inicializamos los datos (un array modificable, por ejemplo), y cada vez que encuentra un elemento de tipo titulo pues añade un elemento al array y luego al terminar un elemento de tipo evento, pues añade el array de propiedades de un evento al array de eventos…fácil…Importante implementar también la función:

- (void)parser:(NSXMLParser *) parser parseErrorOccurred:
  (NSError *)parseError;
ya que nunca se sabe qué errores se pueden cometer, por ejemplo que el documento no llegue completo, y la aplicación pende de un hilo por una mala gestión de este tipo de errores…algo que no da buena imagen por lo que hay que pulir estos detalles…

Uso de caché

La utilización de caché tanto para datos persistentes como para datos dinámicos es importante a la hora de realizar aplicaciones para móviles ya que está muy penalizado el uso de conexiones a Internet, es más rentable llegar a un equilibrio de carga de datos entre el servicio web y los usuarios de los dispositivos, por eso os presento las dos tareas a realizar en un proyecto serio…

Caché de imágenes con ASI Http Framework

En esta dirección encontraréis un framework sorprendente para realizar tareas con análisis sintácticos de XML, descarga de datos a través de urls, caché, etc.

Es una maravilla ver como funcionan los ejemplos, hay uno,especial de caché en el que se dispone una serie de descargas de imágenes y a cada una de ellas se le asocia un puesto en una clase cola-de-espera que tiene asociada una barra de progreso por lo que va actualizando el estado conforme se van descargando los datos…impresionante :)

Caché de datos con SQlite

Lo que podéis hacer es utilizar una caché para guardar la información en un modelo de datos, durante unos días en el iDevice, pasados esos días, vuelve a sincronizarse con el servicio de Google App Engine y reescribimos toda la estructura de datos del programa con nueva información, así nos ahorramos realizar peticiones al servidor continuamente, lo que ralentizaría mucho la carga y si la aplicación es muy usada puede generar un cuello de botella que ha de evitarse.

Para hacer esto nos viene bien los datos de configuración de un usuario, lo veremos en la próxima entrega del curso de aplicaciones para iOS, aquí mismo.

Recordar que podéis utilizar recursos como http://wiki.gnustep.orghttp://stackoverflow.com/ para solucionar vuestras dudas tanto con Objective C como con Java Google App Engine y GWT.

En cualquier caso, los ejercicios de esta entrega están claros cuáles son: desplegar una aplicación en GAE con GWT y pasar los datos a un modelo de datos de XCode (SQlite)…hay cientos de tutoriales en internet sin embargo si tenéis cualquier duda, mandadme el fichero y lo intentaré corregir.

<< Volver al curso de programación de aplicaciones de iOS | Siguiente lección: Configuración y traducción de una aplicación de iOS >>

Programación de redes de redes sociales con elgg

Desde que Facebook empezó a tener éxito, los clones de redes sociales no pararon de aparecer, sobre todo webs de contactos como zoosk, badoo, linked in, …o las miles de redes más, cada una con su propósito, sin embargo las necesidades del público son tan dispares que empezaron a salir generadores online de redes sociales, no contentos con esto, ya que a nadie le interesa tener alojada una red social en las máquinas de alguien que no conoce, aparecieron generadores de redes sociales pero esta vez ,instalables en un servidor propio…una de esas opciones, de la más extendida ,es elgg…
Con elgg podemos simular un facebook, y digo simular porque no trae soporte para clústers, ni gestor de aplicaciones con APi externa, ni chat integrado, pero sí trae las herramientas para programar todas estas cosas, empezando por el muro, existe un componente llamado riverdash que lo implementa, en mi caso he estado extendiendo la funcionalidad de este plugin para un cliente y tengo que decir que el código de elgg aún tiene que madurar ,sin embargo entraña un potencial muy grande que puede aprovecharse tanto para construir una buena red social como para una aplicación de un grupo más reducido de personas que necesiten compartir información.

Podemos consultar la Wiki de Elgg aquí y descargarnos la última versión aquí.

Para añadir funcionalidades a esta red social personal se utiliza el directorio “mod” donde creamos un nuevo subdirectorio con el nombre de nuestro módulo, llamémoslo “saludo”, dentro, si creamos un fichero llamado “start.php” elgg cargará nuestro módulo, en dicho fichero se especifican las inicializaciones a realizar; lo primero después de esto es crear un subdirectorio dentro de “saludo” para las vistas, llamado “views”…aquí empieza a complicarse, tenemos varios tipos de vistas, lo normal es xhtml así que por defecto se llama al subdirectorio dentro de views , “default”, ahora, si es un widget (zona flotante que se puede colocar en cualquier lugar de las plantillas de la web) pues irá dentro del subdirectorio de default, “widgets”, y vamos a llamar al nuevo fichero “vista.php”, luego la ruta completa es
/mod/saludo/views/default/widgets/vista.php , y el código para esta vista es:

[source language=”php”]

[/source]

para que podamos gestionar el widget desde la administración iremos a /mod/saludo/start.php y lo dejaremos así:

[source language=”php”]

function iniciar_saludo() {
add_widget_type(‘saludo’, ‘Mod de Saludo’, ‘Simplemente saluda’);
}

register_elgg_event_handler(‘init’,’system’,’iniciar_saludo’);

[/source]

De forma que elgg ya sabe qué es lo que tiene que hacer con nuestro nuevo módulo…

Para complicarlo un poco más y pasarle datos a nuestro módulo usaremos una vista de elgg, creando un fichero llamado hola.php donde estaba vista.php, con el siguiente contenido:

[source language=”php”]

Tu saludo:
‘params[mensaje]’,
‘value’ => $vars[‘entity’]->mensaje,
‘class’ => ‘hola-input-text’ ) );
?>

[/source]

así, especificamos a elgg que queremos mostrar un tipo de vista basada en un input text con el nombre “mensaje” y el valor es el que tenga la propia entidad (al principio ninguno) en su atributo mensaje, la class es CSS…

Ahora, para que la vista.php muestre el saludo enviado, necesitamos cambiarla para que quede así:

[source language=”php”]

mensaje; ?>

[/source]

Para más información acerca de las vistas pinchar aquí.

La gestión de idiomas se lleva por medio de un array de valores en /mod/saludo/languages/es.php, el índice o clave de una palabra o frase a almacenar contiene el prefijo del módulo, en nuestro caso “saludo:____” , donde ___ es el resto de la llave, por ejemplo, para inicio ->

[source language=”php”]

$espanol = array ( “saludo:inicio” => “Inicio”);

$english = array(“saludo:inicio” => “Home”);

add_traslation(“es”, $espanol);

add_traslation(“en”, $english);

//Para utilizar las claves:

echo elgg_echo(“saludo:inicio”);

[/source]

En este vídeo se puede comprobar como se ha modificado elgg para añadir un motor tipo “muro” de facebook, se ha añadido la funcionalidad de mostrar comentarios, eventos, “me gusta” y “no me gusta”, enviar a redes sociales, etc.

Los encargos que he realizado están asociados a la creación de herramientas (plugins) y modificaciones del núcleo para importar y exportar contenido entre redes sociales y elgg. Desde Blogger hasta Facebook pasando por WordPress, las “tools” que he diseñado específicamente importan y exportan entradas del river-dashboard, también conocido como el famoso muro en facebook, pero adaptado para elgg.

Actualización Marzo 2011:

Crear un plugin como extensión de otro para elgg:
1.- crear directorio en /mod/nombre_plugin
2.- crear /mod/nombre_plugin/manifest.xml
[sourcecode language=”xml”]






3.- crear /mod/nombre_plugin/start.php
donde al menos registraremos una función para la carga del plugin y otra función para manejar los eventos, opcionalmente añadiremos acciones también (funciones,claro).

register_elgg_event_handler('init','system','nombre_plugin_init');
register_elgg_event_handler('pagesetup','system','nombre_plugin_pagesetup');

En el caso en que queramos permitir el uso de preferencias por usuario del plugin, usaremos en start.php -función nombre_plugin_init()-, el siguiente código:

register_plugin_hook('usersettings:save','user','nombre_plugin_user_settings_save');

La función para guardar estas preferencias debe ser algo como:

function nombre_plugin_user_settings_save(){
//sólo usuario registrado y propietario de la cuenta a editar opciones
gatekeeper();
$user = page_owner_entity();
if (!$user) {
$user = $_SESSION['user'];
}
 
$user->nombre_input =  get_input('nombre_input','valor_por_defecto');
 
}

Evidentemente tenemos que añadir las vistas como página
en la función nombre_plugin_pagesetup:

 
//Añadir los campos de configuración de usuario
extend_elgg_settings_page(
'nombre_plugin/settings/usersettings',
'usersettings/user'
);

y claro, necesitamos crear el fichero que referenciamos, en
/mod/nombre_plugin/views/default/settings/usersettings.php
donde colocaremos los (html) que necesitemos. Para obtener los valores en dicha vista de los propios inputs, usaremos

$user = page_owner_entity();

y los valores están dentro de esta clase: $user->nombre_input…
Como truquito que me gusta utilizar, para crear una lista de valores con un select, usar las funciones implode para guardar el dato y split para el dato leído e interpretarlo.

Si queremos que el plugin tenga opciones para el administrador creamos el directorio
/mod/nombre_plugin/views/settings/nombre_plugin/
y dentro colocamos el fichero edit.php. Aquí lo único que tenemos que hacer es escribir por pantalla los campos input que queramos como opciones de administración del plugin, el motor de Elgg nos guardará solito los valores al pulsar en en el botón submit “save”, para obtener el valor del input tenemos que llamar a la función get_plugin_setting(‘nombre_input’,’nombre_plugin’) que nos devuelve el valor.

Tened en cuenta que Elgg usa muchos automatismos, por ejemplo sólo con crear un fichero con el mismo nombre del plugin dentro del directorio settings de mod, ya tenéis hecho un gestor de opciones para vuestra contribución, son cosas como estas las que la comunidad agradece tanto, si echáis un vistazo a los foros veréis de lo que hablo, un saludo

Ejemplo de Aplicaciones para iPhone, iPad, iPod – 2D, 3D – juegos

Este juego se está realizando como proyecto personal, mientras realizo el resto de aplicaciones para clientes; se trata de un juego de rol multijugador online, se paga por tener una cuenta, durante la fase beta (ahora mismo se encuentra en fase pre-alfa) se podrá jugar a la primera pantalla de un mundo con dos personajes.
Está construido con lenguaje LUA sobre el motor Shiva de Stonetrip.com, la comunicación con el servidor se realiza mediante PHP y el protocolo HTTP usando paquetes de información encriptados en XML generados a partir de los datos cotejados de la base de datos MySQL con una aplicación web en PHP con el framework zenphp.
El punto fuerte del juego es el algoritmo generador de mundos que permite reiniciar el juego manteniendo los personajes o usando unos nuevos pero con una experiencia nueva para el jugador.
Los gráficos se están realizando por la empresa BlueShadowGames de Granada.
Este video muestra el progreso de la fase pre-alfa del juego:

Aplicación web para inmobiliarias – proyectos y multimedia

Esta es una aplicación multilenguaje del año 2007 con zenphp. Se incluye un administrador interno con capacidad para subir ficheros e imágenes asociados a los inmuebles así como enviar direcciones de youtube para insertar conjuntamente con la descripción de aquellos.
Las cabeceras se pueden cambiar por cada entrada de inmueble de cada categoría, además ,las plantillas contienen un gestor de imágenes con las que se construye una galería con fotografías dentro de la página de cada inmueble…

Las plantillas XHTML + CSS se crearon por Agencia Q4 en el 2007.

Página 1 de 41234
footer
jbelon © | sitemap.xml