1. No category

Preciosa Documentation
Publicación dev
Martín Gaitán y colaboradores
11 de May de 2015
Índice general
1. A modo de intro
2. Índice
2.1. Instalación de la plataforma . . . . .
2.2. Arquitectura . . . . . . . . . . . . .
2.3. La API de Preciosa . . . . . . . . . .
2.4. Tutorial de uso de la aplicación móvil
2.5. Preguntas Frecuentes . . . . . . . . .
2.6. Glosario . . . . . . . . . . . . . . .
2.7. Licencia . . . . . . . . . . . . . . .
3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5
5
9
11
14
15
16
16
3. Preciosa en los medios
19
4. Indices and tables
21
I
II
Preciosa Documentation, Publicación dev
Preciosa es una plataforma web colaborativa con aplicaciones para teléfonos inteligentes que facilita el relevamiento
de precios y ayuda a encontrar mejores ofertas.
A diferencia de otras aplicaciones existentes, Preciosa no limita la información a precios de productos bajo acuerdo y
enfatiza la participación de los usuarios para mantener la información actualizada.
issue tracker https://github.com/mgaitan/preciosa/issues
twitter @PreciosaApp
lista https://groups.google.com/forum/#!forum/preciosa-devs
estado
email Martín Gaitán <[email protected]>
Índice general
1
Preciosa Documentation, Publicación dev
2
Índice general
CAPÍTULO 1
A modo de intro
(...) Entran a un super, agarran el paquete de harina, le sacan una fotito con su cámara al código de barra
(o buscan el producto por nombre, marca, etc.) y la app les dice cuál es el precio de referencia (o del
acuerdo), en qué super cercano está más barato, cuándo y cuánto aumentó, etc.
Idea original
Repercusión y primeros pasos
3
Preciosa Documentation, Publicación dev
4
Capítulo 1. A modo de intro
CAPÍTULO 2
Índice
2.1 Instalación de la plataforma
Preciosa es una aplicación web basada en Django y Geodjango. Como depende de una base de dato espacial (en
particular, usamos PostGis) y de muchos otros componentes, no es trivial (pero tampoco difícil) armar un entorno de
programación.
Esta sección describe distintos modos, dependiendo el sistema operativo y el objetivo de la instalación.
Para la configuración de un entorno de desarrollo rápido, la recomendación es utilizar Vagrant.
2.1.1 Creación de un entorno de desarrollo basado en Vagrant
El objetivo de este documento es permitir que desarrolladores puedan crear sus entornos de desarrollo rápidamente e
ir a lo que interesa: contribuir con código.
Se basa en Vagrant, una herramienta para la creación y configuración de entornos de desarrollo virtualizados.
En una maquina virtual basada en Ubuntu, Vagrant realiza una instalación automatizada del entorno de desarrollo
(configurando base de dato, dependencias, usuario, etc.) y configura la “conexión de red” y la carpeta compartida para
trabajar desde la maquina física, independientemente del sistema operativo que tenga, y “ejecutar” el código en la
maquina virtual.
Atención: Una forma alternativa para desarrolladores más experimentados o que desean mayor control sobre su
entorno se describe en Creación de un entorno de desarrollo local en Linux.
Esta guía está pensada principalmente para sistemas Linux Ubuntu/Debian, y esta probado para VirtualBox >= 4.3 y
Vagrant >= 1.3.5, pero debería funcionar desde cualquier sistema operativo host. Leé la documentación de Vagrant
para obtener información particular para tu sistema operativo.
Instalación de Vagrant y VirtualBox
Para instalar y ejecutar Vagrant y VirtualBox en tu shell:
sudo apt-get install vagrant virtualbox
Por ultimo instalamos un plugin de Vagrant que es necesario para que todo funcione bien:
vagrant plugin install vagrant-vbguest
5
Preciosa Documentation, Publicación dev
Instalando el Entorno
Posicionados en la carpeta raíz del repositorio instalamos el entorno de desarrollo con un solo comando:
vagrant up
Va a tomar un tiempo la instalación porque implica bajar una maquina virtual completa pero luego de eso accedemos
via ssh a una maquina virtual completa:
vagrant ssh
Adentro del entorno nos posicionamos en la carpeta preciosa y creamos un superuser:
cd preciosa
python manage.py createsuperuser
y levantamos el server de Django:
sudo python manage.py runserver 0:8000
Una vez ejecutado, Preciosa estará disponible en tu browser tecleado http://localhost:8000
Para manipular la base de datos podes acceder a /admin en tu browser en el puerto especificado e ingresar con el
usuario y contraseña creados en createsuperuser.
El script de provisión
El script que Vagrant ejecuta para crear por primera la maquina virtual se encuentre en /tools/install.sh y es
el siguiente:
#!/bin/bash
sudo
sudo
sudo
sudo
sudo
sudo
apt-get
apt-get
apt-get
apt-get
apt-get
apt-get
-y
-y
-y
-y
-y
-y
install
install
install
install
install
install
language-pack-es-base language-pack-en-base
postgresql-9.1 libpq-dev postgresql-9.1-postgis gdal-bin
postgresql-contrib
git python-pip python-dev
libxml2-dev libxslt1-dev
libjpeg-dev zlib1g-dev libpng12-dev
# enforce UTF8 encoding in all databases (instead of SQL_ASCII):
sudo -u postgres pg_dropcluster --stop 9.1 main
sudo -u postgres pg_createcluster 9.1 main -e UTF8
sudo -u postgres pg_ctlcluster 9.1 main start
sudo
sudo
sudo
sudo
sudo
sudo
-u
-u
-u
-u
-u
-u
postgres
postgres
postgres
postgres
postgres
postgres
psql -c "CREATE ROLE dev LOGIN PASSWORD 'dev' SUPERUSER VALID UNTIL 'infinity';"
createdb template_postgis
psql -d template_postgis -f /usr/share/postgresql/9.1/contrib/postgis-1.5/postgis.sq
psql -d template_postgis -f /usr/share/postgresql/9.1/contrib/postgis-1.5/spatial_re
psql -d template_postgis -f /usr/share/postgresql/9.1/contrib/postgis_comments.sql
psql -c "CREATE DATABASE preciosa WITH OWNER=dev TEMPLATE=template_postgis CONNECTIO
ln -s /vagrant/ /home/vagrant/preciosa
cd preciosa
sudo pip install -r requirements.txt
cp preciosa/local_settings.py.template preciosa/local_settings.py
python manage.py syncdb --noinput
python manage.py createsuperuser --username=preciosa [email protected] --noinput
6
Capítulo 2. Índice
Preciosa Documentation, Publicación dev
python manage.py migrate
python manage.py loaddata fixtures/flatpages.json fixtures/blog.json fixtures/newsletter.json fixture
2.1.2 Creación de un entorno de desarrollo local en Linux
El objetivo de este documento es permitir que los desarrolladores puedan crear sus entornos de desarrollo en una
maquina local. Esta instalación es para usuarios más avanzados, que prefieren un control particular sobre la instalación
o necesitan mayor performance. En cualquier otro caso recomendamos vagrant.
Esta guía está pensada principalmente para sistemas Linux Ubuntu/Debian, aunque hay comentarios para otros entornos.
Preparación del entorno
1. Instalación de virtualenv
virtualenv nos permite aislar la instalación de paquetes de la instalación del sistema. Es buena práctica utilizarlo por
dos motivos:
1. No genera conflictos de los paquetes necesarios para correr Preciosa con los paquetes de sistema
2. No instala paquetes innecesarios en el sistema
Para instalarlo ejecutar en tu shell:
pip install virtualenv
virtualenv --no-site-packages preciosa_ve
Una vez instalado, es necesario activar el entorno usando:
source preciosa_ve/bin/activate
Para desactivarlo basta ejecutar deactivate en cualquier path del terminal.
En Windows no se puede usar el comando source. Para activar el virtualenv luego de haber creado
preciosa_ve, ejecutar
preciosa_veScriptsactivate
La creación del directorio preciosa_ve se hace en un directorio de trabajo, preferentemente, para evitar modificar
el directorio del proyecto actual.
2. Instalación de los requerimientos
Preciosa requiere muchos paquetes para que funcione correctamente. Para instalar lo estrictamente necesario en tu
entorno basta ejecutar:
pip install -r requirements.txt
Opcionalmente, si querés algunos otros paquetes útiles (como IPython), podés instalar los paquetes opcionales:
pip install -r requirements/optional.txt
Atención: Para que estos comandos funcionen, tenés que ejecutarlo desde root de Preciosa (es decir, la
carpeta que creaste cuando clonaste el repositorio) con el virtualenv activado.
2.1. Instalación de la plataforma
7
Preciosa Documentation, Publicación dev
Instalar y configurar Postgres y PostGIS
Como Preciosa utiliza funciones de geolocalización basadas en Geodjango, requiere una base de datos con soporte
GIS. Usamos Postgres 9.1 con PostGIS >1.5 . Seguí esta guia en la wiki de Preciosa, para instalar lo necesario.
Luego hace falta indicarle a Django la configuración de la base de datos recién creada, y te conviene hacerlo en
un archivo local_settings.py, que está excluído del control de versiones. Dejamos un template que debería
funcionar sin cambios si seguiste el tutorial de instalación de la base de datos textualmente:
cp preciosa/local_settings.py.template preciosa/local_settings.py
Crear esquemas y cargar datos
1. Crear base de datos
Para crear el schema de la base de datos basta ejecutar los comandos:
python manage.py syncdb --noinput
luego:
python manage.py migrate
y luego:
python manage.py createsuperuser
2. Cargar los fixtures:
python manage.py loaddata fixtures/flatpages.json fixtures/blog.json fixtures/newsletter.json fi
Los fixtures cargan datos al schema creado en la etapa anterior.
Ejecutando Preciosa
Primero probá si todo salió bien corriendo los tests:
python manage.py test
Para correr Preciosa basta ejecutar:
python manage.py runserver
Una vez ejecutado, Preciosa estará disponible en el puerto indicado en la terminal (por defecto es el 8000)
Para hacer uso del admin de Django y editar la base de datos, basta acceder a /admin en tu browser en el puerto
especificado y acceder con el usuario y contraseña creados en syncdb.
2.1.3 Creación de un entorno de desarrollo local en Mac
Recomendamos enfáticamente usar la vagrant
Atención: No obstante, aceptamos la contribución de escribir una guia de instalación local en un entorno Max Os
X
8
Capítulo 2. Índice
Preciosa Documentation, Publicación dev
2.1.4 Creación de un entorno de desarrollo local en Windows
Recomendamos enfáticamente usar la vagrant
Atención: No obstante, aceptamos la contribución de escribir una guia de instalación local en un entorno Windows.
Ver tickets #127 y #153
2.1.5 Instalación en Producción
TO DO
2.2 Arquitectura
2.2.1 Modelo de base de datos
Los
modelos
fundamentales
de
Preciosa
se
definen
en
la
</preciosa/precios/models.py>. Un diagrama simplificado es el siguiente:
aplicación
precios
2.2.2 Algoritmos de “precios”
Como se observa, el relevamiento de un precio está asociado a un producto y a una sucursal específica (y, opcionalmente, a un usuario), además de su fecha de relevamiento.
Al ser improbable la existencia de precios para cualquier producto en todas las sucursales, la consulta del precio de
un producto para una sucursal en particular se realiza a través del método PrecioManager.mas_probables(),
que realiza un degradado de información:
1. Si existe un precio relevado para el producto en la sucursal, dentro del rango de máximo de dias, se devuelve
ese dato
2. En caso de que no exista, se buscan precios para el producto en sucursales de la misma cadena o un radio
definido.
3. Si no hay precios en Sucursales, se buscan el precio del producto en la “Sucursal Online” de la Cadena.
4. Si no hay sucursal online asociada o no existe un precio vigente, no se devuelve un resultado.
def mas_probables(self, producto, sucursal, dias=None, radio=10):
"""
Cuando no hay datos especificos de un
producto para una sucursal (:meth:`PrecioManager.historico`),
debe ofrecerse un precio más probable. Se calcula
- Precio más nuevo para el producto en otras sucursales
de la misma cadena en la ciudad y/o un radio de distancia si es dado
- En su defecto, precio online de la cadena
"""
qs = self.historico(producto, sucursal, dias)
if len(qs) > 0:
return qs
qs = super(PrecioManager, self).get_queryset()
2.2. Arquitectura
9
Preciosa Documentation, Publicación dev
# precios para sucursales de la misma cadena de la ciudad
cercanas_ciudad = sucursal.cercanas(misma_cadena=True).values_list('id',
flat=True)
if radio:
cercanas_radio = sucursal.cercanas(radio=radio,
misma_cadena=True).values_list('id',
flat=True)
else:
cercanas_radio = []
cercanas = set(list(cercanas_ciudad) + list(cercanas_radio))
qs = qs.filter(producto=producto,
sucursal__id__in=cercanas).distinct('precio')
if qs.exists():
return self._registro_precio(qs)
qs = super(PrecioManager, self).get_queryset()
qs = qs.filter(producto=producto,
sucursal__cadena=sucursal.cadena,
sucursal__online=True).distinct('precio')
# precios online
if qs.exists():
return self._registro_precio(qs)
return []
Análogamente se calculan los mejores precios. Dado un producto, una ubicación (o sucursal) y radio de distancia, se
obtiene una lista de los mejores precios en la zona para ese producto.
def mejores(self, producto, ciudad=None, punto_o_sucursal=None,
radio=None, dias=None, limite=5):
"""
devuelve una lista de instancias Precio para el producto,
ordenados por menor precio (importe) para
un determinado producto y un radio de distancia o ciudad.
Sólo considera el último precio en cada sucursal.
"""
#si tiene puto.. tenemos que tener el radio
if punto_o_sucursal and not radio:
raise ValueError(
'Si se especifica el punto o sucursal debe proveer el radio')
if radio and not punto_o_sucursal and not ciudad:
raise ValueError(
'Si se especifica el radio debe proveer el punto o sucursal')
#si no tenemos una ciudad o un punto con radio
if not ciudad and not radio:
raise ValueError(
'Debe proveer una ciudad o un radio en kilometros')
qs = super(PrecioManager,
self).get_queryset().filter(producto=producto, activo__isnull=False)
if dias:
desde = timezone.now() - timedelta(days=dias)
qs = qs.filter(created__gte=desde)
10
Capítulo 2. Índice
Preciosa Documentation, Publicación dev
if ciudad:
if isinstance(ciudad, City):
ciudad = ciudad.id
qs = qs.filter(sucursal__ciudad__id=ciudad).distinct(
'sucursal')[:limite]
elif radio:
if isinstance(punto_o_sucursal, Sucursal):
punto = punto_o_sucursal.ubicacion
else:
punto = punto_o_sucursal
cercanas = Sucursal.objects.filter(ubicacion__distance_lte=(punto,
D(km=radio)))
cercanas = cercanas.values_list('id', flat=True)
qs = qs.filter(sucursal__id__in=cercanas).distinct(
'sucursal')[:limite]
if qs.exists():
return sorted(qs, key=lambda i: i.precio)
return []
2.3 La API de Preciosa
Atención: La API está en plena fase de diseño e implementación. Puede cambiar sin previo aviso
2.3.1 Breve intro a Django Rest Framework
La API REST de Preciosa está implementada con Django Rest Framework (DRF) Hay 3 módulos que importan
serializers.py
views.py
urls.py
El primero define los serializadores, conceptualmente análogos a un formulario, que dado un objeto (en general, una
instancia de un Modelo), define las reglas de como debe mostrar los atributos en un formato de representación (como
JSON) o, en sentido inverso, como debe recontruir un objecto a partir de una representación.
El segundo módulo define las “vistas”, que son similares a las de Django (aunque el objeto Response que usa la
API es ligeramente distinto). Para los casos de uso más comunes se pueden usar Class Based View (análogas
a las CBV de Django, que saben listar, mostrar, crear, etc. objetos/instancias de modelos) o una abstracciín aún más
general denominada ViewSet, que puede pensarse como una factory de Class Based Views: un Viewset para un
modelo, ya sabe hacer todos los casos comunes y, como yapa, mediante un Router, nos genera automáticamente
una estructura de urls tipicas. Por último, puede definirse una vista tipica como función, decorada con el decorador de
DRF @api_view
Las urls son iguales a las de cualquier aplicación Django, salvo por la utilización opcional de un router (una factory
de URLs).
Preciosa utiliza una mezcla de todas las posilidades de que brinda DRF.
Por ejemplo, los endpoints para modelos simples como Cadena (Walmart, Disco, etc), utilizan ViewSets, algunos
listados/detalles como el del modelo Producto (que puede accederse en general o para una sucursal en particular)
usa CBVs y la vista de detalle para productos (en una sucursal) usa una vista basada implenentada como función
decorada.
2.3. La API de Preciosa
11
Preciosa Documentation, Publicación dev
Advertencia: DISCLAIMER: Estamos aprendiendo a usar este framework sobre la marcha. Si tenés ideas de
cómo mejorar, recomendaciones, etc. estaremos contentos de recibirlas.
2.3.2 Autenticación básica basada en token
La API de preciosa utiliza una manera muy simple y opcionalmente anónima de autenticación. El motivo de usar
autenticación es para prevenir/aminorar el vandalismo y el uso desleal de los recursos.
Cada usuario está asociado a un token. Registrar un usuario para obtener un token es muy fácil. Basta hacer un POST
al enpoint
http://preciosdeargentina.com.ar/api/v1/auth/registro
Opcionalmente la petición puede enviar esta información
uuid un identificador único del equipo (ejemplo, el movil)
nombre un nombre elegido por el usuario para el equipo
plataforma la plataforma subyacente (ejemplo: “Android”)
phonegap si el cliente es Phonegap, la versión.
plataforma_version la versión de la plataforma (ejemplo “2.2” para Android)
preciosa_version la versión del cliente de preciosa.
Los parámetros no son obligatorios, pero cualquiera subconjunto que se envie debe incluir el uuid (sin uuid ninguna
información quedará guardada)
Obtenido el token, este debe enviarse para cada subsecuente petición. Puede hacerse configurando el un header HTTP.
Por ejemplo
Authorization: Token XXXXX
Donde XXXX es el token dado.
Desde jQuery, puede configurarse para todas las peticiones ajax
$.ajaxSetup({
headers: {
'Authorization': "Token XXXXX"
}
});
Alternativamente, se puede enviar un token como parámetro en el QUERY de la URL. Por ejemplo:
api/v1/<end_point>/?token=XXXX
Si ya se cuenta con un usuario y contraseña (por ejemplo un Voluntario registrado via web) se puede obtener un token
enviando parámetros usuario y password al recurso
http://preciosdeargentina.com.ar/api/v1/auth/token
Devuelve el token en formato json de igual manera que /auth/registro
2.3.3 ¿Qué se puede hacer?
Como DRF ofrece una versión HTML del contenido de la API, gran parte de los recursos que la API de preciosa
ofrece pueden autodescubrirse navegando desde la raiz.
12
Capítulo 2. Índice
Preciosa Documentation, Publicación dev
http://preciosdeargentina.com.ar/api/v1/
2.3.4 Otros recursos
Detalle de una sucursal http://preciosdeargentina.com.ar/api/v1/sucursales/<pk>
Listado de productos con precios conocidos en una sucursal http://preciosdeargentina.com.ar/api/v1/sucursal
Es igual que http://preciosdeargentina.com.ar/api/v1/productos, pero filtra aquellos productos en los que para esa sucursal hay precios conocidos.
Detalle de producto para una sucursal en particular http://preciosdeargentina.com.ar/api/v1/sucursales/<p
Este recurso devuelve un detalle exhaustivo de los precios probables y los mejores para una zona, incluyendo
sucursales asociadas a esos mejores precios.
2.3.5 Filtros
El listado de productos (http://preciosdeargentina.com.ar/api/v1/productos) puede recibir los siguientes parámetros
opcionales via GET
q cadena a buscar. Usa el criterio definido en Producto.objects.buscar (es decir, dará los mismos resultados
que el buscador de la web). Por ejemplo, puede ser un conjunto de palabras claves o un código de barras
(completo o los primeros números desde la izquierda).
limite cuantos resultados mostrar para el criterio
pk limita la busqueda a un PK de producto en particular
El listado de sucursales (http://preciosdeargentina.com.ar/api/v1/sucursales) puede recibir los siguientes parámetros
via GET
q cadena a buscar. Por ejemplo, nombre de ciudad, cadena, o calle.
lat, lon y radio: una posición y el radio en kilometros que determina las zona donde se buscan sucursales. Estos
parámetros son interdependientes.
El listado de Ciudades (http://preciosdeargentina.com.ar/api/v1/ciudades) puede recibir los siguientes parámetros via GET:
q cadena a buscar. Por ejemplo, nombre de ciudad o provincia.
2.3.6 Formatos
DRF sabe interpretar el content-type preferido en el encabezado de la petición HTTP. Alternativamente puede
definirse mediante el parámetro format en la URL del recurso. Por ejemplo
http://preciosdeargentina.com.ar/api/v1/cadenas/?format=json
Forzará el serializado de la lista de cadenas en formato JSON, aun desde un navegador web que acepta HTML.
2.3.7 Tasas de limitación (throttling)
Complementario a la autenticación, la API tiene un sistema de limitación de peticiones (throttling), para evitar el abuso
de usuarios malintencionados.
Actualmente las tasas son:
2.3. La API de Preciosa
13
Preciosa Documentation, Publicación dev
30 peticiones por dia para usuarios anónimos. Actualmente permite acceder a la URL /auth/registro
40 peticiones por minuto para usuarios autorizados. Es para evitar los picos de peticiones automatizadas.
1000 peticiones por dia para usuarios autorizados. Es para evitar el “leeching”.
2.4 Tutorial de uso de la aplicación móvil
Preciosa tiene un cliente para dispositivos móviles. Esta es una guía de uso de la versión actual.
2.4.1 Instalación
Nuestra intención es que Preciosa sea muy fácil de usar y funcione en la mayor cantidad de teléfonos posible. Existe una aplicación descargable desde Google Play para teléfonos con Android 2.1 o superior. Otras
plataformas o dispositivos pueden acceder a una versión simplificadada para el navegador web desde la url
http://mobile.preciosdeargentina.com.ar [1]_.
2.4.2 Paso 1: elegir tu sucursal
Una vez que instalaste la aplicación, el primer paso es elegir la sucursal de supermercado en la que estás (o querés
consultar precios).
Hay tres maneras de elegir una sucursal:
Buscar por palabras clave. Por ejemplo, podés buscar el nombre de la cadena y la calle, o intentar con el
nombre de tu barrio y tu ciudad.
Elegir una sucursal que ya elegiste antes.Esta es la opción “Recientes”. Se van guardando las sucursales que
más frecuentemente elegís, para facilitar la búsqueda.
O podés buscar sucursales cercanas.Esta es una función experimental que utiliza geolocalización, es decir,
intenta detectar tu ubicación y te da un listado de las sucursales conocidas más cercanas. Si estás en un super, la
primera que aparece debería ser aquella en la que estás.
Si creés que no te detecta correctamente la ubicación, poder
corregirla con el botón Configurar Ubicación que sale al pie de de la solapa, y eligiendo tu ubicación correcta
en el mapa.
¿No aparece la sucursal que buscás? ¡Cargala desde el panel de voluntarios!
2.4.3 Paso 2: Buscar productos
Una vez que encontraste la sucursal que buscabas, podés consultar productos.
Las opciones son: usar el buscador de palabras claves, o, sí tu teléfono tiene una buena cámara, usar el lector de
código de barras. Tenés que tener en cuenta que aun si no te funciona el lector de códigos, podés buscar ingresando
los primeros números que aparecen bajo el código del producto. (¡Como hacen las cajeras!).
Actualmente conocemos más de 30mil productos (aunque todavía no sabemos los precios de todos). Si buscás un
producto específico que te parece muy importante que esté y no aparece, por favor avisanos.
14
Capítulo 2. Índice
Preciosa Documentation, Publicación dev
2.4.4 Paso 3: ¡Comparar los precios!
Una vez que encontraste el producto que buscabas, haciendo click verás los detalles. Preciosa intenta decirte cuál es el
precio más probable que conoce para la sucursal en la que estás(que elegiste en el paso 1) y te pide que la confirmes
o la corrijas, con los botones SIoNO.
Este paso es la esencia de Preciosa. Cuando vos actualizás un precio estás ayudando a todos los que consulten por
ese producto más adelante. Te pedimos que seas solidario y envíes información fidedigna. ¡Acá está la inteligencia
colectiva contra la inflación!
Una vez que enviaste el precio que estás viendo en la góndola, ¡verás los mejores preciosque Preciosa conoce (gracias
a los usuarios) en otros supermercados cercanos! Si sabés los precios para ese mismo producto, podés saber si te
conviene o no comprarlo donde estás.
**
¿Te gusta la idea?
¡Buenísimo! Queremos hacer de Preciosa una herramienta útil para defender el bolsillo de todos los argentinos. Tenemos muchas ideas y funciones nuevas, pero necesitamos ser miles usando Preciosa. ¡Ayudanos a difundir!
2.5 Preguntas Frecuentes
2.5.1 ¿En qué lenguaje está programado Preciosa?
La aplicación web (sitio + API) se basa en el framework Django_, programado principalmente con Python_. Para la
API rest usamos ‘Django Rest Framework‘_
2.5.2 ¿Puedo ayudar en las aplicaciones móviles?
Por supuesto. El respositorio está acá. La aplicación cliente es común para las distintas plataformas está basada en
HTML5 y javascript utilizando Phonegap_
2.5.3 Quiero ayudar, ¿cómo hago?
En primer lugar, ¡muchas gracias por eso! Primero anotate en la lista de correo de colaboradores. Luego fijate cómo
trabajamos.
2.5.4 ¿Cómo trabajamos?
En general tenemos milestones <https://github.com/mgaitan/preciosa/issues/milestones>, es decir, conjuntos de tareas
prioritarias para los objetivos de corto plazo.
Preciosa tiene algunos desarrolladores “core-committers” pero recibe activamente código de la comunidad a través de
pull requests.
Proponé tus ideas o preguntá qué es prioritario hacer en la lista de correo. Luego hacés un fork y pull request (contra
la rama develop) de tus aportes!
Si encontrás bugs, reportalos en el ‘issue tracker‘_.
2.5. Preguntas Frecuentes
15
Preciosa Documentation, Publicación dev
2.5.5 ¿Por qué programan y documentan en español?
Preciosa comenzó como un proyecto particularmente orientado a Argentina, donde el problema del aumento de precios
afecta cada vez más el poder adquisitivo de la población. No sólo se trata de construir una plataforma colaborativa,
sino que el propio desarrollo del proyecto se realiza de manera abierta a la comunidad.
En este contexto, la idea fue ampliar la base de potenciales colaboradores de Argentina (y Latinoamérica), rompiendo
la barrera de la limitación idiomática.
Sabemos y aceptamos que la lengua franca en el software es el inglés, pero creemos que esta excepción, por ahora, es
válida.
2.6 Glosario
EAN, UPC distintos tipos de códigos de barras.
Scrapping Web Scraping es una técnica utilizada mediante programas de software para extraer información de
sitios web. Usualmente, estos programas simulan la navegación de un humano en la World Wide Web ya sea
utilizando el protocolo HTTP manualmente, o incrustando un navegador en una aplicación como puede ser
Internet Explorer o Mozilla Firefox.
JSON acrónimo de JavaScript Object Notation, es un formato ligero para el intercambio de datos. JSON es un
subconjunto de la notación literal de objetos de JavaScript que no requiere el uso de XML.
2.7 Licencia
Por las virtudes técnicas y ventajas estratégicas que aporta, el desarrollo de Preciosa es Software Libre, basado en la
licencia AGPL.
Podés leer el hilo de discusión en la lista de correo donde se discutió el tema.
Además, el desarrollo abierto y comunitario, donde las ideas se discuten públicamente. Gracias a esta transparencia y
la empatía con el fin social del proyecto, decenas de voluntarios han colaborado ad honorem.
Gracias a ser También recibimos la colaboración y apoyo del equipo técnico de Huayra Linux, el sistema operativo libre
del programa Conectar Igualdad. A partir de la versión 2.0, Huayra incluye a Preciosa como una de sus aplicaciones
destacadas.
2.7.1 Términos
Podés leer el texto completo de la licencia en el sitio de GNU.
Preciosa, software colaborativo para relevar precios y encontrar mejores ofertas
Copyright (c) 2014 Martín Gaitán and contributors.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, 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 Affero General Public License for more details.
16
Capítulo 2. Índice
Preciosa Documentation, Publicación dev
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
2.7. Licencia
17
Preciosa Documentation, Publicación dev
18
Capítulo 2. Índice
CAPÍTULO 3
Preciosa en los medios
Durante febrero de 2014 (cuando retomamos el proyecto, iniciado originalmente en junio de 2013) Preciosa, aún en
desarrollo, tuvo muchísima repercusión en los medios:
Entrevista en Radio Nacional
Entrevista en Radio Madres/Universidad de Córdoba
Nota en Agencia Télam.
Entrevista en Canal 10 de Córdoba
Y muchísimas aparaciones más.
19
Preciosa Documentation, Publicación dev
20
Capítulo 3. Preciosa en los medios
CAPÍTULO 4
Indices and tables
genindex
modindex
search
21
Preciosa Documentation, Publicación dev
22
Capítulo 4. Indices and tables
Índice
E
EAN, 16
J
JSON, 16
S
Scrapping, 16
U
UPC, 16
23