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

Mostrando las entradas con la etiqueta desarrollo odoo. Mostrar todas las entradas
Mostrando las entradas con la etiqueta desarrollo odoo. Mostrar todas las entradas

martes, 14 de julio de 2020

Obtener registros Hijos de un registro Padre en Odoo

Como utilizar child of para buscar registros hijos en Odoo



Algo muy frecuente y que estoy seguro que te as preguntado es como poder obtener las categorĆ­as hijas de un registro, por ejemplo en los modelos:

  • Ubicaciones
  • Categorias
  • Partners

Existen columnas dentro de los lineamientos de Odoo que nos permiten tener un control en un esquema de arbol:
  • Parent Left
  • Parent Right
  • Parent ID

Con estos campos podemos saber de donde la estructura de la que se compone nuestro registro y por medio de ellas buscar sus hijos:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
## Iniciamos nuestra lista final ###
all_record_ids = []
#### La variable que usare como ejemplo es record, que es una instancia de un registro de X tabla que usa el esquema de hijos ###
#### Iniciamos nuestro dominio, en este ejemplo usare una variable para no tener todo en una sola linea ####
child_dom = [('parent_left', '>', record.parent_left), ('parent_left', '<', record.parent_right)] 
#### Buscamos los registros que cumplen mi condicion ####
child_records = self.search(child_dom)
#### Agregamos a mi lista final, el registro principal (record) y agregamos los hijos ####
all_record_ids.append(record.id)
all_record_ids=all_record_ids+child_records.ids


Yo por ejemplo, necesitaba saber las categorĆ­as hijas de un registro en donde mi variable era category:

1
2
3
product_category = self.env['product.category']
child_dom = [('parent_left', '>', category.parent_left), ('parent_left', '<', category.parent_right)] 
child_categs = product_category.search(child_dom)

miƩrcoles, 19 de febrero de 2020

Odoo Qweb manejo de Ciclos

Loops o Ciclos con




QWeb en Odoo es muy util al momento de realizar o ejecutar funcionalidades como Reportes, Archivos XML etc. todo esto basado en plantillas, pero existen muchas funcionalidades muy utiles que nos pueden ayudar a mejorar el diseƱo de nuestros Reportes, de las cuales les vengo a hablar en este post y son:


  • as_first
  • as_last
  • as_index

t t-foreach="['A','B','C','D','E']" t-as="item">
    <p t-if="item_first">
        Inicio
    </p>
    <p>
        Indice <t t-esc="item_index"/> y resultado <t t-esc="item"/>
    </p>
    <p t-if="item_last">
        Fin
    </p>
</t>

El resultado seria:

Inicio
Indice 0 y resultado A
Indice 1 y resultado B
Indice 2 y resultado C
Indice 3 y resultado D
Indice 4 y resultado E
Fin

Podemos deducir que las palabras clave as_first indica el inicio del loop, as_index el recorrido de nuestro ciclo y as_end si es el ultimo valor de nuestra lista.


lunes, 3 de febrero de 2020

Uso de CFDI en Punto de Venta - Facturación Electronica


POS - Uso de CFDI 

Odoo 13.0



El siguiente modulo nos permite seleccionar el Uso de CFDI con el cual generaremosl a Factura Electronica para nuestros clientes, dentro de las principales caracteristicas  del modulo que voy a presentarles podremos encontrar:


  • Selección de Uso de CFDI desde el Formulario de Clientes

  • Selección del USo de CFDI desde el Formulario de Clientes en el Punto de Venta.


  • Visualización al seleccionar clientes en el Punto de Venta

  • Como ultima funcionalidad automaticamente relaciona el Uso de CFDI del cliente al seleccionarlo dentro de Formulario de Facturación.

El modulo lo podran descargar desde:


Con el nombre pos_customer_uso_cfdi







lunes, 1 de julio de 2019

Facturación Electrónica CFDI 3.3 con Complemento de Pagos para Odoo 8, Odoo 9 y Odoo 10

Factura Electrónica CFDI 3.3 con Integración de Pagos Electrónicos
(Complemento de Pagos)


Introducción a Facturación Electrónica CFDI 3.3

La Migración de Esquemas de Facturación Electrónica CFDI 3.2 a 3.3 se presento a comienzos del Año 2016 el cual tiene como objetivo cambiar la factura electrónica con el uso de plantillas y catÔlogos, con la finalidad de tener uniformidad en los datos registrados y que permitan a la autoridad fiscal identificar al contribuyente emisor y el tipo de transacción, los periodos de emisión del CFDI y fundamentalmente las fechas y formas de pago de los CFDI.

Este nuevo esquema se presenta como Opcional a partir del 1ro de Julio y como Obligatorio a partir del 1ro de Diciembre.

