Rafa Paradela

Como muchos ya sabéis estoy haciendo un curso intensivo de desarrollo para iOS. No es un curso cualquiera. Es un curso de IronHack, que para el que no lo conozca, representa una manera diferente de impartir formación.

Desde mi punto de vista, el éxito de IronHack radica en una filosofía muy particular, que consiste en exigir dedicación absoluta e intensiva durante unos meses, con los docentes más especializados en cada materia y para aquellos alumnos que más ilusión y ganas tengan de aprenderla.

Pues bien, estoy escribiendo unos resúmenes semanales a modo de "repaso" que podéis leer aquí:

http://theiosdev.com/ironhack/

Con Python (Django)

Crear cuenta en Heroku

Crear la app, por ejemplo: ironhack-api-python-demo, la app estará corriendo en:

http://ironhack-api-python-demo.herokuapp.com/

Repositorio GIT

Nos traemos una copia del proyecto (vacío por ahora):

> git clone [email protected]:ironhack-api-python-demo.git -o heroku

Requisitos

Instalamos heroku toolbelt:

> brew install heroku

Instalamos python:

> brew install python

Instalamos pip:

> sudo easy_install pip

Instalamos virtualenv:

> pip install virtualenv

Instalamos virtualenvwrapper:

> pip install virtualenvwrapper

Creamos un virtualenv (por ejemplo con el nombre api_env) donde estará nuestra app django:

> mkvirtualenv api_env

Para activar ese virtualenv:

> workon api_env

Instalamos django

> pip install django

Instalamos MySql para Python:

> pip install MySQL-python

Ahora vamos a instalar una serie de paquetes necearios para Heroku:

> pip install dj-database-url > pip install dj-static > pip install gunicorn > pip install static

Guardamos los requisitos para Heroku sepa lo que tiene que instalar:

> pip freeze > requirements.txt

Creando projecto Django

Por ejemplo lo llamaré apidemo

> django-admin.py startproject apidemo .

Tenemos que crear un archico Procfile para especificar a Heroku que en la máquina va a correr una app django, lo creamos en la raiz del proyecto con este contenido:

web: gunicorn apidemo.wsgi

Y probamos arrancando la app en local:

> python manage.py runserver

Si todo ha ido bien, podrás ver el sitio corriendo en http://127.0.0.1:8000/

Subimos a producción para probar

Subimos los cambios al repositorio:

> git add * > git commit -m 'Django app created'

Y hacemos push en producción:

> git push heroku master

Cuando acabe podremos ver en http://ironhack-api-python-demo.herokuapp.com/ un mensaje alentador: It worked!

Creamos base de datos local

Con nuestro cliente mysql, creamos una base de datos en localhost, llamada por ejemplo: ironhack-api-demo-test, luego creamos un usuario con permisos grant para esa base de datos. En el ejemplo el usuario será ironhackdemo y contraseña ironhackdemo.

Vamos a configurar django para que se conecte a la base de datos, abrimos /apidemo/settings.py y editamos el contenido del diccionario DATABASES:

DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'ironhack-api-demo-test', 'USER': 'ironhackdemo', 'PASSWORD': 'ironhackdemo', 'HOST': '127.0.0.1', 'PORT': '', } }

Creamos la app que será nuestra API

En Django los proyectos los conforman una o varias apps. Vamos a crearnos nuestra app, que se llamará por ejemplo api:

> python manage.py startapp api

Esto crea un nuevo directorio en nuestro proyecto, pero debemos indicarle al proyecto que incluya esta nueva app. Editamos /apidemo/settings.py de nuevo para añadir a la lista INSTALLED_APPS nuestra nueva app:

INSTALLED_APPS = ( 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'api' )

Creamos nuestros modelos

Vamos a crean el api/models.py estos dos modelos, Ironhackers que representan a los estudiantes del IronHack y Teams que representa por ejemplo posibles equipos en los que agruparnos:

class Ironhackers(models.Model): name = models.CharField(default="",max_length=50) email = models.EmailField(max_length=100,default="") team = models.ForeignKey('Teams',null=True,blank=True,on_delete = models.SET_NULL) def __unicode__(self): return self.name class Teams(models.Model): team = models.CharField(default="",max_length=50) color = models.CharField(default="",max_length=50) def __unicode__(self): return self.team

Una vez creados los modelos, django se encarga crear las tablas en la base de datos, con el comando:

> python manage.py syncdb

