From 434f563a41f6dcf78365c96e634d941b0c63e3ab Mon Sep 17 00:00:00 2001
From: Oliver <oliver.henry.walters@gmail.com>
Date: Fri, 4 Mar 2022 15:26:00 +1100
Subject: [PATCH 1/9] Adds API endpoint for "auto allocating" stock items
 against a build order.

- If stock exists in multiple locations, and the user "does not care" where to take from, simply iterate through and take
---
 InvenTree/build/api.py                      | 32 ++++++++
 InvenTree/build/models.py                   | 82 +++++++++++++++++++++
 InvenTree/build/serializers.py              | 48 ++++++++++++
 InvenTree/build/templates/build/detail.html | 19 ++++-
 InvenTree/part/models.py                    |  9 ++-
 InvenTree/templates/js/translated/build.js  | 29 ++++++++
 6 files changed, 214 insertions(+), 5 deletions(-)

diff --git a/InvenTree/build/api.py b/InvenTree/build/api.py
index 310d4d7f09..114268fa2b 100644
--- a/InvenTree/build/api.py
+++ b/InvenTree/build/api.py
@@ -322,6 +322,37 @@ class BuildFinish(generics.CreateAPIView):
         return ctx
 
 
+class BuildAutoAllocate(generics.CreateAPIView):
+    """
+    API endpoint for 'automatically' allocating stock against a build order.
+
+    - Only looks at 'untracked' parts
+    - If stock exists in a single location, easy!
+    - If user decides that stock items are "fungible", allocate against multiple stock items
+    - If the user wants to, allocate substite parts if the primary parts are not available.
+    """
+
+    queryset = Build.objects.none()
+
+    serializer_class = build.serializers.BuildAutoAllocationSerializer
+
+    def get_serializer_context(self):
+        """
+        Provide the Build object to the serializer context
+        """
+
+        context = super().get_serializer_context()
+
+        try:
+            context['build'] = Build.objects.get(pk=self.kwargs.get('pk', None))
+        except:
+            pass
+
+        context['request'] = self.request
+
+        return context
+
+
 class BuildAllocate(generics.CreateAPIView):
     """
     API endpoint to allocate stock items to a build order
@@ -477,6 +508,7 @@ build_api_urls = [
     # Build Detail
     url(r'^(?P<pk>\d+)/', include([
         url(r'^allocate/', BuildAllocate.as_view(), name='api-build-allocate'),
+        url(r'^auto-allocate/', BuildAutoAllocate.as_view(), name='api-build-auto-allocate'),
         url(r'^complete/', BuildOutputComplete.as_view(), name='api-build-output-complete'),
         url(r'^create-output/', BuildOutputCreate.as_view(), name='api-build-output-create'),
         url(r'^delete-outputs/', BuildOutputDelete.as_view(), name='api-build-output-delete'),
diff --git a/InvenTree/build/models.py b/InvenTree/build/models.py
index 01c2c781e9..e2a7be0c45 100644
--- a/InvenTree/build/models.py
+++ b/InvenTree/build/models.py
@@ -25,6 +25,8 @@ from markdownx.models import MarkdownxField
 from mptt.models import MPTTModel, TreeForeignKey
 from mptt.exceptions import InvalidMove
 
+from rest_framework import serializers
+
 from InvenTree.status_codes import BuildStatus, StockStatus, StockHistoryCode
 from InvenTree.helpers import increment, getSetting, normalize, MakeBarcode
 from InvenTree.models import InvenTreeAttachment, ReferenceIndexingMixin
@@ -823,6 +825,86 @@ class Build(MPTTModel, ReferenceIndexingMixin):
 
         self.save()
 
+    @transaction.atomic
+    def auto_allocate_stock(self, user, **kwargs):
+        """
+        Automatically allocate stock items against this build order,
+        following a number of 'guidelines':
+
+        - Only "untracked" BOM items are considered (tracked BOM items must be manually allocated)
+        - If a particular BOM item is already fully allocated, it is skipped
+        - Extract all available stock items for the BOM part
+            - If variant stock is allowed, extract stock for those too
+            - If substitute parts are available, extract stock for those also
+        - If a single stock item is found, we can allocate that and move on!
+        - If multiple stock items are found, we *may* be able to allocate:
+            - If the calling function has specified that items are interchangeable
+        """
+
+        location = kwargs.get('location', None)
+        interchangeable = kwargs.get('interchangeable', False)
+        substitutes = kwargs.get('substitutes', True)
+
+        # Get a list of all 'untracked' BOM items
+        for bom_item in self.untracked_bom_items:
+            
+            unallocated_quantity = self.unallocated_quantity(bom_item)
+
+            if unallocated_quantity <= 0:
+                # This BomItem is fully allocated, we can continue
+                continue
+
+            # Check which parts we can "use" (may include variants and substitutes)
+            available_parts = bom_item.get_valid_parts_for_allocation(
+                allow_variants=True,
+                allow_substitutes=substitutes,
+            )
+
+            # Look for available stock items
+            available_stock = StockModels.StockItem.objects.filter(StockModels.StockItem.IN_STOCK_FILTER)
+
+            # Filter by list of available parts
+            available_stock = available_stock.filter(
+                part__in=[p for p in available_parts],
+            )
+
+            if location:
+                # Filter only stock items located "below" the specified location
+                sublocations = location.get_descendants(include_self=True)
+                available_stock = available_stock.filter(location__in=[loc for loc in sublocations])
+
+            if available_stock.count() == 0:
+                # No stock items are available
+                continue
+            elif available_stock.count() == 1 or interchangeable:
+                # Either there is only a single stock item available,
+                # or all items are "interchangeable" and we don't care where we take stock from
+
+                for stock_item in available_stock:
+                    # How much of the stock item is "available" for allocation?
+                    quantity = min(unallocated_quantity, stock_item.unallocated_quantity())
+
+                    if quantity > 0:
+
+                        try:
+                            BuildItem.objects.create(
+                                build=self,
+                                bom_item=bom_item,
+                                stock_item=stock_item,
+                                quantity=quantity,
+                            )
+
+                            # Subtract the required quantity
+                            unallocated_quantity -= quantity
+
+                        except (ValidationError, serializers.ValidationError) as exc:
+                            # Catch model errors and re-throw as DRF errors
+                            raise ValidationError(detail=serializers.as_serializer_error(exc))
+
+                    if unallocated_quantity <= 0:
+                        # We have now fully-allocated this BomItem - no need to continue!
+                        break
+
     def required_quantity(self, bom_item, output=None):
         """
         Get the quantity of a part required to complete the particular build output.
