Moved import_catalogue into the partner app

examples/vanilla/settings.py

@@ -200,7 +200,6 @@ INSTALLED_APPS = (
     'oscar.apps.promotions',
     'oscar.apps.reports',
     'oscar.apps.search',
-    'oscar.apps.catalogue_import',
     'pyzen',
 )
 

oscar/apps/catalogue_import/exceptions.py

@@ -1,2 +0,0 @@
-class CatalogueImportException(Exception):
-    pass

oscar/apps/catalogue_import/tests/__init__.py

@@ -1,5 +0,0 @@
-from oscar.apps.catalogue_import.tests.command import *
-
-__test__ = {
-    'command': [command]
-}

oscar/apps/catalogue_import/utils.py

@@ -1,124 +0,0 @@
-import os
-import csv
-import sys
-from decimal import Decimal as D
-
-from oscar.core.loading import import_module
-
-import_module('catalogue_import.exceptions', ['CatalogueImportException'], locals())
-import_module('product.models', ['ItemClass', 'Item'], locals())
-import_module('partner.models', ['Partner', 'StockRecord'], locals())
-
-
-class Importer(object):
-    u"""A catalogue importer object"""
-    
-    _flush = False
-    
-    def __init__(self, logger, delimiter=",", flush=False):
-        self.logger = logger
-        self._delimiter = delimiter
-        self._flush = flush
-        if flush:
-            self.logger.info(" - Flushing product data before import")
-    
-    def handle(self, file_path=None):
-        u"""Handles the actual import process"""
-        if not file_path:
-            raise CatalogueImportException("No file path supplied")
-        
-        if self._flush is True:
-            self._flush_product_data()
-        Validator().validate(file_path)
-        self._import(file_path)
-        
-    def _flush_product_data(self):
-        u"""Flush out product and stock models"""
-        ItemClass.objects.all().delete()
-        Item.objects.all().delete()
-        Partner.objects.all().delete()
-        StockRecord.objects.all().delete()
-
-    def _import(self, file_path):
-        u"""Imports given file"""
-        stats = {'new_items': 0,
-                 'updated_items': 0
-                 }
-        row_number = 0
-        for row in csv.reader(open(file_path,'rb'), delimiter=self._delimiter, quotechar='"', escapechar='\\'):
-            row_number += 1
-            self._import_row(row_number, row, stats)
-        msg = "\tNew items: %d\n\tUpdated items: %d" % (stats['new_items'], stats['updated_items'])
-        self.logger.info(msg)
-    
-    def _import_row(self, row_number, row, stats):
-        if len(row) != 4 and len(row) != 8:
-            self.logger.error("Row number %d has an invalid number of fields, skipping..." % row_number)
-            return
-        item = self._create_item(*row[:4], stats=stats)
-        if len(row) == 8:
-            # With stock data
-            self._create_stockrecord(item, *row[4:8], stats=stats)
-            
-    def _create_item(self, upc, title, description, item_class, stats):
-        # Ignore any entries that are NULL
-        if description == 'NULL':
-            description = ''
-        
-        # Create item class and item
-        item_class,_ = ItemClass.objects.get_or_create(name=item_class)
-        try:
-            item = Item.objects.get(upc=upc)
-            stats['updated_items'] += 1
-        except Item.DoesNotExist:
-            item = Item()
-            stats['new_items'] += 1
-        item.upc = upc
-        item.title = title
-        item.description = description
-        item.item_class = item_class
-        item.save()
-        return item
-        
-    def _create_stockrecord(self, item, partner_name, partner_sku, price_excl_tax, num_in_stock, stats):            
-        # Create partner and stock record
-        partner, _ = Partner.objects.get_or_create(name=partner_name)
-        try:
-            stock = StockRecord.objects.get(partner_sku=partner_sku)
-        except StockRecord.DoesNotExist:
-            stock = StockRecord()
-        
-        stock.product = item
-        stock.partner = partner
-        stock.partner_sku = partner_sku
-        stock.price_excl_tax = D(price_excl_tax)
-        stock.num_in_stock = num_in_stock
-        stock.save()
-        
-        
-class Validator(object):
-    u"""A catalogue importer file object"""
-    
-    def validate(self, file_path):
-        self._exists(file_path)
-        self._is_file(file_path)
-        self._is_readable(file_path)
-    
-    def _exists(self, file_path):
-        u"""Check whether a file exists"""
-        if not os.path.exists(file_path):
-            raise CatalogueImportException("%s does not exist" % (file_path))
-        
-    def _is_file(self, file_path):
-        u"""Check whether file is actually a file type"""
-        if not os.path.isfile(file_path):
-            raise CatalogueImportException("%s is not a file" % (file_path))
-        
-    def _is_readable(self, file_path):
-        u"""Check file is readable"""
-        try:
-            f = open(file_path, 'r')
-            f.close()
-        except:
-            raise CatalogueImportException("%s is not readable" % (file_path))
-        

