mirror of
https://github.com/inventree/InvenTree.git
synced 2025-05-10 09:18:48 +00:00
794e375009
* switch to pathlib * more pathlib * useconvert env to path * fix typo * use resolve instead of absolute * fix gitppod * also allow parents * replace more os operations * fix string replacement feature * make sure root dirs exsist * fix replace function * refactor duplicate code * reduce code * make sure dirs exist * fix typo * also create parent dirs * fix match statement * fix statments expecting string * return getMigrationFileNames to old behaviour * fully resolve config file * make sure comparison works * use pathlib in tasks * fix file count test * reduce code duplication in test + add test for part * fix test * re-add os * Make pathlib usage simpler
554 lines
17 KiB
Python
554 lines
17 KiB
Python
"""Report template model definitions."""
|
|
|
|
import datetime
|
|
import logging
|
|
import os
|
|
import sys
|
|
|
|
from django.conf import settings
|
|
from django.core.cache import cache
|
|
from django.core.exceptions import FieldError, ValidationError
|
|
from django.core.validators import FileExtensionValidator
|
|
from django.db import models
|
|
from django.template import Context, Template
|
|
from django.template.loader import render_to_string
|
|
from django.urls import reverse
|
|
from django.utils.translation import gettext_lazy as _
|
|
|
|
import build.models
|
|
import common.models
|
|
import order.models
|
|
import part.models
|
|
import stock.models
|
|
from InvenTree.helpers import validateFilterString
|
|
|
|
try:
|
|
from django_weasyprint import WeasyTemplateResponseMixin
|
|
except OSError as err: # pragma: no cover
|
|
print("OSError: {e}".format(e=err))
|
|
print("You may require some further system packages to be installed.")
|
|
sys.exit(1)
|
|
|
|
|
|
logger = logging.getLogger("inventree")
|
|
|
|
|
|
def rename_template(instance, filename):
|
|
"""Helper function for 'renaming' uploaded report files.
|
|
|
|
Pass responsibility back to the calling class,
|
|
to ensure that files are uploaded to the correct directory.
|
|
"""
|
|
return instance.rename_file(filename)
|
|
|
|
|
|
def validate_stock_item_report_filters(filters):
|
|
"""Validate filter string against StockItem model."""
|
|
return validateFilterString(filters, model=stock.models.StockItem)
|
|
|
|
|
|
def validate_part_report_filters(filters):
|
|
"""Validate filter string against Part model."""
|
|
return validateFilterString(filters, model=part.models.Part)
|
|
|
|
|
|
def validate_build_report_filters(filters):
|
|
"""Validate filter string against Build model."""
|
|
return validateFilterString(filters, model=build.models.Build)
|
|
|
|
|
|
def validate_purchase_order_filters(filters):
|
|
"""Validate filter string against PurchaseOrder model."""
|
|
return validateFilterString(filters, model=order.models.PurchaseOrder)
|
|
|
|
|
|
def validate_sales_order_filters(filters):
|
|
"""Validate filter string against SalesOrder model."""
|
|
return validateFilterString(filters, model=order.models.SalesOrder)
|
|
|
|
|
|
class WeasyprintReportMixin(WeasyTemplateResponseMixin):
|
|
"""Class for rendering a HTML template to a PDF."""
|
|
|
|
pdf_filename = 'report.pdf'
|
|
pdf_attachment = True
|
|
|
|
def __init__(self, request, template, **kwargs):
|
|
"""Initialize the report mixin with some standard attributes"""
|
|
self.request = request
|
|
self.template_name = template
|
|
self.pdf_filename = kwargs.get('filename', 'report.pdf')
|
|
|
|
|
|
class ReportBase(models.Model):
|
|
"""Base class for uploading html templates."""
|
|
|
|
class Meta:
|
|
"""Metaclass options. Abstract ensures no database table is created."""
|
|
|
|
abstract = True
|
|
|
|
def save(self, *args, **kwargs):
|
|
"""Perform additional actions when the report is saved"""
|
|
# Increment revision number
|
|
self.revision += 1
|
|
|
|
super().save()
|
|
|
|
def __str__(self):
|
|
"""Format a string representation of a report instance"""
|
|
return "{n} - {d}".format(n=self.name, d=self.description)
|
|
|
|
@classmethod
|
|
def getSubdir(cls):
|
|
"""Return the subdirectory where template files for this report model will be located."""
|
|
return ''
|
|
|
|
def rename_file(self, filename):
|
|
"""Function for renaming uploaded file"""
|
|
|
|
filename = os.path.basename(filename)
|
|
|
|
path = os.path.join('report', 'report_template', self.getSubdir(), filename)
|
|
|
|
fullpath = settings.MEDIA_ROOT.joinpath(path).resolve()
|
|
|
|
# If the report file is the *same* filename as the one being uploaded,
|
|
# remove the original one from the media directory
|
|
if str(filename) == str(self.template):
|
|
|
|
if fullpath.exists():
|
|
logger.info(f"Deleting existing report template: '{filename}'")
|
|
os.remove(fullpath)
|
|
|
|
# Ensure that the cache is cleared for this template!
|
|
cache.delete(fullpath)
|
|
|
|
return path
|
|
|
|
@property
|
|
def extension(self):
|
|
"""Return the filename extension of the associated template file"""
|
|
return os.path.splitext(self.template.name)[1].lower()
|
|
|
|
@property
|
|
def template_name(self):
|
|
"""Returns the file system path to the template file.
|
|
|
|
Required for passing the file to an external process
|
|
"""
|
|
template = self.template.name
|
|
|
|
# TODO @matmair change to using new file objects
|
|
template = template.replace('/', os.path.sep)
|
|
template = template.replace('\\', os.path.sep)
|
|
|
|
template = settings.MEDIA_ROOT.joinpath(template)
|
|
|
|
return template
|
|
|
|
name = models.CharField(
|
|
blank=False, max_length=100,
|
|
verbose_name=_('Name'),
|
|
help_text=_('Template name'),
|
|
)
|
|
|
|
template = models.FileField(
|
|
upload_to=rename_template,
|
|
verbose_name=_('Template'),
|
|
help_text=_("Report template file"),
|
|
validators=[FileExtensionValidator(allowed_extensions=['html', 'htm'])],
|
|
)
|
|
|
|
description = models.CharField(
|
|
max_length=250,
|
|
verbose_name=_('Description'),
|
|
help_text=_("Report template description")
|
|
)
|
|
|
|
revision = models.PositiveIntegerField(
|
|
default=1,
|
|
verbose_name=_("Revision"),
|
|
help_text=_("Report revision number (auto-increments)"),
|
|
editable=False,
|
|
)
|
|
|
|
|
|
class ReportTemplateBase(ReportBase):
|
|
"""Reporting template model.
|
|
|
|
Able to be passed context data
|
|
"""
|
|
|
|
# Pass a single top-level object to the report template
|
|
object_to_print = None
|
|
|
|
def get_context_data(self, request):
|
|
"""Supply context data to the template for rendering."""
|
|
return {}
|
|
|
|
def context(self, request):
|
|
"""All context to be passed to the renderer."""
|
|
# Generate custom context data based on the particular report subclass
|
|
context = self.get_context_data(request)
|
|
|
|
context['base_url'] = common.models.InvenTreeSetting.get_setting('INVENTREE_BASE_URL')
|
|
context['date'] = datetime.datetime.now().date()
|
|
context['datetime'] = datetime.datetime.now()
|
|
context['default_page_size'] = common.models.InvenTreeSetting.get_setting('REPORT_DEFAULT_PAGE_SIZE')
|
|
context['report_description'] = self.description
|
|
context['report_name'] = self.name
|
|
context['report_revision'] = self.revision
|
|
context['request'] = request
|
|
context['user'] = request.user
|
|
|
|
return context
|
|
|
|
def generate_filename(self, request, **kwargs):
|
|
"""Generate a filename for this report."""
|
|
template_string = Template(self.filename_pattern)
|
|
|
|
ctx = self.context(request)
|
|
|
|
context = Context(ctx)
|
|
|
|
return template_string.render(context)
|
|
|
|
def render_as_string(self, request, **kwargs):
|
|
"""Render the report to a HTML string.
|
|
|
|
Useful for debug mode (viewing generated code)
|
|
"""
|
|
return render_to_string(self.template_name, self.context(request), request)
|
|
|
|
def render(self, request, **kwargs):
|
|
"""Render the template to a PDF file.
|
|
|
|
Uses django-weasyprint plugin to render HTML template against Weasyprint
|
|
"""
|
|
# TODO: Support custom filename generation!
|
|
# filename = kwargs.get('filename', 'report.pdf')
|
|
|
|
# Render HTML template to PDF
|
|
wp = WeasyprintReportMixin(
|
|
request,
|
|
self.template_name,
|
|
base_url=request.build_absolute_uri("/"),
|
|
presentational_hints=True,
|
|
filename=self.generate_filename(request),
|
|
**kwargs)
|
|
|
|
return wp.render_to_response(
|
|
self.context(request),
|
|
**kwargs)
|
|
|
|
filename_pattern = models.CharField(
|
|
default="report.pdf",
|
|
verbose_name=_('Filename Pattern'),
|
|
help_text=_('Pattern for generating report filenames'),
|
|
max_length=100,
|
|
)
|
|
|
|
enabled = models.BooleanField(
|
|
default=True,
|
|
verbose_name=_('Enabled'),
|
|
help_text=_('Report template is enabled'),
|
|
)
|
|
|
|
class Meta:
|
|
"""Metaclass options. Abstract ensures no database table is created."""
|
|
|
|
abstract = True
|
|
|
|
|
|
class TestReport(ReportTemplateBase):
|
|
"""Render a TestReport against a StockItem object."""
|
|
|
|
@staticmethod
|
|
def get_api_url():
|
|
"""Return the API URL associated with the TestReport model"""
|
|
return reverse('api-stockitem-testreport-list')
|
|
|
|
@classmethod
|
|
def getSubdir(cls):
|
|
"""Return the subdirectory where TestReport templates are located"""
|
|
return 'test'
|
|
|
|
filters = models.CharField(
|
|
blank=True,
|
|
max_length=250,
|
|
verbose_name=_('Filters'),
|
|
help_text=_("StockItem query filters (comma-separated list of key=value pairs)"),
|
|
validators=[
|
|
validate_stock_item_report_filters
|
|
]
|
|
)
|
|
|
|
include_installed = models.BooleanField(
|
|
default=False,
|
|
verbose_name=_('Include Installed Tests'),
|
|
help_text=_('Include test results for stock items installed inside assembled item')
|
|
)
|
|
|
|
def matches_stock_item(self, item):
|
|
"""Test if this report template matches a given StockItem objects."""
|
|
try:
|
|
filters = validateFilterString(self.filters)
|
|
items = stock.models.StockItem.objects.filter(**filters)
|
|
except (ValidationError, FieldError):
|
|
return False
|
|
|
|
# Ensure the provided StockItem object matches the filters
|
|
items = items.filter(pk=item.pk)
|
|
|
|
return items.exists()
|
|
|
|
def get_context_data(self, request):
|
|
"""Return custom context data for the TestReport template"""
|
|
stock_item = self.object_to_print
|
|
|
|
return {
|
|
'stock_item': stock_item,
|
|
'serial': stock_item.serial,
|
|
'part': stock_item.part,
|
|
'parameters': stock_item.part.parameters_map(),
|
|
'results': stock_item.testResultMap(include_installed=self.include_installed),
|
|
'result_list': stock_item.testResultList(include_installed=self.include_installed),
|
|
'installed_items': stock_item.get_installed_items(cascade=True),
|
|
}
|
|
|
|
|
|
class BuildReport(ReportTemplateBase):
|
|
"""Build order / work order report."""
|
|
|
|
@staticmethod
|
|
def get_api_url():
|
|
"""Return the API URL associated with the BuildReport model"""
|
|
return reverse('api-build-report-list')
|
|
|
|
@classmethod
|
|
def getSubdir(cls):
|
|
"""Return the subdirectory where BuildReport templates are located"""
|
|
return 'build'
|
|
|
|
filters = models.CharField(
|
|
blank=True,
|
|
max_length=250,
|
|
verbose_name=_('Build Filters'),
|
|
help_text=_('Build query filters (comma-separated list of key=value pairs'),
|
|
validators=[
|
|
validate_build_report_filters,
|
|
]
|
|
)
|
|
|
|
def get_context_data(self, request):
|
|
"""Custom context data for the build report."""
|
|
my_build = self.object_to_print
|
|
|
|
if type(my_build) != build.models.Build:
|
|
raise TypeError('Provided model is not a Build object')
|
|
|
|
return {
|
|
'build': my_build,
|
|
'part': my_build.part,
|
|
'bom_items': my_build.part.get_bom_items(),
|
|
'reference': my_build.reference,
|
|
'quantity': my_build.quantity,
|
|
'title': str(my_build),
|
|
}
|
|
|
|
|
|
class BillOfMaterialsReport(ReportTemplateBase):
|
|
"""Render a Bill of Materials against a Part object."""
|
|
|
|
@staticmethod
|
|
def get_api_url():
|
|
"""Return the API URL associated with the BillOfMaterialsReport model"""
|
|
return reverse('api-bom-report-list')
|
|
|
|
@classmethod
|
|
def getSubdir(cls):
|
|
"""Retun the directory where BillOfMaterialsReport templates are located"""
|
|
return 'bom'
|
|
|
|
filters = models.CharField(
|
|
blank=True,
|
|
max_length=250,
|
|
verbose_name=_('Part Filters'),
|
|
help_text=_('Part query filters (comma-separated list of key=value pairs'),
|
|
validators=[
|
|
validate_part_report_filters
|
|
]
|
|
)
|
|
|
|
def get_context_data(self, request):
|
|
"""Return custom context data for the BillOfMaterialsReport template"""
|
|
part = self.object_to_print
|
|
|
|
return {
|
|
'part': part,
|
|
'category': part.category,
|
|
'bom_items': part.get_bom_items(),
|
|
}
|
|
|
|
|
|
class PurchaseOrderReport(ReportTemplateBase):
|
|
"""Render a report against a PurchaseOrder object."""
|
|
|
|
@staticmethod
|
|
def get_api_url():
|
|
"""Return the API URL associated with the PurchaseOrderReport model"""
|
|
return reverse('api-po-report-list')
|
|
|
|
@classmethod
|
|
def getSubdir(cls):
|
|
"""Return the directory where PurchaseOrderReport templates are stored"""
|
|
return 'purchaseorder'
|
|
|
|
filters = models.CharField(
|
|
blank=True,
|
|
max_length=250,
|
|
verbose_name=_('Filters'),
|
|
help_text=_('Purchase order query filters'),
|
|
validators=[
|
|
validate_purchase_order_filters,
|
|
]
|
|
)
|
|
|
|
def get_context_data(self, request):
|
|
"""Return custom context data for the PurchaseOrderReport template"""
|
|
order = self.object_to_print
|
|
|
|
return {
|
|
'description': order.description,
|
|
'lines': order.lines,
|
|
'extra_lines': order.extra_lines,
|
|
'order': order,
|
|
'reference': order.reference,
|
|
'supplier': order.supplier,
|
|
'title': str(order),
|
|
}
|
|
|
|
|
|
class SalesOrderReport(ReportTemplateBase):
|
|
"""Render a report against a SalesOrder object."""
|
|
|
|
@staticmethod
|
|
def get_api_url():
|
|
"""Return the API URL associated with the SalesOrderReport model"""
|
|
return reverse('api-so-report-list')
|
|
|
|
@classmethod
|
|
def getSubdir(cls):
|
|
"""Retun the subdirectory where SalesOrderReport templates are located"""
|
|
return 'salesorder'
|
|
|
|
filters = models.CharField(
|
|
blank=True,
|
|
max_length=250,
|
|
verbose_name=_('Filters'),
|
|
help_text=_('Sales order query filters'),
|
|
validators=[
|
|
validate_sales_order_filters
|
|
]
|
|
)
|
|
|
|
def get_context_data(self, request):
|
|
"""Return custom context data for a SalesOrderReport template"""
|
|
order = self.object_to_print
|
|
|
|
return {
|
|
'customer': order.customer,
|
|
'description': order.description,
|
|
'lines': order.lines,
|
|
'extra_lines': order.extra_lines,
|
|
'order': order,
|
|
'reference': order.reference,
|
|
'title': str(order),
|
|
}
|
|
|
|
|
|
def rename_snippet(instance, filename):
|
|
"""Function to rename a report snippet once uploaded"""
|
|
|
|
filename = os.path.basename(filename)
|
|
|
|
path = os.path.join('report', 'snippets', filename)
|
|
|
|
fullpath = settings.MEDIA_ROOT.joinpath(path).resolve()
|
|
|
|
# If the snippet file is the *same* filename as the one being uploaded,
|
|
# delete the original one from the media directory
|
|
if str(filename) == str(instance.snippet):
|
|
|
|
if fullpath.exists():
|
|
logger.info(f"Deleting existing snippet file: '{filename}'")
|
|
os.remove(fullpath)
|
|
|
|
# Ensure that the cache is deleted for this snippet
|
|
cache.delete(fullpath)
|
|
|
|
return path
|
|
|
|
|
|
class ReportSnippet(models.Model):
|
|
"""Report template 'snippet' which can be used to make templates that can then be included in other reports.
|
|
|
|
Useful for 'common' template actions, sub-templates, etc
|
|
"""
|
|
|
|
snippet = models.FileField(
|
|
upload_to=rename_snippet,
|
|
verbose_name=_('Snippet'),
|
|
help_text=_('Report snippet file'),
|
|
validators=[FileExtensionValidator(allowed_extensions=['html', 'htm'])],
|
|
)
|
|
|
|
description = models.CharField(max_length=250, verbose_name=_('Description'), help_text=_("Snippet file description"))
|
|
|
|
|
|
def rename_asset(instance, filename):
|
|
"""Function to rename an asset file when uploaded"""
|
|
|
|
filename = os.path.basename(filename)
|
|
|
|
path = os.path.join('report', 'assets', filename)
|
|
|
|
# If the asset file is the *same* filename as the one being uploaded,
|
|
# delete the original one from the media directory
|
|
if str(filename) == str(instance.asset):
|
|
fullpath = settings.MEDIA_ROOT.joinpath(path).resolve()
|
|
|
|
if fullpath.exists():
|
|
logger.info(f"Deleting existing asset file: '{filename}'")
|
|
os.remove(fullpath)
|
|
|
|
return path
|
|
|
|
|
|
class ReportAsset(models.Model):
|
|
"""Asset file for use in report templates.
|
|
|
|
For example, an image to use in a header file.
|
|
Uploaded asset files appear in MEDIA_ROOT/report/assets,
|
|
and can be loaded in a template using the {% report_asset <filename> %} tag.
|
|
"""
|
|
|
|
def __str__(self):
|
|
"""String representation of a ReportAsset instance"""
|
|
return os.path.basename(self.asset.name)
|
|
|
|
# Asset file
|
|
asset = models.FileField(
|
|
upload_to=rename_asset,
|
|
verbose_name=_('Asset'),
|
|
help_text=_("Report asset file"),
|
|
)
|
|
|
|
# Asset description (user facing string, not used internally)
|
|
description = models.CharField(
|
|
max_length=250,
|
|
verbose_name=_('Description'),
|
|
help_text=_("Asset file description")
|
|
)
|