Refactored image import

.gitignore

@@ -13,7 +13,7 @@ docs/build/*
 examples/.coverage
 assets/*
 nbproject
-examples/defaultshop/assets/*
+examples/vanilla/assets/*
 oscar/bin
 oscar/include
 oscar/lib

oscar/apps/image/exceptions.py

@@ -1,2 +1,6 @@
 class ImageImportException(Exception):
+    pass
+
+
+class IdenticalImageException(Exception):
     pass

oscar/apps/image/management/commands/import_images.py

@@ -23,25 +23,15 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
-        logger = self._get_logger()
-        logger.info("Starting image import...")
-
         if len(args) != 1:
-            raise CommandError('Command requires a path to a single folder')        
-        
-        dirname = args[0]
+            raise CommandError('Command requires a path to a single folder') 
         
-        all_files = [f for f in os.listdir(dirname) if os.path.isfile(os.path.join(dirname,f))]
+        logger = self._get_logger()
+        logger.info("Starting image import...")       
         
+        dirname = args[0]
         importer = Importer(logger, field=options.get('filename'))
-        
-        for f in all_files:
-            ext = os.path.splitext(f)[1]
-            if ext in ['.jpeg','.jpg','.gif','.png']:
-                try:
-                    importer.handle(f,dirname)
-                except ImageImportException, e:
-                    raise CommandError(str(e))
+        importer.handle(dirname)
             
     def _get_logger(self):
         logger = logging.getLogger('oscar.apps.image')

oscar/apps/image/utils.py

@@ -1,56 +1,84 @@
 import os
-
 from PIL import Image as PImage
 
 from django.core.files import File
 from django.core.exceptions import FieldError
 
 from oscar.core.loading import import_module
-
-import_module('image.exceptions', ['ImageImportException'], locals())
+import_module('image.exceptions', ['ImageImportException', 'IdenticalImageException'], locals())
 import_module('product.models', ['Item'], locals())
 import_module('image.models', ['Image'], locals())
 
+
 class Importer(object):
     
+    allowed_extensions = ['.jpeg','.jpg','.gif','.png']
+    
     def __init__(self, logger, field):
         self.logger = logger
         self._field = field
         
-    def handle(self, filename, dirname):
+    def handle(self, dirname):
+        stats = {
+            'num_processed': 0,
+            'num_skipped': 0,
+            'num_invalid': 0         
+        }
+        for filename in self._get_image_files(dirname):
+            try:
+                lookup_value = self._get_lookup_value_from_filename(filename)
+                self._process_image(dirname, filename, lookup_value)
+                stats['num_processed'] += 1
+            except Item.MultipleObjectsReturned:
+                self.logger.warning("Multiple products matching %s='%s', skipping" % (self._field, lookup_value))
+                stats['num_skipped'] += 1
+            except Item.DoesNotExist:
+                self.logger.warning("No item matching %s='%s'" % (self._field, lookup_value))
+                stats['num_skipped'] += 1
+            except IdenticalImageException:
+                self.logger.warning(" - Identical image already exists for %s='%s', skipping" % (self._field, lookup_value))
+                stats['num_skipped'] += 1
+            except IOError:
+                raise ImageImportException('%s is not a valid image' % filename)    
+                stats['num_invalid'] += 1
+            except FieldError, e:
+                raise ImageImportException(e)
+                self._process_image(dirname, filename)
+        self.logger.info("Finished image import: %(num_processed)d imported, %(num_skipped)d skipped" % stats)
         
-        f = os.path.join(dirname,filename)
+    def _get_image_files(self, dirname):
+        filenames = []
+        for filename in os.listdir(dirname):
+            ext = os.path.splitext(filename)[1]
+            if os.path.isfile(os.path.join(dirname, filename)) and ext in self.allowed_extensions:
+                filenames.append(filename)
+        return filenames
+                
+    def _process_image(self, dirname, filename, lookup_value):
+        file_path = os.path.join(dirname, filename)
+        trial_image = PImage.open(file_path)
+        trial_image.verify()
         
-        kwargs = {}
-        kwargs[self._field] = os.path.splitext(filename)[0]
+        kwargs = {self._field: lookup_value}
+        item = Item._default_manager.get(**kwargs)
         
-        try:
-            item = Item.objects.get(**kwargs)
-            
-            create_new = True
-            max_index = 0
+        new_data = open(file_path).read()
+        next_index = 0
+        for existing in item.images.all():
+            next_index = existing.display_order + 1
+            if new_data == existing.original.read():
+                raise IdenticalImageException()
             
-            new_data = open(f).read()
-            
-            trial_image = PImage.open(f)
-            trial_image.verify()
-
-            # if this image already exists for the Item, ignore it
-            for existing in item.images.all():
-                max_index = existing.display_order + 1
-                if new_data == existing.original.read():
-                    create_new = False
-                    break
-                
-            if create_new:
-                new_file = File(open(f))
-                im = Image(product=item,display_order=max_index)
-                im.original.save(filename, new_file, save=False)
-                im.save()
-                self.logger.info('image added to "%s"' % item)
-        except IOError:
-            raise ImageImportException('%s is not a valid image' % filename)
-        except (Item.MultipleObjectsReturned, Item.DoesNotExist):
-            pass # We don't care
-        except FieldError, e:
-            raise ImageImportException(e)
+        new_file = File(open(file_path))
+        im = Image(product=item, display_order=next_index)
+        im.original.save(filename, new_file, save=False)
+        im.save()
+        self.logger.info(' - Image added to "%s"' % item)
+        
+    def _fetch_item(self, filename):
+        kwargs = {self._field: self._get_lookup_value_from_filename(filename)}
+        return Item._default_manager.get(**kwargs)
+    
+    def _get_lookup_value_from_filename(self, filename):
+        return os.path.splitext(filename)[0]
+