oscar/apps/partner/exceptions.py

@@ -1,2 +1,2 @@
-class StockImportException(Exception):
-    pass
+class ImportException(Exception):
+    pass

oscar/apps/catalogue_import/management/commands/import_catalogue.py → oscar/apps/partner/management/commands/import_catalogue.py

@@ -5,8 +5,8 @@ from optparse import make_option
 from django.core.management.base import BaseCommand, CommandError
 
 from oscar.core.loading import import_module
-import_module('catalogue_import.utils', ['Importer'], locals())
-import_module('catalogue_import.exceptions', ['CatalogueImportException'], locals())
+import_module('partner.utils', ['CatalogueImporter'], locals())
+import_module('partner.exceptions', ['CatalogueImportException'], locals())
 
 
 class Command(BaseCommand):
@@ -32,7 +32,7 @@ class Command(BaseCommand):
             raise CommandError("Please select a CSV file to import")
         
         logger.info("Starting catalogue import")
-        importer = Importer(logger, delimiter=options.get('delimiter'), flush=options.get('flush'))
+        importer = CatalogueImporter(logger, delimiter=options.get('delimiter'), flush=options.get('flush'))
         for file_path in args:
             logger.info(" - Importing records from '%s'" % file_path)
             try:

oscar/apps/partner/management/commands/import_stock.py

@@ -0,0 +1,44 @@
+import logging
+import sys
+import os
+from optparse import make_option
+
+from django.core.management.base import BaseCommand, CommandError
+
+from oscar.core.loading import import_module
+import_module('partner.utils', ['StockImporter'], locals())
+import_module('partner.exceptions', ['StockImportException'], locals())
+
+
+class Command(BaseCommand):
+    
+    args = '<partner> /path/to/file1.csv'
+    help = 'For updating stock for a partner based on a CSV file'
+    
+    option_list = BaseCommand.option_list + (
+        make_option('--delimiter',
+            dest='delimiter',
+            default=",",
+            help='Delimiter used within CSV file(s)'),
+        )
+
+    def handle(self, *args, **options):
+        if len(args) != 2:
+            raise CommandError('Command requires a partner and a path to a csv file') 
+        
+        logger = self._get_logger()
+        
+        try:
+            importer = StockImporter(logger, partner=args[0], delimiter=options.get('delimiter'))
+            logger.info("Starting stock import")
+            logger.info(" - Importing records from '%s'" % args[1])
+            importer.handle(args[1])
+        except StockImportException, e:
+            raise CommandError(str(e))
+            
+    def _get_logger(self):
+        logger = logging.getLogger('oscar.apps.partner.import_stock')
+        stream = logging.StreamHandler(self.stdout)
+        logger.addHandler(stream)
+        logger.setLevel(logging.DEBUG)
+        return logger

oscar/apps/partner/tests/__init__.py

@@ -0,0 +1,7 @@
+from oscar.apps.partner.tests.model_tests import *
+from oscar.apps.partner.tests.import_catalogue import *
+
+__test__ = {
+    'model_tests': [model_tests],
+    'import_catalogue': [import_catalogue],
+}

oscar/apps/catalogue_import/tests/command.py → oscar/apps/partner/tests/import_catalogue.py

@@ -3,8 +3,8 @@ from decimal import Decimal as D
 from django.test import TestCase
 import logging
 
-from oscar.apps.catalogue_import.utils import Importer
-from oscar.apps.catalogue_import.exceptions import CatalogueImportException
+from oscar.apps.partner.utils import CatalogueImporter
+from oscar.apps.partner.exceptions import ImportException
 from oscar.apps.product.models import ItemClass, Item
 from oscar.apps.partner.models import Partner, StockRecord
 from oscar.test.helpers import create_product
