Create alternate route for users that cannot force assign.

shipment.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.
 "Shipment"
 from trytond.model import ModelWorkflow, ModelView, ModelSQL, fields
 from trytond.modules.company import CompanyReport
 from trytond.wizard import Wizard
 from trytond.backend import TableHandler
+from trytond.pyson import Eval, Not, Equal, If, Or, And, Bool, In
 
 STATES = {
     'readonly': "state in ('cancel', 'done')",
 }
 
 
 class ShipmentIn(ModelWorkflow, ModelSQL, ModelView):
     "Supplier Shipment"
     _name = 'stock.shipment.in'
     _description = __doc__
     _rec_name = 'code'
 
     effective_date = fields.Date('Effective Date', readonly=True)
-    planned_date = fields.Date(
-        'Planned Date', states={'readonly': "state != 'draft'",})
-    reference = fields.Char(
-        "Reference", size=None, select=1,
-        states={'readonly': "state != 'draft'",})
+    planned_date = fields.Date('Planned Date', states={
+            'readonly': Not(Equal(Eval('state'), 'draft')),
+            })
+    reference = fields.Char("Reference", size=None, select=1,
+            states={
+                'readonly': Not(Equal(Eval('state'), 'draft')),
+            })
     supplier = fields.Many2One('party.party', 'Supplier',
             states={
-                'readonly': "(state != 'draft' or bool(incoming_moves)) " \
-                        "and bool(supplier)",
+                'readonly': And(Or(Not(Equal(Eval('state'), 'draft')),
+                    Bool(Eval('incoming_moves'))), Bool(Eval('supplier'))),
             }, on_change=['supplier'], required=True)
     contact_address = fields.Many2One('party.address', 'Contact Address',
             states={
-                'readonly': "state != 'draft'",
-            }, domain=["('party', '=', supplier)"])
+                'readonly': Not(Equal(Eval('state'), 'draft')),
+            }, domain=[('party', '=', Eval('supplier'))])
     warehouse = fields.Many2One('stock.location', "Warehouse",
             required=True, domain=[('type', '=', 'warehouse')],
             states={
-                'readonly': "state in ('cancel', 'done') or " \
-                        "bool(incoming_moves)",
+                'readonly': Or(In(Eval('state'), ['cancel', 'done']),
+                    Bool(Eval('incoming_moves'))),
             })
     incoming_moves = fields.Function('get_incoming_moves', type='one2many',
             relation='stock.move', string='Incoming Moves',
-            fnct_inv='set_incoming_moves', add_remove="[" \
-                "('shipment_in', '=', False),"\
-                "('from_location.type', '=', 'supplier'),"\
-                "('state', '=', 'draft'),"\
-                "('to_location_warehouse', '=', warehouse),"\
-            "]",
-            states={
-                'readonly': "state in ('received', 'done', 'cancel') "\
-                    "or not bool(warehouse)",
-            }, context="{'warehouse': warehouse, 'type': 'incoming'," \
-                    "'supplier': supplier}")
+            fnct_inv='set_incoming_moves', add_remove=[
+                ('shipment_in', '=', False),
+                ('from_location.type', '=', 'supplier'),
+                ('state', '=', 'draft'),
+                ('to_location_warehouse', '=', Eval('warehouse')),
+            ],
+            states={
+                'readonly': Or(In(Eval('state'),
+                    ['received', 'done', 'cancel']),
+                    Not(Bool(Eval('warehouse')))),
+            }, context={
+                'warehouse': Eval('warehouse'),
+                'type': 'incoming',
+                'supplier': Eval('supplier'),
+            })
     inventory_moves = fields.Function('get_inventory_moves', type='one2many',
             relation='stock.move', string='Inventory Moves',
             fnct_inv='set_inventory_moves',
             states={
-                'readonly': "state in ('draft', 'done', 'cancel')",
-            }, context="{'warehouse': warehouse, 'type': 'inventory_in'}")
+                'readonly': In(Eval('state'), ['draft', 'done', 'cancel']),
+            }, context={
+                'warehouse': Eval('warehouse'),
+                'type': 'inventory_in',
+            })
     moves = fields.One2Many('stock.move', 'shipment_in', 'Moves',
             readonly=True)
     code = fields.Char("Code", size=None, select=1, readonly=True)
     state = fields.Selection([
         ('draft', 'Draft'),
         ('done', 'Done'),
         ('cancel', 'Canceled'),
         ('received', 'Received'),
         ], 'State', readonly=True)
 
