bornhack-website/src/economy/models.py

import os

from django.contrib import messages
from django.core.exceptions import ValidationError
from django.db import models
from django.urls import reverse

from utils.models import CampRelatedModel, CreatedUpdatedModel, UUIDModel
from utils.slugs import unique_slugify

from .email import (
    send_accountingsystem_expense_email,
    send_accountingsystem_revenue_email,
    send_expense_approved_email,
    send_expense_rejected_email,
    send_revenue_approved_email,
    send_revenue_rejected_email,
)


class ChainManager(models.Manager):
    """
    ChainManager adds 'expenses_total' and 'revenues_total' to the Chain qs
    Also adds 'expenses_count' and 'revenues_count' and prefetches all expenses
    and revenues for the credebtors.
    """

    def get_queryset(self):
        qs = super().get_queryset()
        qs = qs.prefetch_related(
            models.Prefetch("credebtors__expenses", to_attr="all_expenses"),
            models.Prefetch("credebtors__revenues", to_attr="all_revenues"),
        )
        qs = qs.annotate(
            all_expenses_amount=models.Sum(
                "credebtors__expenses__amount", distinct=True
            )
        )
        qs = qs.annotate(
            all_expenses_count=models.Count("credebtors__expenses", distinct=True)
        )
        qs = qs.annotate(
            all_revenues_amount=models.Sum(
                "credebtors__revenues__amount", distinct=True
            )
        )
        qs = qs.annotate(
            all_revenues_count=models.Count("credebtors__revenues", distinct=True)
        )
        return qs


class Chain(CreatedUpdatedModel, UUIDModel):
    """
    A chain of Credebtors. Used to group when several Creditors/Debtors
    belong to the same Chain/company, like XL Byg stores or Netto stores.
    """

    class Meta:
        ordering = ["name"]

    objects = ChainManager()

    name = models.CharField(
        max_length=100,
        unique=True,
        help_text='A short name for this Chain, like "Netto" or "XL Byg". 100 characters or fewer.',
    )

    slug = models.SlugField(
        unique=True,
        blank=True,
        help_text="The url slug for this Chain. Leave blank to auto generate a slug.",
    )

    notes = models.TextField(
        help_text="Any notes for this Chain. Will be shown to anyone creating Expenses or Revenues for this Chain.",
        blank=True,
    )

    def __str__(self):
        return self.name

    def save(self, **kwargs):
        if not self.slug:
            self.slug = unique_slugify(
                self.name,
                slugs_in_use=self.__class__.objects.all().values_list(
                    "slug", flat=True
                ),
            )
        super().save(**kwargs)

    @property
    def expenses(self):
        return Expense.objects.filter(creditor__chain__pk=self.pk)

    @property
    def revenues(self):
        return Revenue.objects.filter(debtor__chain__pk=self.pk)


class CredebtorManager(models.Manager):
    """
    CredebtorManager adds 'expenses_total' and 'revenues_total' to the Credebtor qs,
    and prefetches expenses and revenues for the credebtor(s).
    """

    def get_queryset(self):
        qs = super().get_queryset()
        qs = qs.prefetch_related(
            models.Prefetch("expenses", to_attr="all_expenses"),
            models.Prefetch("revenues", to_attr="all_revenues"),
        )
        qs = qs.annotate(all_expenses_amount=models.Sum("expenses__amount"))
        qs = qs.annotate(all_revenues_amount=models.Sum("revenues__amount"))
        return qs


class Credebtor(CreatedUpdatedModel, UUIDModel):
    """
    The Credebtor model represents the specific "instance" of a Chain,
    like "XL Byg Rønne" or "Netto Gelsted".
    The model is used for both creditors and debtors, since there is a
    lot of overlap between them.
    """

    class Meta:
        ordering = ["name"]
        unique_together = ("chain", "slug")

    objects = CredebtorManager()

    chain = models.ForeignKey(
        "economy.Chain",
        on_delete=models.PROTECT,
        related_name="credebtors",
        help_text="The Chain to which this Credebtor belongs.",
    )

    name = models.CharField(
        max_length=100,
        unique=True,
        help_text='The name of this Credebtor, like "XL Byg Rønne" or "Netto Gelsted". 100 characters or fewer.',
    )

    slug = models.SlugField(
        blank=True,
        help_text="The url slug for this Credebtor. Leave blank to auto generate a slug.",
    )

    address = models.TextField(help_text="The address of this Credebtor.")

    notes = models.TextField(
        blank=True,
        help_text="Any notes for this Credebtor. Shown when creating an Expense or Revenue for this Credebtor.",
    )

    def __str__(self):
        return self.name

    def save(self, **kwargs):
        """
        Generate slug as needed
        """
        if not self.slug:
            self.slug = unique_slugify(
                self.name,
                slugs_in_use=self.__class__.objects.filter(
                    chain=self.chain
                ).values_list("slug", flat=True),
            )
        super().save(**kwargs)