@@ -23,21 +23,21 @@ logger.addHandler(NullHandler())
 class CommandEdgeCasesTest(TestCase):
 
     def setUp(self):
-        self.importer = Importer(logger)
+        self.importer = CatalogueImporter(logger)
 
     def test_sending_no_file_argument_raises_exception(self):
         self.importer.afile = None
-        with self.assertRaises(CatalogueImportException):
+        with self.assertRaises(ImportException):
             self.importer.handle()
 
     def test_sending_directory_as_file_raises_exception(self):
         self.importer.afile = "/tmp"
-        with self.assertRaises(CatalogueImportException):
+        with self.assertRaises(ImportException):
             self.importer.handle()
 
     def test_importing_nonexistant_file_raises_exception(self):
         self.importer.afile = "/tmp/catalogue-import.zgvsfsdfsd"
-        with self.assertRaises(CatalogueImportException):
+        with self.assertRaises(ImportException):
             self.importer.handle()
 
 
@@ -51,7 +51,7 @@ class ImportSmokeTest(TestCase):
     
     
     def setUp(self):
-        self.importer = Importer(logger)
+        self.importer = CatalogueImporter(logger)
         self.importer.handle(TEST_BOOKS_CSV)
         self.item = Item.objects.get(upc='9780115531446')
         
@@ -101,7 +101,7 @@ class ImportSmokeTest(TestCase):
 class ImportSemicolonDelimitedFileTest(TestCase):
     
     def setUp(self):
-        self.importer = Importer(logger, delimiter=";")
+        self.importer = CatalogueImporter(logger, delimiter=";")
         
     def test_import(self):
         self.importer.handle(TEST_BOOKS_SEMICOLON_CSV)
@@ -110,7 +110,7 @@ class ImportSemicolonDelimitedFileTest(TestCase):
 class ImportWithFlushTest(TestCase):
     
     def setUp(self):
-        self.importer = Importer(logger, flush=True)
+        self.importer = CatalogueImporter(logger, flush=True)
 
     def test_items_are_flushed_by_importer(self):
         upc = "0000000000000"

oscar/apps/partner/tests.py → oscar/apps/partner/tests/model_tests.py

@@ -9,6 +9,7 @@ from oscar.apps.product.models import Item, ItemClass
 from oscar.apps.partner.models import Partner, StockRecord
 from oscar.test.helpers import create_product
 
+
 class DummyWrapper(object):
     
     def availability(self, stockrecord):
@@ -50,6 +51,7 @@ class DefaultWrapperTests(unittest.TestCase):
         date = datetime.date.today() + datetime.timedelta(days=7)
         self.assertEquals(date, product.stockrecord.dispatch_date)
     
+    
 class CustomWrapperTests(unittest.TestCase):    
 
     def setUp(self):

oscar/apps/partner/utils.py

@@ -5,10 +5,12 @@ from decimal import Decimal as D
 
 from oscar.core.loading import import_module
 
-import_module('partner.exceptions', ['StockImportException'], locals())
+import_module('partner.exceptions', ['ImportException'], locals())
 import_module('partner.models', ['Partner', 'StockRecord'], locals())
+import_module('product.models', ['ItemClass', 'Item'], locals())
 
-class Importer(object):
+
+class StockImporter(object):
     
     def __init__(self, logger, partner, delimiter):
         self.logger = logger
@@ -17,12 +19,12 @@ class Importer(object):
         try:
             self._partner = Partner.objects.get(name=partner)
         except Partner.DoesNotExist:
-            raise StockImportException("Partner named '%s' does not exist" % partner)
+            raise ImportException("Partner named '%s' does not exist" % partner)
     
     def handle(self, file_path=None):
         u"""Handles the actual import process"""
         if not file_path:
-            raise StockImportException("No file path supplied")
+            raise ImportException("No file path supplied")
         Validator().validate(file_path)
         self._import(file_path)
 
@@ -77,6 +79,93 @@ class Importer(object):
             stats['updated_items'] += 1
         else:
             stats['unchanged_items'] += 1
