text: """
  JSON API for the Stock app
  """
  
  # -*- coding: utf-8 -*-
  from __future__ import unicode_literals
  
  from datetime import datetime, timedelta
  
  from django.core.exceptions import ValidationError as DjangoValidationError
  from django.conf.urls import url, include
  from django.http import JsonResponse
  from django.db.models import Q, F
  from django.db import transaction
  from django.utils.translation import ugettext_lazy as _
  
  from django_filters.rest_framework import DjangoFilterBackend
  from django_filters import rest_framework as rest_filters
  
  from rest_framework import status
  from rest_framework.serializers import ValidationError
  from rest_framework.response import Response
  from rest_framework import generics, filters
  
  import common.settings
  import common.models
  
  from company.models import Company, SupplierPart
  from company.serializers import CompanySerializer, SupplierPartSerializer
  
  from InvenTree.helpers import str2bool, isNull, extract_serial_numbers
  from InvenTree.api import AttachmentMixin
  from InvenTree.filters import InvenTreeOrderingFilter
  
  from order.models import PurchaseOrder
  from order.models import SalesOrder, SalesOrderAllocation
  from order.serializers import POSerializer
  
  from part.models import BomItem, Part, PartCategory
  from part.serializers import PartBriefSerializer
  
  from stock.models import StockLocation, StockItem
  from stock.models import StockItemTracking
  from stock.models import StockItemAttachment
  from stock.models import StockItemTestResult
  import stock.serializers as StockSerializers
  
  
  class StockDetail(generics.RetrieveUpdateDestroyAPIView):
      """ API detail endpoint for Stock object
  
      get:
      Return a single StockItem object
  
      post:
      Update a StockItem
  
      delete:
      Remove a StockItem
      """
  
      queryset = StockItem.objects.all()
      serializer_class = StockSerializers.StockItemSerializer
  
      def get_queryset(self, *args, **kwargs):
  
          queryset = super().get_queryset(*args, **kwargs)
          queryset = StockSerializers.StockItemSerializer.annotate_queryset(queryset)
  
          return queryset
  
      def get_serializer_context(self):
  
          ctx = super().get_serializer_context()
          ctx['user'] = getattr(self.request, 'user', None)
  
          return ctx
  
      def get_serializer(self, *args, **kwargs):
  
          kwargs['part_detail'] = True
          kwargs['location_detail'] = True
          kwargs['supplier_part_detail'] = True
          kwargs['test_detail'] = True
          kwargs['context'] = self.get_serializer_context()
  
          return self.serializer_class(*args, **kwargs)
  
  
  class StockItemSerialize(generics.CreateAPIView):
      """
      API endpoint for serializing a stock item
      """
  
      queryset = StockItem.objects.none()
      serializer_class = StockSerializers.SerializeStockItemSerializer
  
      def get_serializer_context(self):
  
          context = super().get_serializer_context()
          context['request'] = self.request
  
          try:
              context['item'] = StockItem.objects.get(pk=self.kwargs.get('pk', None))
          except:
              pass
  
          return context
  
  
  class StockAdjustView(generics.CreateAPIView):
      """
      A generic class for handling stocktake actions.
  
      Subclasses exist for:
  
      - StockCount: count stock items
      - StockAdd: add stock items
      - StockRemove: remove stock items
      - StockTransfer: transfer stock items
      """
  
      queryset = StockItem.objects.none()
  
      def get_serializer_context(self):
  
          context = super().get_serializer_context()
  
          context['request'] = self.request
  
          return context
  
  
  class StockCount(StockAdjustView):
      """
      Endpoint for counting stock (performing a stocktake).
      """
  
      serializer_class = StockSerializers.StockCountSerializer
  
  
  class StockAdd(StockAdjustView):
      """
      Endpoint for adding a quantity of stock to an existing StockItem
      """
  
      serializer_class = StockSerializers.StockAddSerializer
  
  
  class StockRemove(StockAdjustView):
      """
      Endpoint for removing a quantity of stock from an existing StockItem.
      """
  
      serializer_class = StockSerializers.StockRemoveSerializer
  
  
  class StockTransfer(StockAdjustView):
      """
      API endpoint for performing stock movements
      """
  
      serializer_class = StockSerializers.StockTransferSerializer
  
  
  class StockAssign(generics.CreateAPIView):
      """
      API endpoint for assigning stock to a particular customer
      """
  
      queryset = StockItem.objects.all()
      serializer_class = StockSerializers.StockAssignmentSerializer
  
      def get_serializer_context(self):
  
          ctx = super().get_serializer_context()
  
          ctx['request'] = self.request
  
          return ctx
  
  
  class StockLocationList(generics.ListCreateAPIView):
      """
      API endpoint for list view of StockLocation objects:
  
      - GET: Return list of StockLocation objects
      - POST: Create a new StockLocation
      """
  
      queryset = StockLocation.objects.all()
      serializer_class = StockSerializers.LocationSerializer
  
      def filter_queryset(self, queryset):
          """
          Custom filtering:
          - Allow filtering by "null" parent to retrieve top-level stock locations
          """
  
          queryset = super().filter_queryset(queryset)
  
          params = self.request.query_params
  
          loc_id = params.get('parent', None)
  
          cascade = str2bool(params.get('cascade', False))
  
          # Do not filter by location
          if loc_id is None:
              pass
          # Look for top-level locations
          elif isNull(loc_id):
  
              # If we allow "cascade" at the top-level, this essentially means *all* locations
              if not cascade:
                  queryset = queryset.filter(parent=None)
  
          else:
  
              try:
                  location = StockLocation.objects.get(pk=loc_id)
  
                  # All sub-locations to be returned too?
                  if cascade:
                      parents = location.get_descendants(include_self=True)
                      parent_ids = [p.id for p in parents]
                      queryset = queryset.filter(parent__in=parent_ids)
  
                  else:
                      queryset = queryset.filter(parent=location)
  
              except (ValueError, StockLocation.DoesNotExist):
                  pass
  
          # Exclude StockLocation tree
          exclude_tree = params.get('exclude_tree', None)
  
          if exclude_tree is not None:
              try:
                  loc = StockLocation.objects.get(pk=exclude_tree)
  
                  queryset = queryset.exclude(
                      pk__in=[subloc.pk for subloc in loc.get_descendants(include_self=True)]
                  )
  
              except (ValueError, StockLocation.DoesNotExist):
                  pass
  
          return queryset
  
      filter_backends = [
          DjangoFilterBackend,
          filters.SearchFilter,
          filters.OrderingFilter,
      ]
  
      filter_fields = [
      ]
  
      search_fields = [
          'name',
          'description',
      ]
  
      ordering_fields = [
          'name',
          'items',
          'level',
          'tree_id',
          'lft',
      ]
  
      ordering = [
          'tree_id',
          'lft',
          'name',
      ]
  
  
  class StockLocationTree(generics.ListAPIView):
      """
      API endpoint for accessing a list of StockLocation objects,
      ready for rendering as a tree
      """
  
      queryset = StockLocation.objects.all()
      serializer_class = StockSerializers.LocationTreeSerializer
  
      filter_backends = [
          DjangoFilterBackend,
          filters.OrderingFilter,
      ]
  
      # Order by tree level (top levels first) and then name
      ordering = ['level', 'name']
  
  
  class StockFilter(rest_filters.FilterSet):
      """
      FilterSet for StockItem LIST API
      """
  
      # Part name filters
      name = rest_filters.CharFilter(label='Part name (case insensitive)', field_name='part__name', lookup_expr='iexact')
      name_contains = rest_filters.CharFilter(label='Part name contains (case insensitive)', field_name='part__name', lookup_expr='icontains')
      name_regex = rest_filters.CharFilter(label='Part name (regex)', field_name='part__name', lookup_expr='iregex')
  
      # Part IPN filters
      IPN = rest_filters.CharFilter(label='Part IPN (case insensitive)', field_name='part__IPN', lookup_expr='iexact')
      IPN_contains = rest_filters.CharFilter(label='Part IPN contains (case insensitive)', field_name='part__IPN', lookup_expr='icontains')
      IPN_regex = rest_filters.CharFilter(label='Part IPN (regex)', field_name='part__IPN', lookup_expr='iregex')
  
      # Part attribute filters
      assembly = rest_filters.BooleanFilter(label="Assembly", field_name='part__assembly')
      active = rest_filters.BooleanFilter(label="Active", field_name='part__active')
  
      min_stock = rest_filters.NumberFilter(label='Minimum stock', field_name='quantity', lookup_expr='gte')
      max_stock = rest_filters.NumberFilter(label='Maximum stock', field_name='quantity', lookup_expr='lte')
  
      in_stock = rest_filters.BooleanFilter(label='In Stock', method='filter_in_stock')
  
      def filter_in_stock(self, queryset, name, value):
  
          if str2bool(value):
              queryset = queryset.filter(StockItem.IN_STOCK_FILTER)
          else:
              queryset = queryset.exclude(StockItem.IN_STOCK_FILTER)
  
          return queryset
  
      available = rest_filters.BooleanFilter(label='Available', method='filter_available')
  
      def filter_available(self, queryset, name, value):
          """
          Filter by whether the StockItem is "available" or not.
  
          Here, "available" means that the allocated quantity is less than the total quantity
          """
  
          if str2bool(value):
              # The 'quantity' field is greater than the calculated 'allocated' field
              queryset = queryset.filter(Q(quantity__gt=F('allocated')))
          else:
              # The 'quantity' field is less than (or equal to) the calculated 'allocated' field
              queryset = queryset.filter(Q(quantity__lte=F('allocated')))
  
          return queryset
  
      batch = rest_filters.CharFilter(label="Batch code filter (case insensitive)", lookup_expr='iexact')
  
      batch_regex = rest_filters.CharFilter(label="Batch code filter (regex)", field_name='batch', lookup_expr='iregex')
  
      is_building = rest_filters.BooleanFilter(label="In production")
  
      # Serial number filtering
      serial_gte = rest_filters.NumberFilter(label='Serial number GTE', field_name='serial', lookup_expr='gte')
      serial_lte = rest_filters.NumberFilter(label='Serial number LTE', field_name='serial', lookup_expr='lte')
      serial = rest_filters.CharFilter(label='Serial number', field_name='serial', lookup_expr='exact')
  
      serialized = rest_filters.BooleanFilter(label='Has serial number', method='filter_serialized')
  
      def filter_serialized(self, queryset, name, value):
  
          if str2bool(value):
              queryset = queryset.exclude(serial=None)
          else:
              queryset = queryset.filter(serial=None)
  
          return queryset
  
      installed = rest_filters.BooleanFilter(label='Installed in other stock item', method='filter_installed')
  
      def filter_installed(self, queryset, name, value):
          """
          Filter stock items by "belongs_to" field being empty
          """
  
          if str2bool(value):
              queryset = queryset.exclude(belongs_to=None)
          else:
              queryset = queryset.filter(belongs_to=None)
  
          return queryset
  
      sent_to_customer = rest_filters.BooleanFilter(label='Sent to customer', method='filter_sent_to_customer')
  
      def filter_sent_to_customer(self, queryset, name, value):
  
          if str2bool(value):
              queryset = queryset.exclude(customer=None)
          else:
              queryset = queryset.filter(customer=None)
  
          return queryset
  
      depleted = rest_filters.BooleanFilter(label='Depleted', method='filter_depleted')
  
      def filter_depleted(self, queryset, name, value):
  
          if str2bool(value):
              queryset = queryset.filter(quantity__lte=0)
          else:
              queryset = queryset.exclude(quantity__lte=0)
  
          return queryset
  
      has_purchase_price = rest_filters.BooleanFilter(label='Has purchase price', method='filter_has_purchase_price')
  
      def filter_has_purchase_price(self, queryset, name, value):
  
          if str2bool(value):
              queryset = queryset.exclude(purcahse_price=None)
          else:
              queryset = queryset.filter(purchase_price=None)
  
          return queryset
  
      # Update date filters
      updated_before = rest_filters.DateFilter(label='Updated before', field_name='updated', lookup_expr='lte')
      updated_after = rest_filters.DateFilter(label='Updated after', field_name='updated', lookup_expr='gte')
  
  
  class StockList(generics.ListCreateAPIView):
      """ API endpoint for list view of Stock objects
  
      - GET: Return a list of all StockItem objects (with optional query filters)
      - POST: Create a new StockItem
      """
  
      serializer_class = StockSerializers.StockItemSerializer
      queryset = StockItem.objects.all()
      filterset_class = StockFilter
  
      def get_serializer_context(self):
  
          ctx = super().get_serializer_context()
          ctx['user'] = getattr(self.request, 'user', None)
  
          return ctx
  
      def create(self, request, *args, **kwargs):
          """
          Create a new StockItem object via the API.
  
          We override the default 'create' implementation.
  
          If a location is *not* specified, but the linked *part* has a default location,
          we can pre-fill the location automatically.
          """
  
          user = request.user
          data = request.data
  
          serializer = self.get_serializer(data=data)
          serializer.is_valid(raise_exception=True)
  
          # Check if a set of serial numbers was provided
          serial_numbers = data.get('serial_numbers', '')
  
          quantity = data.get('quantity', None)
  
          if quantity is None:
              raise ValidationError({
                  'quantity': _('Quantity is required'),
              })
  
          notes = data.get('notes', '')
  
          serials = None
  
          if serial_numbers:
              # If serial numbers are specified, check that they match!
              try:
                  serials = extract_serial_numbers(serial_numbers, data['quantity'])
              except DjangoValidationError as e:
                  raise ValidationError({
                      'quantity': e.messages,
                      'serial_numbers': e.messages,
                  })
  
          with transaction.atomic():
  
              # Create an initial stock item
              item = serializer.save()
  
              # A location was *not* specified - try to infer it
              if 'location' not in data:
                  item.location = item.part.get_default_location()
  
              # An expiry date was *not* specified - try to infer it!
              if 'expiry_date' not in data:
  
                  if item.part.default_expiry > 0:
                      item.expiry_date = datetime.now().date() + timedelta(days=item.part.default_expiry)
  
              # Finally, save the item (with user information)
              item.save(user=user)
  
              if serials:
                  """
                  Serialize the stock, if required
  
                  - Note that the "original" stock item needs to be created first, so it can be serialized
                  - It is then immediately deleted
                  """
  
                  try:
                      item.serializeStock(
                          quantity,
                          serials,
                          user,
                          notes=notes,
                          location=item.location,
                      )
  
                      headers = self.get_success_headers(serializer.data)
  
                      # Delete the original item
                      item.delete()
  
                      response_data = {
                          'quantity': quantity,
                          'serial_numbers': serials,
                      }
  
                      return Response(response_data, status=status.HTTP_201_CREATED, headers=headers)
  
                  except DjangoValidationError as e:
                      raise ValidationError({
                          'quantity': e.messages,
                          'serial_numbers': e.messages,
                      })
  
              # Return a response
              headers = self.get_success_headers(serializer.data)
              return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
  
      def list(self, request, *args, **kwargs):
          """
          Override the 'list' method, as the StockLocation objects
          are very expensive to serialize.
  
          So, we fetch and serialize the required StockLocation objects only as required.
          """
  
          queryset = self.filter_queryset(self.get_queryset())
  
          page = self.paginate_queryset(queryset)
  
          if page is not None:
              serializer = self.get_serializer(page, many=True)
          else:
              serializer = self.get_serializer(queryset, many=True)
  
          data = serializer.data
  
          # Keep track of which related models we need to query
          location_ids = set()
          part_ids = set()
          supplier_part_ids = set()
  
          # Iterate through each StockItem and grab some data
          for item in data:
              loc = item['location']
              if loc:
                  location_ids.add(loc)
  
              part = item['part']
              if part:
                  part_ids.add(part)
  
              sp = item['supplier_part']
  
              if sp:
                  supplier_part_ids.add(sp)
  
          # Do we wish to include Part detail?
          if str2bool(request.query_params.get('part_detail', False)):
  
              # Fetch only the required Part objects from the database
              parts = Part.objects.filter(pk__in=part_ids).prefetch_related(
                  'category',
              )
  
              part_map = {}
  
              for part in parts:
                  part_map[part.pk] = PartBriefSerializer(part).data
  
              # Now update each StockItem with the related Part data
              for stock_item in data:
                  part_id = stock_item['part']
                  stock_item['part_detail'] = part_map.get(part_id, None)
  
          # Do we wish to include SupplierPart detail?
          if str2bool(request.query_params.get('supplier_part_detail', False)):
  
              supplier_parts = SupplierPart.objects.filter(pk__in=supplier_part_ids)
  
              supplier_part_map = {}
  
              for part in supplier_parts:
                  supplier_part_map[part.pk] = SupplierPartSerializer(part).data
  
              for stock_item in data:
                  part_id = stock_item['supplier_part']
                  stock_item['supplier_part_detail'] = supplier_part_map.get(part_id, None)
  
          # Do we wish to include StockLocation detail?
          if str2bool(request.query_params.get('location_detail', False)):
  
              # Fetch only the required StockLocation objects from the database
              locations = StockLocation.objects.filter(pk__in=location_ids).prefetch_related(
                  'parent',
                  'children',
              )
  
              location_map = {}
  
              # Serialize each StockLocation object
              for location in locations:
                  location_map[location.pk] = StockSerializers.LocationBriefSerializer(location).data
  
              # Now update each StockItem with the related StockLocation data
              for stock_item in data:
                  loc_id = stock_item['location']
                  stock_item['location_detail'] = location_map.get(loc_id, None)
  
          """
          Determine the response type based on the request.
          a) For HTTP requests (e.g. via the browseable API) return a DRF response
          b) For AJAX requests, simply return a JSON rendered response.
  
          Note: b) is about 100x quicker than a), because the DRF framework adds a lot of cruft
          """
  
          if page is not None:
              return self.get_paginated_response(data)
          elif request.is_ajax():
              return JsonResponse(data, safe=False)
          else:
              return Response(data)
  
      def get_queryset(self, *args, **kwargs):
  
          queryset = super().get_queryset(*args, **kwargs)
  
          queryset = StockSerializers.StockItemSerializer.annotate_queryset(queryset)
  
          return queryset
  
      def filter_queryset(self, queryset):
          """
          Custom filtering for the StockItem queryset
          """
  
          params = self.request.query_params
  
          queryset = super().filter_queryset(queryset)
  
          supplier_part = params.get('supplier_part', None)
  
          if supplier_part:
              queryset = queryset.filter(supplier_part=supplier_part)
  
          belongs_to = params.get('belongs_to', None)
  
          if belongs_to:
              queryset = queryset.filter(belongs_to=belongs_to)
  
          build = params.get('build', None)
  
          if build:
              queryset = queryset.filter(build=build)
  
          sales_order = params.get('sales_order', None)
  
          if sales_order:
              queryset = queryset.filter(sales_order=sales_order)
  
          purchase_order = params.get('purchase_order', None)
  
          if purchase_order is not None:
              queryset = queryset.filter(purchase_order=purchase_order)
  
          # Filter stock items which are installed in another (specific) stock item
          installed_in = params.get('installed_in', None)
  
          if installed_in:
              # Note: The "installed_in" field is called "belongs_to"
              queryset = queryset.filter(belongs_to=installed_in)
  
          if common.settings.stock_expiry_enabled():
  
              # Filter by 'expired' status
              expired = params.get('expired', None)
  
              if expired is not None:
                  expired = str2bool(expired)
  
                  if expired:
                      queryset = queryset.filter(StockItem.EXPIRED_FILTER)
                  else:
                      queryset = queryset.exclude(StockItem.EXPIRED_FILTER)
  
              # Filter by 'stale' status
              stale = params.get('stale', None)
  
              if stale is not None:
                  stale = str2bool(stale)
  
                  # How many days to account for "staleness"?
                  stale_days = common.models.InvenTreeSetting.get_setting('STOCK_STALE_DAYS')
  
                  if stale_days > 0:
                      stale_date = datetime.now().date() + timedelta(days=stale_days)
  
                      stale_filter = StockItem.IN_STOCK_FILTER & ~Q(expiry_date=None) & Q(expiry_date__lt=stale_date)
  
                      if stale:
                          queryset = queryset.filter(stale_filter)
                      else:
                          queryset = queryset.exclude(stale_filter)
  
          # Filter by customer
          customer = params.get('customer', None)
  
          if customer:
              queryset = queryset.filter(customer=customer)
  
          # Exclude stock item tree
          exclude_tree = params.get('exclude_tree', None)
  
          if exclude_tree is not None:
              try:
                  item = StockItem.objects.get(pk=exclude_tree)
  
                  queryset = queryset.exclude(
                      pk__in=[it.pk for it in item.get_descendants(include_self=True)]
                  )
  
              except (ValueError, StockItem.DoesNotExist):
                  pass
  
          # Filter by "part tree" - only allow parts within a given variant tree
          part_tree = params.get('part_tree', None)
  
          if part_tree is not None:
              try:
                  part = Part.objects.get(pk=part_tree)
  
                  if part.tree_id is not None:
                      queryset = queryset.filter(part__tree_id=part.tree_id)
              except:
                  pass
  
          # Filter by 'allocated' parts?
          allocated = params.get('allocated', None)
  
          if allocated is not None:
              allocated = str2bool(allocated)
  
              if allocated:
                  # Filter StockItem with either build allocations or sales order allocations
                  queryset = queryset.filter(Q(sales_order_allocations__isnull=False) | Q(allocations__isnull=False))
              else:
                  # Filter StockItem without build allocations or sales order allocations
                  queryset = queryset.filter(Q(sales_order_allocations__isnull=True) & Q(allocations__isnull=True))
  
          # Exclude StockItems which are already allocated to a particular SalesOrder
          exclude_so_allocation = params.get('exclude_so_allocation', None)
  
          if exclude_so_allocation is not None:
  
              try:
                  order = SalesOrder.objects.get(pk=exclude_so_allocation)
  
                  # Grab all the active SalesOrderAllocations for this order
                  allocations = SalesOrderAllocation.objects.filter(
                      line__pk__in=[
                          line.pk for line in order.lines.all()
                      ]
                  )
  
                  # Exclude any stock item which is already allocated to the sales order
                  queryset = queryset.exclude(
                      pk__in=[
                          a.item.pk for a in allocations
                      ]
                  )
  
              except (ValueError, SalesOrder.DoesNotExist):
                  pass
  
          # Does the client wish to filter by the Part ID?
          part_id = params.get('part', None)
  
          if part_id:
              try:
                  part = Part.objects.get(pk=part_id)
  
                  # Do we wish to filter *just* for this part, or also for parts *under* this one?
                  include_variants = str2bool(params.get('include_variants', True))
  
                  if include_variants:
                      # Filter by any parts "under" the given part
                      parts = part.get_descendants(include_self=True)
  
                      queryset = queryset.filter(part__in=parts)
  
                  else:
                      queryset = queryset.filter(part=part)
  
              except (ValueError, Part.DoesNotExist):
                  raise ValidationError({"part": "Invalid Part ID specified"})
  
          # Does the client wish to filter by the 'ancestor'?
          anc_id = params.get('ancestor', None)
  
          if anc_id:
              try:
                  ancestor = StockItem.objects.get(pk=anc_id)
  
                  # Only allow items which are descendants of the specified StockItem
                  queryset = queryset.filter(id__in=[item.pk for item in ancestor.children.all()])
  
              except (ValueError, Part.DoesNotExist):
                  raise ValidationError({"ancestor": "Invalid ancestor ID specified"})
  
          # Does the client wish to filter by stock location?
          loc_id = params.get('location', None)
  
          cascade = str2bool(params.get('cascade', True))
  
          if loc_id is not None:
  
              # Filter by 'null' location (i.e. top-level items)
              if isNull(loc_id) and not cascade:
                  queryset = queryset.filter(location=None)
              else:
                  try:
                      # If '?cascade=true' then include items which exist in sub-locations
                      if cascade:
                          location = StockLocation.objects.get(pk=loc_id)
                          queryset = queryset.filter(location__in=location.getUniqueChildren())
                      else:
                          queryset = queryset.filter(location=loc_id)
  
                  except (ValueError, StockLocation.DoesNotExist):
                      pass
  
          # Does the client wish to filter by part category?
          cat_id = params.get('category', None)
  
          if cat_id:
              try:
                  category = PartCategory.objects.get(pk=cat_id)
                  queryset = queryset.filter(part__category__in=category.getUniqueChildren())
  
              except (ValueError, PartCategory.DoesNotExist):
                  raise ValidationError({"category": "Invalid category id specified"})
  
          # Does the client wish to filter by BomItem
          bom_item_id = params.get('bom_item', None)
  
          if bom_item_id is not None:
              try:
                  bom_item = BomItem.objects.get(pk=bom_item_id)
  
                  queryset = queryset.filter(bom_item.get_stock_filter())
  
              except (ValueError, BomItem.DoesNotExist):
                  pass
  
          # Filter by StockItem status
          status = params.get('status', None)
  
          if status:
              queryset = queryset.filter(status=status)
  
          # Filter by supplier_part ID
          supplier_part_id = params.get('supplier_part', None)
  
          if supplier_part_id:
              queryset = queryset.filter(supplier_part=supplier_part_id)
  
          # Filter by company (either manufacturer or supplier)
          company = params.get('company', None)
  
          if company is not None:
              queryset = queryset.filter(Q(supplier_part__supplier=company) | Q(supplier_part__manufacturer_part__manufacturer=company))
  
          # Filter by supplier
          supplier = params.get('supplier', None)
  
          if supplier is not None:
              queryset = queryset.filter(supplier_part__supplier=supplier)
  
          # Filter by manufacturer
          manufacturer = params.get('manufacturer', None)
  
          if manufacturer is not None:
              queryset = queryset.filter(supplier_part__manufacturer_part__manufacturer=manufacturer)
  
          # Optionally, limit the maximum number of returned results
          max_results = params.get('max_results', None)
  
          if max_results is not None:
              try:
                  max_results = int(max_results)
  
                  if max_results > 0:
                      queryset = queryset[:max_results]
              except (ValueError):
                  pass
  
          # Also ensure that we pre-fecth all the related items
          queryset = queryset.prefetch_related(
              'part',
              'part__category',
              'location'
          )
  
          return queryset
  
      filter_backends = [
          DjangoFilterBackend,
          filters.SearchFilter,
          InvenTreeOrderingFilter,
      ]
  
      ordering_field_aliases = {
          'SKU': 'supplier_part__SKU',
          'stock': ['quantity', 'serial_int', 'serial'],
      }
  
      ordering_fields = [
          'batch',
          'location',
          'part__name',
          'part__IPN',
          'updated',
          'stocktake_date',
          'expiry_date',
          'quantity',
          'stock',
          'status',
          'SKU',
      ]
  
      ordering = [
          'part__name',
          'quantity',
          'location',
      ]
  
      search_fields = [
          'serial',
          'batch',
          'part__name',
          'part__IPN',
          'part__description',
          'location__name',
      ]
  
  
  class StockAttachmentList(generics.ListCreateAPIView, AttachmentMixin):
      """
      API endpoint for listing (and creating) a StockItemAttachment (file upload)
      """
  
      queryset = StockItemAttachment.objects.all()
      serializer_class = StockSerializers.StockItemAttachmentSerializer
  
      filter_backends = [
          DjangoFilterBackend,
          filters.OrderingFilter,
          filters.SearchFilter,
      ]
  
      filter_fields = [
          'stock_item',
      ]
  
  
  class StockAttachmentDetail(generics.RetrieveUpdateDestroyAPIView, AttachmentMixin):
      """
      Detail endpoint for StockItemAttachment
      """
  
      queryset = StockItemAttachment.objects.all()
      serializer_class = StockSerializers.StockItemAttachmentSerializer
  
  
  class StockItemTestResultDetail(generics.RetrieveUpdateDestroyAPIView):
      """
      Detail endpoint for StockItemTestResult
      """
  
      queryset = StockItemTestResult.objects.all()
      serializer_class = StockSerializers.StockItemTestResultSerializer
  
  
  class StockItemTestResultList(generics.ListCreateAPIView):
      """
      API endpoint for listing (and creating) a StockItemTestResult object.
      """
  
      queryset = StockItemTestResult.objects.all()
      serializer_class = StockSerializers.StockItemTestResultSerializer
  
      filter_backends = [
          DjangoFilterBackend,
          filters.SearchFilter,
          filters.OrderingFilter,
      ]
  
      filter_fields = [
          'stock_item',
          'test',
          'user',
          'result',
          'value',
      ]
  
      ordering = 'date'
  
      def get_serializer(self, *args, **kwargs):
          try:
              kwargs['user_detail'] = str2bool(self.request.query_params.get('user_detail', False))
          except:
              pass
  
          kwargs['context'] = self.get_serializer_context()
  
          return self.serializer_class(*args, **kwargs)
  
      def perform_create(self, serializer):
          """
          Create a new test result object.
  
          Also, check if an attachment was uploaded alongside the test result,
          and save it to the database if it were.
          """
  
          # Capture the user information
          test_result = serializer.save()
          test_result.user = self.request.user
          test_result.save()
  
  
  class StockTrackingDetail(generics.RetrieveAPIView):
      """
      Detail API endpoint for StockItemTracking model
      """
  
      queryset = StockItemTracking.objects.all()
      serializer_class = StockSerializers.StockTrackingSerializer
  
  
  class StockTrackingList(generics.ListAPIView):
      """ API endpoint for list view of StockItemTracking objects.
  
      StockItemTracking objects are read-only
      (they are created by internal model functionality)
  
      - GET: Return list of StockItemTracking objects
      """
  
      queryset = StockItemTracking.objects.all()
      serializer_class = StockSerializers.StockTrackingSerializer
  
      def get_serializer(self, *args, **kwargs):
          try:
              kwargs['item_detail'] = str2bool(self.request.query_params.get('item_detail', False))
          except:
              pass
  
          try:
              kwargs['user_detail'] = str2bool(self.request.query_params.get('user_detail', False))
          except:
              pass
  
          kwargs['context'] = self.get_serializer_context()
  
          return self.serializer_class(*args, **kwargs)
  
      def list(self, request, *args, **kwargs):
  
          queryset = self.filter_queryset(self.get_queryset())
  
          serializer = self.get_serializer(queryset, many=True)
  
          data = serializer.data
  
          # Attempt to add extra context information to the historical data
          for item in data:
              deltas = item['deltas']
  
              if not deltas:
                  deltas = {}
  
              # Add location detail
              if 'location' in deltas:
                  try:
                      location = StockLocation.objects.get(pk=deltas['location'])
                      serializer = StockSerializers.LocationSerializer(location)
                      deltas['location_detail'] = serializer.data
                  except:
                      pass
  
              # Add stockitem detail
              if 'stockitem' in deltas:
                  try:
                      stockitem = StockItem.objects.get(pk=deltas['stockitem'])
                      serializer = StockSerializers.StockItemSerializer(stockitem)
                      deltas['stockitem_detail'] = serializer.data
                  except:
                      pass
  
              # Add customer detail
              if 'customer' in deltas:
                  try:
                      customer = Company.objects.get(pk=deltas['customer'])
                      serializer = CompanySerializer(customer)
                      deltas['customer_detail'] = serializer.data
                  except:
                      pass
  
              # Add purchaseorder detail
              if 'purchaseorder' in deltas:
                  try:
                      order = PurchaseOrder.objects.get(pk=deltas['purchaseorder'])
                      serializer = POSerializer(order)
                      deltas['purchaseorder_detail'] = serializer.data
                  except:
                      pass
  
          if request.is_ajax():
              return JsonResponse(data, safe=False)
          else:
              return Response(data)
  
      def create(self, request, *args, **kwargs):
          """ Create a new StockItemTracking object
  
          Here we override the default 'create' implementation,
          to save the user information associated with the request object.
          """
  
          serializer = self.get_serializer(data=request.data)
          serializer.is_valid(raise_exception=True)
  
          # Record the user who created this Part object
          item = serializer.save()
          item.user = request.user
          item.system = False
  
          # quantity field cannot be explicitly adjusted  here
          item.quantity = item.item.quantity
          item.save()
  
          headers = self.get_success_headers(serializer.data)
          return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
  
      filter_backends = [
          DjangoFilterBackend,
          filters.SearchFilter,
          filters.OrderingFilter,
      ]
  
      filter_fields = [
          'item',
          'user',
      ]
  
      ordering = '-date'
  
      ordering_fields = [
          'date',
      ]
  
      search_fields = [
          'title',
          'notes',
      ]
  
  
  class LocationDetail(generics.RetrieveUpdateDestroyAPIView):
      """ API endpoint for detail view of StockLocation object
  
      - GET: Return a single StockLocation object
      - PATCH: Update a StockLocation object
      - DELETE: Remove a StockLocation object
      """
  
      queryset = StockLocation.objects.all()
      serializer_class = StockSerializers.LocationSerializer
  
  
  stock_api_urls = [
      url(r'^location/', include([
  
          url(r'^tree/', StockLocationTree.as_view(), name='api-location-tree'),
  
          url(r'^(?P<pk>\d+)/', LocationDetail.as_view(), name='api-location-detail'),
          url(r'^.*$', StockLocationList.as_view(), name='api-location-list'),
      ])),
  
      # Endpoints for bulk stock adjustment actions
      url(r'^count/', StockCount.as_view(), name='api-stock-count'),
      url(r'^add/', StockAdd.as_view(), name='api-stock-add'),
      url(r'^remove/', StockRemove.as_view(), name='api-stock-remove'),
      url(r'^transfer/', StockTransfer.as_view(), name='api-stock-transfer'),
      url(r'^assign/', StockAssign.as_view(), name='api-stock-assign'),
  
      # StockItemAttachment API endpoints
      url(r'^attachment/', include([
          url(r'^(?P<pk>\d+)/', StockAttachmentDetail.as_view(), name='api-stock-attachment-detail'),
          url(r'^$', StockAttachmentList.as_view(), name='api-stock-attachment-list'),
      ])),
  
      # StockItemTestResult API endpoints
      url(r'^test/', include([
          url(r'^(?P<pk>\d+)/', StockItemTestResultDetail.as_view(), name='api-stock-test-result-detail'),
          url(r'^.*$', StockItemTestResultList.as_view(), name='api-stock-test-result-list'),
      ])),
  
      # StockItemTracking API endpoints
      url(r'^track/', include([
          url(r'^(?P<pk>\d+)/', StockTrackingDetail.as_view(), name='api-stock-tracking-detail'),
          url(r'^.*$', StockTrackingList.as_view(), name='api-stock-tracking-list'),
      ])),
  
      # Detail views for a single stock item
      url(r'^(?P<pk>\d+)/', include([
          url(r'^serialize/', StockItemSerialize.as_view(), name='api-stock-item-serialize'),
          url(r'^.*$', StockDetail.as_view(), name='api-stock-detail'),
      ])),
  
      # Anything else
      url(r'^.*$', StockList.as_view(), name='api-stock-list'),
  ]
  