viernes, 4 de abril de 2014

ADO.NET con Xamarin

Hace algunos posts atras, escribí sobre un ejemplo que había realizado con Xamarin para manejar bases de datos locales. El post es el siguiente: http://lvcios.blogspot.mx/2014/02/bases-de-datos-locales-en-xamarin.html.

Bueno, resulta que en ese ejemplo usé una librería que simplifica mucho el manejo, parecido a un MVC donde creas tu modelo en una clase y desde ahí lo manipulas. El problema de esa librería es el tamaño, es muy grande y no puedes realizar apps muy grandes si la usas. Por fortuna, existe la posibilidad de crear y usar bases de datos locales de forma "nativa", es decir, con SQL puro y duro. Para esto están lo recursos de ADO.NET.

A continuación proporciono el link a mi Git para que descarguen el ejemplo. Funciona de forma muy parecida al que había posteado anteriormente.

Saludos:

martes, 1 de abril de 2014

API REST con Django REST Framework (2 de 2)

Una vez ya escritos los modelos y después de haber interactuado con ellos en el administrador es momento de crear recursos para que pueden ser consumidos por una aplicación móvil o página web.

El primer paso es añadir la aplicación 'rest_framework' al settings.py. Después de esto hay que crear un nuevo archivo al cual le llamaremos (por convención) serializers.py el cual contendrá lo siguiente:

from rest_framework import serializers
from peliculas.models import *

class DirectorSerializer(serializers.ModelSerializer):
class Meta:
model = Director
fields = ('nombreDirector','pais')

class ActorSerializer(serializers.ModelSerializer):
class Meta:
model = Actor
fields = ('nombreActor','pais')

class PeliculaSerializer(serializers.ModelSerializer):
actor = serializers.HyperlinkedRelatedField(many = True, read_only = True, view_name = 'actor-detail')
director = serializers.HyperlinkedRelatedField(many = True, read_only = True, view_name = 'director-detail')
critica = serializers.HyperlinkedRelatedField(many = True, read_only = True, view_name = 'critica-detail')
class Meta:
model = Pelicula
fields = ('nombre','anio','sinopsis','director','actor','critica')

class CriticaSerializer(serializers.ModelSerializer):
criticas = serializers.RelatedField(many = True)
class Meta:
model = Critica
fields = ('pelicula','critica','pelicula')

Como pueden observar, aquí se define la forma en que se serializará nuestro modelo al ser enviado como response en forma de json. Después de esto, es momento de crear las vistas, es decir, la forma en que mostrará la información. Entonces en el archivo views.py escribimos lo siguiente:

from django.shortcuts import render
from peliculas.models import *
from serializers import *
from rest_framework import viewsets, generics, filters

class DirectorViewSet(viewsets.ModelViewSet):
queryset = Director.objects.all()
serializer_class = DirectorSerializer

class PeliculaViewSet(viewsets.ModelViewSet):
queryset = Pelicula.objects.all()
serializer_class = PeliculaSerializer
filter_backends = (filters.DjangoFilterBackend,)
filter_fields = ('director',)

class ActorViewSet(viewsets.ModelViewSet):
queryset = Actor.objects.all()
serializer_class = ActorSerializer

class CriticaPeliculaViewSet(viewsets.ModelViewSet):
queryset = Critica.objects.all()
serializer_class = CriticaSerializer

Aquí especificamos la consulta que hará la vista así como que tipo de serialización usará. De igual forma podemos definir filtros como el de PeliculaViewSet que nos servirá para filtrar las películas por director.
Ahora, para poder realmente usarlas necesitamos configurar las URL's a las que harán solicitudes las apps y páginas web. Eso lo definimos en el archivo urls.py que se encuentra en la carpeta principal de proyecto, es decir, EIMBackendTutorial:

Debe quedarnos así:

from django.conf.urls import patterns, include, url
from rest_framework import routers
from peliculas.views import *
from albums.views import *
from django.contrib import admin
admin.autodiscover()

router = routers.SimpleRouter()
router.register(r'directores', DirectorViewSet)
router.register(r'actores', ActorViewSet)
router.register(r'peliculas', PeliculaViewSet)
router.register(r'criticas', CriticaPeliculaViewSet)
router.register(r'albums',AlbumViewSet)
router.register(r'tracks',TrackViewSet)

