Nuevas Propiedades para los Campos en la nueva API Odoo

Propiedades en la definición de los Campos

    

Las nuevas propiedades de los campos en la Api de Odoo, nos evita definir campos fields.funcion, fields.property, etc..., ahora todo es utilizado mediante atributos:

from openerp import models, fields


class AModel(models.Model):

    _name = 'a_name'

    name = fields.Char(
        string="Name",                   # Etiqueta opcional para el Campo
        compute="_compute_name_custom",  # Transforma un campo normal en campo funcion
        store=True,                      # Si el campo es calculado, esta propiedad lo grabara en base de datos como una columna.
        select=True,                     # Fuerza el indice en un campo.
        readonly=True,                   # Campo solo lectura en las Vistas.
        inverse="_write_name"            # Recalcular cuando ocurre un evento
        required=True,                   # Campo Obligatorio.
        translate=True,                  # Convertir texto para multiples traducciones.
        help='Blabla',                   # Globo de ayuda.
        company_dependent=True,          # Convierte el campo a campo de tipo propiedad(property)
        search='_search_function'        # Funcion de Búsqueda para campos calculados.
    )

   # The string key is not mandatory
   # by default it wil use the property name Capitalized

   name = fields.Char()  #  Valid definition

Herencia de Campos

En odoo, podemos heredar la clase original y sobreescribir el campo original por nuevos valores, string, help, etc...

name = fields.Char(string='Nuevo Nombre')

Tipos de Campos

Boolean

Para la definición de un campo de tipo booleano:

abool = fields.Boolean()

Char

Campo de tipo Cadena.:

achar = fields.Char()

Podemos especificar:

• size: Numero maximo de caracteres
• translate: Si el campo puede contener varias traducciones.

Text

Podemos definir un campo de tipo texto, es decir un campo sin limite de caracteres:

atext = fields.Text()

Opciones:

• translate: Campo traducible a varios idiomas.

HTML

Almacena campos de tipo texto con una estructura html:

anhtml = fields.Html()

Opciones:

• translate: Campo traducible.

Integer

Almacena valores numericos a partir del 0, si se almacena un valor nulo por defecto el sistema guardara 0:

anint = fields.Integer()

Float

Definicion de campos con coma flotante (Punto decimal):

afloat = fields.Float()
afloat = fields.Float(digits=(32, 32))
afloat = fields.Float(digits=lambda cr: (32, 32))

Opciones:

• digits: Fuerza al sistema para asignarle un formato numero, numero de enteros y numero de decimales.

Date

Almacena campos de tipo fecha:

• context_today Devuelve la fecha del dia actual, basado en la zona horaria.
• today Retorna la fecha actual en formato string.
• from_string Retorna el valor datetime.date() en tipo cadena.
• to_string Retorna el valor de la funcion datetime.date en formato cadena.

>>> from openerp import fields

>>> adate = fields.Date()
>>> fields.Date.today()
'2014-06-15'
>>> fields.Date.context_today(self)
'2014-06-15'
>>> fields.Date.context_today(self, timestamp=datetime.datetime.now())
'2014-06-15'
>>> fields.Date.from_string(fields.Date.today())
datetime.datetime(2014, 6, 15, 19, 32, 17)
>>> fields.Date.to_string(datetime.datetime.today())
'2014-06-15'

DateTime

Almacena valores de tipo fecha y hora:

• context_timestamp Devuelve la fecha y hora actual, en formato time zone.
• now Retorna la fecha y hora actual.
• from_string Retorna el valor datetime.date() en tipo cadena
• to_string Retorna el valor de la funcion datetime.date en formato cadena.

>>> fields.Datetime.context_timestamp(self, timestamp=datetime.datetime.now())
datetime.datetime(2014, 6, 15, 21, 26, 1, 248354, tzinfo=<DstTzInfo 'Europe/Brussels' CEST+2:00:00 DST>)
>>> fields.Datetime.now()
'2014-06-15 19:26:13'
>>> fields.Datetime.from_string(fields.Datetime.now())
datetime.datetime(2014, 6, 15, 19, 32, 17)
>>> fields.Datetime.to_string(datetime.datetime.now())
'2014-06-15 19:26:13'

Binary

Almacena archivos binarios encodeados a formato Base 64 en nuestra Base de Datos.

abin = fields.Binary()

Selection

