database_schema

database_schema.py

from django.contrib.auth.models import AbstractUser
from django.db import models
from django.db.models.fields.related import ForeignKey
from django.utils.translation import ugettext


class ArchitectureSupport(models.Model):
    THIRTY_TWO_BIT_VALUE = 32
    SIXTY_FOUR_BIT_VALUE = 64

    has_thirty_two_bit_support = models.BooleanField(default=False)
    has_sixty_four_bit_support = models.BooleanField(default=False)

    def __str__(self):
        architectures = [str(architecture) for architecture in self.get_architectures()]

        if architectures:
            architectures_string = " / ".join(architectures)
            bit_text_translated = ugettext("bit")
            return f"{architectures_string} {bit_text_translated}"

        return ""

    def get_architectures(self):
        architectures = []

        if self.has_thirty_two_bit_support:
            architectures.append(ArchitectureSupport.THIRTY_TWO_BIT_VALUE)

        if self.has_sixty_four_bit_support:
            architectures.append(ArchitectureSupport.SIXTY_FOUR_BIT_VALUE)

        return architectures


class OperatingSystemSupport(models.Model):
    macintosh_architecture_support = models.ForeignKey(to=ArchitectureSupport, related_name="macintosh_operating_system_support_objects", on_delete=models.PROTECT)
    windows_architecture_support = models.ForeignKey(to=ArchitectureSupport, related_name="windows_operating_system_support_objects", on_delete=models.PROTECT)
    linux_architecture_support = models.ForeignKey(to=ArchitectureSupport, related_name="linux_operating_system_support_objects", on_delete=models.PROTECT)

    def __str__(self):
        # TODO: ?
        macintosh_architecture_support_string = str(self.macintosh_architecture_support)
        windows_architecture_support_string = str(self.windows_architecture_support)
        linux_architecture_support_string = str(self.linux_architecture_support)

    @property
    def has_macintosh_support(self):
        return OperatingSystemSupport.__has_architecture_support(self.macintosh_architecture_support)

    @property
    def has_windows_support(self):
        return OperatingSystemSupport.__has_architecture_support(self.windows_architecture_support)

    @property
    def has_linux_support(self):
        return OperatingSystemSupport.__has_architecture_support(self.linux_architecture_support)

    @staticmethod
    def __has_architecture_support(architecture_field):
        return len(architecture_field.get_architectures()) > 0


class SoftwareProduct(models.Model):
    class ApplicationType(models.TextChoices):
        AudioPluginApplication = "Audio Plug-in Application", ugettext("Audio Plug-in Application")
        DesktopApplication = "Desktop Application", ugettext("Desktop Application")

    name = models.TextField(unique=True)
    description = models.TextField()
    price = models.DecimalField(max_digits=6, decimal_places=2)
    application_type = models.TextField(choices=ApplicationType.choices)


class SoftwareVersion(models.Model):
    version_string = models.TextField()
    changes = models.TextField()
    minimum_software_requirements = models.TextField()
    minimum_hardware_requirements = models.TextField()

    user_can_download = models.BooleanField(default=False)
    requires_license = models.BooleanField(default=False)

    release_date = models.DateField
    download_url = models.URLField()

    software_product = models.ForeignKey(to=SoftwareProduct, on_delete=models.PROTECT)


class ProductImage(models.Model):
    image = models.ImageField()

    software_product = models.ForeignKey(to=SoftwareProduct, on_delete=models.PROTECT)


class AudioPluginFormatSupport(models.Model):
    has_aax_support = models.BooleanField(default=False)
    has_vst3_support = models.BooleanField(default=False)
    has_au_support = models.BooleanField(default=False)

    software_product = models.ForeignKey(to=SoftwareProduct, on_delete=models.PROTECT)


class User(AbstractUser):
    class Meta(AbstractUser.Meta):
        swappable = "AUTH_USER_MODEL"


class Transaction(models.Model):
    purchase_datetime = models.DateTimeField()
    license_uuid = models.UUIDField(null=True, default=None)

    user = ForeignKey(to=User, on_delete=models.PROTECT)
    software_product = ForeignKey(to=SoftwareProduct, on_delete=models.PROTECT)