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 44 matching lines @@
             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', type='many2many',
             string='Requests', fnct_inv='set_function_fields',

[ced, 2009/07/03 17:21:43]

I think it is better to use a widget one2many in views.

             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!',
@@ skipping 15 matching lines @@
         :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)
-            req_ref_ids = req_ref_obj.search(cursor, user, [
-                    ('reference', 'in', ['project.work,%s' % i for i in ids]),

[ced, 2009/07/03 17:21:43]

You should create a loop with cursor.IN_MAX for long ids list

-                    ], 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)
+
+            for i in range(0, len(ids), cursor.IN_MAX):
+                sub_ids = ids[i:i + cursor.IN_MAX]
+
+                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 53 matching lines @@
             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 = []
-                to_delete = []
                 operator = v[0]
+
                 ids = len(v) > 1 and v[1] or []
                 if operator == 'set':

[ced, 2009/07/03 17:21:43]

I think it should be better to have the same behavior then the many2many.py. So
call the method directly instead of creating list.

[bch, 2009/07/06 08:50:42]

On 2009/07/03 17:21:43, ced wrote:
> I think it should be better to have the same behavior then the many2many.py.
So
> call the method directly instead of creating list.

Why? here it's the same behavior (one write/delete per item in value) except
when there is several ids in the second member of the item, in this case instead
of calling the same action one by one, the action is called on the list.

[ced, 2009/07/06 09:02:11]

Exactly, we must have the same behavior.

                     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':
-                    to_delete.extend((i for i in ids if i in currents))
+                    request_obj.delete(cursor, user, to_delete, context=context)
                 else:
                     raise Exception('Operation not supported')
 
-                if to_delete:
-                    request_obj.delete(cursor, user, to_delete, context=context)
-
-                if to_unlink:
-                    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)
+                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 412 matching lines @@
                 to_update.add(work.parent.id)
                 to_update.update(c.id for c in work.parent.children \
                                      if c.id not in ids)
         res = super(Work, self).delete(cursor, user, ids, context=context)
 
         for work_id in to_update:
             self.reset_leveling(cursor, user, work_id, context=context)
             self.compute_dates(cursor, user, work_id, context=context)
 
         return res
 Work()

[ced, 2009/07/03 17:21:43]

Remove the space in an other commit.

 
 
+
 class PredecessorSuccessor(ModelSQL):
     'Predecessor - Successor'
     _name = 'project.predecessor_successor'
     _description = __doc__
 
     predecessor = fields.Many2One('project.work', 'Predecessor',
             ondelete='CASCADE', required=True, select=1)
     successor = fields.Many2One('project.work', 'Successor',
             ondelete='CASCADE', required=True, select=1)
 
@@ skipping 68 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()