Programacion Interactiva

Descubre una Nueva y Poderosa Herramienta.

FrameWork de Nueva Generacion

Acceso a tu Informacion desde cualquier Dispositivo con Navegador.

Enfoque en el Backend

Frontend de forma facil con Odoo y XML.

Creacion de Verticales

Creacion de nuevas Verticales Conquistando nuevos Mercados.

Tu marca aqui mismo

Llega a miles de personas.

Publicidad

viernes, 27 de mayo de 2016

Solucion al Error bundle 'web.assets_common' o error lessc

SoluciĆ³n de Errores lessc y web.assets_common




    ƚltimamente las nuevas librerĆ­as de Odoo 9 para mejorar el ambiente (interfaz) web tienen una serie de conflictos con el Sistema Operativo, en ocasiones podemos ver errores como la imagen anterior, errores 404, errores 500, etc., las causas pueden ser muchas pero la mayorĆ­a se basan en la librerĆ­a nodejs y npm, para dar soluciĆ³n a este error debemos ejecutar los siguientes comandos:

  1. sudo apt-get install nodejs
  2. sudo apt-get install npm
  3. sudo npm install -g less
  4. sudo npm install -g less-plugin-clean-css
  5. sudo ln -s /usr/local/bin/lessc /usr/bin/lessc
  6. sudo ln -s /usr/bin/nodejs /usr/bin/node


Listo, solo debemos reiniciar el servicio de Odoo y refrescar el navegador web, en ocasiones sera necesario tener que eliminar los archivos temporales y la cache del navegador.

Nota: Estos comandos solo funcionan para los Sistemas derivados de debĆ­an (Ubuntu Server, Ubuntu Desktop, Linux Mint, erc..)

jueves, 26 de mayo de 2016

¿Por que hay tantos Pythons?

Python es asombroso.


Sorprendentemente, esa es una declaraciĆ³n bastante ambigua. ¿A quĆ© me refiero con ‘Python’?, ¿Me refiero a la interfaz abstracta de Python?, ¿Me refiero a CPython, la implementaciĆ³n comĆŗn de Python (y no confundir con Cython, que son similares en sus nombres)?, ¿O me refiero a algo completamente distinto? Tal vez me estĆ© refiriendo indirectamente a Jython, o IronPython, o PyPy. O tal vez me he ido al extremo y estoy hablando de RPython o RubyPython (los cuales son cosas muy, muy distintas).
Mientras las tecnologĆ­as mencionadas anteriormente son llamadas de formas parecidas y referenciadas de la misma manera, algunas de ellas sirven para propĆ³sitos completamente distintos (o, al menos, operan de maneras completamente distintas).
A lo largo de mi tiempo trabajando con Python, me topĆ© con toneladas de estas herramientas .*ython. Pero no hasta hace poco me tomĆ© el tiempo de entender quĆ© es lo que son, cĆ³mo funcionan y por quĆ© son necesarias (a sus maneras).
En este artĆ­culo, voy a empezar desde cero y recorrerĆ© varias implementaciones de Python, concluyendo con una introducciĆ³n detallada a PyPy, el cual creo es el futuro del lenguaje.
Todo empieza con entender que es lo que ‘Python’ realmente es.
Si tienes un buen entendimiento sobre cĆ³digo binario, mĆ”quinas virtuales y parecidos, siĆ©ntete libre de saltarte esta parte.

“Python es interpretado o compilado?”

