Add support for importing MemberEquityPayment from CORE-POS DB

SQL only, no API for now

rattail_corepos/importing/corepos/api.py

@@ -835,16 +835,7 @@ class MemberImporter(FromCOREPOSAPI, corepos_importing.model.MemberImporter):
     def normalize_host_object(self, member):
         card_number = member['cardNo']
         customer = self.get_customer_by_number(card_number)
-        if not customer:
-            log.warning("Rattail customer not found for cardNo %s: %s",
-                        card_number, member)
-            return
-
-        person = self.app.get_person(customer)
-        if not person:
-            log.warning("Rattail person not found for cardNo %s: %s",
-                        card_number, member)
-            return
+        person = self.app.get_person(customer) if customer else None
 
         # TODO: at first i was *skipping* non-member status records,
         # but since CORE sort of assumes all customers are members,
@@ -883,8 +874,8 @@ class MemberImporter(FromCOREPOSAPI, corepos_importing.model.MemberImporter):
         return {
             'number': card_number,
             'corepos_account_id': int(member['customerAccountID']),
-            'customer_uuid': customer.uuid,
-            'person_uuid': person.uuid,
+            'customer_uuid': customer.uuid if customer else None,
+            'person_uuid': person.uuid if person else None,
             'membership_type_number': typeno,
             'joined': joined,
             'withdrew': withdrew,

rattail_corepos/importing/corepos/db.py

@@ -25,19 +25,27 @@ CORE POS (DB) -> Rattail data importing
 """
 
 import decimal
+import logging
 from collections import OrderedDict
 
+from sqlalchemy import orm
+
 from corepos.db.office_op import model as corepos, Session as CoreSession
+from corepos.db.office_trans import model as coretrans, Session as CoreTransSession
 
 from rattail import importing
 from rattail.gpc import GPC
 from rattail_corepos import importing as corepos_importing
 
 
+log = logging.getLogger(__name__)
+
+
 class FromCOREPOSToRattail(importing.FromSQLAlchemyHandler, importing.ToRattailHandler):
     """
     Import handler for data coming from a CORE POS database.
     """
+    # TODO: these should be changed, it now allows for "trans" DB too..
     generic_host_title = 'CORE Office (DB "op")'
     host_key = 'corepos_db_office_op'
     corepos_dbkey = 'default'
@@ -47,6 +55,12 @@ class FromCOREPOSToRattail(importing.FromSQLAlchemyHandler, importing.ToRattailH
         return "CORE-POS (DB/{})".format(self.corepos_dbkey)
 
     def make_host_session(self):
+
+        # session type depends on the --corepos-dbtype arg
+        if self.corepos_dbtype == 'office_trans':
+            return CoreTransSession(bind=self.config.coretrans_engines[self.corepos_dbkey])
+
+        # assume office_op by default
         return CoreSession(bind=self.config.corepos_engines[self.corepos_dbkey])
 
     def get_importers(self):
@@ -55,8 +69,17 @@ class FromCOREPOSToRattail(importing.FromSQLAlchemyHandler, importing.ToRattailH
         importers['Department'] = DepartmentImporter
         importers['Subdepartment'] = SubdepartmentImporter
         importers['Product'] = ProductImporter
+        importers['MemberEquityPayment'] = MemberEquityPaymentImporter
         return importers
 
+    def get_default_keys(self):
+        keys = super().get_default_keys()
+
+        if 'MemberEquityPayment' in keys:
+            keys.remove('MemberEquityPayment')
+
+        return keys
+
 
 class FromCOREPOS(importing.FromSQLAlchemy):
     """
@@ -228,3 +251,84 @@ class ProductImporter(FromCOREPOS, corepos_importing.model.ProductImporter):
             })
 
         return data
