Objetos, Campos y Métodos

Objetos, campos y métodos

Objetos OpenERP Todos los elementos de datos del ERP son accesibles a través de "objetos". Como ejemplo, hay un objeto res.partner para acceder a los datos relativos a los socios, un objeto account.invoice para los datos relativos al facturas, etc ...Tenga en cuenta que hay un objeto para cada tipo de recurso y no un objeto por recurso. Tenemos así un objeto res.partner para gestionar todos los socios y no un res.partner objeto por socio. Si hablamos en términos "orientado a objetos", también podríamos decir que hay un objeto por nivel.Las consecuencias directas es que todos los métodos de los objetos tienen un parámetro común: el parámetro "ids". Esto especifica en el que se deben aplicar el método de los recursos. Precisamente, este parámetro contiene una lista de identificadores de recursos sobre los que se debe aplicar el método.Por ejemplo, si tenemos dos socios con los identificadores de 1 y 5, y queremos llamar al método "send_email" de res_partner, vamos a escribir algo como:

res_partner.send_email (..., [1, 5], ...)

En la siguiente sección, veremos cómo definir un nuevo objeto. Entonces, vamos a ver los diferentes métodos de hacer esto.

Para los desarrolladores:● OpenERP "objetos" se suele denominar clases en la programación orientada a objetos.● Un OpenERP "recurso", por lo general, se llama a un objeto en la programación OO, instancia de una clase.Es un poco confuso cuando se intenta programar dentro de OpenERP, porque el lenguaje utilizado es Python y Python es un lenguaje totalmente orientado a objetos, y tiene objetos e instancias ...Por suerte, un "resource" OpenERP se puede convertir por arte de magia en un bonito objeto Python utilizando el método de la clase "browse" (método de objeto OpenERP).

El ORM - mapeo objeto-relacional - Modelos El ORM, acrónimo de Object-Relational Mapping, es una parte central de OpenERP.En OpenERP, el modelo de datos se describe y se manipula a través de clases de Python y de sus objetos. Es el trabajo ORM para establecer un puente - la forma más transparente posible para el desarrollador - entre Python y la base de datos relacional subyacente (PostgreSQL), que

fuente:http://openerp-server.readthedocs.org/en/latest/03_module_dev_02.html

proporcionará la persistencia que necesitamos para nuestros objetos.

Atributos OpenERP Objeto

Objetos Introducción Para definir un nuevo objeto, debe definir una nueva clase Python para después instanciarlo. Esta clase debe heredar de la clase OSV en el módulo osv.

Objeto definición La primera línea de la definición del objeto siempre será de la forma:clase name_of_the_object (OSV.osv:) _name = 'name.of.the.object' _columns = {...} ... name_of_the_object ()

Un objeto se define declarando algunos campos con nombres predefinidos en la clase. Dos de ellos están obligados (_name y _columns), el resto son opcionales. Los campos predefinidos son:

Campos predefinidos _autoDetermina si una tabla de PostgreSQL correspondiente se debe generarse automáticamente del objeto. La configuración _auto = 'False' puede ser útil en caso de objetos OpenERP generados a partir de vistas de PostgreSQL.

_columns (requerido)

Los campos de objeto. Ver sección Fields para más detalles.

_constraintsLas restricciones sobre el objeto. Vea la sección de limitaciones para más detalles.

_sql_constraintsLa restricción de SQL en el objeto. Vea la sección de limitaciones de SQL para obtener más detalles.

_defaultsLos valores predeterminados para algunos de los campos del objeto. Vea la sección de valor por defecto para los detalles.


_inheritEl nombre del objeto osv que el objeto actual hereda. Vea la sección de objetos de herencia (primera forma) para más detalles.


_inheritsLa lista de objetos osv el objeto hereda de. Esta lista se debe dar en un diccionario python de la forma: {'name_of_the_parent_object': 'name_of_the_field', ...}. Vea la sección de objetos de herencia (segunda forma) para más detalles. Valor por defecto: {}.

