Hi all,

I noticed something a bit curious after shipping a new feature on a customized Odoo 18 instance on Odoo.sh. We built a custom integration with a service, and part of our implementation involved overriding the create​ and write​ methods in the res.partner​ model to make calls to the service (see the example code below).

  def create(self, vals):
    '''
      Override account creation so that a brivo user is 
      created along with this user.
    '''
    res = super().create(vals)
    res._create_brivo_user()
    return res

  def write(self, vals):
    '''
      Override account editing so that the brivo user
      is edited along with this user.
    '''
    res = super().write(vals)
    # Update or create the brivo user on write if the user is active
    if not self.env.context.get('skip_brivo_call_on_write', False) and self.active:  
      if self.brivo_id:
        brivo_update_user(self.env, self)
      else:
        self._create_brivo_user()
    # If the user's barcode was updated, 
    # update the Brivo user's credential
    if not self.env.context.get('skip_brivo_call_on_write', False) and vals.get('barcode') and self:
      self._update_user_barcode_credential()
    return res

So, when we call create​, we create a corresponding user on the service (Brivo). We then use the context to avoid making extra calls in write​ because we understand that there's an automatic call to it that's made after the call to create​.

This flow worked perfectly fine on a local (neutralized) copy of our database. However, when we tested it in a production database, we were unable to create new contacts on Odoo. Inspecting the logs, I noticed that there were extra, unexpected calls being made to the Brivo service that were causing creation to fail. After a bit of digging, I realized that the write​ method was being called before the new contact record was being written to the database. We fixed the issue by removing our create​ override.

I expected the flow to be like this: create​, then write to database, then write​. This seemed to be how it worked in the local copy of the database. That doesn't seem to be the case in the production copy.

What are the differences in the create/write lifecycle between a production and a neutralized database, if any?