Este es un punto comĆŗn de confusiĆ³n para principiantes en Python.
La primera cosa que hay que saber es que ‘Python’ es una interfaz. Existe una especificaciĆ³n sobre lo que Python deberĆ­a hacer y cĆ³mo deberĆ­a comportarse (cĆ³mo con cualquier interfaz). Y hay mĆŗltiples implementaciones (como en cualquier interfaz).
Lo segundo que hay que saber es que ‘interpretado’ y ‘compilado’ son propiedades de una implementaciĆ³n, no de una interfaz.
Entonces, la pregunta no estĆ” realmente bien formada.
¿Python es interpretado o compilado? La pregunta no estĆ” realmente bien formada.
Dicho esto, para la implementaciĆ³n mĆ”s comĆŗn (CPython: escrito en C, usualmente llamado simplemente ‘Python’, y seguramente lo que estĆ”s usando si no tienes idea de lo que estoy hablando), la respuesta es:interpretado, con algunas partes compiladas. CPython compila** el cĆ³digo fuente de Python a *bytecode, y en ese momento interpreta ese bytecode, ejecutĆ”ndolo sobre la marcha.
Nota: no es una ‘compilaciĆ³n’ en sentido tradicional de la palabra. Normalmente, decimos que ‘compilar’ es tomar el cĆ³digo de alto nivel y convertirlo en cĆ³digo binario. Pero es un tipo de ‘compilaciĆ³n’.
Veamos la respuesta un poco mƔs de cerca, ya que nos permitirƔ entender algunos de los conceptos que surgirƔn mƔs adelante en el artƭculo.

Bytecode vs. cĆ³digo binario

Es muy importante entender la diferencia entre bytecode y cĆ³digo binario (o nativo), tal vez mejor ilustrada con ejemplos:
  • C compila a cĆ³digo binario, que luego es ejecutado directamente en tu procesador. Cada instrucciĆ³n le indica a tu CPU que mueva cosas alrededor.
  • Java compila a bytecode, que luego es ejecutado en la mĆ”quina virtual de Java(Java Virtual Machine, Ć³ JVM), una abstracciĆ³n de una computadora que ejecuta programas. Cada instrucciĆ³n es entonces manejada por la JVM, que interactĆŗa con tu computadora.
En tĆ©rminos breves: cĆ³digo binario es mĆ”s rĆ”pido, pero bytecode es mĆ”s portable y seguro.
El cĆ³digo binario se ve distinto, dependiendo de tu mĆ”quina, pero bytecode se ve igual en todas las maquinas. Se podrĆ­a decir que el cĆ³digo binario estĆ” optimizado para tu configuracion.
Volviendo a CPython, el proceso en el conjunto de herramientas sucede de la siguiente manera:
  1. CPython compila tu cĆ³digo Python a bytecode
  2. Ese bytecode es entonces ejecutado en la MƔquina Virtual CPython
Los principiantes asumen que Python es compilado a raĆ­z de los archivos .pyc. Hay alguna verdad en esto: el archivo .pyc es bytecode compilado, que es despuĆ©s interpretado. Entonces si haz ejecutado cĆ³digo Python y ya tienes un archivo .pyc disponible, el mismo va a ejecutarse mĆ”s rĆ”pido la segunda vez ya que no necesitarĆ” recompilar el bytecode.

Maquinas virtuales alternativas: Jython, IronPython, y mƔs