diff --git a/InvenTree/build/serializers.py b/InvenTree/build/serializers.py
index 0a8964ee82..9085a25f30 100644
--- a/InvenTree/build/serializers.py
+++ b/InvenTree/build/serializers.py
@@ -709,6 +709,54 @@ class BuildAllocationSerializer(serializers.Serializer):
                     raise ValidationError(detail=serializers.as_serializer_error(exc))
 
 
+class BuildAutoAllocationSerializer(serializers.Serializer):
+    """
+    DRF serializer for auto allocating stock items against a build order
+    """
+
+    class Meta:
+        fields = [
+            'location',
+            'interchangeable',
+            'substitutes',
+        ]
+
+    location = serializers.PrimaryKeyRelatedField(
+        queryset=StockLocation.objects.all(),
+        many=False,
+        allow_null=True,
+        required=False,
+        label=_('Source Location'),
+        help_text=_('Stock location where parts are to be sourced (leave blank to take from any location)'),
+    )
+
+    interchangeable = serializers.BooleanField(
+        default=False,
+        label=_('Interchangeable Stock'),
+        help_text=_('Stock items in multiple locations can be used interchangeably'),
+    )
+
+    substitutes = serializers.BooleanField(
+        default=True,
+        label=_('Substitute Stock'),
+        help_text=_('Allow allocation of substitute parts'),
+    )
+
+    def save(self):
+
+        data = self.validated_data
+
+        request = self.context['request']
+        build = self.context['build']
+
+        build.auto_allocate_stock(
+            request.user,
+            location=data.get('location', None),
+            interchangeable=data['interchangeable'],
+            substitutes=data['substitutes'],
+        )
+
+
 class BuildItemSerializer(InvenTreeModelSerializer):
     """ Serializes a BuildItem object """
 
