[ADD] connector_carepoint: Patient & Address export logic

* Improve existing patient export
* Add tests for patient importer/exporter
* Add abstract address export logic
* Add patient address export logic

connector_carepoint/consumer.py

@@ -3,14 +3,13 @@
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
 
 # from openerp.addons.connector.connector import Binder
-from .unit.export_synchronizer import (export_record,
-                                       )
+from .unit.export_synchronizer import export_record
 # from .unit.delete_synchronizer import export_delete_record
 # from .connector import get_environment
-# from openerp.addons.connector.event import (on_record_write,
-#                                             on_record_create,
-#                                             on_record_unlink
-#                                             )
+from openerp.addons.connector.event import (on_record_write,
+                                            on_record_create,
+                                            # on_record_unlink
+                                            )
 
 
 import logging
@@ -21,10 +20,6 @@
 #                                'carepoint.carepoint.address',
 #                                'carepoint.carepoint.address.patient',
 #                                ])
-# @on_record_write(model_names=['carepoint.medical.patient',
-#                               'carepoint.carepoint.address',
-#                               'carepoint.carepoint.address.patient',
-#                               ])
 def delay_export(session, model_name, record_id, vals):
     """ Delay a job which export a binding record.
     (A binding record being a ``carepoint.res.partner``,
@@ -36,10 +31,10 @@ def delay_export(session, model_name, record_id, vals):
     export_record.delay(session, model_name, record_id, fields=fields)
 
 
-# @on_record_write(model_names=['medical.patient',
-#                               'carepoint.address',
-#                               'carepoint.address.patient',
-#                               ])
+@on_record_write(model_names=['medical.patient',
+                              'carepoint.address',
+                              'carepoint.address.patient',
+                              ])
 def delay_export_all_bindings(session, model_name, record_id, vals):
     """ Delay a job which export all the bindings of a record.
     In this case, it is called on records of normal models and will delay
@@ -54,6 +49,25 @@ def delay_export_all_bindings(session, model_name, record_id, vals):
                             fields=fields)
 
 
+@on_record_create(model_names=['medical.patient',
+                               'carepoint.address',
+                               'carepoint.address.patient',
+                               ])
+def delay_create(session, model_name, record_id, vals):
+    """ Create a new binding record, then trigger delayed export
+    In this case, it is called on records of normal models to create
+    binding record, and trigger external system export
+    """
+    model_obj = session.env['carepoint.%s' % model_name].with_context(
+        connector_no_export=True,
+    )
+    if not len(model_obj.search([('odoo_id', '=', record_id)])):
+        model_obj.create({
+            'odoo_id': record_id,
+        })
+    delay_export_all_bindings(session, model_name, record_id, vals)
+
+
 # @on_record_unlink(model_names=['carepoint.medical.patient',
 #                                'carepoint.carepoint.address',
 #                                'carepoint.carepoint.address.patient',

connector_carepoint/models/address.py

@@ -7,6 +7,7 @@
 
 from openerp.addons.connector.connector import ConnectorUnit
 from openerp.addons.connector.unit.mapper import (mapping,
+                                                  changed_by,
                                                   ExportMapper
                                                   )
 from ..unit.backend_adapter import CarepointCRUDAdapter
@@ -16,8 +17,7 @@
 from ..unit.import_synchronizer import (DelayedBatchImporter,
                                         CarepointImporter,
                                         )
-from ..unit.export_synchronizer import (CarepointExporter)
-from ..unit.delete_synchronizer import (CarepointDeleter)
+from ..unit.export_synchronizer import CarepointExporter
 
 
 _logger = logging.getLogger(__name__)