CĆ³mo mencionĆ© anteriormente, Python tiene varias implementaciones. De vuelta, como mencionĆ© antes, la mĆ”s comĆŗn es CPython. Ɖsta es una implementaciĆ³n de Python escrita en C y es considerada la implementaciĆ³n ‘por defecto’.
¿Pero, quĆ© pasa con las alternativas? Una de las mĆ”s prominentes es Jython, una implementaciĆ³n en Java que utiliza la JVM. Mientras CPython produce bytecode para ser corrido en la VM de CPython, Jython produce bytecode de Java para correr en la JVM (esto es lo mismo que es producido cuando se compila un programa en Java).
“¿Por quĆ© usarĆ­a alguna vez una implementaciĆ³n alternativa?”, podrĆ­as preguntar. Bueno, para empezar, esasdiferentes implementaciones juegan muy bien con diferentes conjuntos de tecnologĆ­as.
CPython hace muy fĆ”cil el escribir extensiones C para tu cĆ³digo Python porque al final es ejecutado por un intĆ©rprete de C. Por otro lado, Jython, facilita trabajar con otros programas en Java: puedes importar cualquier clase de Java sin mayor esfuerzo, evocando y utilizando tus clases Java dentro tus programas Jython. (Nota aparte: si no pensaste en esto detalladamente, es una locura. Estamos en un punto donde puedes mezclar y triturar diferentes lenguajes y compilarlos todos en una misma esencia. Como fue mencionado por Rostin, los programas que mezclan cĆ³digo Fortran y C estĆ”n desde hace un tiempo. AsĆ­ que, por supuesto que esto no es algo necesariamente nuevo. Pero sigue siendo genial.)
CĆ³mo ejemplo, esto es cĆ³digo Jython vĆ”lido:
[Java HotSpot(TM) 64-Bit Server VM (Apple Inc.)] on java1.6.0_51
>>> from java.util import HashSet
>>> s = HashSet(5)
>>> s.add("Foo")
>>> s.add("Bar")
>>> s
[Foo, Bar]
IronPython es otra implementaciĆ³n popular de Python, escrita enteramente en C# y apuntando a la tecnologĆ­a .NET. En particular, corre con lo que se podrĆ­a llamar la MĆ”quina Virtual .NET,Common Language Runtime (CLR)de Microsoft, comparable con la JVM.
PodrĆ­as decir que Jython : Java :: IronPython : C#. Corren en sus respectivas VMs, puedes importar clases C# en tu cĆ³digo IronPython y clases Java desde tu cĆ³digo Jython, etc.
Es totalmente posible sobrevivir sin tocar alguna vez una implementaciĆ³n de Python no-CPython. Pero hay ventajas que se obtienen desde el cambio, muchas de ellas son dependientes de la tecnologĆ­a que uses. ¿Usas muchos lenguajes basados en la JVM? Jython puede ser para tĆ­. ¿Todo lo que haces es sobre la tecnologĆ­a .NET? Tal vez debas probar IronPython (y tal vez ya lo hayas hecho).
Por cierto: mientras que esto no serĆ­a una razĆ³n para usar una implementaciĆ³n diferente, nota que estas implementaciones sĆ­ difieren en comportamiento mĆ”s allĆ” de como tratan tu cĆ³digo fuente en Python. Sin embargo, esas diferencias son comĆŗnmente menores, y se disuelven o emergen con el tiempo mientras estas implementaciones se encuentran bajo un activo desarrollo. Por ejemplo, IronPython usa cadenas Unicode por defecto; Sin embargo, CPython, por defecto usa ASCII para versiones 2.x (fallando con un error de codificaciĆ³nUnicodeEncodeError para caracteres no-ASCII), pero sĆ­ soporta cadenas Unicode por defecto para las versiones 3.x.

CompilaciĆ³n Justo-a-Tiempo: PyPy y el futuro

Por lo tanto, tenemos una implementaciĆ³n de Python escrita en C, una en Java una en C#. El prĆ³ximo paso lĆ³gico: una implementaciĆ³n de Python escrita en… Python. (El lector educado encontrarĆ” esta notaciĆ³n levemente engaƱosa).
AquĆ­ es donde las cosas se ponen confusas. Primero, discutamos sobre compilaciĆ³n Justo-a-Tiempo (Just-in-Time, Ć³ JIT).

JIT: El por quĆ© y el cĆ³mo

Recordemos que el cĆ³digo binario es mucho mĆ”s rĆ”pido que bytecode. Bueno, ¿y si pudiĆ©ramos compilar algunas partes de nuestro bytecode y luego correrlo como cĆ³digo nativo? TendrĆ­amos que pagar algĆŗn precio al compilar a bytecode (por ej., tiempo), pero si el resultado fuese mĆ”s rĆ”pido, eso serĆ­a genial! Esa es la motivaciĆ³n de la compilaciĆ³n JIT, una tĆ©cnica hĆ­brida que mezcla los beneficios de los interpretadores y los compiladores. En tĆ©rminos bĆ”sicos, JIT quiere utilizar compilaciĆ³n para acelerar un sistema interpretado.
Por ejemplo, un enfoque comĆŗn tomado por la compilaciĆ³n JIT:
  1. Identificar bytecode que es ejecutado frecuentemente.
  2. Compilar a cĆ³digo binario.
  3. Almacenar el resultado en memoria cachƩ.
  4. Siempre que el mismo bytecode sea encontrado para ejecutar, en vez de usarlo, ejecutar el cĆ³digo binario precompilado y cosechar los beneficios (por ej., aumentos de velocidad)