_log_accessDetermina los permisos del recurso al iniciar sesión. Si es verdad, cuatro campos se crearán en la tabla de SQL: create_uid, create_date, write_uid, write_date. Esos campos representan, respectivamente, el ID del usuario que creó el registro, la fecha de creación del registro, el identificador del usuario que modificó por última vez el registro y la fecha de la última modificación. Estos datos pueden obtenerse utilizando el método perm_read.

_name (requerido)Nombre del objeto. Valor predeterminado: Ninguno.

_orderNombre de los campos utilizados para ordenar los resultados de los métodos búsqueda y lectura.

Valor por defecto: 'id'.

Ejemplos:

_order = "name" _order = "date_order desc"

_rec_nameNombre del campo en el que el nombre de cada recurso se almacena. Valor por defecto: "name". Nota: por defecto, el método name_get simplemente devuelve el contenido de este campo.

_sequenceNombre de la secuencia SQL que gestiona los identificadores para este objeto. Valor predeterminado: Ninguno.

_sqlCódigo SQL ejecutado sobre la creación del objeto (sólo si _auto es verdadera). Significa que este código es ejecutado después de crear la tabla.

_tableNombre de la tabla de SQL. Valor por defecto: el valor del campo _name anterior con los puntos reemplazada por guiones bajos (_) (.).


Herencia de Objetos - _inherit

Introducción Los objetos pueden ser heredados de módulos comunes o de módulos específicos. Se utiliza para heredar un objeto para agregar y/o modificar algunos campos.Se realiza con:

_inherit = 'object.name'

Extensión de un objeto Hay dos formas posibles de hacer este tipo de herencia. Ambas formas dan como resultado una nueva clase de datos, que tiene campos de padres y métodos, así como campos adicionales y comportamiento propio, pero difieren en resultados diferentes del programa al ser ejecutados.Mientras Ejemplo 1 crea una nueva subclase "custom_material" que pueden ser "heredada" o "usada" por cualquier vista o un árbol que se ocupa de "network.material", éste no será el caso para el Ejemplo 2.Esto se debe a la tabla (other.material) la nueva subclase está operando en, que nunca será reconocido por las opiniones anteriores "network.material" o árboles.Ejemplo 1:

class custom_material(osv.osv): _name = 'network.material' _inherit = 'network.material' _columns = { 'manuf_warranty': fields.boolean('Manufacturer warranty?'), } _defaults = { 'manuf_warranty': lambda *a: False, } custom_material()

aviso_name == _inherit

En este ejemplo, el 'custom_material' añadirá un nuevo campo 'manuf_warranty' al objeto 'network.material'. Nuevas instancias de esta clase serán visibles por los puntos de vista o árboles que operan en la mesa superclases 'network.material'.


Este inheritancy se suele llamar "la herencia de clases" en el diseño orientado a objetos. El niño hereda de datos (campos) y el comportamiento (funciones) de su padre.


Ejemplo 2:

class other_material(osv.osv): _name = 'other.material' _inherit = 'network.material' _columns = { 'manuf_warranty': fields.boolean('Manufacturer warranty?'), } _defaults = { 'manuf_warranty': lambda *a: False, } other_material()

aviso_name != _inheritEn este ejemplo, el 'other_material' llevará a cabo todos los campos especificados por 'network.material' y, además, llevará a cabo un nuevo campo 'manuf_warranty'. Todos los campos serán parte de la tabla 'other.material'. Nuevos casos de esta clase, por lo tanto nunca han visto por opiniones o árboles que operan en la mesa superclases 'network.material'.Este tipo de inheritancy se conoce como "herencia de prototipos" (por ejemplo Javascript), debido a que las subclases de "copias" de nueva creación todos los campos de la superclase especificado (prototipo). El hijo hereda de los datos (campos) y el comportamiento (funciones) de su padre.

La herencia selectiva de objetos - _inherits Sintaxis::tiny_object clase (osv.osv) _name = 'tiny.object' _table = 'tiny_object' _inherits = { 'tiny.object_a': 'object_a_id', 'tiny.object_b': 'object_b_id', ..., 'tiny.object_n': 'object_n_id' } (...)

