646 lines
21 KiB
Python
646 lines
21 KiB
Python
from django.db import models
|
|
from django.db.models import Q
|
|
|
|
from .base import Currency, Term, Unit
|
|
from .providers import CloudProvider
|
|
from .services import Service
|
|
|
|
|
|
class ComputePlanGroup(models.Model):
|
|
name = models.CharField(max_length=200)
|
|
description = models.TextField(blank=True)
|
|
node_label = models.CharField(
|
|
max_length=100, help_text="Kubernetes node label for this group"
|
|
)
|
|
order = models.IntegerField(default=0)
|
|
|
|
class Meta:
|
|
ordering = ["order", "name"]
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class ComputePlanPrice(models.Model):
|
|
compute_plan = models.ForeignKey(
|
|
"ComputePlan", on_delete=models.CASCADE, related_name="prices"
|
|
)
|
|
currency = models.CharField(
|
|
max_length=3,
|
|
choices=Currency.choices,
|
|
)
|
|
amount = models.DecimalField(
|
|
max_digits=10,
|
|
decimal_places=2,
|
|
help_text="Price in the specified currency, excl. VAT",
|
|
)
|
|
|
|
class Meta:
|
|
unique_together = ("compute_plan", "currency")
|
|
ordering = ["currency"]
|
|
|
|
def __str__(self):
|
|
return f"{self.compute_plan.name} - {self.amount} {self.currency}"
|
|
|
|
|
|
class ComputePlan(models.Model):
|
|
name = models.CharField(max_length=200)
|
|
vcpus = models.FloatField(help_text="Number of available vCPUs")
|
|
ram = models.FloatField(help_text="Amount of RAM available")
|
|
cpu_mem_ratio = models.FloatField(
|
|
help_text="vCPU to Memory ratio. How much vCPU per GiB RAM is available?"
|
|
)
|
|
active = models.BooleanField(default=True, help_text="Is the plan active?")
|
|
term = models.CharField(
|
|
max_length=3,
|
|
default=Term.MTH,
|
|
choices=Term.choices,
|
|
)
|
|
|
|
cloud_provider = models.ForeignKey(
|
|
CloudProvider, on_delete=models.CASCADE, related_name="compute_plans"
|
|
)
|
|
|
|
group = models.ForeignKey(
|
|
ComputePlanGroup,
|
|
on_delete=models.SET_NULL,
|
|
null=True,
|
|
blank=True,
|
|
related_name="compute_plans",
|
|
help_text="Group this compute plan belongs to",
|
|
)
|
|
|
|
valid_from = models.DateTimeField(blank=True, null=True)
|
|
valid_to = models.DateTimeField(blank=True, null=True)
|
|
|
|
class Meta:
|
|
ordering = ["name"]
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
def get_price(self, currency_code: str):
|
|
try:
|
|
return self.prices.get(currency=currency_code).amount
|
|
except ComputePlanPrice.DoesNotExist:
|
|
return None
|
|
|
|
|
|
class StoragePlanPrice(models.Model):
|
|
storage_plan = models.ForeignKey(
|
|
"StoragePlan", on_delete=models.CASCADE, related_name="prices"
|
|
)
|
|
currency = models.CharField(
|
|
max_length=3,
|
|
choices=Currency.choices,
|
|
)
|
|
amount = models.DecimalField(
|
|
max_digits=10,
|
|
decimal_places=2,
|
|
help_text="Price in the specified currency, excl. VAT",
|
|
)
|
|
|
|
class Meta:
|
|
unique_together = ("storage_plan", "currency")
|
|
ordering = ["currency"]
|
|
|
|
def __str__(self):
|
|
return f"{self.storage_plan.name} - {self.amount} {self.currency}"
|
|
|
|
|
|
class StoragePlan(models.Model):
|
|
name = models.CharField(max_length=200)
|
|
cloud_provider = models.ForeignKey(
|
|
CloudProvider, on_delete=models.CASCADE, related_name="storage_plans"
|
|
)
|
|
term = models.CharField(
|
|
max_length=3,
|
|
default=Term.MTH,
|
|
choices=Term.choices,
|
|
)
|
|
unit = models.CharField(
|
|
max_length=3,
|
|
default=Unit.GIB,
|
|
choices=Unit.choices,
|
|
)
|
|
|
|
valid_from = models.DateTimeField(blank=True, null=True)
|
|
valid_to = models.DateTimeField(blank=True, null=True)
|
|
|
|
class Meta:
|
|
unique_together = ("cloud_provider", "term", "unit", "valid_from", "valid_to")
|
|
ordering = ["name"]
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
def get_price(self, currency_code: str):
|
|
try:
|
|
return self.prices.get(currency=currency_code).amount
|
|
except StoragePlanPrice.DoesNotExist:
|
|
return None
|
|
|
|
|
|
class ProgressiveDiscountModel(models.Model):
|
|
name = models.CharField(max_length=100)
|
|
description = models.TextField(blank=True)
|
|
active = models.BooleanField(default=True)
|
|
|
|
class Meta:
|
|
verbose_name = "Discount Model"
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
def calculate_discount(self, base_rate, units):
|
|
"""Calculate price using progressive percentage discounts."""
|
|
final_price = 0
|
|
remaining_units = units
|
|
|
|
discount_tiers = self.tiers.all().order_by("min_units")
|
|
|
|
for tier in discount_tiers:
|
|
if remaining_units <= 0:
|
|
break
|
|
|
|
# Determine how many units fall into this tier
|
|
tier_min = tier.min_units
|
|
tier_max = tier.max_units if tier.max_units else float("inf")
|
|
|
|
# Skip if we haven't reached this tier yet
|
|
if units < tier_min:
|
|
continue
|
|
|
|
# Calculate units in this tier
|
|
units_start = max(0, units - remaining_units)
|
|
units_end = min(units, tier_max if tier.max_units else units)
|
|
tier_units = max(0, units_end - max(units_start, tier_min - 1))
|
|
|
|
if tier_units > 0:
|
|
discounted_rate = base_rate * (1 - tier.discount_percent / 100)
|
|
final_price += discounted_rate * tier_units
|
|
remaining_units -= tier_units
|
|
|
|
return final_price
|
|
|
|
def get_discount_breakdown(self, base_rate, units):
|
|
"""Get detailed breakdown of discount calculation."""
|
|
breakdown = []
|
|
remaining_units = units
|
|
|
|
discount_tiers = self.tiers.all().order_by("min_units")
|
|
|
|
for tier in discount_tiers:
|
|
if remaining_units <= 0:
|
|
break
|
|
|
|
tier_min = tier.min_units
|
|
tier_max = tier.max_units if tier.max_units else float("inf")
|
|
|
|
if units < tier_min:
|
|
continue
|
|
|
|
units_start = max(0, units - remaining_units)
|
|
units_end = min(units, tier_max if tier.max_units else units)
|
|
tier_units = max(0, units_end - max(units_start, tier_min - 1))
|
|
|
|
if tier_units > 0:
|
|
discounted_rate = base_rate * (1 - tier.discount_percent / 100)
|
|
tier_total = discounted_rate * tier_units
|
|
|
|
breakdown.append(
|
|
{
|
|
"tier_range": f"{tier_min}-{tier_max-1 if tier.max_units else '∞'}",
|
|
"units": tier_units,
|
|
"discount_percent": tier.discount_percent,
|
|
"rate": discounted_rate,
|
|
"subtotal": tier_total,
|
|
}
|
|
)
|
|
|
|
remaining_units -= tier_units
|
|
|
|
return breakdown
|
|
|
|
|
|
class DiscountTier(models.Model):
|
|
discount_model = models.ForeignKey(
|
|
ProgressiveDiscountModel, on_delete=models.CASCADE, related_name="tiers"
|
|
)
|
|
min_units = models.PositiveIntegerField(
|
|
help_text="Minimum unit count for this tier (inclusive)", default=0
|
|
)
|
|
max_units = models.PositiveIntegerField(
|
|
null=True,
|
|
blank=True,
|
|
help_text="Maximum unit count for this tier (exclusive). Leave blank for unlimited.",
|
|
)
|
|
discount_percent = models.DecimalField(
|
|
max_digits=5, decimal_places=2, help_text="Percentage discount applied (0-100)"
|
|
)
|
|
|
|
class Meta:
|
|
ordering = ["min_units"]
|
|
unique_together = ["discount_model", "min_units"]
|
|
|
|
def __str__(self):
|
|
if self.max_units:
|
|
return f"{self.discount_model.name}: {self.min_units}-{self.max_units-1} units → {self.discount_percent}% discount"
|
|
else:
|
|
return f"{self.discount_model.name}: {self.min_units}+ units → {self.discount_percent}% discount"
|
|
|
|
|
|
class VSHNAppCatPrice(models.Model):
|
|
class VariableUnit(models.TextChoices):
|
|
RAM = "RAM", "Memory (RAM)"
|
|
CPU = "CPU", "CPU (vCPU)"
|
|
USER = "USR", "Users"
|
|
|
|
class ServiceLevel(models.TextChoices):
|
|
BEST_EFFORT = "BE", "Best Effort"
|
|
GUARANTEED = "GA", "Guaranteed Availability"
|
|
|
|
service = models.ForeignKey(
|
|
Service, on_delete=models.CASCADE, related_name="vshn_appcat_price"
|
|
)
|
|
variable_unit = models.CharField(
|
|
max_length=3,
|
|
choices=VariableUnit.choices,
|
|
default=VariableUnit.RAM,
|
|
)
|
|
term = models.CharField(
|
|
max_length=3,
|
|
default=Term.MTH,
|
|
choices=Term.choices,
|
|
)
|
|
discount_model = models.ForeignKey(
|
|
ProgressiveDiscountModel,
|
|
on_delete=models.SET_NULL,
|
|
null=True,
|
|
blank=True,
|
|
related_name="price_configs",
|
|
)
|
|
|
|
ha_replica_min = models.IntegerField(
|
|
default=1, help_text="Minimum of replicas for HA"
|
|
)
|
|
ha_replica_max = models.IntegerField(
|
|
default=1, help_text="Maximum supported replicas"
|
|
)
|
|
|
|
public_display_enabled = models.BooleanField(
|
|
default=True,
|
|
help_text="Enable public display of price calculator on offering detail page",
|
|
)
|
|
|
|
valid_from = models.DateTimeField(blank=True, null=True)
|
|
valid_to = models.DateTimeField(blank=True, null=True)
|
|
|
|
class Meta:
|
|
verbose_name = "AppCat Price"
|
|
|
|
def __str__(self):
|
|
return f"{self.service.name} - {self.get_variable_unit_display()} based pricing"
|
|
|
|
def get_unit_rate(self, currency_code: str, service_level: str):
|
|
try:
|
|
return self.unit_rates.get(
|
|
currency=currency_code, service_level=service_level
|
|
).amount
|
|
except VSHNAppCatUnitRate.DoesNotExist:
|
|
return None
|
|
|
|
def calculate_final_price(
|
|
self,
|
|
currency_code: str,
|
|
service_level: str,
|
|
number_of_units: int,
|
|
addon_ids=None,
|
|
):
|
|
base_fee = self.get_base_fee(currency_code, service_level)
|
|
unit_rate = self.get_unit_rate(currency_code, service_level)
|
|
|
|
if base_fee is None or unit_rate is None:
|
|
return None
|
|
|
|
if number_of_units < 0:
|
|
raise ValueError("Number of units cannot be negative")
|
|
|
|
# Apply discount model if available
|
|
if self.discount_model and self.discount_model.active:
|
|
discounted_price = self.discount_model.calculate_discount(
|
|
unit_rate, number_of_units
|
|
)
|
|
total_price = base_fee + discounted_price
|
|
else:
|
|
total_price = base_fee + (unit_rate * number_of_units)
|
|
|
|
# Add prices for mandatory addons and selected addons
|
|
addon_total = 0
|
|
addon_breakdown = []
|
|
|
|
# Query all active addons related to this price config
|
|
addons_query = self.addons.filter(active=True)
|
|
|
|
# Include mandatory addons and explicitly selected addons
|
|
if addon_ids:
|
|
addons = addons_query.filter(Q(mandatory=True) | Q(id__in=addon_ids))
|
|
else:
|
|
addons = addons_query.filter(mandatory=True)
|
|
|
|
for addon in addons:
|
|
addon_price = 0
|
|
if addon.addon_type == VSHNAppCatAddon.AddonType.BASE_FEE:
|
|
addon_price_value = addon.get_price(currency_code, service_level)
|
|
if addon_price_value:
|
|
addon_price = addon_price_value
|
|
elif addon.addon_type == VSHNAppCatAddon.AddonType.UNIT_RATE:
|
|
addon_price_value = addon.get_price(currency_code, service_level)
|
|
if addon_price_value:
|
|
addon_price = addon_price_value * number_of_units
|
|
|
|
addon_total += addon_price
|
|
addon_breakdown.append(
|
|
{
|
|
"id": addon.id,
|
|
"name": addon.name,
|
|
"description": addon.description,
|
|
"commercial_description": addon.commercial_description,
|
|
"mandatory": addon.mandatory,
|
|
"price": addon_price,
|
|
}
|
|
)
|
|
|
|
total_price += addon_total
|
|
|
|
return {
|
|
"total_price": total_price,
|
|
"addon_total": addon_total,
|
|
"addon_breakdown": addon_breakdown,
|
|
}
|
|
|
|
def get_base_fee(self, currency_code: str, service_level: str):
|
|
"""
|
|
Get the base fee for the given currency and service level.
|
|
"""
|
|
try:
|
|
return self.base_fees.get(currency=currency_code, service_level=service_level).amount
|
|
except VSHNAppCatBaseFee.DoesNotExist:
|
|
return None
|
|
|
|
|
|
class VSHNAppCatUnitRate(models.Model):
|
|
vshn_appcat_price_config = models.ForeignKey(
|
|
VSHNAppCatPrice, on_delete=models.CASCADE, related_name="unit_rates"
|
|
)
|
|
currency = models.CharField(
|
|
max_length=3,
|
|
choices=Currency.choices,
|
|
)
|
|
service_level = models.CharField(
|
|
max_length=2,
|
|
choices=VSHNAppCatPrice.ServiceLevel.choices,
|
|
)
|
|
amount = models.DecimalField(
|
|
max_digits=10,
|
|
decimal_places=4,
|
|
help_text="Price per unit in the specified currency and service level, excl. VAT",
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = "Service Unit Rate"
|
|
unique_together = ("vshn_appcat_price_config", "currency", "service_level")
|
|
ordering = ["currency", "service_level"]
|
|
|
|
def __str__(self):
|
|
return f"{self.vshn_appcat_price_config.service.name} - {self.get_service_level_display()} Unit Rate - {self.amount} {self.currency}"
|
|
|
|
|
|
class VSHNAppCatAddon(models.Model):
|
|
"""
|
|
Addon pricing model for VSHNAppCatPrice. Can be added to a service price configuration
|
|
to provide additional features or resources with their own pricing.
|
|
"""
|
|
|
|
class AddonType(models.TextChoices):
|
|
BASE_FEE = "BF", "Base Fee" # Fixed amount regardless of units
|
|
UNIT_RATE = "UR", "Unit Rate" # Price per unit
|
|
|
|
vshn_appcat_price_config = models.ForeignKey(
|
|
VSHNAppCatPrice, on_delete=models.CASCADE, related_name="addons"
|
|
)
|
|
name = models.CharField(max_length=100, help_text="Name of the addon")
|
|
description = models.TextField(
|
|
blank=True, help_text="Technical description of the addon"
|
|
)
|
|
commercial_description = models.TextField(
|
|
blank=True, help_text="Commercial description displayed in the frontend"
|
|
)
|
|
addon_type = models.CharField(
|
|
max_length=2,
|
|
choices=AddonType.choices,
|
|
help_text="Type of addon pricing (fixed fee or per-unit)",
|
|
)
|
|
mandatory = models.BooleanField(default=False, help_text="Is this addon mandatory?")
|
|
active = models.BooleanField(
|
|
default=True, help_text="Is this addon active and available for selection?"
|
|
)
|
|
order = models.IntegerField(default=0, help_text="Display order in the frontend")
|
|
valid_from = models.DateTimeField(blank=True, null=True)
|
|
valid_to = models.DateTimeField(blank=True, null=True)
|
|
|
|
class Meta:
|
|
verbose_name = "Service Addon"
|
|
ordering = ["order", "name"]
|
|
|
|
def __str__(self):
|
|
return f"{self.vshn_appcat_price_config.service.name} - {self.name}"
|
|
|
|
def get_price(self, currency_code: str, service_level: str = None):
|
|
"""
|
|
Get the price for this addon in the specified currency and service level.
|
|
For base fee addons, service_level is required and used.
|
|
For unit rate addons, service_level is required and used.
|
|
"""
|
|
try:
|
|
if self.addon_type == self.AddonType.BASE_FEE:
|
|
if not service_level:
|
|
raise ValueError("Service level is required for base fee addons")
|
|
return self.base_fees.get(currency=currency_code, service_level=service_level).amount
|
|
elif self.addon_type == self.AddonType.UNIT_RATE:
|
|
if not service_level:
|
|
raise ValueError("Service level is required for unit rate addons")
|
|
return self.unit_rates.get(
|
|
currency=currency_code, service_level=service_level
|
|
).amount
|
|
except (
|
|
VSHNAppCatAddonBaseFee.DoesNotExist,
|
|
VSHNAppCatAddonUnitRate.DoesNotExist,
|
|
):
|
|
return None
|
|
|
|
|
|
class VSHNAppCatAddonBaseFee(models.Model):
|
|
"""
|
|
Base fee for an addon (fixed amount regardless of units), specified per currency and service level.
|
|
"""
|
|
addon = models.ForeignKey(
|
|
VSHNAppCatAddon, on_delete=models.CASCADE, related_name="base_fees"
|
|
)
|
|
currency = models.CharField(
|
|
max_length=3,
|
|
choices=Currency.choices,
|
|
)
|
|
service_level = models.CharField(
|
|
max_length=2,
|
|
choices=VSHNAppCatPrice.ServiceLevel.choices,
|
|
default=VSHNAppCatPrice.ServiceLevel.BEST_EFFORT,
|
|
)
|
|
amount = models.DecimalField(
|
|
max_digits=10,
|
|
decimal_places=2,
|
|
help_text="Base fee in the specified currency and service level, excl. VAT",
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = "Addon Base Fee"
|
|
unique_together = ("addon", "currency", "service_level")
|
|
ordering = ["currency", "service_level"]
|
|
|
|
def __str__(self):
|
|
return f"{self.addon.name} Base Fee - {self.amount} {self.currency} ({self.get_service_level_display()})"
|
|
|
|
def get_service_level_display(self):
|
|
return dict(VSHNAppCatPrice.ServiceLevel.choices).get(self.service_level, self.service_level)
|
|
|
|
|
|
class VSHNAppCatAddonUnitRate(models.Model):
|
|
"""Unit rate for an addon (price per unit)"""
|
|
|
|
addon = models.ForeignKey(
|
|
VSHNAppCatAddon, on_delete=models.CASCADE, related_name="unit_rates"
|
|
)
|
|
currency = models.CharField(
|
|
max_length=3,
|
|
choices=Currency.choices,
|
|
)
|
|
service_level = models.CharField(
|
|
max_length=2,
|
|
choices=VSHNAppCatPrice.ServiceLevel.choices,
|
|
)
|
|
amount = models.DecimalField(
|
|
max_digits=10,
|
|
decimal_places=4,
|
|
help_text="Price per unit in the specified currency and service level, excl. VAT",
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = "Addon Unit Rate"
|
|
unique_together = ("addon", "currency", "service_level")
|
|
ordering = ["currency", "service_level"]
|
|
|
|
def __str__(self):
|
|
return f"{self.addon.name} - {self.get_service_level_display()} Unit Rate - {self.amount} {self.currency}"
|
|
|
|
|
|
class VSHNAppCatBaseFee(models.Model):
|
|
"""
|
|
Base fee for a service, specified per currency and service level.
|
|
"""
|
|
vshn_appcat_price_config = models.ForeignKey(
|
|
"VSHNAppCatPrice", on_delete=models.CASCADE, related_name="base_fees"
|
|
)
|
|
currency = models.CharField(
|
|
max_length=3,
|
|
choices=Currency.choices,
|
|
)
|
|
service_level = models.CharField(
|
|
max_length=2,
|
|
choices=VSHNAppCatPrice.ServiceLevel.choices,
|
|
default=VSHNAppCatPrice.ServiceLevel.BEST_EFFORT,
|
|
)
|
|
amount = models.DecimalField(
|
|
max_digits=10,
|
|
decimal_places=2,
|
|
help_text="Base fee in the specified currency and service level, excl. VAT",
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = "Service Base Fee"
|
|
unique_together = ("vshn_appcat_price_config", "currency", "service_level")
|
|
ordering = ["currency", "service_level"]
|
|
|
|
def __str__(self):
|
|
return f"{self.vshn_appcat_price_config.service.name} Base Fee - {self.amount} {self.currency} ({self.get_service_level_display()})"
|
|
|
|
def get_service_level_display(self):
|
|
return dict(VSHNAppCatPrice.ServiceLevel.choices).get(self.service_level, self.service_level)
|
|
|
|
|
|
class ExternalPricePlans(models.Model):
|
|
plan_name = models.CharField()
|
|
description = models.CharField(max_length=200, blank=True, null=True)
|
|
source = models.URLField(blank=True, null=True)
|
|
date_retrieved = models.DateField(blank=True, null=True)
|
|
|
|
## Relations
|
|
cloud_provider = models.ForeignKey(
|
|
CloudProvider, on_delete=models.CASCADE, related_name="external_price"
|
|
)
|
|
service = models.ForeignKey(
|
|
Service, on_delete=models.CASCADE, related_name="external_price"
|
|
)
|
|
compare_to = models.ManyToManyField(
|
|
ComputePlan, related_name="external_prices", blank=True
|
|
)
|
|
vshn_appcat_price = models.ForeignKey(
|
|
VSHNAppCatPrice,
|
|
on_delete=models.CASCADE,
|
|
related_name="external_comparisons",
|
|
blank=True,
|
|
null=True,
|
|
help_text="Specific VSHN AppCat price configuration to compare against",
|
|
)
|
|
service_level = models.CharField(
|
|
max_length=2,
|
|
choices=VSHNAppCatPrice.ServiceLevel.choices,
|
|
blank=True,
|
|
null=True,
|
|
help_text="Service level equivalent for comparison",
|
|
)
|
|
|
|
## Money
|
|
currency = models.CharField(
|
|
max_length=3,
|
|
default=Currency.CHF,
|
|
choices=Currency.choices,
|
|
)
|
|
term = models.CharField(
|
|
max_length=3,
|
|
default=Term.MTH,
|
|
choices=Term.choices,
|
|
)
|
|
amount = models.DecimalField(
|
|
max_digits=10,
|
|
decimal_places=4,
|
|
help_text="Price per unit in the specified currency, excl. VAT",
|
|
)
|
|
|
|
## Offering
|
|
vcpus = models.FloatField(
|
|
help_text="Number of included vCPUs", blank=True, null=True
|
|
)
|
|
ram = models.FloatField(
|
|
help_text="Amount of GiB RAM included", blank=True, null=True
|
|
)
|
|
storage = models.FloatField(
|
|
help_text="Amount of GiB included", blank=True, null=True
|
|
)
|
|
competitor_sla = models.CharField(blank=True, null=True)
|
|
replicas = models.IntegerField(blank=True, null=True)
|
|
|
|
class Meta:
|
|
verbose_name = "External Price"
|
|
|
|
def __str__(self):
|
|
return f"{self.cloud_provider.name} - {self.service.name} - {self.plan_name}"
|