Debido a este nuevo reto y al mismo tiempo Obligación Fiscal, nos dimos a la tarea de desarrollar esta Solución Integrada 100 % a Odoo desde la Versión 7 (OpenERP) hasta Odoo 10.

El proceso es bastante sencillo y transparente para los usuarios finales.

Dentro de los cambios principales observaremos los CatƔlogos:
  • Uso CFDI
  • Formas de Pago
  • MĆ©todos de Pago
  • Impuestos
  • Catalogo Productos/Servicios
  • Unidades de Medida
  • Códigos Postales
Para el Uso de Comercio Exterior:
  • Ciudades
  • Localidades
  • Colonias
  • Paises
  • Estados
  • Pedimentos
  • Aduanas
Podemos observar toda la funcionalidad en el siguiente vĆ­deo:


Localizacion Mexicana Odoo con Facturacion Electronica 3.3

Cualquier información: info@argil.mx


jueves, 4 de octubre de 2018

Instsalación Odoo 12 en Linux

Instalación Odoo 12 en Linux, Ubuntu Server y Desktop 16.x , Ubuntu 17.x y Ubuntu 18.x


PASOS PARA LA INSTALACIƓN: 


Antes que nada necesitamos instalar las dependencias que utiliza Odoo (una dependencia es una aplicación o una biblioteca requerida por otro programa para poder funcionar correctamente. Por ello se dice que dicho programa depende de tal aplicación o biblioteca).
Antes de instalar las dependencias, necesitamos una actualizacion de los repositorios:
sudo apt-get update && sudo apt-get upgrade
Creamos un directorio en la ruta /opt llamada Odoo:
cd /opt
Despues:
sudo mkdir odoo
Cambiamos los permisos de la carpeta odoo al usuario que usara esta ruta (german es el usuario del sistema):
sudo chown german.german * -R odoo
Descargamos Odoo desde el Repositorio Oficial:
sudo git clone https://www.github.com/odoo/odoo --depth 1 --branch 12.0 --single-branch .
Instalamos las dependencias de la aplicación:
sudo pip install -r /opt/odoo/doc/requirements.txt
sudo pip install -r /opt/odoo/requirements.txt

Creamos nuestro Usuario Postgres


Entramos al prompt de postgres:
sudo su postgres
Creamos el Usuario:
createuser -s -P -e odoo
Tecleamos la contraseña (odoo) 2 veces. Ahora para evitar algún error modificamos el template principal de postgres (template1)
psql template1
Y una vez dentro del template:
alter role odoo with password 'odoo';
Para salir del prompt de postgres solo ejecutamos:

psql \q

Instalación Dependencias Externas


sudo apt-get install nodejs -y
sudo apt-get install npm -y
apt-get install node-less
sudo npm install -g less
sudo npm install -g less-plugin-clean-css
sudo ln -s /usr/local/bin/lessc /usr/bin/lessc
sudo ln -s /usr/bin/nodejs /usr/bin/node
sudo apt-get install sassc

Iniciamos nuestro Servidor de Odoo 12


Creamos nuestro archivo de configuracion de Odoo, para ello vamos al directorio de instalación (/opt/odoo/) y ejecutamos:
python odoo-bin -c odoo.conf -s
Lo que estamos haciendo es crear un archivo de configuración para Odoo.
Ahora debemos pausar la ejecución del servidor con la combinación de teclas ctr+c.
Listo, ahora editamos el archivo de configuración llamado odoo.conf, con el editor vi, vim, nano o gedit si estÔn en modo grÔfico y modificamos los valores:
db_host = localhost
db_maxconn = 64
db_name = False
db_password = odoo
db_port = 5432
db_template = template1
db_user = odoo
Guardamos y ahora para ejecutar el servidor odoo, usamos el comando:
python /opt/odoo/odoo-bin -c /opt/odoo/odoo.conf
Una Captura de Odoo 12:

Desde mi perspectiva Odoo 12 es 3 veces mas rapido y mejor optimizado en cuestion del manejo de Datos, podemos optimizar aĆŗn mas el rendimiento montando un Servidor Web (Nginx) con un certificado de Serguridad HTTPS.
Y ahora con el manejo de Multi Sitios Web.

jueves, 9 de agosto de 2018

Definición y lectura de campos multi Compañia en Odoo

Lectura de campos de tipo propiedad con Odoo



Los campos multi-compañia o propiedad permiten al usuario tener un control interno por compañia dentro de la base de datos, esto permite la segmentación de la información para que una Base de Datos conserve sus propias particularidades, configuración, valores, etc.
Los datos de tipo propiedad podemos encontrarlos dentro de Clientes o Productos, principalmente para la parte Contable.

Como podemos definir un campo de tipo propiedad, antes de la Api  se definia un campo llamandolo fields.property pero con la migración a la nueva api, el valor property es cambiado por el parametro company_dependent, por ejemplo, voy a definir una tarifa secundaria dentro de Clientes, pero quiero que esta tarifa sea unica por CompaƱia:

