← Back to branch summary

~unifield-team/unifield-wm/us-826

« back to all changes in this revision

Viewing changes to msf_supply_doc_import/purchase_order.py

  • Committer: duy.vo at msf
  • Date: 2012-09-18 21:05:00 UTC
  • mfrom: (1175 unifield-wm)
  • mto: This revision was merged to the branch mainline in revision 1188.
  • Revision ID: duy.vo@geneva.msf.org-20120918210500-qw8i815ns8xtk3bv
UF-1055: Merged with trunk 1175

Show diffs side-by-side

added added

removed removed

Lines of Context:
msf_supply_doc_import/purchase_order.py
19
19
#
20
20
##############################################################################
21
21
 
22
 
from datetime import datetime
23
 
 
24
22
from osv import osv
25
23
from osv import fields
26
24
import logging
29
27
from tools.translate import _
30
28
import base64
31
29
from spreadsheet_xml.spreadsheet_xml import SpreadsheetXML
 
30
from check_line import *
 
31
from msf_supply_doc_import import MAX_LINES_NB
 
32
 
32
33
 
33
34
class purchase_order(osv.osv):
34
35
    _inherit = 'purchase.order'
40
41
        if hasattr(super(purchase_order, self), 'init'):
41
42
            super(purchase_order, self).init(cr)
42
43
 
43
 
        mod_obj = self.pool.get('ir.module.module')
44
44
        logging.getLogger('init').info('HOOK: module product: loading product_data.xml')
45
45
        pathname = path.join('product', 'product_data.xml')
46
46
        file = tools.file_open(pathname)
47
47
        tools.convert_xml_import(cr, 'product', file, {}, mode='init', noupdate=False)
48
48
 
49
 
    _columns = {
50
 
        'file_to_import': fields.binary(string='File to import', 
51
 
                                        help='You can use the template of the export for the format that you need to use'),
52
 
    }
53
 
 
54
49
    def hook_rfq_sent_check_lines(self, cr, uid, ids, context=None):
55
50
        '''
56
51
        Please copy this to your module's method also.
58
53
        - check lines after import
59
54
        '''
60
55
        res = super(purchase_order, self).hook_rfq_sent_check_lines(cr, uid, ids, context)
61
 
        
62
56
        if self.check_lines_to_fix(cr, uid, ids, context):
63
57
            res = False
64
58
        return res
78
72
        return res
79
73
 
80
74
    _columns = {
81
 
        'file_to_import': fields.binary(string='File to import', filters='*.xml', help='You can use the template of the export for the format that you need to use'),
82
 
        'import_error_ok':fields.function(_get_import_error,  method=True, type="boolean", string="Error in Import", store=True),
 
75
        'file_to_import': fields.binary(string='File to import', filters='*.xml',
 
76
                                        help="""* You can use the template of the export for the format that you need to use.
 
77
                                                * The file should be in XML Spreadsheet 2003 format.
 
78
                                                * You can import up to %s lines each time,
 
79
                                                else you have to split the lines in several files and import each one by one.
 
80
                                                """ % MAX_LINES_NB),
 
81
        'import_error_ok': fields.function(_get_import_error, method=True, type="boolean", string="Error in Import", store=True),
83
82
    }
84
83
 
85
84
    def button_remove_lines(self, cr, uid, ids, context=None):
103
102
        '''
104
103
        Import lines from file
105
104
        '''
106
 
        if not context:
 
105
        if context is None:
107
106
            context = {}
 
107
        if isinstance(ids, (int, long)):
 
108
            ids = [ids]
108
109
 
109
110
        product_obj = self.pool.get('product.product')
110
111
        uom_obj = self.pool.get('product.uom')
111
112
        obj_data = self.pool.get('ir.model.data')
112
113
        currency_obj = self.pool.get('res.currency')
113
 
 
 
114
        purchase_obj = self.pool.get('purchase.order')
 
115
        purchase_line_obj = self.pool.get('purchase.order.line')
 