De esto se trata PyPy: llevar JIT a Python (mira el ApĆ©ndice para ver esfuerzos anteriores). Hay, por supuesto, otros objetivos: PyPy apunta a ser multiplataforma, bajo en consumo de memoria e independiente del conjunto de tecnologĆ­as. Pero JIT realmente se vende por si solo. Como promedio de un puƱado de pruebas de tiempo, se dice que mejora el rendimiento a un factor de 6.27. Para un mayor anĆ”lisis, vĆ©ase este cuadro del PyPy Speed Center:

PyPy es difĆ­cil de entender

PyPy tiene un gran potencial, y a estas alturas es muy compatible con CPython (asĆ­ que puede correr Flask, Django, etc.).
Pero hay mucha confusiĆ³n alrededor de PyPy (vĆ©ase, por ejemplo, esta propuesta sin sentido para crear unPyPyPy…). En mi opiniĆ³n, eso es principalmente porque PyPy es actualmente dos cosas:
  1. Un intĆ©rprete de Python escrito en RPython (no Python (he mentido antes). RPython es un subconjunto de Python con tipos estĆ”ticos. En Python, es “prĆ”cticamente imposible” razonar rigurosamente acerca de tipos (¿Por que es tan difĆ­cil? Bueno, considera el hecho que:
     x = random.choice([1, "foo"])
    
    serĆ­a cĆ³digo Python vĆ”lido (crĆ©ditos a Ademan). ¿De quĆ© tipo es x? ¿CĆ³mo podemos razonar acerca de tipos de variables cuando los tipos ni siquiera son estrictamente forzados?). Con RPython, sacrificas algo de flexibilidad, pero a cambio es muchĆ­simo mĆ”s fĆ”cil razonar sobre manejo de memoria y demĆ”s, lo cual permite optimizaciones.
  2. Un compilador que compila cĆ³digo RPython para varios objetivos y agrega JIT. La plataforma por defecto es C, por ej., un compilador RPython-a-C, pero tambiĆ©n puedes apuntar a JVM y otros.
ƚnicamente para mayor claridad, me referirĆ© a ellos como PyPy (1) y PyPy (2).
¿Por quĆ© necesitarĆ­as esas dos cosas, y por quĆ© bajo el mismo techo? PiĆ©nsalo de esta manera: PyPy(1) es un intĆ©rprete escrito en RPython. Entonces toma el cĆ³digo Python del usuario y lo compila a bytecode. Pero el interpretador en sĆ­ (escrito en RPython) tiene que ser interpretado por otra implementaciĆ³n de Python para poder correr, ¿Verdad?
Bueno, podrĆ­amos simplemente usar CPython para correr el intĆ©rprete. Pero eso no serĆ­a lo suficientemente rĆ”pido.
En cambio, la idea es que usemos PyPy(2) (tambiĆ©n conocido cĆ³mo RPython Toolchain)-Set de herramientas RPython) para compilar al interpretador de PyPy a cĆ³digo que otra plataforma (por ej., C, JVM o CLI) pueda correr en nuestra mĆ”quina, agregando tambiĆ©n JIT. Es mĆ”gico: PyPy agrega dinĆ”micamente JIT a un interpretador, generando su propio compilador! (De vuelta, esto es una locura: estamos compilando un interpretador y agregando otro compilador independiente por separado).
Al final, el resultado es un ejecutable independiente que interpreta el cĆ³digo fuente Python y explota las optimizaciones de JIT. Que es lo que justamente querĆ­amos! Es un gran bocado, pero tal vez este diagrama ayude:
Reiterando, la verdadera belleza de PyPy es que podemos escribir nosotros mismos un puƱado de interpretadores Python distintos en RPython sin preocuparnos por JIT (salvo algunas sugerencias). PyPy entonces implementarĆ­a JIT por nosotros usando el set de herramientas de RPython/PyPy(2).
De hecho, si nos ponemos aĆŗn mĆ”s abstractos, podrĆ­as, teĆ³ricamente, escribir un interpretador para cualquierlenguaje, alimentar a PyPy con Ć©l, y obtener un JIT para ese lenguaje. Esto es porque PyPy se enfoca en optimizar el interpretador actual, en vez de los detalles del lenguaje que estĆ” interpretando.
PodrĆ­as, teĆ³ricamente, escribir un interpretador para *cualquier* lenguaje, alimentar a PyPy con Ć©l, y obtener un JIT para ese lenguaje.
Divagando un poco, me gustarĆ­a mencionar que JIT en sĆ­ mismo es absolutamente fascinante. Usa una tĆ©cnica llamada tracing (Ć³ seguimiento), la cual se ejecuta de la siguiente manera:
  1. Correr el interpretador e interpretar todo (sin agregar nada de JIT)
  2. Perfilar levemente el cĆ³digo interpretado.
  3. Identificar operaciones que hayas realizado antes.
  4. Compilar esos pedazos a cĆ³digo binario.