class ResPartner(models.Model):
    _inherit = 'res.partner'

    second_product_pricelist = fields.Many2one('product.pricelist', 
         'Tarifa Secundaria', company_dependent=True)

Ahora, como podemos dar lectura al campo de tipo propiedad para obtener el valor, aqui entra en función el Contexto (context), utilizamos un parametro llamado force_company  dentro del código, por ejemplo si tengo 2 compaƱias, una con el ID 1 la otra con el ID 2, la lectura seria:

# Company 1
partner_br = self.env['res.partner'].with_context(force_company=1).browse(256)
second_product_pricelist_company_1 = partner_br.second_product_pricelist.id

#Company 2

partner_br = self.env['res.partner'].with_context(force_company=2).browse(256)
second_product_pricelist_company_2 = partner_br.second_product_pricelist.id

El parametro force_company recibe el ID de la compaƱia de la cual se obtendran los valores y el browse del ejemplo es el ID de un Cliente.

No se olviden comentar ...

lunes, 21 de mayo de 2018

Creación de Campos con Precisión Decimal Dinamica en Odoo

Creación de Campos con Decimales Dinamicos




Un aspecto fundamental en la parte administrativa es la contable donde la presición decimal debe ser muy controlada, tanto en la generación de reportes como en la creación de algunos formularios.

Dentro de las muchas bondades que siempre describo en mis articulos, Odoo cuenta con una presición dinamica, esta precisón puede ser moderada por el usuario final (cliente), esto le ayudara a aumentar o disminuir el numero de decimales en Odoo de acuerdo a sus necesidades y sin tener que programar o editar el codigo fuente.

La precisión decimal la encontramos en el Menu Configuración --> Tenico --> Estructura de la Base de Datos --> Presición Decimal.

El primer paso es crear tu precisión Decimal mediante una vista XML.

<?xml version="1.0" encoding="UTF-8"?>
<odoo>
   <data>
  <!--  Mi presicion decimal-->

  <record model="decimal.precision" id="precision_discounts">
    <field name="name">Discount</field>
    <field name="digits">6</field>
  </record>  

   </data>
</odoo>

Al instalar nuestro modulo o actualizarlo, nos creara el registro correspondiente al XML:


El valor digits es el numero de decimales que tendra el campo que lo utilice como su presición decimal.

El paso final es asignar esta presición en la creación del campo en una clase Odoo.

# -*- coding: utf-8 -*-
from openerp.exceptions import UserError
from openerp import api, fields, models, _, tools
import openerp.addons.decimal_precision as dp

class Accountinvoice(models.Model):
    _inherit = 'account.invoice'
    _name = 'account.invoice'
    
    invoice_discount_amount = fields.Float(digits=dp.get_precision('Discount'), 
                                string='Descuento Total en Monto')


En el ejemplo anterior herede facturas y cree mi campo llamado Descuento Total con 6 Decimales en su parte flotante, el campo se visualiza de la siguiente manera en el Sistema:

Si modificamos la presición decimal a 4.


Veriamos el campo actualizado y los registros anteriores redondeados al nuevo numero de decimales.

Una presición puede ser reutilzada muchas veces no es necesario crear una por cada campo a menos que el proceso lo requiera.

Espero que les ayude esta información y no se olviden dejar sus comentarios.




miƩrcoles, 16 de mayo de 2018

Creación Metodos Automatizados en Odoo (Cron) v 11

Creación de nuestro primer Metodo Planificado


Una caracteristica dentro de la API de Odoo es el uso de un Cron, el cual te permite generar una planificacion en la ejecución de un Metodo, de forma dinamica, diaria, semanal, mensual, cada X periodo de tiempo, etc.

Este tipo de Metodos los podemos encontrar en el apartado de Planificacion en la Configuración Tecnica.


Lo primero que debemos hacer es  decidir en que Clase de Odoo pondremos nuestro metodo, por ejemplo creare un metodo que valide el vencimiento de las facturas y envie un correo al administrador con los Folios de estas.

Heredamos Facturas

class AccountInvoice(models.Model):
    _name = 'account.invoice'
    _inherit ='account.invoice'

Creamos nuestro Metodo

class AccountInvoice(models.Model):
    _name = 'account.invoice'
    _inherit ='account.invoice'

    @api.model
    def revision_due_invoices(self, id=None):
        print "### Revisando las Facturas Vencidas"

Creamos el Registro de Automatización (Objedo ir.cron)

Para la creación utilizaremos un registro en nuestro XML