Creamos las rutas que servirán de endpoints para nuestra API

Las rutas en Django se gestionan desde el archivo urls.py, lo abrimos y añadimos por ejemplo estas urls:

url(r'^ironhackers/add$', 'api.endpoints.ironhackers.add'), url(r'^ironhackers/delete$', 'api.endpoints.ironhackers.delete'), url(r'^ironhackers/list$', 'api.endpoints.ironhackers.list'), url(r'^ironhackers/orphans$', 'api.endpoints.ironhackers.orphan'), url(r'^ironhackers/link_to_team$', 'api.endpoints.ironhackers.link_to_team'), url(r'^teams/add$', 'api.endpoints.ironhackers.add'), url(r'^teams/delete$', 'api.endpoints.ironhackers.delete'), url(r'^teams/list$', 'api.endpoints.ironhackers.list'),

O sea en este ejemplo estamos añadiendo a nuestra api los métodos add, delete, list, orphans y link_to_team para ironhackers y add, delete y list para teams.

Implementación de los métodos

Para implementar los métodos de ironhackers, creamos el archivo /api/endpoints/ironhackers.py:

Añadir un ironhacker dados el name y el email:

def add(request): try: student=Ironhackers() student.name=request.POST['name'] student.email=request.POST['email'] student.save() data=json.dumps({'status': 'success', 'response':'added', 'data':{'id':student.id}}) except Exception as e: data = json.dumps({ 'status':'failed', 'response': e.args[0] }) return HttpResponse(data, content_type="application/json")

Eliminar un ironhacker dado su id:

def delete(request): try: student=Ironhackers.objects.get(id=request.POST["id"]) student.delete() data=json.dumps({'status': 'success', 'response':'deleted'}) except Exception as e: data = json.dumps({ 'status':'failed', 'response': e.args[0] }) return HttpResponse(data, content_type="application/json")

Lista de ironhackers:

def list(request): try: students=Ironhackers.objects.all() list_students=[] for student in students: list_students.append({'id':student.id, 'name':student.name, 'email':student.email }) data=json.dumps({'status': 'success', 'response':'list', 'data': list_students }); except Exception as e: data = json.dumps({ 'status':'failed', 'response': e.args[0] }) return HttpResponse(data, content_type="application/json")

Lista de ironhackers sin equipo asignado:

def orphans(request): try: students=Ironhackers.objects.filter(team__isnull=True) list_students=[] for student in students: list_students.append({'id':student.id, 'name':student.name, 'email':student.email }) data=json.dumps({'status': 'success', 'response':'orphans', 'data': list_students }); except Exception as e: data = json.dumps({ 'status':'failed', 'response': e.args[0] }) return HttpResponse(data, content_type="application/json")

Vincular un ironhacker a un equipo dados el id del estudiante y el id del equipo:

def link_to_team(request): try: student=Ironhackers.objects.get(id=request.POST["student_id"]) team = Teams.objects.get(id=request.POST["team_id"]) student.team = team student.save() data=json.dumps({'status': 'success', 'response':'linked'}) except Exception as e: data = json.dumps({ 'status':'failed', 'response': e.args[0] }) return HttpResponse(data, content_type="application/json")

Para implementar los métodos de teams, creamos el archivo /api/endpoints/teams:

Añadir un equipo dados el team y el color:

def add(request): try: team=Teams() team.team=request.POST['team'] team.color=request.POST['color'] team.save() data=json.dumps({'status': 'success', 'response':'added', 'data':{'id':team.id}}) except Exception as e: data = json.dumps({ 'status':'failed', 'response': e.args[0] }) return HttpResponse(data, content_type="application/json")

Eliminar un equipo dado su id:

def delete(request): try: team=Teams.objects.get(id=request.POST["id"]) team.delete() data=json.dumps({'status': 'success', 'response':'deleted'}) except Exception as e: data = json.dumps({ 'status':'failed', 'response': e.args[0] }) return HttpResponse(data, content_type="application/json")

Lista de equipos:

def list(request): try: teams=Teams.objects.all() list_teams=[] for team in teams: list_teams.append({'id':team.id, 'team':team.team, 'color':team.color }) data=json.dumps({'status': 'success', 'response':'list', 'data': list_teams }); except Exception as e: data = json.dumps({ 'status':'failed', 'response': e.args[0] }) return HttpResponse(data, content_type="application/json")