+
+
+class CatalogueImporter(object):
+    u"""A catalogue importer object"""
+    
+    _flush = False
+    
+    def __init__(self, logger, delimiter=",", flush=False):
+        self.logger = logger
+        self._delimiter = delimiter
+        self._flush = flush
+        if flush:
+            self.logger.info(" - Flushing product data before import")
+    
+    def handle(self, file_path=None):
+        u"""Handles the actual import process"""
+        if not file_path:
+            raise ImportException("No file path supplied")
+        
+        if self._flush is True:
+            self._flush_product_data()
+        Validator().validate(file_path)
+        self._import(file_path)
+        
+    def _flush_product_data(self):
+        u"""Flush out product and stock models"""
+        ItemClass.objects.all().delete()
+        Item.objects.all().delete()
+        Partner.objects.all().delete()
+        StockRecord.objects.all().delete()
+
+    def _import(self, file_path):
+        u"""Imports given file"""
+        stats = {'new_items': 0,
+                 'updated_items': 0
+                 }
+        row_number = 0
+        for row in csv.reader(open(file_path,'rb'), delimiter=self._delimiter, quotechar='"', escapechar='\\'):
+            row_number += 1
+            self._import_row(row_number, row, stats)
+        msg = "\tNew items: %d\n\tUpdated items: %d" % (stats['new_items'], stats['updated_items'])
+        self.logger.info(msg)
+    
+    def _import_row(self, row_number, row, stats):
+        if len(row) != 4 and len(row) != 8:
+            self.logger.error("Row number %d has an invalid number of fields (%d), skipping..." % (row_number, len(row)))
+            return
+        item = self._create_item(*row[:4], stats=stats)
+        if len(row) == 8:
+            # With stock data
+            self._create_stockrecord(item, *row[4:8], stats=stats)
+            
+    def _create_item(self, upc, title, description, item_class, stats):
+        # Ignore any entries that are NULL
+        if description == 'NULL':
+            description = ''
+        
+        # Create item class and item
+        item_class,_ = ItemClass.objects.get_or_create(name=item_class)
+        try:
+            item = Item.objects.get(upc=upc)
+            stats['updated_items'] += 1
+        except Item.DoesNotExist:
+            item = Item()
+            stats['new_items'] += 1
+        item.upc = upc
+        item.title = title
+        item.description = description
+        item.item_class = item_class
+        item.save()
+        return item
+        
+    def _create_stockrecord(self, item, partner_name, partner_sku, price_excl_tax, num_in_stock, stats):            
+        # Create partner and stock record
+        partner, _ = Partner.objects.get_or_create(name=partner_name)
+        try:
+            stock = StockRecord.objects.get(partner_sku=partner_sku)
+        except StockRecord.DoesNotExist:
+            stock = StockRecord()
+        
+        stock.product = item
+        stock.partner = partner
+        stock.partner_sku = partner_sku
+        stock.price_excl_tax = D(price_excl_tax)
+        stock.num_in_stock = num_in_stock
+        stock.save()    
+    
         
 class Validator(object):
     def validate(self, file_path):
@@ -87,12 +176,12 @@ class Validator(object):
     def _exists(self, file_path):
         u"""Check whether a file exists"""
         if not os.path.exists(file_path):
-            raise StockImportException("%s does not exist" % (file_path))
+            raise ImportException("%s does not exist" % (file_path))
         
     def _is_file(self, file_path):
         u"""Check whether file is actually a file type"""
         if not os.path.isfile(file_path):
-            raise StockImportException("%s is not a file" % (file_path))
+            raise ImportException("%s is not a file" % (file_path))
         
     def _is_readable(self, file_path):
         u"""Check file is readable"""
@@ -100,4 +189,4 @@ class Validator(object):
             f = open(file_path, 'r')
             f.close()
         except:
-            raise StockImportException("%s is not readable" % (file_path))
+            raise ImportException("%s is not readable" % (file_path))

oscar/tests.py

@@ -10,6 +10,5 @@ from oscar.apps.shipping.tests import *
 from oscar.apps.customer.tests import *
 from oscar.apps.discount.tests import *
 from oscar.apps.promotions.tests import *
-from oscar.apps.catalogue_import.tests import *
 
 from oscar.core.tests import *