Generic System Event

This module provides framework that allows to make odoo event-driven. Note, that in this case event means business event.

With this module, you can easily convert your model to event source, and then handle events from that model in any other place of odoo. With this module you may forget about again and again overriding ``write`` methods.

Why this is needed?

This module allows to step away from infinite overrides of write/create, or overriding other methods to add some logic. Instead, with this framework, you can think in event driven way: just trigger event with all needed data where it is needed. And handle this event in multiple places in multiple modules, in multiple related models.

For example, you can define event like Invoice Paid, and then handle it on Sale Order, In CRM, or in any other related object. The framework, will automatically call all registered handlers of this event. This way, it is possible to significantly simplify complex logic of handling events.

Also, because events are stored in database, you always have history of events related to specific record, which could help in debug, or in tracking what is going on in some cases.

How to use

1. Create model for events

   At first, you have to create model to store events produced by your event source.

   You can define such model as following:

    python
                       
                           class MyEvent(models.Model):
                               _name = 'my.event'
                               _inherit = 'generic.system.event.data.mixin'
   
                               # You can add here fields specific to your events.
                               # For example:
                               my_param_old = fields.Char()
                               my_param_new = fields.Char()
                       
                   

2. Create event source

   You have to inherit your model from ``generic.system.event.source.mixin`` to to make it event source, capable to generate events. For example, let's define simple model with one field ``param``, and trigger event any type this field changed.

   python
                   
                       from odoo.addons.generic_mixin import post_write
                       from odoo.addons.generic_system_event import on_event
   
                       class MyEventSource(models.Model):
                            _name = 'my.event.source'
                            _inherit = 'generic.system.event.source.mixin'
   
                            # This is needed to automatically register event source
                            # Other wise, you will need additionally to define
                            # event source in XML.
                            # Automatic event source will be generated with
                            # xmlid: your_module_name.system_event_source__my_event_source
                            _generic_system_event_source__auto_create = True
   
                            # name of data model for events from this event source
                            _generic_system_event_source__event_data_model = 'my.event'
   
                            # Next, we can define some data on this model
                            my_param = fields.Char()
   
                            # This field will be changed automatically by event handler.
                            counter = Integer
   
                            # Let's trigger event
                            @post_write('my_param')
                            def _after_my_param_changed_trigger_event(self, changes):
                                # The line below triggers event
                                self.trigger_event('my-param-changed', {
                                    'my_param_old': changes['my_param'].old_val,
                                    'my_param_new': changes['my_param'].new_val,
                                })
   
                            # Next, we can define event handler:
                            @on_event('my-param-changed')
                            def _on_my_param_changed(self, event):
                                self.counter += 1
                   
               

3. Define event types

   Next, we have to define all event types in the XML.

   xml
                       
                           My Events
                           my-events
                           My Param Changed
                           my-param-changed
                       
                   

4. Define views for events

   Next we have to define views for event data model (that model that is used to store events).

   xml
                       
                           my.event
                           primary
                               false
                               false
                           my.event
                           primary
                       
                   

5. Add stat-button to show events on your view

   If needed, you can add stat-button on your form view of 'my.event.source' to show related events. All you need is to add following xml snippet.

   xml
                   

Note, that method ``action_show_related_system_events`` already implemented in ``generic.system.event.source.mixin``, thus, this xml-snipped is all you need.

Advanced usage

For advanced usage, look for documentation in the code. Basically, this framework, allows you to handle events triggered in context of one model (for example invoices), in context of another related model (for example sale order).

All you need for this, is to specify mapping in XML (see ``generic.system.event.source.handler.map`` model for more info). Also, in this case, you have to apply ``generic.system.event.handler.mixin`` to handler model to allow framework to automatically discover handlers.

Launch your own ITSM system in 60 seconds:

Create your own Bureaucrat ITSM database

Maintainer

This module is maintained by the Center of Research & Development company.

We can provide you further Odoo Support, Odoo implementation, Odoo customization, Odoo 3rd Party development and integration software, consulting services. Our main goal is to provide the best quality product for you.