Beispiel #1
0
    def save(self, user, domain):
        if self.cleaned_data["create_dom_admin"] == "no":
            return
        username = "%[email protected]%s" % (self.cleaned_data["dom_admin_username"], domain.name)
        try:
            da = User.objects.get(username=username)
        except User.DoesNotExist:
            pass
        else:
            raise AdminError(_("User '%s' already exists" % username))
        da = User(username=username, email=username, is_active=True)
        da.set_password("password")
        da.save()
        da.set_role("DomainAdmins")
        da.post_create(user)
        mb = Mailbox(address=self.cleaned_data["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)

        if self.cleaned_data["create_aliases"] == "yes":
            al = Alias(address="postmaster", domain=domain, enabled=True)
            al.save(int_rcpts=[mb], creator=user)

        domain.add_admin(da)
Beispiel #2
0
    def save(self, user, account):
        if self.cleaned_data["email"] == "":
            return None

        if self.cleaned_data["quota_act"]:
            self.cleaned_data["quota"] = None

        if not hasattr(self, "mb") or self.mb is None:
            self.create_mailbox(user, account)
        else:
            self.update_mailbox(user, account)
        events.raiseEvent(
            'SaveExtraFormFields', 'mailform', self.mb, self.cleaned_data
        )

        account.email = self.cleaned_data["email"]
        account.save()

        aliases = []
        for name, value in self.cleaned_data.iteritems():
            if not name.startswith("aliases"):
                continue
            if value == "":
                continue
            aliases.append(value)

        for alias in self.mb.alias_set.all():
            if not alias.full_address in aliases:
                if len(alias.get_recipients()) >= 2:
                    continue
                alias.delete()
            else:
                aliases.remove(alias.full_address)
        if aliases:
            events.raiseEvent(
                "CanCreate", user, "mailbox_aliases", len(aliases)
            )
            for alias in aliases:
                local_part, domname = split_mailbox(alias)
                try:
                    self.mb.alias_set.get(address=local_part, domain__name=domname)
                except Alias.DoesNotExist:
                    pass
                else:
                    continue
                al = Alias(address=local_part, enabled=account.is_active)
                al.domain = Domain.objects.get(name=domname)
                al.save(int_rcpts=[self.mb], creator=user)

        return self.mb
Beispiel #3
0
    def _update_aliases(self, user, account):
        """Update mailbox aliases."""
        aliases = []
        for name, value in self.cleaned_data.iteritems():
            if not name.startswith("aliases"):
                continue
            if value == "":
                continue
            aliases.append(value.lower())

        for alias in self.mb.alias_set.all():
            if alias.full_address not in aliases:
                if len(alias.get_recipients()) >= 2:
                    continue
                alias.delete()
            else:
                aliases.remove(alias.full_address)
        if not aliases:
            return
        events.raiseEvent(
            "CanCreate", user, "mailbox_aliases", len(aliases)
        )
        for alias in aliases:
            local_part, domname = split_mailbox(alias)
            try:
                self.mb.alias_set.get(address=local_part, domain__name=domname)
            except Alias.DoesNotExist:
                pass
            else:
                continue
            al = Alias(address=local_part, enabled=account.is_active)
            al.domain = Domain.objects.get(name=domname)
            al.save(int_rcpts=[self.mb])
            al.post_create(user)
Beispiel #4
0
def forward(request, tplname='admin/forward.html'):
    try:
        mb = request.user.mailbox_set.all()[0]
    except IndexError:
        raise ModoboaException(
            _("You need a mailbox in order to define a forward")
        )
    try:
        al = Alias.objects.get(address=mb.address,
                               domain__name=mb.domain.name)
    except Alias.DoesNotExist:
        al = None
    if request.method == "POST":
        form = ForwardForm(request.POST)
        error = None
        if form.is_valid():
            try:
                if al is None:
                    al = Alias()
                    al.address = mb.address
                    al.domain = mb.domain
                    al.enabled = mb.user.is_active
                intdests = []
                if form.cleaned_data["keepcopies"]:
                    intdests += [mb]
                form.parse_dest()
                al.save(int_rcpts=intdests, ext_rcpts=form.dests)
                if request.user.group != "SimpleUsers":
                    al.post_create(request.user)
                return ajax_response(request, respmsg=_("Forward updated"))
            except BadDestination, e:
                error = str(e)

        return ajax_simple_response(dict(
            status="ko",
            errors=form.errors,
            respmsg=error
        ))
Beispiel #5
0
def forward(request, tplname='admin/forward.html'):
    mb = request.user.mailbox_set.all()[0]
    try:
        al = Alias.objects.get(address=mb.address,
                               domain__name=mb.domain.name)
    except Alias.DoesNotExist:
        al = None
    if request.method == "POST":
        form = ForwardForm(request.POST)
        error = None
        if form.is_valid():
            if al is None:
                al = Alias()
                al.address = mb.address
                al.domain = mb.domain
                al.enabled = mb.user.is_active
            intdests = []
            if form.cleaned_data["keepcopies"]:
                intdests += [mb]
            form.parse_dest()
            al.save(
                int_rcpts=intdests, ext_rcpts=form.dests, creator=request.user
            )
            return render_to_json_response(_("Forward updated"))

        return render_to_json_response(
            {'form_errors': form.errors}, status=400
        )

    form = ForwardForm()
    if al is not None:
        form.fields["dest"].initial = al.extmboxes
        try:
            al.mboxes.get(pk=mb.id)
        except Mailbox.DoesNotExist:
            pass
        else:
            form.fields["keepcopies"].initial = True
    return render_to_json_response({
        "content": _render_to_string(request, tplname, {
            "form": form
        })
    })
Beispiel #6
0
def _import_alias(user, row, **kwargs):
    """Specific code for aliases import"""
    alias = Alias()
    alias.from_csv(user, row, **kwargs)
Beispiel #7
0
    def save(self, user, account):
        if self.cleaned_data["email"] == "":
            return None

        if self.cleaned_data["quota_act"]:
            self.cleaned_data["quota"] = None

        if not hasattr(self, "mb") or self.mb is None:
            locpart, domname = split_mailbox(self.cleaned_data["email"])
            try:
                domain = Domain.objects.get(name=domname)
            except Domain.DoesNotExist:
                raise AdminError(_("Domain does not exist"))
            if not user.can_access(domain):
                raise PermDeniedException
            try:
                Mailbox.objects.get(address=locpart, domain=domain)
            except Mailbox.DoesNotExist:
                pass
            else:
                raise AdminError(_("Mailbox %s already exists" % self.cleaned_data["email"]))
            events.raiseEvent("CanCreate", user, "mailboxes")
            self.mb = Mailbox(address=locpart, domain=domain, user=account,
                              use_domain_quota=self.cleaned_data["quota_act"])
            self.mb.set_quota(self.cleaned_data["quota"], 
                              user.has_perm("admin.add_domain"))
            self.mb.save(creator=user)
        else:
            newaddress = None
            if self.cleaned_data["email"] != self.mb.full_address:
                newaddress = self.cleaned_data["email"]
            elif account.group == "SimpleUsers" and account.username != self.mb.full_address:
                newaddress = account.username
            if newaddress is not None:
                local_part, domname = split_mailbox(newaddress)
                try:
                    domain = Domain.objects.get(name=domname)
                except Domain.DoesNotExist:
                    raise AdminError(_("Domain does not exist"))
                if not user.can_access(domain):
                    raise PermDeniedException
                self.mb.rename(local_part, domain)

            self.mb.use_domain_quota = self.cleaned_data["quota_act"]
            override_rules = True \
                if not self.mb.quota or user.has_perm("admin.add_domain") \
                else False
            self.mb.set_quota(self.cleaned_data["quota"], override_rules)
            self.mb.save()

        account.email = self.cleaned_data["email"]
        account.save()

        for name, value in self.cleaned_data.iteritems():
            if not name.startswith("aliases"):
                continue
            if value == "":
                continue
            local_part, domname = split_mailbox(value)
            try:
                self.mb.alias_set.get(address=local_part, domain__name=domname)
            except Alias.DoesNotExist:
                pass
            else:
                continue
            events.raiseEvent("CanCreate", user, "mailbox_aliases")
            al = Alias(address=local_part, enabled=account.is_active)
            al.domain = Domain.objects.get(name=domname)
            al.save(int_rcpts=[self.mb], creator=user)

        for alias in self.mb.alias_set.all():
            if len(alias.get_recipients()) >= 2:
                continue
            if not len(filter(lambda name: self.cleaned_data[name] == alias.full_address,
                              self.cleaned_data.keys())):
                alias.delete()

        return self.mb