move barcodes

InvenTree/plugin/base/barcodes/barcode.py

@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+from django.urls import reverse, path, re_path
+from django.utils.translation import gettext_lazy as _
+
+from rest_framework.exceptions import ValidationError
+from rest_framework import permissions
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from stock.models import StockItem
+from stock.serializers import StockItemSerializer
+
+from plugin.builtin.barcodes.inventree_barcode import InvenTreeBarcodePlugin
+from plugin.base.barcodes.mixins import hash_barcode
+from plugin import registry
+
+
+class BarcodeScan(APIView):
+    """
+    Endpoint for handling generic barcode scan requests.
+
+    Barcode data are decoded by the client application,
+    and sent to this endpoint (as a JSON object) for validation.
+
+    A barcode could follow the internal InvenTree barcode format,
+    or it could match to a third-party barcode format (e.g. Digikey).
+
+    When a barcode is sent to the server, the following parameters must be provided:
+
+    - barcode: The raw barcode data
+
+    plugins:
+    Third-party barcode formats may be supported using 'plugins'
+    (more information to follow)
+
+    hashing:
+    Barcode hashes are calculated using MD5
+
+    """
+
+    permission_classes = [
+        permissions.IsAuthenticated,
+    ]
+
+    def post(self, request, *args, **kwargs):
+        """
+        Respond to a barcode POST request
+        """
+
+        data = request.data
+
+        if 'barcode' not in data:
+            raise ValidationError({'barcode': _('Must provide barcode_data parameter')})
+
+        plugins = registry.with_mixin('barcode')
+
+        barcode_data = data.get('barcode')
+
+        # Ensure that the default barcode handler is installed
+        plugins.append(InvenTreeBarcodePlugin())
+
+        # Look for a barcode plugin which knows how to deal with this barcode
+        plugin = None
+
+        for current_plugin in plugins:
+            # TODO @matmair make simpler after InvenTree 0.7.0 release
+            current_plugin.init(barcode_data)
+
+            if current_plugin.validate():
+                plugin = current_plugin
+                break
+
+        match_found = False
+        response = {}
+
+        response['barcode_data'] = barcode_data
+
+        # A plugin has been found!
+        if plugin is not None:
+
+            # Try to associate with a stock item
+            item = plugin.getStockItem()
+
+            if item is None:
+                item = plugin.getStockItemByHash()
+
+            if item is not None:
+                response['stockitem'] = plugin.renderStockItem(item)
+                response['url'] = reverse('stock-item-detail', kwargs={'pk': item.id})
+                match_found = True
+
+            # Try to associate with a stock location
+            loc = plugin.getStockLocation()
+
+            if loc is not None:
+                response['stocklocation'] = plugin.renderStockLocation(loc)
+                response['url'] = reverse('stock-location-detail', kwargs={'pk': loc.id})
+                match_found = True
+
+            # Try to associate with a part
+            part = plugin.getPart()
+
+            if part is not None:
+                response['part'] = plugin.renderPart(part)
+                response['url'] = reverse('part-detail', kwargs={'pk': part.id})
+                match_found = True
+
+            response['hash'] = plugin.hash()
+            response['plugin'] = plugin.name
+
+        # No plugin is found!
+        # However, the hash of the barcode may still be associated with a StockItem!
+        else:
+            result_hash = hash_barcode(barcode_data)
+
+            response['hash'] = result_hash
+            response['plugin'] = None
+
+            # Try to look for a matching StockItem
+            try:
+                item = StockItem.objects.get(uid=result_hash)
+                serializer = StockItemSerializer(item, part_detail=True, location_detail=True, supplier_part_detail=True)
+                response['stockitem'] = serializer.data
+                response['url'] = reverse('stock-item-detail', kwargs={'pk': item.id})
+                match_found = True
+            except StockItem.DoesNotExist:
+                pass
+
+        if not match_found:
+            response['error'] = _('No match found for barcode data')
+        else:
+            response['success'] = _('Match found for barcode data')
+
+        return Response(response)
+
+
+class BarcodeAssign(APIView):
+    """
+    Endpoint for assigning a barcode to a stock item.
+
+    - This only works if the barcode is not already associated with an object in the database
+    - If the barcode does not match an object, then the barcode hash is assigned to the StockItem
+    """
+
+    permission_classes = [
+        permissions.IsAuthenticated
+    ]
+
+    def post(self, request, *args, **kwargs):
+
+        data = request.data
+
+        if 'barcode' not in data:
+            raise ValidationError({'barcode': _('Must provide barcode_data parameter')})
+
+        if 'stockitem' not in data:
+            raise ValidationError({'stockitem': _('Must provide stockitem parameter')})
+
+        barcode_data = data['barcode']
+
+        try:
+            item = StockItem.objects.get(pk=data['stockitem'])
+        except (ValueError, StockItem.DoesNotExist):
+            raise ValidationError({'stockitem': _('No matching stock item found')})
+
+        plugins = registry.with_mixin('barcode')
+
+        plugin = None
+
+        for current_plugin in plugins:
+            # TODO @matmair make simpler after InvenTree 0.7.0 release
+            current_plugin.init(barcode_data)
+
+            if current_plugin.validate():
+                plugin = current_plugin
+                break
+
+        match_found = False
+
+        response = {}
+
+        response['barcode_data'] = barcode_data
+
+        # Matching plugin was found
+        if plugin is not None:
+
+            result_hash = plugin.hash()
+            response['hash'] = result_hash
+            response['plugin'] = plugin.name
+
+            # Ensure that the barcode does not already match a database entry
+
+            if plugin.getStockItem() is not None:
+                match_found = True
+                response['error'] = _('Barcode already matches Stock Item')
+
+            if plugin.getStockLocation() is not None:
+                match_found = True
+                response['error'] = _('Barcode already matches Stock Location')
+
+            if plugin.getPart() is not None:
+                match_found = True
+                response['error'] = _('Barcode already matches Part')
+
+            if not match_found:
+                item = plugin.getStockItemByHash()
+
+                if item is not None:
+                    response['error'] = _('Barcode hash already matches Stock Item')
+                    match_found = True
+
+        else:
+            result_hash = hash_barcode(barcode_data)
+
+            response['hash'] = result_hash
+            response['plugin'] = None
+
+            # Lookup stock item by hash
+            try:
+                item = StockItem.objects.get(uid=result_hash)
+                response['error'] = _('Barcode hash already matches Stock Item')
+                match_found = True
+            except StockItem.DoesNotExist:
+                pass
+
+        if not match_found:
+            response['success'] = _('Barcode associated with Stock Item')
+
+            # Save the barcode hash
+            item.uid = response['hash']
+            item.save()
+
+            serializer = StockItemSerializer(item, part_detail=True, location_detail=True, supplier_part_detail=True)
+            response['stockitem'] = serializer.data
+
+        return Response(response)
+
+
+barcode_api_urls = [
+
+    path('link/', BarcodeAssign.as_view(), name='api-barcode-link'),
+
+    # Catch-all performs barcode 'scan'
+    re_path(r'^.*$', BarcodeScan.as_view(), name='api-barcode-scan'),
+]

