Rewrite plugin for Saleor 3.14

Over the past year several changes were made to Saleor, including:
- dropping the vatlayer plugin
- changing the behavior of plugin methods

These changes require a rewrite of most of the plugin, which
hopefully still retains the same functionality. For the plugin to
work correctly, it's necessary to use the "TAX_APP" strategy in the
tax setting of Saleor.

Using TAX_APP delegates tax calculation to our plugin, however,
unless the user has a valid VATIN, we actually use the
update_checkout_prices_with_flat_rates method from the FLAT_RATES
taxCalculationStrategy. This way we can:

- reverse charge VAT for EU businesses
- charge VAT for everyone else, according to their country

Special thanks to Sergey for the support while going through this.

Author: fsiddi

saleor_vatrc/plugin.py

@@ -1,24 +1,20 @@
 from decimal import Decimal
-from typing import TYPE_CHECKING, List, Dict, Iterable, Optional, Union, Tuple
+from typing import TYPE_CHECKING, List, Optional, Union, Tuple
 import logging
 
 from stdnum.eu import vat
 import stdnum.exceptions
 
-from prices import TaxedMoney, TaxedMoneyRange
-from saleor.checkout.interface import CheckoutTaxedPricesData
-from saleor.core.taxes import include_taxes_in_prices
+from prices import TaxedMoney, TaxedMoneyRange, Money
 from saleor.order.interface import OrderTaxedPricesData
 from saleor.plugins.base_plugin import BasePlugin
-from saleor.plugins.manager import get_plugins_manager
+from saleor.tax.calculations.checkout import update_checkout_prices_with_flat_rates
 
 
 if TYPE_CHECKING:
     from saleor.account.models import Address
     from saleor.checkout.fetch import CheckoutInfo, CheckoutLineInfo
     from saleor.checkout.models import Checkout
-    from saleor.discount import DiscountInfo
-    from saleor.plugins.models import PluginConfiguration
 
 
 logger = logging.getLogger(__name__)
