flask_tryton: Add support for 5.2 series

flask_tryton.py

 # This file is part of flask_tryton.  The COPYRIGHT file at the top level of
 # this repository contains the full copyright notices and license terms.
 
 from functools import wraps
 
 from flask import request, current_app
 from werkzeug.routing import BaseConverter
 from werkzeug.exceptions import BadRequest
 
 try:
@@ skipping 75 matching lines @@
         def instanciate(value):
             if isinstance(value, _BaseProxy):
                 return value()
             return value
 
         def decorator(func):
             @wraps(func)
             def wrapper(*args, **kwargs):
                 tryton = current_app.extensions['Tryton']
                 database = current_app.config['TRYTON_DATABASE']
-                if trytond_version >= (5, 1):
-                    with Transaction().start(database, 0) as transaction:
-                        Cache.sync(transaction)

[ced, 2019/07/18 08:03:11]

It is not needed the Cache is sync by the Transaction.start.

-                elif trytond_version >= (3, 3):
+                if (5, 1) > trytond_version >= (3, 3):
                     with Transaction().start(database, 0):
                         Cache.clean(database)
-                else:
+                elif trytond_version < (3, 3):
                     Cache.clean(database)
 
                 if user is None:
                     transaction_user = get_value(
                         int(current_app.config['TRYTON_USER']))
                 else:
                     transaction_user = get_value(user)
 
                 if readonly is None:
                     is_readonly = get_value(tryton._readonly)
@@ skipping 31 matching lines @@
                             raise
                         except Exception, e:
                             if hasattr(transaction, 'cursor'):
                                 transaction.cursor.rollback()
                             if isinstance(e, (
                                         UserError,
                                         UserWarning,
                                         ConcurrencyException)):
                                 raise BadRequest(e.message)
                             raise
-                        if trytond_version >= (5, 1):
-                            Cache.rollback(transaction)

[ced, 2019/07/18 08:03:11]

We should not rollback the cache on succeed.
Indeed now the cache is fully managed by the Transaction.

-                        elif trytond_version >= (3, 3):
+                        if (5, 1) > trytond_version >= (3, 3):
                             Cache.resets(database)
+                    if hasattr(transaction, 'tasks'):
+                        from trytond.worker import run_task
+                        while transaction.tasks:
+                            task_id = transaction.tasks.pop()
+                            run_task(tryton.pool, task_id)
                     if trytond_version < (3, 3):
                         Cache.resets(database)
                     return result
             return wrapper
         return decorator
 
+
 tryton_transaction = Tryton.transaction
 
 
 class _BaseProxy(object):
     pass
 
 
 class _RecordsProxy(_BaseProxy):
     def __init__(self, model, ids):
         self.model = model
@@ skipping 44 matching lines @@
 
     def __init__(self, map, model):
         super(RecordsConverter, self).__init__(map)
         self.model = model
 
     def to_python(self, value):
         return _RecordsProxy(self.model, map(int, value.split(',')))
 
     def to_url(self, value):
         return ','.join(map(int, value))