← Back to branch summary

~unifield-team/unifield-wm/us-671-homere

« back to all changes in this revision

Viewing changes to procurement_auto/procurement.py

  • Committer: chloups208
  • Date: 2012-11-21 11:15:15 UTC
  • mto: This revision was merged to the branch mainline in revision 1340.
  • Revision ID: chloups208@chloups208-laptop-20121121111515-myqv282h6xmgh053
utp-171 modification of fields po, po line, product, so, so line

Show diffs side-by-side

added added

removed removed

Lines of Context:
procurement_auto/procurement.py
28
28
    _name = 'stock.warehouse.automatic.supply'
29
29
    _description = 'Automatic Supply'
30
30
    _order = 'name, id'
31
 
 
 
31
    
32
32
    def _get_next_date_from_frequence(self, cr, uid, ids, name, args, context=None):
33
33
        '''
34
34
        Returns the next date of the frequency
35
35
        '''
36
36
        res = {}
37
 
 
 
37
        
38
38
        for proc in self.browse(cr, uid, ids):
39
39
            if proc.frequence_id and proc.frequence_id.next_date:
40
40
                res[proc.id] = proc.frequence_id.next_date
41
41
            else:
42
42
                res[proc.id] = False
43
 
 
 
43
                
44
44
        return res
45
 
 
 
45
    
46
46
    def _get_frequence_change(self, cr, uid, ids, context=None):
47
47
        '''
48
48
        Returns Auto. Sup. ids when frequence change
51
51
        for frequence in self.pool.get('stock.frequence').browse(cr, uid, ids, context=context):
52
52
            for sup_id in frequence.auto_sup_ids:
53
53
                result[sup_id.id] = True
54
 
 
 
54
                
55
55
        return result.keys()
56
 
 
 
56
    
57
57
    def _get_frequence_name(self, cr, uid, ids, field_name, arg, context=None):
58
58
        '''
59
59
        Returns the name_get value of the frequence
61
61
        res = {}
62
62
        for proc in self.browse(cr, uid, ids):
63
63
            if proc.frequence_id:
64
 
                res[proc.id] = self.pool.get('stock.frequence').name_get(cr, uid, [proc.frequence_id.id], context=context)[0][1]
65
 
 
 
64
                res[proc.id] = self.pool.get('stock.frequence').name_get(cr, uid, [proc.frequence_id.id])[0][1]
 
65
            
66
66
        return res
67
 
 
 
67
    
68
68
    def _get_product_ids(self, cr, uid, ids, field_name, arg, context=None):
69
69
        '''
70
70
        Returns a list of products for the rule
71
71
        '''
72
72
        res = {}
73
 
 
 
73
        
74
74
        for rule in self.browse(cr, uid, ids, context=context):
75
75
            res[rule.id] = []
76
76
            for line in rule.line_ids:
77
77
                res[rule.id].append(line.product_id.id)
78
 
 
 
78
        
79
79
        return res
80
 
 
 
80
    
81
81
    def _src_product_ids(self, cr, uid, obj, name, args, context=None):
82
82
        if not context:
83
83
            context = {}
84
 
 
 
84
            
85
85
        res = []
86
 
 
 
86
            
87
87
        for arg in args:
88
88
            if arg[0] == 'product_ids':
89
89
                rule_ids = []
92
92
                    if l.supply_id.id not in rule_ids:
93
93
                        rule_ids.append(l.supply_id.id)
94
94
                res.append(('id', 'in', rule_ids))
95
 
 
 
95
                
96
96
        return res
97
 
 
 
97
    
98
98
    _columns = {
99
99
        'sequence': fields.integer(string='Order', required=False, help='A higher order value means a low priority'),
100
100
        'name': fields.char(size=64, string='Reference', required=True),
121
121
                                            'stock.frequence': (_get_frequence_change, None, 20)}),
122
122
        'product_ids': fields.function(_get_product_ids, fnct_search=_src_product_ids, 
123
123
                                    type='many2many', relation='product.product', method=True, string='Products'),
124
 
        'sublist_id': fields.many2one('product.list', string='List/Sublist', ondelete='set null'),
125
 
        'nomen_manda_0': fields.many2one('product.nomenclature', 'Main Type', ondelete='set null'),
126
 
        'nomen_manda_1': fields.many2one('product.nomenclature', 'Group', ondelete='set null'),
127
 
        'nomen_manda_2': fields.many2one('product.nomenclature', 'Family', ondelete='set null'),
128
 
        'nomen_manda_3': fields.many2one('product.nomenclature', 'Root', ondelete='set null'),
 
124
        'sublist_id': fields.many2one('product.list', string='List/Sublist'),
 
125
        'nomen_manda_0': fields.many2one('product.nomenclature', 'Main Type'),
 
126
        'nomen_manda_1': fields.many2one('product.nomenclature', 'Group'),
 
127
        'nomen_manda_2': fields.many2one('product.nomenclature', 'Family'),
 
128
        'nomen_manda_3': fields.many2one('product.nomenclature', 'Root'),
129
129
    }
130
 
 
 
130
    