116
        view_id = obj_data.get_object_reference(cr, uid, 'purchase', 'purchase_order_form')[1]
114
117
        vals = {}
115
118
        vals['order_line'] = []
116
 
        msg_to_return = _("All lines successfully imported")
117
119
 
118
120
        obj = self.browse(cr, uid, ids, context=context)[0]
119
121
        if not obj.file_to_import:
120
122
            raise osv.except_osv(_('Error'), _('Nothing to import.'))
121
123
 
122
124
        fileobj = SpreadsheetXML(xmlstring=base64.decodestring(obj.file_to_import))
123
 
        
 
125
        # check that the max number of lines is not excedeed
 
126
        if check_nb_of_lines(fileobj=fileobj):
 
127
            raise osv.except_osv(_('Warning !'), _("""You can\'t have more than %s lines in your file.""") % MAX_LINES_NB)
124
128
        # iterator on rows
125
 
        reader = fileobj.getRows()
126
 
        
 
129
        rows = fileobj.getRows()
127
130
        # ignore the first row
128
 
        reader.next()
129
 
        line_num = 1
130
 
        for row in reader:
 
131
        rows.next()
 
132
        line_num = 0
 
133
        to_write = {}
 
134
        for row in rows:
 
135
            browse_purchase = purchase_obj.browse(cr, uid, ids, context=context)[0]
131
136
            # default values
132
 
            error_list = []
133
 
            to_correct_ok = False
134
 
            comment = False
135
 
            date_planned = obj.delivery_requested_date
136
 
            functional_currency_id = False
137
 
            price_unit = 1.0
138
 
            product_qty = 1.0
139
 
            nomen_manda_0 =  obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd0')[1]
140
 
            nomen_manda_1 =  obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd1')[1]
141
 
            nomen_manda_2 =  obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd2')[1]
142
 
            nomen_manda_3 =  obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd3')[1]
143
 
            
144
 
            line_num += 1
145
 
            row_len = len(row)
146
 
            if row_len != 8:
147
 
                raise osv.except_osv(_('Error'), _("""You should have exactly 8 columns in this order:
148
 
Product Code*, Product Description*, Quantity*, Product UoM*, Unit Price*, Delivery Requested Date*, Currency*, Comment"""))
149
 
            
150
 
            product_code = row.cells[0].data
151
 
            if not product_code :
152
 
                default_code = False
153
 
                to_correct_ok = True
154
 
                error_list.append('No Product Code.')
155
 
                comment = 'Product Code to be defined'
156
 
            else:
157
 
                try:
158
 
                    product_code = product_code.strip()
159
 
                    code_ids = product_obj.search(cr, uid, [('default_code', '=', product_code)])
160
 
                    if not code_ids:
161
 
                        default_code = False
162
 
                        to_correct_ok = True
163
 
                        comment = 'Code: %s'%product_code
164
 
                    else:
165
 
                        default_code = code_ids[0]
166
 
                except Exception:
167
 
                     error_list.append('The Product Code has to be a string.')
168
 
                     comment = 'Product Code to be defined'
169
 
                     default_code = False
170
 
                     to_correct_ok = True
171
 
            
172
 
            p_id = row.cells[1].data
173
 
            if not p_id:
174
 
                product_id = False
175
 
                to_correct_ok = True
176
 
                error_list.append('No Product Description')
177
 
                comment = 'Product Description to be defined'
178
 
            else:
179
 
                try:
180
 
                    p_name = p_id.strip()
181
 
                    p_ids = product_obj.search(cr, uid, [('name', '=', p_name)])
182
 
                    if not p_ids:
183
 
                        product_id = False
184
 
                        to_correct_ok = True
185
 
                        comment = 'Description: %s' %p_name
186
 
                        error_list.append('The Product was not found in the list of the products.')
187
 
                    else:
188
 
                        product_id = p_ids[0]
189
 
                        nomen_manda_0 = product_obj.browse(cr, uid, [product_id], context=context)[0].nomen_manda_0
