Merge lp:~arthru/prestashoperpconnect/import-product-combinations into lp:prestashoperpconnect

[arthru]

This permits to import a product by combination in prestashop

[Guewen Baconnier @ Camptocamp (gbaconnier-c2c)]

Good piece of work Arthur,

Some comments:

--

What is a "product combination". At least a few words (in the docstring of the Python module product_combination.py) to explain this concept could be useful.

--

l.44-47, l.217ff. l.226ff (and other places, possibly on methods search, browse, read, create, unlink)

    model = self.session.pool.get('product.product')
    product_ids = model.search(self.session.cr, self.session.uid, [
        ('default_code', '=', code)
    ])

A better idiom is:

    product_ids = self.session.search('product.product', [('default_code', '=', code)])

(side note on the alignment: "Arguments on first line forbidden when not using vertical alignment", source http://www.python.org/dev/peps/pep-0008/#indentation)

--

l.134
"unidecode" is to add in the "external_dependencies" in __openerp__.py

--

l.212 (and each time you use the unwrap keyword argument of to_openerp())

Please use the keyword when calling a keyword argument, so instead of

    attribute_id = option_binder.to_openerp(
        option_value['id_attribute_group'], True)

Use

    attribute_id = option_binder.to_openerp(
        option_value['id_attribute_group'], unwrap=True)

--
l.264, l.302, l.453

Instead of:

  type(main_product[attribute]) is list

Use:

  isinstance(main_product[attribute], list)

--
l.306-321:
suggestion (as you want): externalize the part which get the option value in another ConnectorUnit, allowing to customize the way the options values are get.

--
l.599
    if len(combinations) == 0:
=>
    if not combinations:

--

Thanks!

review: Needs Fixing (code review)

[lp:~arthru/prestashoperpconnect/import-product-combinations]

278. By arthru on 2013-10-29

Add a comment on product_combination

279. By arthru on 2013-10-29

Clean calls to the pool using the session API

280. By arthru on 2013-10-29

Add unidecode to the external dependencies

281. By arthru on 2013-10-29

Explicitly set the unwrap keywrod when used in binder.to_openerp

282. By arthru on 2013-10-29

Use isinstance instead of type comparisons

[arthru (arthru)]

I made most of the changes. Thanks a lot for these advice, I'll try to apply them in the code that already exist !

review: Needs Resubmitting

[lp:~arthru/prestashoperpconnect/import-product-combinations]

283. By arthru on 2014-02-05

Fix the dependency on unidecode

284. By arthru on 2014-02-05

Fix a search call

Unmerged revisions

=== modified file 'prestashoperpconnect/__init__.py'
--- prestashoperpconnect/__init__.py	2013-08-12 17:37:07 +0000
+++ prestashoperpconnect/__init__.py	2013-10-29 09:24:05 +0000
@@ -27,6 +27,7 @@
 import prestashop_model
 import partner
 import product
+import product_combination
 import sale
 import setting
 import delivery

=== modified file 'prestashoperpconnect/__openerp__.py'
--- prestashoperpconnect/__openerp__.py	2013-10-08 14:32:58 +0000
+++ prestashoperpconnect/__openerp__.py	2013-10-29 09:24:05 +0000
@@ -32,7 +32,9 @@
         "product_m2mcategories",
         "connector_ecommerce",
         "product_images",
+        "product_custom_attributes",
     ],
