django-orchestra/orchestra/apps/websites/models.py

115 lines
3.6 KiB
Python
Raw Normal View History

2014-05-08 16:59:35 +00:00
import re
from django.core.exceptions import ValidationError
from django.db import models
from django.utils.translation import ugettext_lazy as _
from orchestra.core import validators, services
2014-10-24 10:16:46 +00:00
from orchestra.utils import tuple_setting_to_choices
2014-05-08 16:59:35 +00:00
from orchestra.utils.functional import cached
from . import settings
class Website(models.Model):
name = models.CharField(_("name"), max_length=128, unique=True,
validators=[validators.validate_name])
account = models.ForeignKey('accounts.Account', verbose_name=_("Account"),
related_name='websites')
port = models.PositiveIntegerField(_("port"),
choices=settings.WEBSITES_PORT_CHOICES,
default=settings.WEBSITES_DEFAULT_PORT)
domains = models.ManyToManyField(settings.WEBSITES_DOMAIN_MODEL,
related_name='websites', verbose_name=_("domains"))
contents = models.ManyToManyField('webapps.WebApp', through='websites.Content')
2014-09-30 10:20:11 +00:00
is_active = models.BooleanField(_("active"), default=True)
2014-05-08 16:59:35 +00:00
def __unicode__(self):
return self.name
@property
def unique_name(self):
return "%s-%s" % (self.account, self.name)
@cached
def get_options(self):
return {
opt.name: opt.value for opt in self.options.all()
}
2014-05-08 16:59:35 +00:00
@property
def protocol(self):
if self.port == 80:
return 'http'
if self.port == 443:
return 'https'
raise TypeError('No protocol for port "%s"' % self.port)
2014-10-23 15:38:46 +00:00
def get_absolute_url(self):
domain = self.domains.first()
if domain:
return '%s://%s' % (self.protocol, domain)
def get_username(self):
return self.account.username
def get_groupname(self):
return self.get_username()
2014-10-27 14:31:04 +00:00
def get_www_log_path(self):
context = {
'unique_name': self.unique_name
}
return settings.WEBSITES_WEBSITE_WWW_LOG_PATH % context
2014-05-08 16:59:35 +00:00
class WebsiteOption(models.Model):
website = models.ForeignKey(Website, verbose_name=_("web site"),
related_name='options')
name = models.CharField(_("name"), max_length=128,
2014-10-24 10:16:46 +00:00
choices=tuple_setting_to_choices(settings.WEBSITES_OPTIONS))
2014-05-08 16:59:35 +00:00
value = models.CharField(_("value"), max_length=256)
class Meta:
unique_together = ('website', 'name')
verbose_name = _("option")
verbose_name_plural = _("options")
def __unicode__(self):
return self.name
def clean(self):
""" validates name and value according to WEBSITES_WEBSITEOPTIONS """
__, regex = settings.WEBSITES_OPTIONS[self.name]
if not re.match(regex, self.value):
msg = _("'%s' does not match %s")
raise ValidationError(msg % (self.value, regex))
class Content(models.Model):
webapp = models.ForeignKey('webapps.WebApp', verbose_name=_("web application"))
website = models.ForeignKey('websites.Website', verbose_name=_("web site"))
path = models.CharField(_("path"), max_length=256, blank=True,
validators=[validators.validate_url_path])
2014-05-08 16:59:35 +00:00
class Meta:
unique_together = ('website', 'path')
def __unicode__(self):
try:
return self.website.name + self.path
except Website.DoesNotExist:
return self.path
2014-05-08 16:59:35 +00:00
def clean(self):
if not self.path.startswith('/'):
self.path = '/' + self.path
2014-10-23 15:38:46 +00:00
def get_absolute_url(self):
domain = self.website.domains.first()
if domain:
return '%s://%s%s' % (self.website.protocol, domain, self.path)
2014-05-08 16:59:35 +00:00
services.register(Website)