190
 
                        nomen_manda_1 = product_obj.browse(cr, uid, [product_id], context=context)[0].nomen_manda_1
191
 
                        nomen_manda_2 = product_obj.browse(cr, uid, [product_id], context=context)[0].nomen_manda_2
192
 
                        nomen_manda_3 = product_obj.browse(cr, uid, [product_id], context=context)[0].nomen_manda_3
193
 
                except Exception:
194
 
                     error_list.append('The Product Description has to be a string.')
195
 
                     comment = 'Product Description to be defined'
196
 
                     product_id = False
197
 
                     to_correct_ok = True
198
 
                
199
 
            if not row.cells[2].data :
200
 
                product_qty = 1.0
201
 
                to_correct_ok = True
202
 
                error_list.append('The Product Quantity was not set, we set it to 1 by default.')
203
 
            else:
204
 
                if row.cells[4].type in ['int', 'float']:
205
 
                    product_qty = row.cells[2].data
206
 
                else:
207
 
                     error_list.append('The Product Quantity was not a number, we set it to 1 by default.')
208
 
                     to_correct_ok = True
209
 
                     product_qty = 1.0
210
 
            
211
 
            p_uom = row.cells[3].data
212
 
            if not p_uom:
213
 
                uom_id = obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import','uom_tbd')[1]
214
 
                to_correct_ok = True
215
 
                error_list.append('No product UoM was defined.')
216
 
            else:
217
 
                try:
218
 
                    uom_name = p_uom.strip()
219
 
                    uom_ids = uom_obj.search(cr, uid, [('name', '=', uom_name)], context=context)
220
 
                    if not uom_ids:
221
 
                        uom_id = obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import','uom_tbd')[1]
222
 
                        to_correct_ok = True
223
 
                        error_list.append('The UOM was not found.')
224
 
                    else:
225
 
                        uom_id = uom_ids[0]
226
 
                except Exception:
227
 
                     error_list.append('The UOM name has to be a string.')
228
 
                     uom_id = obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import','uom_tbd')[1]
229
 
                     to_correct_ok = True
230
 
                
231
 
            price_unit = row.cells[4].data
232
 
            if not price_unit:
233
 
                to_correct_ok = True
234
 
                error_list.append('The Price Unit was not set, we set it to 1 by default.')
235
 
                price_unit = 1.0
236
 
            else:
237
 
                if row.cells[4].type in ['int', 'float']:
238
 
                    price_unit = row.cells[4].data
239
 
                else:
240
 
                     error_list.append('The Price Unit was not a number, we set it to 1 by default.')
241
 
                     to_correct_ok = True
242
 
                     price_unit = 1.0
243
 
            
244
 
            if row.cells[5].data:
245
 
                if row.cells[5].type == 'datetime':
246
 
                    date_planned = row.cells[5].data
247
 
                else:
248
 
                    error_list.append('The date format was not good so we took the date from the parent.')
249
 
                    to_correct_ok = True
250
 
            else:
251
 
                error_list.append('The date was not specified or so we took the one from the parent.')
252
 
                to_correct_ok = True
253
 
            
254
 
            curr = row.cells[6].data
255
 
            if not curr:
256
 
                to_correct_ok = True
257
 
                error_list.append('No currency was defined.')
258
 
            else:
259
 
                try:
260
 
                    curr_name = curr.strip()
261
 
                    currency_ids = currency_obj.search(cr, uid, [('name', '=', curr_name)])
262
 
                    if currency_ids:
263
 
                        functional_currency_id = curr
264
 
                    else:
265
 
                        error_list.append('The currency was not found or the format of the currency was not good.')
266
 
                except Exception:
267
 
                    error_list.append('The Currency name should be a string.')
268
 
                    to_correct_ok = True
269
 
                
270
 
            proc_type = 'make_to_stock'
271
 
            for product in product_obj.read(cr, uid, ids, ['type'], context=context):
272
 
                if product['type'] == 'service_recep':
273
 
                    proc_type = 'make_to_order'