@@ skipping 93 matching lines @@
                             shipment.warehouse.input_location.id:
                         self.raise_user_error(cursor,
                                 'incoming_move_input_dest', context=context)
             elif act[0] == 'write':
                 if 'to_location' in act[2]:
                     if act[2]['to_location'] != \
                             shipment.warehouse.input_location.id:
                         self.raise_user_error(cursor,
                                 'incoming_move_input_dest', context=context)
             elif act[0] == 'add':
-                move_ids.append(act[1])
+                if isinstance(act[1], (int, long)):
+                    move_ids.append(act[1])
+                else:
+                    move_ids.extend(act[1])
             elif act[0] == 'set':
                 move_ids.extend(act[1])
 
         moves = move_obj.browse(cursor, user, move_ids, context=context)
         for move in moves:
             if move.to_location.id != \
                     shipment.warehouse.input_location.id:
                 self.raise_user_error(cursor,
                         'incoming_move_input_dest', context=context)
 
@@ skipping 26 matching lines @@
                             shipment.warehouse.input_location.id:
                         self.raise_user_error(cursor,
                                 'inventory_move_input_source', context=context)
             elif act[0] == 'write':
                 if 'from_location' in act[2]:
                     if act[2]['from_location'] != \
                             shipment.warehouse.input_location.id:
                         self.raise_user_error(cursor,
                                 'inventory_move_input_source', context=context)
             elif act[0] == 'add':
-                move_ids.append(act[1])
+                if isinstance(act[1], (int, long)):
+                    move_ids.append(act[1])
+                else:
+                    move_ids.extend(act[1])
             elif act[0] == 'set':
                 move_ids.extend(act[1])
 
         moves = move_obj.browse(cursor, user, move_ids, context=context)
         for move in moves:
             if move.from_location.id != \
                     shipment.warehouse.input_location.id:
                 self.raise_user_error(cursor,
                         'inventory_move_input_source', context=context)
 
@@ skipping 104 matching lines @@
 ShipmentIn()
 
 
 class ShipmentInReturn(ModelWorkflow, ModelSQL, ModelView):
     "Supplier Return Shipment"
     _name = 'stock.shipment.in.return'
     _description = __doc__
     _rec_name = 'code'
 
     effective_date =fields.Date('Effective Date', readonly=True)
-    planned_date = fields.Date(
-        'Planned Date', states={'readonly': "state != 'draft'",})
+    planned_date = fields.Date('Planned Date',
+            states={
+                'readonly': Not(Equal(Eval('state'), 'draft')),
+            })
     code = fields.Char("Code", size=None, select=1, readonly=True)
-    reference = fields.Char(
-        "Reference", size=None, select=1,
-        states={'readonly': "state != 'draft'",})
-    from_location = fields.Many2One(
-        'stock.location', "From Location", required=True,
-        states={ 'readonly': "state != 'draft' or bool(moves)", },
-        domain=[('type', '=', 'storage')])
+    reference = fields.Char("Reference", size=None, select=1,
+            states={
+                'readonly': Not(Equal(Eval('state'), 'draft')),
+            })
+    from_location = fields.Many2One('stock.location', "From Location",
+            required=True, states={
+                'readonly': Or(Not(Equal(Eval('state'), 'draft')),
+                    Bool(Eval('moves'))),
+            }, domain=[('type', '=', 'storage')])
     to_location = fields.Many2One('stock.location', "To Location",
             required=True, states={
-                'readonly': "state != 'draft' or bool(moves)",
+                'readonly': Or(Not(Equal(Eval('state'), 'draft')),
+                    Bool(Eval('moves'))),
             }, domain=[('type', '=', 'supplier')])
-    moves = fields.One2Many(
-        'stock.move', 'shipment_in_return', 'Moves',
-        states={'readonly': "state != 'draft' or "\
-                    "not(bool(from_location) and bool (to_location))"},
-        context="{'from_location': from_location,"
-                "'to_location': to_location,"
-                "'planned_date': planned_date}",
-        )
+    moves = fields.One2Many('stock.move', 'shipment_in_return', 'Moves',
+        states={
+            'readonly': And(Or(Not(Equal(Eval('state'), 'draft')),
+                Not(Bool(Eval('from_location')))),
+                Bool(Eval('to_location'))),
+        },
+        context={
+            'from_location': Eval('from_location'),
+            'to_location': Eval('to_location'),
+            'planned_date': Eval('planned_date'),
+        })
     state = fields.Selection([
         ('draft', 'Draft'),
         ('cancel', 'Canceled'),
         ('assigned', 'Assigned'),
         ('waiting', 'Waiting'),
         ('done', 'Done'),
         ], 'State', readonly=True)
 
     def default_state(self, cursor, user, context=None):
         return 'draft'
