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

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.