274
 
 
275
137
            to_write = {
276
 
                'to_correct_ok': to_correct_ok, # the lines with to_correct_ok=True will be red
277
 
                'comment': comment,
278
 
                'nomen_manda_0': nomen_manda_0,
279
 
                'nomen_manda_1': nomen_manda_1,
280
 
                'nomen_manda_2': nomen_manda_2,
281
 
                'nomen_manda_3': nomen_manda_3,
 
138
                'error_list': [],
 
139
                'warning_list': [],
 
140
                'to_correct_ok': False,
 
141
                'show_msg_ok': False,
 
142
                'comment': '',
 
143
                'date_planned': obj.delivery_requested_date,
 
144
                'functional_currency_id': browse_purchase.pricelist_id.currency_id.id,
 
145
                'price_unit': 1,  # as the price unit cannot be null, it will be computed in the method "compute_price_unit" after.
 
146
                'product_qty': 1,
 
147
                'nomen_manda_0':  obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd0')[1],
 
148
                'nomen_manda_1':  obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd1')[1],
 
149
                'nomen_manda_2':  obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd2')[1],
 
150
                'nomen_manda_3':  obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd3')[1],
 
151
                'proc_type': 'make_to_order',
 
152
                'default_code': False,
282
153
                'confirmed_delivery_date': False,
283
 
                'order_id': obj.id,
284
 
                'default_code':  default_code,
285
 
                'product_id': product_id,
286
 
                'product_uom': uom_id,
287
 
                'product_qty': product_qty,
288
 
                'price_unit': price_unit,
289
 
                'date_planned': date_planned,
290
 
                'functional_currency_id': functional_currency_id,
291
 
                'type': proc_type,
292
 
                'text_error': '\n'.join(error_list), 
293
154
            }
294
 
            
295
 
            vals['order_line'].append((0, 0, to_write))
296
 
            
 
155
 
 
156
            line_num += 1
 
157
            col_count = len(row)
 
158
            if col_count != 8:
 
159
                raise osv.except_osv(_('Warning !'), _("""You should have exactly 8 columns in this order:
 
160
Product Code*, Product Description*, Quantity*, Product UoM*, Unit Price*, Delivery Requested Date*, Currency*, Comment. """))
 
161
            try:
 
162
                if not check_empty_line(row=row, col_count=col_count):
 
163
                    continue
 
164
 
 
165
                # Cell 0: Product Code
 
166
                p_value = {}
 
167
                p_value = product_value(cr, uid, obj_data=obj_data, product_obj=product_obj, row=row, to_write=to_write, context=context)
 
168
                to_write.update({'default_code': p_value['default_code'], 'product_id': p_value['default_code'],
 
169
                                 'comment': p_value['comment'], 'error_list': p_value['error_list'], 'type': p_value['proc_type']})
 
170
 
 
171
                # Cell 2: Quantity
 
172
                qty_value = {}
 
173
                qty_value = quantity_value(product_obj=product_obj, row=row, to_write=to_write, context=context)
 
174
                to_write.update({'product_qty': qty_value['product_qty'], 'error_list': qty_value['error_list'],
 
175
                                 'warning_list': qty_value['warning_list']})
 
176
 
 
177
                # Cell 3: UOM
 
178
                uom_value = {}
 
179
                uom_value = compute_uom_value(cr, uid, obj_data=obj_data, uom_obj=uom_obj, row=row, to_write=to_write, context=context)
 
180
                to_write.update({'product_uom': uom_value['uom_id'], 'error_list': uom_value['error_list']})
 
181
 
 
182
                # Cell 4: Price
 
183
                price_value = {}
 
184
                price_value = compute_price_value(row=row, to_write=to_write, price='Cost Price', context=context)
 
185
                to_write.update({'price_unit': price_value['price_unit'], 'error_list': price_value['error_list'],
 
186
                                 'warning_list': price_value['warning_list']})
 
187
 
 
188
                # Cell 5: Delivery Request Date
 
189
                date_value = {}
 