class Revenue(CampRelatedModel, UUIDModel):
    """
    The Revenue model represents any type of income for BornHack.

    Most Revenue objects will have a FK to the Invoice model,
    but only if the revenue relates directly to an Invoice in our system.

    Other Revenue objects (such as money returned from bottle deposits) will
    not have a related BornHack Invoice object.
    """

    camp = models.ForeignKey(
        "camps.Camp",
        on_delete=models.PROTECT,
        related_name="revenues",
        help_text="The camp to which this revenue belongs",
    )

    debtor = models.ForeignKey(
        "economy.Credebtor",
        on_delete=models.PROTECT,
        related_name="revenues",
        help_text="The Debtor to which this revenue belongs",
    )

    user = models.ForeignKey(
        "auth.User",
        on_delete=models.PROTECT,
        related_name="revenues",
        help_text="The user who submitted this revenue",
    )

    amount = models.DecimalField(
        decimal_places=2,
        max_digits=12,
        help_text="The amount of this revenue in DKK. Must match the amount on the documentation uploaded below.",
    )

    description = models.CharField(
        max_length=200,
        help_text="A short description of this revenue. Please keep it meningful as it helps the Economy team a lot when categorising revenue. 200 characters or fewer.",
    )

    invoice = models.ImageField(
        help_text="The invoice file for this revenue. Please make sure the amount on the invoice matches the amount you entered above. All common image formats are accepted, as well as PDF.",
        upload_to="revenues/",
    )

    invoice_date = models.DateField(
        help_text="The invoice date for this Revenue. This must match the invoice date on the documentation uploaded below. Format is YYYY-MM-DD."
    )

    invoice_fk = models.ForeignKey(
        "shop.Invoice",
        on_delete=models.PROTECT,
        related_name="revenues",
        help_text="The Invoice object to which this Revenue object relates. Can be None if this revenue does not have a related BornHack Invoice.",
        blank=True,
        null=True,
    )

    responsible_team = models.ForeignKey(
        "teams.Team",
        on_delete=models.PROTECT,
        related_name="revenues",
        help_text="The team to which this revenue belongs. When in doubt pick the Economy team.",
    )

    approved = models.BooleanField(
        blank=True,
        null=True,
        default=None,
        help_text="True if this Revenue has been approved by the responsible team. False if it has been rejected. Blank if noone has decided yet.",
    )

    notes = models.TextField(
        blank=True,
        help_text="Economy Team notes for this revenue. Only visible to the Economy team and the submitting user.",
    )

    def clean(self):
        if self.amount < 0:
            raise ValidationError("Amount of a Revenue object can not be negative")

    @property
    def invoice_filename(self):
        return os.path.basename(self.invoice.file.name)

    @property
    def approval_status(self):
        if self.approved is None:
            return "Pending approval"
        elif self.approved:
            return "Approved"
        else:
            return "Rejected"

    def approve(self, request):
        """
        This method marks a revenue as approved.
        Approving a revenue triggers an email to the economy system, and another email to the user who submitted the revenue
        """
        if request.user == self.user:
            messages.error(
                request,
                "You cannot approve your own revenues, aka. the anti-stein-bagger defense",
            )
            return

        # mark as approved and save
        self.approved = True
        self.save()

        # send email to economic for this revenue
        send_accountingsystem_revenue_email(revenue=self)

        # send email to the user
        send_revenue_approved_email(revenue=self)

        # message to the browser
        messages.success(request, "Revenue %s approved" % self.pk)

    def reject(self, request):
        """
        This method marks a revenue as not approved.
        Not approving a revenue triggers an email to the user who submitted the revenue in the first place.
        """
        # mark as not approved and save
        self.approved = False
        self.save()

        # send email to the user
        send_revenue_rejected_email(revenue=self)

        # message to the browser
        messages.success(request, "Revenue %s rejected" % self.pk)


