494 lines
19 KiB
Python
494 lines
19 KiB
Python
from django import forms
|
|
from django.urls import re_path as url
|
|
from django.contrib import admin, messages
|
|
from django.contrib.admin.utils import unquote
|
|
from django.urls import reverse
|
|
from django.db import models
|
|
from django.db.models import F, Sum, Prefetch
|
|
from django.db.models.functions import Coalesce
|
|
from django.templatetags.static import static
|
|
from django.utils.html import format_html
|
|
from django.utils.safestring import mark_safe
|
|
from django.utils.translation import gettext_lazy as _
|
|
from django.shortcuts import redirect
|
|
|
|
from orchestra.admin import ExtendedModelAdmin
|
|
from orchestra.admin.utils import admin_date, insertattr, admin_link, change_url
|
|
from orchestra.contrib.accounts.actions import list_accounts
|
|
from orchestra.contrib.accounts.admin import AccountAdminMixin, AccountAdmin
|
|
from orchestra.forms.widgets import PaddingCheckboxSelectMultiple
|
|
|
|
from . import settings, actions
|
|
from .filters import (BillTypeListFilter, HasBillContactListFilter, TotalListFilter,
|
|
PaymentStateListFilter, AmendedListFilter)
|
|
from .models import (Bill, Invoice, AmendmentInvoice, AbonoInvoice, Fee, AmendmentFee, ProForma, BillLine,
|
|
BillSubline, BillContact)
|
|
|
|
|
|
PAYMENT_STATE_COLORS = {
|
|
Bill.OPEN: 'grey',
|
|
Bill.CREATED: 'magenta',
|
|
Bill.PROCESSED: 'darkorange',
|
|
Bill.AMENDED: 'blue',
|
|
Bill.PAID: 'green',
|
|
Bill.EXECUTED: 'olive',
|
|
Bill.BAD_DEBT: 'red',
|
|
Bill.INCOMPLETE: 'red',
|
|
}
|
|
|
|
|
|
class BillSublineInline(admin.TabularInline):
|
|
model = BillSubline
|
|
fields = ('description', 'total', 'type')
|
|
|
|
def get_readonly_fields(self, request, obj=None):
|
|
fields = super().get_readonly_fields(request, obj)
|
|
if obj and not obj.bill.is_open:
|
|
return self.get_fields(request)
|
|
return fields
|
|
|
|
def get_max_num(self, request, obj=None):
|
|
if obj and not obj.bill.is_open:
|
|
return 0
|
|
return super().get_max_num(request, obj)
|
|
|
|
def has_delete_permission(self, request, obj=None):
|
|
if obj and not obj.bill.is_open:
|
|
return False
|
|
return super().has_delete_permission(request, obj)
|
|
|
|
|
|
class BillLineInline(admin.TabularInline):
|
|
model = BillLine
|
|
fields = (
|
|
'description', 'order_link', 'start_on', 'end_on', 'rate', 'quantity', 'tax',
|
|
'subtotal', 'display_total',
|
|
)
|
|
readonly_fields = ('display_total', 'order_link')
|
|
|
|
order_link = admin_link('order', display='pk')
|
|
|
|
@mark_safe
|
|
def display_total(self, line):
|
|
if line.pk:
|
|
total = line.compute_total()
|
|
sublines = line.sublines.all()
|
|
url = change_url(line)
|
|
if sublines:
|
|
content = '\n'.join(['%s: %s' % (sub.description, sub.total) for sub in sublines])
|
|
img = static('admin/img/icon-alert.svg')
|
|
return '<a href="%s" title="%s">%s <img src="%s"></img></a>' % (url, content, total, img)
|
|
return '<a href="%s">%s</a>' % (url, total)
|
|
display_total.short_description = _("Total")
|
|
|
|
def formfield_for_dbfield(self, db_field, **kwargs):
|
|
""" Make value input widget bigger """
|
|
if db_field.name == 'description':
|
|
kwargs['widget'] = forms.TextInput(attrs={'size':'50'})
|
|
elif db_field.name not in ('start_on', 'end_on'):
|
|
kwargs['widget'] = forms.TextInput(attrs={'size':'6'})
|
|
return super().formfield_for_dbfield(db_field, **kwargs)
|
|
|
|
def get_queryset(self, request):
|
|
qs = super().get_queryset(request)
|
|
return qs.prefetch_related('sublines').select_related('order')
|
|
|
|
|
|
class ClosedBillLineInline(BillLineInline):
|
|
# TODO reimplement as nested inlines when upstream
|
|
# https://code.djangoproject.com/ticket/9025
|
|
|
|
fields = (
|
|
'display_description', 'order_link', 'start_on', 'end_on', 'rate', 'quantity', 'tax',
|
|
'display_subtotal', 'display_total'
|
|
)
|
|
readonly_fields = fields
|
|
can_delete = False
|
|
|
|
@mark_safe
|
|
def display_description(self, line):
|
|
descriptions = [line.description]
|
|
for subline in line.sublines.all():
|
|
descriptions.append(' ' * 4 + subline.description)
|
|
return '<br>'.join(descriptions)
|
|
display_description.short_description = _("Description")
|
|
|
|
@mark_safe
|
|
def display_subtotal(self, line):
|
|
subtotals = [' ' + str(line.subtotal)]
|
|
for subline in line.sublines.all():
|
|
subtotals.append(str(subline.total))
|
|
return '<br>'.join(subtotals)
|
|
display_subtotal.short_description = _("Subtotal")
|
|
|
|
def display_total(self, line):
|
|
if line.pk:
|
|
return line.compute_total()
|
|
display_total.short_description = _("Total")
|
|
|
|
def has_add_permission(self, request, obj):
|
|
return False
|
|
|
|
|
|
class BillLineAdmin(admin.ModelAdmin):
|
|
list_display = (
|
|
'description', 'bill_link', 'display_is_open', 'account_link', 'rate', 'quantity',
|
|
'tax', 'subtotal', 'display_sublinetotal', 'display_total'
|
|
)
|
|
actions = (
|
|
actions.undo_billing, actions.move_lines, actions.copy_lines, actions.service_report,
|
|
actions.list_bills,
|
|
)
|
|
fieldsets = (
|
|
(None, {
|
|
'fields': ('bill_link', 'description', 'tax', 'start_on', 'end_on', 'amended_line_link')
|
|
}),
|
|
(_("Totals"), {
|
|
'fields': ('rate', ('quantity', 'verbose_quantity'), 'subtotal', 'display_sublinetotal',
|
|
'display_total'),
|
|
}),
|
|
(_("Order"), {
|
|
'fields': ('order_link', 'order_billed_on', 'order_billed_until',)
|
|
}),
|
|
)
|
|
readonly_fields = (
|
|
'bill_link', 'order_link', 'amended_line_link', 'display_sublinetotal', 'display_total'
|
|
)
|
|
list_filter = ('tax', 'bill__is_open', 'order__service')
|
|
list_select_related = ('bill', 'bill__account')
|
|
search_fields = ('description', 'bill__number')
|
|
inlines = (BillSublineInline,)
|
|
|
|
account_link = admin_link('bill__account')
|
|
bill_link = admin_link('bill')
|
|
order_link = admin_link('order')
|
|
amended_line_link = admin_link('amended_line')
|
|
|
|
def display_is_open(self, instance):
|
|
return instance.bill.is_open
|
|
display_is_open.short_description = _("Is open")
|
|
display_is_open.boolean = True
|
|
|
|
def display_sublinetotal(self, instance):
|
|
total = instance.subline_total
|
|
return total if total is not None else '---'
|
|
display_sublinetotal.short_description = _("Sublines")
|
|
display_sublinetotal.admin_order_field = 'subline_total'
|
|
|
|
def display_total(self, instance):
|
|
return round(instance.computed_total or 0, 2)
|
|
display_total.short_description = _("Total")
|
|
display_total.admin_order_field = 'computed_total'
|
|
|
|
def get_readonly_fields(self, request, obj=None):
|
|
fields = super().get_readonly_fields(request, obj)
|
|
if obj and not obj.bill.is_open:
|
|
return list(fields) + [
|
|
'description', 'tax', 'start_on', 'end_on', 'rate', 'quantity', 'verbose_quantity',
|
|
'subtotal', 'order_billed_on', 'order_billed_until'
|
|
]
|
|
return fields
|
|
|
|
def get_queryset(self, request):
|
|
qs = super().get_queryset(request)
|
|
qs = qs.annotate(
|
|
subline_total=Sum('sublines__total'),
|
|
computed_total=(F('subtotal') + Sum(Coalesce('sublines__total', 0))) * (1+F('tax')/100),
|
|
)
|
|
return qs
|
|
|
|
def has_delete_permission(self, request, obj=None):
|
|
if obj and not obj.bill.is_open:
|
|
return False
|
|
return super().has_delete_permission(request, obj)
|
|
|
|
|
|
class BillLineManagerAdmin(BillLineAdmin):
|
|
def get_queryset(self, request):
|
|
qset = super().get_queryset(request)
|
|
if self.bill_ids:
|
|
return qset.filter(bill_id__in=self.bill_ids)
|
|
return qset
|
|
|
|
def changelist_view(self, request, extra_context=None):
|
|
GET_copy = request.GET.copy()
|
|
bill_ids = GET_copy.pop('ids', None)
|
|
if bill_ids:
|
|
bill_ids = bill_ids[0]
|
|
request.GET = GET_copy
|
|
bill_ids = list(map(int, bill_ids.split(',')))
|
|
else:
|
|
messages.error(request, _("No bills selected."))
|
|
return redirect('..')
|
|
self.bill_ids = bill_ids
|
|
bill = None
|
|
if len(bill_ids) == 1:
|
|
bill_url = reverse('admin:bills_bill_change', args=(bill_ids[0],))
|
|
bill = Bill.objects.get(pk=bill_ids[0])
|
|
bill_link = '<a href="%s">%s</a>' % (bill_url, bill.number)
|
|
title = mark_safe(_("Manage %s bill lines") % bill_link)
|
|
if not bill.is_open:
|
|
messages.warning(request, _("Bill not in open state."))
|
|
else:
|
|
if Bill.objects.filter(id__in=bill_ids, is_open=False).exists():
|
|
messages.warning(request, _("Not all bills are in open state."))
|
|
title = _("Manage bill lines of multiple bills")
|
|
context = {
|
|
'title': title,
|
|
'bill': bill,
|
|
}
|
|
context.update(extra_context or {})
|
|
return super().changelist_view(request, context)
|
|
|
|
|
|
class BillAdminMixin(AccountAdminMixin):
|
|
@mark_safe
|
|
def display_total_with_subtotals(self, bill):
|
|
if bill.pk:
|
|
currency = settings.BILLS_CURRENCY.lower()
|
|
subtotals = []
|
|
for tax, subtotal in bill.compute_subtotals().items():
|
|
subtotals.append(_("Subtotal %s%% VAT %s &%s;") % (tax, subtotal[0], currency))
|
|
subtotals.append(_("Taxes %s%% VAT %s &%s;") % (tax, subtotal[1], currency))
|
|
subtotals = '\n'.join(subtotals)
|
|
return '<span title="%s">%s &%s;</span>' % (subtotals, bill.compute_total(), currency)
|
|
display_total_with_subtotals.short_description = _("total")
|
|
display_total_with_subtotals.admin_order_field = 'approx_total'
|
|
|
|
@mark_safe
|
|
def display_payment_state(self, bill):
|
|
if bill.pk:
|
|
t_opts = bill.transactions.model._meta
|
|
if bill.get_type() == bill.PROFORMA:
|
|
return '<span title="Pro forma">---</span>'
|
|
transactions = bill.transactions.all()
|
|
if len(transactions) == 1:
|
|
args = (transactions[0].pk,)
|
|
view = 'admin:%s_%s_change' % (t_opts.app_label, t_opts.model_name)
|
|
url = reverse(view, args=args)
|
|
else:
|
|
url = reverse('admin:%s_%s_changelist' % (t_opts.app_label, t_opts.model_name))
|
|
url += '?bill=%i' % bill.pk
|
|
state = bill.get_payment_state_display().upper()
|
|
title = ''
|
|
if bill.closed_amends:
|
|
state = '<strike>%s*</strike>' % state
|
|
title = _("This bill has been amended, this value may not be valid.")
|
|
color = PAYMENT_STATE_COLORS.get(bill.payment_state, 'grey')
|
|
return '<a href="{url}" style="color:{color}" title="{title}">{name}</a>'.format(
|
|
url=url, color=color, name=state, title=title)
|
|
display_payment_state.short_description = _("Payment")
|
|
|
|
def get_queryset(self, request):
|
|
qs = super().get_queryset(request)
|
|
qs = qs.annotate(
|
|
models.Count('lines'),
|
|
# FIXME https://code.djangoproject.com/ticket/10060
|
|
approx_total=Coalesce(Sum(
|
|
(F('lines__subtotal') + Coalesce('lines__sublines__total', 0)) * (1+F('lines__tax')/100),
|
|
), 0),
|
|
)
|
|
qs = qs.prefetch_related(
|
|
Prefetch('amends', queryset=Bill.objects.filter(is_open=False), to_attr='closed_amends')
|
|
)
|
|
return qs.defer('html')
|
|
|
|
|
|
class AmendInline(BillAdminMixin, admin.TabularInline):
|
|
model = Bill
|
|
fields = (
|
|
'self_link', 'type', 'display_total_with_subtotals', 'display_payment_state', 'is_open',
|
|
'is_sent'
|
|
)
|
|
readonly_fields = fields
|
|
verbose_name_plural = _("Amends")
|
|
can_delete = False
|
|
extra = 0
|
|
|
|
self_link = admin_link('__str__')
|
|
|
|
def has_add_permission(self, *args, **kwargs):
|
|
return False
|
|
|
|
|
|
class BillAdmin(BillAdminMixin, ExtendedModelAdmin):
|
|
list_display = (
|
|
'number', 'type_link', 'account_link', 'closed_on_display', 'updated_on_display',
|
|
'num_lines', 'display_total', 'display_payment_state', 'is_sent'
|
|
)
|
|
list_filter = (
|
|
BillTypeListFilter, 'is_open', 'is_sent', TotalListFilter, PaymentStateListFilter,
|
|
AmendedListFilter, 'account__is_active',
|
|
)
|
|
add_fields = ('account', 'type', 'amend_of', 'is_open', 'due_on', 'comments')
|
|
change_list_template = 'admin/bills/bill/change_list.html'
|
|
fieldsets = (
|
|
(None, {
|
|
'fields': ['number', 'type', (), 'account_link', 'display_total_with_subtotals',
|
|
'display_payment_state', 'is_sent', 'comments'],
|
|
}),
|
|
(_("Dates"), {
|
|
'classes': ('collapse',),
|
|
'fields': ('created_on_display', 'closed_on_display', 'updated_on_display',
|
|
'due_on'),
|
|
}),
|
|
(_("Raw"), {
|
|
'classes': ('collapse',),
|
|
'fields': ('html',),
|
|
}),
|
|
)
|
|
list_prefetch_related = ('transactions', 'lines__sublines')
|
|
search_fields = ('number', 'account__username', 'comments')
|
|
change_view_actions = [
|
|
actions.manage_lines, actions.view_bill, actions.download_bills, actions.send_bills,
|
|
actions.close_bills, actions.amend_bills, actions.close_send_download_bills,
|
|
]
|
|
actions = [
|
|
actions.manage_lines, actions.download_bills, actions.close_bills, actions.send_bills,
|
|
actions.amend_bills, actions.bill_report, actions.service_report,
|
|
actions.close_send_download_bills, list_accounts,
|
|
]
|
|
change_readonly_fields = ('account_link', 'type', 'is_open', 'amend_of_link')
|
|
readonly_fields = (
|
|
'number', 'display_total', 'is_sent', 'display_payment_state', 'created_on_display',
|
|
'closed_on_display', 'updated_on_display', 'display_total_with_subtotals',
|
|
)
|
|
date_hierarchy = 'closed_on'
|
|
|
|
created_on_display = admin_date('created_on', short_description=_("Created"))
|
|
closed_on_display = admin_date('closed_on', short_description=_("Closed"))
|
|
updated_on_display = admin_date('updated_on', short_description=_("Updated"))
|
|
amend_of_link = admin_link('amend_of')
|
|
|
|
# def amend_links(self, bill):
|
|
# links = []
|
|
# for amend in bill.amends.all():
|
|
# url = reverse('admin:bills_bill_change', args=(amend.id,))
|
|
# links.append('<a href="{url}">{num}</a>'.format(url=url, num=amend.number))
|
|
# return '<br>'.join(links)
|
|
# amend_links.short_description = _("Amends")
|
|
# amend_links.allow_tags = True
|
|
|
|
def num_lines(self, bill):
|
|
return bill.lines__count
|
|
num_lines.admin_order_field = 'lines__count'
|
|
num_lines.short_description = _("lines")
|
|
|
|
def display_total(self, bill):
|
|
currency = settings.BILLS_CURRENCY.lower()
|
|
return format_html('{} &{};', bill.compute_total(), currency)
|
|
display_total.short_description = _("total")
|
|
display_total.admin_order_field = 'approx_total'
|
|
|
|
def type_link(self, bill):
|
|
bill_type = bill.type.lower()
|
|
url = reverse('admin:bills_%s_changelist' % bill_type)
|
|
return format_html('<a href="{}">{}</a>', url, bill.get_type_display())
|
|
type_link.short_description = _("type")
|
|
type_link.admin_order_field = 'type'
|
|
|
|
def get_urls(self):
|
|
""" Hook bill lines management URLs on bill admin """
|
|
urls = super().get_urls()
|
|
admin_site = self.admin_site
|
|
extra_urls = [
|
|
url("^manage-lines/$",
|
|
admin_site.admin_view(BillLineManagerAdmin(BillLine, admin_site).changelist_view),
|
|
name='bills_bill_manage_lines'),
|
|
]
|
|
return extra_urls + urls
|
|
|
|
def get_readonly_fields(self, request, obj=None):
|
|
fields = super().get_readonly_fields(request, obj)
|
|
if obj and not obj.is_open:
|
|
fields += self.add_fields
|
|
return fields
|
|
|
|
def get_fieldsets(self, request, obj=None):
|
|
fieldsets = super().get_fieldsets(request, obj)
|
|
if obj:
|
|
# Switches between amend_of_link and amend_links fields
|
|
fields = fieldsets[0][1]['fields']
|
|
if obj.amend_of_id:
|
|
fields[2] = 'amend_of_link'
|
|
else:
|
|
fields[2] = ()
|
|
if obj.is_open:
|
|
fieldsets = fieldsets[0:-1]
|
|
return fieldsets
|
|
|
|
def get_change_view_actions(self, obj=None):
|
|
actions = super().get_change_view_actions(obj)
|
|
exclude = []
|
|
if obj:
|
|
if not obj.is_open:
|
|
exclude += ['close_bills', 'close_send_download_bills']
|
|
if obj.type not in obj.AMEND_MAP:
|
|
exclude += ['amend_bills']
|
|
return [action for action in actions if action.__name__ not in exclude]
|
|
|
|
def get_inline_instances(self, request, obj=None):
|
|
cls = type(self)
|
|
if obj and not obj.is_open:
|
|
if obj.amends.all():
|
|
cls.inlines = [AmendInline, ClosedBillLineInline]
|
|
else:
|
|
cls.inlines = [ClosedBillLineInline]
|
|
else:
|
|
cls.inlines = [BillLineInline]
|
|
return super().get_inline_instances(request, obj)
|
|
|
|
def formfield_for_dbfield(self, db_field, **kwargs):
|
|
""" Make value input widget bigger """
|
|
if db_field.name == 'comments':
|
|
kwargs['widget'] = forms.Textarea(attrs={'cols': 70, 'rows': 4})
|
|
elif db_field.name == 'html':
|
|
kwargs['widget'] = forms.Textarea(attrs={'cols': 150, 'rows': 20})
|
|
formfield = super().formfield_for_dbfield(db_field, **kwargs)
|
|
if db_field.name == 'amend_of':
|
|
formfield.queryset = formfield.queryset.filter(is_open=False)
|
|
return formfield
|
|
|
|
def change_view(self, request, object_id, **kwargs):
|
|
# TODO raise404, here and everywhere
|
|
bill = self.get_object(request, unquote(object_id))
|
|
actions.validate_contact(request, bill, error=False)
|
|
return super().change_view(request, object_id, **kwargs)
|
|
|
|
|
|
admin.site.register(Bill, BillAdmin)
|
|
admin.site.register(Invoice, BillAdmin)
|
|
admin.site.register(AmendmentInvoice, BillAdmin)
|
|
admin.site.register(AbonoInvoice, BillAdmin)
|
|
admin.site.register(Fee, BillAdmin)
|
|
admin.site.register(AmendmentFee, BillAdmin)
|
|
admin.site.register(ProForma, BillAdmin)
|
|
admin.site.register(BillLine, BillLineAdmin)
|
|
|
|
|
|
class BillContactInline(admin.StackedInline):
|
|
model = BillContact
|
|
fields = ('name', 'address', ('city', 'zipcode'), 'country', 'vat')
|
|
|
|
def formfield_for_dbfield(self, db_field, **kwargs):
|
|
""" Make value input widget bigger """
|
|
if db_field.name == 'name':
|
|
kwargs['widget'] = forms.TextInput(attrs={'size':'90'})
|
|
if db_field.name == 'address':
|
|
kwargs['widget'] = forms.Textarea(attrs={'cols': 70, 'rows': 2})
|
|
if db_field.name == 'email_usage':
|
|
kwargs['widget'] = PaddingCheckboxSelectMultiple(45)
|
|
return super().formfield_for_dbfield(db_field, **kwargs)
|
|
|
|
|
|
def has_bill_contact(account):
|
|
return hasattr(account, 'billcontact')
|
|
has_bill_contact.boolean = True
|
|
has_bill_contact.admin_order_field = 'billcontact'
|
|
|
|
|
|
insertattr(AccountAdmin, 'inlines', BillContactInline)
|
|
insertattr(AccountAdmin, 'list_display', has_bill_contact)
|
|
insertattr(AccountAdmin, 'list_filter', HasBillContactListFilter)
|
|
insertattr(AccountAdmin, 'list_select_related', 'billcontact')
|