190
                date_value = compute_date_value(row=row, to_write=to_write, context=context)
 
191
                to_write.update({'date_planned': date_value['date_planned'], 'error_list': date_value['error_list']})
 
192
 
 
193
                # Cell 6: Currency
 
194
                curr_value = {}
 
195
                curr_value = compute_currency_value(cr, uid, cell=6, browse_purchase=browse_purchase,
 
196
                                                    currency_obj=currency_obj, row=row, to_write=to_write, context=context)
 
197
                to_write.update({'functional_currency_id': curr_value['functional_currency_id'], 'warning_list': curr_value['warning_list']})
 
198
 
 
199
                # Cell 7: Comment
 
200
                c_value = {}
 
201
                c_value = comment_value(row=row, cell=7, to_write=to_write, context=context)
 
202
                to_write.update({'comment': c_value['comment'], 'warning_list': c_value['warning_list']})
 
203
                to_write.update({
 
204
                    'to_correct_ok': [True for x in to_write['error_list']],  # the lines with to_correct_ok=True will be red
 
205
                    'show_msg_ok': [True for x in to_write['warning_list']],  # the lines with show_msg_ok=True won't change color, it is just info
 
206
                    'order_id': obj.id,
 
207
                    'text_error': '\n'.join(to_write['error_list'] + to_write['warning_list']),
 
208
                })
 
209
                # we check consistency on the model of on_change functions to call for updating values
 
210
                purchase_line_obj.check_line_consistency(cr, uid, ids, to_write=to_write, context=context)
 
211
 
 
212
                vals['order_line'].append((0, 0, to_write))
 
213
 
 
214
            except IndexError:
 
215
                print "The line num %s in the Excel file got element outside the defined 8 columns" % line_num
 
216
 
297
217
        # write order line on PO
 
218
        context['import_in_progress'] = True
298
219
        self.write(cr, uid, ids, vals, context=context)
299
 
        
300
 
        view_id = obj_data.get_object_reference(cr, uid, 'purchase','purchase_order_form')[1]
301
 
        
302
 
        for line in obj.order_line:
303
 
            if line.to_correct_ok:
304
 
                msg_to_return = _("The import of lines had errors, please correct the red lines below")
305
 
        
306
 
        return self.log(cr, uid, obj.id, msg_to_return, context={'view_id': view_id,})
307
 
        
 
220
        msg_to_return = get_log_message(to_write=to_write, obj=obj)
 
221
        if msg_to_return:
 
222
            self.log(cr, uid, obj.id, _(msg_to_return), context={'view_id': view_id})
 
223
        return True
 
224
 
308
225
    def check_lines_to_fix(self, cr, uid, ids, context=None):
309
226
        """
310
227
        Check both the lines that need to be corrected and also that the supplier or the address is not 'To be defined'
314
231
        message = ''
315
232
        plural= ''
316
233
        obj_data = self.pool.get('ir.model.data')
317
 
            
318
234
        for var in self.browse(cr, uid, ids, context=context):
319
235
            # we check the supplier and the address
320
236
            if var.partner_id.id == obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import','supplier_tbd')[1] \
331
247
                        if len(message.split(',')) > 1:
332
248
                            plural = 's'
333
249
        if message:
334
 
            raise osv.except_osv(_('Warning !'), _('You need to correct the following line%s : %s')% (plural, message))
 
250
            raise osv.except_osv(_('Warning !'), _('You need to correct the following line%s: %s') % (plural, message))
335
251
        return True
336
 
        
 
252
 
337
253
purchase_order()
338
254
 
 
255
 
339
256
class purchase_order_line(osv.osv):
340
257
    '''
341
258
    override of purchase_order_line class
344
261
    _description = 'Purchase Order Line'
345
262
    _columns = {
346
263
        'to_correct_ok': fields.boolean('To correct'),
 
264
        'show_msg_ok': fields.boolean('Info on importation of lines'),
347
265
        'text_error': fields.text('Errors when trying to import file'),
348
266
    }
349
267
 
 
268
    def check_line_consistency(self, cr, uid, ids, *args, **kwargs):
 
269
        """
 