<data noupdate="1">

    <record forcecreate="True" id="revision_due_invoices_v1" model="ir.cron">
           <field name="name">Revision de Facturas Vencidas</field>
           <field eval="True" name="active" />
           <field name="user_id" ref="base.user_root" />
           <field name="interval_number">24</field>
           <field name="interval_type">hours</field>
           <field name="numbercall">-1</field>
           <field ref="model_account_invoice" name="model_id" />
            <field name="state">code</field>
           <field name="code">model.revision_due_invoices()</field>
           <field eval="False" name="doall"/>
           <field name="function">True</field>

        </record>


</data>

Podemos Observar que la Ejecucion Sera Cada 24 Horas con Ciclos Ilimitados.



Para la revisión de las Facturas Vencidas utilizaremos el campo llamado due_invoice:

    @api.model
    def revision_due_invoices(self, id=None):
        print "### Revisando las Facturas Vencidas"
        date_act = fields.Datetime.now()
        invoice_due_ids = self.search([('due_invoice','<=',date_act),
        ('state','=','open')])
        if invoice_due_ids:
            # Folios de Facturas Vencidas
            ref_list_due = [x.name for x in invoice_due_ids]


El Metodo completo quedaria como el siguiente:

    @api.model
    def revision_due_invoices(self, id=None):
        print "### Revisando las Facturas Vencidas"
        date_act = fields.Datetime.now()
        invoice_due_ids = self.search([('due_invoice','<=',date_act),
        ('state','=','open')])
        if invoice_due_ids:
            # Folios de Facturas Vencidas
            ref_list_due = [x.number for x in invoice_due_ids]
            from odoo import SUPERUSER_ID
            user_admin = self.env.['res.user'].browse(SUPERUSER_ID)
            my_user = self.env.user
            mail_from = my_user.partner_id.email
            mail_to = user_admin.partner_id.email

            mail_vals = {
                    'subject': 'Notificacion de Facturas Vencidas %s' % date_act,
                    'author_id': my_user.id,
                    'email_from': mail_from,
                    'email_to': mail_to,
                    'message_type':'email',
                    'body_html': 'En la Fecha %s se encontraron las \
                    siguientes Facturas Vencidas %s' % (date_act, str(ref_list_due)) ,
                        }
            mail_id = self.env.['mail.mail'].create(mail_vals)
            mail_id.send()


No se olviden dejar sus comentarios.




martes, 27 de marzo de 2018

Reportes Word en Odoo


Generación de reportes en formato Doc/Docx integrado a Odoo




Mas de uno de nosotros hemos tenido la curiosidad o necesidad de Generar reportes en formato Doc(x),  esto es posible gracias a Python y a la gran cantidad de librerias que se crean y existen, en este Post les enseƱare un par de librerias que nos ayudan a generar este tipo de Reportes.


Instalación

Haremos uso de la libreria python-docx alojada en los Repositorios de Python, para ello podemos utilizar la aplicación Pip en Linux o easy_install.

sudo pip install python-docx
o
sudo easy_install install python-docx


Implementación

El primer paso que debemos realizar como cualquier libreria es importarla en nuestra Clase Odoo.

from docx import Document

Creamos una instancia de la libreria y la asignamos a una variable para poder generar nuestro Documento.

report_word = Document()

A partir de nuestra variable instanciada, podemos ir añadiendo información tomada de nuestro recordset o bien para ejemplos, podemos usar información ficticia.

Algunos ejemplos de lo que podemos hacer con la  libreria son:

Agregar un Parrafo


report_word = Document()

paragraph  = report_word.add_paragraph('Hola, este es mi primer parrafo con la libreria docx')


Agregar una cabecera


report_word = Document()

report_word.add_heading('Dream big and start with something small')

Agregar una tabla

report_word = Document()

report_word.add_table(rows=2, cols=2)

Un ejemplo completo seria:

from docx import Document
from docx.shared import Inches

document = Document()

document.add_heading('Document Title', 0)

p = document.add_paragraph('A plain paragraph having some ')
p.add_run('bold').bold = True
p.add_run(' and some ')
p.add_run('italic.').italic = True

document.add_heading('Heading, level 1', level=1)
document.add_paragraph('Intense quote', style='IntenseQuote')

document.add_paragraph(
    'first item in unordered list', style='ListBullet'
)
document.add_paragraph(
    'first item in ordered list', style='ListNumber'
)

document.add_picture('monty-truth.png', width=Inches(1.25))

table = document.add_table(rows=1, cols=3)
hdr_cells = table.rows[0].cells
hdr_cells[0].text = 'Qty'
hdr_cells[1].text = 'Id'
hdr_cells[2].text = 'Desc'
for item in recordset:
    row_cells = table.add_row().cells
    row_cells[0].text = str(item.qty)
    row_cells[1].text = str(item.id)
    row_cells[2].text = item.desc

document.add_page_break()

document.save('demo.docx')

Si quieren conocer mas acerca de la libreria:

https://python-docx.readthedocs.io/en/latest/

miƩrcoles, 25 de octubre de 2017

Obtener ID en Metodos Onchange API Odoo

Obtener el ID del Registro que ejecuta un metodo Onchange


Anteriormente con OpenERP podriamos acceder a los parametros base de una forma facil ya que estos tenian estar implicitos en la declaración de los metodos en  cada una de nuestras clases, este panorama obtiene un cambio radical con la llegada de la nueva API, anteriormente podiamos acceder a los IDS del registro que ejecutaba un metodo onchange de forma facil, pero cambia en la programación con la API de Odoo.

Al ejecutar la siguiente instrucción en un metodo onchange:

self.id

Obtendremos:

<odoo.models.NewId object at 0x7fd5a8048ed0>

Esto en algĆŗn momento me ha llegado a limitar al realizar consultas o actualizaciones por Query duro, ya que es una instancia lo que estamos recibiendo y no un valor Numerico.

Existe una solución muy simple y es una variable del entorno de desarrollo de la API (Environment):

self._origin.id

La instrucción anterior nos dara el ID del Registro que esta ejecutando el metodo onchange.

viernes, 23 de junio de 2017

Descarga de Reporte con Nombres DinƔmicos en Odoo 9 y Odoo 10

Generación de Reportes con Nombres DinÔmicos en Odoo



Dentro de las grandes virtudes de Odoo podemos ver una actualización muy util al apartado de Reportes, la cual es la generación del nombre del archivo descargado (Ej. Pedido 01.pdf) de forma dinÔmica tomando información de un campo del formulario donde se imprime el Reporte.

El primero paso es activar el modo desarrollador.

Con este paso, podremos visualizar en Configuración --> Informes --> Formulario --> Campo Printed Report Name

Este campo nos permitirÔ ingresar una serie de evaluaciones del registro del cual se imprime la información para generar el nombre de descarga del Archivo PDF, por ejemplo en el reporte de Facturas podria generar el siguiente nombre:


El resultado sera de 2 maneras, si no existe numero de factura:


Existiendo un numero de folio (factura confirmada):


El Nombre del reporte con concatenaciones puede ser dinƔmico o fijo, reemplazando el valor original del reporte.


Espero les ayude tanto como a mi.


viernes, 2 de diciembre de 2016

Retornar un reporte mediante una función Python en Odoo

Retornar un reporte mediante un botón en Odoo


    
La ejecución y el manejo de los reportes mediante funciones en odoo, se hace de la siguiente manera:

# -*- coding: utf-8 -*-
def print_report(self):
    return self.env['report'].get_action(self, 'modulo.nombre_tecnico_reporte')

La parte importante en este boton es invocar el reporte correcto, primero el nombre del modulo seguido de un punto y por ultimo el nombre tecnico del reporte.

Otra parte importante es que self contiene los ids de los registros que tenemos que imprimir, entonces si queremos imprimir varios registros al mismo tiempo bastarĆ­a con tener una instancia de ellos.



jueves, 16 de junio de 2016

Leer y ordenar archivos por fecha de Creación desde Python

Leer y Ordenar Archivos por su fecha de Creación (Antiguedad Descendente Antiguo --> Reciente)



Este pequeño codigo es muy util en la creación de colas de lectura ordenadas por antiguedad del archivo.

Primero haremos uso de 2 librerĆ­as:
  1. glob
  2. os
Las importamos en nuestro codigo como cualquier otra libreria:

import glob
import os

Ahora un ejemplo del Codigo:

import glob
import os

search_dir = "/mi_ruta_archivos/"
files = filter(os.path.isfile, glob.glob(search_dir + "*"))
files.sort(key=lambda x: os.path.getmtime(x))
files = [str(x) for x in files]

print "####### ARCHIVOS ORDENADOS POR ANTIGUEDAD", files

Un ejemplo de cada elemento de la lista files es "/mi_ruta_archivos/archivo1.txt"

jueves, 9 de junio de 2016

Trabajando con Symfony2 y Odoo (OpenERP)

Symfony2 & Odoo (OpenERP)



    Symfony es un completo framework diseƱado para optimizar, gracias a sus caracterĆ­sticas, el desarrollo de las aplicaciones web. Para empezar, separa la lógica de negocio, la lógica de servidor y la presentación de la aplicación web. Usa un entorno de desarrollo MVC (Modelo Vista Controlador) similar al Framework de Odoo, este framework se usa para el desarrollo de aplicaciones en PHP.

1.1. Instalación de LAMP

LAMP son las siglas de linux apache mysql php. Symfony necesita de un servidor LAMP para poder funcionar. A continuación veremos como instalar un servidor LAMP en nuestro sistema. En primer lugar instalaremos apache:
$ sudo apt-get install apache2