Con estas implementaciones tenemos en local estos métodos de nuestra API:

http://127.0.0.1:8000/ironhackers/add

http://127.0.0.1:8000/ironhackers/delete

http://127.0.0.1:8000/ironhackers/list

http://127.0.0.1:8000/ironhackers/orphans

http://127.0.0.1:8000/ironhackers/link_to_team

http://127.0.0.1:8000/teams/add

http://127.0.0.1:8000/teams/delete

http://127.0.0.1:8000/teams/list

Configurar la base de datos de producción

En la terminal, creamos una base de datos en producción con el comando:

> heroku addons:add cleardb:ignite

Para saber los datos de acceso de la base de datos recien creada:

> heroku config | grep CLEARDB_DATABASE_URL

Con esas credenciales, accedemos desde un cliente mysql e importamos la base de datos local. También cambiamos esas credenciales en el settings.py de nuestro proyecto.

Subimos a producción

Subimos todo a producción:

> git add * > git commit -m 'Django app created' > git push heroku master

Si todo ha udo bien, debériamos tener estos métodos listos para ser usados:

http://ironhack-api-python-demo-test.herokuapp.com//ironhackers/add

http://ironhack-api-python-demo-test.herokuapp.com//ironhackers/delete

http://ironhack-api-python-demo-test.herokuapp.com//ironhackers/list

http://ironhack-api-python-demo-test.herokuapp.com//ironhackers/orphans

http://ironhack-api-python-demo-test.herokuapp.com//ironhackers/link_to_team

http://ironhack-api-python-demo-test.herokuapp.com//teams/add

http://ironhack-api-python-demo-test.herokuapp.com//teams/delete

http://ironhack-api-python-demo-test.herokuapp.com//teams/list

Para probar, podéis usar http://www.hurl.it/

Para descargar el proyecto entero, https://github.com/rafaparadela/ironhack-api-python-demo

Con PHP (CodeIgniter)

Crear cuenta en Heroku

Crear la app, por ejemplo: ironhack-api-php-demo, la app estará corriendo en:

http://ironhack-api-php-demo.herokuapp.com/

Repositorio GIT

Nos traemos una copia del proyecto (vacío por ahora):

> git clone [email protected]:ironhack-api-php-demo.git -o heroku

Requisitos

Debemos tener Apache, PHP y MySQL corriendo en nuestro servidor local.

Descargamos CodeIgniter

Descargamos y descomprimimos una instancia de CodeIgniter en el directorio donde clonamos el repositorio. (Podemos borrar el directorio user_guiade) y vemos en el navegador la pantalla por defecto de CodeIgniter.

Subimos a producción para probar

Subimos los cambios al repositorio:

> git add * > git commit -m 'Django app created'

Y hacemos push en producción:

> git push heroku master

Cuando acabe podremos ver en http://ironhack-api-php-demo.herokuapp.com/

Creamos base de datos local

Con nuestro cliente mysql, creamos una base de datos en localhost, llamada por ejemplo: ironhack-api-demo-test, luego creamos un usuario con permisos grant para esa base de datos. En el ejemplo el usuario será ironhackdemo y contraseña ironhackdemo.

Vamos a configurar codeigniter para que se conecte a la base de datos, abrimos /applications/config/database.php y editamos el array db

$db['default']['hostname'] = '127.0.0.1'; $db['default']['username'] = 'ironhackdemo'; $db['default']['password'] = 'ironhackdemo'; $db['default']['database'] = 'ironhack-api-demo-test';

Creamos los controladores

Primero vamos a crear los controladores. Para entender el sistema de rutas, vamos a crearnos en application/controllers/micontrolador.php

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); class Micontrolador extends CI_Controller { public function index() { echo 'How cool is that!'; } public function una() { echo 'Pollito!'; } public function dos($tres='') { echo 'Palote! '.$tres; } }

Para acceder a los métodos de los controladores, hay que poner la base_url de nuestra app, seguido del nombre del controlador, seguido del método a llamar. Si no le pasamos el segmento 'método' pues ejecuta función index();

Para llamar por ejemplo a la función una():

[base_url]/micontrolador/una

Para llamar por ejemplo a la función dos():

[base_url]/micontrolador/dos

Para pasarle el parámetro $tres a la función dos():

[base_url]/micontrolador/dos/mrpotato