270
        After having taken the value in the to_write variable we are going to check them.
 
271
        This function routes the value to check in dedicated methods (one for checking UoM, an other for Price Unit...).
 
272
        """
 
273
        context = kwargs['context']
 
274
        if context is None:
 
275
            context = {}
 
276
        if isinstance(ids, (int, long)):
 
277
            ids = [ids]
 
278
        obj_data = self.pool.get('ir.model.data')
 
279
        to_write = kwargs['to_write']
 
280
        order_id = to_write['order_id']
 
281
        text_error = to_write['text_error']
 
282
        po_obj = self.pool.get('purchase.order')
 
283
        po = po_obj.browse(cr, uid, order_id, context=context)
 
284
        # on_change functions to call for updating values
 
285
        pricelist = po.pricelist_id.id or False
 
286
        partner_id = po.partner_id.id or False
 
287
        date_order = po.date_order or False
 
288
        fiscal_position = po.fiscal_position or False
 
289
        state = po.state or False
 
290
        product = to_write['product_id']
 
291
        qty = to_write['product_qty']
 
292
        price_unit = to_write['price_unit']
 
293
        uom = to_write['product_uom']
 
294
        if product and qty and not price_unit:
 
295
            res = self.product_id_on_change(cr, uid, ids, pricelist, product, qty, uom,
 
296
                                            partner_id, date_order, fiscal_position, date_planned=False,
 
297
                                            name=False, price_unit=price_unit, notes=False, state=state, old_price_unit=False,
 
298
                                            nomen_manda_0=False, comment=False, context=context)
 
299
            price_unit = res.get('value', {}).get('price_unit', False)
 
300
            uom = res.get('value', {}).get('product_uom', False)
 
301
            warning_msg = res.get('warning', {}).get('message', '')
 
302
            text_error += '\n %s' % warning_msg
 
303
            text_error += 'We use the price mechanism to compute the Price Unit.'
 
304
            to_write.update({'price_unit': price_unit, 'product_uom': uom, 'text_error': text_error})
 
305
        if uom:
 
306
            self.check_data_for_uom(cr, uid, ids, to_write=to_write, context=context)
 
307
        else:
 
308
            uom = obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'uom_tbd')[1]
 
309
            text_error += '\n It wasn\'t possible to update the UoM with the product\'s one because the former wasn\'t either defined.'
 
310
            to_write.update({'product_uom': uom, 'text_error': text_error})
 
311
 
 
312
    def check_data_for_uom(self, cr, uid, ids, *args, **kwargs):
 
313
        context = kwargs['context']
 
314
        if context is None:
 
315
            context = {}
 
316
        if isinstance(ids, (int, long)):
 
317
            ids = [ids]
 
318
        obj_data = self.pool.get('ir.model.data')
 
319
        # we take the values that we are going to write in PO line in "to_write"
 
320
        to_write = kwargs['to_write']
 
321
        text_error = to_write['text_error']
 
322
        product_id = to_write['product_id']
 
323
        uom_id = to_write['product_uom']
 
324
        if uom_id and product_id:
 
325
            product_obj = self.pool.get('product.product')
 
326
            uom_obj = self.pool.get('product.uom')
 
327
            product = product_obj.browse(cr, uid, product_id, context=context)
 
328
            uom = uom_obj.browse(cr, uid, uom_id, context=context)
 
329
            if product.uom_id.category_id.id != uom.category_id.id:
 
330
                # this is inspired by onchange_uom in specific_rules>specific_rules.py
 
331
                text_error += """\n You have to select a product UOM in the same category than the UOM of the product.
 
332
                The category of the UoM of the product is '%s' whereas the category of the UoM you have chosen is '%s'.
 
