118 lines
3.8 KiB
Python
118 lines
3.8 KiB
Python
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
|
|
from orchestra.utils import tuple_setting_to_choices
|
|
from orchestra.utils.functional import cached
|
|
|
|
from . import settings
|
|
|
|
|
|
class Website(models.Model):
|
|
""" Models a web site, also known as virtual host """
|
|
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')
|
|
is_active = models.BooleanField(_("active"), default=True)
|
|
|
|
def __unicode__(self):
|
|
return self.name
|
|
|
|
@property
|
|
def unique_name(self):
|
|
return "%s-%i" % (self.name, self.pk)
|
|
|
|
@cached
|
|
def get_options(self):
|
|
return {
|
|
opt.name: opt.value for opt in self.options.all()
|
|
}
|
|
|
|
@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)
|
|
|
|
def get_absolute_url(self):
|
|
domain = self.domains.first()
|
|
if domain:
|
|
return '%s://%s' % (self.protocol, domain)
|
|
|
|
def get_www_log_path(self):
|
|
context = {
|
|
'user_home': self.account.main_systemuser.get_home(),
|
|
'username': self.account.username,
|
|
'name': self.name,
|
|
'unique_name': self.unique_name
|
|
}
|
|
return settings.WEBSITES_WEBSITE_WWW_LOG_PATH % context
|
|
|
|
|
|
class WebsiteOption(models.Model):
|
|
website = models.ForeignKey(Website, verbose_name=_("web site"),
|
|
related_name='options')
|
|
name = models.CharField(_("name"), max_length=128,
|
|
choices=tuple_setting_to_choices(settings.WEBSITES_OPTIONS))
|
|
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][-1]
|
|
if not re.match(regex, self.value):
|
|
raise ValidationError({
|
|
'value': ValidationError(_("'%(value)s' does not match %(regex)s."),
|
|
params={
|
|
'value': self.value,
|
|
'regex': 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])
|
|
|
|
class Meta:
|
|
unique_together = ('website', 'path')
|
|
|
|
def __unicode__(self):
|
|
try:
|
|
return self.website.name + self.path
|
|
except Website.DoesNotExist:
|
|
return self.path
|
|
|
|
def clean(self):
|
|
if not self.path.startswith('/'):
|
|
self.path = '/' + self.path
|
|
|
|
def get_absolute_url(self):
|
|
domain = self.website.domains.first()
|
|
if domain:
|
|
return '%s://%s%s' % (self.website.protocol, domain, self.path)
|
|
|
|
|
|
services.register(Website)
|