Work - request relation, m2m implementation

work.py

 #This file is part of Tryton.  The COPYRIGHT file at the top level of
 #this repository contains the full copyright notices and license terms.
 
 from trytond.model import ModelView, ModelSQL, fields
 from trytond.wizard import Wizard
 from datetime import datetime, timedelta
 from collections import deque, defaultdict
 from heapq import heappop, heappush
 
 def intfloor(x):
@@ skipping 43 matching lines @@
     actual_start_date = fields.Function('get_function_fields',
             type='date', string='Actual Start', fnct_inv='set_function_fields')
     actual_finish_date = fields.Function('get_function_fields',
             type='date', string='Actual Finish', fnct_inv='set_function_fields')
     constraint_start_date = fields.Function('get_function_fields',
             type='date', string='Constraint Start', depends=[ 'type'],
             fnct_inv='set_function_fields')
     constraint_finish_date = fields.Function('get_function_fields',
             type='date', string='Constraint Finish', depends=[ 'type'],
             fnct_inv='set_function_fields')
-    requests = fields.Function('get_function_fields', string='Requests',
-            type='one2many', relation='res.request')
+    requests = fields.Function('get_function_fields', type='many2many',
+            string='Requests', fnct_inv='set_function_fields',
+            relation='res.request')
 
     def __init__(self):
         super(Work, self).__init__()
         self._constraints += [
             ('check_recursion', 'recursive_dependency'),
             ]
         self._error_messages.update({
                 'recursive_dependency': 'You can not create recursive '
                         'dependencies!',
                 })
 
     def check_recursion(self,cursor,  user, ids, parent='parent'):
         return super(Work, self).check_recursion(cursor, user, ids,
                 parent='successors')
 
     def get_function_fields(self, cursor, user, ids, names, args, context=None):
         '''
         Function to compute function fields
 
         :param cursor: the database cursor
         :param user: the user id
         :param ids: the ids of the works
         :param names: the list of field name to compute
         :param args: optional argument
         :param context: the context
         :return: a dictionary with all field names as key and
             a dictionary as value with id as key
         '''
+        req_ref_obj = self.pool.get('res.request.reference')
+
         res = {}
 
+        if 'requests' in names:
+            requests = dict((i, []) for i in ids)
 
-        if 'requests' in names:
-            req_ref_obj = self.pool.get('res.request.reference')
-            req_ref_ids = req_ref_obj.search(cursor, user, [
-                    ('reference', 'in', ['project.work,' + str(i) for i in ids]),
-                    ], context=context)
-            req_refs = req_ref_obj.browse(cursor, user, req_ref_ids,
-                    context=context)
-            requests = defaultdict(list)
+            for i in range(0, len(ids), cursor.IN_MAX):
+                sub_ids = ids[i:i + cursor.IN_MAX]
 
-            for req_ref in req_refs:
-                work_id = int(req_ref.reference.split(',')[1])
-                requests[work_id].append(req_ref.request.id)
+                req_ref_ids = req_ref_obj.search(cursor, user, [
+                        ('reference', 'in', [
+                                'project.work,%s' % i for i in sub_ids
+                                ]
+                         ),
+                        ], context=context)
+                req_refs = req_ref_obj.browse(cursor, user, req_ref_ids,
+                        context=context)
+                for req_ref in req_refs:
+                    _, work_id = req_ref.reference.split(',')
+                    requests[int(work_id)].append(req_ref.request.id)
 
             res['requests'] = requests
 
         if 'duration' in names:
             all_ids = self.search(cursor, user, [
                     ('parent', 'child_of', ids),
                     ('active', '=', True)], context=context) + ids
             all_ids = list(set(all_ids))
 
             works = self.browse(cursor, user, all_ids, context=context)
@@ skipping 44 matching lines @@
                     works = self.browse(cursor, user, ids, context=context)
                 for work in works:
                     values[work.id] = work[db_field] \
                         and work[db_field].date() or None
                 res[fun_field] = values
 
         return res
 
     def set_function_fields(self, cursor, user, id, name, value, arg,
             context=None):
+        request_obj = self.pool.get('res.request')
+        req_ref_obj = self.pool.get('res.request.reference')
+
+        if name == 'requests':
+            work = self.browse(cursor, user, id, context=context)
+            currents = dict((req.id, req) for req in work.requests)
+            for v in value:
+                to_unlink = []
+                to_link = []
+                operator = v[0]
+
+                ids = len(v) > 1 and v[1] or []
+                if operator == 'set':
+                    to_link.extend((i for i in ids if i not in currents))
+                    to_unlink.extend((i for i in currents if i not in ids))
+                elif operator == 'add':
+                    to_link.extend((i for i in ids if i not in currents))
+                elif operator == 'unlink':
+                    to_unlink.extend((i for i in ids if i in currents))
+                elif operator == 'unlink_all':
+                    to_unlink.extend(currents)
+                elif operator == 'delete':
+                    request_obj.delete(cursor, user, to_delete, context=context)
+                else:
+                    raise Exception('Operation not supported')
+
+                req_ref_ids = []
+                for i in to_unlink:
+                    request = currents[i]
+                    for ref in request.references:
+                        if int(ref.reference.split(',')[1]) == id:
+                            req_ref_ids.append(ref.id)
+                req_ref_obj.delete(cursor, user, req_ref_ids,
+                        context=context)
+
+                for i in to_link:
+                    req_ref_obj.create(cursor, user, {
+                            'request': i,
+                            'reference': 'project.work,%s' % id,
+                            }, context=context)
+            return
 
         fun_fields = ('actual_start_date', 'actual_finish_date',
                       'constraint_start_date', 'constraint_finish_date')
         db_fields = ('actual_start_time', 'actual_finish_time',
                      'constraint_start_time', 'constraint_finish_time')
         for fun_field, db_field in zip(fun_fields, db_fields):
             if fun_field == name:
                 self.write(cursor, user, id, {db_field: value}, context=context)
                 break
 
@@ skipping 504 matching lines @@
                 },
             },
         }
 
     def _leveling(self, cursor, user, data, context=None):
         work_obj = self.pool.get('project.work')
         work_obj.create_leveling(cursor, user, data['id'], context=context)
         return {}
 
 Leveling()