Merge lp:~camptocamp/openerp-connector-magento/7.0-new-mapper-api-gbr into lp:~openerp-connector-core-editors/openerp-connector-magento/7.0

[Guewen Baconnier @ Camptocamp]

Follows the API changes of https://code.launchpad.net/~openerp-connector-core-editors/openerp-connector/7.0-connector-mapper-refactor/+merge/194485

[Guewen Baconnier @ Camptocamp (gbaconnier-c2c)]

Branch is now sufficiently stable to be tested and used for development.

[Joël Grand-Guillaume @ camptocamp (jgrandguillaume-c2c)]

Hi,

Thanks for the contrib, as far as I can see, LGTM.

Regards,

Joël

review: Approve (code review, no tests)

=== modified file 'magentoerpconnect/partner.py'
--- magentoerpconnect/partner.py	2013-08-05 09:42:06 +0000
+++ magentoerpconnect/partner.py	2013-11-09 22:36:08 +0000
@@ -451,10 +451,10 @@
                     # and use the name of the company for the name
                     company_mapper = get_unit(CompanyImportMapper,
                                               'magento.res.partner')
-                    company_mapper.convert(magento_record)
+                    map_record = company_mapper.map_record(magento_record)
                     self.session.write('magento.res.partner',
                                        partner_binding_id,
-                                       company_mapper.data)
+                                       map_record.values())
                 else:
                     # for B2C individual customers, merge with the main
                     # partner

=== modified file 'magentoerpconnect/sale.py'
--- magentoerpconnect/sale.py	2013-11-08 14:16:29 +0000
+++ magentoerpconnect/sale.py	2013-11-09 22:36:08 +0000
@@ -563,11 +563,11 @@
                 'website_id': record.get('website_id'),
             }
             mapper = self.get_connector_unit_for_model(PartnerImportMapper,
-                                                      'magento.res.partner')
-            mapper.convert(customer_record)
-            oe_record = mapper.data_for_create
-            oe_record['guest_customer'] = True
-            partner_bind_id = sess.create('magento.res.partner', oe_record)
+                                                       'magento.res.partner')
+            map_record = mapper.map_record(customer_record)
+            map_record.update(guest_customer=True)
+            partner_bind_id = sess.create('magento.res.partner',
+                                          map_record.values(for_create=True))
             partner_binder.bind(guest_customer_id,
                                 partner_bind_id)
         else:
@@ -608,10 +608,10 @@
                                                        'magento.address')
 
         def create_address(address_record):
-            addr_mapper.convert(address_record)
-            oe_address = addr_mapper.data_for_create
-            oe_address.update(addresses_defaults)
-            address_bind_id = sess.create('magento.address', oe_address)
+            map_record = addr_mapper.map_record(address_record)
+            map_record.update(addresses_defaults)
+            address_bind_id = sess.create('magento.address',
+                                          map_record.values(for_create=True))
             return sess.read('magento.address',
                              address_bind_id,
                              ['openerp_id'])['openerp_id'][0]
@@ -671,14 +671,14 @@
     children = [('items', 'magento_order_line_ids', 'magento.sale.order.line'),
                 ]
 
-    def _after_mapping(self, result):
+    def finalize(self, map_record, values):
         sess = self.session
         # TODO: refactor: do no longer store the transient fields in the
         # result, use a ConnectorUnit to create the lines
         result = sess.pool['sale.order']._convert_special_fields(sess.cr,
                                                                  sess.uid,
-                                                                 result,
-                                                                 result['magento_order_line_ids'],
+                                                                 values,
+                                                                 values['magento_order_line_ids'],
                                                                  sess.context)
         # remove transient fields otherwise OpenERP will raise a warning
         # or even fail to create the record because the fields do not
@@ -689,7 +689,7 @@
         result.pop('gift_certificates_amount', None)
         result.pop('gift_certificates_code', None)
         onchange = self.get_connector_unit_for_model(SaleOrderOnChange)
-        return onchange.play(result, result['magento_order_line_ids'])
+        return onchange.play(values, values['magento_order_line_ids'])
 
     @mapping
     def name(self, record):
@@ -754,7 +754,7 @@
         ifield = record.get('shipping_method')
         if not ifield:
             return
-        
+
         carrier_ids = session.search('delivery.carrier',
                                      [('magento_code', '=', ifield)])
         if carrier_ids:

=== modified file 'magentoerpconnect/unit/export_synchronizer.py'
--- magentoerpconnect/unit/export_synchronizer.py	2013-05-01 12:12:58 +0000
+++ magentoerpconnect/unit/export_synchronizer.py	2013-11-09 22:36:08 +0000
@@ -139,9 +139,9 @@
         """ Export the dependencies for the record"""
         return
 
