def ready(self):
from .management import create_initial_superuser
from .models import Account
services.register(Account, menu=False, dashboard=False)
accounts.register(Account, icon='Face-monkey.png')
post_migrate.connect(create_initial_superuser,
dispatch_uid="orchestra.contrib.accounts.management.createsuperuser")
def ready(self):
from .models import SystemUser
services.register(SystemUser, icon='roleplaying.png')
if 'migrate' in sys.argv and 'accounts' not in sys.argv:
post_migrate.connect(
self.create_initial_systemuser,
dispatch_uid=
"orchestra.contrib.systemusers.apps.create_initial_systemuser")
def ready(self):
from .management import create_initial_superuser
from .models import Account
services.register(Account, menu=False, dashboard=False)
accounts.register(Account, icon='Face-monkey.png')
post_migrate.connect(
create_initial_superuser,
dispatch_uid="orchestra.contrib.accounts.management.createsuperuser"
)
def ready(self):
if database_ready():
# from django.contrib.contenttypes.models import ContentType
# from .models import Content, Website
# qset = Content.content_type.field.get_limit_choices_to()
# for ct in ContentType.objects.filter(qset):
# relation = GenericRelation('websites.Content')
# ct.model_class().add_to_class('content_set', relation)
from .models import Website
services.register(Website, icon='Applications-internet.png')
def ready(self):
from .models import MiscService, Miscellaneous
services.register(Miscellaneous, icon='applications-other.png')
administration.register(MiscService, icon='Misc-Misc-Box-icon.png')
ModelTranslation.register(MiscService, ('verbose_name',))
def ready(self):
from .models import Mailbox, Address
services.register(Mailbox, icon="email.png")
services.register(Address, icon="X-office-address-book.png")
from . import signals
return self.name
@cached_property
def option_class(self):
return AppOption.get(self.name)
@cached_property
def option_instance(self):
""" Per request lived option instance """
return self.option_class(self)
def clean(self):
self.option_instance.validate()
services.register(WebApp)
# Admin bulk deletion doesn't call model.delete()
# So, signals are used instead of model method overriding
@receiver(pre_save, sender=WebApp, dispatch_uid='webapps.type.save')
def type_save(sender, *args, **kwargs):
instance = kwargs['instance']
instance.type_instance.save()
@receiver(pre_delete, sender=WebApp, dispatch_uid='webapps.type.delete')
def type_delete(sender, *args, **kwargs):
instance = kwargs['instance']
try:
instance.type_instance.delete()
validators=[validators.validate_forward])
account = models.ForeignKey('accounts.Account', verbose_name=_("Account"),
related_name='addresses')
class Meta:
verbose_name_plural = _("addresses")
unique_together = ('name', 'domain')
def __unicode__(self):
return self.email
@property
def email(self):
return "%s@%s" % (self.name, self.domain)
class Autoresponse(models.Model):
address = models.OneToOneField(Address, verbose_name=_("address"),
related_name='autoresponse')
# TODO initial_date
subject = models.CharField(_("subject"), max_length=256)
message = models.TextField(_("message"))
enabled = models.BooleanField(_("enabled"), default=False)
def __unicode__(self):
return self.address
services.register(Mailbox)
services.register(Address)
"""
# Active superusers have all permissions.
if self.is_active and self.is_superuser:
return True
# Otherwise we need to check the backends.
return auth._user_has_perm(self, perm, obj)
def has_perms(self, perm_list, obj=None):
"""
Returns True if the user has each of the specified permissions. If
object is passed, it checks if the user has all required perms for this
object.
"""
for perm in perm_list:
if not self.has_perm(perm, obj):
return False
return True
def has_module_perms(self, app_label):
"""
Returns True if the user has any permissions in the given app label.
Uses pretty much the same logic as has_perm, above.
"""
# Active superusers have all permissions.
if self.is_active and self.is_superuser:
return True
return auth._user_has_module_perms(self, app_label)
services.register(User, menu=False)
"""
Returns True if the user has any permissions in the given app label.
Uses pretty much the same logic as has_perm, above.
"""
# Active superusers have all permissions.
if self.is_active and self.is_superuser:
return True
return auth._user_has_module_perms(self, app_label)
def get_related_passwords(self):
related = [
self.main_systemuser,
]
for model, key, related_kwargs, __ in settings.ACCOUNTS_CREATE_RELATED:
if 'password' not in related_kwargs:
continue
model = apps.get_model(model)
kwargs = {
key: eval(related_kwargs[key], {'account': self})
}
try:
rel = model.objects.get(account=self, **kwargs)
except model.DoesNotExist:
continue
related.append(rel)
return related
services.register(Account, menu=False)
accounts.register(Account)
def ready(self):
from .models import Domain
services.register(Domain, icon='domain.png')
has_amount = models.BooleanField(default=False,
help_text=_("Designates whether this service has <tt>amount</tt> "
"property or not."))
is_active = models.BooleanField(default=True,
help_text=_("Whether new instances of this service can be created "
"or not. Unselect this instead of deleting services."))
def __unicode__(self):
return self.name
class Miscellaneous(models.Model):
service = models.ForeignKey(MiscService, verbose_name=_("service"),
related_name='instances')
account = models.ForeignKey('accounts.Account', verbose_name=_("account"),
related_name='miscellaneous')
description = models.TextField(_("description"), blank=True)
amount = models.PositiveIntegerField(_("amount"), default=1)
is_active = models.BooleanField(default=True,
help_text=_("Designates whether this service should be treated as "
"active. Unselect this instead of deleting services."))
class Meta:
verbose_name_plural = _("miscellaneous")
def __unicode__(self):
return "{0}-{1}".format(str(self.service), str(self.account))
services.register(Miscellaneous)
def ready(self):
from . import signals
from .models import SaaS
services.register(SaaS, icon='saas.png')
self.directive_instance.validate(self)
class Content(models.Model):
# related_name is content_set to differentiate between website.content -> webapp
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 __str__(self):
try:
return self.website.name + self.path
except Website.DoesNotExist:
return self.path
def clean(self):
if not self.path:
self.path = '/'
def get_absolute_url(self):
domain = self.website.domains.first()
if domain:
return '%s://%s%s' % (self.website.get_protocol(), domain, self.path)
services.register(Website)
type = models.CharField(_("type"), max_length=32, choices=TYPE_CHOICES)
value = models.CharField(_("value"), max_length=256)
def __str__(self):
return "%s %s IN %s %s" % (self.domain, self.get_ttl(), self.type, self.value)
def clean(self):
""" validates record value based on its type """
# validate value
self.value = self.value.lower().strip()
choices = {
self.MX: validators.validate_mx_record,
self.NS: validators.validate_zone_label,
self.A: validate_ipv4_address,
self.AAAA: validate_ipv6_address,
self.CNAME: validators.validate_zone_label,
self.TXT: validate_ascii,
self.SRV: validators.validate_srv_record,
self.SOA: validators.validate_soa_record,
}
try:
choices[self.type](self.value)
except ValidationError as error:
raise ValidationError({'value': error})
def get_ttl(self):
return self.ttl or settings.DOMAINS_DEFAULT_TTL
services.register(Domain)
def ready(self):
from .models import Plan, ContractedPlan
accounts.register(ContractedPlan, icon='ContractedPack.png')
services.register(ContractedPlan, menu=False, dashboard=False)
administration.register(Plan, icon='Pack.png')
ModelTranslation.register(Plan, ('verbose_name',))
def ready(self):
from .models import WebApp
services.register(WebApp, icon='Applications-other.png')
from . import signals
from . import settings
class VPS(models.Model):
hostname = models.CharField(_("hostname"), max_length=256, unique=True,
validators=[validate_hostname])
type = models.CharField(_("type"), max_length=64, choices=settings.VPS_TYPES,
default=settings.VPS_DEFAULT_TYPE)
template = models.CharField(_("template"), max_length=64,
choices=settings.VPS_TEMPLATES, default=settings.VPS_DEFAULT_TEMPLATE)
password = models.CharField(_('password'), max_length=128,
help_text=_("<TT>root</TT> password of this virtual machine"))
account = models.ForeignKey('accounts.Account', verbose_name=_("Account"),
related_name='vpss')
class Meta:
verbose_name = "VPS"
verbose_name_plural = "VPSs"
def __str__(self):
return self.hostname
def set_password(self, raw_password):
self.password = make_password(raw_password)
def get_username(self):
return self.hostname
services.register(VPS)
def ready(self):
from .models import Database, DatabaseUser
services.register(Database, icon='database.png')
services.register(DatabaseUser, icon='postgresql.png', verbose_name_plural=_("Database users"))
def ready(self):
from .models import WebApp
services.register(WebApp, icon='Applications-other.png')
from . import signals
from . import settings
class List(models.Model):
name = models.CharField(_("name"), max_length=128, unique=True,
validators=[validate_name])
address_name = models.CharField(_("address name"), max_length=128,
validators=[validate_name], blank=True)
address_domain = models.ForeignKey(settings.LISTS_DOMAIN_MODEL,
verbose_name=_("address domain"), blank=True, null=True)
admin_email = models.EmailField(_("admin email"),
help_text=_("Administration email address"))
account = models.ForeignKey('accounts.Account', verbose_name=_("Account"),
related_name='lists')
class Meta:
unique_together = ('address_name', 'address_domain')
def __unicode__(self):
return "%s@%s" % (self.address_name, self.address_domain)
def get_username(self):
return self.name
def set_password(self, password):
self.password = password
services.register(List)
def ready(self):
from .models import List
services.register(List, icon='email-alter.png')
from . import signals
def ready(self):
from .models import SystemUser
services.register(SystemUser, icon='roleplaying.png')
if 'migrate' in sys.argv and 'accounts' not in sys.argv:
post_migrate.connect(self.create_initial_systemuser,
dispatch_uid="orchestra.contrib.systemusers.apps.create_initial_systemuser")
if self.has_shell:
directory_error = _("Directory with shell users can not be specified.")
elif self.account_id and self.is_main:
directory_error = _("Directory with main system users can not be specified.")
elif self.home == self.get_base_home():
directory_error = _("Directory on the user's base home is not allowed.")
if directory_error:
raise ValidationError({
'directory': directory_error,
})
if self.has_shell and self.home and self.home != self.get_base_home():
raise ValidationError({
'home': _("Shell users should use their own home."),
})
def set_password(self, raw_password):
self.password = make_password(raw_password)
def get_base_home(self):
context = {
'user': self.username,
'username': self.username,
}
return os.path.normpath(settings.SYSTEMUSERS_HOME % context)
def get_home(self):
return os.path.normpath(os.path.join(self.home, self.directory))
services.register(SystemUser)
def ready(self):
from .models import VPS
services.register(VPS, icon='TuxBox.png')
validators=[validators.validate_forward])
account = models.ForeignKey('accounts.Account', verbose_name=_("Account"),
related_name='addresses')
class Meta:
verbose_name_plural = _("addresses")
unique_together = ('name', 'domain')
def __unicode__(self):
return self.email
@property
def email(self):
return "%s@%s" % (self.name, self.domain)
class Autoresponse(models.Model):
address = models.OneToOneField(Address, verbose_name=_("address"),
related_name='autoresponse')
# TODO initial_date
subject = models.CharField(_("subject"), max_length=256)
message = models.TextField(_("message"))
enabled = models.BooleanField(_("enabled"), default=False)
def __unicode__(self):
return self.address
services.register(Address)
roles.register('mailbox', Mailbox)
def ready(self):
from .models import Database, DatabaseUser
services.register(Database, icon='database.png')
services.register(DatabaseUser,
icon='postgresql.png',
verbose_name_plural=_("Database users"))
service = models.ForeignKey('services.Service', verbose_name=_("service"),
related_name='rates')
plan = models.ForeignKey(Plan, verbose_name=_("plan"), related_name='rates')
quantity = models.PositiveIntegerField(_("quantity"), null=True, blank=True)
price = models.DecimalField(_("price"), max_digits=12, decimal_places=2)
objects = RateQuerySet.as_manager()
class Meta:
unique_together = ('service', 'plan', 'quantity')
def __str__(self):
return "{}-{}".format(str(self.price), self.quantity)
@classmethod
def get_methods(cls):
return cls.RATE_METHODS
@classmethod
def get_choices(cls):
choices = []
for name, method in cls.RATE_METHODS.items():
choices.append((name, method.verbose_name))
return choices
accounts.register(ContractedPlan)
services.register(ContractedPlan, menu=False)
ModelTranslation.register(Plan, ('verbose_name',))
def ready(self):
from .models import Mailbox, Address
services.register(Mailbox, icon='email.png')
services.register(Address, icon='X-office-address-book.png')
def ready(self):
from .models import Plan, ContractedPlan
accounts.register(ContractedPlan, icon='ContractedPack.png')
services.register(ContractedPlan, menu=False, dashboard=False)
administration.register(Plan, icon='Pack.png')
ModelTranslation.register(Plan, ('verbose_name', ))
def ready(self):
from .models import List
services.register(List, icon='email-alter.png')
def ready(self):
from .models import Mailbox, Address
services.register(Mailbox, icon='email.png')
services.register(Address, icon='X-office-address-book.png')
from . import signals
password = models.CharField(_("password"), max_length=128)
type = models.CharField(_("type"), max_length=32,
choices=settings.DATABASES_TYPE_CHOICES,
default=settings.DATABASES_DEFAULT_TYPE)
account = models.ForeignKey('accounts.Account', verbose_name=_("Account"),
related_name='databaseusers')
class Meta:
verbose_name_plural = _("DB users")
unique_together = ('username', 'type')
def __unicode__(self):
return self.username
def get_username(self):
return self.username
def set_password(self, password):
if self.type == self.MYSQL:
# MySQL stores sha1(sha1(password).binary).hex
binary = hashlib.sha1(password).digest()
hexdigest = hashlib.sha1(binary).hexdigest()
password = '******' % hexdigest.upper()
self.password = password
else:
raise TypeError("Database type '%s' not supported" % self.type)
services.register(Database)
services.register(DatabaseUser, verbose_name_plural=_("Database users"))
def ready(self):
from .models import Domain
services.register(Domain, icon='domain.png')
return 0
@receiver(pre_delete, dispatch_uid="orders.cancel_orders")
def cancel_orders(sender, **kwargs):
if sender in services:
instance = kwargs['instance']
for order in Order.objects.by_object(instance).active():
order.cancel()
@receiver(post_save, dispatch_uid="orders.update_orders")
@receiver(post_delete, dispatch_uid="orders.update_orders_post_delete")
def update_orders(sender, **kwargs):
exclude = (
MetricStorage, LogEntry, Order, Service, ContentType, MigrationRecorder.Migration
)
if sender not in exclude:
instance = kwargs['instance']
if instance.pk:
# post_save
Order.update_orders(instance)
related = helpers.get_related_objects(instance)
if related:
Order.update_orders(related)
accounts.register(Order)
accounts.register(Plan)
services.register(Plan, menu=False)