La base_url por defecto incluye el punto de entrada de la app, o sea el archivo index.php. Para evitar que aparezca esto en nuetras rutas, debemos configurar algunas reglas de apache, lo más sencillo es crear un archivo .htaccess con estas reglas:

RewriteEngine On RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteRule ^(.*)$ index.php/$1 [L]

Vamos a crear ahora el controlador que contendrá los métodos de los estudiantes, lo llamamos ironhackers.php:

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); class Ironhackers extends CI_Controller { public function index() { return false; } public function add() { return false } public function delete() { return false } public function list_students() { return false } public function link_to_team() { return false } }

Lo mismo con los equipos. Lo llamamos teams.php:

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); class Teams extends CI_Controller { public function index() { return false; } public function add() { return false } public function delete() { return false } public function list_teams() { return false } }

Creamos los modelos

Para que el controlador interactúe con la base de datos, lo hace a través de los modelos.

Vamoa a empezar creando el modelo para los estudiantes. En models, creamos ironhackers_model.php con una clase que extienda al CI_Model:

<?php if (!defined('BASEPATH')) exit('No direct script access allowed'); class ironhackers_model extends CI_Model { function __construct() { parent::__construct(); } function get($id){ $this->db->where('id', $id); $this->db->limit(1); $query=$this->db->get('ironhackers'); if ($query->num_rows() > 0) return $query->row(); else return FALSE; } }

Con esto estamos creando una función get(), disponible para todo aquel que importe el modelo ironhackers, para que dado un id, te devuelva los campos de ese estudiante. El resto de funciones podría ser get_list para que devuelva todos los estudiantes, add para añadir uno, set para cambiar algun campo de un estudiante y delete para borrar un estudiante. Quedaría así:

<?php if (!defined('BASEPATH')) exit('No direct script access allowed'); class ironhackers_model extends CI_Model { function __construct() { parent::__construct(); } function get($id){ $this->db->where('id', $id); $this->db->limit(1); $query=$this->db->get('ironhackers'); if ($query->num_rows() > 0) return $query->row(); else return FALSE; } function get_list(){ // $this->db->order_by('ironhacker','asc'); $query=$this->db->get('ironhackers'); if ($query->num_rows() > 0) return $query->result(); else return FALSE; } function add($ironhacker) { $this->db->insert('ironhackers', $ironhacker); return $this->db->insert_id(); } function set($id_ironhacker,$field=FALSE,$value=FALSE) { if($field) $this->db->set($field,$value); // $this->db->set('update','NOW()', FALSE); $this->db->where('id', $id_ironhacker); return $this->db->update('ironhackers'); } function delete($id_ironhacker) { $this->db->where('id', $id_ironhacker); return $this->db->delete('ironhackers'); } }

Y el modelo de Teams quedaría así:

<?php if (!defined('BASEPATH')) exit('No direct script access allowed'); class teams_model extends CI_Model { function __construct() { parent::__construct(); } function get($id){ $this->db->where('id', $id); $this->db->limit(1); $query=$this->db->get('teams'); if ($query->num_rows() > 0) return $query->row(); else return FALSE; } function get_list(){ // $this->db->order_by('team','asc'); $query=$this->db->get('teams'); if ($query->num_rows() > 0) return $query->result(); else return FALSE; } function add($team) { $this->db->insert('teams', $team); return $this->db->insert_id(); } function set($id_team,$field=FALSE,$value=FALSE) { if($field) $this->db->set($field,$value); // $this->db->set('update','NOW()', FALSE); $this->db->where('id', $id_team); return $this->db->update('teams'); } function delete($id_team) { $this->db->where('id', $id_team); return $this->db->delete('teams'); } }

Ya podemos implementar los métodos. Ironhackers quedaría así:

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); class Ironhackers extends CI_Controller { function __construct() { parent::__construct(); // $this->output->enable_profiler(TRUE); } public function index() { return false; } public function add() { $this->load->model('ironhackers_model'); $student = array( 'name' => $_POST['name'], 'email' => $_POST['email'] ); $id = $this->ironhackers_model->add($student); $dev = array( 'status' => 'success', 'response' => 'added' , 'data' => $id ); echo json_encode($dev); } public function delete() { $this->load->model('ironhackers_model'); $id = $this->ironhackers_model->delete($_POST['id']); $dev = array( 'status' => 'success', 'response' => 'deleted' ); echo json_encode($dev); } public function list_students() { $this->load->model('ironhackers_model'); $students=$this->ironhackers_model->get_list(); $my_students=array(); foreach ($students as $student) { $item=array( 'id'=>$student->id, 'name'=> $student->name, 'email'=> $student->email ); array_push($my_students,$item); } $dev = array( 'status' => 'success', 'response' => 'deleted', 'data' => $my_students ); echo json_encode($dev); } public function link_to_team() { $this->load->model('ironhackers_model'); $this->ironhackers_model->set($_POST['student_id'], $field='team_id', $value=$_POST['team_id'] ); $dev = array( 'status' => 'success', 'response' => 'linked' ); echo json_encode($dev); } }

Y Team así:

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); class Teams extends CI_Controller { function __construct() { parent::__construct(); // $this->output->enable_profiler(TRUE); } public function index() { return false; } public function add() { $this->load->model('teams_model'); $team = array( 'team' => $_POST['team'], 'color' => $_POST['color'] ); $id = $this->teams_model->add($team); $dev = array( 'status' => 'success', 'response' => 'added' , 'data' => $id ); echo json_encode($dev); } public function delete() { $this->load->model('teams_model'); $id = $this->teams_model->delete($_POST['id']); $dev = array( 'status' => 'success', 'response' => 'deleted' ); echo json_encode($dev); } public function list_teams() { $this->load->model('teams_model'); $teams=$this->teams_model->get_list(); $my_teams=array(); foreach ($teams as $team) { $item=array( 'id'=>$team->id, 'team'=> $team->team, 'color'=> $team->color ); array_push($my_teams,$item); } $dev = array( 'status' => 'success', 'response' => 'list', 'data' => $my_teams ); echo json_encode($dev); } }

Este ejemplo está en GitHub: https://github.com/rafaparadela/ironhack-api-php-demo

Nota 1

Para subirlo a Heroku, el .htaccess debería ser así:

<IfModule mod_rewrite.c> RewriteEngine On RewriteBase / RewriteRule ^index\.php$ - [L] RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteRule . /index.php [L] </IfModule>

Nota 2

Si hay problema para conectar con Heroku por las credenciales:

Metiendo código en el siguiente párrafo.

Seguro que alguna vez te ha echo falta obtener cierta información de alguna web automáticamente y ésta no tiene una API a la que solicitar dichos datos. En ese caso, lo más sencillo es parsear el arbol DOM de la misma y "quedarte" con lo que necesitas.

Para ilustrarlo os pongo un ejemplo. Imaginaos que queremos tener siempre actualizado los datos del próximo partido del Real Madrid, la hora, contra quien juega, el canal que lo retransmitirá, etc. Desconzco si hay una API que provea de estos datos, pero lo que si sé es que en la web oficial siempre se puede leer dicha información.

Si lo queremos hacer en Python, os recomiendo usar la librería Beautiful Soup porque te facilitará la vida a la hora de navegar por el árbol DOM hasta llegar al nodo que necesites. Sería algo así:

# -*- encoding: utf-8 -*- import urllib2 from bs4 import BeautifulSoup url1=’http://www.realmadrid.com/cs/Satellite/es/Home.htm’ req1 = urllib2.Request(url1) response = urllib2.urlopen(req1) html=response.read() try:   soup2= BeautifulSoup(html, “lxml”)   result= soup2.find_all(“dl”)   try:     result[1].attrs[‘class’]     soup3= BeautifulSoup(str(result[1]), “lxml”)     result2= soup3.find_all(“dd”)     competicion=’Liga’   except:     soup3= BeautifulSoup(str(result[2]), “lxml”)     result2= soup3.find_all(“dd”)     competicion=’Champion Leage’   partido=result2[0].string   dia=result2[1].string   hora=result2[2].string   estadio=result2[3].string   jornada=result2[4].string   arbitro=result2[5].string   tv=result2[6].string   print partido+’ ‘+dia+’ ‘+hora+’ ‘+estadio+’ ‘+jornada+’ ‘+arbitro+’ ‘+tv except:   print ‘error’

En PHP, también existe una "navaja suiza" para parsear que nos ahorrará algún que otro sofocón. De ese modo, quedaría algo así:

<?php include_once(‘simple_html_dom.php’); $html = file_get_html(‘http://www.realmadrid.com/cs/Satellite/es/Home.htm’); $pestanias=$html->find(‘dl’); $liga=$pestanias[1]; $champion=$pestanias[2]; if($liga->class!=’oculto’){   $padre=$liga;   $competicion=’Liga’; } else{   $padre=$champion;   $competicion=’Champion’; } $campos=$padre->find(‘dd’); $partido=$campos[0]->plaintext; $dia=$campos[1]->plaintext; $hora=$campos[2]->plaintext; $estadio=$campos[3]->plaintext; $jornada=$campos[4]->plaintext; $arbitro=$campos[5]->plaintext; $tv=$campos[6]->plaintext; echo $partido.’ ‘.$dia.’ ‘.$hora.’ ‘.$estadio.’ ‘.$jornada.’ ‘.$arbitro.’ ‘.$tv; ?>

La manera más sencilla de obtener el último artículo de tu blog WordPress para mostrarlo en tu página web, es sin duda usando el protocolo XML-RPC. Aunque las posibilidades de interaccionar con el blog remotamente son un poco limitadas, para tareas sencillas como obtener los últimos artículos es más que suficiente. Para conectar mediante python basta con estas líneas:

import xmlrpclib host = xmlrpclib.ServerProxy('http://tublog.com/xmlrpc.php') entradas = host.metaWeblog.getRecentPosts(blog_id, 'username', 'password', 10)

Así tenemos en 'entradas' un array con los últimos 10 artículos. Siendo blog_id normalmente 1 para referirse al único blog alojado en ese servidor xmlrpc, username es el nombre de usuario con el que te identificas en el wp-admin y password es la contraseña de dicho usuario. El 10 representa el número de artículos que queremos recibir. Es importante activar la conexión XML-RPC en nuestro panel de control de WordPress normalmente en Ajustes >> Publicación remota.

Si nuestra web está montada con Django, una posible implementación para mostrar el último artículo dinámicamente al cargar la página sería así:

En el archivo "views.py" de nuestra aplicación Django añadimos:

import xmlrpclib

@csrf_exempt def last_post(request):   username = 'admin'   password = '*****'   blog_id = 1   try:     host = xmlrpclib.ServerProxy('http://yourblogdomain.com/xmlrpc.php')     entradas = host.metaWeblog.getRecentPosts(blog_id, username, password, 1)     if entries:       title= entries[0]['title']       description= entries[0]['description']       url= entries[0]['permaLink']       return HttpResponse(json.dumps({'status':'ok', 'title': title, 'description': description, 'url': url}))     else:       return HttpResponse(json.dumps({'status': "error1"}))

  except:     return HttpResponse(json.dumps({'status': "error0"}))

Para añadir dicha función en nuestro routes, debemos añadir este patrón al archivo "urls.py":

urlpatterns = patterns('',   ...   (r'^last_post', 'myproject.myapp.views.last_post') )   ... )

Para cargar por JavaScript (jQuery) el artículo al cargar la página, podría ser así:

$(document).ready(function() {   var blog = window.setTimeout( function(){     get_last_post();   },1000); });

function get_last_post () {   var postwrapper=$('#postwrapper');   $.post('myapp.com/last_post',function(data, textStatus, xhr)   {     var post=$.parseJSON(data);     if(post.status=="ok"){       var title=$('<h1></h1>').text(post.title);       var descripction=$('<p></p>').text(post.descripction);       var link=$('<a></a>').text('Read more').attr('href',post.url);       postwrapper.empty().append(title).append(descripction).append(link);     }   }); }

Obviamente necesitamos insertar la capa donde se imprimirá el artículo y cargar el javascript y la librería jQuery. Añadiendo esto al body de nuestro template:

<div id="postwrapper">   Loading post... </div>

<script src="//ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script> <script src="media/js/app.js"> </script>

Si alguna vez habéis tenido que trabajar con fechas en MySQL y en particular obtener datos agrupados por semanas, seguro que habréis tenido la duda de saber qué "modo" usar para la función week(). 

Dependiendo de tu elección, el servidor considera que la primera semana empieza un lunes o un domingo, o si debe tener más de 3 días ese año o si las semanas empiezan a contar en 0 o en 1, y las combinaciones entre las posibilidades anteriores. Resumiendo:

Modo 0: Empieza un Domingo con un domingo en este año (0-53)

Modo 1: Empieza un Lunes con más de 3 días este año (0-53)

Modo 2: Empieza un Domingo con un domingo este año (1-53)

Modo 3: Empieza un Lunes con más de 3 días este año (1-53) 

Modo 4: Empieza un Domingo con más de 3 días este año (0-53)

Modo 5: Empieza un Lunes con un lunes en este año (0-53)

Modo 6: Empieza un Domingo con más de 3 días este año (1-53)

Modo 7: Empieza un Lunes con un lunes en este año (1-53) 

________

¿Estás empezando a programar? Tal vez te interese estos 10 consejos que te doy.

1.- Piensa antes de escribir código.

Es fundamental que plantees en tu cabeza el "problema" a resolver. Intenta decidir la estrategia correcta mentalmente antes de tirar lineas y lineas. Si lo necesitas, aclara el flujo de ejecución del programa dibujando un diagrama en un papel. Dedica el tiempo que sea necesario a este propósito porque cuanto más claro lo tengas en el coco menos horas vas a necesitar aporreando el teclado.

2.- Simplifica tareas

Divide y vencerás. Tras entender el planteamiento global del programa, lo mejor es dividir el desarrollo del mismo en sencillas tareas que se puedan acometer sin complicaciones. Es muy importante que estas pequeñas divisiones puedan ser ejecutadas por separado e inspeccionadas para validar su correcto funcionamiento y testar su rendimiento. 

3.- Estudia

Es básico conocer al dedillo el lenguaje en el que estás programando. Sus virtudes y sus limitaciones. No te quedes en aprender lo mínimo que necesitaste en el proyecto anterior. Documéntate sobre las librerías disponibles y las bondades de usar métodos nativos. Que levante la mano el que nunca ha implementado una función y luego descubrió que existía otra que hacía exactamente lo mismo.

4.- Encuentra el equilibrio entre escribir poco y que sea legible

La falsa creencia de que sistemáticamente cuantas menos líneas de código tenga tu programa más eficiente es, muchas veces acaba por influir negativamente en la legibilidad del mismo. No caigas en la fiebre del ahorro de lineas indiscriminadamente con enrevesadas llamadas encadenadas que no harán más que dificultar la comprensión del código posteriormente.

5.- ¡Comenta y sangra!

Los comentarios son importantísimos. Puede ahorrar mucho tiempo a compañeros en un futuro y a tí mismo. Respecto al sangrado, o la horrorosa palabra "indentación", aunque el lenguaje en si no te exija, toma por costumbre ser exhaustivo con él. Por cosas así amo Python.

6.- Nombres de variables/clases/funciones/métodos descriptivos

Sé descriptivo a la hora de bautizar tus variables. Piensa en ti mismo leyendo el código 10 años después. Si el lenguaje en sí no te exige una convención para nombre funciones o clases, establece tu mismo la que más te guste o consensúa una nomenclatura con tu equipo para que todos uséis el mismo criterio. Y sed fieles a él. Nota: si decides nombrar variables y funciones en inglés te aseguro que mejorarás tu inglés.

7.- Encuentra tu IDE ideal

Da igual que tal editor sea el más usado para tal lenguaje. Si no te va no te va. Es importante que te encuentres cómodo con el entorno de programación, que te resulte fácil hacer aquellas labores que vas a repetir miles de veces, como búsquedas, mover bloques de código, edición vertical, etc. Yo pienso que no existe el IDE perfecto. Pero si existe el que a mi me hace la vida más fácil. Según el lenguaje en el que estés programando tal vez valores más algunas funcionalidades que otras. La advertencias de errores, la depuración de código, el auto-completado de código, la vinculación entre la declaración de funciones y sus llamadas, el resaltado de la sintaxis, etc. son algunas de las prestaciones que yo valoro muchísimo. Yo en particular hace mucho que uso TextMate porque existen "bundles" programables para cada lenguaje/framework que uso.

8.- No escatimes en el manejo de errores

Recuerda gestionar los posibles errores que puedan surgir a medida que introduzcas directivas susceptibles de "petar". Para programas largos y complejos es la única manera de no volverte loco cuando algo falle. Aquí el IDE juega un papel fundamental.

9.- Nada de reinventar la rueda

Tu tiempo es oro. Eso lo sabe tu jefe mejor que tu. Antes de acometer la implementación de algún "script" con un propósito muy definido, dedica unos minutos a averiguar si existe alguna librería/plugin/helper que ya lo haga. Si no es exactamente como tú necesitas que sea, valora si merece la pena modificarlo para tu conveniencia. Y si ves que te atascas personalizándolo, corta por lo sano antes de verte en un "agujero de gusano". 

10.- Conoce otros paradigmas y patrones de arquitectura