@@ -42,6 +38,7 @@ class VatReverseCharge(BasePlugin):
     Read more at
     https://europa.eu/youreurope/business/taxation/vat/cross-border-vat/index_en.htm#withintheeu
     """
+
     PLUGIN_ID = "blender.saleor_vatrc"
     PLUGIN_NAME = "VAT reverse charge"
     PLUGIN_DESCRIPTION = (
@@ -51,46 +48,23 @@ class VatReverseCharge(BasePlugin):
     META_VATIN_KEY = "vatrc.vatin"
     META_VATIN_VALIDATED_KEY = "vatrc.vatin_validated"
 
-    # This plugin depends on another plugin for calculating VAT
-    VAT_PLUGIN_ID = 'mirumee.taxes.vatlayer'
-
     CONFIGURATION_PER_CHANNEL = True
     DEFAULT_ACTIVE = False
 
-    @property
-    def vat_plugin(self) -> "PluginConfiguration":
-        manager = get_plugins_manager()
-        plugins = manager.plugins_per_channel[self.channel.slug]
-        return next((p for p in plugins if p.PLUGIN_ID == self.VAT_PLUGIN_ID), None)
-
-    @property
-    def vat_plugin_config(self) -> Dict[str, str]:
-        # Convert to dict to easier get config elements of the plugin we depend on
-        return {
-            item["name"]: item["value"] for item in self.vat_plugin.configuration
-        }
-
     def _skip_plugin(
         self,
         checkout_info: "CheckoutInfo",
         previous_value: Union[
             TaxedMoney,
             TaxedMoneyRange,
             Decimal,
-            CheckoutTaxedPricesData,
             OrderTaxedPricesData,
         ],
     ) -> bool:
         if not self.active:
             return True
 
-        # Skip when plugin that calculates VAT isn't active
-        if not self.vat_plugin.active:
-            return True
-
-        # If taxes aren't included into prices, there's no reverse charge to apply.
-        if not include_taxes_in_prices():
-            return True
+        return False
 
     def _skip_price_modification(
         self,
@@ -99,28 +73,21 @@ def _skip_price_modification(
             TaxedMoney,
             TaxedMoneyRange,
             Decimal,
-            CheckoutTaxedPricesData,
             OrderTaxedPricesData,
         ],
     ) -> bool:
         # If there's no tax on the given prices
         if isinstance(previous_value, TaxedMoney):
             return previous_value.net == previous_value.gross
-        if isinstance(previous_value, CheckoutTaxedPricesData):
-            return (
-                previous_value.price_with_sale.net
-                == previous_value.price_with_sale.gross
-            )
         if isinstance(previous_value, OrderTaxedPricesData):
             return (
-                previous_value.price_with_discounts.net
-                == previous_value.price_with_discounts.gross
+                previous_value.price_with_discounts.net == previous_value.price_with_discounts.gross
             )
 
         return False
 
-    def _get_seller_country_code(self) -> str:
-        return self.vat_plugin_config.get("origin_country", "").upper()
+    def _get_seller_country_code(self, checkout) -> str:
+        return checkout.channel.default_country.code
 
     def _get_buyer_country_code(self, address: Optional["Address"]) -> str:
         return address.country.code if address else ""
@@ -154,8 +121,10 @@ def _validate_vatin_metadata(
         checkout: "Checkout",
         address: Optional["Address"],
     ) -> bool:
-        vatin_metadata_value = checkout.get_value_from_metadata(self.META_VATIN_KEY)
-        valid_vatin_previous = checkout.get_value_from_metadata(
+        vatin_metadata_value = checkout.metadata_storage.get_value_from_metadata(
+            self.META_VATIN_KEY
+        )
+        valid_vatin_previous = checkout.metadata_storage.get_value_from_metadata(
             self.META_VATIN_VALIDATED_KEY
         )
         buyer_country = self._get_buyer_country_code(address)
@@ -167,18 +136,18 @@ def _validate_vatin_metadata(
         # Does not look like a valid VATIN
         if not vatin_country or not vatin or vatin_country != buyer_country:
             logger.debug('Invalid VATIN format: missing or mismatching country code')
-            checkout.delete_value_from_metadata(self.META_VATIN_KEY)
-            checkout.delete_value_from_metadata(self.META_VATIN_VALIDATED_KEY)
-            checkout.save(update_fields=["metadata"])
+            checkout.metadata_storage.delete_value_from_metadata(self.META_VATIN_KEY)
+            checkout.metadata_storage.delete_value_from_metadata(self.META_VATIN_VALIDATED_KEY)
+            checkout.metadata_storage.save(update_fields=["metadata"])
         # Only validate the VATIN further if it differs from an already validated one:
         elif vatin != valid_vatin_previous and self._validate_vatin_value(vatin):
             logger.debug('Updating VATIN: %s', vatin)
             metadata_items = {
                 self.META_VATIN_KEY: vatin,
                 self.META_VATIN_VALIDATED_KEY: vatin,
             }
-            checkout.store_value_in_metadata(items=metadata_items)
-            checkout.save(update_fields=["metadata"])
+            checkout.metadata_storage.store_value_in_metadata(items=metadata_items)
+            checkout.metadata_storage.save(update_fields=["metadata"])
 
     def _deduct_tax(self, previous_value: "TaxedMoney") -> "TaxedMoney":
         return TaxedMoney(gross=previous_value.net, net=previous_value.net)
@@ -188,61 +157,32 @@ def calculate_checkout_total(
         checkout_info: "CheckoutInfo",
         lines: List["CheckoutLineInfo"],
         address: Optional["Address"],
-        discounts: Iterable["DiscountInfo"],
         previous_value: TaxedMoney,
     ) -> TaxedMoney:
+
         if self._skip_plugin(checkout_info, previous_value):
             return previous_value
 
         checkout = checkout_info.checkout
 
         self._validate_vatin_metadata(checkout, address)
 
-        if self._skip_price_modification(checkout_info, previous_value):
-            return previous_value
-
-        valid_vatin = checkout.get_value_from_metadata(self.META_VATIN_VALIDATED_KEY)
+        valid_vatin = checkout.metadata_storage.get_value_from_metadata(
+            self.META_VATIN_VALIDATED_KEY
+        )
         buyer_country_code = self._get_buyer_country_code(address)
-        seller_country_code = self._get_seller_country_code()
+        seller_country_code = self._get_seller_country_code(checkout)
         # If a valid VATIN is provided and the sale isn't within the same country,
         # reverse-charged applies.
         if valid_vatin and seller_country_code != buyer_country_code:
             # VAT is reverse-charged, so it must be excluded from total.
             return self._deduct_tax(previous_value)
 
-        return previous_value
-
-    def calculate_checkout_line_total(
-        self,
-        checkout_info: "CheckoutInfo",
-        lines: List["CheckoutLineInfo"],
-        checkout_line_info: "CheckoutLineInfo",
-        address: Optional["Address"],
-        discounts: Iterable["DiscountInfo"],
-        previous_value: CheckoutTaxedPricesData,
-    ) -> CheckoutTaxedPricesData:
-        if self._skip_plugin(checkout_info, previous_value):
-            return previous_value
-
-        checkout = checkout_info.checkout
-
-        self._validate_vatin_metadata(checkout, address)
-
-        if self._skip_price_modification(checkout_info, previous_value):
-            return previous_value
-
-        valid_vatin = checkout.get_value_from_metadata(self.META_VATIN_VALIDATED_KEY)
-        buyer_country_code = self._get_buyer_country_code(address)
-        seller_country_code = self._get_seller_country_code()
-        # If a valid VATIN is provided and the sale isn't within the same country,
-        # reverse-charged applies.
-        if valid_vatin and seller_country_code != buyer_country_code:
-            # VAT is reverse-charged, so it must be excluded from line total.
-            return CheckoutTaxedPricesData(
-                price_with_discounts=self._deduct_tax(
-                    previous_value.price_with_discounts
-                ),
-                price_with_sale=self._deduct_tax(previous_value.price_with_sale),
-                undiscounted_price=self._deduct_tax(previous_value.undiscounted_price),
-            )
-        return previous_value
+        update_checkout_prices_with_flat_rates(
+            checkout,
+            checkout_info,
+            lines,
+            True,
+            address,
+        )
+        return checkout.total

saleor_vatrc/templatetags/saleor_vatrc.py

@@ -12,19 +12,14 @@ def _get_vat_plugin():
     vat_plugin_id = saleor_vatrc.plugin.VatReverseCharge.VAT_PLUGIN_ID
     manager = get_plugins_manager()
     plugins = manager.all_plugins
-    vat_plugin = next(
-        (
-            p for p in plugins
-            if p.PLUGIN_ID == vat_plugin_id),
-        None
-    )
+    vat_plugin = next((p for p in plugins if p.PLUGIN_ID == vat_plugin_id), None)
     return vat_plugin
 
 
 @register.simple_tag(takes_context=True)
 def get_value_from_metadata(context, obj, key: str) -> bool:
     """Retrieve a value from object's metadata."""
-    return obj.get_value_from_metadata(key)
+    return obj.metadata_storage.get_value_from_metadata(key)
 
 
 @register.simple_tag(takes_context=True)

setup.py

@@ -2,7 +2,7 @@
 
 setup(
     name="saleor_vatrc",
-    version="0.3",
+    version="0.4",
     description="Implements VAT reverse charge in Saleor",
     author="Anna Sirota",
     author_email="[email protected]",
@@ -13,7 +13,7 @@
     packages=["saleor_vatrc"],
     entry_points={
         "saleor.plugins": [
-            "saleor_vatrc = saleor_vatrc.plugin:VatReverseCharge"
-        ]
-    }
+            "saleor_vatrc = saleor_vatrc.plugin:VatReverseCharge",
+        ],
+    },
 )