Posteriomente instalamos php:
$ sudo apt-get install php5 libapache2-mod-php5 php-cli php-mysql
y reiniciamos apache:
$ sudo service apache2 restart
por Ćŗltimo instalamos mysql:
$ sudo apt-get install mysql-server mysql-client libmysqlclient-dev
durante el proceso de instalación nos pedirÔ que asignemos contraseña al usuario root de mysql.
Adicionalmente, podemos instalar también phpmyadmin para ayudarnos con la configuración de mysql:
$ sudo apt-get install phpmyadmin
y creamos un enlace simbólico para acceder:
$ sudo ln -s /usr/share/phpmyadmin /var/www
Ahora podremos acceder mediante la url 192.168.0.122/phpmyadmin.

1.2. Instalación de composer

Composer es un gestor de dependencias para un proyecto php. Para instalar composer primero debemos instalar curl
$ sudo apt-get install curl
Posteriomente instalamos composer:
$ curl -s https://getcomposer.org/installer | php
Si todo ha funcionado bien, en el directorio donde te encuentras veras un nuevo fichero llamado composer.phar. Para comprobar que se ha instalado correctamente, ejecuta el siguiente comando que muestra el menĆŗ de opciones de Composer:
$ php composer.phar
Instalar Composer de esta manera es correcto, pero te obliga a realizar una nueva instalación para cada proyecto Symfony2. Si tienes muchos proyectos, es mucho mejor que instales Composer de forma global en tu ordenador, para que todos los proyectos utilicen la misma versión de Composer.
Para instalar Composer globalmente, mueve el archivo composer.phar a algĆŗn directorio ejecutable del sistema, como por ejemplo:
$ sudo mv composer.phar /usr/local/bin/composer
Comprueba que todo funciona bien ejecutando el comando composer sin opciones desde cualquier directorio del sistema. La instalación global de Composer también facilita su mantenimiento, ya que sólo hay que ejecutar el siguiente comando para actualizar la versión de Composer de todos los proyectos:
$ sudo composer self-update

1.3. Instalación de Symfony

Gracias a composer la instalación de Symfony se reduce a un simple comando de consola:
php composer.phar create-project symfony/framework-standard-edition nuestra_ruta/ 2.3.6
por ejemplo:
php composer.phar create-project symfony/framework-standard-edition /home/user/openerp/ 2.3.6
En caso de haber instalado composer globalmente:
composer create-project symfony/framework-standard-edition nuestra_ruta/ 2.3.6
El proceso de instalación nos ira pidiendo los datos de configuración de nuestro servidor. Podemos introducirlos en el momento o introducirlos a mano en el fichero app/config/parameters.yml
Una vez instalado, hay que borrar el bundle AcmeDemo:
Eliminar carpeta AcmeBundle de src
Eliminar $bundles[] = new AcmeDemoBundleAcmeDemoBundle(); del fichero app/AppKernel.php
Eliminar bloque referente AcmeDemo en app/config/routing_dev.yml

2. Conectar Symfony con OpenErp

Ya tenemos instalado Symfony en nuestro sistema, ahora vamos a ver como realizar la conexión con nuestro OpenERP.

2.1. Crear bundle conexión OpenERP

Un bundle se Symfony es el equivalente de un módulo de OpenERP, contiene todos los ficheros que proporcionan una nueva funcionalidad a nuestra aplicación web.
Para generar un bundle, debemos ejecutar en el directorio de nuestro proyecto Symfony:
$ php app/console generate:bundle
Esto nos mostrara un asistente para generar nuestro bundle:
Bundle Namespace: Openerp/ConnectBundle
Bundle Name: ConnectBundle
Target directory: Pulsamos enter (valor por defecto)
Configuration format: yml
Do you want to generate the whole directory structure?: pulsamos enter (valor por defecto)
Do you confirm generator?: pulsamos enter (valor por defecto)
Confirm automatic update of your kernel?: Pulsamos enter (valor por defecto)
Si vamos a la carpeta src de nuestro proyecto, podremos ver como se ha generado el nuevo Bundle, OpenERP.

connect

2.2. Generar entidad datos OpenERP

Una opción de configuración que podemos utilizar para no tener que introducir los datos de conexión en cada acceso, es generar una entidad de conexión a OpenERP para almacenar los parÔmetros de conexión. Una entidad es un fichero php que se encarga de interactuar con la base de datos de nuestro proyecto.
Para generar esta entidad debemos ejecutar en el directorio de nuestro proyecto Symfony el siguiente comando:
$ php app/console doctrine:generate:entity
Esto nos mostrara un asistente para generar nuestra entidad:
The Entity shortcut name: ConnectBundle:OpenERP
Configuration format (yml, xml, php, or annotation) [annotation]: pulsamos enter 

New field name (press  to stop adding fields): server
Field type [string]: pulsamos enter
Field length [255]: 100

