206 lines
7.3 KiB
Python
206 lines
7.3 KiB
Python
# -*- coding: utf-8; -*-
|
|
################################################################################
|
|
#
|
|
# Rattail -- Retail Software Framework
|
|
# Copyright © 2010-2021 Lance Edgar
|
|
#
|
|
# This file is part of Rattail.
|
|
#
|
|
# Rattail is free software: you can redistribute it and/or modify it under the
|
|
# terms of the GNU General Public License as published by the Free Software
|
|
# Foundation, either version 3 of the License, or (at your option) any later
|
|
# version.
|
|
#
|
|
# Rattail is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
# details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License along with
|
|
# Rattail. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
################################################################################
|
|
"""
|
|
Rattail -> WooCommerce importing
|
|
"""
|
|
|
|
from rattail import importing
|
|
from rattail.db import model
|
|
from rattail.util import OrderedDict
|
|
from rattail_woocommerce.db.model import WooCacheProduct
|
|
from rattail_woocommerce.woocommerce import importing as woocommerce_importing
|
|
|
|
|
|
class FromRattailToWooCommerce(importing.FromRattailHandler):
|
|
"""
|
|
Rattail -> WooCommerce import handler
|
|
"""
|
|
local_title = "WooCommerce"
|
|
direction = 'export'
|
|
|
|
# necessary to save new WooCacheProduct records along the way
|
|
# (since they really are created immediately in Woo via API)
|
|
commit_host_partial = True
|
|
|
|
@property
|
|
def host_title(self):
|
|
return self.config.app_title(default="Rattail")
|
|
|
|
def get_importers(self):
|
|
importers = OrderedDict()
|
|
importers['Product'] = ProductImporter
|
|
return importers
|
|
|
|
|
|
class FromRattail(importing.FromSQLAlchemy):
|
|
"""
|
|
Base class for WooCommerce -> Rattail importers
|
|
"""
|
|
|
|
|
|
class ProductImporter(FromRattail, woocommerce_importing.model.ProductImporter):
|
|
"""
|
|
Product data importer
|
|
"""
|
|
host_model_class = model.Product
|
|
key = 'id'
|
|
supported_fields = [
|
|
'id',
|
|
'name',
|
|
'sku',
|
|
'regular_price',
|
|
'sale_price',
|
|
'date_on_sale_from_gmt',
|
|
'date_on_sale_to_gmt',
|
|
]
|
|
|
|
def setup(self):
|
|
super(ProductImporter, self).setup()
|
|
self.init_woo_id_counter()
|
|
self.establish_cache_importer()
|
|
|
|
def datasync_setup(self):
|
|
super(ProductImporter, self).datasync_setup()
|
|
self.init_woo_id_counter()
|
|
self.establish_cache_importer()
|
|
|
|
def init_woo_id_counter(self):
|
|
self.next_woo_id = 1
|
|
|
|
def establish_cache_importer(self):
|
|
from rattail_woocommerce.importing.woocommerce import WooCacheProductImporter
|
|
|
|
# we'll use this importer to update our local cache
|
|
self.cache_importer = WooCacheProductImporter(config=self.config)
|
|
self.cache_importer.session = self.host_session
|
|
|
|
def normalize_host_object(self, product):
|
|
|
|
woo_id = product.woocommerce_id
|
|
if not woo_id:
|
|
# note, we set to negative to ensure it won't exist but is unique.
|
|
# but we will not actually try to push this value to Woo
|
|
woo_id = -self.next_woo_id
|
|
self.next_woo_id += 1
|
|
|
|
regular_price = ''
|
|
if product.regular_price and product.regular_price.price:
|
|
regular_price = '{:0.2f}'.format(product.regular_price.price)
|
|
|
|
sale_price = ''
|
|
if product.sale_price and product.sale_price.price:
|
|
sale_price = '{:0.2f}'.format(product.sale_price.price)
|
|
|
|
date_on_sale_from_gmt = '1900-01-01T00:00:00'
|
|
if product.sale_price and product.sale_price.starts:
|
|
dt = localtime(self.config, product.sale_price.starts,
|
|
from_utc=True, zoneinfo=False)
|
|
date_on_sale_from_gmt = dt.isoformat()
|
|
|
|
date_on_sale_to_gmt = '1900-01-01T00:00:00'
|
|
if product.sale_price and product.sale_price.starts:
|
|
dt = localtime(self.config, product.sale_price.starts,
|
|
from_utc=True, zoneinfo=False)
|
|
date_on_sale_to_gmt = dt.isoformat()
|
|
|
|
return {
|
|
'id': woo_id,
|
|
'name': (product.description or '').strip().replace('&', '&') or 'Product',
|
|
'sku': product.item_id,
|
|
'regular_price': regular_price,
|
|
'sale_price': sale_price,
|
|
'date_on_sale_from_gmt': date_on_sale_from_gmt,
|
|
'date_on_sale_to_gmt': date_on_sale_to_gmt,
|
|
}
|
|
|
|
def create_object(self, key, host_data):
|
|
|
|
# push create to API as normal
|
|
api_product = super(ProductImporter, self).create_object(key, host_data)
|
|
|
|
# also create local cache record, if running in datasync
|
|
if self.batch_size == 1: # datasync
|
|
self.update_woocache(api_product)
|
|
|
|
return api_product
|
|
|
|
def update_object(self, api_product, host_data, local_data=None, **kwargs):
|
|
|
|
# push update to API as normal
|
|
api_product = super(ProductImporter, self).update_object(api_product, host_data,
|
|
local_data=local_data,
|
|
**kwargs)
|
|
|
|
# also update local cache record, if running in datasync
|
|
if self.batch_size == 1:
|
|
self.update_woocache(api_product)
|
|
|
|
return api_product
|
|
|
|
def post_products_batch(self):
|
|
|
|
# first post batch to API as normal
|
|
response = super(ProductImporter, self).post_products_batch()
|
|
data = response.json()
|
|
|
|
def create_cache(api_product, i):
|
|
self.update_woocache(api_product)
|
|
|
|
self.progress_loop(create_cache, data.get('create', []),
|
|
message="Updating cache for created items")
|
|
self.host_session.flush()
|
|
|
|
def update_cache(api_product, i):
|
|
# re-fetch the api_product to make sure we have right info. for
|
|
# some reason at least one field is represented differently, when
|
|
# we fetch the record vs. how it appears in the batch response.
|
|
api_product = self.api.get('products/{}'.format(api_product['id']))\
|
|
.json()
|
|
self.update_woocache(api_product)
|
|
|
|
self.progress_loop(update_cache, data.get('update', []),
|
|
message="Updating cache for updated items")
|
|
self.host_session.flush()
|
|
|
|
return response
|
|
|
|
def update_woocache(self, api_product):
|
|
|
|
# normalize data and process importer update
|
|
normal = self.cache_importer.normalize_host_object(api_product)
|
|
key = self.cache_importer.get_key(normal)
|
|
cache_product = self.cache_importer.get_local_object(key)
|
|
if cache_product:
|
|
cache_normal = self.cache_importer.normalize_local_object(cache_product)
|
|
cache_product = self.cache_importer.update_object(
|
|
cache_product, normal, local_data=cache_normal)
|
|
else:
|
|
cache_product = self.cache_importer.create_object(key, normal)
|
|
|
|
# update cached woo_id too, if we can
|
|
self.host_session.flush()
|
|
if cache_product and cache_product.product:
|
|
product = cache_product.product
|
|
if product.woocommerce_id != api_product['id']:
|
|
product.woocommerce_id = api_product['id']
|