def load_status_codes(context):
"""
Make the various StatusCodes available to the page context
"""
context['order_status_codes'] = OrderStatus.list()
context['stock_status_codes'] = StockStatus.list()
context['build_status_codes'] = BuildStatus.list()
# Need to return something as the result is rendered to the page
return ''
def build_status_label(key, *args, **kwargs):
""" Render a Build status label """
return mark_safe(BuildStatus.render(key, large=kwargs.get('large', False)))
class Build(MPTTModel):
""" A Build object organises the creation of new StockItem objects from other existing StockItem objects.
Attributes:
part: The part to be built (from component BOM items)
reference: Build order reference (required, must be unique)
title: Brief title describing the build (required)
quantity: Number of units to be built
parent: Reference to a Build object for which this Build is required
sales_order: References to a SalesOrder object for which this Build is required (e.g. the output of this build will be used to fulfil a sales order)
take_from: Location to take stock from to make this build (if blank, can take from anywhere)
status: Build status code
batch: Batch code transferred to build parts (optional)
creation_date: Date the build was created (auto)
target_date: Date the build will be overdue
completion_date: Date the build was completed (or, if incomplete, the expected date of completion)
link: External URL for extra information
notes: Text notes
completed_by: User that completed the build
issued_by: User that issued the build
responsible: User (or group) responsible for completing the build
"""
OVERDUE_FILTER = Q(status__in=BuildStatus.ACTIVE_CODES) & ~Q(
target_date=None) & Q(target_date__lte=datetime.now().date())
class Meta:
verbose_name = _("Build Order")
verbose_name_plural = _("Build Orders")
def format_barcode(self, **kwargs):
"""
Return a JSON string to represent this build as a barcode
"""
return MakeBarcode("buildorder", self.pk, {
"reference": self.title,
"url": self.get_absolute_url(),
})
@staticmethod
def filterByDate(queryset, min_date, max_date):
"""
Filter by 'minimum and maximum date range'
- Specified as min_date, max_date
- Both must be specified for filter to be applied
"""
date_fmt = '%Y-%m-%d' # ISO format date string
# Ensure that both dates are valid
try:
min_date = datetime.strptime(str(min_date), date_fmt).date()
max_date = datetime.strptime(str(max_date), date_fmt).date()
except (ValueError, TypeError):
# Date processing error, return queryset unchanged
return queryset
# Order was completed within the specified range
completed = Q(status=BuildStatus.COMPLETE) & Q(
completion_date__gte=min_date) & Q(completion_date__lte=max_date)
# Order target date falls witin specified range
pending = Q(
status__in=BuildStatus.ACTIVE_CODES) & ~Q(target_date=None) & Q(
target_date__gte=min_date) & Q(target_date__lte=max_date)
# TODO - Construct a queryset for "overdue" orders
queryset = queryset.filter(completed | pending)
return queryset
def __str__(self):
prefix = getSetting("BUILDORDER_REFERENCE_PREFIX")
return f"{prefix}{self.reference}"
def get_absolute_url(self):
return reverse('build-detail', kwargs={'pk': self.id})
reference = models.CharField(unique=True,
max_length=64,
blank=False,
help_text=_('Build Order Reference'),
verbose_name=_('Reference'),
validators=[validate_build_order_reference])
title = models.CharField(verbose_name=_('Description'),
blank=False,
max_length=100,
help_text=_('Brief description of the build'))
# TODO - Perhaps delete the build "tree"
parent = TreeForeignKey(
'self',
on_delete=models.SET_NULL,
blank=True,
null=True,
related_name='children',
verbose_name=_('Parent Build'),
help_text=_('BuildOrder to which this build is allocated'),
)
part = models.ForeignKey(
'part.Part',
verbose_name=_('Part'),
on_delete=models.CASCADE,
related_name='builds',
limit_choices_to={
'assembly': True,
'active': True,
'virtual': False,
},
help_text=_('Select part to build'),
)
sales_order = models.ForeignKey(
'order.SalesOrder',
verbose_name=_('Sales Order Reference'),
on_delete=models.SET_NULL,
related_name='builds',
null=True,
blank=True,
help_text=_('SalesOrder to which this build is allocated'))
take_from = models.ForeignKey(
'stock.StockLocation',
verbose_name=_('Source Location'),
on_delete=models.SET_NULL,
related_name='sourcing_builds',
null=True,
blank=True,
help_text=
_('Select location to take stock from for this build (leave blank to take from any stock location)'
))
destination = models.ForeignKey(
'stock.StockLocation',
verbose_name=_('Destination Location'),
on_delete=models.SET_NULL,
related_name='incoming_builds',
null=True,
blank=True,
help_text=_(
'Select location where the completed items will be stored'),
)
quantity = models.PositiveIntegerField(
verbose_name=_('Build Quantity'),
default=1,
validators=[MinValueValidator(1)],
help_text=_('Number of stock items to build'))
completed = models.PositiveIntegerField(
verbose_name=_('Completed items'),
default=0,
help_text=_('Number of stock items which have been completed'))
status = models.PositiveIntegerField(verbose_name=_('Build Status'),
default=BuildStatus.PENDING,
choices=BuildStatus.items(),
validators=[MinValueValidator(0)],
help_text=_('Build status code'))
batch = models.CharField(verbose_name=_('Batch Code'),
max_length=100,
blank=True,
null=True,
help_text=_('Batch code for this build output'))
creation_date = models.DateField(auto_now_add=True, editable=False)
target_date = models.DateField(
null=True,
blank=True,
verbose_name=_('Target completion date'),
help_text=
_('Target date for build completion. Build will be overdue after this date.'
))
completion_date = models.DateField(null=True, blank=True)
completed_by = models.ForeignKey(User,
on_delete=models.SET_NULL,
blank=True,
null=True,
related_name='builds_completed')
issued_by = models.ForeignKey(
User,
on_delete=models.SET_NULL,
blank=True,
null=True,
help_text=_('User who issued this build order'),
related_name='builds_issued',
)
responsible = models.ForeignKey(
UserModels.Owner,
on_delete=models.SET_NULL,
blank=True,
null=True,
help_text=_('User responsible for this build order'),
related_name='builds_responsible',
)
link = InvenTree.fields.InvenTreeURLField(
verbose_name=_('External Link'),
blank=True,
help_text=_('Link to external URL'))
notes = MarkdownxField(verbose_name=_('Notes'),
blank=True,
help_text=_('Extra build notes'))
@property
def is_overdue(self):
"""
Returns true if this build is "overdue":
Makes use of the OVERDUE_FILTER to avoid code duplication
"""
query = Build.objects.filter(pk=self.pk)
query = query.filter(Build.OVERDUE_FILTER)
return query.exists()
@property
def active(self):
"""
Return True if this build is active
"""
return self.status in BuildStatus.ACTIVE_CODES
@property
def bom_items(self):
"""
Returns the BOM items for the part referenced by this BuildOrder
"""
return self.part.bom_items.all().prefetch_related('sub_part')
@property
def remaining(self):
"""
Return the number of outputs remaining to be completed.
"""
return max(0, self.quantity - self.completed)
@property
def output_count(self):
return self.build_outputs.count()
def get_build_outputs(self, **kwargs):
"""
Return a list of build outputs.
kwargs:
complete = (True / False) - If supplied, filter by completed status
in_stock = (True / False) - If supplied, filter by 'in-stock' status
"""
outputs = self.build_outputs.all()
# Filter by 'in stock' status
in_stock = kwargs.get('in_stock', None)
if in_stock is not None:
if in_stock:
outputs = outputs.filter(StockModels.StockItem.IN_STOCK_FILTER)
else:
outputs = outputs.exclude(
StockModels.StockItem.IN_STOCK_FILTER)
# Filter by 'complete' status
complete = kwargs.get('complete', None)
if complete is not None:
if complete:
outputs = outputs.filter(is_building=False)
else:
outputs = outputs.filter(is_building=True)
return outputs
@property
def complete_outputs(self):
"""
Return all the "completed" build outputs
"""
outputs = self.get_build_outputs(complete=True)
# TODO - Ordering?
return outputs
@property
def incomplete_outputs(self):
"""
Return all the "incomplete" build outputs
"""
outputs = self.get_build_outputs(complete=False)
# TODO - Order by how "complete" they are?
return outputs
@property
def incomplete_count(self):
"""
Return the total number of "incomplete" outputs
"""
quantity = 0
for output in self.incomplete_outputs:
quantity += output.quantity
return quantity
@classmethod
def getNextBuildNumber(cls):
"""
Try to predict the next Build Order reference:
"""
if cls.objects.count() == 0:
return None
build = cls.objects.last()
ref = build.reference
if not ref:
return None
tries = set()
while 1:
new_ref = increment(ref)
if new_ref in tries:
# We are potentially stuck in a loop - simply return the original reference
return ref
if cls.objects.filter(reference=new_ref).exists():
tries.add(new_ref)
new_ref = increment(new_ref)
else:
break
return new_ref
@property
def can_complete(self):
"""
Returns True if this build can be "completed"
- Must not have any outstanding build outputs
- 'completed' value must meet (or exceed) the 'quantity' value
"""
if self.incomplete_count > 0:
return False
if self.completed < self.quantity:
return False
# No issues!
return True
@transaction.atomic
def complete_build(self, user):
"""
Mark this build as complete
"""
if not self.can_complete:
return
self.completion_date = datetime.now().date()
self.completed_by = user
self.status = BuildStatus.COMPLETE
self.save()
# Ensure that there are no longer any BuildItem objects
# which point to thie Build Order
self.allocated_stock.all().delete()
@transaction.atomic
def cancelBuild(self, user):
""" Mark the Build as CANCELLED
- Delete any pending BuildItem objects (but do not remove items from stock)
- Set build status to CANCELLED
- Save the Build object
"""
for item in self.allocated_stock.all():
item.delete()
# Date of 'completion' is the date the build was cancelled
self.completion_date = datetime.now().date()
self.completed_by = user
self.status = BuildStatus.CANCELLED
self.save()
def getAutoAllocations(self, output):
"""
Return a list of StockItem objects which will be allocated
using the 'AutoAllocate' function.
For each item in the BOM for the attached Part,
the following tests must *all* evaluate to True,
for the part to be auto-allocated:
- The sub_item in the BOM line must *not* be trackable
- There is only a single stock item available (which has not already been allocated to this build)
- The stock item has an availability greater than zero
Returns:
A list object containing the StockItem objects to be allocated (and the quantities).
Each item in the list is a dict as follows:
{
'stock_item': stock_item,
'quantity': stock_quantity,
}
"""
allocations = []
"""
Iterate through each item in the BOM
"""
for bom_item in self.bom_items:
part = bom_item.sub_part
# Skip any parts which are already fully allocated
if self.isPartFullyAllocated(part, output):
continue
# How many parts are required to complete the output?
required = self.unallocatedQuantity(part, output)
# Grab a list of stock items which are available
stock_items = self.availableStockItems(part, output)
# Ensure that the available stock items are in the correct location
if self.take_from is not None:
# Filter for stock that is located downstream of the designated location
stock_items = stock_items.filter(location__in=[
loc for loc in self.take_from.getUniqueChildren()
])
# Only one StockItem to choose from? Default to that one!
if stock_items.count() == 1:
stock_item = stock_items[0]
# Double check that we have not already allocated this stock-item against this build
build_items = BuildItem.objects.filter(build=self,
stock_item=stock_item,
install_into=output)
if len(build_items) > 0:
continue
# How many items are actually available?
if stock_item.quantity > 0:
# Only take as many as are available
if stock_item.quantity < required:
required = stock_item.quantity
allocation = {
'stock_item': stock_item,
'quantity': required,
}
allocations.append(allocation)
return allocations
@transaction.atomic
def unallocateStock(self, output=None, part=None):
"""
Deletes all stock allocations for this build.
Args:
output: Specify which build output to delete allocations (optional)
"""
allocations = BuildItem.objects.filter(build=self.pk)
if output:
allocations = allocations.filter(install_into=output.pk)
if part:
allocations = allocations.filter(stock_item__part=part)
# Remove all the allocations
allocations.delete()
@transaction.atomic
def create_build_output(self, quantity, **kwargs):
"""
Create a new build output against this BuildOrder.
args:
quantity: The quantity of the item to produce
kwargs:
batch: Override batch code
serials: Serial numbers
location: Override location
"""
batch = kwargs.get('batch', self.batch)
location = kwargs.get('location', self.destination)
serials = kwargs.get('serials', None)
"""
Determine if we can create a single output (with quantity > 0),
or multiple outputs (with quantity = 1)
"""
multiple = False
# Serial numbers are provided? We need to split!
if serials:
multiple = True
# BOM has trackable parts, so we must split!
if self.part.has_trackable_parts:
multiple = True
if multiple:
"""
Create multiple build outputs with a single quantity of 1
"""
for ii in range(quantity):
if serials:
serial = serials[ii]
else:
serial = None
StockModels.StockItem.objects.create(
quantity=1,
location=location,
part=self.part,
build=self,
batch=batch,
serial=serial,
is_building=True,
)
else:
"""
Create a single build output of the given quantity
"""
StockModels.StockItem.objects.create(quantity=quantity,
location=location,
part=self.part,
build=self,
batch=batch,
is_building=True)
if self.status == BuildStatus.PENDING:
self.status = BuildStatus.PRODUCTION
self.save()
@transaction.atomic
def deleteBuildOutput(self, output):
"""
Remove a build output from the database:
- Unallocate any build items against the output
- Delete the output StockItem
"""
if not output:
raise ValidationError(_("No build output specified"))
if not output.is_building:
raise ValidationError(_("Build output is already completed"))
if not output.build == self:
raise ValidationError(_("Build output does not match Build Order"))
# Unallocate all build items against the output
self.unallocateStock(output)
# Remove the build output from the database
output.delete()
@transaction.atomic
def autoAllocate(self, output):
"""
Run auto-allocation routine to allocate StockItems to this Build.
Args:
output: If specified, only auto-allocate against the given built output
Returns a list of dict objects with keys like:
{
'stock_item': item,
'quantity': quantity,
}
See: getAutoAllocations()
"""
allocations = self.getAutoAllocations(output)
for item in allocations:
# Create a new allocation
build_item = BuildItem(
build=self,
stock_item=item['stock_item'],
quantity=item['quantity'],
install_into=output,
)
build_item.save()
@transaction.atomic
def completeBuildOutput(self, output, user, **kwargs):
"""
Complete a particular build output
- Remove allocated StockItems
- Mark the output as complete
"""
# Select the location for the build output
location = kwargs.get('location', self.destination)
# List the allocated BuildItem objects for the given output
allocated_items = output.items_to_install.all()
for build_item in allocated_items:
# TODO: This is VERY SLOW as each deletion from the database takes ~1 second to complete
# TODO: Use celery / redis to offload the actual object deletion...
# REF: https://www.botreetechnologies.com/blog/implementing-celery-using-django-for-background-task-processing
# REF: https://code.tutsplus.com/tutorials/using-celery-with-django-for-background-task-processing--cms-28732
# Complete the allocation of stock for that item
build_item.complete_allocation(user)
# Delete the BuildItem objects from the database
allocated_items.all().delete()
# Ensure that the output is updated correctly
output.build = self
output.is_building = False
output.location = location
output.save()
output.addTransactionNote(_('Completed build output'),
user,
system=True)
# Increase the completed quantity for this build
self.completed += output.quantity
self.save()
def requiredQuantity(self, part, output):
"""
Get the quantity of a part required to complete the particular build output.
Args:
part: The Part object
output - The particular build output (StockItem)
"""
# Extract the BOM line item from the database
try:
bom_item = PartModels.BomItem.objects.get(part=self.part.pk,
sub_part=part.pk)
quantity = bom_item.quantity
except (PartModels.BomItem.DoesNotExist):
quantity = 0
if output:
quantity *= output.quantity
else:
quantity *= self.remaining
return quantity
def allocatedItems(self, part, output):
"""
Return all BuildItem objects which allocate stock of <part> to <output>
Args:
part - The part object
output - Build output (StockItem).
"""
allocations = BuildItem.objects.filter(
build=self,
stock_item__part=part,
install_into=output,
)
return allocations
def allocatedQuantity(self, part, output):
"""
Return the total quantity of given part allocated to a given build output.
"""
allocations = self.allocatedItems(part, output)
allocated = allocations.aggregate(q=Coalesce(Sum('quantity'), 0))
return allocated['q']
def unallocatedQuantity(self, part, output):
"""
Return the total unallocated (remaining) quantity of a part against a particular output.
"""
required = self.requiredQuantity(part, output)
allocated = self.allocatedQuantity(part, output)
return max(required - allocated, 0)
def isPartFullyAllocated(self, part, output):
"""
Returns True if the part has been fully allocated to the particular build output
"""
return self.unallocatedQuantity(part, output) == 0
def isFullyAllocated(self, output):
"""
Returns True if the particular build output is fully allocated.
"""
for bom_item in self.bom_items:
part = bom_item.sub_part
if not self.isPartFullyAllocated(part, output):
return False
# All parts must be fully allocated!
return True
def allocatedParts(self, output):
"""
Return a list of parts which have been fully allocated against a particular output
"""
allocated = []
for bom_item in self.bom_items:
part = bom_item.sub_part
if self.isPartFullyAllocated(part, output):
allocated.append(part)
return allocated
def unallocatedParts(self, output):
"""
Return a list of parts which have *not* been fully allocated against a particular output
"""
unallocated = []
for bom_item in self.bom_items:
part = bom_item.sub_part
if not self.isPartFullyAllocated(part, output):
unallocated.append(part)
return unallocated
@property
def required_parts(self):
""" Returns a dict of parts required to build this part (BOM) """
parts = []
for item in self.part.bom_items.all().prefetch_related('sub_part'):
parts.append(item.sub_part)
return parts
def availableStockItems(self, part, output):
"""
Returns stock items which are available for allocation to this build.
Args:
part - Part object
output - The particular build output
"""
# Grab initial query for items which are "in stock" and match the part
items = StockModels.StockItem.objects.filter(
StockModels.StockItem.IN_STOCK_FILTER)
items = items.filter(part=part)
# Exclude any items which have already been allocated
allocated = BuildItem.objects.filter(
build=self,
stock_item__part=part,
install_into=output,
)
items = items.exclude(
id__in=[item.stock_item.id for item in allocated.all()])
# Limit query to stock items which are "downstream" of the source location
if self.take_from is not None:
items = items.filter(location__in=[
loc for loc in self.take_from.getUniqueChildren()
])
# Exclude expired stock items
if not common.models.InvenTreeSetting.get_setting(
'STOCK_ALLOW_EXPIRED_BUILD'):
items = items.exclude(StockModels.StockItem.EXPIRED_FILTER)
return items
@property
def is_active(self):
""" Is this build active? An active build is either:
- PENDING
- HOLDING
"""
return self.status in BuildStatus.ACTIVE_CODES
@property
def is_complete(self):
""" Returns True if the build status is COMPLETE """
return self.status == BuildStatus.COMPLETE
class Build(MPTTModel):
""" A Build object organises the creation of new parts from the component parts.
Attributes:
part: The part to be built (from component BOM items)
title: Brief title describing the build (required)
quantity: Number of units to be built
parent: Reference to a Build object for which this Build is required
sales_order: References to a SalesOrder object for which this Build is required (e.g. the output of this build will be used to fulfil a sales order)
take_from: Location to take stock from to make this build (if blank, can take from anywhere)
status: Build status code
batch: Batch code transferred to build parts (optional)
creation_date: Date the build was created (auto)
completion_date: Date the build was completed
link: External URL for extra information
notes: Text notes
"""
def __str__(self):
return "{q} x {part}".format(q=decimal2string(self.quantity),
part=str(self.part.full_name))
def get_absolute_url(self):
return reverse('build-detail', kwargs={'pk': self.id})
def clean(self):
"""
Validation for Build object.
"""
super().clean()
try:
if self.part.trackable:
if not self.quantity == int(self.quantity):
raise ValidationError({
'quantity':
_("Build quantity must be integer value for trackable parts"
)
})
except PartModels.Part.DoesNotExist:
pass
title = models.CharField(verbose_name=_('Build Title'),
blank=False,
max_length=100,
help_text=_('Brief description of the build'))
parent = TreeForeignKey(
'self',
on_delete=models.DO_NOTHING,
blank=True,
null=True,
related_name='children',
verbose_name=_('Parent Build'),
help_text=_('Parent build to which this build is allocated'),
)
part = models.ForeignKey(
'part.Part',
verbose_name=_('Part'),
on_delete=models.CASCADE,
related_name='builds',
limit_choices_to={
'is_template': False,
'assembly': True,
'active': True,
'virtual': False,
},
help_text=_('Select part to build'),
)
sales_order = models.ForeignKey(
'order.SalesOrder',
verbose_name=_('Sales Order Reference'),
on_delete=models.SET_NULL,
related_name='builds',
null=True,
blank=True,
help_text=_('SalesOrder to which this build is allocated'))
take_from = models.ForeignKey(
'stock.StockLocation',
verbose_name=_('Source Location'),
on_delete=models.SET_NULL,
related_name='sourcing_builds',
null=True,
blank=True,
help_text=
_('Select location to take stock from for this build (leave blank to take from any stock location)'
))
quantity = models.PositiveIntegerField(
verbose_name=_('Build Quantity'),
default=1,
validators=[MinValueValidator(1)],
help_text=_('Number of parts to build'))
status = models.PositiveIntegerField(verbose_name=_('Build Status'),
default=BuildStatus.PENDING,
choices=BuildStatus.items(),
validators=[MinValueValidator(0)],
help_text=_('Build status code'))
batch = models.CharField(verbose_name=_('Batch Code'),
max_length=100,
blank=True,
null=True,
help_text=_('Batch code for this build output'))
creation_date = models.DateField(auto_now_add=True, editable=False)
completion_date = models.DateField(null=True, blank=True)
completed_by = models.ForeignKey(User,
on_delete=models.SET_NULL,
blank=True,
null=True,
related_name='builds_completed')
link = InvenTreeURLField(verbose_name=_('External Link'),
blank=True,
help_text=_('Link to external URL'))
notes = MarkdownxField(verbose_name=_('Notes'),
blank=True,
help_text=_('Extra build notes'))
@property
def output_count(self):
return self.build_outputs.count()
@transaction.atomic
def cancelBuild(self, user):
""" Mark the Build as CANCELLED
- Delete any pending BuildItem objects (but do not remove items from stock)
- Set build status to CANCELLED
- Save the Build object
"""
for item in self.allocated_stock.all():
item.delete()
# Date of 'completion' is the date the build was cancelled
self.completion_date = datetime.now().date()
self.completed_by = user
self.status = BuildStatus.CANCELLED
self.save()
def getAutoAllocations(self):
""" Return a list of parts which will be allocated
using the 'AutoAllocate' function.
For each item in the BOM for the attached Part:
- If there is a single StockItem, use that StockItem
- Take as many parts as available (up to the quantity required for the BOM)
- If there are multiple StockItems available, ignore (leave up to the user)
Returns:
A list object containing the StockItem objects to be allocated (and the quantities)
"""
allocations = []
for item in self.part.bom_items.all().prefetch_related('sub_part'):
# How many parts required for this build?
q_required = item.quantity * self.quantity
# Grab a list of StockItem objects which are "in stock"
stock = StockModels.StockItem.objects.filter(
StockModels.StockItem.IN_STOCK_FILTER)
# Filter by part reference
stock = stock.filter(part=item.sub_part)
# Ensure that the available stock items are in the correct location
if self.take_from is not None:
# Filter for stock that is located downstream of the designated location
stock = stock.filter(location__in=[
loc for loc in self.take_from.getUniqueChildren()
])
# Only one StockItem to choose from? Default to that one!
if len(stock) == 1:
stock_item = stock[0]
# Check that we have not already allocated this stock-item against this build
build_items = BuildItem.objects.filter(build=self,
stock_item=stock_item)
if len(build_items) > 0:
continue
# Are there any parts available?
if stock_item.quantity > 0:
# Only take as many as are available
if stock_item.quantity < q_required:
q_required = stock_item.quantity
allocation = {
'stock_item': stock_item,
'quantity': q_required,
}
allocations.append(allocation)
return allocations
@transaction.atomic
def unallocateStock(self):
""" Deletes all stock allocations for this build. """
BuildItem.objects.filter(build=self.id).delete()
@transaction.atomic
def autoAllocate(self):
""" Run auto-allocation routine to allocate StockItems to this Build.
Returns a list of dict objects with keys like:
{
'stock_item': item,
'quantity': quantity,
}
See: getAutoAllocations()
"""
allocations = self.getAutoAllocations()
for item in allocations:
# Create a new allocation
build_item = BuildItem(build=self,
stock_item=item['stock_item'],
quantity=item['quantity'])
build_item.save()
@transaction.atomic
def completeBuild(self, location, serial_numbers, user):
""" Mark the Build as COMPLETE
- Takes allocated items from stock
- Delete pending BuildItem objects
"""
# Complete the build allocation for each BuildItem
for build_item in self.allocated_stock.all().prefetch_related(
'stock_item'):
build_item.complete_allocation(user)
# Check that the stock-item has been assigned to this build, and remove the builditem from the database
if build_item.stock_item.build_order == self:
build_item.delete()
notes = 'Built {q} on {now}'.format(q=self.quantity,
now=str(datetime.now().date()))
# Generate the build outputs
if self.part.trackable and serial_numbers:
# Add new serial numbers
for serial in serial_numbers:
item = StockModels.StockItem.objects.create(
part=self.part,
build=self,
location=location,
quantity=1,
serial=serial,
batch=str(self.batch) if self.batch else '',
notes=notes)
item.save()
else:
# Add stock of the newly created item
item = StockModels.StockItem.objects.create(
part=self.part,
build=self,
location=location,
quantity=self.quantity,
batch=str(self.batch) if self.batch else '',
notes=notes)
item.save()
# Finally, mark the build as complete
self.completion_date = datetime.now().date()
self.completed_by = user
self.status = BuildStatus.COMPLETE
self.save()
return True
def isFullyAllocated(self):
"""
Return True if this build has been fully allocated.
"""
bom_items = self.part.bom_items.all()
for item in bom_items:
part = item.sub_part
if not self.isPartFullyAllocated(part):
return False
return True
def isPartFullyAllocated(self, part):
"""
Check if a given Part is fully allocated for this Build
"""
return self.getAllocatedQuantity(part) >= self.getRequiredQuantity(
part)
def getRequiredQuantity(self, part):
""" Calculate the quantity of <part> required to make this build.
"""
try:
item = PartModels.BomItem.objects.get(part=self.part.id,
sub_part=part.id)
q = item.quantity
except PartModels.BomItem.DoesNotExist:
q = 0
return q * self.quantity
def getAllocatedQuantity(self, part):
""" Calculate the total number of <part> currently allocated to this build
"""
allocated = BuildItem.objects.filter(
build=self.id,
stock_item__part=part.id).aggregate(q=Coalesce(Sum('quantity'), 0))
return allocated['q']
def getUnallocatedQuantity(self, part):
""" Calculate the quantity of <part> which still needs to be allocated to this build.
Args:
Part - the part to be tested
Returns:
The remaining allocated quantity
"""
return max(
self.getRequiredQuantity(part) - self.getAllocatedQuantity(part),
0)
@property
def required_parts(self):
""" Returns a dict of parts required to build this part (BOM) """
parts = []
for item in self.part.bom_items.all().prefetch_related('sub_part'):
part = {
'part': item.sub_part,
'per_build': item.quantity,
'quantity': item.quantity * self.quantity,
'allocated': self.getAllocatedQuantity(item.sub_part)
}
parts.append(part)
return parts
@property
def can_build(self):
""" Return true if there are enough parts to supply build """
for item in self.required_parts:
if item['part'].total_stock < item['quantity']:
return False
return True
@property
def is_active(self):
""" Is this build active? An active build is either:
- PENDING
- HOLDING
"""
return self.status in BuildStatus.ACTIVE_CODES
@property
def is_complete(self):
""" Returns True if the build status is COMPLETE """
return self.status == BuildStatus.COMPLETE
class Build(models.Model):
""" A Build object organises the creation of new parts from the component parts.
Attributes:
part: The part to be built (from component BOM items)
title: Brief title describing the build (required)
quantity: Number of units to be built
take_from: Location to take stock from to make this build (if blank, can take from anywhere)
status: Build status code
batch: Batch code transferred to build parts (optional)
creation_date: Date the build was created (auto)
completion_date: Date the build was completed
URL: External URL for extra information
notes: Text notes
"""
def __str__(self):
return "Build {q} x {part}".format(q=self.quantity,
part=str(self.part))
def get_absolute_url(self):
return reverse('build-detail', kwargs={'pk': self.id})
title = models.CharField(blank=False,
max_length=100,
help_text='Brief description of the build')
part = models.ForeignKey(
'part.Part',
on_delete=models.CASCADE,
related_name='builds',
limit_choices_to={
'is_template': False,
'assembly': True,
'active': True
},
help_text='Select part to build',
)
take_from = models.ForeignKey(
'stock.StockLocation',
on_delete=models.SET_NULL,
related_name='sourcing_builds',
null=True,
blank=True,
help_text=
'Select location to take stock from for this build (leave blank to take from any stock location)'
)
quantity = models.PositiveIntegerField(
default=1,
validators=[MinValueValidator(1)],
help_text='Number of parts to build')
status = models.PositiveIntegerField(default=BuildStatus.PENDING,
choices=BuildStatus.items(),
validators=[MinValueValidator(0)],
help_text='Build status')
batch = models.CharField(max_length=100,
blank=True,
null=True,
help_text='Batch code for this build output')
creation_date = models.DateField(auto_now=True, editable=False)
completion_date = models.DateField(null=True, blank=True)
completed_by = models.ForeignKey(User,
on_delete=models.SET_NULL,
blank=True,
null=True,
related_name='builds_completed')
URL = models.URLField(blank=True, help_text='Link to external URL')
notes = models.TextField(blank=True, help_text='Extra build notes')
""" Notes attached to each build output """
@transaction.atomic
def cancelBuild(self, user):
""" Mark the Build as CANCELLED
- Delete any pending BuildItem objects (but do not remove items from stock)
- Set build status to CANCELLED
- Save the Build object
"""
for item in self.allocated_stock.all():
item.delete()
# Date of 'completion' is the date the build was cancelled
self.completion_date = datetime.now().date()
self.completed_by = user
self.status = BuildStatus.CANCELLED
self.save()
def getAutoAllocations(self):
""" Return a list of parts which will be allocated
using the 'AutoAllocate' function.
For each item in the BOM for the attached Part:
- If there is a single StockItem, use that StockItem
- Take as many parts as available (up to the quantity required for the BOM)
- If there are multiple StockItems available, ignore (leave up to the user)
Returns:
A list object containing the StockItem objects to be allocated (and the quantities)
"""
allocations = []
for item in self.part.bom_items.all().prefetch_related('sub_part'):
# How many parts required for this build?
q_required = item.quantity * self.quantity
stock = StockItem.objects.filter(part=item.sub_part)
# Ensure that the available stock items are in the correct location
if self.take_from is not None:
# Filter for stock that is located downstream of the designated location
stock = stock.filter(location__in=[
loc for loc in self.take_from.getUniqueChildren()
])
# Only one StockItem to choose from? Default to that one!
if len(stock) == 1:
stock_item = stock[0]
# Check that we have not already allocated this stock-item against this build
build_items = BuildItem.objects.filter(build=self,
stock_item=stock_item)
if len(build_items) > 0:
continue
# Are there any parts available?
if stock_item.quantity > 0:
# Only take as many as are available
if stock_item.quantity < q_required:
q_required = stock_item.quantity
allocation = {
'stock_item': stock_item,
'quantity': q_required,
}
allocations.append(allocation)
return allocations
@transaction.atomic
def unallocateStock(self):
""" Deletes all stock allocations for this build. """
BuildItem.objects.filter(build=self.id).delete()
@transaction.atomic
def autoAllocate(self):
""" Run auto-allocation routine to allocate StockItems to this Build.
Returns a list of dict objects with keys like:
{
'stock_item': item,
'quantity': quantity,
}
See: getAutoAllocations()
"""
allocations = self.getAutoAllocations()
for item in allocations:
# Create a new allocation
build_item = BuildItem(build=self,
stock_item=item['stock_item'],
quantity=item['quantity'])
build_item.save()
@transaction.atomic
def completeBuild(self, location, serial_numbers, user):
""" Mark the Build as COMPLETE
- Takes allocated items from stock
- Delete pending BuildItem objects
"""
for item in self.allocated_stock.all().prefetch_related('stock_item'):
# Subtract stock from the item
item.stock_item.take_stock(
item.quantity, user,
'Removed {n} items to build {m} x {part}'.format(
n=item.quantity, m=self.quantity,
part=self.part.full_name))
# Delete the item
item.delete()
# Mark the date of completion
self.completion_date = datetime.now().date()
self.completed_by = user
notes = 'Built {q} on {now}'.format(q=self.quantity,
now=str(datetime.now().date()))
if self.part.trackable:
# Add new serial numbers
for serial in serial_numbers:
item = StockItem.objects.create(
part=self.part,
location=location,
quantity=1,
serial=serial,
batch=str(self.batch) if self.batch else '',
notes=notes)
item.save()
else:
# Add stock of the newly created item
item = StockItem.objects.create(
part=self.part,
location=location,
quantity=self.quantity,
batch=str(self.batch) if self.batch else '',
notes=notes)
item.save()
# Finally, mark the build as complete
self.status = BuildStatus.COMPLETE
self.save()
def getRequiredQuantity(self, part):
""" Calculate the quantity of <part> required to make this build.
"""
try:
item = BomItem.objects.get(part=self.part.id, sub_part=part.id)
return item.get_required_quantity(self.quantity)
except BomItem.DoesNotExist:
return 0
def getAllocatedQuantity(self, part):
""" Calculate the total number of <part> currently allocated to this build
"""
allocated = BuildItem.objects.filter(
build=self.id, stock_item__part=part.id).aggregate(Sum('quantity'))
q = allocated['quantity__sum']
if q:
return int(q)
else:
return 0
def getUnallocatedQuantity(self, part):
""" Calculate the quantity of <part> which still needs to be allocated to this build.
Args:
Part - the part to be tested
Returns:
The remaining allocated quantity
"""
return max(
self.getRequiredQuantity(part) - self.getAllocatedQuantity(part),
0)
@property
def required_parts(self):
""" Returns a dict of parts required to build this part (BOM) """
parts = []
for item in self.part.bom_items.all().prefetch_related('sub_part'):
part = {
'part': item.sub_part,
'per_build': item.quantity,
'quantity': item.quantity * self.quantity,
'allocated': self.getAllocatedQuantity(item.sub_part)
}
parts.append(part)
return parts
@property
def can_build(self):
""" Return true if there are enough parts to supply build """
for item in self.required_parts:
if item['part'].total_stock < item['quantity']:
return False
return True
@property
def is_active(self):
""" Is this build active? An active build is either:
- PENDING
- HOLDING
"""
return self.status in BuildStatus.ACTIVE_CODES
@property
def is_complete(self):
""" Returns True if the build status is COMPLETE """
return self.status == BuildStatus.COMPLETE
class Build(MPTTModel, ReferenceIndexingMixin):
""" A Build object organises the creation of new StockItem objects from other existing StockItem objects.
Attributes:
part: The part to be built (from component BOM items)
reference: Build order reference (required, must be unique)
title: Brief title describing the build (required)
quantity: Number of units to be built
parent: Reference to a Build object for which this Build is required
sales_order: References to a SalesOrder object for which this Build is required (e.g. the output of this build will be used to fulfil a sales order)
take_from: Location to take stock from to make this build (if blank, can take from anywhere)
status: Build status code
batch: Batch code transferred to build parts (optional)
creation_date: Date the build was created (auto)
target_date: Date the build will be overdue
completion_date: Date the build was completed (or, if incomplete, the expected date of completion)
link: External URL for extra information
notes: Text notes
completed_by: User that completed the build
issued_by: User that issued the build
responsible: User (or group) responsible for completing the build
"""
OVERDUE_FILTER = Q(status__in=BuildStatus.ACTIVE_CODES) & ~Q(
target_date=None) & Q(target_date__lte=datetime.now().date())
@staticmethod
def get_api_url():
return reverse('api-build-list')
def api_instance_filters(self):
return {
'parent': {
'exclude_tree': self.pk,
}
}
@classmethod
def api_defaults(cls, request):
"""
Return default values for this model when issuing an API OPTIONS request
"""
defaults = {
'reference': get_next_build_number(),
}
if request and request.user:
defaults['issued_by'] = request.user.pk
return defaults
def save(self, *args, **kwargs):
self.rebuild_reference_field()
try:
super().save(*args, **kwargs)
except InvalidMove:
raise ValidationError({
'parent':
_('Invalid choice for parent build'),
})
class Meta:
verbose_name = _("Build Order")
verbose_name_plural = _("Build Orders")
def format_barcode(self, **kwargs):
"""
Return a JSON string to represent this build as a barcode
"""
return MakeBarcode("buildorder", self.pk, {
"reference": self.title,
"url": self.get_absolute_url(),
})
@staticmethod
def filterByDate(queryset, min_date, max_date):
"""
Filter by 'minimum and maximum date range'
- Specified as min_date, max_date
- Both must be specified for filter to be applied
"""
date_fmt = '%Y-%m-%d' # ISO format date string
# Ensure that both dates are valid
try:
min_date = datetime.strptime(str(min_date), date_fmt).date()
max_date = datetime.strptime(str(max_date), date_fmt).date()
except (ValueError, TypeError):
# Date processing error, return queryset unchanged
return queryset
# Order was completed within the specified range
completed = Q(status=BuildStatus.COMPLETE) & Q(
completion_date__gte=min_date) & Q(completion_date__lte=max_date)
# Order target date falls witin specified range
pending = Q(
status__in=BuildStatus.ACTIVE_CODES) & ~Q(target_date=None) & Q(
target_date__gte=min_date) & Q(target_date__lte=max_date)
# TODO - Construct a queryset for "overdue" orders
queryset = queryset.filter(completed | pending)
return queryset
def __str__(self):
prefix = getSetting("BUILDORDER_REFERENCE_PREFIX")
return f"{prefix}{self.reference}"
def get_absolute_url(self):
return reverse('build-detail', kwargs={'pk': self.id})
reference = models.CharField(unique=True,
max_length=64,
blank=False,
help_text=_('Build Order Reference'),
verbose_name=_('Reference'),
default=get_next_build_number,
validators=[validate_build_order_reference])
title = models.CharField(verbose_name=_('Description'),
blank=False,
max_length=100,
help_text=_('Brief description of the build'))
# TODO - Perhaps delete the build "tree"
parent = TreeForeignKey(
'self',
on_delete=models.SET_NULL,
blank=True,
null=True,
related_name='children',
verbose_name=_('Parent Build'),
help_text=_('BuildOrder to which this build is allocated'),
)
part = models.ForeignKey(
'part.Part',
verbose_name=_('Part'),
on_delete=models.CASCADE,
related_name='builds',
limit_choices_to={
'assembly': True,
'active': True,
'virtual': False,
},
help_text=_('Select part to build'),
)
sales_order = models.ForeignKey(
'order.SalesOrder',
verbose_name=_('Sales Order Reference'),
on_delete=models.SET_NULL,
related_name='builds',
null=True,
blank=True,
help_text=_('SalesOrder to which this build is allocated'))
take_from = models.ForeignKey(
'stock.StockLocation',
verbose_name=_('Source Location'),
on_delete=models.SET_NULL,
related_name='sourcing_builds',
null=True,
blank=True,
help_text=
_('Select location to take stock from for this build (leave blank to take from any stock location)'
))
destination = models.ForeignKey(
'stock.StockLocation',
verbose_name=_('Destination Location'),
on_delete=models.SET_NULL,
related_name='incoming_builds',
null=True,
blank=True,
help_text=_(
'Select location where the completed items will be stored'),
)
quantity = models.PositiveIntegerField(
verbose_name=_('Build Quantity'),
default=1,
validators=[MinValueValidator(1)],
help_text=_('Number of stock items to build'))
completed = models.PositiveIntegerField(
verbose_name=_('Completed items'),
default=0,
help_text=_('Number of stock items which have been completed'))
status = models.PositiveIntegerField(verbose_name=_('Build Status'),
default=BuildStatus.PENDING,
choices=BuildStatus.items(),
validators=[MinValueValidator(0)],
help_text=_('Build status code'))
batch = models.CharField(verbose_name=_('Batch Code'),
max_length=100,
blank=True,
null=True,
help_text=_('Batch code for this build output'))
creation_date = models.DateField(auto_now_add=True,
editable=False,
verbose_name=_('Creation Date'))
target_date = models.DateField(
null=True,
blank=True,
verbose_name=_('Target completion date'),
help_text=
_('Target date for build completion. Build will be overdue after this date.'
))
completion_date = models.DateField(null=True,
blank=True,
verbose_name=_('Completion Date'))
completed_by = models.ForeignKey(User,
on_delete=models.SET_NULL,
blank=True,
null=True,
verbose_name=_('completed by'),
related_name='builds_completed')
issued_by = models.ForeignKey(
User,
on_delete=models.SET_NULL,
blank=True,
null=True,
verbose_name=_('Issued by'),
help_text=_('User who issued this build order'),
related_name='builds_issued',
)
responsible = models.ForeignKey(
UserModels.Owner,
on_delete=models.SET_NULL,
blank=True,
null=True,
verbose_name=_('Responsible'),
help_text=_('User responsible for this build order'),
related_name='builds_responsible',
)
link = InvenTree.fields.InvenTreeURLField(
verbose_name=_('External Link'),
blank=True,
help_text=_('Link to external URL'))
notes = MarkdownxField(verbose_name=_('Notes'),
blank=True,
help_text=_('Extra build notes'))
def sub_builds(self, cascade=True):
"""
Return all Build Order objects under this one.
"""
if cascade:
return Build.objects.filter(parent=self.pk)
else:
descendants = self.get_descendants(include_self=True)
Build.objects.filter(parent__pk__in=[d.pk for d in descendants])
def sub_build_count(self, cascade=True):
"""
Return the number of sub builds under this one.
Args:
cascade: If True (defualt), include cascading builds under sub builds
"""
return self.sub_builds(cascade=cascade).count()
@property
def is_overdue(self):
"""
Returns true if this build is "overdue":
Makes use of the OVERDUE_FILTER to avoid code duplication
"""
query = Build.objects.filter(pk=self.pk)
query = query.filter(Build.OVERDUE_FILTER)
return query.exists()
@property
def active(self):
"""
Return True if this build is active
"""
return self.status in BuildStatus.ACTIVE_CODES
@property
def bom_items(self):
"""
Returns the BOM items for the part referenced by this BuildOrder
"""
return self.part.bom_items.all().prefetch_related('sub_part')
@property
def tracked_bom_items(self):
"""
Returns the "trackable" BOM items for this BuildOrder
"""
items = self.bom_items
items = items.filter(sub_part__trackable=True)
return items
def has_tracked_bom_items(self):
"""
Returns True if this BuildOrder has trackable BomItems
"""
return self.tracked_bom_items.count() > 0
@property
def untracked_bom_items(self):
"""
Returns the "non trackable" BOM items for this BuildOrder
"""
items = self.bom_items
items = items.filter(sub_part__trackable=False)
return items
def has_untracked_bom_items(self):
"""
Returns True if this BuildOrder has non trackable BomItems
"""
return self.untracked_bom_items.count() > 0
@property
def remaining(self):
"""
Return the number of outputs remaining to be completed.
"""
return max(0, self.quantity - self.completed)
@property
def output_count(self):
return self.build_outputs.count()
def get_build_outputs(self, **kwargs):
"""
Return a list of build outputs.
kwargs:
complete = (True / False) - If supplied, filter by completed status
in_stock = (True / False) - If supplied, filter by 'in-stock' status
"""
outputs = self.build_outputs.all()
# Filter by 'in stock' status
in_stock = kwargs.get('in_stock', None)
if in_stock is not None:
if in_stock:
outputs = outputs.filter(StockModels.StockItem.IN_STOCK_FILTER)
else:
outputs = outputs.exclude(
StockModels.StockItem.IN_STOCK_FILTER)
# Filter by 'complete' status
complete = kwargs.get('complete', None)
if complete is not None:
if complete:
outputs = outputs.filter(is_building=False)
else:
outputs = outputs.filter(is_building=True)
return outputs
@property
def complete_outputs(self):
"""
Return all the "completed" build outputs
"""
outputs = self.get_build_outputs(complete=True)
# TODO - Ordering?
return outputs
@property
def incomplete_outputs(self):
"""
Return all the "incomplete" build outputs
"""
outputs = self.get_build_outputs(complete=False)
# TODO - Order by how "complete" they are?
return outputs
@property
def incomplete_count(self):
"""
Return the total number of "incomplete" outputs
"""
quantity = 0
for output in self.incomplete_outputs:
quantity += output.quantity
return quantity
@classmethod
def getNextBuildNumber(cls):
"""
Try to predict the next Build Order reference:
"""
if cls.objects.count() == 0:
return None
# Extract the "most recent" build order reference
builds = cls.objects.exclude(reference=None)
if not builds.exists():
return None
build = builds.last()
ref = build.reference
if not ref:
return None
tries = set(ref)
new_ref = ref
while 1:
new_ref = increment(new_ref)
if new_ref in tries:
# We are potentially stuck in a loop - simply return the original reference
return ref
# Check if the existing build reference exists
if cls.objects.filter(reference=new_ref).exists():
tries.add(new_ref)
else:
break
return new_ref
@property
def can_complete(self):
"""
Returns True if this build can be "completed"
- Must not have any outstanding build outputs
- 'completed' value must meet (or exceed) the 'quantity' value
"""
if self.incomplete_count > 0:
return False
if self.completed < self.quantity:
return False
if not self.areUntrackedPartsFullyAllocated():
return False
# No issues!
return True
@transaction.atomic
def complete_build(self, user):
"""
Mark this build as complete
"""
if self.incomplete_count > 0:
return
self.completion_date = datetime.now().date()
self.completed_by = user
self.status = BuildStatus.COMPLETE
self.save()
# Remove untracked allocated stock
self.subtractUntrackedStock(user)
# Ensure that there are no longer any BuildItem objects
# which point to thie Build Order
self.allocated_stock.all().delete()
@transaction.atomic
def cancelBuild(self, user):
""" Mark the Build as CANCELLED
- Delete any pending BuildItem objects (but do not remove items from stock)
- Set build status to CANCELLED
- Save the Build object
"""
for item in self.allocated_stock.all():
item.delete()
# Date of 'completion' is the date the build was cancelled
self.completion_date = datetime.now().date()
self.completed_by = user
self.status = BuildStatus.CANCELLED
self.save()
@transaction.atomic
def unallocateStock(self, bom_item=None, output=None):
"""
Unallocate stock from this Build
arguments:
- bom_item: Specify a particular BomItem to unallocate stock against
- output: Specify a particular StockItem (output) to unallocate stock against
"""
allocations = BuildItem.objects.filter(build=self, install_into=output)
if bom_item:
allocations = allocations.filter(bom_item=bom_item)
allocations.delete()
@transaction.atomic
def create_build_output(self, quantity, **kwargs):
"""
Create a new build output against this BuildOrder.
args:
quantity: The quantity of the item to produce
kwargs:
batch: Override batch code
serials: Serial numbers
location: Override location
"""
batch = kwargs.get('batch', self.batch)
location = kwargs.get('location', self.destination)
serials = kwargs.get('serials', None)
"""
Determine if we can create a single output (with quantity > 0),
or multiple outputs (with quantity = 1)
"""
multiple = False
# Serial numbers are provided? We need to split!
if serials:
multiple = True
# BOM has trackable parts, so we must split!
if self.part.has_trackable_parts:
multiple = True
if multiple:
"""
Create multiple build outputs with a single quantity of 1
"""
for ii in range(quantity):
if serials:
serial = serials[ii]
else:
serial = None
StockModels.StockItem.objects.create(
quantity=1,
location=location,
part=self.part,
build=self,
batch=batch,
serial=serial,
is_building=True,
)
else:
"""
Create a single build output of the given quantity
"""
StockModels.StockItem.objects.create(quantity=quantity,
location=location,
part=self.part,
build=self,
batch=batch,
is_building=True)
if self.status == BuildStatus.PENDING:
self.status = BuildStatus.PRODUCTION
self.save()
@transaction.atomic
def deleteBuildOutput(self, output):
"""
Remove a build output from the database:
- Unallocate any build items against the output
- Delete the output StockItem
"""
if not output:
raise ValidationError(_("No build output specified"))
if not output.is_building:
raise ValidationError(_("Build output is already completed"))
if not output.build == self:
raise ValidationError(_("Build output does not match Build Order"))
# Unallocate all build items against the output
self.unallocateStock(output=output)
# Remove the build output from the database
output.delete()
@transaction.atomic
def subtractUntrackedStock(self, user):
"""
Called when the Build is marked as "complete",
this function removes the allocated untracked items from stock.
"""
items = self.allocated_stock.filter(stock_item__part__trackable=False)
# Remove stock
for item in items:
item.complete_allocation(user)
# Delete allocation
items.all().delete()
@transaction.atomic
def complete_build_output(self, output, user, **kwargs):
"""
Complete a particular build output
- Remove allocated StockItems
- Mark the output as complete
"""
# Select the location for the build output
location = kwargs.get('location', self.destination)
status = kwargs.get('status', StockStatus.OK)
notes = kwargs.get('notes', '')
# List the allocated BuildItem objects for the given output
allocated_items = output.items_to_install.all()
for build_item in allocated_items:
# Complete the allocation of stock for that item
build_item.complete_allocation(user)
# Delete the BuildItem objects from the database
allocated_items.all().delete()
# Ensure that the output is updated correctly
output.build = self
output.is_building = False
output.location = location
output.status = status
output.save()
output.add_tracking_entry(StockHistoryCode.BUILD_OUTPUT_COMPLETED,
user,
notes=notes,
deltas={
'status': status,
})
# Increase the completed quantity for this build
self.completed += output.quantity
self.save()
def requiredQuantity(self, part, output):
"""
Get the quantity of a part required to complete the particular build output.
Args:
part: The Part object
output - The particular build output (StockItem)
"""
# Extract the BOM line item from the database
try:
bom_item = PartModels.BomItem.objects.get(part=self.part.pk,
sub_part=part.pk)
quantity = bom_item.quantity
except (PartModels.BomItem.DoesNotExist):
quantity = 0
if output:
quantity *= output.quantity
else:
quantity *= self.quantity
return quantity
def allocatedItems(self, part, output):
"""
Return all BuildItem objects which allocate stock of <part> to <output>
Args:
part - The part object
output - Build output (StockItem).
"""
# Remember, if 'variant' stock is allowed to be allocated, it becomes more complicated!
variants = part.get_descendants(include_self=True)
allocations = BuildItem.objects.filter(
build=self,
stock_item__part__pk__in=[p.pk for p in variants],
install_into=output,
)
return allocations
def allocatedQuantity(self, part, output):
"""
Return the total quantity of given part allocated to a given build output.
"""
allocations = self.allocatedItems(part, output)
allocated = allocations.aggregate(q=Coalesce(
Sum('quantity'),
0,
output_field=models.DecimalField(),
))
return allocated['q']
def unallocatedQuantity(self, part, output):
"""
Return the total unallocated (remaining) quantity of a part against a particular output.
"""
required = self.requiredQuantity(part, output)
allocated = self.allocatedQuantity(part, output)
return max(required - allocated, 0)
def isPartFullyAllocated(self, part, output):
"""
Returns True if the part has been fully allocated to the particular build output
"""
return self.unallocatedQuantity(part, output) == 0
def isFullyAllocated(self, output, verbose=False):
"""
Returns True if the particular build output is fully allocated.
"""
# If output is not specified, we are talking about "untracked" items
if output is None:
bom_items = self.untracked_bom_items
else:
bom_items = self.tracked_bom_items
fully_allocated = True
for bom_item in bom_items:
part = bom_item.sub_part
if not self.isPartFullyAllocated(part, output):
fully_allocated = False
if verbose:
print(
f"Part {part} is not fully allocated for output {output}"
)
else:
break
# All parts must be fully allocated!
return fully_allocated
def areUntrackedPartsFullyAllocated(self):
"""
Returns True if the un-tracked parts are fully allocated for this BuildOrder
"""
return self.isFullyAllocated(None)
def allocatedParts(self, output):
"""
Return a list of parts which have been fully allocated against a particular output
"""
allocated = []
# If output is not specified, we are talking about "untracked" items
if output is None:
bom_items = self.untracked_bom_items
else:
bom_items = self.tracked_bom_items
for bom_item in bom_items:
part = bom_item.sub_part
if self.isPartFullyAllocated(part, output):
allocated.append(part)
return allocated
def unallocatedParts(self, output):
"""
Return a list of parts which have *not* been fully allocated against a particular output
"""
unallocated = []
# If output is not specified, we are talking about "untracked" items
if output is None:
bom_items = self.untracked_bom_items
else:
bom_items = self.tracked_bom_items
for bom_item in bom_items:
part = bom_item.sub_part
if not self.isPartFullyAllocated(part, output):
unallocated.append(part)
return unallocated
@property
def required_parts(self):
""" Returns a list of parts required to build this part (BOM) """
parts = []
for item in self.bom_items:
parts.append(item.sub_part)
return parts
@property
def required_parts_to_complete_build(self):
""" Returns a list of parts required to complete the full build """
parts = []
for bom_item in self.bom_items:
# Get remaining quantity needed
required_quantity_to_complete_build = self.remaining * bom_item.quantity
# Compare to net stock
if bom_item.sub_part.net_stock < required_quantity_to_complete_build:
parts.append(bom_item.sub_part)
return parts
def availableStockItems(self, part, output):
"""
Returns stock items which are available for allocation to this build.
Args:
part - Part object
output - The particular build output
"""
# Grab initial query for items which are "in stock" and match the part
items = StockModels.StockItem.objects.filter(
StockModels.StockItem.IN_STOCK_FILTER)
# Check if variants are allowed for this part
try:
bom_item = PartModels.BomItem.objects.get(part=self.part,
sub_part=part)
allow_part_variants = bom_item.allow_variants
except PartModels.BomItem.DoesNotExist:
allow_part_variants = False
if allow_part_variants:
parts = part.get_descendants(include_self=True)
items = items.filter(part__pk__in=[p.pk for p in parts])
else:
items = items.filter(part=part)
# Exclude any items which have already been allocated
allocated = BuildItem.objects.filter(
build=self,
stock_item__part=part,
install_into=output,
)
items = items.exclude(
id__in=[item.stock_item.id for item in allocated.all()])
# Limit query to stock items which are "downstream" of the source location
if self.take_from is not None:
items = items.filter(location__in=[
loc for loc in self.take_from.getUniqueChildren()
])
# Exclude expired stock items
if not common.models.InvenTreeSetting.get_setting(
'STOCK_ALLOW_EXPIRED_BUILD'):
items = items.exclude(StockModels.StockItem.EXPIRED_FILTER)
return items
@property
def is_active(self):
""" Is this build active? An active build is either:
- PENDING
- HOLDING
"""
return self.status in BuildStatus.ACTIVE_CODES
@property
def is_complete(self):
""" Returns True if the build status is COMPLETE """
return self.status == BuildStatus.COMPLETE
def build_status(key, *args, **kwargs):
return mark_safe(BuildStatus.render(key))
class Build(MPTTModel, ReferenceIndexingMixin):
"""A Build object organises the creation of new StockItem objects from other existing StockItem objects.
Attributes:
part: The part to be built (from component BOM items)
reference: Build order reference (required, must be unique)
title: Brief title describing the build (required)
quantity: Number of units to be built
parent: Reference to a Build object for which this Build is required
sales_order: References to a SalesOrder object for which this Build is required (e.g. the output of this build will be used to fulfil a sales order)
take_from: Location to take stock from to make this build (if blank, can take from anywhere)
status: Build status code
batch: Batch code transferred to build parts (optional)
creation_date: Date the build was created (auto)
target_date: Date the build will be overdue
completion_date: Date the build was completed (or, if incomplete, the expected date of completion)
link: External URL for extra information
notes: Text notes
completed_by: User that completed the build
issued_by: User that issued the build
responsible: User (or group) responsible for completing the build
"""
OVERDUE_FILTER = Q(status__in=BuildStatus.ACTIVE_CODES) & ~Q(
target_date=None) & Q(target_date__lte=datetime.now().date())
# Global setting for specifying reference pattern
REFERENCE_PATTERN_SETTING = 'BUILDORDER_REFERENCE_PATTERN'
@staticmethod
def get_api_url():
"""Return the API URL associated with the BuildOrder model"""
return reverse('api-build-list')
def api_instance_filters(self):
"""Returns custom API filters for the particular BuildOrder instance"""
return {
'parent': {
'exclude_tree': self.pk,
}
}
@classmethod
def api_defaults(cls, request):
"""Return default values for this model when issuing an API OPTIONS request."""
defaults = {
'reference': generate_next_build_reference(),
}
if request and request.user:
defaults['issued_by'] = request.user.pk
return defaults
def save(self, *args, **kwargs):
"""Custom save method for the BuildOrder model"""
self.validate_reference_field(self.reference)
self.reference_int = self.rebuild_reference_field(self.reference)
try:
super().save(*args, **kwargs)
except InvalidMove:
raise ValidationError({
'parent':
_('Invalid choice for parent build'),
})
class Meta:
"""Metaclass options for the BuildOrder model"""
verbose_name = _("Build Order")
verbose_name_plural = _("Build Orders")
def format_barcode(self, **kwargs):
"""Return a JSON string to represent this build as a barcode."""
return MakeBarcode("buildorder", self.pk, {
"reference": self.title,
"url": self.get_absolute_url(),
})
@staticmethod
def filterByDate(queryset, min_date, max_date):
"""Filter by 'minimum and maximum date range'.
- Specified as min_date, max_date
- Both must be specified for filter to be applied
"""
date_fmt = '%Y-%m-%d' # ISO format date string
# Ensure that both dates are valid
try:
min_date = datetime.strptime(str(min_date), date_fmt).date()
max_date = datetime.strptime(str(max_date), date_fmt).date()
except (ValueError, TypeError):
# Date processing error, return queryset unchanged
return queryset
# Order was completed within the specified range
completed = Q(status=BuildStatus.COMPLETE) & Q(
completion_date__gte=min_date) & Q(completion_date__lte=max_date)
# Order target date falls witin specified range
pending = Q(
status__in=BuildStatus.ACTIVE_CODES) & ~Q(target_date=None) & Q(
target_date__gte=min_date) & Q(target_date__lte=max_date)
# TODO - Construct a queryset for "overdue" orders
queryset = queryset.filter(completed | pending)
return queryset
def __str__(self):
"""String representation of a BuildOrder"""
return self.reference
def get_absolute_url(self):
"""Return the web URL associated with this BuildOrder"""
return reverse('build-detail', kwargs={'pk': self.id})
reference = models.CharField(unique=True,
max_length=64,
blank=False,
help_text=_('Build Order Reference'),
verbose_name=_('Reference'),
default=generate_next_build_reference,
validators=[
validate_build_order_reference,
])
title = models.CharField(verbose_name=_('Description'),
blank=False,
max_length=100,
help_text=_('Brief description of the build'))
parent = TreeForeignKey(
'self',
on_delete=models.SET_NULL,
blank=True,
null=True,
related_name='children',
verbose_name=_('Parent Build'),
help_text=_('BuildOrder to which this build is allocated'),
)
part = models.ForeignKey(
'part.Part',
verbose_name=_('Part'),
on_delete=models.CASCADE,
related_name='builds',
limit_choices_to={
'assembly': True,
'active': True,
'virtual': False,
},
help_text=_('Select part to build'),
)
sales_order = models.ForeignKey(
'order.SalesOrder',
verbose_name=_('Sales Order Reference'),
on_delete=models.SET_NULL,
related_name='builds',
null=True,
blank=True,
help_text=_('SalesOrder to which this build is allocated'))
take_from = models.ForeignKey(
'stock.StockLocation',
verbose_name=_('Source Location'),
on_delete=models.SET_NULL,
related_name='sourcing_builds',
null=True,
blank=True,
help_text=
_('Select location to take stock from for this build (leave blank to take from any stock location)'
))
destination = models.ForeignKey(
'stock.StockLocation',
verbose_name=_('Destination Location'),
on_delete=models.SET_NULL,
related_name='incoming_builds',
null=True,
blank=True,
help_text=_(
'Select location where the completed items will be stored'),
)
quantity = models.PositiveIntegerField(
verbose_name=_('Build Quantity'),
default=1,
validators=[MinValueValidator(1)],
help_text=_('Number of stock items to build'))
completed = models.PositiveIntegerField(
verbose_name=_('Completed items'),
default=0,
help_text=_('Number of stock items which have been completed'))
status = models.PositiveIntegerField(verbose_name=_('Build Status'),
default=BuildStatus.PENDING,
choices=BuildStatus.items(),
validators=[MinValueValidator(0)],
help_text=_('Build status code'))
batch = models.CharField(verbose_name=_('Batch Code'),
max_length=100,
blank=True,
null=True,
help_text=_('Batch code for this build output'))
creation_date = models.DateField(auto_now_add=True,
editable=False,
verbose_name=_('Creation Date'))
target_date = models.DateField(
null=True,
blank=True,
verbose_name=_('Target completion date'),
help_text=
_('Target date for build completion. Build will be overdue after this date.'
))
completion_date = models.DateField(null=True,
blank=True,
verbose_name=_('Completion Date'))
completed_by = models.ForeignKey(User,
on_delete=models.SET_NULL,
blank=True,
null=True,
verbose_name=_('completed by'),
related_name='builds_completed')
issued_by = models.ForeignKey(
User,
on_delete=models.SET_NULL,
blank=True,
null=True,
verbose_name=_('Issued by'),
help_text=_('User who issued this build order'),
related_name='builds_issued',
)
responsible = models.ForeignKey(
UserModels.Owner,
on_delete=models.SET_NULL,
blank=True,
null=True,
verbose_name=_('Responsible'),
help_text=_('User responsible for this build order'),
related_name='builds_responsible',
)
link = InvenTree.fields.InvenTreeURLField(
verbose_name=_('External Link'),
blank=True,
help_text=_('Link to external URL'))
notes = InvenTree.fields.InvenTreeNotesField(
help_text=_('Extra build notes'))
def sub_builds(self, cascade=True):
"""Return all Build Order objects under this one."""
if cascade:
return Build.objects.filter(parent=self.pk)
else:
descendants = self.get_descendants(include_self=True)
Build.objects.filter(parent__pk__in=[d.pk for d in descendants])
def sub_build_count(self, cascade=True):
"""Return the number of sub builds under this one.
Args:
cascade: If True (defualt), include cascading builds under sub builds
"""
return self.sub_builds(cascade=cascade).count()
@property
def is_overdue(self):
"""Returns true if this build is "overdue".
Makes use of the OVERDUE_FILTER to avoid code duplication
Returns:
bool: Is the build overdue
"""
query = Build.objects.filter(pk=self.pk)
query = query.filter(Build.OVERDUE_FILTER)
return query.exists()
@property
def active(self):
"""Return True if this build is active."""
return self.status in BuildStatus.ACTIVE_CODES
@property
def bom_items(self):
"""Returns the BOM items for the part referenced by this BuildOrder."""
return self.part.get_bom_items()
@property
def tracked_bom_items(self):
"""Returns the "trackable" BOM items for this BuildOrder."""
items = self.bom_items
items = items.filter(sub_part__trackable=True)
return items
def has_tracked_bom_items(self):
"""Returns True if this BuildOrder has trackable BomItems."""
return self.tracked_bom_items.count() > 0
@property
def untracked_bom_items(self):
"""Returns the "non trackable" BOM items for this BuildOrder."""
items = self.bom_items
items = items.filter(sub_part__trackable=False)
return items
def has_untracked_bom_items(self):
"""Returns True if this BuildOrder has non trackable BomItems."""
return self.untracked_bom_items.count() > 0
@property
def remaining(self):
"""Return the number of outputs remaining to be completed."""
return max(0, self.quantity - self.completed)
@property
def output_count(self):
"""Return the number of build outputs (StockItem) associated with this build order"""
return self.build_outputs.count()
def has_build_outputs(self):
"""Returns True if this build has more than zero build outputs"""
return self.output_count > 0
def get_build_outputs(self, **kwargs):
"""Return a list of build outputs.
kwargs:
complete = (True / False) - If supplied, filter by completed status
in_stock = (True / False) - If supplied, filter by 'in-stock' status
"""
outputs = self.build_outputs.all()
# Filter by 'in stock' status
in_stock = kwargs.get('in_stock', None)
if in_stock is not None:
if in_stock:
outputs = outputs.filter(StockModels.StockItem.IN_STOCK_FILTER)
else:
outputs = outputs.exclude(
StockModels.StockItem.IN_STOCK_FILTER)
# Filter by 'complete' status
complete = kwargs.get('complete', None)
if complete is not None:
if complete:
outputs = outputs.filter(is_building=False)
else:
outputs = outputs.filter(is_building=True)
return outputs
@property
def complete_outputs(self):
"""Return all the "completed" build outputs."""
outputs = self.get_build_outputs(complete=True)
return outputs
@property
def complete_count(self):
"""Return the total quantity of completed outputs"""
quantity = 0
for output in self.complete_outputs:
quantity += output.quantity
return quantity
@property
def incomplete_outputs(self):
"""Return all the "incomplete" build outputs."""
outputs = self.get_build_outputs(complete=False)
return outputs
@property
def incomplete_count(self):
"""Return the total number of "incomplete" outputs."""
quantity = 0
for output in self.incomplete_outputs:
quantity += output.quantity
return quantity
@classmethod
def getNextBuildNumber(cls):
"""Try to predict the next Build Order reference."""
if cls.objects.count() == 0:
return None
# Extract the "most recent" build order reference
builds = cls.objects.exclude(reference=None)
if not builds.exists():
return None
build = builds.last()
ref = build.reference
if not ref:
return None
tries = set(ref)
new_ref = ref
while 1:
new_ref = increment(new_ref)
if new_ref in tries:
# We are potentially stuck in a loop - simply return the original reference
return ref
# Check if the existing build reference exists
if cls.objects.filter(reference=new_ref).exists():
tries.add(new_ref)
else:
break
return new_ref
@property
def can_complete(self):
"""Returns True if this build can be "completed".
- Must not have any outstanding build outputs
- 'completed' value must meet (or exceed) the 'quantity' value
"""
if self.incomplete_count > 0:
return False
if self.remaining > 0:
return False
if not self.are_untracked_parts_allocated():
return False
# No issues!
return True
@transaction.atomic
def complete_build(self, user):
"""Mark this build as complete."""
if self.incomplete_count > 0:
return
self.completion_date = datetime.now().date()
self.completed_by = user
self.status = BuildStatus.COMPLETE
self.save()
# Remove untracked allocated stock
self.subtract_allocated_stock(user)
# Ensure that there are no longer any BuildItem objects
# which point to this Build Order
self.allocated_stock.all().delete()
# Register an event
trigger_event('build.completed', id=self.pk)
# Notify users that this build has been completed
targets = [
self.issued_by,
self.responsible,
]
# Notify those users interested in the parent build
if self.parent:
targets.append(self.parent.issued_by)
targets.append(self.parent.responsible)
# Notify users if this build points to a sales order
if self.sales_order:
targets.append(self.sales_order.created_by)
targets.append(self.sales_order.responsible)
build = self
name = _(f'Build order {build} has been completed')
context = {
'build':
build,
'name':
name,
'slug':
'build.completed',
'message':
_('A build order has been completed'),
'link':
InvenTree.helpers.construct_absolute_url(self.get_absolute_url()),
'template': {
'html': 'email/build_order_completed.html',
'subject': name,
}
}
common.notifications.trigger_notification(
build,
'build.completed',
targets=targets,
context=context,
target_exclude=[user],
)
@transaction.atomic
def cancel_build(self, user, **kwargs):
"""Mark the Build as CANCELLED.
- Delete any pending BuildItem objects (but do not remove items from stock)
- Set build status to CANCELLED
- Save the Build object
"""
remove_allocated_stock = kwargs.get('remove_allocated_stock', False)
remove_incomplete_outputs = kwargs.get('remove_incomplete_outputs',
False)
# Handle stock allocations
for build_item in self.allocated_stock.all():
if remove_allocated_stock:
build_item.complete_allocation(user)
build_item.delete()
# Remove incomplete outputs (if required)
if remove_incomplete_outputs:
outputs = self.build_outputs.filter(is_building=True)
for output in outputs:
output.delete()
# Date of 'completion' is the date the build was cancelled
self.completion_date = datetime.now().date()
self.completed_by = user
self.status = BuildStatus.CANCELLED
self.save()
trigger_event('build.cancelled', id=self.pk)
@transaction.atomic
def unallocateStock(self, bom_item=None, output=None):
"""Unallocate stock from this Build.
Args:
bom_item: Specify a particular BomItem to unallocate stock against
output: Specify a particular StockItem (output) to unallocate stock against
"""
allocations = BuildItem.objects.filter(build=self, install_into=output)
if bom_item:
allocations = allocations.filter(bom_item=bom_item)
allocations.delete()
@transaction.atomic
def create_build_output(self, quantity, **kwargs):
"""Create a new build output against this BuildOrder.
Args:
quantity: The quantity of the item to produce
Kwargs:
batch: Override batch code
serials: Serial numbers
location: Override location
auto_allocate: Automatically allocate stock with matching serial numbers
"""
batch = kwargs.get('batch', self.batch)
location = kwargs.get('location', self.destination)
serials = kwargs.get('serials', None)
auto_allocate = kwargs.get('auto_allocate', False)
"""
Determine if we can create a single output (with quantity > 0),
or multiple outputs (with quantity = 1)
"""
multiple = False
# Serial numbers are provided? We need to split!
if serials:
multiple = True
# BOM has trackable parts, so we must split!
if self.part.has_trackable_parts:
multiple = True
if multiple:
"""Create multiple build outputs with a single quantity of 1."""
# Quantity *must* be an integer at this point!
quantity = int(quantity)
for ii in range(quantity):
if serials:
serial = serials[ii]
else:
serial = None
output = StockModels.StockItem.objects.create(
quantity=1,
location=location,
part=self.part,
build=self,
batch=batch,
serial=serial,
is_building=True,
)
if auto_allocate and serial is not None:
# Get a list of BomItem objects which point to "trackable" parts
for bom_item in self.part.get_trackable_parts():
parts = bom_item.get_valid_parts_for_allocation()
for part in parts:
items = StockModels.StockItem.objects.filter(
part=part,
serial=str(serial),
quantity=1,
).filter(StockModels.StockItem.IN_STOCK_FILTER)
"""
Test if there is a matching serial number!
"""
if items.exists() and items.count() == 1:
stock_item = items[0]
# Allocate the stock item
BuildItem.objects.create(
build=self,
bom_item=bom_item,
stock_item=stock_item,
quantity=1,
install_into=output,
)
else:
"""Create a single build output of the given quantity."""
StockModels.StockItem.objects.create(quantity=quantity,
location=location,
part=self.part,
build=self,
batch=batch,
is_building=True)
if self.status == BuildStatus.PENDING:
self.status = BuildStatus.PRODUCTION
self.save()
@transaction.atomic
def delete_output(self, output):
"""Remove a build output from the database.
Executes:
- Unallocate any build items against the output
- Delete the output StockItem
"""
if not output:
raise ValidationError(_("No build output specified"))
if not output.is_building:
raise ValidationError(_("Build output is already completed"))
if output.build != self:
raise ValidationError(_("Build output does not match Build Order"))
# Unallocate all build items against the output
self.unallocateStock(output=output)
# Remove the build output from the database
output.delete()
@transaction.atomic
def subtract_allocated_stock(self, user):
"""Called when the Build is marked as "complete", this function removes the allocated untracked items from stock."""
items = self.allocated_stock.filter(stock_item__part__trackable=False)
# Remove stock
for item in items:
item.complete_allocation(user)
# Delete allocation
items.all().delete()
@transaction.atomic
def complete_build_output(self, output, user, **kwargs):
"""Complete a particular build output.
- Remove allocated StockItems
- Mark the output as complete
"""
# Select the location for the build output
location = kwargs.get('location', self.destination)
status = kwargs.get('status', StockStatus.OK)
notes = kwargs.get('notes', '')
# List the allocated BuildItem objects for the given output
allocated_items = output.items_to_install.all()
for build_item in allocated_items:
# Complete the allocation of stock for that item
build_item.complete_allocation(user)
# Delete the BuildItem objects from the database
allocated_items.all().delete()
# Ensure that the output is updated correctly
output.build = self
output.is_building = False
output.location = location
output.status = status
output.save()
output.add_tracking_entry(StockHistoryCode.BUILD_OUTPUT_COMPLETED,
user,
notes=notes,
deltas={
'status': status,
})
# Increase the completed quantity for this build
self.completed += output.quantity
self.save()
@transaction.atomic
def auto_allocate_stock(self, **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)
exclude_location = kwargs.get('exclude_location', None)
interchangeable = kwargs.get('interchangeable', False)
substitutes = kwargs.get('substitutes', True)
def stock_sort(item, bom_item, variant_parts):
if item.part == bom_item.sub_part:
return 1
elif item.part in variant_parts:
return 2
else:
return 3
# 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)
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], )
# Filter out "serialized" stock items, these cannot be auto-allocated
available_stock = available_stock.filter(
Q(serial=None) | Q(serial=''))
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 exclude_location:
# Exclude any stock items from the provided location
sublocations = exclude_location.get_descendants(
include_self=True)
available_stock = available_stock.exclude(
location__in=[loc for loc in sublocations])
"""
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
"""
available_stock = sorted(available_stock,
key=lambda item, b=bom_item, v=
variant_parts: stock_sort(item, b, v))
if len(available_stock) == 0:
# No stock items are available
continue
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
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.
Args:
bom_item: The Part object
output: The particular build output (StockItem)
"""
quantity = bom_item.quantity
if output:
quantity *= output.quantity
else:
quantity *= self.quantity
return quantity
def allocated_bom_items(self, bom_item, output=None):
"""Return all BuildItem objects which allocate stock of <bom_item> to <output>.
Note that the bom_item may allow variants, or direct substitutes,
making things difficult.
Args:
bom_item: The BomItem object
output: Build output (StockItem).
"""
allocations = BuildItem.objects.filter(
build=self,
bom_item=bom_item,
install_into=output,
)
return allocations
def allocated_quantity(self, bom_item, output=None):
"""Return the total quantity of given part allocated to a given build output."""
allocations = self.allocated_bom_items(bom_item, output)
allocated = allocations.aggregate(q=Coalesce(
Sum('quantity'),
0,
output_field=models.DecimalField(),
))
return allocated['q']
def unallocated_quantity(self, bom_item, output=None):
"""Return the total unallocated (remaining) quantity of a part against a particular output."""
required = self.required_quantity(bom_item, output)
allocated = self.allocated_quantity(bom_item, output)
return max(required - allocated, 0)
def is_bom_item_allocated(self, bom_item, output=None):
"""Test if the supplied BomItem has been fully allocated!"""
return self.unallocated_quantity(bom_item, output) == 0
def is_fully_allocated(self, output):
"""Returns True if the particular build output is fully allocated."""
# If output is not specified, we are talking about "untracked" items
if output is None:
bom_items = self.untracked_bom_items
else:
bom_items = self.tracked_bom_items
for bom_item in bom_items:
if not self.is_bom_item_allocated(bom_item, output):
return False
# All parts must be fully allocated!
return True
def is_partially_allocated(self, output):
"""Returns True if the particular build output is (at least) partially allocated."""
# If output is not specified, we are talking about "untracked" items
if output is None:
bom_items = self.untracked_bom_items
else:
bom_items = self.tracked_bom_items
for bom_item in bom_items:
if self.allocated_quantity(bom_item, output) > 0:
return True
return False
def are_untracked_parts_allocated(self):
"""Returns True if the un-tracked parts are fully allocated for this BuildOrder."""
return self.is_fully_allocated(None)
def has_overallocated_parts(self, output=None):
"""Check if parts have been 'over-allocated' against the specified output.
Note: If output=None, test un-tracked parts
"""
bom_items = self.tracked_bom_items if output else self.untracked_bom_items
for bom_item in bom_items:
if self.allocated_quantity(bom_item,
output) > self.required_quantity(
bom_item, output):
return True
return False
def unallocated_bom_items(self, output):
"""Return a list of bom items which have *not* been fully allocated against a particular output."""
unallocated = []
# If output is not specified, we are talking about "untracked" items
if output is None:
bom_items = self.untracked_bom_items
else:
bom_items = self.tracked_bom_items
for bom_item in bom_items:
if not self.is_bom_item_allocated(bom_item, output):
unallocated.append(bom_item)
return unallocated
@property
def required_parts(self):
"""Returns a list of parts required to build this part (BOM)."""
parts = []
for item in self.bom_items:
parts.append(item.sub_part)
return parts
@property
def required_parts_to_complete_build(self):
"""Returns a list of parts required to complete the full build."""
parts = []
for bom_item in self.bom_items:
# Get remaining quantity needed
required_quantity_to_complete_build = self.remaining * bom_item.quantity
# Compare to net stock
if bom_item.sub_part.net_stock < required_quantity_to_complete_build:
parts.append(bom_item.sub_part)
return parts
@property
def is_active(self):
"""Is this build active?
An active build is either:
- PENDING
- HOLDING
"""
return self.status in BuildStatus.ACTIVE_CODES
@property
def is_complete(self):
"""Returns True if the build status is COMPLETE."""
return self.status == BuildStatus.COMPLETE
