def _migrate_mailboxes(self, domain, options, creator):
"""Migrate mailboxes of a single domain."""
print "\tMigrating mailboxes"
old_mboxes = pf_models.Mailbox.objects \
.using(options["_from"]).filter(domain=domain.name)
for old_mb in old_mboxes:
new_user = core_models.User()
new_user.username = old_mb.username
new_user.first_name = old_mb.name.partition(' ')[0]
new_user.last_name = old_mb.name.partition(' ')[2]
new_user.email = old_mb.username
new_user.is_active = old_mb.active
new_user.date_joined = old_mb.created
set_account_password(
new_user, old_mb.password, options["passwords_scheme"])
new_user.dates = self._migrate_dates(old_mb)
new_user.save(creator=creator, using=options["_to"])
new_user.set_role("SimpleUsers")
new_mb = admin_models.Mailbox()
new_mb.user = new_user
new_mb.address = old_mb.local_part
new_mb.domain = domain
new_mb.dates = self._migrate_dates(old_mb)
new_mb.set_quota(old_mb.quota / 1024000, override_rules=True)
new_mb.save(creator=creator, using=options["_to"])
def create(self, validated_data):
"""Create account, mailbox and aliases."""
creator = self.context["request"].user
mailbox_data = validated_data.pop("mailbox", None)
role = validated_data.pop("role")
domains = validated_data.pop("domains", [])
aliases = validated_data.pop("aliases", None)
user = core_models.User(**validated_data)
password = validated_data.pop("password")
user.set_password(password)
if "language" not in validated_data:
user.language = settings.LANGUAGE_CODE
user.save(creator=creator)
if mailbox_data:
mailbox_data["full_address"] = user.username
self._create_mailbox(creator, user, mailbox_data)
user.role = role
self.set_permissions(user, domains)
if aliases:
for alias in aliases:
models.Alias.objects.create(creator=creator,
domain=alias["domain"],
address="{}@{}".format(
alias["localpart"],
alias["domain"]),
recipients=[user.username])
return user
def create(self, validated_data):
"""Create administrator and other stuff if needed."""
domain_admin = validated_data.pop("domain_admin", None)
domain = super().create(validated_data)
if not domain_admin:
return domain
# 1. Create a domain administrator
username = "******" % (domain_admin["username"], domain.name)
try:
da = core_models.User.objects.get(username=username)
except core_models.User.DoesNotExist:
pass
else:
raise lib_exceptions.Conflict(
_("User '%s' already exists") % username)
user = self.context["request"].user
core_signals.can_create_object.send(self.__class__,
context=user,
klass=models.Mailbox)
da = core_models.User(username=username,
email=username,
is_active=True)
password = domain_admin.get("password")
if password is None:
password = param_tools.get_global_parameter("default_password",
app="core")
da.set_password(password)
da.save()
da.role = "DomainAdmins"
da.post_create(user)
# 2. Create mailbox if needed
if domain_admin["with_mailbox"]:
dom_admin_username = domain_admin["username"]
mb = models.Mailbox(address=dom_admin_username,
domain=domain,
user=da,
use_domain_quota=True)
mb.set_quota(override_rules=user.has_perm("admin.change_domain"))
mb.save(creator=user)
# 3. Create aliases if needed
condition = (domain.type == "domain"
and domain_admin["with_aliases"]
and dom_admin_username != "postmaster")
if condition:
core_signals.can_create_object.send(self.__class__,
context=user,
klass=models.Alias)
address = u"postmaster@{}".format(domain.name)
alias = models.Alias.objects.create(address=address,
domain=domain,
enabled=True)
alias.set_recipients([mb.full_address])
alias.post_create(user)
domain.add_admin(da)
return domain
def _migrate_admins(self, options, creator, pf_domain, newdom=None):
"""Administrators migration.
:param pf_domain: The ``pf_models.Domain`` to get the admins to migrate.
:param newdom: If None the admins will not be linked to any domain
and they will be SuperAdmins. Otherwise link them to
this domain and make them DomainAdmins.
"""
if newdom is None:
print "\nMigrating super administrators"
else:
print "\tMigrating administrators"
dagroup = Group.objects.using(options["_to"]).get(name="DomainAdmins")
for old_admin in pf_domain.admins.all():
if newdom is None:
print "\tMigrating %s" % old_admin.username
# In postfixadmin, it's possible to have an admin account
# and a user account with the same username but they are
# completely different entities, so they do not have a
# common password. In Modoboa this does not makes sense, so
# we actually merge these two entities into a single user
# if both are found. Question is, which password should we
# use?. The admin password is used to be on the secure
# side.
try:
user = core_models.User.objects \
.using(options["_to"]).get(username=old_admin.username)
if "SimpleUsers" == user.group:
print (
"Warning: Found an admin account with the same "
"username as normal user '%s'. The existing user will "
"be promoted to admin and it's password changed to the "
"admin's account password. " % user.username
)
except core_models.User.DoesNotExist:
user = core_models.User()
user.username = old_admin.username
user.email = old_admin.username
user.is_active = old_admin.active
user.save(creator=creator, using=options["_to"])
user.date_joined = old_admin.modified
set_account_password(
user, old_admin.password, options["passwords_scheme"])
if newdom is None:
grant_access_to_all_objects(user, "SuperAdmins")
user.is_superuser = True
else:
user.groups.add(dagroup)
newdom.add_admin(user)
user.save(using=options["_to"])
def create(self, validated_data):
"""Create appropriate objects."""
creator = self.context["request"].user
mailbox_data = validated_data.pop("mailbox", None)
role = validated_data.pop("role")
user = core_models.User(**validated_data)
user.set_password(validated_data["password"])
user.save(creator=creator)
if mailbox_data:
self._create_mailbox(creator, user, mailbox_data)
user.role = role
return user
def create(self, validated_data):
"""Create appropriate objects."""
creator = self.context["request"].user
mailbox_data = validated_data.pop("mailbox", None)
role = validated_data.pop("role")
domains = validated_data.pop("domains", [])
random_password = validated_data.pop("random_password", False)
user = core_models.User(**validated_data)
if random_password:
password = lib.make_password()
else:
password = validated_data.pop("password")
user.set_password(password)
user.save(creator=creator)
if mailbox_data:
self._create_mailbox(creator, user, mailbox_data)
user.role = role
self.set_permissions(user, domains)
return user