-    def _map_data(self, fields=None):
+    def _map_data(self):
         """ Convert the external record to OpenERP """
-        self.mapper.convert(self.binding_record, fields=fields)
+        return self.mapper.map_record(self.binding_record)
 
     def _validate_data(self, data):
         """ Check if the values to import are correct
@@ -153,13 +153,23 @@
         """
         return
 
+    def _create_data(self, map_record, fields=None):
+        return map_record.values(for_create=True, fields=fields)
+
     def _create(self, data):
         """ Create the Magento record """
+        # special check on data before export
+        self._validate_data(data)
         return self.backend_adapter.create(data)
 
+    def _update_data(self, map_record, fields=None):
+        return map_record.values(fields=fields)
+
     def _update(self, data):
         """ Update an Magento record """
         assert self.magento_id
+        # special check on data before export
+        self._validate_data(data)
         self.backend_adapter.write(self.magento_id, data)
 
     def _run(self, fields=None):
@@ -176,21 +186,17 @@
         # export the missing linked resources
         self._export_dependencies()
 
-        self._map_data(fields=fields)
+        map_record = self._map_data()
 
         if self.magento_id:
-            record = self.mapper.data
+            record = self._update_data(map_record, fields=fields)
             if not record:
                 return _('Nothing to export.')
-            # special check on data before export
-            self._validate_data(record)
             self._update(record)
         else:
-            record = self.mapper.data_for_create
+            record = self._create_data(map_record, fields=fields)
             if not record:
                 return _('Nothing to export.')
-            # special check on data before export
-            self._validate_data(record)
             self.magento_id = self._create(record)
         return _('Record exported with ID %s on Magento.') % self.magento_id
 

=== modified file 'magentoerpconnect/unit/import_synchronizer.py'
--- magentoerpconnect/unit/import_synchronizer.py	2013-10-31 08:53:35 +0000
+++ magentoerpconnect/unit/import_synchronizer.py	2013-11-09 22:36:08 +0000
@@ -92,9 +92,11 @@
         return
 
     def _map_data(self):
-        """ Call the convert on the Mapper so the converted record can
-        be obtained using mapper.data or mapper.data_for_create"""
-        self.mapper.convert(self.magento_record)
+        """ Returns an instance of
+        :py:class:`~openerp.addons.connector.unit.mapper.MapRecord`
+
+        """
+        return self.mapper.map_record(self.magento_record)
 
     def _validate_data(self, data):
         """ Check if the values to import are correct
@@ -124,21 +126,26 @@
         """Return the binding id from the magento id"""
         return self.binder.to_openerp(self.magento_id)
 
-    def _context(self):
-        context = self.session.context.copy()
-        context['connector_no_export'] = True
-        return context
+    def _create_data(self, map_record):
+        return map_record.values(for_create=True)
 
     def _create(self, data):
         """ Create the OpenERP record """
+        # special check on data before import
+        self._validate_data(data)
         with self.session.change_context({'connector_no_export': True}):
             binding_id = self.session.create(self.model._name, data)
         _logger.debug('%s %d created from magento %s',
                       self.model._name, binding_id, self.magento_id)
         return binding_id
 
+    def _update_data(self, map_record):
+        return map_record.values()
+
     def _update(self, binding_id, data):
         """ Update an OpenERP record """
+        # special check on data before import
+        self._validate_data(data)
         with self.session.change_context({'connector_no_export': True}):
             self.session.write(self.model._name, binding_id, data)
         _logger.debug('%s %d updated from magento %s',
@@ -173,17 +180,13 @@
         # import the missing linked resources
         self._import_dependencies()
 
-        self._map_data()
+        map_record = self._map_data()
 
         if binding_id:
-            record = self.mapper.data
-            # special check on data before import
-            self._validate_data(record)
+            record = self._update_data(map_record)
             self._update(binding_id, record)
         else:
-            record = self.mapper.data_for_create
-            # special check on data before import
-            self._validate_data(record)
+            record = self._create_data(map_record)
             binding_id = self._create(record)
 
         self.binder.bind(self.magento_id, binding_id)
@@ -282,8 +285,8 @@
 
         for storeview in lang_storeviews:
             lang_record = self._get_magento_data(storeview.magento_id)
-            self.mapper.convert(lang_record)
-            record = self.mapper.data
+            map_record = self.mapper.map_record(lang_record)
+            record = map_record.values()
 
             data = dict((field, value) for field, value in record.iteritems()
                         if field in translatable_fields)