@@ skipping 141 matching lines @@
 
 class ShipmentOut(ModelWorkflow, ModelSQL, ModelView):
     "Customer Shipment"
     _name = 'stock.shipment.out'
     _description = __doc__
     _rec_name = 'code'
 
     effective_date = fields.Date('Effective Date', readonly=True)
     planned_date = fields.Date('Planned Date',
             states={
-                'readonly': "state != 'draft'",
+                'readonly': Not(Equal(Eval('state'), 'draft')),
             })
     customer = fields.Many2One('party.party', 'Customer', required=True,
             states={
-                'readonly': "state != 'draft' or bool(outgoing_moves)",
+                'readonly': Or(Not(Equal(Eval('state'), 'draft')),
+                    Bool(Eval('outgoing_moves'))),
             }, on_change=['customer'])
     delivery_address = fields.Many2One('party.address',
             'Delivery Address', required=True,
             states={
-                'readonly': "state != 'draft'",
-            }, domain=["('party', '=', customer)"])
+                'readonly': Not(Equal(Eval('state'), 'draft')),
+            }, domain=[('party', '=', Eval('customer'))])
     reference = fields.Char("Reference", size=None, select=1,
             states={
-                'readonly': "state != 'draft'",
+                'readonly': Not(Equal(Eval('state'), 'draft')),
             })
     warehouse = fields.Many2One('stock.location', "Warehouse", required=True,
             states={
-                'readonly': "state != 'draft' or bool(outgoing_moves)",
+                'readonly': Or(Not(Equal(Eval('state'), 'draft')),
+                    Bool(Eval('outgoing_moves'))),
             }, domain=[('type', '=', 'warehouse')])
     outgoing_moves = fields.Function('get_outgoing_moves', type='one2many',
             relation='stock.move', string='Outgoing Moves',
             fnct_inv='set_outgoing_moves',
             states={
-                'readonly':"state != 'draft' or not bool(warehouse)",
-            }, context="{'warehouse': warehouse, 'type': 'outgoing'," \
-                    "'customer': customer}")
+                'readonly': Or(Not(Equal(Eval('state'), 'draft')),
+                    Not(Bool(Eval('warehouse')))),
+            }, context={
+                'warehouse': Eval('warehouse'),
+                'type': 'outgoing',
+                'customer': Eval('customer'),
+            })
     inventory_moves = fields.Function('get_inventory_moves', type='one2many',
             relation='stock.move', string='Inventory Moves',
             fnct_inv='set_inventory_moves',
             states={
-                'readonly':"state in ('draft', 'packed', 'done')",
-            }, context="{'warehouse': warehouse, 'type': 'inventory_out',}")
+                'readonly': In(Eval('state'), ['draft', 'packed', 'done']),
+            }, context={
+                'warehouse': Eval('warehouse'),
+                'type': 'inventory_out',
+            })
     moves = fields.One2Many('stock.move', 'shipment_out', 'Moves',
             readonly=True)
     code = fields.Char("Code", size=None, select=1, readonly=True)
     state = fields.Selection([
         ('draft', 'Draft'),
         ('done', 'Done'),
         ('cancel', 'Canceled'),
         ('assigned', 'Assigned'),
         ('packed', 'Packed'),
         ('waiting', 'Waiting'),
@@ skipping 81 matching lines @@
                             shipment.warehouse.output_location.id:
                         self.raise_user_error(cursor,
                                 'outgoing_move_output_source', context=context)
             elif act[0] == 'write':
                 if 'from_location' in act[2]:
                     if act[2]['from_location'] != \
                             shipment.warehouse.output_location.id:
                         self.raise_user_error(cursor,
                                 'outgoing_move_output_source', context=context)
             elif act[0] == 'add':
-                move_ids.append(act[1])
+                if isinstance(act[1], (int, long)):
+                    move_ids.append(act[1])
+                else:
+                    move_ids.extend(act[1])
             elif act[0] == 'set':
                 move_ids.extend(act[1])
 
         moves = move_obj.browse(cursor, user, move_ids, context=context)
         for move in moves:
             if move.from_location.id != \
                     shipment.warehouse.output_location.id:
                 self.raise_user_error(cursor,
                         'outgoing_move_output_source', context=context)
         self.write(cursor, user, shipment_id, {
@@ skipping 26 matching lines @@
                             shipment.warehouse.output_location.id:
                         self.raise_user_error(cursor,
                                 'inventory_move_output_dest', context=context)
             elif act[0] == 'write':
                 if 'to_location' in act[2]:
                     if act[2]['to_location'] != \
                             shipment.warehouse.output_location.id:
                         self.raise_user_error(cursor,
                                 'inventory_move_output_dest', context=context)
             elif act[0] == 'add':
-                move_ids.append(act[1])
+                if isinstance(act[1], (int, long)):
+                    move_ids.append(act[1])
+                else:
+                    move_ids.extend(act[1])
             elif act[0] == 'set':
                 move_ids.extend(act[1])
 
         moves = move_obj.browse(cursor, user, move_ids, context=context)
         for move in moves:
             if move.to_location.id != \
                     shipment.warehouse.output_location.id:
                 self.raise_user_error(cursor,
                         'inventory_move_output_dest', context=context)
         self.write(cursor, user, shipment_id, {
@@ skipping 213 matching lines @@
 
 class ShipmentOutReturn(ModelWorkflow, ModelSQL, ModelView):
     "Customer Return Shipment"
     _name = 'stock.shipment.out.return'
     _description = __doc__
     _rec_name = 'code'
 
     effective_date = fields.Date('Effective Date', readonly=True)
     planned_date = fields.Date('Planned Date',
             states={
-                'readonly': "state != 'draft'",
+                'readonly': Not(Equal(Eval('state'), 'draft')),
             })
     customer = fields.Many2One('party.party', 'Customer', required=True,
             states={
-                'readonly': "state != 'draft' or bool(incoming_moves)",
+                'readonly': Or(Not(Equal(Eval('state'), 'draft')),
+                    Bool(Eval('incoming_moves'))),
             }, on_change=['customer'])
     delivery_address = fields.Many2One('party.address',
             'Delivery Address', required=True,
             states={
-                'readonly': "state != 'draft'",
-            }, domain=["('party', '=', customer)"])
+                'readonly': Not(Equal(Eval('state'), 'draft')),
+            }, domain=[('party', '=', Eval('customer'))])
     reference = fields.Char("Reference", size=None, select=1,
             states={
-                'readonly': "state != 'draft'",
+                'readonly': Not(Equal(Eval('state'), 'draft')),
             })
     warehouse = fields.Many2One('stock.location', "Warehouse", required=True,
             states={
-                'readonly': "state != 'draft' or bool(incoming_moves)",
+                'readonly': Or(Not(Equal(Eval('state'), 'draft')),
+                    Bool(Eval('incoming_moves'))),
             }, domain=[('type', '=', 'warehouse')])
     incoming_moves = fields.Function('get_incoming_moves', type='one2many',
             relation='stock.move', string='Incoming Moves',
             fnct_inv='set_incoming_moves',
             states={
-                'readonly':"state != 'draft'",
-            }, context="{'warehouse': warehouse, 'type': 'incoming'," \
-                    "'customer': customer}")
+                'readonly': Not(Equal(Eval('state'), 'draft')),
+            }, context={
+                'warehouse': Eval('warehouse'),
+                'type': 'incoming',
+                'customer': Eval('customer'),
+            })
     inventory_moves = fields.Function('get_inventory_moves', type='one2many',
             relation='stock.move', string='Inventory Moves',
             fnct_inv='set_inventory_moves',
             states={
-                'readonly':"state in ('draft', 'cancel', 'done')",
-            }, context="{'warehouse': warehouse, 'type': 'inventory_out',}")
+                'readonly': In(Eval('state'), ['draft', 'cancel', 'done']),
+            }, context={
+                'warehouse': Eval('warehouse'),
+                'type': 'inventory_out',
+            })
     moves = fields.One2Many('stock.move', 'shipment_out_return', 'Moves',
             readonly=True)
     code = fields.Char("Code", size=None, select=1, readonly=True)
     state = fields.Selection([
         ('draft', 'Draft'),
         ('done', 'Done'),
         ('cancel', 'Canceled'),
         ('received', 'Received'),
         ], 'State', readonly=True)
 
