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