+
+
+class MemberEquityPaymentImporter(FromCOREPOS, corepos_importing.model.MemberEquityPaymentImporter):
+    """
+    Imports equity payment data from CORE-POS
+    """
+    host_model_class = coretrans.StockPurchase
+    # TODO: this is composite key for StockPurchase, but may need to change?
+    key = ('member_uuid', 'received', 'transaction_identifier')
+    supported_fields = [
+        'member_uuid',
+        'amount',
+        'received',
+        'transaction_identifier',
+        'corepos_card_number',
+        'corepos_transaction_number',
+        'corepos_transaction_id',
+        'corepos_department_number',
+    ]
+
+    def setup(self):
+        super().setup()
+        model = self.model
+
+        query = self.session.query(model.Member)\
+                            .join(model.Customer)\
+                            .join(model.CoreCustomer)\
+                            .options(orm.joinedload(model.Member.customer)\
+                                     .joinedload(model.Customer._corepos))
+        key = lambda member, normal: member.customer.corepos_card_number
+        self.members_by_card_number = self.cache_model(model.Member,
+                                                       query=query,
+                                                       key=key)
+
+    def get_member(self, card_number):
+        if hasattr(self, 'members_by_card_number'):
+            return self.members_by_card_number.get(card_number)
+
+        model = self.model
+        try:
+            return self.session.query(model.Member)\
+                               .join(model.Customer)\
+                               .join(model.CoreCustomer)\
+                               .filter(model.CoreCustomer.corepos_card_number == card_number)\
+                               .one()
+        except orm.exc.NoResultFound:
+            pass
+
+    def normalize_host_object(self, stock_purchase):
+
+        card_number = stock_purchase.card_number
+        member = self.get_member(card_number)
+        if not member:
+            log.warning("member not found for card number %s: %s",
+                        card_number, stock_purchase)
+            return
+
+        received = stock_purchase.datetime
+        if received:
+            received = self.app.localtime(received)
+            received = self.app.make_utc(received)
+
+        return {
+            'member_uuid': member.uuid,
+            'amount': stock_purchase.amount,
+            'received': received,
+            'transaction_identifier': stock_purchase.transaction_number,
+            'corepos_card_number': stock_purchase.card_number,
+            'corepos_transaction_number': stock_purchase.transaction_number,
+            'corepos_transaction_id': stock_purchase.transaction_id,
+            'corepos_department_number': stock_purchase.department_number,
+        }
+
+    def create_object(self, key, host_data):
+        payment = super().create_object(key, host_data)
+        if payment:
+
+            # track where each payment comes from!
+            payment.source = 'corepos'
+
+            return payment

rattail_corepos/importing/model.py

@@ -82,6 +82,18 @@ class MemberImporter(importing.model.MemberImporter):
     }
 
 
+class MemberEquityPaymentImporter(importing.model.MemberEquityPaymentImporter):
+
+    extensions = {
+        '_corepos': [
+            'corepos_card_number',
+            'corepos_transaction_number',
+            'corepos_transaction_id',
+            'corepos_department_number',
+        ],
+    }
+
+
 class StoreImporter(importing.model.StoreImporter):
 
     extensions = {

rattail_corepos/importing/versions.py

@@ -37,6 +37,7 @@ class CoreposVersionMixin(object):
         importers['CoreCustomer'] = CoreCustomerImporter
         importers['CoreCustomerShopper'] = CoreCustomerShopperImporter
         importers['CoreMember'] = CoreMemberImporter
+        importers['CoreMemberEquityPayment'] = CoreMemberEquityPaymentImporter
         importers['CoreStore'] = CoreStoreImporter
         importers['CoreDepartment'] = CoreDepartmentImporter
         importers['CoreSubdepartment'] = CoreSubdepartmentImporter
@@ -76,6 +77,14 @@ class CoreMemberImporter(base.VersionImporter):
         return model.CoreMember
 
 
+class CoreMemberEquityPaymentImporter(base.VersionImporter):
+
+    @property
+    def host_model_class(self):
+        model = self.config.get_model()
+        return model.CoreMemberEquityPayment
+
+
 class CoreStoreImporter(base.VersionImporter):
 
     @property