131
131
    _defaults = {
132
132
        'active': lambda *a: 1,
133
133
        'name': lambda x,y,z,c: x.pool.get('ir.sequence').get(y,z,'stock.automatic.supply') or '',
134
134
    }
135
 
 
 
135
    
136
136
    def default_get(self, cr, uid, fields, context=None):
137
137
        '''
138
138
        Get the default values for the replenishment rule
139
139
        '''
140
140
        res = super(stock_warehouse_automatic_supply, self).default_get(cr, uid, fields, context=context)
141
 
 
 
141
        
142
142
        company_id = res.get('company_id')
143
143
        warehouse_id = res.get('warehouse_id')
144
 
 
 
144
        
145
145
        if not 'company_id' in res:
146
146
            company_id = self.pool.get('res.company')._company_default_get(cr, uid, 'stock.warehouse.automatic.supply', context=context)
147
147
            res.update({'company_id': company_id})
148
 
 
 
148
        
149
149
        if not 'warehouse_id' in res:
150
150
            warehouse_id = self.pool.get('stock.warehouse').search(cr, uid, [('company_id', '=', company_id)], context=context)[0]
151
151
            res.update({'warehouse_id': warehouse_id})
152
 
 
 
152
            
153
153
        if not 'location_id' in res:
154
154
            location_id = self.pool.get('stock.warehouse').browse(cr, uid, warehouse_id, context=context).lot_stock_id.id
155
155
            res.update({'location_id': location_id})
156
 
 
 
156
        
157
157
        return res
158
 
 
 
158
    
159
159
    def choose_change_frequence(self, cr, uid, ids, context=None):
160
160
        '''
161
161
        Open a wizard to define a frequency for the automatic supply
165
165
            ids = [ids]
166
166
        if context is None:
167
167
            context = {}
168
 
 
 
168
            
169
169
        frequence_id = False
170
170
        res_id = False
171
171
        res_ok = False
172
 
 
 
172
            
173
173
        for proc in self.browse(cr, uid, ids):
174
174
            res_id = proc.id
175
175
            if proc.frequence_id and proc.frequence_id.id:
186
186
                frequence_id = self.pool.get('stock.frequence').create(cr, uid, frequence_data, context=context)
187
187
                self.write(cr, uid, proc.id, {'frequence_id': frequence_id}, context=context)
188
188
                res_ok = True
189
 
 
 
189
            
190
190
        context.update({'active_id': res_id, 
191
191
                        'active_model': 'stock.warehouse.automatic.supply',
192
192
                        'res_ok': res_ok})
193
 
 
 
193
            
194
194
        return {'type': 'ir.actions.act_window',
195
195
                'target': 'new',
196
196
                'res_model': 'stock.frequence',
198
198
                'view_model': 'form',
199
199
                'context': context,
200
200
                'res_id': frequence_id}
201
 
 
 
201
    
202
202
    def onchange_warehouse_id(self, cr, uid, ids, warehouse_id, context=None):
203
203
        """ Finds location id for changed warehouse.
204
204
        @param warehouse_id: Changed id of warehouse.
209
209
            v = {'location_id': w.lot_stock_id.id}
210
210
            return {'value': v}
211
211
        return {}
212
 
 
 
212
    
213
213
    def onchange_product_id(self, cr, uid, ids, product_id, context=None):
214
214
        """ Finds uom for changed product.
215
215
        @param product_id: Changed id of product.
220
220
            v = {'product_uom_id': w.uom_id.id}
221
221
            return {'value': v}
222
222
        return {}
223
 
 
 
223
   
224
224
    def unlink(self, cr, uid, ids, context):
225
225
        '''
226
226
        When delete an automatic supply rule, also remove the frequency
249
249
            'procurement_id': False,
250
250
        })
251
251
        return super(stock_warehouse_automatic_supply, self).copy(cr, uid, id, default, context=context)
252
 
 
 
252
 
253
253
    def _check_frequency(self, cr, uid, ids, context=None):
254
254
        if not context:
255
255
            context = {}
323
323
 
324
324
            for product in self.pool.get('product.product').browse(cr, uid, product_ids, context=context):
325
325
                # Check if the product is not already on the report
326
 
                if product.type not in ('consu', 'service', 'service_recep') and product.id not in products:
 
326
                if product.id not in products:
327
327
                    self.pool.get('stock.warehouse.automatic.supply.line').create(cr, uid, {'product_id': product.id,
328
328
                                                                                            'product_uom_id': product.uom_id.id,
329
329
                                                                                            'product_qty': 1.00,
345
345
    _name = 'stock.warehouse.automatic.supply.line'
346
346
    _description = 'Automatic Supply Line'
347
347
    _rec_name = 'product_id'
348
 
 
 
348
    
349
349
    _columns = {
350
350
        'product_id': fields.many2one('product.product', string='Product', required=True),
351
351
        'product_uom_id': fields.many2one('product.uom', string='Product UoM', required=True),
352
352
        'product_qty': fields.float(digit=(16,2), string='Quantity to order', required=True),
353
353
        'supply_id': fields.many2one('stock.warehouse.automatic.supply', string='Supply', ondelete='cascade', required=True)
354
354
    }
355
 
 
 
355
    
356
356
    _defaults = {
357
357
        'product_qty': lambda *a: 1.00,
358
358
    }
359
 
 
360
 
    def _check_product_qty(self, cr, uid, ids, context=None):
361
 
        '''
362
 
        Check if the quantity is larger than 0.00
363
 
        '''
364
 
        context = context is None and {} or context
365
 
 
366
 
        if isinstance(ids, (int, long)):
367
 
            ids = [ids]
368
 
 
369
 
        if not context.get('noraise'):
370
 
            for line in self.read(cr, uid, ids, ['product_qty'], context=context):
371
 
                if line['product_qty'] <= 0.00:
372
 
                    raise osv.except_osv(_('Error'), _('Lines must have a quantity larger than 0.00'))
373
 
                    return False
374
 
 
375
 
        return True
376
 
 
377
 
    def create(self, cr, uid, vals, context=None):
378
 
        res = super(stock_warehouse_automatic_supply_line, self).create(cr, uid, vals, context=context)
379
 
        self._check_product_qty(cr, uid, res, context=context)
380
 
        return res
381
 
 
382
 
    def write(self, cr, uid, ids, vals, context=None):
383
 
        res = super(stock_warehouse_automatic_supply_line, self).write(cr, uid, ids, vals, context=context)
384
 
        self._check_product_qty(cr, uid, ids, context=context)
385
 
        return res
386
 
 
 
359
    
 
360
    _sql_constraints = [
 
361
        ('product_qty_check', 'CHECK( product_qty > 0 )', 'Product Qty must be greater than zero.'),
 
362
    ]
 
363
    
387
364
    def _check_uniqueness(self, cr, uid, ids, context=None):
388
365
        '''
389
366
        Check if the product is not already in the current rule
394
371
                                          ('supply_id', '=', line.supply_id.id)], context=context)
395
372
            if lines:
396
373
                return False
397
 
 
 
374
            
398
375
        return True
399
 
 
 
376
    
400
377
    _constraints = [
401
378
        (_check_uniqueness, 'You cannot have two times the same product on the same automatic supply rule', ['product_id'])
402
379
    ]
403
 
 
404
 
    def onchange_product_id(self, cr, uid, ids, product_id, uom_id, product_qty, context=None):
 
380
    
 
381
    def onchange_product_id(self, cr, uid, ids, product_id, context=None):
405
382
        """ Finds UoM for changed product.
406
383
        @param product_id: Changed id of product.
407
384
        @return: Dictionary of values.
408
385
        """
409
 
        res = {}
410
 
 
411
386
        if product_id:
412
387
            prod = self.pool.get('product.product').browse(cr, uid, product_id, context=context)
413
388
            v = {'product_uom_id': prod.uom_id.id}
414
 
            res.update({'value': v})
415
 
 
416
 
        if product_qty:
417
 
            uom_id = res.get('value', {}).get('product_uom_id', uom_id)
418
 
            res = self.pool.get('product.uom')._change_round_up_qty(cr, uid, uom_id, product_qty, 'product_qty', result=res)
419
 
 
420
 
        return res
421
 
 
422
 
    def onchange_uom_qty(self, cr, uid, ids, uom_id, product_qty, context=None):
423
 
        '''
424
 
        Check the round of qty according to UoM
425
 
        '''
426
 
        res = {}
427
 
 
428
 
        if product_qty:
429
 
            res = self.pool.get('product.uom')._change_round_up_qty(cr, uid, uom_id, product_qty, 'product_qty', result=res)
430
 
 
431
 
        return res
432
 
 
 
389
            return {'value': v}
 
390
        return {}
 
391
    
433
392
stock_warehouse_automatic_supply_line()
434
393
 
435
394
class stock_frequence(osv.osv):
436
395
    _name = 'stock.frequence'
437
396
    _inherit = 'stock.frequence'
438
 
 
 
397
    
439
398
    _columns = {
440
399
        'auto_sup_ids': fields.one2many('stock.warehouse.automatic.supply', 'frequence_id', string='Auto. Sup.'),
441
400
    }
442
 
 
 
401
    
443
402
    def choose_frequency(self, cr, uid, ids, context=None):
444
403
        '''
445
404
        Adds the support of automatic supply on choose frequency method
448
407
            ids = [ids]
449
408
        if context is None:
450
409
            context = {}
451
 
 
 
410
            
452
411
        if not context.get('res_ok', False) and 'active_id' in context and 'active_model' in context and \
453
412
            context.get('active_model') == 'stock.warehouse.automatic.supply':
454
413
            self.pool.get('stock.warehouse.automatic.supply').write(cr, uid, [context.get('active_id')], {'frequence_id': ids[0]})
455
 
 
 
414
            
456
415
        return super(stock_frequence, self).choose_frequency(cr, uid, ids, context=context)
457
 
 
 
416
    
458
417
    def copy(self, cr, uid, id, default=None, context=None):
459
418
        if not default:
460
419
            default = {}