diff --git a/InvenTree/build/templates/build/detail.html b/InvenTree/build/templates/build/detail.html
index 1e31857ba5..ca909f82f7 100644
--- a/InvenTree/build/templates/build/detail.html
+++ b/InvenTree/build/templates/build/detail.html
@@ -177,7 +177,10 @@
                 <button class='btn btn-danger' type='button' id='btn-unallocate' title='{% trans "Unallocate stock" %}'>
                     <span class='fas fa-minus-circle'></span> {% trans "Unallocate Stock" %}
                 </button>
-                <button class='btn btn-success' type='button' id='btn-auto-allocate' title='{% trans "Allocate stock to build" %}'>
+                <button class='btn btn-primary' type='button' id='btn-auto-allocate' title='{% trans "Automatically allocate stock to build" %}'>
+                    <span class='fas fa-magic'></span> {% trans "Auto Allocate" %}
+                </button>
+                <button class='btn btn-success' type='button' id='btn-allocate' title='{% trans "Manually allocate stock to build" %}'>
                     <span class='fas fa-sign-in-alt'></span> {% trans "Allocate Stock" %}
                 </button>
                 <!--
@@ -485,8 +488,22 @@ function reloadTable() {
 }
 
 {% if build.active %}
+
 $("#btn-auto-allocate").on('click', function() {
 
+    autoAllocateStockToBuild(
+        {{ build.pk }},
+        [],
+        {
+            {% if build.take_from %}
+            location: {{ build.take_from.pk }},
+            {% endif %}
+        }
+    );
+});
+
+$("#btn-allocate").on('click', function() {
+
     var bom_items = $("#allocation-table-untracked").bootstrapTable("getData");
 
     var incomplete_bom_items = [];
diff --git a/InvenTree/part/models.py b/InvenTree/part/models.py
index 88a230c41c..fc09dcd042 100644
--- a/InvenTree/part/models.py
+++ b/InvenTree/part/models.py
@@ -2651,7 +2651,7 @@ class BomItem(models.Model, DataImportMixin):
     def get_api_url():
         return reverse('api-bom-list')
 
-    def get_valid_parts_for_allocation(self):
+    def get_valid_parts_for_allocation(self, allow_variants=True, allow_substitutes=True):
         """
         Return a list of valid parts which can be allocated against this BomItem:
 
@@ -2666,13 +2666,14 @@ class BomItem(models.Model, DataImportMixin):
         parts.add(self.sub_part)
 
         # Variant parts (if allowed)
-        if self.allow_variants:
+        if allow_variants and self.allow_variants:
             for variant in self.sub_part.get_descendants(include_self=False):
                 parts.add(variant)
 
         # Substitute parts
-        for sub in self.substitutes.all():
-            parts.add(sub.part)
+        if allow_substitutes:
+            for sub in self.substitutes.all():
+                parts.add(sub.part)
 
         return parts
 
diff --git a/InvenTree/templates/js/translated/build.js b/InvenTree/templates/js/translated/build.js
index 1272670f7b..7f5cd2b57a 100644
--- a/InvenTree/templates/js/translated/build.js
+++ b/InvenTree/templates/js/translated/build.js
@@ -20,6 +20,7 @@
 
 /* exported
     allocateStockToBuild,
+    autoAllocateStockToBuild,
     completeBuildOrder,
     createBuildOutput,
     editBuildOrder,
@@ -1844,6 +1845,34 @@ function allocateStockToBuild(build_id, part_id, bom_items, options={}) {
 }
 
 
+/**
+ * Automatically allocate stock items to a build
+ */
+function autoAllocateStockToBuild(build_id, bom_items=[], options={}) {
+
+    var html = '';
+
+    var fields = {
+        location: {
+            value: options.location,
+        },
+        interchangeable: {},
+        substitutes: {},
+    }
+
+    constructForm(`/api/build/${build_id}/auto-allocate/`, {
+        method: 'POST',
+        fields: fields,
+        title: '{% trans "Allocate Stock Items" %}',
+        confirm: true,
+        preFormContent: html,
+        onSuccess: function(response) {
+            // TODO - Reload the allocation table
+        }
+    });
+}
+
+
 /*
  * Display a table of Build orders
  */

From 71cd6c93d1121c4ddacbb251949fb066f72a3a62 Mon Sep 17 00:00:00 2001
From: Oliver <oliver.henry.walters@gmail.com>
Date: Fri, 4 Mar 2022 15:52:42 +1100
Subject: [PATCH 2/9] Assign sorting priority when allocating parts to a build
 order

1. Direct match parts
2. Variant parts
3. Any other parts (e.g. substitute parts)
---
 InvenTree/build/models.py                  | 25 ++++++++++++++++++++--
 InvenTree/templates/js/translated/build.js | 22 +++++++++++++++----
 2 files changed, 41 insertions(+), 6 deletions(-)

diff --git a/InvenTree/build/models.py b/InvenTree/build/models.py
index e2a7be0c45..15f1f252f2 100644
--- a/InvenTree/build/models.py
+++ b/InvenTree/build/models.py
@@ -848,6 +848,9 @@ class Build(MPTTModel, ReferenceIndexingMixin):
         # Get a list of all 'untracked' BOM items
         for bom_item in self.untracked_bom_items:
             
+            variant_parts = bom_item.sub_part.get_descendants(include_self=False)
+            substitute_parts = [p for p in bom_item.substitutes.all()]
+
             unallocated_quantity = self.unallocated_quantity(bom_item)
 
             if unallocated_quantity <= 0:
@@ -873,10 +876,28 @@ class Build(MPTTModel, ReferenceIndexingMixin):
                 sublocations = location.get_descendants(include_self=True)
                 available_stock = available_stock.filter(location__in=[loc for loc in sublocations])
 
-            if available_stock.count() == 0:
+            """
+            Next, we sort the available stock items with the following priority:
+            1. Direct part matches (+1)
+            2. Variant part matches (+2)
+            3. Substitute part matches (+3)
+
+            This ensures that allocation priority is first given to "direct" parts
+            """
+            def stock_sort(item):
+                if item.part == bom_item.sub_part:
+                    return 1
+                elif item.part in variant_parts:
+                    return 2
+                else:
+                    return 3
+                
+            available_stock = sorted(available_stock, key=stock_sort)
+
+            if len(available_stock) == 0:
                 # No stock items are available
                 continue
-            elif available_stock.count() == 1 or interchangeable:
+            elif len(available_stock) == 1 or interchangeable:
                 # Either there is only a single stock item available,
                 # or all items are "interchangeable" and we don't care where we take stock from
 
diff --git a/InvenTree/templates/js/translated/build.js b/InvenTree/templates/js/translated/build.js
index 7f5cd2b57a..0eb798aa28 100644
--- a/InvenTree/templates/js/translated/build.js
+++ b/InvenTree/templates/js/translated/build.js
@@ -1850,14 +1850,28 @@ function allocateStockToBuild(build_id, part_id, bom_items, options={}) {
  */
 function autoAllocateStockToBuild(build_id, bom_items=[], options={}) {
 
-    var html = '';
+    var html = `
+    <div class='alert alert-block alert-info'>
+    <strong>{% trans "Automatic Stock Allocation" %}</strong><br>
+    {% trans "Stock items will be automatically allocated to this build order, according to the provided guidelines" %}:
+    <ul>
+        <li>{% trans "If a location is specifed, stock will only be allocated from that location" %}</li>
+        <li>{% trans "If stock is considered interchangeable, it will be allocated from the first location it is found" %}</li>
+        <li>{% trans "If substitute stock is allowed, it will be used where stock of the primary part cannot be found" %}</li>
+    </ul>
+    </div>
+    `;
 
     var fields = {
         location: {
             value: options.location,
         },
-        interchangeable: {},
-        substitutes: {},
+        interchangeable: {
+            value: true,
+        },
+        substitutes: {
+            value: true,
+        },
     }
 
     constructForm(`/api/build/${build_id}/auto-allocate/`, {
@@ -1867,7 +1881,7 @@ function autoAllocateStockToBuild(build_id, bom_items=[], options={}) {
         confirm: true,
         preFormContent: html,
         onSuccess: function(response) {
-            // TODO - Reload the allocation table
+            $('#allocation-table-untracked').bootstrapTable('refresh');
         }
     });
 }

From 0bb0047fcd19582850b6300c7dfa63466285fa2e Mon Sep 17 00:00:00 2001
From: Oliver <oliver.henry.walters@gmail.com>
Date: Fri, 4 Mar 2022 16:27:50 +1100
Subject: [PATCH 3/9] Add unit tests for the auto_allocate_stock method

---
 InvenTree/build/models.py      |   7 +-
 InvenTree/build/serializers.py |   2 -
 InvenTree/build/test_build.py  | 120 +++++++++++++++++++++++++++++++--
 3 files changed, 119 insertions(+), 10 deletions(-)

diff --git a/InvenTree/build/models.py b/InvenTree/build/models.py
index 15f1f252f2..e4a5013b7b 100644
--- a/InvenTree/build/models.py
+++ b/InvenTree/build/models.py
@@ -826,7 +826,7 @@ class Build(MPTTModel, ReferenceIndexingMixin):
         self.save()
 
     @transaction.atomic
-    def auto_allocate_stock(self, user, **kwargs):
+    def auto_allocate_stock(self, **kwargs):
         """
         Automatically allocate stock items against this build order,
         following a number of 'guidelines':
@@ -847,9 +847,8 @@ class Build(MPTTModel, ReferenceIndexingMixin):
 
         # Get a list of all 'untracked' BOM items
         for bom_item in self.untracked_bom_items:
-            
+
             variant_parts = bom_item.sub_part.get_descendants(include_self=False)
-            substitute_parts = [p for p in bom_item.substitutes.all()]
 
             unallocated_quantity = self.unallocated_quantity(bom_item)
 
@@ -891,7 +890,7 @@ class Build(MPTTModel, ReferenceIndexingMixin):
                     return 2
                 else:
                     return 3
-                
+
             available_stock = sorted(available_stock, key=stock_sort)
 
             if len(available_stock) == 0:
diff --git a/InvenTree/build/serializers.py b/InvenTree/build/serializers.py
index 9085a25f30..ba43a079ff 100644
--- a/InvenTree/build/serializers.py
+++ b/InvenTree/build/serializers.py
@@ -746,11 +746,9 @@ class BuildAutoAllocationSerializer(serializers.Serializer):
 
         data = self.validated_data
 
-        request = self.context['request']
         build = self.context['build']
 
         build.auto_allocate_stock(
-            request.user,
             location=data.get('location', None),
             interchangeable=data['interchangeable'],
             substitutes=data['substitutes'],
diff --git a/InvenTree/build/test_build.py b/InvenTree/build/test_build.py
index 116c705f61..4c48d27853 100644
--- a/InvenTree/build/test_build.py
+++ b/InvenTree/build/test_build.py
@@ -8,11 +8,11 @@ from django.db.utils import IntegrityError
 from InvenTree import status_codes as status
 
 from build.models import Build, BuildItem, get_next_build_number
-from part.models import Part, BomItem
+from part.models import Part, BomItem, BomItemSubstitute
 from stock.models import StockItem
 
 
-class BuildTest(TestCase):
+class BuildTestBase(TestCase):
     """
     Run some tests to ensure that the Build model is working properly.
     """
@@ -107,13 +107,20 @@ class BuildTest(TestCase):
         )
 
         # Create some stock items to assign to the build
-        self.stock_1_1 = StockItem.objects.create(part=self.sub_part_1, quantity=1000)
+        self.stock_1_1 = StockItem.objects.create(part=self.sub_part_1, quantity=3)
         self.stock_1_2 = StockItem.objects.create(part=self.sub_part_1, quantity=100)
 
-        self.stock_2_1 = StockItem.objects.create(part=self.sub_part_2, quantity=5000)
+        self.stock_2_1 = StockItem.objects.create(part=self.sub_part_2, quantity=5)
+        self.stock_2_2 = StockItem.objects.create(part=self.sub_part_2, quantity=5)
+        self.stock_2_2 = StockItem.objects.create(part=self.sub_part_2, quantity=5)
+        self.stock_2_2 = StockItem.objects.create(part=self.sub_part_2, quantity=5)
+        self.stock_2_2 = StockItem.objects.create(part=self.sub_part_2, quantity=5)
 
         self.stock_3_1 = StockItem.objects.create(part=self.sub_part_3, quantity=1000)
 
+
+class BuildTest(BuildTestBase):
+
     def test_ref_int(self):
         """
         Test the "integer reference" field used for natural sorting
@@ -369,3 +376,108 @@ class BuildTest(TestCase):
 
         for output in outputs:
             self.assertFalse(output.is_building)
+
+
+class AutoAllocationTests(BuildTestBase):
+    """
+    Tests for auto allocating stock against a build order
+    """
+
+    def setUp(self):
+
+        super().setUp()
+
+        # Add a "substitute" part for bom_item_2
+        alt_part = Part.objects.create(
+            name="alt part",
+            description="An alternative part!",
+            component=True,
+        )
+
+        BomItemSubstitute.objects.create(
+            bom_item=self.bom_item_2,
+            part=alt_part,
+        )
+
+        StockItem.objects.create(
+            part=alt_part,
+            quantity=500,
+        )
+
+    def test_auto_allocate(self):
+        """
+        Run the 'auto-allocate' function. What do we expect to happen?
+
+        There are two "untracked" parts:
+            - sub_part_1 (quantity 5 per BOM = 50 required total) / 103 in stock (2 items)
+            - sub_part_2 (quantity 3 per BOM = 30 required total) / 25 in stock (5 items)
+
+        A "fully auto" allocation should allocate *all* of these stock items to the build
+        """
+
+        # No build item allocations have been made against the build
+        self.assertEqual(self.build.allocated_stock.count(), 0)
+
+        self.assertFalse(self.build.are_untracked_parts_allocated())
+
+        # Stock is not interchangeable, nothing will happen
+        self.build.auto_allocate_stock(
+            interchangeable=False,
+            substitutes=False,
+        )
+
+        self.assertFalse(self.build.are_untracked_parts_allocated())
+
+        self.assertEqual(self.build.allocated_stock.count(), 0)
+
+        self.assertFalse(self.build.is_bom_item_allocated(self.bom_item_1))
+        self.assertFalse(self.build.is_bom_item_allocated(self.bom_item_2))
+
+        self.assertEqual(self.build.unallocated_quantity(self.bom_item_1), 50)
+        self.assertEqual(self.build.unallocated_quantity(self.bom_item_2), 30)
+
+        # This time we expect stock to be allocated!
+        self.build.auto_allocate_stock(
+            interchangeable=True,
+            substitutes=False,
+        )
+
+        self.assertFalse(self.build.are_untracked_parts_allocated())
+
+        self.assertEqual(self.build.allocated_stock.count(), 7)
+
+        self.assertTrue(self.build.is_bom_item_allocated(self.bom_item_1))
+        self.assertFalse(self.build.is_bom_item_allocated(self.bom_item_2))
+
+        self.assertEqual(self.build.unallocated_quantity(self.bom_item_1), 0)
+        self.assertEqual(self.build.unallocated_quantity(self.bom_item_2), 5)
+
+        # This time, allow substitue parts to be used!
+        self.build.auto_allocate_stock(
+            interchangeable=True,
+            substitutes=True,
+        )
+
+        # self.assertTrue(self.build.are_untracked_parts_allocated())
+
+        # self.assertEqual(self.build.allocated_stock.count(), 8)
+        self.assertEqual(self.build.unallocated_quantity(self.bom_item_1), 0)
+        self.assertEqual(self.build.unallocated_quantity(self.bom_item_2), 0)
+
+        self.assertTrue(self.build.is_bom_item_allocated(self.bom_item_1))
+        self.assertTrue(self.build.is_bom_item_allocated(self.bom_item_2))
+
+    def test_fully_auto(self):
+        """
+        We should be able to auto-allocate against a build in a single go
+        """
+
+        self.build.auto_allocate_stock(
+            interchangeable=True,
+            substitutes=True
+        )
+
+        self.assertTrue(self.build.are_untracked_parts_allocated())
+
+        self.assertEqual(self.build.unallocated_quantity(self.bom_item_1), 0)
+        self.assertEqual(self.build.unallocated_quantity(self.bom_item_2), 0)

From d2027dc5905735f002cfdd9badd5d10432e4b19e Mon Sep 17 00:00:00 2001
From: Oliver <oliver.henry.walters@gmail.com>
Date: Fri, 4 Mar 2022 16:29:26 +1100
Subject: [PATCH 4/9] Increment API version

---
 InvenTree/InvenTree/version.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/InvenTree/InvenTree/version.py b/InvenTree/InvenTree/version.py
index 678f69d228..2908cda052 100644
--- a/InvenTree/InvenTree/version.py
+++ b/InvenTree/InvenTree/version.py
@@ -12,11 +12,15 @@ import common.models
 INVENTREE_SW_VERSION = "0.7.0 dev"
 
 # InvenTree API version
-INVENTREE_API_VERSION = 27
+INVENTREE_API_VERSION = 28
 
 """
 Increment this API version number whenever there is a significant change to the API that any clients need to know about
 
+v28 -> 2022-03-04
+    - Adds an API endpoint for auto allocation of stock items against a build order
+    - Ref: https://github.com/inventree/InvenTree/pull/2713
+
 v27 -> 2022-02-28
     - Adds target_date field to individual line items for purchase orders and sales orders
 

From 4151d942403fdb63bbb24644e15837024b634d29 Mon Sep 17 00:00:00 2001
From: Oliver <oliver.henry.walters@gmail.com>
Date: Fri, 4 Mar 2022 16:34:26 +1100
Subject: [PATCH 5/9] JS linting

---
 InvenTree/templates/js/translated/build.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/InvenTree/templates/js/translated/build.js b/InvenTree/templates/js/translated/build.js
index 0eb798aa28..fa0b90682e 100644
--- a/InvenTree/templates/js/translated/build.js
+++ b/InvenTree/templates/js/translated/build.js
@@ -1872,7 +1872,7 @@ function autoAllocateStockToBuild(build_id, bom_items=[], options={}) {
         substitutes: {
             value: true,
         },
-    }
+    };
 
     constructForm(`/api/build/${build_id}/auto-allocate/`, {
         method: 'POST',

From 70c9c9473dc78d4ee39bba9301388da67d702284 Mon Sep 17 00:00:00 2001
From: Oliver <oliver.henry.walters@gmail.com>
Date: Fri, 4 Mar 2022 17:27:07 +1100
Subject: [PATCH 6/9] Unit test fixes

---
 InvenTree/build/test_build.py | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/InvenTree/build/test_build.py b/InvenTree/build/test_build.py
index 4c48d27853..914cef29ab 100644
--- a/InvenTree/build/test_build.py
+++ b/InvenTree/build/test_build.py
@@ -144,7 +144,7 @@ class BuildTest(BuildTestBase):
     def test_init(self):
         # Perform some basic tests before we start the ball rolling
 
-        self.assertEqual(StockItem.objects.count(), 6)
+        self.assertEqual(StockItem.objects.count(), 10)
 
         # Build is PENDING
         self.assertEqual(self.build.status, status.BuildStatus.PENDING)
@@ -190,7 +190,7 @@ class BuildTest(BuildTestBase):
             b.clean()
 
         # Ok, what about we make one that does *not* fail?
-        b = BuildItem(stock_item=self.stock_1_1, build=self.build, install_into=self.output_1, quantity=10)
+        b = BuildItem(stock_item=self.stock_1_2, build=self.build, install_into=self.output_1, quantity=10)
         b.save()
 
     def test_duplicate_bom_line(self):
@@ -281,11 +281,14 @@ class BuildTest(BuildTestBase):
 
         self.assertFalse(self.build.are_untracked_parts_allocated())
 
+        self.stock_2_1.quantity = 500
+        self.stock_2_1.save()
+
         # Now we "fully" allocate the untracked untracked items
         self.allocate_stock(
             None,
             {
-                self.stock_1_1: 50,
+                self.stock_1_2: 50,
                 self.stock_2_1: 50,
             }
         )
@@ -312,6 +315,12 @@ class BuildTest(BuildTestBase):
         Test completion of a build output
         """
 
+        self.stock_1_1.quantity = 1000
+        self.stock_1_1.save()
+
+        self.stock_2_1.quantity = 30
+        self.stock_2_1.save()
+
         # Allocate non-tracked parts
         self.allocate_stock(
             None,
@@ -358,16 +367,15 @@ class BuildTest(BuildTestBase):
         self.assertEqual(BuildItem.objects.count(), 0)
 
         # New stock items should have been created!
-        self.assertEqual(StockItem.objects.count(), 7)
+        self.assertEqual(StockItem.objects.count(), 10)
 
         # This stock item has been depleted!
         with self.assertRaises(StockItem.DoesNotExist):
             StockItem.objects.get(pk=self.stock_1_1.pk)
 
-        # This stock item has *not* been depleted
-        x = StockItem.objects.get(pk=self.stock_2_1.pk)
-
-        self.assertEqual(x.quantity, 4970)
+        # This stock item has also been depleted
+        with self.assertRaises(StockItem.DoesNotExist):
+            StockItem.objects.get(pk=self.stock_2_1.pk)
 
         # And 10 new stock items created for the build output
         outputs = StockItem.objects.filter(build=self.build)

From d06def3c29a00870d60cb0f80e92df0ba1a26700 Mon Sep 17 00:00:00 2001
From: Oliver <oliver.henry.walters@gmail.com>
Date: Fri, 4 Mar 2022 17:40:04 +1100
Subject: [PATCH 7/9] Improve dialog message when allocating stock to a build
 order

---
 InvenTree/templates/js/translated/build.js | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/InvenTree/templates/js/translated/build.js b/InvenTree/templates/js/translated/build.js
index fa0b90682e..7d82e9d424 100644
--- a/InvenTree/templates/js/translated/build.js
+++ b/InvenTree/templates/js/translated/build.js
@@ -1513,6 +1513,16 @@ function loadBuildOutputAllocationTable(buildInfo, output, options={}) {
  */
 function allocateStockToBuild(build_id, part_id, bom_items, options={}) {
 
+    if (bom_items.length == 0) {
+
+        showAlertDialog(
+            '{% trans "Select Parts" %}',
+            '{% trans "You must select at least one part to allocate" %}',
+        );
+
+        return;
+    }
+
     // ID of the associated "build output" (or null)
     var output_id = options.output || null;
 
@@ -1627,8 +1637,8 @@ function allocateStockToBuild(build_id, part_id, bom_items, options={}) {
     if (table_entries.length == 0) {
 
         showAlertDialog(
-            '{% trans "Select Parts" %}',
-            '{% trans "You must select at least one part to allocate" %}',
+            '{% trans "All Parts Allocated" %}',
+            '{% trans "All selected parts have been fully allocated" %}',
         );
 
         return;

From 4bb7c65d8ad2eee82cfcfde8513efae0a2f93b36 Mon Sep 17 00:00:00 2001
From: Oliver <oliver.henry.walters@gmail.com>
Date: Fri, 4 Mar 2022 17:42:37 +1100
Subject: [PATCH 8/9] Template fix

---
 InvenTree/stock/templates/stock/item_base.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/InvenTree/stock/templates/stock/item_base.html b/InvenTree/stock/templates/stock/item_base.html
index ef71cfc05a..f023989887 100644
--- a/InvenTree/stock/templates/stock/item_base.html
+++ b/InvenTree/stock/templates/stock/item_base.html
@@ -244,7 +244,7 @@
 
     {% for allocation in item.allocations.all %}
     <div class='alert alert-block alert-info'>
-        {% object_link 'build-detail' allocation.build.id allocation.build %}
+        {% object_link 'build-detail' allocation.build.id allocation.build as link %}
         {% decimal allocation.quantity as qty %}
         {% trans "This stock item is allocated to Build Order" %} {{ link }} {% if qty < item.quantity %}({% trans "Quantity" %}: {{ qty }}){% endif %}
     </div>

From 83fbc6159ca51ea4e40e3992ddc465409c11d281 Mon Sep 17 00:00:00 2001
From: Oliver <oliver.henry.walters@gmail.com>
Date: Fri, 4 Mar 2022 17:47:46 +1100
Subject: [PATCH 9/9] Add table filter buttons to incomplete build output table

---
 InvenTree/templates/js/translated/build.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/InvenTree/templates/js/translated/build.js b/InvenTree/templates/js/translated/build.js
index 7d82e9d424..8a894189e8 100644
--- a/InvenTree/templates/js/translated/build.js
+++ b/InvenTree/templates/js/translated/build.js
@@ -755,7 +755,7 @@ function loadBuildOutputTable(build_info, options={}) {
         filters[key] = params[key];
     }
 
-    // TODO: Initialize filter list
+    setupFilterList('builditems', $(table), options.filterTarget || '#filter-list-incompletebuilditems');
 
     function setupBuildOutputButtonCallbacks() {
         
@@ -1000,7 +1000,7 @@ function loadBuildOutputAllocationTable(buildInfo, output, options={}) {
         filters[key] = params[key];
     }
 
-    setupFilterList('builditems', $(table), options.filterTarget || null);
+    setupFilterList('builditems', $(table), options.filterTarget);
 
     // If an "output" is specified, then only "trackable" parts are allocated
     // Otherwise, only "untrackable" parts are allowed