@@ skipping 83 matching lines @@
                             shipment.warehouse.input_location.id:
                         self.raise_user_error(cursor,
                                 'incoming_move_input_dest', context=context)
             elif act[0] == 'write':
                 if 'to_location' in act[2]:
                     if act[2]['to_location'] != \
                             shipment.warehouse.input_location.id:
                         self.raise_user_error(cursor,
                                 'incoming_move_input_dest', context=context)
             elif act[0] == 'add':
-                move_ids.append(act[1])
+                if isinstance(act[1], (int, long)):
+                    move_ids.append(act[1])
+                else:
+                    move_ids.extend(act[1])
             elif act[0] == 'set':
                 move_ids.extend(act[1])
 
         moves = move_obj.browse(cursor, user, move_ids, context=context)
         for move in moves:
             if move.to_location.id != \
                     shipment.warehouse.input_location.id:
                 self.raise_user_error(cursor,
                         'incoming_move_input_dest', context=context)
         self.write(cursor, user, shipment_id, {
@@ skipping 26 matching lines @@
                             shipment.warehouse.input_location.id:
                         self.raise_user_error(cursor,
                                 'inventory_move_input_source', context=context)
             elif act[0] == 'write':
                 if 'from_location' in act[2]:
                     if act[2]['from_location'] != \
                             shipment.warehouse.input_location.id:
                         self.raise_user_error(cursor,
                                 'inventory_move_input_source', context=context)
             elif act[0] == 'add':
-                move_ids.append(act[1])
+                if isinstance(act[1], (int, long)):
+                    move_ids.append(act[1])
+                else:
+                    move_ids.extend(act[1])
             elif act[0] == 'set':
                 move_ids.extend(act[1])
 
         moves = move_obj.browse(cursor, user, move_ids, context=context)
         for move in moves:
             if move.from_location.id != \
                     shipment.warehouse.input_location.id:
                 self.raise_user_error(cursor,
                         'inventory_move_input_source', context=context)
         self.write(cursor, user, shipment_id, {
@@ skipping 94 matching lines @@
             vals = self._get_inventory_moves(cursor, user, incoming_move,
                     context=context)
             if vals:
                 self.write(cursor, user, shipment.id, {
                     'inventory_moves': [('create', vals)]
                     }, context=context)
 
 ShipmentOutReturn()
 
 
-class AssignShipmentOutAskForce(ModelView):
-    'Assign Shipment Out Ask Force'
-    _name = 'stock.shipment.out.assign.ask_force'
+class AssignShipmentOutAssignFailed(ModelView):
+    'Assign Shipment Out Assign Failed'
+    _name = 'stock.shipment.out.assign.assign_failed'
     _description = __doc__
 
     inventory_moves = fields.Many2Many('stock.move', None, None,
             'Inventory Moves', readonly=True)
 
-AssignShipmentOutAskForce()
+AssignShipmentOutAssignFailed()
 
 
 class AssignShipmentOut(Wizard):
     'Assign Shipment Out'
     _name = 'stock.shipment.out.assign'
     states = {
         'init': {
             'result': {
                 'type': 'choice',
                 'next_state': '_choice',
             },
         },
-        'notify': {

[ced, 2010/01/15 23:23:25]

I think it should be named, assign_failed

+        'assign_failed': {
             'actions': ['_moves'],
             'result': {
                 'type': 'form',
-                'object': 'stock.shipment.out.assign.ask_force',

[ced, 2010/01/15 23:23:25]

You must use an other object

+                'object': 'stock.shipment.out.assign.assign_failed',
                 'state': [
                     ('end', 'Ok', 'tryton-ok', True),
                 ],
             },
         },

[Ian Wilson, 2010/01/15 19:27:33]

There seemed no way to just hide the button in a dialog so I created an
alternate path to notify users without the ability to force assign that
assigning failed.

[udono, 2010/01/15 20:08:06]

I think its the right way you go.

         'ask_force': {
             'actions': ['_moves'],
             'result': {
                 'type': 'form',
-                'object': 'stock.shipment.out.assign.ask_force',
+                'object': 'stock.shipment.out.assign.assign_failed',
                 'state': [
                     ('force', 'Force Assign', 'tryton-go-next'),
                     ('end', 'Ok', 'tryton-ok', True),
                 ],
             },
         },
         'force': {
             'result': {
                 'type': 'action',
                 'action': '_force',
                 'state': 'end',
             },
         },
     }
 
     def _choice(self, cursor, user, data, context=None):
         shipment_out_obj = self.pool.get('stock.shipment.out')
-        user_obj = self.pool.get('res.user')
+        user_group_obj = self.pool.get('res.user-res.group')
+        model_data_obj = self.pool.get('ir.model.data')
+        transition_obj = self.pool.get('workflow.transition')
 
         shipment_out_obj.workflow_trigger_validate(cursor, user, data['id'],
                 'assign', context=context)
         shipment = shipment_out_obj.browse(cursor, user, data['id'],
                 context=context)
         if not [x.id for x in shipment.inventory_moves if x.state == 'draft']:
             return 'end'
         else:
-            users = user_obj.browse(cursor, user, [user], context=context)

[ced, 2010/01/15 23:23:25]

It will be better to search on group with users = user and id = group id.

-            if users:
-                for group in users[0].groups:
-                    if group.name == 'Stock Force Assignment':

[Ian Wilson, 2010/01/15 19:27:33]

Is there a better way to check if a user belongs to a group specified in
XML(stock.xml) ?

[udono, 2010/01/15 20:08:06]

I don't know a better way.

[ced, 2010/01/15 23:23:25]

You must use ir.model.data to get the id.
But I think it will be best to read the group id from the workflow.transition.

[Ian Wilson, 2010/01/16 02:39:39]

I think I understand all the comments except for this one.  What do you mean by
"read the group id from the workflow.transition"?  From
shipmentinternal_trans_waiting_assigned_force ?

[ced, 2010/01/16 09:12:33]

Yes but don't forget that there is also a wizard stock.shipment.internal.assign

-                        return 'ask_force'
-            return 'notify'
+            trans_id = model_data_obj.get_id(cursor, user, 'stock',
+                    'shipmentout_trans_waiting_assigned_force', context=context)
+            trans = transition_obj.read(cursor, user, trans_id, context=context)
+            user_in_group = user_group_obj.search(cursor, user, [
+                    ('uid', '=', user),
+                    ('gid', '=', trans['group']),
+                    ], limit=1, context=context)
+            if user_in_group:
+                return 'ask_force'
+            return 'assign_failed'
 
     def _moves(self, cursor, user, data, context=None):
         shipment_out_obj = self.pool.get('stock.shipment.out')
         shipment = shipment_out_obj.browse(cursor, user, data['id'],
                 context=context)
         return {'inventory_moves': [x.id for x in shipment.inventory_moves
             if x.state == 'draft']}
 
     def _force(self, cursor, user, data, context=None):
         shipment_out_obj = self.pool.get('stock.shipment.out')
 
         shipment_out_obj.workflow_trigger_validate(cursor, user, data['id'],
                 'force_assign', context=context)
         return {}
 
 AssignShipmentOut()
 
 
 class ShipmentInternal(ModelWorkflow, ModelSQL, ModelView):
     "Internal Shipment"
     _name = 'stock.shipment.internal'
     _description = __doc__
     _rec_name = 'code'
 
     effective_date =fields.Date('Effective Date', readonly=True)
-    planned_date = fields.Date(
-        'Planned Date', states={'readonly': "state != 'draft'",})
+    planned_date = fields.Date('Planned Date',
+            states={
+                'readonly': Not(Equal(Eval('state'), 'draft')),
+            })
     code = fields.Char("Code", size=None, select=1, readonly=True)
-    reference = fields.Char(
-        "Reference", size=None, select=1,
-        states={'readonly': "state != 'draft'",})
-    from_location = fields.Many2One(
-        'stock.location', "From Location", required=True,
-        states={ 'readonly': "state != 'draft' or bool(moves)", },
-        domain=["('type', 'not in', " \
-                    "('supplier', 'customer', 'warehouse', 'view'))"])
+    reference = fields.Char("Reference", size=None, select=1,
+            states={
+                'readonly': Not(Equal(Eval('state'), 'draft')),
+            })
+    from_location = fields.Many2One('stock.location', "From Location",
+            required=True, states={
+                'readonly': Or(Not(Equal(Eval('state'), 'draft')),
+                    Bool(Eval('moves'))),
+            },
+            domain=[
+                ('type', 'not in',
+                    ['supplier', 'customer', 'warehouse', 'view']),
+            ])
     to_location = fields.Many2One('stock.location', "To Location",
             required=True, states={
-                'readonly': "state != 'draft' or bool(moves)",
-            }, domain=["('type', 'not in', " \
-                    "('supplier', 'customer', 'warehouse', 'view'))"])
-    moves = fields.One2Many(
-        'stock.move', 'shipment_internal', 'Moves',
-        states={'readonly': "state != 'draft' or "\
-                    "not(bool(from_location) and bool (to_location))"},
-        context="{'from_location': from_location,"
-                "'to_location': to_location,"
-                "'planned_date': planned_date}",
-        )
+                'readonly': Or(Not(Equal(Eval('state'), 'draft')),
+                    Bool(Eval('moves'))),
+            }, domain=[
+                ('type', 'not in',
+                    ['supplier', 'customer', 'warehouse', 'view']),
+            ])
+    moves = fields.One2Many('stock.move', 'shipment_internal', 'Moves',
+        states={
+            'readonly': And(Or(Not(Equal(Eval('state'), 'draft')),
+                Not(Bool(Eval('from_location')))),
+                Bool(Eval('to_location'))),
+        },
+        context={
+            'from_location': Eval('from_location'),
+            'to_location': Eval('to_location'),
+            'planned_date': Eval('planned_date'),
+        })
     state = fields.Selection([
         ('draft', 'Draft'),
         ('cancel', 'Canceled'),
         ('assigned', 'Assigned'),
         ('waiting', 'Waiting'),
         ('done', 'Done'),
         ], 'State', readonly=True)
 
     def init(self, cursor, module_name):
         # Migration from 1.2: packing renamed into shipment
@@ skipping 104 matching lines @@
 ShipmentInternal()
 
 
 class Address(ModelSQL, ModelView):
     _name = 'party.address'
     delivery = fields.Boolean('Delivery')
 
 Address()
 
 
-class AssignShipmentInternalAskForce(ModelView):
-    'Assign Shipment Internal Ask Force'
-    _name = 'stock.shipment.internal.assign.ask_force'
+class AssignShipmentInternalAssignFailed(ModelView):
+    'Assign Shipment Internal Assign Failed'
+    _name = 'stock.shipment.internal.assign.assign_failed'
     _description = __doc__
 
     moves = fields.Many2Many('stock.move', None, None, 'Moves',
             readonly=True)
 
-AssignShipmentInternalAskForce()
+AssignShipmentInternalAssignFailed()
 
 
 class AssignShipmentInternal(Wizard):
     'Assign Shipment Internal'
     _name = 'stock.shipment.internal.assign'
     states = {
         'init': {
             'result': {
                 'type': 'choice',
                 'next_state': '_choice',
             },
         },
+        'assign_failed': {
+            'actions': ['_moves'],
+            'result': {
+                'type': 'form',
+                'object': 'stock.shipment.internal.assign.assign_failed',
+                'state': [
+                    ('end', 'Ok', 'tryton-ok', True),
+                ],
+            },
+        },
         'ask_force': {
             'actions': ['_moves'],
             'result': {
                 'type': 'form',
-                'object': 'stock.shipment.internal.assign.ask_force',
+                'object': 'stock.shipment.internal.assign.assign_failed',
                 'state': [
                     ('force', 'Force Assign', 'tryton-go-next'),
                     ('end', 'Ok', 'tryton-ok', True),
                 ],
             },
         },
         'force': {
             'result': {
                 'type': 'action',
                 'action': '_force',
                 'state': 'end',
             },
         },
     }
 
     def _choice(self, cursor, user, data, context=None):
         shipment_internal_obj = self.pool.get('stock.shipment.internal')
+        user_group_obj = self.pool.get('res.user-res.group')
+        model_data_obj = self.pool.get('ir.model.data')
+        transition_obj = self.pool.get('workflow.transition')
 
         shipment_internal_obj.workflow_trigger_validate(cursor, user,
                 data['id'], 'assign', context=context)
         shipment = shipment_internal_obj.browse(cursor, user, data['id'],
                 context=context)
         if not [x.id for x in shipment.moves if x.state == 'draft']:
             return 'end'
         else:
-            return 'ask_force'
+            trans_id = model_data_obj.get_id(cursor, user, 'stock',
+                    'shipmentinternal_trans_waiting_assigned_force',
+                    context=context)
+            trans = transition_obj.read(cursor, user, trans_id,
+                    context=context)
+            user_in_group = user_group_obj.search(cursor, user, [
+                    ('uid', '=', user),
+                    ('gid', '=', trans['group']),
+                    ], limit=1, context=context)
+            if user_in_group:
+                return 'ask_force'
+            return 'assign_failed'
 
     def _moves(self, cursor, user, data, context=None):
         shipment_internal_obj = self.pool.get('stock.shipment.internal')
         shipment = shipment_internal_obj.browse(cursor, user, data['id'],
                 context=context)
         return {'moves': [x.id for x in shipment.moves if x.state == 'draft']}
 
     def _force(self, cursor, user, data, context=None):
         shipment_internal_obj = self.pool.get('stock.shipment.internal')
 
         shipment_internal_obj.workflow_trigger_validate(cursor, user,
                 data['id'], 'force_assign', context=context)
         return {}
 
 AssignShipmentInternal()
 
 
-class AssignShipmentInReturnAskForce(ModelView):
-    'Assign Supplier Return Shipment Ask Force'
-    _name = 'stock.shipment.in.return.assign.ask_force'
+class AssignShipmentInReturnAssignFailed(ModelView):
+    'Assign Supplier Return Shipment Assign Failed'
+    _name = 'stock.shipment.in.return.assign.assign_failed'
     _description = __doc__
 
     moves = fields.Many2Many('stock.move', None, None, 'Moves',
             readonly=True)
 
-AssignShipmentInReturnAskForce()
+AssignShipmentInReturnAssignFailed()
 
 
 class AssignShipmentInReturn(Wizard):
     'Assign Supplier Return Shipment'
     _name = 'stock.shipment.in.return.assign'
     states = {
         'init': {
             'result': {
                 'type': 'choice',
                 'next_state': '_choice',
             },
         },
+        'assign_failed': {
+            'actions': ['_moves'],
+            'result': {
+                'type': 'form',
+                'object': 'stock.shipment.in.return.assign.assign_failed',
+                'state': [
+                    ('end', 'Ok', 'tryton-ok', True),
+                ],
+            },
+        },
         'ask_force': {
             'actions': ['_moves'],
             'result': {
                 'type': 'form',
-                'object': 'stock.shipment.in.return.assign.ask_force',
+                'object': 'stock.shipment.in.return.assign.assign_failed',
                 'state': [
                     ('force', 'Force Assign', 'tryton-go-next'),
                     ('end', 'Ok', 'tryton-ok', True),
                 ],
             },
         },
         'force': {
             'result': {
                 'type': 'action',
                 'action': '_force',
                 'state': 'end',
             },
         },
     }
 
     def _choice(self, cursor, user, data, context=None):
         shipment_internal_obj = self.pool.get('stock.shipment.in.return')
+        user_group_obj = self.pool.get('res.user-res.group')
+        model_data_obj = self.pool.get('ir.model.data')
+        transition_obj = self.pool.get('workflow.transition')
 
         shipment_internal_obj.workflow_trigger_validate(cursor, user,
                 data['id'], 'assign', context=context)
         shipment = shipment_internal_obj.browse(cursor, user, data['id'],
                 context=context)
         if not [x.id for x in shipment.moves if x.state == 'draft']:
             return 'end'
         else:
-            return 'ask_force'
+            trans_id = model_data_obj.get_id(cursor, user, 'stock',
+                    'shipment_in_return_trans_waiting_assigned_force',
+                    context=context)
+            trans = transition_obj.read(cursor, user, trans_id, context=context)
+            user_in_group = user_group_obj.search(cursor, user, [
+                    ('uid', '=', user),
+                    ('gid', '=', trans['group']),
+                    ], limit=1, context=context)
+            if user_in_group:
+                return 'ask_force'
+            return 'assign_failed'
 
     def _moves(self, cursor, user, data, context=None):
         shipment_internal_obj = self.pool.get('stock.shipment.in.return')
         shipment = shipment_internal_obj.browse(cursor, user, data['id'],
                 context=context)
         return {'moves': [x.id for x in shipment.moves if x.state == 'draft']}
 
     def _force(self, cursor, user, data, context=None):
         shipment_internal_obj = self.pool.get('stock.shipment.in.return')
 
@@ skipping 56 matching lines @@
                 shipment_out_return_obj.create(
                     cursor, user,
                     {'customer': shipment_out.customer.id,
                      'delivery_address': shipment_out.delivery_address.id,
                      'warehouse': shipment_out.warehouse.id,
                      'incoming_moves': incoming_moves,
                      },
                     context=context)
                 )
 
-        model_data_ids = model_data_obj.search(cursor, user, [
-            ('fs_id', '=', 'act_shipment_out_return_form'),
-            ('module', '=', 'stock'),
-            ('inherit', '=', False),
-            ], limit=1, context=context)
-        model_data = model_data_obj.browse(cursor, user, model_data_ids[0],
-                context=context)
-        res = act_window_obj.read(cursor, user, model_data.db_id, context=context)
+        act_window_id = model_data_obj.get_id(cursor, user, 'stock',
+                'act_shipment_out_return_form', context=context)
+        res = act_window_obj.read(cursor, user, act_window_id, context=context)
         res['res_id'] = shipment_out_return_ids
         if len(shipment_out_return_ids) == 1:
             res['views'].reverse()
 
         return res
 
 CreateShipmentOutReturn()
 
 
 class DeliveryNote(CompanyReport):
@@ skipping 210 matching lines @@
                 'to_location_ids' : to_location_ids}
 
 
     def get_compare_key(self, move, compare_context):
         from_location_ids = compare_context['from_location_ids']
         to_location_ids = compare_context['to_location_ids']
         return [from_location_ids.index(move.from_location.id),
                 to_location_ids.index(move.to_location.id)]
 
 InteralShipmentReport()