class Expense(CampRelatedModel, UUIDModel):
    camp = models.ForeignKey(
        "camps.Camp",
        on_delete=models.PROTECT,
        related_name="expenses",
        help_text="The camp to which this expense belongs",
    )

    creditor = models.ForeignKey(
        "economy.Credebtor",
        on_delete=models.PROTECT,
        related_name="expenses",
        help_text="The Creditor to which this expense belongs",
    )

    user = models.ForeignKey(
        "auth.User",
        on_delete=models.PROTECT,
        related_name="expenses",
        help_text="The user to which this expense belongs",
    )

    amount = models.DecimalField(
        decimal_places=2,
        max_digits=12,
        help_text="The amount of this expense in DKK. Must match the amount on the invoice uploaded below.",
    )

    description = models.CharField(
        max_length=200,
        help_text="A short description of this expense. Please keep it meningful as it helps the Economy team a lot when categorising expenses. 200 characters or fewer.",
    )

    paid_by_bornhack = models.BooleanField(
        default=True,
        help_text="Leave checked if this expense was paid by BornHack. Uncheck if you need a reimbursement for this expense.",
    )

    invoice = models.ImageField(
        help_text="The invoice for this expense. Please make sure the amount on the invoice matches the amount you entered above. All common image formats are accepted.",
        upload_to="expenses/",
    )

    invoice_date = models.DateField(
        help_text="The invoice date for this Expense. This must match the invoice date on the documentation uploaded below. Format is YYYY-MM-DD."
    )

    responsible_team = models.ForeignKey(
        "teams.Team",
        on_delete=models.PROTECT,
        related_name="expenses",
        help_text="The team to which this Expense belongs. A team responsible will need to approve the expense. When in doubt pick the Economy team.",
    )

    approved = models.BooleanField(
        blank=True,
        null=True,
        default=None,
        help_text="True if this expense has been approved by the responsible team. False if it has been rejected. Blank if noone has decided yet.",
    )

    reimbursement = models.ForeignKey(
        "economy.Reimbursement",
        on_delete=models.PROTECT,
        related_name="expenses",
        null=True,
        blank=True,
        help_text="The reimbursement for this expense, if any. This is a dual-purpose field. If expense.paid_by_bornhack is true then expense.reimbursement references the reimbursement which this expense is created to cover. If expense.paid_by_bornhack is false then expense.reimbursement references the reimbursement which reimbursed this expense.",
    )

    notes = models.TextField(
        blank=True,
        help_text="Economy Team notes for this expense. Only visible to the Economy team and the submitting user.",
    )

    def clean(self):
        if self.amount < 0:
            raise ValidationError("Amount of an expense can not be negative")

    @property
    def invoice_filename(self):
        return os.path.basename(self.invoice.file.name)

    @property
    def approval_status(self):
        if self.approved is None:
            return "Pending approval"
        elif self.approved:
            return "Approved"
        else:
            return "Rejected"

    def approve(self, request):
        """
        This method marks an expense as approved.
        Approving an expense triggers an email to the economy system, and another email to the user who submitted the expense in the first place.
        """
        if request.user == self.user:
            messages.error(
                request,
                "You cannot approve your own expenses, aka. the anti-stein-bagger defense",
            )
            return

        # mark as approved and save
        self.approved = True
        self.save()

        # send email to economic for this expense
        send_accountingsystem_expense_email(expense=self)

        # send email to the user
        send_expense_approved_email(expense=self)

        # message to the browser
        messages.success(request, "Expense %s approved" % self.pk)

    def reject(self, request):
        """
        This method marks an expense as not approved.
        Not approving an expense triggers an email to the user who submitted the expense in the first place.
        """
        # mark as not approved and save
        self.approved = False
        self.save()

        # send email to the user
        send_expense_rejected_email(expense=self)

        # message to the browser
        messages.success(request, "Expense %s rejected" % self.pk)