333
                """ % (product.uom_id.category_id.name, uom.category_id.name)
 
334
                return to_write.update({'text_error': text_error,
 
335
                                        'to_correct_ok': True})
 
336
        elif not uom_id or uom_id == obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'uom_tbd')[1] and product_id:
 
337
            # we take the default uom of the product
 
338
            product_uom = product.uom_id.id
 
339
            return to_write.update({'product_uom': product_uom})
 
340
        elif not uom_id or uom_id == obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'uom_tbd')[1]:
 
341
            # this is inspired by the on_change in purchase>purchase.py: product_uom_change
 
342
            text_error += "\n The UoM was not defined so we set the price unit to 0.0."
 
343
            return to_write.update({'text_error': text_error,
 
344
                                    'to_correct_ok': True,
 
345
                                    'price_unit': 0.0, })
 
346
 
350
347
    def write(self, cr, uid, ids, vals, context=None):
351
348
        if isinstance(ids, (int, long)):
352
349
            ids = [ids]
353
 
        uom_obj = self.pool.get('product.uom')
 
350
        if context is None:
 
351
            context = {}
354
352
        obj_data = self.pool.get('ir.model.data')
355
 
        tbd_uom = obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import','uom_tbd')[1]
 
353
        tbd_uom = obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'uom_tbd')[1]
356
354
        message = ''
357
 
        
358
 
        if vals.get('product_uom'):
359
 
            if vals.get('product_uom') == tbd_uom:
360
 
                message += 'You have to define a valid UOM, i.e. not "To be define".'
361
 
        if vals.get('nomen_manda_0'):
362
 
            if vals.get('nomen_manda_0') == obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd0')[1]:
363
 
                message += 'You have to define a valid Main Type (in tab "Nomenclature Selection"), i.e. not "To be define".'
364
 
        if vals.get('nomen_manda_1'):
365
 
            if vals.get('nomen_manda_1') == obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd1')[1]:
366
 
                message += 'You have to define a valid Group (in tab "Nomenclature Selection"), i.e. not "To be define".'
367
 
        if vals.get('nomen_manda_2'):
368
 
            if vals.get('nomen_manda_2') == obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd2')[1]:
369
 
                message += 'You have to define a valid Family (in tab "Nomenclature Selection"), i.e. not "To be define".'
370
 
        # the 3rd level is not mandatory
371
 
        if message:
372
 
            raise osv.except_osv(_('Warning !'), _(message))
373
 
        else:
374
 
            vals['to_correct_ok'] = False
375
 
            vals['text_error'] = False
376
 
        
 
355
        if not context.get('import_in_progress') and not context.get('button'):
 
356
            if vals.get('product_uom'):
 
357
                if vals.get('product_uom') == tbd_uom:
 
358
                    message += 'You have to define a valid UOM, i.e. not "To be define".'
 
359
            if vals.get('nomen_manda_0'):
 
360
                if vals.get('nomen_manda_0') == obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd0')[1]:
 
361
                    message += 'You have to define a valid Main Type (in tab "Nomenclature Selection"), i.e. not "To be define".'
 
362
            if vals.get('nomen_manda_1'):
 
363
                if vals.get('nomen_manda_1') == obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd1')[1]:
 
364
                    message += 'You have to define a valid Group (in tab "Nomenclature Selection"), i.e. not "To be define".'
 
365
            if vals.get('nomen_manda_2'):
 
366
                if vals.get('nomen_manda_2') == obj_data.get_object_reference(cr, uid, 'msf_supply_doc_import', 'nomen_tbd2')[1]:
 
367
                    message += 'You have to define a valid Family (in tab "Nomenclature Selection"), i.e. not "To be define".'
 
368
            # the 3rd level is not mandatory
 
369
            if message:
 
370
                raise osv.except_osv(_('Warning !'), _(message))
 
371
            else:
 
372
                vals['show_msg_ok'] = False
 
373
                vals['to_correct_ok'] = False
 
374
                vals['text_error'] = False
 
375
 
377
376
        return super(purchase_order_line, self).write(cr, uid, ids, vals, context=context)
378
377
 
379
378
purchase_order_line()
380