如何在Odoo 8中创建或写入时标准化字段值？

Question

In Odoo 8, is there a preferred method for standardizing field values on create or write? Several methods come to mind, but this functionality seems like it belongs in the API. Essentially, I am wanting to create a field that specifies a standardize function, somewhat like a compute field that only specifies an inverse function. Does this already exist somewhere in the API?

Method 0: Create a field that specifies a standardize function.

The only flaw that I can see with this method is that the API does not exist.

import openerp

class Model(openerp.models.Model):

  _name = 'addon.model'

  field = openerp.fields.Text(
    required=True,
    standardize='_standardize_field',
  )

  @openerp.api.one
  def _standardize_field(self):
    self.field = self.field.upper()

Method 1: Override the create and write methods to insert a call to standardize the field.

This works, but seems rather verbose for what could be done with a single function, above. Note that the constraint is required if required=True and the standardization might yield an empty field.

import openerp

class Model(openerp.models.Model):

  _name = 'addon.model'

  field = openerp.fields.Text(
    required=True,
  )

  @openerp.api.one
  @openerp.api.constrains('field')
  def _constrains_field(self):
    if len(self.field) == 0:
      raise openerp.exceptions.ValidationError('Field must be valid.')

  def _standardize(self, args):
    if 'field' in args:
      # Return standardized field or empty string.
      args['field'] = args['field'].upper()

  @openerp.api.model
  def create(self, args):
    self._standardize(args)
    return super(Model, self).create(args)

  @openerp.api.multi
  def write(self, args):
    self._standardize(args)
    super(Model, self).write(args)
    return True

Method 2: Use a computed field and a bit of magic.

This works but feels a bit contrived. In addition, this method requires that the standardization function is deterministic, or this may create an infinite loop. Note that the standardization function may be called twice, which could be a concern if standardization is an expensive operation.

import openerp

class Model(openerp.models.Model):

  _name = 'addon.model'

  field = openerp.fields.Text(
    compute=lambda x: x,
    inverse='_inverse_field',
    required=True,
    store=True,
  )

  @openerp.api.one
  @openerp.api.constrains('field')
  def _constrains_field(self):
    if self._standardize_field() is None:
      raise openerp.exceptions.ValidationError('Field must be valid.')

  def _inverse_field(self):
    field = self._standardize_field()

    # If the field is updated during standardization, this function will
    # run a second time, so use this check to prevent an infinite loop.
    if self.field != field:
      self.field = field

  def _standardize_field(self):
    # Return the standardized field.
    return self.field.upper()

Method 3: Use a regular field and a computed field, with only the computed field being exposed in the view.

The readonly flag and the constraints help to protect the underlying field, but I am not certain that this method would maintain data integrity, and the method as a whole feels contrived.

import openerp

class Model(openerp.models.Model):

  _name = 'addon.model'

  field = openerp.fields.Text(
    readonly=True,
    required=True,
  )

  field_for_view = openerp.fields.Text(
    compute='_compute_field_for_view',
    inverse='_inverse_field_for_view',
    required=True,
  )

  @openerp.api.one
  @openerp.api.depends('field')
  def _compute_field_for_view(self):
    self.field_for_view = self.field

  @openerp.api.one
  @openerp.api.constrains('field', 'field_for_view')
  def _constrains_field(self):
    if self._standardize_field() is None:
      raise openerp.exceptions.ValidationError('Field must be valid.')

  def _inverse_field(self):
    self.field = self._standardize_field()

  def _standardize_field(self):
    # Return the standardized field.
    return self.field_for_view.upper()

Answer 1

Maybe the 'default' attribute is an implementation of your approach #1? Here's the example taken from the Odoo8 documentation at https://www.odoo.com/documentation/8.0/reference/orm.html#creating-models

a_field = fields.Char(default=compute_default_value)

def compute_default_value(self):
    return self.get_value()

Another option is to override the write() method in your subclass to add your call like so:

    def write(self, vals):

        for record in self:
            # do the cleanup here for each record, storing the result in 
            # vals again

        # call the super:
        res = super(extendedProject, self).write(vals)

        return res

vals is a dictionary with the modified values to store; self is a recordset with all records to store the values to. Note that the transaction in Odoo may still be rolled back after returning from your call to write .