Para mĆ”s informaciĆ³n, este documento es altamente accesible y muy interesante.
Para ir concluyendo: usamos el compilador RPython-a-C de PyPy (u otra plataforma) para compilar el interpretador implementado RPython de PyPy.

Concluyendo

¿Por quĆ© es tan genial? ¿Por quĆ© vale la pena perseguir esta idea tan loca? Creo que Alex Gaynor lo describiĆ³ muy bien en su blog: “[PyPy es el futuro] porque ofrece mejor velocidad, mĆ”s flexibilidad y es una mejor plataforma para el crecimiento de Python.”
En resumen:

ApƩndice: Otros nombres que tal vez hayas oƭdo

  • Python 3000 (Py3k): nombre alternativo para Python 3.0, un mayor, compatible-con-versiones-anterioreslanzamiento de Python que alcanzĆ³ la escena en 2008. El equipo de Py3k predijo que llevarĆ­a alrededor decinco anos para que esta versiĆ³n sea completamente adoptada. Y mientras que la mayorĆ­a (cuidado: se dice que es anecdĆ³tico) de los desarrolladores de Python siguen usando Python 2.x, la conciencia de Py3k entre la gente estĆ” incrementĆ”ndose.
  • Cython: un super set de Python que incluye bindings (Ć³ enlaces)para llamar funciones de C.
    • Objetivo: permitirte escribir extensiones en C para tu cĆ³digo Python
    • AdemĆ”s te permite agregar tipos de variables estĆ”ticos a tu cĆ³digo Python, permitiĆ©ndole que sea compilado y alcanzar rendimiento parecido al de C.
    • Es similar a PyPy, pero no es lo mismo. En este caso, estĆ”s forzado a escribir el cĆ³digo del usuario antes de pasarlo al compilador. Con PyPy, escribes simplemente cĆ³digo Python, y el compilador maneja cualquier optimizaciĆ³n.
  • Numba: : un “compilador especializado justo-a-tiempo” que agrega JIT a cĆ³digo Python anotado. En tĆ©rminos mĆ”s bĆ”sicos, le das algunas indicaciones y acelera partes de tu cĆ³digo. Numa viene como parte de la distribuciĆ³n Anaconda,un set de paquetes para manejo y anĆ”lisis de datos.
  • IPython: muy diferente a todo lo que hemos discutido hasta ahora. Es un ambiente de procesamiento para Python. Interactivo y con soporte para herramientas grĆ”ficas y experiencia de navegador, etc.

Enlaces de lenguaje

  • RubyPython: un puente entre las mĆ”quinas virtuales de Ruby y Python. Permite embeber cĆ³digo de Python dentro de tu cĆ³digo de Ruby. Defines donde Python comienza y termina, y RubyPython calcula los datos entre las VMs.
  • PyObjc: enlaces de lenguaje entre Python y Objetive-C, actuando como un puente entre ellos. PrĆ”cticamente, eso significa que puedes utilizar librerĆ­as de Objective-C (incluyendo todo lo que necesitas para crear aplicaciones de OS X) desde tu cĆ³digo Python, y mĆ³dulos de Python desde tu cĆ³digo Objective-C. En este caso, es conveniente que CPython estĆ© escrito en C, el cual es un subconjunto de Objective-C.
  • PyQt: mientras PyObjc te ofrece una interfaz para los componentes grĆ”ficos de OS X, PyQt hace lo mismo para el framework de QT, permitiendote crear completas interfaces grĆ”ficas, acceso a bases de datos SQL, etc. Otra herramienta dirigida a traer la simplicidad de Python a otros frameworks.