urlpatterns = patterns('',
    url(r'^admin/', include(admin.site.urls)),
    url(r'api/v1/', include(router.urls)),
    url(r'api-auth/', include('rest_framework.urls', namespace='rest_framework'))
)

Donde el router sirve para organizar las rutas a las que se dirigirán las requests así como los recursos de los que harán uso. Finalmente estás url's las podemos agrupar bajo un mismo prefijo el cual, en este caso es '/api/v1/'.

Ahora bien. Correremos el proyecto y nos en el explorador abriremos la siguiente dirección:

Seguro nos va a marcar un error, el cual es porque no hemos configurado las opciones de REST_FRAMEWORK en el settings.py. Dichas opciones se añaden agregando lo siguiente al final del settings.py:

REST_FRAMEWORK = { 
'DEFAULT_FILTER_BACKENDS': ('rest_framework.filters.DjangoFilterBackend',),
}

Nos mostrará un formulario y un área de visualización semejante al administrador de Django. Desde ahí podemos agregar información y visualizarla en formato JSON.  Esa misma url sirve para hacer post y get usando ajax de jquery como se muestra en el ejemplo que adjunto en la carpeta AjaxExample.
Sin embargo, si ustedes lo prueban se darán cuenta que la consola del explorador marca error de CSRF. Esto ocurre porque no hemos especificado la configuración de conexiones entrantes, es decir, tal cual está nuestro proyecto solo nosotros podemos hacer post, get, put y delete. 

Para dar acceso a cualquier otra conexión o desde cualquier otra aplicación hacemos uso de la libreria django-cors-headers la cual sirve para esto. Lo único que tenemos que hacer es instalarla, lo cual ya hicimos al momento de instalar lo que venia en requirements.txt. Ahora para configurar los accesos tenemos que agregar a las apps del settings.py la app 'corsheaders' y en la sección de middlewarer_classes añadimos la siguiente línea: 'corsheaders.middleware.CorsMiddleware'. No olviden la coma al final.

Por último, al final de nuestro archivo settings.py añadimos lo siguiente:
CORS_ORIGIN_ALLOW_ALL = True 

Ya con eso es suficiente para aceptar cualquier conexión. Si desean saber más acerca de como configurar las conexiones entrantes lean la documentación de Django-cors-headers.

Finalmente, si desean desactivar el explorador por defecto del rest-framework añadimos a las opciones de rest-framework lo siguiente:

'DEFAULT_RENDERER_CLASSES': (#con esta configuracion desactivo el visor por defecto de rest_framework en todo el sistema
'rest_framework.renderers.JSONRenderer',
),

Con eso el explorador por default no estará disponible.

Hasta aquí las dos partes del tutorial

Todo el código lo pueden descargar de aquí:
https://bitbucket.org/Lvcios/eimtutorial/src


PRIMERA PARTE
NOTA: Estos tutoriales estarán en video, aumentados y corregidos en la página del EIM proxiamente.


API REST con Django REST Framework (1 de 2)

Como parte del staff del Concurso Nacional de Emprendimiento e Innovación Móvil 2014 se me solicitó realizar un minitutorial acerca de como crear una API REST usando el framework para desarrollo web "Django" el cual está escrito en Python y con el cual se pueden crear poderosas aplicaciones y sitios web altamente versátiles.

El tutorial se dividirá de la siguiente forma:
Primera parte: Creación de proyecto, apps y modelo.
Segunda parte: Django REST Framework Configuraciones de Acceso.

Anexos: Instalación de Python. Instalación de paquetes vía pip/easy_install. Archivos estáticos en Django. Uso básico de Git. Variables de entorno en Windows.

Asumiendo que ya saben usar pip install o easy_install  lo que sigue es instalar todas las librerías que se señalan en el archivo requirements.txt. El código fuente de todo el proyecto y el requirements.txt lo descargan de aqui:

https://bitbucket.org/Lvcios/eimtutorial/src