New field name (press  to stop adding fields): bda
Field type [string]: pulsamos enter
Field length [255]: 100

New field name (press  to stop adding fields): username
Field type [string]: pulsamos enter
Field length [255]: 100

New field name (press  to stop adding fields): password
Field type [string]: pulsamos enter
Field length [255]: 255

New field name (press  to stop adding fields): pulsamos enter

Do you want to generate an empty repository class [no]? No 

Do you confirm generation [yes]? Yes
Con esto ya hemos generado el código de nuestra endidad, el cual podremos ver en la carpeta Entity de nuestro bundle.
Si queremos mapear esta entidad con nuestra base de datos, debemos ejecutar el siguiente comando en la consola:
$ php app/console doctrine:schema:create
Una vez creada la entidad, podemos crear datos de conexión para nuestra entidad mediante el phpmyadmin indicando la url de nuestro servidor, la base de datos a la cual nos vamos a conectar, el usuario y la contraseña.

2.3. Generar controlador OpenERP

Un controlador es un fichero que incluye la funcionalidad de nuestro bundle. Normalmente un controlador accede a la entidad de nuestro bundle, para acceder a la información de nuestra base de datos, y devuelve una vista, que muestra en pantalla esta información. Vamos a generar un controlador nuevo para conectar a OpenERP.
El primer paso serĆ­a descargar la liberia de conexion a OpenERP de la siguiente url https://github.com/tejastank/openerp-php-connector e incluirla en la carpeta controller de nuestro bundle.
require_once __DIR__.'/openerp/openerp.class.php';
En este ejemplo la libreria de conexión a OpenERP se ha guardado en la carpeta openerp del controlador.
Con todo esto, podemos desarrollar nuestra conexión simple mediante el siguiente controlador:
<?php
    namespace OpenerpConnectBundleController;

    use SymfonyBundleFrameworkBundleControllerController;
    use OpenerpConnectBundleEntityOpenerp;
    use SymfonyComponentHttpFoundationRequest;

   require_once __DIR__.'/openerp/openerp.class.php';

   class DefaultController extends Controller
   {

       public function indexAction($name)
        {
           return $this->render('ConnectBundle:Default:index.html.twig', array('name' => $name));
       }

       public function loginAction(Request $request)
       {

           $openerp = new Openerp();
           $form = $this->createFormBuilder($openerp)
             ->add('username', 'text')
             ->add('password', 'password')
             ->getForm();

           if ($request->isMethod('POST')) 
           {
                $form->bind($request);
              if ($form->isValid()) 
              {
                    $em = $this->getDoctrine()->getManager();
                    $shop = $em->getRepository('ConnectBundle:Openerp')->findOneBy(array('id' => 1));
                 $rpc = new OpenERP();
                 $uid = $rpc->login($shop->getUsername(), $shop->getPassword(), $shop->getBda());
                 $name = $rpc->read(array($uid), array('name'), 'res.users');
                 return $this->render('ConnectBundle:Default:welcome.html.twig', array(
                    'name' => $name[0]['name'],));
              }
           }
          return $this->render('ConnectBundle:Default:login.html.twig', array(   
          'form' => $form->createView(),
            ));
       }
    }
Este controlador genera un formulario simple para introducir el usuario y contraseƱa de un usuario de OpenERP. Una vez validado el formulario, busca el nombre del usuario que se ha conectado y devuelve una pĆ”gina con el mensaje “Bienvenido” mas el nombre de este usuario.

Las vistas para este controlador son las que se devuelven en el return:
return $this->render('ConnectBundle:Default:login.html.twig', array('form' => $form->createView(),));
return $this->render('ConnectBundle:Default:welcome.html.twig', array('name' => $name[0]['name'],));
Y se deben crear en la carpeta Resources/views del bundle, conteniendo el siguiente código:
<!-- login.html.twig -->
<form action="{{ path('portada')}}" method="post" {{ form_enctype(form)}}>
{{ form_widget(form)}}
<input type="submit"/>
</form>
<!-- welcome.html.twig -->
<h1>Bienvenido {{ name}}</h1>
Por último, hay que crear el path del controlador. Para ello hay que añadir las siguientes líneas en el fichero routing.yml que se encuentra en la carpeta app/config de nuestro proyecto:
portada:
path: /
defaults: { _controller: ConnectBundle:Default:login}
Ahora si accedemos a 192.168.0.122/symfony/web/app_dev.php podremos ver nuestro formularĆ­o de acceso.

Con todo esto hemos conseguido generar un bundle de conexión a OpenERP que puede ser incluido en otros bundles facilitando con esto acceder a los datos de OpenERP.

3. Conexión OpenERP con Symfony