Frameworks JavaScript

  • pyjs (Pyjamas): un framework para crear aplicaciones web y de escritorio en Python. Incluye un compilador Python-a-Javascript, un conjunto de widgets, y algunas herramientas mĆ”s.
  • Brython: una mĆ”quina virtual de Python escrita en JavaScript para permitir que el cĆ³digo de Py3k sea ejecutado en navegadores.

Creditos:
      By CHARLES MARSH 
      Traduccion: Pablo Fabregat, miembro de TransBunko
Fuente Original:

miƩrcoles, 25 de mayo de 2016

Redireccionar Odoo a la Pagina Web Principal de una Base de Datos sin DB Filter

RedirecciĆ³n de una Pagina Web sin enviar a los Visitantes al Login o a la SelecciĆ³n de  la Base de Datos



    Un problema que Ćŗltimamente eh notado en Odoo, es al momento de activar los Portales Web y tener MĆŗltiples Bases de Datos, normalmente envĆ­a a los visitantes a la selecciĆ³n de la Base de Datos y cuando redireccionamos el trafico de un dominio a nuestro servidor Web, este siempre es enviado directamente al login y no a la pagina Web, bueno esto puede resolverse de muchas formas, utilizando subdominios, reverse proxy con nginx y muchas mas, a mi parecer todas eran un poco complejas y necesitaban muchos pasos, me di a la tarea de pensar un poco y modificar el mĆ©todo principal de re direccionamiento de odoo, el cual se encuentra en:

path_addons_odoo/web/controller/main.py

Podemos modificar este archivo con vim, vi, nano, gedit, sublime text, brackets o cualquier editor, simplemente debemos ir al metodo llamado def_login_redirect().

Debemos comentar el metodo quedando de la siguiente forma:


#def login_redirect():
#    url = '/web/login?'
#    # built the redirect url, keeping all the query parameters of the url
#    redirect_url = '%s?%s' % (request.httprequest.base_url, werkzeug.urls.url_encode(request.params))
#    return """<html><head><script>
#        window.location = '%sredirect=' + encodeURIComponent("%s" + location.hash);
#    </script></head></html>
#    """ % (url, redirect_url)

Modificamos el mƩtodo quedando de la siguiente manera:

def login_redirect():
    return """<html><head><script>
        window.location = '%sredirect=' + encodeURIComponent("%s" + location.hash);
    </script></head></html>
    """ % ('/?db=Mi_Base_de_Datos', '')

Notemos  que al final solo debemos enviar la Base a la que  se enviara a los visitantes, esta tambiĆ©n debera contener nuestra pagina Web.

Si vamos a redireccionar el trafico de un dominio externo hacia nuestro servidor Odoo, este debe ser redireccionado de la siguiente manera:

http://odoo.poncesoft.net:8069/?db=Mi_Base_de_Datos&web

El valor Mi_Base_de_Datos corresponde a la misma base a la que redireccionamos el mƩtodo login_redirect()


Nota: Cada uno de los valores para el redireccionamiento de nuestra aplicaciĆ³n, dependerĆ” de la instalaciĆ³n de nuestro Servidor Odoo y si utilizamos un servidor Web como Nginx, Apache, etc. o la ejecuciĆ³n nativa de Odoo.

martes, 24 de mayo de 2016

Trabajar con iReport y JDK 8 o 9 en Ubuntu 15.10 o Ubuntu 16.04

Instalar iReport con Ubuntu 15.10 o Ubuntu 16.04 y JDK Update 8 o 9



    ƚltimamente con cada nueva versiĆ³n de Ubuntu y Java (JDK, JRE y JVM) viene una serie de problemas con nuestras herramientas de trabajo, un problema muy frecuente es no poder trabajar con iReport y Java Update 8 o 9, debido a que viene predefinido en las ultimas versiones de Linux, bueno me eh dado a la tarea de buscar una soluciĆ³n que permita trabajar el Sistema con esta versiĆ³n de Java y poder trabajar al mismo tiempo nuestro iReport, antes que nada en nuestro Linux podemos tener una serie de diferentes versiones de Java (JDK o JRE).

