Add common cost split and corrections for ZEV.

Author: MarcoSteinacher

django/geno/utils.py

@@ -221,6 +221,12 @@ def nformat(number, precision=2, round_to=False, thousands_separator="'"):
         return format(number, ".%df" % precision)
 
 
+def unformat(number: str | float, thousands_separator="'"):
+    if isinstance(number, str):
+        number = number.replace(thousands_separator, "").replace("%", "")
+    return float(number)
+
+
 def sanitize_filename(filename):
     normalized_filename = filename.replace("+", "-").replace("/", "-")
     return re.sub(r"[^\w\-_\.]+", "", normalized_filename)

django/geno/views.py

@@ -1609,7 +1609,7 @@ def get_context_data(self, **kwargs):
 
 
 class ShareInterestView(CohivaAdminViewMixin, TemplateView):
-    title = _("Zinsabrechung")
+    title = _("Zinsabrechnung")
     permission_required = (
         "geno.canview_share",
         "geno.canview_billing",

django/report/nk/bill.py

@@ -145,14 +145,12 @@ def _get_billing_groups(costs: list[NkCost]):
         return billing_groups
 
     def _get_billing_group_context(
-        self, name, group, rental_unit, total_building_cost, total_ru_cost
+        self, name, group: list[NkCost], rental_unit, total_building_cost, total_ru_cost
     ):
         object_cost = 0
         building_cost = 0
         for cost in group:
-            object_cost += cost.get_assigned_amount(
-                NkCostValueType.COST, self.contract, rental_unit
-            )
+            object_cost += cost.get_assigned_cost(self.contract, rental_unit)
             building_cost += cost.get_building_amount(NkCostValueType.COST)
         if object_cost == 0 and building_cost == 0:
             return None

django/report/nk/contract.py

@@ -6,7 +6,7 @@
 from cohiva.utils.countries import normalize_country_code
 from finance.accounting import Account, AccountKey
 from geno.models import Address, Contract, Invoice, InvoiceCategory
-from report.nk.cost import NkCost, NkCostValueType
+from report.nk.cost import NkCost
 from report.nk.rental_unit import NkRentalUnit
 
 
@@ -178,7 +178,7 @@ def akonto_nominal(self):
     def get_total_costs(self, costs: list[NkCost], rental_unit: NkRentalUnit | None = None):
         ret = 0
         for cost in costs:
-            ret += cost.get_assigned_amount(NkCostValueType.COST, self, rental_unit)
+            ret += cost.get_assigned_cost(self, rental_unit)
         return ret
 
     def get_paid_akonto(self, ru: NkRentalUnit) -> float:

django/report/nk/cost/base.py

@@ -12,6 +12,11 @@ class NkCostValueType(Enum):
     COST = 1  # The costs that are billed
     USAGE = 2  # The usage that is billed (consumed energy, rental unit area, etc.)
     WEIGHT = 3  # The (internal) weight for the distribution of the costs
+    COMMON_COST = (
+        4  # s Cost from common usage (e.g., Allgemeinstrom) that is split between all rental units
+    )
+    COMMON_USAGE = 5
+    COMMON_WEIGHT = 6
 
 
 @dataclass
@@ -106,25 +111,38 @@ def _normalize_monthly_amounts_for_dict(self, container: dict, value_required=Fa
     def split_costs(self):
         self._calculate_weights()
         for kind in self.total_values:
-            if kind == NkCostValueType.WEIGHT:
-                continue
-            amount_per_weight = (
-                (self.total_values[kind].amount / self.total_values[NkCostValueType.WEIGHT].amount)
-                if self.total_values[NkCostValueType.WEIGHT].amount
-                else 0
-            )
-            self._calculate_amounts(self.total_values, kind, amount_per_weight)
-            for ru in self.generator.rental_units:
-                self._calculate_amounts(self.rental_unit_values[ru.id], kind, amount_per_weight)
-            for section in self.generator.sections:
-                self._calculate_amounts(self.section_values[section.id], kind, amount_per_weight)
+            if kind in (NkCostValueType.COST, NkCostValueType.USAGE):
+                self._split_cost(kind, NkCostValueType.WEIGHT)
 
     def update(self):
         pass
 
-    def _calculate_amounts(self, values, kind: NkCostValueType, amount_per_weight):
+    def _split_cost(self, cost_type, weight_type):
+        amount_per_weight = self.generator.num_months * [0]
+        for month in range(self.generator.num_months):
+            amount_per_weight[month] = (
+                (
+                    self.total_values[cost_type].monthly_amounts[month]
+                    / self.total_values[weight_type].monthly_amounts[month]
+                )
+                if self.total_values[weight_type].monthly_amounts[month]
+                else 0
+            )
+        self._calculate_amounts(self.total_values, cost_type, weight_type, amount_per_weight)
+        for ru in self.generator.rental_units:
+            self._calculate_amounts(
+                self.rental_unit_values[ru.id], cost_type, weight_type, amount_per_weight
+            )
+        for section in self.generator.sections:
+            self._calculate_amounts(
+                self.section_values[section.id], cost_type, weight_type, amount_per_weight
+            )
+
+    def _calculate_amounts(
+        self, values, kind: NkCostValueType, weight_type: NkCostValueType, amount_per_weight
+    ):
         for month in range(self.generator.num_months):
-            amount = amount_per_weight * values[NkCostValueType.WEIGHT].monthly_amounts[month]
+            amount = amount_per_weight[month] * values[weight_type].monthly_amounts[month]
             if (
                 values[kind].monthly_amounts[month]
                 and abs(values[kind].monthly_amounts[month] - amount) > 0.01
@@ -146,14 +164,22 @@ def _calculate_amounts(self, values, kind: NkCostValueType, amount_per_weight):
         values[kind].amount = total_amount
 
     def _calculate_weights(self):
-        self.add_value_type(NkCostValueType.WEIGHT, "Gewichtung", "")
+        self._calculate_weights_for_type(NkCostValueType.WEIGHT, "get_rental_unit_weights")
+
+    def _calculate_weights_for_type(
+        self, value_type: NkCostValueType, rental_unit_weights_function_name: str
+    ):
+        self.add_value_type(value_type, "Gewichtung", "")
         monthly_weights = self.get_monthly_weights()
         section_weights = self.get_section_weights()
-        total = self.total_values[NkCostValueType.WEIGHT]
+        total = self.total_values[value_type]
+        rental_unit_weights_function = getattr(self, rental_unit_weights_function_name)
+        if not callable(rental_unit_weights_function):
+            raise ValueError(f"Invalid function name: {rental_unit_weights_function_name}")
         for ru in self.generator.rental_units:
-            ru_weights = self.get_rental_unit_weights(ru.id)
-            values = self.rental_unit_values[ru.id][NkCostValueType.WEIGHT]
-            section = self.section_values[ru.section.id][NkCostValueType.WEIGHT]
+            ru_weights = rental_unit_weights_function(ru.id)
+            values = self.rental_unit_values[ru.id][value_type]
+            section = self.section_values[ru.section.id][value_type]
             for month in range(self.generator.num_months):
                 weight = (
                     monthly_weights[month] * section_weights[ru.section.id] * ru_weights[month]
@@ -163,8 +189,8 @@ def _calculate_weights(self):
                 total.monthly_amounts[month] += weight
             values.amount = sum(values.monthly_amounts)
         for section in self.generator.sections:
-            self.section_values[section.id][NkCostValueType.WEIGHT].amount = sum(
-                self.section_values[section.id][NkCostValueType.WEIGHT].monthly_amounts
+            self.section_values[section.id][value_type].amount = sum(
+                self.section_values[section.id][value_type].monthly_amounts
             )
         total.amount = sum(total.monthly_amounts)
 
@@ -217,6 +243,9 @@ def get_export_weight_row(self, include_percent=False):
         row = self._get_export_row(NkCostValueType.WEIGHT, include_percent)
         return row
 
+    def get_export_extra_info(self, include_percent=False, formatter=None):
+        return None
+
     def _get_export_row(self, kind, include_percent):
         ## TODO: implement include_percent (if still needed)
         row = [self.name]
@@ -230,7 +259,7 @@ def _get_export_row(self, kind, include_percent):
             row.append(self.rental_unit_values[ru.id][kind].amount)
         return row
 
-    def get_assigned_amount(
+    def _get_assigned_amount(
         self,
         value_type: NkCostValueType,
         contract: "NkContract",
@@ -239,12 +268,37 @@ def get_assigned_amount(
         ret = 0
         rental_units = [rental_unit] if rental_unit else contract.rental_units
         for ru in rental_units:
-            for idx, amount in enumerate(
-                self.rental_unit_values[ru.id][value_type].monthly_amounts
-            ):
-                assigned_contract = ru.get_assigned_contract_for_month(idx)
-                if assigned_contract == contract:
-                    ret += amount
+            ret += self._get_assigned_sum(
+                self.rental_unit_values[ru.id][value_type].monthly_amounts, contract, ru
+            )
+        return ret
+
+    def get_assigned_cost(self, contract: "NkContract", rental_unit: "NkRentalUnit | None" = None):
+        return self._get_assigned_amount(NkCostValueType.COST, contract, rental_unit)
+
+    @classmethod
+    def get_assigned_amounts(
+        cls,
+        data: dict[str, list[float]],
+        contract: "NkContract",
+        rental_unit: "NkRentalUnit",
+    ):
+        ret = {}
+        for kind, monthly_values in data.items():
+            ret[kind] = cls._get_assigned_sum(monthly_values, contract, rental_unit)
+        return ret
+
+    @staticmethod
+    def _get_assigned_sum(
+        monthly_values: list[float],
+        contract: "NkContract",
+        rental_unit: "NkRentalUnit",
+    ):
+        ret = 0
+        for idx, amount in enumerate(monthly_values):
+            assigned_contract = rental_unit.get_assigned_contract_for_month(idx)
+            if assigned_contract == contract:
+                ret += amount
         return ret
 
     def get_building_amount(self, value_type: NkCostValueType):
@@ -276,3 +330,44 @@ def load_input_data(self):
                     print(warning)
                     self.generator.add_warning(warning[0], warning[1])
         super().load_input_data()
+
+
+class NkCommonCostMixin:
+    """Mixin for NkCosts that have a common usage part (e.g., Allgemeinstrom), which is distributed among all rental units."""
+
+    def __init__(self, report_generator: "NkReportGenerator", cost_config: dict):
+        super().__init__(report_generator, cost_config)
+        self.add_value_type(NkCostValueType.COMMON_COST, "Allgemeinkosten", "CHF")
+
+    def get_assigned_cost(self, contract: "NkContract", rental_unit: "NkRentalUnit | None" = None):
+        ret = super().get_assigned_cost(contract, rental_unit)
+        return ret + self._get_assigned_amount(NkCostValueType.COMMON_COST, contract, rental_unit)
+
+    def get_rental_unit_common_weights(self, ru_id):
+        """Default is the rental unit area (per period)."""
+        ru = self.generator.get_rental_unit_by_id(ru_id)
+        if ru.is_virtual:
+            return self.generator.num_months * [0.0]
+        else:
+            return self.generator.num_months * [ru.area / self.generator.num_months]
+
+    def set_common_costs(self, cost: float | list[float], usage: float | list[float] | None):
+        if isinstance(cost, list):
+            self.total_values[NkCostValueType.COMMON_COST].monthly_amounts = cost
+        else:
+            self.total_values[NkCostValueType.COMMON_COST].amount = cost
+        if usage:
+            if isinstance(usage, list):
+                self.total_values[NkCostValueType.COMMON_USAGE].monthly_amounts = usage
+            else:
+                self.total_values[NkCostValueType.COMMON_USAGE].amount = usage
+
+    def _split_common_costs(self):
+        self._calculate_common_weights()
+        for kind in (NkCostValueType.COMMON_COST, NkCostValueType.COMMON_USAGE):
+            self._split_cost(kind, NkCostValueType.COMMON_WEIGHT)
+
+    def _calculate_common_weights(self):
+        self._calculate_weights_for_type(
+            NkCostValueType.COMMON_WEIGHT, "get_rental_unit_common_weights"
+        )