Symfony funciona como un servicio rest, el cual nos permite acceder a la información mediante una url que accede a un método definido en un controlador. A continuación veremos un ejemplo de como conectar OpenERP con Symfony.
En primer lugar vamos a crear un módulo de OpenERP que genere una vista con un boton que nos permita enviar todos los productos de nuestro sistema a Symfony.
Definimos la clase:
class symfony(osv.osv_memory):
 _name = 'symfony'
symfony()
Con su vista asociada:
<?xml version="1.0" encoding="UTF-8"?>
    <openerp>
        <data>
            <record id="sync_products_form" model="ir.ui.view">
                <field name="name">sync.products.form</field>
                <field name="model">symfony</field>
                <field name="type">form</field>
                <field name="arch"type="xml">
                    <form string = "Sync Products">
                        <button name="sync_products" string="Sync" type="object" icon="gtk-apply"/>
                    </form>
                </field>
           </record>
         <record id="action_sync_products" model="ir.actions.act_window">
              <field name="name">Sync Products</field>
              <field name="type">ir.actions.act_window</field>
              <field name="res_model">symfony</field>
              <field name="view_type">form</field>
              <field name="view_mode">form</field>
              <field name="view_id" ref="sync_products_form"/>
              <field name="target">new</field>
          </record>
          <menuitem id="menu_sync_product" name="Sync Products"
          parent="stock.menu_stock_product" sequence="6"
          action="action_sync_products"/>
      </data>
    </openerp>
Y el metódo de sincronización:
def sync_products(self, cr, uid, ids, context = None):
   product_obj = self.pool.get("product.template")
      product_ids = product_obj.search(cr, uid, [], context = context)
   products = []

   for product in product_obj.browse(cr, uid, product_ids, context = context):
       product_dict = {}
        product_dict['name'] = product.name
                product_dict['list_price'] = product.list_price
                product_dict['standard_price'] = product.standard_price
                product_dict['description'] = product.description
                products.append(product_dict)

    products_json = json.dumps(products)
    url = "http://192.168.0.122/symfony/web/app_dev.php/get_products"
        f = urllib2.urlopen(url, products_json)
    response = f.read()
    f.close()
Como podemos observar el mƩtodo recupera todos los productos que tenemos en el sistema, los codifica en json y los envia al controlador get_products.
El siguiente paso seria definir este controlador en nuestro sistema Symfony:
public function get_productsAction()
{
    $em = $this->getDoctrine()->getManager(); 
    $products = json_decode($this->get('request')->getContent(), true);
        foreach ($products as $p)
       {
        $product = new Product();
                $product->setName($p['name']);
                $product->setListPrice($p['list_price']);
                $product->setStandardPrice($p['standard_price']);
                $product->setDescription($p['description']);
                $em->persist($product);
   }
   $em->flush();
      return new Response("ok");
}
Y aƱadirlo a nuestro routing.yml:
getProducts:
    path: /get_products
    defaults: { _controller: ConnectBundle:Default:get_products}
Como podemos observar en el código de nuestro controlador, existe una nueva entidad llamada Product que es la que se encarga de almacenar los productos. Para generarla utilizaremos la consola de Symfony:
$ php app/console doctrine:generate:entity

The Entity shortcut name: ConnectBundle:Product
Configuration format (yml, xml, php, or annotation) [annotation]: 
pulsamos enter

New field name (press  to stop adding fields): name
Field type [string]: 
pulsamos enter

Field length [255]: 
pulsamos enter

New field name (press  to stop adding fields): list_price
Field type [string]: decimal

New field name (press  to stop adding fields): standard_price
Field type [string]: decimal

New field name (press  to stop adding fields): description
Field type [string]: text

New field name (press  to stop adding fields): 
pulsamos enter

Do you want to generate an empty repository class [no]? 
pulsamos enter

Do you confirm generation [yes]? 
pulsamos enter
Por Ćŗltimo, actualizamos el esquema de nuestra base de datos.
$ php app/console doctrine:schema:update --force
Con esto ya podemos ejecutar nuestro módulo de OpenERP y realizar la conexión que nos importara todos los productos.
productos

4. Conclusiones

Como hemos podido observar en este artículo, la conexión a OpenERP con Symfony es muy sencilla. Debemos incluir la librería de conexión de php a OpenERP en un nuevo bundle de conexión. Este nuevo bundle podra ser incluido en otros bundles facilitando con esto el acceso de Symfony a OpenErp.

En cuanto a la conexión de OpenErp con Symfony, también hemos podido comprobar que es bastante sencilla ya que Symfony actua como un servicio rest muy facil de acceder. Simplemente debemos llamar desde OpenErp al método de Symfony que queramos acceder.

En resumen, generar un nuevo proyecto web con Symfony que acceda a OpenERP es muy sencillo, lo cual nos permite generar proyectos como tiendas online mediante el respaldo de OpenERP.