La solucion es la siguiente:


  1. Instalar OpenJDK Update 7, para ello ejecutamos los siguientes comandos:
    • sudo add-apt-repository ppa:openjdk-r/ppa
    • sudo apt-get update
    • sudo apt-get install openjdk-7-jdk
  2. Podemos hacer una revisiĆ³n de la versiĆ³n que tenemos actualmente en el Sistema:
    • java -versiĆ³n
  3. En Caso de que la instalaciĆ³n del update 7 de Java modificara la versiĆ³n establecida por defecto en el Sistema, ejecutaremos:
    • sudo /usr/sbin/update-alternatives --config java
    • Seleccionamos la versiĆ³n correcta.
  4. Solo falta editar el archivo de arranque llamado ireport, que se encuentra en nuestra carpeta de ejecuciĆ³n en mi caso "/home/german/iReport-3.7.6/bin/ireport", podemos abrirlo con gedit o cualquier otro editor y modificar lo siguiente:
    • Buscamos la linea  --jdkhome '"$jdkhome"'
    • Cambiamos por --jdkhome '"/usr/lib/jvm/java-7-openjdk-amd64"'
    • Guardamos
  5. Listo, volvemos a ejecutar nuestro Reporteador con el comando:
    • ./ireport o dando doble click y ejecutar.

jueves, 12 de mayo de 2016

Pop-Up (Ventanas Emergentes) Odoo

Tipos de Ventanas Emergentes en Odoo


Como podemos crear una ventana Emergente en Odoo?

Muchos hemos tenido la necesidad de poder enviar mensajes para validar procesos en Odoo, esto nos ayuda a evitar errores de programaciĆ³n, el buen funcionamiento de nuestra logica de negocio o flujo de funcional, etc., mencionare 3 formas de poder enviar ventas emergentes para el usuario:

  1. Ventana de Advertencia desde metodos onchange. Uno de los tipos de mensajes que podemos enviar al usuario es desde un mƩtodo onchange (Evento al Cambio), esto nos puede ayudar para dar aviso al usuario que al modificar un valor del formulario este afectara el comportamiento de ese Registro, por ejemplo aƱadir un producto sin existencias en un pedido de Venta o una tarifa invalida para ciertos productos.

    El  cĆ³digo para enviar este tipo de mensajes es directamente desde el return de nuestro mĆ©todo onchange, si recordamos este envĆ­a un diccionario, solo debemos aƱadir el atributo 'warning' :
    return {'value': res, 'warning': warning }
    El atributo warning recibe un subdiccionario compuesto de 2 partes, el titulo y el mensaje, el cĆ³digo es el siguiente:
    warning = {
               'title': "Advertencia!",
               'message': "Cuerpo del Mensaje de Advertencia!"),
                                }
    Como nota, este tipo de mensajes no detiene el flujo del proceso que estemos ejecutando, solo  envĆ­a una Advertencia al usuario.
  2. Exception ORM (Excepciones Odoo). Este tipo de advertencias a diferencia de los metodos onchange, interrumpe completamente el flujo del proceso que se este ejecutando y hace una reversiĆ³n de lo que hayamos creado, actualizado o borrado.
    Para Ejecutar este tipo de Excepcion, debemos importar la librerĆ­a:
    from openerp.exceptions import except_orm
    
    Posterior a importarla solo debemos integrarla en nuestros metodos, para lanzar una excepcion debemos enviarla de la siguiente forma:
    raise except_orm(_('Error'),
                     _('Mensaje interruptor del Flujo!'))
    Este tipo de errores funcionan para validar parĆ”metros necesarios para nuestro metodo, falta de datos, informaciĆ³n erronea, etc.

  3. Ventana Emergente con mensajes para el Usuario. Este tipo de mensajes nos sirven para dar una aviso al usuario sobre la finalizaciĆ³n de un proceso o la modificaciĆ³n de un registro, el uso que le demos no tiene limites y este tipo de mensajes no interrumpen el flujo del sistema.
    Este mensaje se envĆ­a desde el return de la siguiente manera:
    return {
            'type': 'ir.actions.client',
            'tag': 'action_warn',
            'name': _('Aviso'),
            'context' : context,
            'params': {
               'title': _('Aviso'),
               'text': _(u'Mensaje para el usuario'),
               'sticky': True
           }}