Supongamos que queremos realizar una aplicación que muestre información sobre películas, es decir, críticas, actores, director, datos importantes como cuanto recaudó, en que año salio,  cuantas nominaciones a los oscares tuvo, etc. Es claro ver que el presentar esta información en una base de datos requiere de mas de una tabla si hablamos de SQL o de modelos embebidos si estamos usando alguna base de datos NoSQL. Como sea, el primer paso es crear un proyecto en Django con el siguiente comando:

python django-admin.py startproject EIMBackendTutorial

Lo anterior creará una carpeta con el nombre especificado junto con los archivos mínimos necesarios para correr el proyecto. Para correr el proyecto entramos en la carpeta del mismo y ejecutamos el siguiente comando:

python manage.py runserver

Este comando nos indicará que nuestra aplicación está corriendo en determinada dirección la cual es por defecto http://127.0.0.1:8000/ Para romper el proceso  basta con presionar ctrl + c en la consola.

Lo que sigue es crear nuestro modelo en Django, para eso tenemos que crear una aplicación la cual llamaré "Movies" y la creo de la siguiente manera:

python manage.py startapp peliculas

Al igual que startproject, startapp crea una carpeta con los archivos mínimos necesarios para crear una aplicación. Dentro de esa carpeta tenemos el archivo models.py que es donde escribiremos nuestro modelo de datos que posteriormente será leído por el api que crearemos con RESTFramwork. Básicamente el modelo de datos seria el siguiente:

#endcoding:utf-8
from django.db import models

# Create your models here.

class Director(models.Model):
nombreDirector = models.CharField(max_length = 100)
pais = models.CharField(max_length = 100)

def __unicode__(self):
return self.nombreDirector

class Actor(models.Model):
nombreActor = models.CharField(max_length = 100)
pais = models.CharField(max_length = 100)
def __unicode__(self):
return self.nombreActor

class Pelicula(models.Model):
nombre = models.CharField(max_length = 100)
anio = models.DateField()
sinopsis = models.TextField()
director = models.ManyToManyField(Director, related_name = 'director')
actor = models.ManyToManyField(Actor, related_name = 'actor')

def __unicode__(self):
return self.nombre

class Critica(models.Model):
pelicula = models.ForeignKey(Pelicula, related_name = 'critica')
critica = models.TextField()
def __unicode__(self):
return unicode(self.pelicula) + ' ' + unicode(self.critica)


Y para poder visualizarlos en el administrador por defecto de django creamos un archivo llamado admin.py dentro de la misma carpeta con lo siguiente

# -*- coding: UTF-8 -*-
from django.contrib import admin
from peliculas.models import *

admin.site.register(Director)
admin.site.register(Actor)
admin.site.register(Pelicula)

admin.site.register(Critica)

Con esto ya es posible agregar datos a la base de datos desde el Administrador. Ahora solo queda sincronizar la bd con el siguiente comando:

python manage.py syncdb


Es súper importante mencionar que deben registrar la aplicación en el settings.py. Busquen dentro de ese archivo la sección de INSTALLED_APPS y solo agregan 'peliculas'. No olviden colocar la coma al final.

Al momento de sincronizar la base de datos nos mostrará los errores, si es que los hay. Si no hay errores entonces nos pedirá crear un súper usuario. Este paso lo podemos omitir si queremos pero en este tutorial si lo crearemos.

Una vez sincronizados los modelos con la base de datos corremos el proyecto con el comando indicado anteriormente y en el explorador tecleamos: http://127.0.0.1:8000/admin/. Encontrarán un pantalla de log-in y a continuación verán el listado de los modelos que creamos. Desde el administrador de Django ya poseé la capacidad de realizar inserciones, modificaciones, consultas y eliminaciones de registros. Recomiendo explorarlo poco a poco.

El administrador posee muchas opciones las cuales se pueden personalizar a través de código. De igual forma, los modelos se pueden manipular desde la consola y realizar operaciones y tests. Esos son temas que no veremos aquí pero están muy bien documentados en la página oficial de DjangoProject.

Hasta aquí llega la primera parte del tutorial.

El código se lo pueden descargar de aqui:
https://bitbucket.org/Lvcios/eimtutorial/src

SEGUNDA PARTE
NOTA: Estos tutoriales estarán en video, aumentados y corregidos en la página del EIM proxiamente.