332 lines
10 KiB
Python
332 lines
10 KiB
Python
"""Main app models."""
|
|
from django.conf import settings
|
|
from django.contrib.contenttypes import fields as generic
|
|
from django.contrib.postgres.fields import JSONField
|
|
from django.db import models
|
|
from django.utils.translation import gettext_lazy as _
|
|
from django.contrib.contenttypes.models import ContentType
|
|
from location.models import Country
|
|
from main import methods
|
|
from utils.models import (ProjectBaseMixin, TJSONField,
|
|
TranslatedFieldsMixin, ImageMixin)
|
|
from utils.querysets import ContentTypeQuerySetMixin
|
|
from configuration.models import TranslationSettings
|
|
|
|
#
|
|
#
|
|
# class Tag(models.Model):
|
|
# """Tag model."""
|
|
# name = models.CharField(max_length=250)
|
|
#
|
|
#
|
|
# class MediaAsset(models.Model):
|
|
# """Assets model."""
|
|
# PHOTO = 0
|
|
# VIDEO = 1
|
|
# VIDEO_URL = 2
|
|
# PDF = 3
|
|
# DOCUMENT = 4
|
|
#
|
|
# ASSET_TYPE_CHOICES = (
|
|
# (PHOTO, _('photo')),
|
|
# (VIDEO, _('video')),
|
|
# (VIDEO_URL, _('video url')),
|
|
# (PDF, _('pdf')),
|
|
# (DOCUMENT, _('document'))
|
|
# )
|
|
#
|
|
# AMAZON_S3 = 0
|
|
#
|
|
# STORAGE_TYPE_CHOICES = (
|
|
# (AMAZON_S3, _('amazon s3')),
|
|
# )
|
|
#
|
|
# PUBLIC = 0
|
|
# PRIVATE = 1
|
|
# ROLE = 2
|
|
#
|
|
# ACCESS_TYPE_CHOICES = (
|
|
# (PUBLIC, _('public')),
|
|
# (PRIVATE, _('private')),
|
|
# (ROLE, _('role')),
|
|
# )
|
|
#
|
|
# asset_type = models.PositiveSmallIntegerField(
|
|
# _('asset type'), choices=ASSET_TYPE_CHOICES, default=PHOTO
|
|
# )
|
|
# storage_type = models.PositiveSmallIntegerField(
|
|
# _('storage type'), choices=STORAGE_TYPE_CHOICES, default=AMAZON_S3
|
|
# )
|
|
# storage_unit = models.CharField(_('storage unit'), blank=True, default='')
|
|
# path = models.CharField(_('path'))
|
|
# access_type = models.PositiveSmallIntegerField(
|
|
# _('access type'), choices=ACCESS_TYPE_CHOICES, default=PUBLIC)
|
|
# asset_text = JSONField(_('asset_text'))
|
|
# size = models.IntegerField(_('size'))
|
|
# version = models.CharField(_('version'), max_length=250)
|
|
# text = JSONField(_('text'))
|
|
#
|
|
#
|
|
# class Contacts(models.Model):
|
|
# """Contacts model."""
|
|
# address = models.ForeignKey(
|
|
# 'location.Address', verbose_name=_('address'), on_delete=models.CASCADE
|
|
# )
|
|
#
|
|
#
|
|
# class Social(models.Model):
|
|
# """Social model."""
|
|
# WEBSITE = 0
|
|
# SOCIAL = 1
|
|
#
|
|
# SOCIAL_TYPE_CHOICES = (
|
|
# (WEBSITE, _('website')),
|
|
# (SOCIAL, _('social')),
|
|
# )
|
|
#
|
|
# social_type = models.PositiveSmallIntegerField(
|
|
# _('social type'), choices=SOCIAL_TYPE_CHOICES
|
|
# )
|
|
#
|
|
#
|
|
# class Note(models.Model):
|
|
# """Note model."""
|
|
#
|
|
#
|
|
# class Ad(models.Model):
|
|
# """Ad model."""
|
|
#
|
|
|
|
|
|
class SiteSettingsQuerySet(models.QuerySet):
|
|
"""Extended queryset for SiteSettings model."""
|
|
|
|
def with_country(self):
|
|
return self.filter(country__isnull=False)
|
|
|
|
|
|
class SiteSettings(ProjectBaseMixin):
|
|
|
|
subdomain = models.CharField(max_length=255, db_index=True, unique=True,
|
|
verbose_name=_('Subdomain'))
|
|
country = models.OneToOneField(Country, on_delete=models.PROTECT,
|
|
null=True, blank=True, default=None,
|
|
verbose_name=_('Country'))
|
|
default_site = models.BooleanField(default=False,
|
|
verbose_name=_('Default site'))
|
|
pinterest_page_url = models.URLField(blank=True, null=True, default=None,
|
|
verbose_name=_('Pinterest page URL'))
|
|
twitter_page_url = models.URLField(blank=True, null=True, default=None,
|
|
verbose_name=_('Twitter page URL'))
|
|
facebook_page_url = models.URLField(blank=True, null=True, default=None,
|
|
verbose_name=_('Facebook page URL'))
|
|
instagram_page_url = models.URLField(blank=True, null=True, default=None,
|
|
verbose_name=_('Instagram page URL'))
|
|
contact_email = models.EmailField(blank=True, null=True, default=None,
|
|
verbose_name=_('Contact email'))
|
|
config = JSONField(blank=True, null=True, default=None,
|
|
verbose_name=_('Config'))
|
|
ad_config = models.TextField(blank=True, null=True, default=None,
|
|
verbose_name=_('AD config'))
|
|
|
|
objects = SiteSettingsQuerySet.as_manager()
|
|
|
|
class Meta:
|
|
"""Meta class."""
|
|
|
|
verbose_name = _('Site setting')
|
|
verbose_name_plural = _('Site settings')
|
|
|
|
def __str__(self):
|
|
return f'ID: "{self.id}". Site: "{self.subdomain}"'
|
|
|
|
@property
|
|
def published_features(self):
|
|
return self.feature_set.filter(sitefeature__site_settings=self,
|
|
sitefeature__published=True)
|
|
|
|
@property
|
|
def published_sitefeatures(self):
|
|
return self.sitefeature_set.filter(published=True)
|
|
|
|
@property
|
|
def site_url(self):
|
|
return methods.site_url(schema=settings.SCHEMA_URI,
|
|
subdomain=self.subdomain,
|
|
domain=settings.SITE_DOMAIN_URI)
|
|
|
|
|
|
class Feature(ProjectBaseMixin):
|
|
"""Feature model."""
|
|
|
|
slug = models.CharField(max_length=255, unique=True)
|
|
site_settings = models.ManyToManyField(SiteSettings, through='SiteFeature')
|
|
|
|
class Meta:
|
|
"""Meta class."""
|
|
verbose_name = _('Feature')
|
|
verbose_name_plural = _('Features')
|
|
|
|
def __str__(self):
|
|
return f'{self.slug}'
|
|
|
|
|
|
class SiteFeatureQuerySet(models.QuerySet):
|
|
"""Extended queryset for SiteFeature model."""
|
|
|
|
def published(self, switcher=True):
|
|
return self.filter(published=switcher)
|
|
|
|
|
|
class SiteFeature(ProjectBaseMixin):
|
|
"""SiteFeature model."""
|
|
|
|
site_settings = models.ForeignKey(SiteSettings, on_delete=models.CASCADE)
|
|
feature = models.ForeignKey(Feature, on_delete=models.PROTECT)
|
|
published = models.BooleanField(default=False, verbose_name=_('Published'))
|
|
main = models.BooleanField(default=False, verbose_name=_('Main'))
|
|
|
|
objects = SiteFeatureQuerySet.as_manager()
|
|
|
|
class Meta:
|
|
"""Meta class."""
|
|
|
|
verbose_name = _('Site feature')
|
|
verbose_name_plural = _('Site features')
|
|
unique_together = ('site_settings', 'feature')
|
|
|
|
|
|
class Award(TranslatedFieldsMixin, models.Model):
|
|
"""Award model."""
|
|
award_type = models.ForeignKey('main.AwardType', on_delete=models.CASCADE)
|
|
title = TJSONField(
|
|
_('title'), null=True, blank=True,
|
|
default=None, help_text='{"en-GB":"some text"}')
|
|
vintage_year = models.CharField(_('vintage year'), max_length=255, default='')
|
|
|
|
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
|
|
object_id = models.PositiveIntegerField()
|
|
content_object = generic.GenericForeignKey('content_type', 'object_id')
|
|
|
|
def __str__(self):
|
|
title = 'None'
|
|
lang = TranslationSettings.get_solo().default_language
|
|
if self.title and lang in self.title:
|
|
title = self.title[lang]
|
|
return f'id:{self.id}-{title}'
|
|
|
|
|
|
class AwardType(models.Model):
|
|
"""AwardType model."""
|
|
country = models.ForeignKey(
|
|
'location.Country', verbose_name=_('country'), on_delete=models.CASCADE)
|
|
name = models.CharField(_('name'), max_length=255)
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class MetaDataCategory(models.Model):
|
|
"""MetaData category model."""
|
|
|
|
country = models.ForeignKey(
|
|
'location.Country', null=True, default=None, on_delete=models.CASCADE)
|
|
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
|
|
public = models.BooleanField()
|
|
|
|
|
|
class MetaData(TranslatedFieldsMixin, models.Model):
|
|
"""MetaData model."""
|
|
label = TJSONField(
|
|
_('label'), null=True, blank=True,
|
|
default=None, help_text='{"en-GB":"some text"}')
|
|
category = models.ForeignKey(
|
|
MetaDataCategory, verbose_name=_('category'), on_delete=models.CASCADE)
|
|
|
|
class Meta:
|
|
verbose_name = _('metadata')
|
|
verbose_name_plural = _('metadata')
|
|
|
|
def __str__(self):
|
|
label = 'None'
|
|
lang = TranslationSettings.get_solo().default_language
|
|
if self.label and lang in self.label:
|
|
label = self.label[lang]
|
|
return f'id:{self.id}-{label}'
|
|
|
|
|
|
class MetaDataContentQuerySet(ContentTypeQuerySetMixin):
|
|
"""QuerySets for MetaDataContent model."""
|
|
|
|
|
|
class MetaDataContent(models.Model):
|
|
"""MetaDataContent model."""
|
|
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
|
|
object_id = models.PositiveIntegerField()
|
|
content_object = generic.GenericForeignKey('content_type', 'object_id')
|
|
metadata = models.ForeignKey(MetaData, on_delete=models.CASCADE)
|
|
|
|
objects = MetaDataContentQuerySet.as_manager()
|
|
|
|
|
|
class Currency(models.Model):
|
|
"""Currency model."""
|
|
name = models.CharField(_('name'), max_length=50)
|
|
|
|
class Meta:
|
|
verbose_name = _('currency')
|
|
verbose_name_plural = _('currencies')
|
|
|
|
def __str__(self):
|
|
return f'{self.name}'
|
|
|
|
|
|
class CarouselQuerySet(models.QuerySet):
|
|
"""Carousel QuerySet."""
|
|
|
|
|
|
class Carousel(models.Model):
|
|
"""Carousel model."""
|
|
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
|
|
object_id = models.PositiveIntegerField()
|
|
content_object = generic.GenericForeignKey('content_type', 'object_id')
|
|
|
|
objects = CarouselQuerySet.as_manager()
|
|
|
|
class Meta:
|
|
"""Meta class."""
|
|
verbose_name = _('Carousel')
|
|
verbose_name_plural = _('Carousel')
|
|
|
|
@property
|
|
def name(self):
|
|
if hasattr(self.content_object, 'name'):
|
|
return self.content_object.name
|
|
if hasattr(self.content_object, 'title'):
|
|
return self.content_object.title_translated
|
|
|
|
@property
|
|
def awards(self):
|
|
if hasattr(self.content_object, 'awards'):
|
|
return self.content_object.awards
|
|
|
|
@property
|
|
def toque_number(self):
|
|
if hasattr(self.content_object, 'toque_number'):
|
|
return self.content_object.toque_number
|
|
|
|
@property
|
|
def public_mark(self):
|
|
if hasattr(self.content_object, 'public_mark'):
|
|
return self.content_object.public_mark
|
|
|
|
@property
|
|
def image(self):
|
|
if not hasattr(self.content_object.image, 'url'):
|
|
return self.content_object.image.image.url
|
|
return self.content_object.image.url
|
|
|
|
@property
|
|
def model_name(self):
|
|
return self.content_object.__class__.__name__
|