class Reimbursement(CampRelatedModel, UUIDModel):
    """
    A reimbursement covers one or more expenses.
    """

    camp = models.ForeignKey(
        "camps.Camp",
        on_delete=models.PROTECT,
        related_name="reimbursements",
        help_text="The camp to which this reimbursement belongs",
    )

    user = models.ForeignKey(
        "auth.User",
        on_delete=models.PROTECT,
        related_name="created_reimbursements",
        help_text="The economy team member who created this reimbursement.",
    )

    reimbursement_user = models.ForeignKey(
        "auth.User",
        on_delete=models.PROTECT,
        related_name="reimbursements",
        help_text="The user this reimbursement belongs to.",
    )

    notes = models.TextField(
        blank=True,
        help_text="Economy Team notes for this reimbursement. Only visible to the Economy team and the related user.",
    )

    paid = models.BooleanField(
        default=False,
        help_text="Check when this reimbursement has been paid to the user",
    )

    @property
    def covered_expenses(self):
        """
        Returns a queryset of all expenses covered by this reimbursement. Does not include the expense that paid for the reimbursement.
        """
        return self.expenses.filter(paid_by_bornhack=False)

    @property
    def amount(self):
        """
        The total amount for a reimbursement is calculated by adding up the amounts for all the related expenses
        """
        amount = 0
        for expense in self.expenses.filter(paid_by_bornhack=False):
            amount += expense.amount
        return amount


class Pos(CampRelatedModel, UUIDModel):
    """A Pos is a point-of-sale like the bar or infodesk."""

    class Meta:
        ordering = ["name"]

    name = models.CharField(max_length=255, help_text="The point-of-sale name")

    slug = models.SlugField(
        max_length=255,
        blank=True,
        help_text="Url slug for this POS. Leave blank to generate based on POS name.",
    )

    team = models.ForeignKey(
        "teams.Team",
        on_delete=models.PROTECT,
        help_text="The Team managning this POS",
    )

    def save(self, **kwargs):
        """Generate slug if needed."""
        if not self.slug:
            self.slug = unique_slugify(
                self.name,
                slugs_in_use=self.__class__.objects.filter(
                    team__camp=self.team.camp
                ).values_list("slug", flat=True),
            )
        super().save(**kwargs)

    @property
    def camp(self):
        return self.team.camp

    camp_filter = "team__camp"

    def get_absolute_url(self):
        return reverse(
            "backoffice:pos_detail",
            kwargs={"camp_slug": self.team.camp.slug, "pos_slug": self.slug},
        )