Almacena cadenas de texto, de una selección especifica (Diferentes Opciones):

aselection = fields.Selection([('a', 'A')])
aselection = fields.Selection(selection=[('a', 'A')])
aselection = fields.Selection(selection='a_function_name')

Opciones:

• selection: Lista de tuplas con las opciones a elegir, cada tupla se conforma de la clave la cual es almacenada en la Base de Datos y el segundo valor es el Texto para la parte grafica que mostramos al usuario.

Si extendemos o heredamos el campo es posible añadir opciones sin reemplazar todo el campo para ello utilizamos:

class SomeModel(models.Model):
    _inherits = 'some.model'
    type = fields.Selection(selection_add=[('b', 'B'), ('c', 'C')])

Reference

Guarda una referencia de un modelo y una fila:

aref = fields.Reference([('model_name', 'String')])
aref = fields.Reference(selection=[('model_name', 'String')])
aref = fields.Reference(selection='a_function_name')

Opciones:

• selection: Almacena una lista de tuplas con recorsets.

Many2one

Campo Relacional Muchos a Uno, relaciona valores de una segunda tabla en un campo, el cual contiene por defecto el ID del registro relacionado, el usuario vera siempre el campo especificado como nombre (name o rec_name).

arel_id = fields.Many2one('res.users')
arel_id = fields.Many2one(comodel_name='res.users')
an_other_rel_id = fields.Many2one(comodel_name='res.partner', delegate=True)

Opciones:

• comodel_name: Nombre de la Clase Opuesta.
• delegate: Activa True si el campo podra ser accedido desde el modelo donde se crea la relacion (_inherits)

One2many

Relación Uno a Muchos, crea una especie de lineas en el Sistema, done la relacion de los registros no puede ser reutilizada en otras tablas, se crea una especie de pertenencia de datos:

arel_ids = fields.One2many('res.users', 'rel_id')
arel_ids = fields.One2many(comodel_name='res.users', inverse_name='rel_id')

Opciones:

• comodel_name: Nombre del modelo opuesto.
• inverse_name: Relaciona la columna del modelo opuesto.

Many2many

Almacena registros creando una nueva tabla con las llaves primarias de Ambos, de esta forma podemos reutilizar registros de ambas tablas una cantidad infinita de veces:

arel_ids = fields.Many2many('res.users')
arel_ids = fields.Many2many(comodel_name='res.users',
                            relation='table_name',
                            column1='col_name',
                            column2='other_col_name')

Opciones:

• comodel_name: Nombre del modelo Opuesto.
• relation: Nombre de la tabla relacionada
• columns1: Nombre de la 1 columna de la nueva tabla con los IDS de la tabla donde creamos la relación.
• columns2: IDS de los registros de la relación y este sera el nombre de la columna.

Valores por defecto en los Campos

Ahora es posible definir los valores por defecto desde la definición del mismo campo, ya no es necesaria la propiedad _defaults = {}.

name = fields.Char(default='Nombre XXX')
# or
name = fields.Char(default=a_fun)

#...
def a_fun(self):
   return self.do_something()

Campos Calculados

Para la definición solo es necesario el atributo compute y el nombre del metodo que obtendra el resultado.

class AModel(models.Model):
    _name = 'a_name'

    computed_total = fields.Float(compute='compute_total')

    def compute_total(self):
        ...
        self.computed_total = x

En los campos calculados podemos utilizar el atributo search y definir un metodo que busque los campos que no son almacenados en las tablas:

def search_total(self, operator, operand):
    ...
    return domain  # e.g. [('id', 'in', ids)]

Related Field

Para los campos relacion, que nos permite obtener valores a traves de un campo many2one, ahora lo utilizamos desde el atributo related:

participant_nick = fields.Char(string='Nick name',
                               related='partner_id.name')

El valor type fue eliminado debido a que esta implicito en la definición del campo.

El valor store nos va permitir generar la columna en la tabla con el resultado de la funcion.

participant_nick = fields.Char(string='Nick name',
                               store=True,
                               related='partner_id.name')

Note

Si definimos el atributo translate, el resultado de la traducción es almacenada en el Sistema.

WIP copyable option

Podemos evitar que un registro sea duplicado con el metodo copy(), activando el atributo copy=False.

copy=False  # !! Evita copiar el valor de este campo cuando duplicamos un registro.