El objeto 'tiny.object' hereda de todas las columnas y todos los métodos de los n objetos 'tiny.object_a', ..., 'tiny.object_n'.Para heredar de varias tablas, la técnica consiste en añadir una columna a la tiny_object tabla por objeto heredado. En esta columna se almacenará una clave externa (un id de otra tabla). Los valores 'object_a_id' 'object_b_id' ... 'object_n_id' son de tipo cadena y determinar el título de las columnas en las que las claves externas de 'tiny.object_a', ..., 'tiny.object_n' se almacenan.Este mecanismo de herencia se suele llamar "la herencia ejemplo" o "la herencia de valor". Un recurso (ejemplo) tiene los valores de sus padres.


Los campos Introducción Los objetos pueden contener diferentes tipos de campos. Esos tipos se pueden dividir en tres categorías: tipos simples, tipos de relaciones y campos funcionales. Los tipos simples son enteros, flotadores, booleanos, cadenas, etc ...; Los tipos de relación se utilizan para representar relaciones entre objetos (one2one, one2many, many2one). Campos funcionales son campos especiales porque no se almacenan en la base de datos pero calculan en tiempo real dado otros campos de la vista.Aquí está la cabecera del método de inicialización de la clase cualquier campo definido en OpenERP hereda (como se puede ver en el server / bin / osv / fields.py):

def __init __ (self, cadena = "desconocido", requerido = False, readonly = False, domain = Ninguno, context = "", afirma = Ninguno, priority = 0, change_default = False, size = Ninguno, onDelete = "conjunto vacío", traducir = False, seleccione = False, ** args):

Hay un conjunto común de parámetros opcionales que están disponibles para la mayoría de los tipos de campo:

change_default:

Sea o no el usuario puede definir valores por defecto en otros campos, dependiendo del valor de este campo. Esos valores por defecto deben ser definidos en la tabla ir.values.

help: Una descripción de cómo el campo se debe utilizar: mucho más descriptivo que cadena. Aparecerá en una información sobre herramientas cuando el ratón pasa sobre el campo.

ondelete: Cómo manejar deleciones en un registro relacionado. Los valores permitidos son: 'restringir', 'no acción', 'cascada', 'conjunto vacío "y" predeterminado ".

priority: ¿No utilizado?readonly: Verdadero si el usuario no puede editar este campo, de lo

contrario False.sequired: Verdadero si este campo debe tener un valor antes de que el

objeto puede ser salvado, de lo contrario False.size: El tamaño del campo en la base de datos: caracteres numéricos o

dígitos.establece lo siguiente:

Le permite anular otros parámetros para estados específicos de este objeto. Acepta un diccionario con los nombres de estado como llaves y una lista de tuplas de nombre / valor como los valores. Por ejemplo: estados = {'publicado': [('sólo lectura', True)]}

cuerda: El nombre del campo como debe aparecer en un encabezado de etiqueta o columna. Cuerdas que contienen caracteres no ASCII deben utilizar objetos Unicode Python. Por ejemplo: 'probado': fields.boolean (u'Testé ')

translate: Verdadero si el contenido de este campo debe ser traducido, de lo contrario False.

También hay algunos parámetros opcionales que son específicos para algunos tipos de campos:


context: Definir el valor de una variable visible en el contexto de la vista o una función en el cambio. Se utiliza en la búsqueda de la tabla secundaria one2many relación?

domain: Restricción de dominio en un campo relacional.Valor por defecto: [].Ejemplo: domain = [('campo', '=', valor)])

invisible: Ocultar el valor del campo en formas. Por ejemplo, una contraseña.

on_change:

El valor por defecto para el on_change atributo en la vista. Esto abrirá una función en el servidor cuando el campo cambia en el cliente. Por ejemplo, on_change = "onchange_shop_id (shop_id)".