+    "external_dependencies": ["unidecode"],
     "author": "PrestashopERPconnect Core Editors",
     "description": """This module connects OpenERP and Prestashop.
 

=== modified file 'prestashoperpconnect/product.py'
--- prestashoperpconnect/product.py	2013-10-25 12:39:24 +0000
+++ prestashoperpconnect/product.py	2013-10-29 09:24:05 +0000
@@ -203,6 +203,24 @@
             return {'date_upd': datetime.datetime.now()}
         return {'date_upd': record['date_upd']}
 
+    def has_combinations(self, record):
+        combinations = record.get('associations', {}).get(
+            'combinations', {}).get('combinations', [])
+        return len(combinations) != 0
+
+    @mapping
+    def attribute_set_id(self, record):
+        if self.has_combinations(record) and 'attribute_set_id' in record:
+            return {'attribute_set_id': record['attribute_set_id']}
+        return {}
+
+    def _product_code_exists(self, code):
+        model = self.session.pool.get('product.product')
+        product_ids = model.search(self.session.cr, self.session.uid, [
+            ('default_code', '=', code)
+        ])
+        return len(product_ids) > 0
+
     @mapping
     def image(self, record):
         if record['id_default_image']['value'] == '':
@@ -216,9 +234,17 @@
 
     @mapping
     def default_code(self, record):
-        if record.get('reference'):
-            return {'default_code': record.get('reference')}
-        return {}
+        if not record.get('reference'):
+            return {}
+        code = record.get('reference')
+        if not self._product_code_exists(code):
+            return {'default_code': code}
+        i = 1
+        current_code = '%s_%d' % (code, i)
+        while self._product_code_exists(current_code):
+            i += 1
+            current_code = '%s_%d' % (code, i)
+        return {'default_code': current_code}
 
     @mapping
     def active(self, record):
@@ -226,7 +252,11 @@
 
     @mapping
     def sale_ok(self, record):
-        return {'sale_ok': record['available_for_order'] == '1'}
+		# if this product has combinations, we do not want to sell this product,
+		# but its combinations (so sale_ok = False in that case).
+        sale_ok = (record['available_for_order'] == '1'
+                   and not self.has_combinations(record))
+        return {'sale_ok': sale_ok}
 
     @mapping
     def categ_id(self, record):
@@ -286,10 +316,14 @@
 
     @mapping
     def type(self, record):
-        product_type = {"type": 'product'}
-        if record['type']['value'] and record['type']['value'] == 'virtual':
-            product_type = {"type": 'consu'}
-        return product_type
+		# If the product has combinations, this main product is not a real
+		# product. So it is set to a 'service' kind of product. Should better be
+		# a 'virtual' product... but it does not exist...
+		# The same if the product is a virtual one in prestashop.
+        if ((record['type']['value'] and record['type']['value'] == 'virtual')
+                or self.has_combinations(record)):
+            return {"type": 'service'}
+        return {"type": 'product'}
 
 
 class product_product(orm.Model):
@@ -328,10 +362,6 @@
         'always_available': fields.boolean(
             'Active',
             help='if check, this object is always available'),
-        'sale_ok': fields.boolean(
-            'For sale',
-            help='see parent field'
-        ),
         'quantity': fields.float(
             'Computed Quantity',
             help="Last computed quantity to send on Prestashop."
@@ -363,6 +393,11 @@
             translate=True,
             required=True,
         ),
+        'combinations_ids': fields.one2many(
+            'prestashop.product.combination',
+            'main_product_id',
+            string='Combinations'
+        ),
     }
 
     _sql_constraints = [

=== added file 'prestashoperpconnect/product_combination.py'
--- prestashoperpconnect/product_combination.py	1970-01-01 00:00:00 +0000
+++ prestashoperpconnect/product_combination.py	2013-10-29 09:24:05 +0000
@@ -0,0 +1,397 @@
+'''
+A product combination is a product with different attributes in prestashop.
+In prestashop, we can sell a product or a combination of a product with some
+attributes.
+
+For example, for the iPod product we can found in demo data, it has some
+combinations with different colors and different storage size.
+
+We map that in OpenERP to a product.product with an attribute.set defined for
+the main product.
+'''
+
+from unidecode import unidecode
+
+from openerp.osv import fields, orm
+from backend import prestashop
+from .unit.backend_adapter import GenericAdapter
+from .unit.import_synchronizer import PrestashopImportSynchronizer
+from .unit.import_synchronizer import TranslatableRecordImport
+from .unit.mapper import PrestashopImportMapper
+from openerp.addons.connector.unit.backend_adapter import BackendAdapter
+from openerp.addons.connector.unit.mapper import mapping
+
+
+class product_product(orm.Model):
+    _inherit = 'product.product'
+
+    _columns = {
+        'prestashop_combinations_bind_ids': fields.one2many(
+            'prestashop.product.combination',
+            'openerp_id',
+            string='PrestaShop Bindings (combinations)'
+        ),
+    }
+
+
+class prestashop_product_combination(orm.Model):
+    _name = 'prestashop.product.combination'
+    _inherit = 'prestashop.binding'
+    _inherits = {'product.product': 'openerp_id'}
+
+    _columns = {
+        'openerp_id': fields.many2one(
+            'product.product',
+            string='Product',
+            required=True,
+            ondelete='cascade'
+        ),
+        'main_product_id': fields.many2one(
+            'prestashop.product.product',
+            string='Main product',
+            required=True,
+            ondelete='cascade'
+        ),
+    }
+
+
+@prestashop
+class ProductCombinationAdapter(GenericAdapter):
+    _model_name = 'prestashop.product.combination'
+    _prestashop_model = 'combinations'
+
+
+@prestashop
+class ProductCombinationRecordImport(PrestashopImportSynchronizer):
+    _model_name = 'prestashop.product.combination'
+
+    def _import_dependencies(self):
+        record = self.prestashop_record
+        option_values = record.get('associations', {}).get(
+            'product_option_values', {}).get('product_option_value', [])
+        if not isinstance(option_values, list):
+            option_values = [option_values]
+        for option_value in option_values:
+            backend_adapter = self.get_connector_unit_for_model(
+                BackendAdapter,
+                'prestashop.product.combination.option.value'
+            )
+            option_value = backend_adapter.read(option_value['id'])
+            self._check_dependency(
+                option_value['id_attribute_group'],
+                'prestashop.product.combination.option',
+            )
+
+            self.check_location(option_value)
+
+    def check_location(self, option_value):
+        option_binder = self.get_binder_for_model(
+            'prestashop.product.combination.option')
+        attribute_id = option_binder.to_openerp(
+            option_value['id_attribute_group'], unwrap=True)
+        product = self.mapper.main_product(self.prestashop_record)
+        attribute_group_id = product.attribute_set_id.attribute_group_ids[0].id
+
+        attribute_location_ids = self.session.search(
+            'attribute.location',
+            [
+                ('attribute_id', '=', attribute_id),
+                ('attribute_group_id', '=', attribute_group_id)
+            ]
+        )
+        if not attribute_location_ids:
+            self.session.create(
+                'attribute.location',
+                {
+                    'attribute_id': attribute_id,
+                    'attribute_group_id': attribute_group_id,
+                }
+            )
+
+
+@prestashop
+class ProductCombinationMapper(PrestashopImportMapper):
+    _model_name = 'prestashop.product.combination'
+
+    direct = [
+        ('weight', 'weight'),
+        ('wholesale_price', 'standard_price'),
+        ('price', 'lst_price'),
+    ]
+
+    from_main = [
+        'name',
+        'categ_id',
+        'categ_ids',
+        'taxes_ids',
+        'type',
+        'company_id',
+    ]
+
+    @mapping
+    def from_main_product(self, record):
+        main_product = self.main_product(record)
+        result = {}
+        for attribute in self.from_main:
+            if attribute not in main_product:
+                continue
+            if hasattr(main_product[attribute], 'id'):
+                result[attribute] = main_product[attribute].id
+            elif isinstance(main_product[attribute]), list):
+                ids = []
+                for element in main_product[attribute]:
+                    ids.append(element.id)
+                result[attribute] = [(6, 0, ids)]
+            else:
+                result[attribute] = main_product[attribute]
+        return result
+
+    def main_product(self, record):
+        if hasattr(self, '_main_product'):
+            return self._main_product
+        product_id = self.get_main_product_id(record)
+        self._main_product = self.session.browse(
+            'prestashop.product.product',
+            product_id
+        )
+        return self._main_product
+
+    def get_main_product_id(self, record):
+        product_binder = self.get_binder_for_model(
+            'prestashop.product.product')
+        return product_binder.to_openerp(record['id_product'])
+
+    @mapping
+    def attribute_set_id(self, record):
+        product = self.main_product(record)
+        if 'attribute_set_id' in product:
+            return {'attribute_set_id': product.attribute_set_id.id}
+        return {}
+
+    @mapping
+    def attributes_values(self, record):
+        option_values = record['associations']['product_option_values'][
+            'product_option_value']
+        if isinstance(option_values, dict):
+            option_values = [option_values]
+
+        results = {}
+        for option_value in option_values:
+
+            option_value_binder = self.get_binder_for_model(
+                'prestashop.product.combination.option.value')
+            option_value_openerp_id = option_value_binder.to_openerp(
+                option_value['id'])
+
+            option_value_object = self.session.browse(
+                'prestashop.product.combination.option.value',
+                option_value_openerp_id
+            )
+            field_name = option_value_object.attribute_id.name
+            results[field_name] = option_value_object.id
+        return results
+
+    @mapping
+    def main_product_id(self, record):
+        return {'main_product_id': self.get_main_product_id(record)}
+
+    def _product_code_exists(self, code):
+        product_ids = self.session.search('product.product',
+                                          [('default_code', '=', code)])
+        return len(product_ids) > 0
+
+    @mapping
+    def default_code(self, record):
+        if not record.get('reference'):
+            return {}
+        code = record.get('reference')
+        if not self._product_code_exists(code):
+            return {'default_code': code}
+        i = 1
+        current_code = '%s_%d' % (code, i)
+        while self._product_code_exists(current_code):
+            i += 1
+            current_code = '%s_%d' % (code, i)
+        return {'default_code': current_code}
+
+    ##@mapping
+    ##def active(self, record):
+    ##    return {'always_available': bool(int(record['active']))}
+
+    ##@mapping
+    ##def sale_ok(self, record):
+    ##    return {'sale_ok': record['available_for_order'] == '1'}
+
+    @mapping
+    def backend_id(self, record):
+        return {'backend_id': self.backend_record.id}
+
+    @mapping
+    def ean13(self, record):
+        if record['ean13'] == '0':
+            return {}
+        return {'ean13': record['ean13']}
+
+
+class attribute_attribute(orm.Model):
+    _inherit = 'attribute.attribute'
+
+    _columns = {
+        'prestashop_bind_ids': fields.one2many(
+            'prestashop.product.combination.option',
+            'openerp_id',
+            string='PrestaShop Bindings (combinations)'
+        ),
+    }
+
+
+class prestashop_product_combination_option(orm.Model):
+    _name = 'prestashop.product.combination.option'
+    _inherit = 'prestashop.binding'
+    _inherits = {'attribute.attribute': 'openerp_id'}
+
+    _columns = {
+        'openerp_id': fields.many2one(
+            'attribute.attribute',
+            string='Attribute',
+            required=True,
+            ondelete='cascade'
+        ),
+    }
+
+
+@prestashop
+class ProductCombinationOptionAdapter(GenericAdapter):
+    _model_name = 'prestashop.product.combination.option'
+    _prestashop_model = 'product_options'
+
+
+@prestashop
+class ProductCombinationOptionRecordImport(PrestashopImportSynchronizer):
+    _model_name = 'prestashop.product.combination.option'
+
+    def _import_values(self):
+        record = self.prestashop_record
+        option_values = record.get('associations', {}).get(
+            'product_option_values', {}).get('product_option_value', [])
+        if not isinstance(option_values, list):
+            option_values = [option_values]
+        for option_value in option_values:
+            self._check_dependency(
+                option_value['id'],
+                'prestashop.product.combination.option.value'
+            )
+
+    def run(self, ext_id):
+        super(ProductCombinationOptionRecordImport, self).run(ext_id)
+
+        self._import_values()
+
+
+@prestashop
+class ProductCombinationOptionMapper(PrestashopImportMapper):
+    _model_name = 'prestashop.product.combination.option'
+
+    @mapping
+    def attribute_type(self, record):
+        return {'attribute_type': 'select'}
+
+    @mapping
+    def model_id(self, record):
+        ids = self.session.search('ir.model',
+                                  [('model', '=', 'product.product')])
+        assert len(ids) == 1
+        return {'model_id': ids[0], 'model': 'product.product'}
+
+    @mapping
+    def backend_id(self, record):
+        return {'backend_id': self.backend_record.id}
+
+    @mapping
+    def name(self, record):
+        name = None
+        if 'language' in record['name']:
+            language_binder = self.get_binder_for_model('prestashop.res.lang')
+            languages = record['name']['language']
+            if not isinstance(languages, list):
+                languages = [languages]
+            for lang in languages:
+                erp_language_id = language_binder.to_openerp(
+                    lang['attrs']['id'])
+                erp_lang = self.session.read(
+                    'prestashop.res.lang',
+                    erp_language_id,
+                )
+                if erp_lang['code'] == 'en_US':
+                    name = lang['value']
+                    break
+            if name is None:
+                name = languages[0]['value']
+        else:
+            name = record['name']
+        field_name = 'x_' + unidecode(name.replace(' ', ''))
+        return {'name': field_name, 'field_description': name}
+
+
+class attribute_option(orm.Model):
+    _inherit = 'attribute.option'
+
+    _columns = {
+        'prestashop_bind_ids': fields.one2many(
+            'prestashop.product.combination.option.value',
+            'openerp_id',
+            string='PrestaShop Bindings'
+        ),
+    }
+
+
+class prestashop_product_combination_option_value(orm.Model):
+    _name = 'prestashop.product.combination.option.value'
+    _inherit = 'prestashop.binding'
+    _inherits = {'attribute.option': 'openerp_id'}
+
+    _columns = {
+        'openerp_id': fields.many2one(
+            'attribute.option',
+            string='Attribute',
+            required=True,
+            ondelete='cascade'
+        ),
+    }
+
+
+@prestashop
+class ProductCombinationOptionValueAdapter(GenericAdapter):
+    _model_name = 'prestashop.product.combination.option.value'
+    _prestashop_model = 'product_option_values'
+
+
+@prestashop
+class ProductCombinationOptionValueRecordImport(TranslatableRecordImport):
+    _model_name = 'prestashop.product.combination.option.value'
+
+    _translatable_fields = {
+        'prestashop.product.combination.option.value': ['name'],
+    }
+
+
+@prestashop
+class ProductCombinationOptionValueMapper(PrestashopImportMapper):
+    _model_name = 'prestashop.product.combination.option.value'
+
+    direct = [
+        ('name', 'name'),
+        ('position', 'sequence'),
+    ]
+
+    @mapping
+    def attribute_id(self, record):
+        binder = self.get_binder_for_model(
+            'prestashop.product.combination.option')
+        attribute_id = binder.to_openerp(record['id_attribute_group'],
+                                         unwrap=True)
+        return {'attribute_id': attribute_id}
+
+    @mapping
+    def backend_id(self, record):
+        return {'backend_id': self.backend_record.id}

=== modified file 'prestashoperpconnect/security/ir.model.access.csv'
--- prestashoperpconnect/security/ir.model.access.csv	2013-08-13 08:22:25 +0000
+++ prestashoperpconnect/security/ir.model.access.csv	2013-10-29 09:24:05 +0000
@@ -20,4 +20,6 @@
 access_prestashop_product_category_full,Full access on prestashop.product.category,model_prestashop_product_category,connector.group_connector_manager,1,1,1,1
 access_prestashop_product_image_full,Full access on prestashop.product.image,model_prestashop_product_image,connector.group_connector_manager,1,1,1,1
 access_prestashop_product_product_full,Full access on prestashop.product.product,model_prestashop_product_product,connector.group_connector_manager,1,1,1,1
-
+access_prestashop_product_combination_full,Full access on prestashop.product.combination,model_prestashop_product_combination,connector.group_connector_manager,1,1,1,1
+access_prestashop_product_combination_option_full,Full access on prestashop.product.combination.option,model_prestashop_product_combination_option,connector.group_connector_manager,1,1,1,1
+access_prestashop_product_combination_option_value_full,Full access on prestashop.product.combination.option.value,model_prestashop_product_combination_option_value,connector.group_connector_manager,1,1,1,1

=== modified file 'prestashoperpconnect/unit/binder.py'
--- prestashoperpconnect/unit/binder.py	2013-07-12 13:35:45 +0000
+++ prestashoperpconnect/unit/binder.py	2013-10-29 09:24:05 +0000
@@ -51,6 +51,9 @@
         'prestashop.product.category',
         'prestashop.product.image',
         'prestashop.product.product',
+        'prestashop.product.combination',
+        'prestashop.product.combination.option',
+        'prestashop.product.combination.option.value',
         'prestashop.sale.order',
         'prestashop.sale.order.state',
         'prestashop.delivery.carrier',

=== modified file 'prestashoperpconnect/unit/import_synchronizer.py'
--- prestashoperpconnect/unit/import_synchronizer.py	2013-10-25 12:40:37 +0000
+++ prestashoperpconnect/unit/import_synchronizer.py	2013-10-29 09:24:05 +0000
@@ -531,6 +531,20 @@
 
         prestashop_record = self._get_prestashop_data()
         associations = prestashop_record.get('associations', {})
+
+        combinations = associations.get('combinations', {}).get(
+            'combinations', {})
+        if not isinstance(combinations, list):
+            combinations = [combinations]
+        for combination in combinations:
+            if 'id' in combination:
+                import_record(
+                    self.session,
+                    'prestashop.product.combination',
+                    self.backend_record.id,
+                    combination['id']
+                )
+
         images = associations.get('images', {}).get('image', {})
         if not isinstance(images, list):
             images = [images]
@@ -546,11 +560,51 @@
                 )
 
     def _import_dependencies(self):
+        self._import_default_category()
+        self._import_categories()
+        self._import_attribute_set()
+
+    def _import_attribute_set(self):
+        record = self.prestashop_record
+
+        combinations = record.get('associations', {}).get(
+            'combinations', {}).get('combinations', [])
+        if len(combinations) == 0:
+            return
+
+        splitted_record = self._split_per_language(self.prestashop_record)
+        if self._default_language in splitted_record:
+            name = splitted_record[self._default_language]['name']
+        else:
+            name = splitted_record.values()[0]['name']
+
+        product_model_id = self.get_product_model_id()
+        attribute_group = {
+            'model_id': product_model_id,
+            'name': 'Combinations options',
+            'sequence': 0,
+        }
+        attribute_set = {
+            'model_id': product_model_id,
+            'name': name + ' Options',
+            'attribute_group_ids': [(0, 0,  attribute_group)],
+        }
+        attribute_set_id = self.session.create('attribute.set', attribute_set)
+        self.prestashop_record['attribute_set_id'] = attribute_set_id
+
+    def get_product_model_id(self):
+        ids = model.search('ir.model', [('model', '=', 'product.product')])
+        assert len(ids) == 1
+        return ids[0]
+
+    def _import_default_category(self):
         record = self.prestashop_record
         if int(record['id_category_default']):
             self._check_dependency(record['id_category_default'],
                                    'prestashop.product.category')
 
+    def _import_categories(self):
+        record = self.prestashop_record
         associations = record.get('associations', {})
         categories = associations.get('categories', {}).get('category', [])
         if not isinstance(categories, list):

=== modified file 'prestashoperpconnect/unit/mapper.py'
--- prestashoperpconnect/unit/mapper.py	2013-10-25 12:41:52 +0000
+++ prestashoperpconnect/unit/mapper.py	2013-10-29 09:24:05 +0000
@@ -419,10 +419,20 @@
 
     @mapping
     def product_id(self, record):
-        return {'product_id': self.get_openerp_id(
-            'prestashop.product.product',
-            record['product_id']
-        )}
+        if ('product_attribute_id' in record and
+                record['product_attribute_id'] != '0'):
+            combination_binder = self.get_binder_for_model(
+                'prestashop.product.combination')
+            product_id = combination_binder.to_openerp(
+                record['product_attribute_id'],
+                unwrap=True
+            )
+        else:
+            product_id = self.get_openerp_id(
+                'prestashop.product.product',
+                record['product_id']
+            )
+        return {'product_id': product_id}
 
     @mapping
     def backend_id(self, record):