class PosReport(CampRelatedModel, UUIDModel):
    """A PosReport contains the HAX/DKK counts and the csv report from the POS system."""

    class Meta:
        ordering = ["date", "pos"]

    pos = models.ForeignKey(
        "economy.Pos",
        on_delete=models.PROTECT,
        related_name="pos_reports",
        help_text="The Pos this PosReport belongs to.",
    )

    bank_responsible = models.ForeignKey(
        "auth.User",
        on_delete=models.PROTECT,
        related_name="pos_reports_banker",
        help_text="The banker responsible for this PosReport",
    )

    pos_responsible = models.ForeignKey(
        "auth.User",
        on_delete=models.PROTECT,
        related_name="pos_reports_poser",
        help_text="The POS person responsible for this PosReport",
    )

    date = models.DateField(
        help_text="The date this report covers (pick the starting date if opening hours cross midnight).",
    )

    pos_json = models.JSONField(
        null=True,
        blank=True,
        help_text="The JSON exported from the external POS system",
    )

    comments = models.TextField(
        blank=True,
        help_text="Any comments about this PosReport",
    )

    dkk_sales_izettle = models.PositiveIntegerField(
        default=0, help_text="The total DKK amount in iZettle cash sales"
    )

    hax_sold_izettle = models.PositiveIntegerField(
        default=0,
        help_text="The number of HAX sold through the iZettle from the POS",
    )

    hax_sold_website = models.PositiveIntegerField(
        default=0,
        help_text="The number of HAX sold through webshop tickets being used in the POS",
    )

    # bank count start of day

    bank_count_dkk_start = models.PositiveIntegerField(
        default=0,
        help_text="The number of DKK handed out from the bank to the POS at the start of the business day (counted by the bank responsible)",
    )

    bank_count_hax5_start = models.PositiveIntegerField(
        default=0,
        help_text="The number of 5 HAX coins handed out from the bank to the POS at the start of the business day (counted by the bank responsible)",
    )

    bank_count_hax10_start = models.PositiveIntegerField(
        default=0,
        help_text="The number of 10 HAX coins handed out from the bank to the POS at the start of the business day (counted by the bank responsible)",
    )

    bank_count_hax20_start = models.PositiveIntegerField(
        default=0,
        help_text="The number of 20 HAX coins handed out from the bank to the POS at the start of the business day (counted by the bank responsible)",
    )

    bank_count_hax50_start = models.PositiveIntegerField(
        default=0,
        help_text="The number of 50 HAX coins handed out from the bank to the POS at the start of the business day (counted by the bank responsible)",
    )

    bank_count_hax100_start = models.PositiveIntegerField(
        default=0,
        help_text="The number of 100 HAX coins handed out from the bank to the POS at the start of the business day (counted by the bank responsible)",
    )

    # POS count start of day

    pos_count_dkk_start = models.PositiveIntegerField(
        default=0,
        help_text="The number of DKK handed out from the bank to the POS at the start of the business day (counted by the POS responsible)",
    )

    pos_count_hax5_start = models.PositiveIntegerField(
        default=0,
        help_text="The number of 5 HAX coins received by the POS from the bank at the start of the business day (counted by the POS responsible)",
    )

    pos_count_hax10_start = models.PositiveIntegerField(
        default=0,
        help_text="The number of 10 HAX coins received by the POS from the bank at the start of the business day (counted by the POS responsible)",
    )

    pos_count_hax20_start = models.PositiveIntegerField(
        default=0,
        help_text="The number of 20 HAX coins received by the POS from the bank at the start of the business day (counted by the POS responsible)",
    )

    pos_count_hax50_start = models.PositiveIntegerField(
        default=0,
        help_text="The number of 50 HAX coins received by the POS from the bank at the start of the business day (counted by the POS responsible)",
    )

    pos_count_hax100_start = models.PositiveIntegerField(
        default=0,
        help_text="The number of 100 HAX coins received by the POS from the bank at the start of the business day (counted by the POS responsible)",
    )

    # bank count end of day

    bank_count_dkk_end = models.PositiveIntegerField(
        default=0,
        help_text="The number of DKK handed back from the POS to the bank at the end of the business day (counted by the bank responsible)",
    )

    bank_count_hax5_end = models.PositiveIntegerField(
        default=0,
        help_text="The number of 5 HAX coins handed back from the POS to the bank at the end of the business day (counted by the bank responsible)",
    )

    bank_count_hax10_end = models.PositiveIntegerField(
        default=0,
        help_text="The number of 10 HAX coins handed back from the POS to the bank at the end of the business day (counted by the bank responsible)",
    )

    bank_count_hax20_end = models.PositiveIntegerField(
        default=0,
        help_text="The number of 20 HAX coins handed back from the POS to the bank at the end of the business day (counted by the bank responsible)",
    )

    bank_count_hax50_end = models.PositiveIntegerField(
        default=0,
        help_text="The number of 50 HAX coins handed back from the POS to the bank at the end of the business day (counted by the bank responsible)",
    )

    bank_count_hax100_end = models.PositiveIntegerField(
        default=0,
        help_text="The number of 100 HAX coins handed back from the POS to the bank at the end of the business day (counted by the bank responsible)",
    )

    # pos count end of day

    pos_count_dkk_end = models.PositiveIntegerField(
        default=0,
        help_text="The number of DKK handed back from the POS to the bank at the end of the business day (counted by the POS responsible)",
    )

    pos_count_hax5_end = models.PositiveIntegerField(
        default=0,
        help_text="The number of 5 HAX coins received by the bank from the POS at the end of the business day (counted by the POS responsible)",
    )

    pos_count_hax10_end = models.PositiveIntegerField(
        default=0,
        help_text="The number of 10 HAX coins received by the bank from the POS at the end of the business day (counted by the POS responsible)",
    )

    pos_count_hax20_end = models.PositiveIntegerField(
        default=0,
        help_text="The number of 20 HAX coins received by the bank from the POS at the end of the business day (counted by the POS responsible)",
    )

    pos_count_hax50_end = models.PositiveIntegerField(
        default=0,
        help_text="The number of 50 HAX coins received by the bank from the POS at the end of the business day (counted by the POS responsible)",
    )

    pos_count_hax100_end = models.PositiveIntegerField(
        default=0,
        help_text="The number of 100 HAX coins received by the bank from the POS at the end of the business day (counted by the POS responsible)",
    )

    @property
    def camp(self):
        return self.pos.team.camp

    camp_filter = "pos__team__camp"

    def get_absolute_url(self):
        return reverse(
            "backoffice:posreport_detail",
            kwargs={
                "camp_slug": self.camp.slug,
                "pos_slug": self.pos.slug,
                "posreport_uuid": self.uuid,
            },
        )

    @property
    def dkk_start_ok(self):
        return self.bank_count_dkk_start == self.pos_count_dkk_start

    @property
    def hax5_start_ok(self):
        return self.bank_count_hax5_start == self.pos_count_hax5_start

    @property
    def hax10_start_ok(self):
        return self.bank_count_hax10_start == self.pos_count_hax10_start

    @property
    def hax20_start_ok(self):
        return self.bank_count_hax20_start == self.pos_count_hax20_start

    @property
    def hax50_start_ok(self):
        return self.bank_count_hax50_start == self.pos_count_hax50_start

    @property
    def hax100_start_ok(self):
        return self.bank_count_hax100_start == self.pos_count_hax100_start

    @property
    def bank_start_hax(self):
        return (
            (self.bank_count_hax5_start * 5)
            + (self.bank_count_hax10_start * 10)
            + (self.bank_count_hax20_start * 20)
            + (self.bank_count_hax50_start * 50)
            + (self.bank_count_hax100_start * 100)
        )

    @property
    def pos_start_hax(self):
        return (
            (self.pos_count_hax5_start * 5)
            + (self.pos_count_hax10_start * 10)
            + (self.pos_count_hax20_start * 20)
            + (self.pos_count_hax50_start * 50)
            + (self.pos_count_hax100_start * 100)
        )

    @property
    def bank_end_hax(self):
        return (
            (self.bank_count_hax5_end * 5)
            + (self.bank_count_hax10_end * 10)
            + (self.bank_count_hax20_end * 20)
            + (self.bank_count_hax50_end * 50)
            + (self.bank_count_hax100_end * 100)
        )

    @property
    def pos_end_hax(self):
        return (
            (self.pos_count_hax5_end * 5)
            + (self.pos_count_hax10_end * 10)
            + (self.pos_count_hax20_end * 20)
            + (self.pos_count_hax50_end * 50)
            + (self.pos_count_hax100_end * 100)
        )

    @property
    def dkk_end_ok(self):
        return self.bank_count_dkk_end == self.pos_count_dkk_end

    @property
    def hax5_end_ok(self):
        return self.bank_count_hax5_end == self.pos_count_hax5_end

    @property
    def hax10_end_ok(self):
        return self.bank_count_hax10_end == self.pos_count_hax10_end

    @property
    def hax20_end_ok(self):
        return self.bank_count_hax20_end == self.pos_count_hax20_end

    @property
    def hax50_end_ok(self):
        return self.bank_count_hax50_end == self.pos_count_hax50_end

    @property
    def hax100_end_ok(self):
        return self.bank_count_hax100_end == self.pos_count_hax100_end

    def allok(self):
        return all(
            [
                self.dkk_start_ok,
                self.hax5_start_ok,
                self.hax10_start_ok,
                self.hax20_start_ok,
                self.hax50_start_ok,
                self.hax100_start_ok,
                self.dkk_end_ok,
                self.hax5_end_ok,
                self.hax10_end_ok,
                self.hax20_end_ok,
                self.hax50_end_ok,
                self.hax100_end_ok,
            ]
        )

    @property
    def pos_json_sales(self):
        """Calculate the total HAX sales and number of transactions."""
        transactions = 0
        total = 0
        if self.pos_json:
            for tx in self.pos_json:
                transactions += 1
                total += tx["amount"]
        return transactions, total

    @property
    def hax_balance(self):
        """Return the hax balance all things considered."""
        balance = 0
        # start by adding what the POS got at the start of the day
        balance += self.bank_start_hax
        # then substract the HAX the POS sold via the izettle
        balance -= self.hax_sold_izettle
        # then substract the HAX sold through webshop tickets
        balance -= self.hax_sold_website
        # then add the HAX sales from the POS json
        balance += self.pos_json_sales[1]
        # finally substract the HAX received from the POS at the end of the day
        balance -= self.bank_end_hax
        # all good
        return balance

    @property
    def dkk_balance(self):
        """Return the DKK balance all things considered."""
        balance = 0
        # start with the bank count at the start of the day
        balance += self.bank_count_dkk_start
        # then add the iZettle sales for the day
        balance += self.dkk_sales_izettle
        # then substract what was returned to the bank at days end
        balance -= self.bank_count_dkk_end
        # all good
        return balance