relation: Se utiliza cuando un campo es una referencia de Identificación a otra mesa. Este es el nombre de la tabla a mirar en. Lo más común es utilizar con tipos de campos relacionados y función.

selected: El valor por defecto para el selecto atributo en la vista. 1 significa búsqueda básica y 2 significa búsqueda avanzada.

Tipo de Campos

Tipos básicos boolean: Un booleano (verdadero, falso).

Sintaxis:

fields.boolean ('Nombre de campo' [, Parámetros Opcional]),

integer: Un entero.Sintaxis:

fields.integer ('Nombre de campo' [, Parámetros Opcional]),

float: Un número de coma flotante.Sintaxis:

fields.float ('Nombre de campo' [, Parámetros Opcional]),

Nota

Los dígitos de los parámetros opcionales define la precisión y escala del número. La escala es el número de dígitos después del punto mientras que la precisión decimal es el número total de dígitos significativos en el número (antes y después del punto decimal). Si los dígitos parámetro no está presente, el número será un número de coma flotante de doble precisión. Advertencia: estos números de punto flotante son inexactas (no cualquier valor puede convertirse a


su representación binaria) y esto puede dar lugar a errores de redondeo. Siempre se debe utilizar el parámetro dígitos para importes monetarios.

Ejemplo:

'tasa': fields.float ( 'Relativa tasa de cambio ", dígitos = (12,6) [, Parámetros opcionales]),

char: Una cadena de longitud limitada. El parámetro tamaño requerido determina su tamaño.Sintaxis:

fields.char ( 'Nombre del campo', size = n [, Parámetros opcionales]), #, donde '' n '' es un número entero.

Ejemplo:

'ciudad': fields.char ('Nombre de la ciudad ", tamaño = 30, requerida = True),

text: Un campo de texto sin límite de longitud.Sintaxis:

fields.text ('Nombre de campo' [, Parámetros Opcional]),

date: Una cita.Sintaxis:

fields.date ('Nombre de campo' [, Parámetros opcionales]),

datetime: Permite almacenar una fecha y el momento del día en el mismo campo.Sintaxis:

fields.datetime ('Nombre de campo' [, Parámetros opcionales]),

binary: Una cadena binariaselection: Un campo que permite al usuario hacer una selección entre

varios valores predefinidos.Sintaxis:

fields.selection ((('n', 'no confirmada'), ('c',


'Confirmado')), 'Nombre del campo' [, Parámetros Opcional]),

Nota

Formato del parámetro de selección: tupla de tuplas de cadenas de la forma:

(('Key_or_value', 'string_to_display'), ...)

Nota

Puede especificar una función que devolverá la tupla. Ejemplo

def _get_selection (auto, cursor, user_id, contexto = None): retorno (('Choice1', 'Esta es la opción 1'), ('elección2', 'Esta es la opción 2'))

_columns = {'sel': campos. selección (_get_selection, '¿Qué quieres?')}

EjemploCampos de relación Uso many2one con la selección. En los campos de las definiciones agregan:

...,'my_field': fields.many2one ( 'mymodule.relation.model', 'Título', selección = _sel_func),...,

Y luego definir el _sel_func así (pero antes de las definiciones de los campos):

def _sel_func ( self , cr , uid , context = None ): obj = self . pool . get ( 'mymodule.relation.model' ) ids = obj . search ( cr , uid , []) res = obj . read ( cr , uid , ids , [ 'name' , 'id' ],


context ) res = [( r [ 'id' ], r [ 'name' ]) for r in res ] return res


Tipos relacionales one2one: Un campo one2one expresa una: a: un relación entre dos

objetos. Se está en desuso. Utilice many2one lugar.Sintaxis:

campos. one2one ('other.object.name', 'Nombre del campo')

many2one: Associates este objeto a un objeto padre a través de este campo. Por ejemplo Departamento un Empleado pertenece haría Muchos a uno. es decir Muchos empleados pertenecerán a un DepartamentoSintaxis:

fields.many2one ( 'other.object.name', 'Nombre del campo', parámetros opcionales)

Parámetros opcionales:● ondelete: ¿Qué debe suceder cuando el recurso puntos este campo para se elimina.○ Valor predefinido: "cascada", "conjunto vacío", "restringir", "no acción", "conjunto predeterminado"○ Valor por defecto: "null set"● requerido: True● readonly: True● seleccione: True - (crea un índice en el campo de clave externa)Ejemplo

"comercial": fields.many2one ( 'res.users', 'Comercial', ondelete = "en cascada"),

one2many: HACERSintaxis:

fields.one2many ( 'other.object.name', 'El campo Identificación relación', 'Nombre del campo', parámetro opcional)

Parámetros opcionales:


● invisible: Verdadero / Falso● afirma:?● readonly: Verdadero / FalsoEjemplo

'dirección': fields.one2many ( 'res.partner.address', 'identificación del socio', "Contactos"),

Many2Many:

HACERSintaxis:

campos. Many2Many ('other.object.name', 'objeto relación', 'actual.object.id', 'other.object.id', 'Nombre de campo')

Dónde:● other.object.name es el otro objeto que pertenece a la relación● relación de objeto es la tabla que hace el enlace● actual.object.id y other.object.id son los nombres de los campos de los utilizados en la tabla de relaciónEjemplo:

'category_ids': fields.many2many ( 'res.partner.category', 'res_partner_category_rel', 'identificación del socio', 'category_id', 'Categorías'),

Para que sea bidireccional (= crear un campo en el otro objeto):

class other_object_name2 ( osv . osv ): _inherit = 'other.object.name' _columns = { 'other_fields' : fields . many2many ( 'actual.object.name' , 'relation objeto ',' actual.object.id ',' other.object.id ',' Otro Nombre de campo '),} other_object_name2 ()

Ejemplo:


class res_partner_category2 ( osv . osv ): _inherit = 'res.partner.category' _columns = { 'partner_ids' : fields . many2many ( 'res.partner' , 'res_partner_category_rel' , 'category_id' , 'partner_id' , 'Partners' ), } res_partner_category2 ()

related: A veces es necesario hacer referencia a la relación de una relación. Por ejemplo, supongamos que usted tiene objetos: Ciudad -> Estado -> País, y lo que necesita para hacer referencia al país de una ciudad, se puede definir un campo como a continuación en el objeto Ciudad:

'country_id': fields.related ( 'state_id', 'country_id', type = "many2one", relación = "res.country", cadena = "País", store = False)

Dónde:● El primer conjunto de parámetros son la cadena de campos de referencia a seguir, con el campo deseado al final.● tipo es el tipo de campo que se desee.● Utilice relación si el campo deseado sigue siendo una especie de referencia. Relación es la tabla para buscar esa referencia en.


Los campos funcionales Un campo funcional es un campo cuyo valor se calcula mediante una función (en lugar de ser almacenado en la base de datos).Parámetros:

fnct, arg = Ninguno, fnct_inv = Ninguno, fnct_inv_arg = Ninguno, type = "float", fnct_search = Ninguno, obj = Ninguno, method = False, almacenar = False, multi = False

dónde● fnct es la función o el método que va a calcular el valor del campo. Debe de haber sido declarado antes de declarar el ámbito funcional.● fnct_inv es la función o método que permitirá a los valores de escritura en ese campo.● tipo es el nombre del tipo de campo devuelto por la función. Puede ser cualquier nombre de tipo de campo, excepto la función.● fnct_search le permite definir el comportamiento de búsqueda en ese campo.● método si el campo es calculada por un método (de un objeto) o una función global● almacenar Si desea almacenar campo en la base de datos o no. El valor predeterminado es False.● múltiples es un nombre de grupo. Todos los campos con el mismo múltiples parámetros se calcularán en una sola llamada de función.

parámetro fnct

Si el método es cierto que la firma del método debe ser:

def fnct (self, cr, uid, ids, field_name, arg, contexto):

de lo contrario (si se trata de una función global), su firma debe ser:

def fnct (cr, mesa, identificadores, field_name, arg, contexto):


De cualquier manera, debe devolver un diccionario de los valores de la forma {id'_1_ ': value'_1_', id'_2_ ': value'_2 _', ...}.Los valores del diccionario regresado deben ser del tipo especificado por el tipo de argumento en la declaración de campo.Si múltiples se establece, entonces field_name se sustituye por field_names: una lista de los nombres de los campos que deben ser calculados.Cada valor en el diccionario devuelto es también un diccionario de nombre de campo de valor. Por ejemplo, si los campos "Nombre" y "edad"están basados en la vital_statistics función, entonces el valor de retorno de vital_statistics podría tener este aspecto cuando ids es [1, 2, 5]:

{ 1: {'nombre': 'Bob', "edad": 23}, 2: {"nombre": "Sally," edad ", 19}, 5: {'nombre': 'Ed', "edad": 62}}

parámetro fnct_inv

Si el método es cierto, la firma del método debe ser:

def fnct (self, cr, uid, ids, field_name, FIELD_VALUE, arg, contexto):

en caso contrario (si se trata de una función global), que debe ser:

def fnct (cr, mesa, identificadores, field_name, FIELD_VALUE, arg, contexto):

parámetro fnct_search

Si el método es cierto, la firma del método debe ser:

fnct def (self, cr, uid, obj, nombre, args, contexto):

en caso contrario (si se trata de una función global), que debe ser:

def fnct (cr, uid, obj, nombre, args, contexto):

El valor de retorno es una lista que contiene 3 partes tuplas que se utilizan en función de búsqueda:

volver [('id', 'en', [1, 3, 5])]

obj es igual que uno mismo, y nombre recibe el nombre del campo. args es una lista de tuplas de 3 partes que contienen criterios de búsqueda para este campo, aunque la función de búsqueda puede ser llamado por separado para cada tupla.


Ejemplo

Supongamos que creamos un objeto de contrato que es:

class hr_contract ( osv . osv ): _name = 'hr.contract' _description = 'Contract' _columns = { 'name' : fields . char ( 'Contract Name' , size = 30 , required = True ), 'employee_id' : fields . many2one ( 'hr.employee' , 'Employee' , required = True ), 'function' : fields . many2one ( 'res.partner.function' , 'Function' ), } hr_contract ()

Si queremos añadir un campo que recupera la función de un empleado por mirar de su actual contrato, utilizamos un campo funcional. El hr_employee objeto se hereda de esta manera:

class hr_employee ( osv . osv ): _name = "hr.employee" _description = "Employee" _inherit = "hr.employee" _columns = { 'contract_ids' : fields . one2many ( 'hr.contract' , 'employee_id' , 'Contracts' ), 'function' : fields . function ( _get_cur_function_id , type = 'many2one' , obj = "res.partner.function" , method = True , string = 'Contract Función '),} hr_employee ()

Nota

tres puntos

● escriba = 'many2one' se debe a que el campo de función debe crear un campo many2one; función se declara como un many2one en hr_contract también.● obj = "res.partner.function" se utiliza para especificar que el objeto que se utilizará para el campo many2one es res.partner.function.● Llamamos a nuestro método _get_cur_function_id porque su papel es el de devolver un diccionario cuyas claves son identificadores de los empleados, y


cuyos valores correspondientes son los identificadores de la función de esos empleados. El código de este método es:

def _get_cur_function_id (auto, cr, uid, identificadores, field_name, arg, contexto): para i en identificadores: #get el id de la función actual del empleado de identificador "i" sql_req = "" "SELECT f.id AS id_función DESDE hr_contract c LEFT JOIN res_partner_function f ON (f.id = c.function) DONDE (c.employee_id =% d) "" "% (i,)

cr. ejecutar (sql_req) sql_res = cr. dictfetchone ()

si sql_res: #El empleado tiene un contrato asociados res [i] = sql_res ['id_función'] otra cosa: #res [i] se deben establecer en falso y no a ninguno a causa de XML: RPC # "no pueden reunir Nada menos que allow_none es habilitados "res [i] = False retorno res

El id de la función se recupera mediante una consulta SQL. Tenga en cuenta que si la consulta no devuelve ningún resultado, el valor de sql_res ['id_función'] será Ninguno. Nos forzamos el valor False en este caso porque el valor XML: RPC (comunicación entre el servidor y el cliente) no permite transmitir este valor.

almacenar Parámetro

Se calculará el campo y almacenar el resultado en la tabla. El campo se volverá a calcular cuando ciertos campos se cambian en otros objetos. Se utiliza la siguiente sintaxis:

store = {'object_name': (function_name, ['field_name1', 'field_name2'], prioridad)}

Se llamará a la función function_name cuando los cambios se escriben en los campos en la lista ["campo1", "campo2 '] en el objeto' object_name '. La función debe tener la siguiente firma:

function_name def (self, cr, uid, ids, context = None):


Dónde identificadores serán los identificadores de los registros en la mesa del otro objeto que han cambiado los valores en los campos observados. La función debe devolver una lista de identificadores de registros en su propia mesa que debe tener el campo vuelve a calcular.Dicha lista se enviará como un parámetro para la función principal del campo.He aquí un ejemplo del módulo de la membresía:

'membership_state': campos. función (_membership_state, método = Verdadero, cadena = 'Composición actual state' , type = 'selection' , selection = STATE , store = { 'account.invoice' : ( _get_invoice_partner , [ 'state' ], 10 ),

'membership.membership_line' : ( _get_partner_id ,[ 'state' ], 10 ), 'res.partner' : ( lambda self , cr , uid , ids , c = {}: ids , [ 'free_member' ], 10 ) }),

Los campos Propiedad Declarar una propiedadUna propiedad es un campo especial: fields.property.

class res_partner ( osv . osv ): _name = "res.partner" _inherit = "res.partner" _columns = { 'property_product_pricelist' : fields . property ( 'product.pricelist' , type = 'many2one' , relation = 'product.pricelist' , string = "Sale Lista de precios ", método = Verdadero, nombre_grupo =" Lista de precios Propiedades "),}

Entonces usted tiene que crear el valor por defecto en un archivo .XML para esta propiedad:

<record model= "ir.property" id= "property_product_pricelist" > <field name= "name" > property_product_pricelist </field> <field name= "fields_id" search= "[('model','=','res.partner'), ('name','=','property_product_pricelist')]" /> <field name= "value" eval= "'product.pricelist,'+str(list0)" />


</record>

Consejo

si el valor por defecto apunta a un recurso de otro módulo, puede utilizar la función ref así:

<nombre del campo = "valor" eval = "'product.pricelist,' + str (ref ('module.data_id'))" />

Poner propiedades en formasPara agregar propiedades en formas, sólo hay que poner la <propiedades /> en su formulario. Esto agregará automáticamente todos los campos de propiedades que están relacionados con este objeto. El sistema agregará propiedades en función de sus derechos. (algunas personas serán capaces de cambiar una propiedad específica, otros no).Las propiedades se muestran por sección, dependiendo del atributo nombre_grupo. (Se hizo en el cliente como una etiqueta separador).Cómo funciona esto ?La clase fields.property hereda de fields.function y reemplaza el método de lectura y escritura. El tipo de este campo es many2one, por lo que en la forma de una propiedad se representa como una función many2one.Pero el valor de una propiedad se almacena en el ir.property clase / tabla como un registro completo. El valor almacenado es un campo de referencia de tipo (no many2one) porque cada propiedad puede apuntar a un objeto diferente. Si modifica valores de las propiedades (en el menú de administración), éstas se representan como un campo de referencia del tipo.Cuando lees una propiedad, el programa le da la propiedad adjunta a la instancia de objeto que está leyendo. Si este objeto no tiene valor, el sistema le dará la propiedad predeterminada.La definición de una propiedad se almacena en la clase ir.model.fields como cualquier otro campo. En la definición de la propiedad, puede agregar grupos que tienen permiso para cambiar a la propiedad.El uso de propiedades o campos normalesCuando usted quiere agregar una nueva función, usted tendrá que elegir para poner en práctica como una propiedad o como campo normal.Utilice un campo normal cuando se hereda de un objeto y desea extender este objeto. Utilice una propiedad cuando la nueva característica no está relacionada con el objeto, sino a un concepto externo.Aquí hay algunos consejos para ayudarle a elegir entre un campo normal o una propiedad:Campos normales extienden el objeto, añadiendo más características o datos.Una propiedad es un concepto que se adjunta a un objeto y tienen características especiales:● Valor diferente para la misma propiedad dependiendo de la compañía● Gestión de derechos por campo● Es un vínculo entre los recursos (many2one)Ejemplo 1: Cuenta por Cobrar


El valor por defecto "Cuenta por Cobrar" un socio específico se ejecuta como una propiedad porque:● Este es un concepto relacionado con la tabla de cuenta y no a la pareja, por lo que es una propiedad cuenta que es visible en una forma pareja. Derechos tienen que ser gestionados en estos campos para los contadores, estos no son los mismos derechos que se aplican a los objetos asociados. Así que usted tiene derechos específicos sólo para este campo de forma pareja: sólo los contadores pueden cambiar la cuenta por cobrar de un socio.● Este es un campo multi-empresa: la misma pareja puede tener diferentes valores de la cuenta por cobrar en función de la empresa que pertenece el usuario. En un sistema multi-empresa, hay una tabla de cuenta por cada empresa. La cuenta por cobrar de la pareja depende de la empresa que realizó el pedido de venta.● La cuenta por cobrar por defecto es el mismo para todos los socios y se configura en el menú propiedad general (en la administración).

Nota

Una cosa interesante es que las propiedades evitan código "spaghetti". El módulo cuenta depende de la (base) Módulo de pareja. Pero usted puede instalar el socio (base) del módulo sin el módulo de contabilidad. Si agrega un campo que apunta a una cuenta en el objeto de pareja, ambos objetos dependerán de uno al otro. Es mucho más difícil de mantener y código (por ejemplo, tratar de eliminar una tabla cuando ambas tablas están apuntando a los demás.)

Ejemplo 2: El producto tiemposEl módulo de caducidad del producto implementa todas las demoras relacionadas con los productos: fecha de retirada, usetime producto, ... Este módulo es muy útil para las industrias de alimentos.Este módulo hereda del objeto product.product y añade nuevos campos a la misma:

clase product_product (OSV. OSV):

_inherit = 'product.product' _name = 'product.product' _columns = {

'life_time': campos. entero ('tiempo de vida del producto'), 'use_time': campos. entero ('usetime producto'), 'removal_time': campos. entero ('tiempo de eliminación del producto'), 'alert_time': campos. entero ('Producto tiempo de alerta'),}

product_product ()

Este módulo añade campos simples al objeto product.product. No hicimos uso de propiedades debido a que:


● Extendemos un producto, el campo life_time es un concepto relacionado con un producto, no a otro objeto.● No necesitamos una gestión correcta por campo, los diferentes retardos son gestionados por las mismas personas que manejan todos los productos.

Métodos ORM

Mantener el contexto en métodos ORM En OpenObject, el contexto tiene datos muy importantes, tales como el idioma en que un documento debe ser escrito, si las necesidades sobre el terreno la función de actualizar o no, etc.Cuando se llama a un método de ORM, es probable que ya tenga un contexto - por ejemplo, el marco le proporcionará una como un parámetro de casi todos los métodos. Si usted tiene un contexto, es muy importante que siempre pasa a través de cada método de llamar.Esta regla también se aplica a la escritura de métodos ORM. Usted debe esperar recibir un contexto como parámetro, y siempre pasar a través de cualquier otro método de llamar ..


Documents

Objetos, Campos y Métodos