@@ -99,9 +99,11 @@ def _get_partner_sync_vals(self, partner):
         """
         vals = {}
         for attr in self.PARTNER_ATTRS:
-            val = getattr(partner, attr, None)
-            if getattr(val, 'id', None):
+            val = getattr(partner, attr, False)
+            if getattr(val, 'id', False):
                 val = val.id
+            if not val:
+                val = False
             vals[attr] = val
         return vals
 
@@ -179,10 +181,33 @@ class CarepointAddressExportMapper(ExportMapper):
 
     direct = [
         ('street', 'addr1'),
-        ('email', 'addr2'),
+        ('street2', 'addr2'),
         ('city', 'city'),
     ]
 
+    @mapping
+    @changed_by('state_id')
+    def state_cd(self, record):
+        return {'state_cd': record.state_id.code}
+
+    @mapping
+    @changed_by('zip')
+    def zip_and_plus_four(self, record):
+        if not record.zip:
+            return
+        _zip = record.zip.replace('-', '')
+        if len(_zip) > 5:
+            return {
+                'zip': _zip[0:5],
+                'zip_plus4': _zip[5:],
+            }
+        return {'zip': _zip}
+
+    @mapping
+    @changed_by('country_id')
+    def country_cd(self, record):
+        return {'country_cd': record.country_id.code}
+
     @mapping
     def addr_id(self, record):
         return {'addr_id': record.carepoint_id}
@@ -192,8 +217,3 @@ def addr_id(self, record):
 class CarepointAddressExporter(CarepointExporter):
     _model_name = ['carepoint.carepoint.address']
     _base_mapper = CarepointAddressExportMapper
-
-
-@carepoint
-class CarepointAddressDeleteSynchronizer(CarepointDeleter):
-    _model_name = ['carepoint.carepoint.address']

connector_carepoint/models/address_abstract.py

@@ -3,9 +3,10 @@
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
 
 import logging
-from openerp import models, fields, api
+from openerp import models, fields, api, _
 from openerp.addons.connector.unit.mapper import (mapping,
                                                   only_create,
+                                                  ExportMapper,
                                                   )
 from ..unit.mapper import CarepointImportMapper
 from ..backend import carepoint
@@ -37,11 +38,35 @@ class CarepointAddressAbstract(models.AbstractModel):
         string='Partner',
         comodel_name='res.partner',
         required=True,
+        store=True,
         compute='_compute_partner_id',
         inverse='_set_partner_id',
     )
+    res_model = fields.Char(
+        string='Resource Model',
+        default=lambda s: s._default_res_model(),
+    )
+    res_id = fields.Integer(
+        string='Resource PK',
+        compute='_compute_res_id',
+        store=True,
+    )
+
+    @property
+    @api.multi
+    def medical_entity_id(self):
+        self.ensure_one()
+        return self.env[self.res_model].browse(self.res_id)
+
+    @api.model
+    def _default_res_model(self):
+        """ It returns the res model. Should be overloaded in children """
+        raise NotImplementedError(
+            _('_default_res_model should be implemented in child classes')
+        )
 
     @api.multi
+    @api.depends('partner_id')
     def _compute_partner_id(self):
         """ It sets the partner_id from the address_id """
         for rec_id in self:
@@ -71,6 +96,44 @@ def _set_partner_id(self):
             else:
                 rec_id.address_id.write(vals)
 
+    @api.multi
+    @api.depends('partner_id', 'res_model')
+    def _compute_res_id(self):
+        """ It computes the resource ID from model """
+        for rec_id in self:
+            if not all([rec_id.res_model, rec_id.partner_id]):
+                continue
+            medical_entity = self.env[rec_id.res_model].search([
+                ('partner_id', '=', rec_id.partner_id.id),
+            ],
+                limit=1,
+            )
+            rec_id.res_id = medical_entity.id
+
+    @api.model
+    def _get_by_partner(self, partner, create=True, recurse=False):
+        """ It returns the address associated to the partner.
+        Params:
+            partner: Recordset singleton of partner to search for
+            create: Bool determining whether to create address if not exist
+            recurse: Bool determining whether to recurse into children (this
+                is only really useful when create=True)
+        Return:
+            Recordset of partner address
+        """
+        address = self.search([('partner_id', '=', partner.id)], limit=1)
+        vals = self.address_id._get_partner_sync_vals(partner)
+        _logger.info('_get_by_partner %s, %s, %s' % (address, partner, vals))
+        if not address and create:
+            vals['partner_id'] = partner.id
+            address = self.create(vals)
+        else:
+            address.write(vals)
+        if recurse:
+            for child in partner.child_ids:
+                self._get_by_partner(child, create, recurse)
+        return address
+
 
 @carepoint
 class CarepointAddressAbstractImportMapper(CarepointImportMapper):
@@ -116,6 +179,19 @@ def partner_id(self, record, medical_entity):
             partner = self.env['res.partner'].create(vals)
         return {'partner_id': partner.id}
 
+    def res_model_and_id(self, record, medical_entity):
+        """ It returns the vals dict for res_model and res_id
+        Params:
+            record: ``dict`` of carepoint record
+            medical_entity: Recordset with a ``partner_id`` column
+        Return:
+            ``dict`` of values for mapping
+        """
+        return {
+            'res_id': medical_entity.id,
+            'res_model': medical_entity._name,
+        }
+
     @mapping
     @only_create
     def address_id(self, record):
@@ -139,3 +215,21 @@ def _create(self, data):
             self.session, binding._name, binding.id, binding.backend_id.id
         )
         return binding
+
+
+@carepoint
+class CarepointAddressAbstractExportMapper(ExportMapper):
+
+    @mapping
+    def addr_id(self, binding):
+        binder = self.binder_for('carepoint.carepoint.address')
+        rec_id = binder.to_backend(binding.address_id.id)
+        return {'addr_id': rec_id}
+
+    @mapping
+    def static_defaults(self, binding):
+        return {
+            'priority': 2,
+            'addr_type_cn': 2,
+            'app_flags': 0,
+        }

connector_carepoint/models/address_patient.py

@@ -3,17 +3,19 @@
 # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
 
 import logging
-from openerp import models, fields
+from openerp import models, fields, api, _
 from openerp.addons.connector.connector import ConnectorUnit
 from openerp.addons.connector.unit.mapper import (mapping,
                                                   only_create,
                                                   )
 from ..unit.backend_adapter import CarepointCRUDAdapter
 from ..backend import carepoint
 from ..unit.import_synchronizer import DelayedBatchImporter
+from ..unit.export_synchronizer import CarepointExporter
 
 from .address_abstract import (CarepointAddressAbstractImportMapper,
                                CarepointAddressAbstractImporter,
+                               CarepointAddressAbstractExportMapper,
                                )
 
 _logger = logging.getLogger(__name__)
@@ -49,6 +51,11 @@ class CarepointAddressPatient(models.Model):
         string='Carepoint Bindings',
     )
 
+    @api.model
+    def _default_res_model(self):
+        """ It returns the res model. """
+        return 'medical.patient'
+
 
 @carepoint
 class CarepointAddressPatientAdapter(CarepointCRUDAdapter):
@@ -81,6 +88,16 @@ def partner_id(self, record):
             record, patient_id,
         )
 
+    @mapping
+    @only_create
+    def res_model_and_id(self, record):
+        binder = self.binder_for('carepoint.medical.patient')
+        patient_id = binder.to_odoo(record['pat_id'], browse=True)
+        _sup = super(CarepointAddressPatientImportMapper, self)
+        return _sup.res_model_and_id(
+            record, patient_id,
+        )
+
     @mapping
     def carepoint_id(self, record):
         return {'carepoint_id': '%d,%d' % (record['pat_id'],
@@ -111,3 +128,35 @@ def _import_addresses(self, patient_id, partner_binding):
         address_ids = adapter.search(pat_id=patient_id)
         for address_id in address_ids:
             importer.run(address_id)
+
+
+@carepoint
+class CarepointAddressPatientExportMapper(
+    CarepointAddressAbstractExportMapper
+):
+    _model_name = 'carepoint.carepoint.address.patient'
+
+    @mapping
+    def pat_id(self, binding):
+        binder = self.binder_for('carepoint.medical.patient')
+        rec_id = binder.to_backend(binding.res_id)
+        return {'pat_id': rec_id}
+
+
+@carepoint
+class CarepointAddressPatientExporter(CarepointExporter):
+    _model_name = 'carepoint.carepoint.address.patient'
+    _base_mapper = CarepointAddressPatientExportMapper
+
+    @mapping
+    def _export_dependencies(self):
+        model = self._model_name
+        if isinstance(model, list):
+            model = model[0]
+            _logger.debug(
+                _('_model_name was a list, using %s from %s') % (
+                    self._model_name, model,
+                )
+            )
+        self._export_dependency(self.binding_record.address_id,
+                                model)