InvenTree/plugin/base/barcodes/mixins.py

@@ -0,0 +1,146 @@
+"""
+Plugin mixin classes for barcode plugin
+"""
+import string
+import hashlib
+
+from stock.models import StockItem
+from stock.serializers import StockItemSerializer, LocationSerializer
+from part.serializers import PartSerializer
+
+
+def hash_barcode(barcode_data):
+    """
+    Calculate an MD5 hash of barcode data.
+
+    HACK: Remove any 'non printable' characters from the hash,
+          as it seems browers will remove special control characters...
+
+    TODO: Work out a way around this!
+    """
+
+    barcode_data = str(barcode_data).strip()
+
+    printable_chars = filter(lambda x: x in string.printable, barcode_data)
+
+    barcode_data = ''.join(list(printable_chars))
+
+    result_hash = hashlib.md5(str(barcode_data).encode())
+    return str(result_hash.hexdigest())
+
+
+class BarcodeMixin:
+    """
+    Mixin that enables barcode handeling
+    Custom barcode plugins should use and extend this mixin as necessary.
+    """
+    ACTION_NAME = ""
+
+    class MixinMeta:
+        """
+        meta options for this mixin
+        """
+        MIXIN_NAME = 'Barcode'
+
+    def __init__(self):
+        super().__init__()
+        self.add_mixin('barcode', 'has_barcode', __class__)
+
+    @property
+    def has_barcode(self):
+        """
+        Does this plugin have everything needed to process a barcode
+        """
+        return True
+
+    def init(self, barcode_data):
+        """
+        Initialize the BarcodePlugin instance
+
+        Args:
+            barcode_data - The raw barcode data
+        """
+
+        self.data = barcode_data
+
+    def getStockItem(self):
+        """
+        Attempt to retrieve a StockItem associated with this barcode.
+        Default implementation returns None
+        """
+
+        return None  # pragma: no cover
+
+    def getStockItemByHash(self):
+        """
+        Attempt to retrieve a StockItem associated with this barcode,
+        based on the barcode hash.
+        """
+
+        try:
+            item = StockItem.objects.get(uid=self.hash())
+            return item
+        except StockItem.DoesNotExist:
+            return None
+
+    def renderStockItem(self, item):
+        """
+        Render a stock item to JSON response
+        """
+
+        serializer = StockItemSerializer(item, part_detail=True, location_detail=True, supplier_part_detail=True)
+        return serializer.data
+
+    def getStockLocation(self):
+        """
+        Attempt to retrieve a StockLocation associated with this barcode.
+        Default implementation returns None
+        """
+
+        return None  # pragma: no cover
+
+    def renderStockLocation(self, loc):
+        """
+        Render a stock location to a JSON response
+        """
+
+        serializer = LocationSerializer(loc)
+        return serializer.data
+
+    def getPart(self):
+        """
+        Attempt to retrieve a Part associated with this barcode.
+        Default implementation returns None
+        """
+
+        return None  # pragma: no cover
+
+    def renderPart(self, part):
+        """
+        Render a part to JSON response
+        """
+
+        serializer = PartSerializer(part)
+        return serializer.data
+
+    def hash(self):
+        """
+        Calculate a hash for the barcode data.
+        This is supposed to uniquely identify the barcode contents,
+        at least within the bardcode sub-type.
+
+        The default implementation simply returns an MD5 hash of the barcode data,
+        encoded to a string.
+
+        This may be sufficient for most applications, but can obviously be overridden
+        by a subclass.
+
+        """
+
+        return hash_barcode(self.data)
+
+    def validate(self):
+        """
+        Default implementation returns False
+        """
+        return False  # pragma: no cover