def edit_auth(self, authid):
"Edit auth server"
server = self._get_authserver(authid)
if not server:
abort(404)
c.form = AddAuthForm(request.POST, server, csrf_context=session)
if request.method == 'POST' and c.form.validate():
kwd = dict(domainid=server.domain_id)
if auth_update_if_changed(c.form, server):
try:
edit_auth(server, c.user, request.host,
request.remote_addr)
flash(_('The authentication settings have been updated'))
self.invalidate = 1
self._get_authserver(authid)
kwd['uc'] = 1
redirect(url('domain-detail', **kwd))
except IntegrityError:
Session.rollback()
msg = _('The authentication settings update failed')
flash_alert(msg)
log.info(msg)
else:
msg = _('No changes were made to the authentication settings')
flash_info(msg)
log.info(msg)
redirect(url('domain-detail', **kwd))
c.domainid = server.domains.id
c.domainname = server.domains.name
c.authid = authid
return self.render('/domains/editauth.html')
def delete_auth(self, authid):
"Delete auth server"
server = self._get_authserver(authid)
if not server:
abort(404)
c.form = AddAuthForm(request.POST, server, csrf_context=session)
if request.POST and c.form.validate():
name = server.domains.name
server_addr = server.address
domainid = server.domains.id
Session.delete(server)
Session.commit()
flash(_('The authentication settings have been deleted'))
info = DELETEAUTHSVR_MSG % dict(d=name, ds=server_addr)
audit_log(c.user.username, 4, info, request.host,
request.remote_addr, now())
redirect(url('domain-detail', domainid=domainid))
else:
flash(
_('The authentication server: %(s)s will be deleted,'
' This action is not reversible') % dict(s=server.address))
c.domainid = server.domains.id
c.domainname = server.domains.name
c.authid = authid
return render('/domains/deleteauth.html')
def edit(self, userid):
"""GET /accounts/edit/id: Form to edit an existing item"""
user = self._get_user(userid)
if not user:
abort(404)
c.form = user_update_form(user, c.user, request.POST, session)
if request.method == 'POST' and c.form.validate():
kwd = dict(userid=user.id)
if update_changed(c.form, FORM_FIELDS, user):
try:
update_user(user, c.user, request.host,
request.remote_addr)
flash(_('The account has been updated'))
kwd['uc'] = 1
except IntegrityError:
Session.rollback()
flash_alert(
_('The account: %(acc)s could not be updated') %
dict(acc=user.username))
if (user.id == c.user.id and c.form.active
and c.form.active.data is False):
redirect(url('/logout'))
else:
flash_info(_('No changes made to the account'))
redirect(url(controller='accounts', action='detail', **kwd))
c.fields = FORM_FIELDS
c.id = userid
return self.render('/accounts/edit.html')
def edit_server(self, serverid):
"Edit scan server"
server = self._get_server(serverid)
if not server:
abort(404)
c.form = ServerForm(request.POST, server, csrf_context=session)
c.id = server.id
if request.POST and c.form.validate():
if (server.hostname != c.form.hostname.data
or server.enabled != c.form.enabled.data):
try:
server.hostname = c.form.hostname.data
server.enabled = c.form.enabled.data
Session.add(server)
Session.commit()
update_serial.delay()
info = HOSTUPDATE_MSG % dict(n=server.hostname)
audit_log(c.user.username, 2, info, request.host,
request.remote_addr, now())
flash(_('The scanning server has been updated'))
except IntegrityError:
Session.rollback()
flash(_('Update of server failed'))
else:
flash_info(_('No changes were made to the server'))
redirect(url(controller='settings'))
return render('/settings/editserver.html')
def add(self, orgid=None):
"Add a domain"
c.form = AddDomainForm(request.POST, csrf_context=session)
c.form.organizations.query = self._get_organizations(orgid)
if request.POST and c.form.validate():
try:
domain = Domain()
for field in c.form:
if field.name != 'csrf_token':
setattr(domain, field.name, field.data)
Session.add(domain)
Session.commit()
update_serial.delay()
info = ADDDOMAIN_MSG % dict(d=domain.name)
audit_log(c.user.username, 3, info, request.host,
request.remote_addr, now())
flash(
_('The domain: %(dom)s has been created') %
dict(dom=domain.name))
redirect(url(controller='domains'))
except IntegrityError:
Session.rollback()
flash_alert(
_('The domain name %(dom)s already exists') %
dict(dom=domain.name))
return render('/domains/new.html')
def edit(self, orgid):
"Edit an organization"
org = get_org(orgid)
if not org:
abort(404)
c.id = org.id
c.form = org_add_form(request.POST, session, org)
if request.method == 'POST' and c.form.validate():
if update_if_changed(c.form, org):
try:
edit_org(org, c.user, request.host, request.remote_addr)
msg = _('The organization has been updated')
flash(msg)
log.info(msg)
except IntegrityError:
Session.rollback()
msg = _('The organization could not be updated')
flash(msg)
log.info(msg)
else:
msg = _('No changes made, Organization not updated')
flash_info(msg)
log.info(msg)
redirect(url(controller='organizations'))
return self.render('/organizations/edit.html')
def delete(self, orgid):
"Delete an organization"
org = self._get_org(orgid)
if not org:
abort(404)
c.form = DelOrgForm(request.POST, org, csrf_context=session)
c.form.domains.query = Session.query(Domain)
c.form.admins.query = Session.query(User).filter(
User.account_type == 2)
c.id = org.id
if request.POST and c.form.validate():
org_name = org.name
if c.form.delete_domains.data:
for domain in org.domains:
Session.delete(domain)
Session.delete(org)
Session.commit()
info = DELETEORG_MSG % dict(o=org_name)
audit_log(c.user.username, 4, info, request.host,
request.remote_addr, datetime.now())
flash(_('The organization has been deleted'))
redirect(url(controller='organizations'))
else:
flash(
_('The organization: %(s)s will be deleted,'
' This action is not reversible') % dict(s=org.name))
return render('/organizations/delete.html')
def add(self, orgid=None):
"Add a domain"
c.form = AddDomainForm(request.POST, csrf_context=session)
c.form.organizations.query = self._get_organizations(orgid)
if request.POST and c.form.validate():
try:
domain = Domain()
for field in c.form:
if field.name != 'csrf_token':
setattr(domain, field.name, field.data)
Session.add(domain)
Session.commit()
update_serial.delay()
info = ADDDOMAIN_MSG % dict(d=domain.name)
audit_log(c.user.username,
3, unicode(info), request.host,
request.remote_addr, now())
flash(_('The domain: %(dom)s has been created') %
dict(dom=domain.name))
redirect(url(controller='domains'))
except IntegrityError:
Session.rollback()
flash_alert(_('The domain name %(dom)s already exists') %
dict(dom=domain.name))
return render('/domains/new.html')
def deletedestination(self, destinationid):
"Delete destination server"
server = self._get_server(destinationid)
if not server:
abort(404)
c.form = AddDeliveryServerForm(request.POST,
server,
csrf_context=session)
if request.POST and c.form.validate():
name = server.domains.name
server_addr = server.address
domainid = server.domain_id
Session.delete(server)
Session.commit()
flash(_('The destination server has been deleted'))
info = DELETEDELSVR_MSG % dict(d=name, ds=server_addr)
audit_log(c.user.username,
4, unicode(info), request.host,
request.remote_addr, now())
redirect(url('domain-detail', domainid=domainid))
else:
flash(_('The destination server: %(s)s will be deleted,'
' This action is not reversible') % dict(s=server.address))
c.id = destinationid
c.domainid = server.domain_id
return render('/domains/deletedestination.html')
def addaddress(self, userid):
"Add address"
user = self._get_user(userid)
if not user:
abort(404)
c.form = AddressForm(request.POST, csrf_context=session)
if request.method == 'POST' and c.form.validate():
try:
addr = create_address(c.form, user, c.user,
request.host, request.remote_addr)
flash(
_('The alias address %(address)s was successfully created.'
% dict(address=addr.address)))
except IntegrityError:
Session.rollback()
msg = _('The address %(addr)s already exists') % \
dict(addr=c.form.address.data)
flash_alert(msg)
log.info(msg)
except NoResultFound:
domain = c.form.address.data.split('@')[1]
msg = _('Domain: %(d)s does not belong to you') % \
dict(d=domain)
flash(msg)
log.info(msg)
redirect(url(controller='accounts', action='detail',
userid=userid))
c.id = userid
return self.render('/accounts/addaddress.html')
def editaddress(self, addressid):
"Edit address"
address = get_address(addressid)
if not address:
abort(404)
c.form = AddressForm(request.POST, address, csrf_context=session)
if request.method == 'POST' and c.form.validate():
try:
if (address.address != c.form.address.data or
address.enabled != c.form.enabled.data):
update_address(c.form, address, c.user,
request.host, request.remote_addr)
flash(_('The alias address has been updated'))
else:
flash_info(_('No changes were made to the address'))
except IntegrityError:
Session.rollback()
msg = _('The address %(addr)s already exists') % \
dict(addr=c.form.address.data)
flash_alert(msg)
log.info(msg)
except NoResultFound:
domain = c.form.address.data.split('@')[1]
msg = _('Domain: %(d)s does not belong to you') % \
dict(d=domain)
flash(msg)
log.info(msg)
redirect(url(controller='accounts', action='detail',
userid=address.user_id))
c.id = addressid
c.userid = address.user_id
return self.render('/accounts/editaddress.html')
def edit(self, userid):
"""GET /accounts/edit/id: Form to edit an existing item"""
user = self._get_user(userid)
if not user:
abort(404)
c.form = user_update_form(user, c.user, request.POST, session)
if request.method == 'POST' and c.form.validate():
kwd = dict(userid=user.id)
if update_changed(c.form, FORM_FIELDS, user):
try:
update_user(user, c.user, request.host,
request.remote_addr)
flash(_('The account has been updated'))
kwd['uc'] = 1
except IntegrityError:
Session.rollback()
flash_alert(
_('The account: %(acc)s could not be updated') %
dict(acc=user.username))
if (user.id == c.user.id and c.form.active and
c.form.active.data is False):
redirect(url('/logout'))
else:
flash_info(_('No changes made to the account'))
redirect(url(controller='accounts', action='detail', **kwd))
c.fields = FORM_FIELDS
c.id = userid
return self.render('/accounts/edit.html')
def editalias(self, aliasid):
"Edit alias domain"
alias = self._get_alias(aliasid)
if not alias:
abort(404)
c.form = EditDomainAlias(request.POST, alias, csrf_context=session)
c.form.domain.query = Session.query(Domain)\
.filter(Domain.id == alias.domain_id)
if request.method == 'POST' and c.form.validate():
if update_if_changed(c.form, alias):
try:
edit_alias(alias, c.user, request.host,
request.remote_addr)
flash(_('The domain alias: %s has been updated') %
alias.name)
redirect(url('domain-detail', domainid=alias.domain_id))
except IntegrityError:
Session.rollback()
msg = _('The update failed')
flash_alert(msg)
log.info(msg)
else:
msg = _('No changes were made to the domain alias')
flash_info(msg)
log.info(msg)
redirect(url('domain-detail', domainid=alias.domain_id))
c.aliasid = aliasid
c.domainid = alias.domain_id
c.domainname = alias.domain.name
return self.render('/domains/editalias.html')
def addalias(self, domainid):
"Add alias domain"
domain = self._get_domain(domainid)
if not domain:
abort(404)
c.form = AddDomainAlias(request.POST, csrf_context=session)
c.form.domain.query = Session.query(Domain)\
.filter(Domain.id == domainid)
if request.method == 'POST' and c.form.validate():
alias = DomainAlias()
alias.from_form(c.form)
try:
create_alias(domain, alias, c.user,
request.host, request.remote_addr)
flash(_('The domain alias: %s has been created') % alias.name)
redirect(url(controller='domains', action='detail',
domainid=domain.id))
except IntegrityError:
Session.rollback()
msg = _('The domain alias: %s already exists') % alias.name
flash_alert(msg)
log.info(msg)
c.domainid = domain.id
c.domainname = domain.name
return self.render('/domains/addalias.html')
def edit(self, orgid):
"Edit an organization"
org = self._get_org(orgid)
if not org:
abort(404)
c.form = OrgForm(request.POST, org, csrf_context=session)
c.form.domains.query = Session.query(Domain)
c.form.admins.query = Session.query(User).filter(
User.account_type == 2)
c.id = org.id
if request.POST and c.form.validate():
updated = False
for field in c.form:
if (field.name != 'csrf_token' and
field.data != getattr(org, field.name)):
setattr(org, field.name, field.data)
updated = True
if updated:
try:
Session.add(org)
Session.commit()
info = UPDATEORG_MSG % dict(o=org.name)
audit_log(c.user.username,
2, info, request.host,
request.remote_addr, datetime.now())
flash(_('The organization has been updated'))
except IntegrityError:
Session.rollback()
flash(_('The organization could not be updated'))
else:
flash_info(_('No changes made, Organization not updated'))
redirect(url(controller='organizations'))
return render('/organizations/edit.html')
def deletealias(self, aliasid):
"Delete alias domain"
alias = self._get_alias(aliasid)
if not alias:
abort(404)
c.form = DelDomainAlias(request.POST, alias, csrf_context=session)
c.form.domain.query = Session.query(Domain)\
.filter(Domain.id==alias.domain_id)
if request.POST and c.form.validate():
domainid = alias.domain_id
aliasname = alias.name
Session.delete(alias)
Session.commit()
update_serial.delay()
info = DELETEDOMALIAS_MSG % dict(d=aliasname)
audit_log(c.user.username,
4, unicode(info), request.host,
request.remote_addr, now())
flash(_('The domain alias: %s has been deleted') % aliasname)
redirect(url('domain-detail', domainid=domainid))
c.aliasid = aliasid
c.domainid = alias.domain_id
c.domainname = alias.domain.name
return render('/domains/deletealias.html')
def add_relay(self, orgid):
"Add a mail relay"
org = self._get_org(orgid)
if not org:
abort(404)
c.form = RelayForm(request.POST, csrf_context=session)
if request.POST and c.form.validate():
try:
outbound = Relay()
outbound.address = c.form.address.data
outbound.username = c.form.username.data
outbound.enabled = c.form.enabled.data
outbound.org = org
if c.form.password1.data:
outbound.set_password(c.form.password1.data)
Session.add(outbound)
Session.commit()
relay_name = c.form.address.data or c.form.username.data
info = ADDRELAY_MSG % dict(r=relay_name)
audit_log(c.user.username,
3, info, request.host,
request.remote_addr, datetime.now())
flash(_('The outbound settings have been created'))
except IntegrityError:
Session.rollback()
flash(_('The outbound settings could not created, Try again'))
redirect(url('org-detail', orgid=orgid))
c.orgid = org.id
c.orgname = org.name
return render('/organizations/addrelay.html')
def adddestination(self, domainid):
"Add a destination server"
domain = self._get_domain(domainid)
if not domain:
abort(404)
c.form = AddDeliveryServerForm(request.POST, csrf_context=session)
c.id = domainid
if request.POST and c.form.validate():
server = DeliveryServer()
for field in c.form:
if field.name != "csrf_token":
setattr(server, field.name, field.data)
try:
domain.servers.append(server)
Session.add(server)
Session.add(domain)
Session.commit()
info = ADDDELSVR_MSG % dict(d=domain.name, ds=server.address)
audit_log(c.user.username, 3, info, request.host, request.remote_addr, datetime.now())
flash(_("The destination server has been created"))
redirect(url(controller="domains", action="detail", domainid=domain.id))
except IntegrityError:
Session.rollback()
flash_alert(_("The destination server %(dest)s already exists ") % dict(dest=server.address))
return render("/domains/adddestination.html")
def pwchange(self, userid):
"""Reset a user password"""
user = self._get_user(userid)
if not user:
abort(404)
c.form = ChangePasswordForm(request.POST, csrf_context=session)
if request.POST and c.form.validate():
if user.local:
user.set_password(c.form.password1.data)
Session.add(user)
Session.commit()
flash(_('The account password for %(name)s has been reset')
% dict(name=user.username))
info = PASSWORDCHANGE_MSG % dict(u=user.username)
audit_log(c.user.username,
2, info, request.host,
request.remote_addr, datetime.now())
else:
flash(_('This is an external account, use'
' external system to reset the password'))
redirect(url('account-detail', userid=user.id))
c.id = userid
c.username = user.username
c.posturl = 'accounts-pw-change'
return render('/accounts/pwchange.html')
def editdestination(self, destinationid):
"Edit destination server"
server = self._get_server(destinationid)
if not server:
abort(404)
c.form = AddDeliveryServerForm(request.POST, server, csrf_context=session)
if request.POST and c.form.validate():
updated = False
kw = dict(domainid=server.domain_id)
for field in c.form:
if field.name != "csrf_token" and field.data != getattr(server, field.name):
setattr(server, field.name, field.data)
updated = True
if updated:
try:
Session.add(server)
Session.commit()
flash(_("The destination server has been updated"))
info = UPDATEDELSVR_MSG % dict(d=server.domains.name, ds=server.address)
audit_log(c.user.username, 2, info, request.host, request.remote_addr, datetime.now())
self.invalidate = 1
self._get_server(destinationid)
redirect(url("domain-detail", **kw))
except IntegrityError:
Session.rollback()
flash_alert(_("The update failed"))
else:
flash_info(_("No changes were made to the destination server"))
redirect(url("domain-detail", **kw))
c.id = destinationid
c.domainid = server.domain_id
return render("/domains/editdestination.html")
def save(self, filterid, format=None):
"Save a temp filter"
filters = session.get('filter_by', [])
try:
filt = filters[int(filterid)]
filteritems = dict(FILTER_ITEMS)
filterby = dict(FILTER_BY)
saved = SavedFilter(name="%s %s %s" %
(filteritems[filt["field"]],
filterby[filt["filter"]], filt["value"]),
field=filt["field"],
option=filt["filter"],
user=c.user)
saved.value = filt["value"]
Session.add(saved)
Session.commit()
success = True
error_msg = ''
self.invalidate = True
except IndexError:
success = False
error_msg = _("The filter does not exist")
except IntegrityError:
success = False
error_msg = _("The filter already exists")
Session.rollback()
if format == 'json':
response.headers['Content-Type'] = JSON_HEADER
errors = dict(msg=error_msg)
return json.dumps(self._get_data(format, success, errors))
if success:
flash(_("The filter has been saved"))
else:
flash(error_msg)
redirect(url('toplevel', controller='reports'))
def add_auth(self, domainid):
"Add auth server"
domain = self._get_domain(domainid)
if not domain:
abort(404)
c.form = AddAuthForm(request.POST, csrf_context=session)
if request.POST and c.form.validate():
server = AuthServer()
for field in c.form:
if field.data and field.name != "csrf_token":
setattr(server, field.name, field.data)
try:
domain.authservers.append(server)
Session.add(server)
Session.add(domain)
Session.commit()
info = ADDAUTHSVR_MSG % dict(d=domain.name, ds=server.address)
audit_log(c.user.username, 3, info, request.host, request.remote_addr, datetime.now())
flash(_("The authentication settings have been created"))
redirect(url(controller="domains", action="detail", domainid=domain.id))
except IntegrityError:
Session.rollback()
auth = dict(AUTH_PROTOCOLS)[str(server.protocol)]
flash_alert(
_("The host %(dest)s already configured for %(auth)s " "authentication for this domain")
% dict(dest=server.address, auth=auth)
)
c.domainid = domainid
c.domainname = domain.name
return render("/domains/addauth.html")
def add_domain_sigs(self, domainid):
"Add domain signature"
domain = self._get_domain(domainid)
if not domain:
abort(404)
c.form = SigForm(request.POST, csrf_context=session)
if request.POST and c.form.validate():
try:
sig = DomSignature()
for field in c.form:
if field.name != 'csrf_token':
setattr(sig, field.name, field.data)
domain.signatures.append(sig)
Session.add(sig)
Session.add(domain)
Session.commit()
save_dom_sig.apply_async(args=[sig.id], queue='msbackend')
info = ADDDOMSIG_MSG % dict(d=domain.name)
audit_log(c.user.username, 3, info, request.host,
request.remote_addr, now())
flash(_('The signature has been created'))
redirect(url('domain-settings-sigs', domainid=domainid))
except IntegrityError:
Session.rollback()
flash(_('This signature type already exists'))
c.domain = domain
return render('/settings/domain_addsig.html')
def delete_auth(self, authid):
"Delete auth server"
server = self._get_authserver(authid)
if not server:
abort(404)
c.form = AddAuthForm(request.POST, server, csrf_context=session)
if request.POST and c.form.validate():
name = server.domains.name
server_addr = server.address
domainid = server.domains.id
Session.delete(server)
Session.commit()
flash(_("The authentication settings have been deleted"))
info = DELETEAUTHSVR_MSG % dict(d=name, ds=server_addr)
audit_log(c.user.username, 4, info, request.host, request.remote_addr, datetime.now())
redirect(url("domain-detail", domainid=domainid))
else:
flash(
_("The authentication server: %(s)s will be deleted," " This action is not reversible")
% dict(s=server.address)
)
c.domainid = server.domains.id
c.domainname = server.domains.name
c.authid = authid
return render("/domains/deleteauth.html")
def deletedestination(self, destinationid):
"Delete destination server"
server = self._get_server(destinationid)
if not server:
abort(404)
c.form = AddDeliveryServerForm(request.POST,
server,
csrf_context=session)
if request.POST and c.form.validate():
name = server.domains.name
server_addr = server.address
domainid = server.domain_id
Session.delete(server)
Session.commit()
flash(_('The destination server has been deleted'))
info = DELETEDELSVR_MSG % dict(d=name, ds=server_addr)
audit_log(c.user.username, 4, info, request.host,
request.remote_addr, now())
redirect(url('domain-detail', domainid=domainid))
else:
flash(
_('The destination server: %(s)s will be deleted,'
' This action is not reversible') % dict(s=server.address))
c.id = destinationid
c.domainid = server.domain_id
return render('/domains/deletedestination.html')
def addalias(self, domainid):
"Add alias domain"
domain = self._get_domain(domainid)
if not domain:
abort(404)
c.form = AddDomainAlias(request.POST, csrf_context=session)
c.form.domain.query = Session.query(Domain).filter(Domain.id == domainid)
if request.POST and c.form.validate():
alias = DomainAlias()
for field in c.form:
if field.data and field.name != "csrf_token":
setattr(alias, field.name, field.data)
try:
domain.aliases.append(alias)
Session.add(alias)
Session.add(domain)
Session.commit()
update_serial.delay()
info = ADDDOMALIAS_MSG % dict(d=alias.name)
audit_log(c.user.username, 3, info, request.host, request.remote_addr, datetime.now())
flash(_("The domain alias: %s has been created") % alias.name)
redirect(url(controller="domains", action="detail", domainid=domain.id))
except IntegrityError:
Session.rollback()
flash_alert(_("The domain alias: %s already exists") % alias.name)
c.domainid = domain.id
c.domainname = domain.name
return render("/domains/addalias.html")
def upwchange(self, userid):
"""User change own password"""
user = self._get_user(userid)
if not user:
abort(404)
if user.id != c.user.id or c.user.is_superadmin:
abort(403)
c.form = UserPasswordForm(request.POST, csrf_context=session)
if (request.POST and c.form.validate() and
user.validate_password(c.form.password3.data)):
if user.local:
user.set_password(c.form.password1.data)
Session.add(user)
Session.commit()
flash(_('The account password for %(name)s has been reset')
% dict(name=user.username))
info = PASSWORDCHANGE_MSG % dict(u=user.username)
audit_log(c.user.username,
2, unicode(info), request.host,
request.remote_addr, now())
else:
flash(_('This is an external account, use'
' external system to reset the password'))
redirect(url('account-detail', userid=user.id))
elif (request.POST and not
user.validate_password(c.form.password3.data)
and not c.form.password3.errors):
flash_alert(_('The old password supplied does'
' not match our records'))
c.id = userid
c.username = user.username
c.posturl = 'accounts-pw-uchange'
return render('/accounts/pwchange.html')
def editalias(self, aliasid):
"Edit alias domain"
alias = self._get_alias(aliasid)
if not alias:
abort(404)
c.form = EditDomainAlias(request.POST, alias, csrf_context=session)
c.form.domain.query = Session.query(Domain).filter(Domain.id == alias.domain_id)
if request.POST and c.form.validate():
updated = False
for field in c.form:
if field.name != "csrf_token" and field.data != getattr(alias, field.name):
setattr(alias, field.name, field.data)
updated = True
if updated:
try:
Session.add(alias)
Session.commit()
update_serial.delay()
info = UPDATEDOMALIAS_MSG % dict(d=alias.name)
audit_log(c.user.username, 2, info, request.host, request.remote_addr, datetime.now())
flash(_("The domain alias: %s has been updated") % alias.name)
redirect(url("domain-detail", domainid=alias.domain_id))
except IntegrityError:
Session.rollback()
flash_alert(_("The update failed"))
else:
flash_info(_("No changes were made to the domain alias"))
redirect(url("domain-detail", domainid=alias.domain_id))
c.aliasid = aliasid
c.domainid = alias.domain_id
c.domainname = alias.domain.name
return render("/domains/editalias.html")
def editaddress(self, addressid):
"Edit address"
address = get_address(addressid)
if not address:
abort(404)
c.form = AddressForm(request.POST, address, csrf_context=session)
if request.method == 'POST' and c.form.validate():
try:
if (address.address != c.form.address.data
or address.enabled != c.form.enabled.data):
update_address(c.form, address, c.user, request.host,
request.remote_addr)
flash(_('The alias address has been updated'))
else:
flash_info(_('No changes were made to the address'))
except IntegrityError:
Session.rollback()
msg = _('The address %(addr)s already exists') % \
dict(addr=c.form.address.data)
flash_alert(msg)
log.info(msg)
except NoResultFound:
domain = c.form.address.data.split('@')[1]
msg = _('Domain: %(d)s does not belong to you') % \
dict(d=domain)
flash(msg)
log.info(msg)
redirect(
url(controller='accounts',
action='detail',
userid=address.user_id))
c.id = addressid
c.userid = address.user_id
return self.render('/accounts/editaddress.html')
def edit_server(self, serverid):
"Edit scan server"
server = self._get_server(serverid)
if not server:
abort(404)
c.form = ServerForm(request.POST, server, csrf_context=session)
c.id = server.id
if request.POST and c.form.validate():
if (server.hostname != c.form.hostname.data or
server.enabled != c.form.enabled.data):
try:
server.hostname = c.form.hostname.data
server.enabled = c.form.enabled.data
Session.add(server)
Session.commit()
update_serial.delay()
info = HOSTUPDATE_MSG % dict(n=server.hostname)
audit_log(c.user.username,
2, info, request.host,
request.remote_addr, datetime.now())
flash(_('The scanning server has been updated'))
except IntegrityError:
Session.rollback()
flash(_('Update of server failed'))
else:
flash_info(_('No changes were made to the server'))
redirect(url(controller='settings'))
return render('/settings/editserver.html')
def delete(self, userid):
"""/accounts/delete/id"""
user = self._get_user(userid)
if not user:
abort(404)
c.form = EditUserForm(request.POST, user, csrf_context=session)
c.form.domains.query = Session.query(Domain)
if request.POST and c.form.validate():
username = user.username
Session.delete(user)
Session.commit()
update_serial.delay()
flash(_('The account has been deleted'))
info = DELETEACCOUNT_MSG % dict(u=username)
audit_log(c.user.username, 4, info, request.host,
request.remote_addr, now())
if userid == c.user.id:
redirect(url('/logout'))
redirect(url(controller='accounts', action='index'))
else:
flash_info(
_('The account: %(a)s and all associated data'
' will be deleted, This action is not reversible.') %
dict(a=user.username))
c.fields = FORM_FIELDS
c.id = userid
return render('/accounts/delete.html')
def domain_dkim_generate(self, domainid):
"Domain DKIM generate keys"
domain = self._get_domain(domainid)
if not domain:
abort(404)
pub_key, pri_key = make_key_pair()
if domain.dkimkeys:
dkimkeys = domain.dkimkeys[0]
else:
dkimkeys = DKIMKeys()
dkimkeys.pub_key = pub_key
dkimkeys.pri_key = pri_key
try:
if domain.dkimkeys:
domain.dkimkeys[0] = dkimkeys
else:
domain.dkimkeys.append(dkimkeys)
Session.add(dkimkeys)
Session.add(domain)
Session.commit()
info = DKIMGEN_MSG % dict(d=domain.name)
audit_log(c.user.username,
3, info, request.host,
request.remote_addr, datetime.now())
flash(_('DKIM keys successfully generated'))
except DatabaseError:
flash_alert(_('Generation of DKIM keys failed'))
redirect(url('domain-dkim', domainid=domain.id))
def delete(self, orgid):
"Delete an organization"
org = self._get_org(orgid)
if not org:
abort(404)
c.form = DelOrgForm(request.POST, org, csrf_context=session)
c.form.domains.query = Session.query(Domain)
c.form.admins.query = Session.query(User).filter(
User.account_type == 2)
c.id = org.id
if request.POST and c.form.validate():
org_name = org.name
if c.form.delete_domains.data:
for domain in org.domains:
Session.delete(domain)
Session.delete(org)
Session.commit()
info = DELETEORG_MSG % dict(o=org_name)
audit_log(c.user.username,
4, info, request.host,
request.remote_addr, datetime.now())
flash(_('The organization has been deleted'))
redirect(url(controller='organizations'))
else:
flash(_('The organization: %(s)s will be deleted,'
' This action is not reversible') % dict(s=org.name))
return render('/organizations/delete.html')
def domain_dkim_enable(self, domainid):
"Enable or disable DKIM signing"
domain = self._get_domain(domainid)
if not domain or not domain.dkimkeys:
abort(404)
c.form = DKIMForm(request.POST, domain.dkimkeys[0],
csrf_context=session)
if request.POST and c.form.validate():
dkimkeys = domain.dkimkeys[0]
if dkimkeys.enabled != c.form.enabled.data:
dkimkeys.enabled = c.form.enabled.data
Session.add(dkimkeys)
Session.commit()
if c.form.enabled.data:
state = _('enabled')
save_dkim_key.apply_async(args=[domain.name,
dkimkeys.pri_key],
queue='msbackend')
info = DKIMENABLED_MSG % dict(d=domain.name)
else:
info = DKIMDISABLED_MSG % dict(d=domain.name)
delete_dkim_key.apply_async(args=[domain.name],
queue='msbackend')
state = _('disabled')
audit_log(c.user.username,
2, info, request.host,
request.remote_addr, datetime.now())
reload_exim.delay()
flash(_('DKIM signing for: %s has been %s') %
(domain.name, state))
else:
flash(_('DKIM signing status: No changes made'))
redirect(url('domain-dkim', domainid=domain.id))
c.domain = domain
return render('/settings/domain_dkim_enable.html')
def process_mailq(self):
"Process mailq"
sendto = url('mailq-status')
choices = session.get('queue_choices', [])
form = MailQueueProcessForm(request.POST, csrf_context=session)
form.id.choices = choices
if request.POST and form.validate() and choices:
queueids = form.id.data
if form.queue_action.data != '0':
hosts = {}
direction = None
queueitems = Session.query(MailQueueItem)\
.filter(MailQueueItem.id.in_(queueids))\
.all()
for item in queueitems:
if not item.hostname in hosts:
hosts[item.hostname] = []
if not direction:
direction = item.direction
hosts[item.hostname].append(item.messageid)
for hostname in hosts:
process_queued_msgs.apply_async(args=[hosts[hostname],
form.queue_action.data,
direction],
queue=hostname)
flash(_('The request has been queued for processing'))
session['queue_choices'] = []
session.save()
referer = request.headers.get('Referer', None)
if referer and '/mailq' in referer:
sendto = referer
redirect(sendto)
def add_domain_sigs(self, domainid):
"Add domain signature"
domain = self._get_domain(domainid)
if not domain:
abort(404)
c.form = SigForm(request.POST, csrf_context=session)
if request.POST and c.form.validate():
try:
sig = DomSignature()
for field in c.form:
if field.name != 'csrf_token':
setattr(sig, field.name, field.data)
domain.signatures.append(sig)
Session.add(sig)
Session.add(domain)
Session.commit()
save_dom_sig.apply_async(args=[sig.id], queue='msbackend')
info = ADDDOMSIG_MSG % dict(d=domain.name)
audit_log(c.user.username,
3, info, request.host,
request.remote_addr, datetime.now())
flash(_('The signature has been created'))
redirect(url('domain-settings-sigs', domainid=domainid))
except IntegrityError:
Session.rollback()
flash(_('This signature type already exists'))
c.domain = domain
return render('/settings/domain_addsig.html')
def image_fixups(content, msgid, archive, richformat, allowimgs):
"Replace the CID links stored messages"
html = local_fromstring(content)
for element, attribute, link, _ in iterlinks(html):
if not link.startswith('cid:'):
if not allowimgs and attribute == 'src':
element.attrib['src'] = '%simgs/blocked.gif' % media_url()
element.attrib['title'] = link
if richformat:
if archive:
displayurl = url('message-preview-archived-with-imgs',
msgid=msgid)
else:
displayurl = url('message-preview-with-imgs',
msgid=msgid)
flash(ugettext('This message contains external'
' images, which have been blocked. ') +
literal(link_to(ugettext('Display images'),
displayurl)))
else:
imgname = link.replace('cid:', '')
if archive:
imgurl = url('messages-preview-archived-img',
img=imgname.replace('/', '__xoxo__'),
msgid=msgid)
else:
imgurl = url('messages-preview-img',
img=imgname.replace('/', '__xoxo__'),
msgid=msgid)
element.attrib['src'] = imgurl
return tostring(html)
def add_account_sigs(self, userid):
"Add account signature"
account = self._get_user(userid)
if not account:
abort(404)
c.form = SigForm(request.POST, csrf_context=session)
if request.POST and c.form.validate():
try:
sig = UserSignature()
for field in c.form:
if field.name != 'csrf_token':
setattr(sig, field.name, field.data)
account.signatures.append(sig)
Session.add(sig)
Session.add(account)
Session.commit()
save_user_sig.apply_async(args=[sig.id], queue='msbackend')
info = ADDACCSIG_MSG % dict(u=account.username)
audit_log(c.user.username,
3, info, request.host,
request.remote_addr, datetime.now())
flash(_('The signature has been created'))
redirect(url('account-detail', userid=userid))
except IntegrityError:
Session.rollback()
flash(_('This signature type already exists'))
c.account = account
return render('/settings/account_addsig.html')
def edit(self, orgid):
"Edit an organization"
org = self._get_org(orgid)
if not org:
abort(404)
c.form = OrgForm(request.POST, org, csrf_context=session)
c.form.domains.query = Session.query(Domain)
c.form.admins.query = Session.query(User).filter(
User.account_type == 2)
c.id = org.id
if request.POST and c.form.validate():
updated = False
for field in c.form:
if (field.name != 'csrf_token'
and field.data != getattr(org, field.name)):
setattr(org, field.name, field.data)
updated = True
if updated:
try:
Session.add(org)
Session.commit()
info = UPDATEORG_MSG % dict(o=org.name)
audit_log(c.user.username, 2, info, request.host,
request.remote_addr, datetime.now())
flash(_('The organization has been updated'))
except IntegrityError:
Session.rollback()
flash(_('The organization could not be updated'))
else:
flash_info(_('No changes made, Organization not updated'))
redirect(url(controller='organizations'))
return render('/organizations/edit.html')
def add(self, orgid=None):
"Add a domain"
c.form = AddDomainForm(request.POST, csrf_context=session)
c.form.organizations.query = get_organizations(orgid)
if request.method == 'POST' and c.form.validate():
try:
domain = create_domain(c.form, c.user, request.host,
request.remote_addr)
try:
from baruwa.tasks.invite import create_mx_records
create_mx_records.apply_async(args=[domain.name])
except ImportError:
pass
flash(
_('The domain: %(dom)s has been created') %
dict(dom=domain.name))
redirect(url(controller='domains'))
except IntegrityError:
Session.rollback()
msg = _('The domain name %(dom)s already exists') % \
dict(dom=domain.name)
flash_alert(msg)
log.info(msg)
return self.render('/domains/new.html')
def add_relay(self, orgid):
"Add a mail relay"
org = self._get_org(orgid)
if not org:
abort(404)
c.form = RelayForm(request.POST, csrf_context=session)
if request.POST and c.form.validate():
try:
outbound = Relay()
outbound.address = c.form.address.data
outbound.username = c.form.username.data
outbound.enabled = c.form.enabled.data
outbound.org = org
if c.form.password1.data:
outbound.set_password(c.form.password1.data)
Session.add(outbound)
Session.commit()
relay_name = c.form.address.data or c.form.username.data
info = ADDRELAY_MSG % dict(r=relay_name)
audit_log(c.user.username, 3, info, request.host,
request.remote_addr, datetime.now())
flash(_('The outbound settings have been created'))
except IntegrityError:
Session.rollback()
flash(_('The outbound settings could not created, Try again'))
redirect(url('org-detail', orgid=orgid))
c.orgid = org.id
c.orgname = org.name
return render('/organizations/addrelay.html')
def edit(self, domainid):
"Edit a domain"
domain = self._get_domain(domainid)
if not domain:
abort(404)
c.id = domainid
c.form = domain_update_form(c.user, request.POST, domain,
get_organizations, session)
if request.method == 'POST' and c.form.validate():
kwd = dict(domainid=domain.id)
if domain_update_if_changed(c.form, domain):
try:
update_domain(domain, c.user, request.host,
request.remote_addr)
flash(
_('The domain: %(dom)s has been updated') %
dict(dom=domain.name))
kwd['uc'] = 1
except IntegrityError:
Session.rollback()
msg = _('The domain %(dom)s could not be updated') % \
dict(dom=domain.name)
flash(msg)
log.info(msg)
else:
msg = _('No changes were made to the domain')
flash_info(msg)
log.info(msg)
redirect(url('domain-detail', **kwd))
return self.render('/domains/edit.html')
def process_mailq(self):
"Process mailq"
sendto = url('mailq-status')
choices = session.get('queue_choices', [])
form = MailQueueProcessForm(request.POST, csrf_context=session)
form.id.choices = choices
if request.POST and form.validate() and choices:
queueids = form.id.data
if form.queue_action.data != '0':
hosts = {}
direction = None
queueitems = Session.query(MailQueueItem)\
.filter(MailQueueItem.id.in_(queueids))\
.all()
for item in queueitems:
if not item.hostname in hosts:
hosts[item.hostname] = []
if not direction:
direction = item.direction
hosts[item.hostname].append(item.messageid)
for hostname in hosts:
process_queued_msgs.apply_async(args=[hosts[hostname],
form.queue_action.data,
direction],
queue=hostname)
flash(_('The request has been queued for processing'))
session['queue_choices'] = []
session.save()
referer = request.headers.get('Referer', None)
if referer and '/mailq' in referer:
sendto = referer
redirect(sendto)
def adddestination(self, domainid):
"Add a destination server"
domain = self._get_domain(domainid)
if not domain:
abort(404)
c.id = domainid
c.form = AddDeliveryServerForm(request.POST, csrf_context=session)
if request.method == 'POST' and c.form.validate():
server = DeliveryServer()
server.from_form(c.form)
try:
create_destination(domain, server, c.user, request.host,
request.remote_addr)
flash(_('The destination server has been created'))
redirect(
url(controller='domains',
action='detail',
domainid=domain.id))
except IntegrityError:
Session.rollback()
msg = _('The destination server %(dest)s already exists ') % \
dict(dest=server.address)
flash_alert(msg)
log.info(msg)
return self.render('/domains/adddestination.html')
def domain_dkim_generate(self, domainid):
"Domain DKIM generate keys"
domain = self._get_domain(domainid)
if not domain:
abort(404)
pub_key, pri_key = make_key_pair()
if domain.dkimkeys:
dkimkeys = domain.dkimkeys[0]
else:
dkimkeys = DKIMKeys()
dkimkeys.pub_key = pub_key
dkimkeys.pri_key = pri_key
try:
if domain.dkimkeys:
domain.dkimkeys[0] = dkimkeys
else:
domain.dkimkeys.append(dkimkeys)
Session.add(dkimkeys)
Session.add(domain)
Session.commit()
info = DKIMGEN_MSG % dict(d=domain.name)
audit_log(c.user.username, 3, info, request.host,
request.remote_addr, now())
flash(_('DKIM keys successfully generated'))
except DatabaseError:
flash_alert(_('Generation of DKIM keys failed'))
redirect(url('domain-dkim', domainid=domain.id))
def editdestination(self, destinationid):
"Edit destination server"
server = self._get_server(destinationid)
if not server:
abort(404)
c.form = AddDeliveryServerForm(request.POST,
server,
csrf_context=session)
if request.method == 'POST' and c.form.validate():
kwd = dict(domainid=server.domain_id)
if update_if_changed(c.form, server):
try:
update_destination(server, c.user, request.host,
request.remote_addr)
self.invalidate = 1
self._get_server(destinationid)
kwd['uc'] = 1
flash(_('The destination server has been updated'))
redirect(url('domain-detail', **kwd))
except IntegrityError:
Session.rollback()
msg = _('The update failed')
flash_alert(msg)
log.info(msg)
else:
msg = _('No changes were made to the destination server')
flash_info(msg)
log.info(msg)
redirect(url('domain-detail', **kwd))
c.id = destinationid
c.domainid = server.domain_id
return self.render('/domains/editdestination.html')
def add_account_sigs(self, userid):
"Add account signature"
account = self._get_user(userid)
if not account:
abort(404)
c.form = SigForm(request.POST, csrf_context=session)
if request.POST and c.form.validate():
try:
sig = UserSignature()
for field in c.form:
if field.name != 'csrf_token':
setattr(sig, field.name, field.data)
account.signatures.append(sig)
Session.add(sig)
Session.add(account)
Session.commit()
save_user_sig.apply_async(args=[sig.id], queue='msbackend')
info = ADDACCSIG_MSG % dict(u=account.username)
audit_log(c.user.username, 3, info, request.host,
request.remote_addr, now())
flash(_('The signature has been created'))
redirect(url('account-detail', userid=userid))
except IntegrityError:
Session.rollback()
flash(_('This signature type already exists'))
c.account = account
return render('/settings/account_addsig.html')
def add_auth(self, domainid):
"Add auth server"
domain = self._get_domain(domainid)
if not domain:
abort(404)
c.form = AddAuthForm(request.POST, csrf_context=session)
if request.method == 'POST' and c.form.validate():
server = AuthServer()
server.from_form(c.form)
try:
create_auth(domain, server, c.user, request.host,
request.remote_addr)
flash(_('The authentication settings have been created'))
redirect(
url(controller='domains',
action='detail',
domainid=domain.id))
except IntegrityError:
Session.rollback()
auth = dict(AUTH_PROTOCOLS)[str(server.protocol)]
msg = _('The host %(dest)s already configured for %(auth)s '
'authentication for this domain') % \
dict(dest=server.address, auth=auth)
flash_alert(msg)
log.info(msg)
c.domainid = domainid
c.domainname = domain.name
return self.render('/domains/addauth.html')
def adddestination(self, domainid):
"Add a destination server"
domain = self._get_domain(domainid)
if not domain:
abort(404)
c.form = AddDeliveryServerForm(request.POST, csrf_context=session)
c.id = domainid
if request.POST and c.form.validate():
server = DeliveryServer()
for field in c.form:
if field.name != 'csrf_token':
setattr(server, field.name, field.data)
try:
domain.servers.append(server)
Session.add(server)
Session.add(domain)
Session.commit()
info = ADDDELSVR_MSG % dict(d=domain.name, ds=server.address)
audit_log(c.user.username, 3, info, request.host,
request.remote_addr, now())
flash(_('The destination server has been created'))
redirect(
url(controller='domains',
action='detail',
domainid=domain.id))
except IntegrityError:
Session.rollback()
flash_alert(
_('The destination server %(dest)s already exists ') %
dict(dest=server.address))
return render('/domains/adddestination.html')
def edit_auth(self, authid):
"Edit auth server"
server = self._get_authserver(authid)
if not server:
abort(404)
c.form = AddAuthForm(request.POST, server, csrf_context=session)
if request.method == 'POST' and c.form.validate():
kwd = dict(domainid=server.domain_id)
if auth_update_if_changed(c.form, server):
try:
edit_auth(server, c.user, request.host,
request.remote_addr)
flash(_('The authentication settings have been updated'))
self.invalidate = 1
self._get_authserver(authid)
kwd['uc'] = 1
redirect(url('domain-detail', **kwd))
except IntegrityError:
Session.rollback()
msg = _('The authentication settings update failed')
flash_alert(msg)
log.info(msg)
else:
msg = _('No changes were made to the authentication settings')
flash_info(msg)
log.info(msg)
redirect(url('domain-detail', **kwd))
c.domainid = server.domains.id
c.domainname = server.domains.name
c.authid = authid
return self.render('/domains/editauth.html')
def add_auth(self, domainid):
"Add auth server"
domain = self._get_domain(domainid)
if not domain:
abort(404)
c.form = AddAuthForm(request.POST, csrf_context=session)
if request.POST and c.form.validate():
server = AuthServer()
for field in c.form:
if field.data and field.name != 'csrf_token':
setattr(server, field.name, field.data)
try:
domain.authservers.append(server)
Session.add(server)
Session.add(domain)
Session.commit()
info = ADDAUTHSVR_MSG % dict(d=domain.name, ds=server.address)
audit_log(c.user.username, 3, info, request.host,
request.remote_addr, now())
flash(_('The authentication settings have been created'))
redirect(
url(controller='domains',
action='detail',
domainid=domain.id))
except IntegrityError:
Session.rollback()
auth = dict(AUTH_PROTOCOLS)[str(server.protocol)]
flash_alert(
_('The host %(dest)s already configured for %(auth)s '
'authentication for this domain') %
dict(dest=server.address, auth=auth))
c.domainid = domainid
c.domainname = domain.name
return render('/domains/addauth.html')
def addalias(self, domainid):
"Add alias domain"
domain = self._get_domain(domainid)
if not domain:
abort(404)
c.form = AddDomainAlias(request.POST, csrf_context=session)
c.form.domain.query = Session.query(Domain)\
.filter(Domain.id == domainid)
if request.method == 'POST' and c.form.validate():
alias = DomainAlias()
alias.from_form(c.form)
try:
create_alias(domain, alias, c.user, request.host,
request.remote_addr)
flash(_('The domain alias: %s has been created') % alias.name)
redirect(
url(controller='domains',
action='detail',
domainid=domain.id))
except IntegrityError:
Session.rollback()
msg = _('The domain alias: %s already exists') % alias.name
flash_alert(msg)
log.info(msg)
c.domainid = domain.id
c.domainname = domain.name
return self.render('/domains/addalias.html')
def deletealias(self, aliasid):
"Delete alias domain"
alias = self._get_alias(aliasid)
if not alias:
abort(404)
c.form = AddDomainAlias(request.POST, alias, csrf_context=session)
c.form.domain.query = Session.query(Domain)\
.filter(Domain.id==alias.domain_id)
if request.POST and c.form.validate():
domainid = alias.domain_id
aliasname = alias.name
Session.delete(alias)
Session.commit()
update_serial.delay()
info = DELETEDOMALIAS_MSG % dict(d=aliasname)
audit_log(c.user.username, 4, info, request.host,
request.remote_addr, now())
flash(_('The domain alias: %s has been deleted') % aliasname)
redirect(url('domain-detail', domainid=domainid))
c.aliasid = aliasid
c.domainid = alias.domain_id
c.domainname = alias.domain.name
return render('/domains/deletealias.html')
def editalias(self, aliasid):
"Edit alias domain"
alias = self._get_alias(aliasid)
if not alias:
abort(404)
c.form = EditDomainAlias(request.POST, alias, csrf_context=session)
c.form.domain.query = Session.query(Domain)\
.filter(Domain.id == alias.domain_id)
if request.method == 'POST' and c.form.validate():
if update_if_changed(c.form, alias):
try:
edit_alias(alias, c.user, request.host,
request.remote_addr)
flash(
_('The domain alias: %s has been updated') %
alias.name)
redirect(url('domain-detail', domainid=alias.domain_id))
except IntegrityError:
Session.rollback()
msg = _('The update failed')
flash_alert(msg)
log.info(msg)
else:
msg = _('No changes were made to the domain alias')
flash_info(msg)
log.info(msg)
redirect(url('domain-detail', domainid=alias.domain_id))
c.aliasid = aliasid
c.domainid = alias.domain_id
c.domainname = alias.domain.name
return self.render('/domains/editalias.html')
def delete(self, userid):
"""/accounts/delete/id"""
user = self._get_user(userid)
if not user:
abort(404)
c.form = EditUserForm(request.POST, user, csrf_context=session)
del c.form.domains
if request.POST and c.form.validate():
username = user.username
user_id = unicode(user.id)
Session.delete(user)
Session.commit()
update_serial.delay()
flash(_('The account has been deleted'))
info = DELETEACCOUNT_MSG % dict(u=username)
audit_log(c.user.username,
4, unicode(info), request.host,
request.remote_addr, now())
if userid == user_id:
redirect(url('/logout'))
redirect(url(controller='accounts', action='index'))
else:
flash_info(_('The account: %(a)s and all associated data'
' will be deleted, This action is not reversible.') %
dict(a=user.username))
c.fields = FORM_FIELDS
c.id = userid
return render('/accounts/delete.html')
def pwchange(self, userid):
"""Reset a user password"""
user = self._get_user(userid)
if not user:
abort(404)
c.form = ChangePasswordForm(request.POST, csrf_context=session)
if request.POST and c.form.validate():
if user.local:
user.set_password(c.form.password1.data)
Session.add(user)
Session.commit()
flash(
_('The account password for %(name)s has been reset') %
dict(name=user.username))
info = PASSWORDCHANGE_MSG % dict(u=user.username)
audit_log(c.user.username, 2, info, request.host,
request.remote_addr, now())
else:
flash(
_('This is an external account, use'
' external system to reset the password'))
redirect(url('account-detail', userid=user.id))
c.id = userid
c.username = user.username
c.posturl = 'accounts-pw-change'
return render('/accounts/pwchange.html')
def addaddress(self, userid):
"Add address"
user = self._get_user(userid)
if not user:
abort(404)
c.form = AddressForm(request.POST, csrf_context=session)
if request.method == 'POST' and c.form.validate():
try:
addr = create_address(c.form, user, c.user, request.host,
request.remote_addr)
flash(
_('The alias address %(address)s was successfully created.'
% dict(address=addr.address)))
except IntegrityError:
Session.rollback()
msg = _('The address %(addr)s already exists') % \
dict(addr=c.form.address.data)
flash_alert(msg)
log.info(msg)
except NoResultFound:
domain = c.form.address.data.split('@')[1]
msg = _('Domain: %(d)s does not belong to you') % \
dict(d=domain)
flash(msg)
log.info(msg)
redirect(url(controller='accounts', action='detail',
userid=userid))
c.id = userid
return self.render('/accounts/addaddress.html')
def upwchange(self, userid):
"""User change own password"""
user = self._get_user(userid)
if not user:
abort(404)
if user.id != c.user.id or c.user.is_superadmin:
abort(403)
c.form = UserPasswordForm(request.POST, csrf_context=session)
if (request.POST and c.form.validate()
and user.validate_password(c.form.password3.data)):
if user.local:
user.set_password(c.form.password1.data)
Session.add(user)
Session.commit()
flash(
_('The account password for %(name)s has been reset') %
dict(name=user.username))
info = PASSWORDCHANGE_MSG % dict(u=user.username)
audit_log(c.user.username, 2, info, request.host,
request.remote_addr, now())
else:
flash(
_('This is an external account, use'
' external system to reset the password'))
redirect(url('account-detail', userid=user.id))
elif (request.POST
and not user.validate_password(c.form.password3.data)
and not c.form.password3.errors):
flash_alert(
_('The old password supplied does'
' not match our records'))
c.id = userid
c.username = user.username
c.posturl = 'accounts-pw-uchange'
return render('/accounts/pwchange.html')
def export_status(self, taskid):
"export status"
result = AsyncResult(taskid)
if result is None or taskid not in session['taskids']:
msg = _('The task status requested has expired or does not exist')
flash(msg)
log.info(msg)
redirect(url(controller='accounts', action='index'))
if result.ready():
finished = True
flash.pop_messages()
if isinstance(result.result, Exception):
msg = _('Error occured in processing %s') % result.result
if c.user.is_superadmin:
flash_alert(msg)
log.info(msg)
else:
flash_alert(_('Backend error occured during processing.'))
log.info(msg)
redirect(url(controller='accounts', action='index'))
results = dict(
f=True if not result.result['global_error'] else False,
id=taskid,
global_error=result.result['global_error'])
audit_log(c.user.username, 5, unicode(auditmsgs.ACCOUNTEXPORT_MSG),
request.host, request.remote_addr,
arrow.utcnow().datetime)
else:
try:
session['acexport-count'] += 1
except KeyError:
session['acexport-count'] = 1
session.save()
if (session['acexport-count'] >= 10
and result.state in ['PENDING', 'RETRY', 'FAILURE']):
result.revoke()
del session['acexport-count']
session.save()
msg = _('The export could not be processed, try again later')
flash_alert(msg)
log.info(msg)
redirect(url(controller='accounts', action='index'))
finished = False
results = dict(f=None, global_error=None)
c.finished = finished
c.results = results
c.success = result.successful()
dwn = request.GET.get('d', None)
if finished and (dwn and dwn == 'y'):
response.content_type = 'text/csv'
response.headers['Cache-Control'] = 'max-age=0'
csvdata = result.result['f']
disposition = 'attachment; filename=accounts-export-%s.csv' % \
taskid
response.headers['Content-Disposition'] = str(disposition)
response.headers['Content-Length'] = len(csvdata)
return csvdata
return self.render('/accounts/exportstatus.html')
def add_auth(self, domainid):
"Add auth server"
domain = self._get_domain(domainid)
if not domain:
abort(404)
c.form = AddAuthForm(request.POST, csrf_context=session)
if request.method == 'POST' and c.form.validate():
server = AuthServer()
server.from_form(c.form)
try:
create_auth(domain, server, c.user,
request.host, request.remote_addr)
flash(_('The authentication settings have been created'))
redirect(url(controller='domains', action='detail',
domainid=domain.id))
except IntegrityError:
Session.rollback()
auth = dict(AUTH_PROTOCOLS)[str(server.protocol)]
msg = _('The host %(dest)s already configured for %(auth)s '
'authentication for this domain') % \
dict(dest=server.address, auth=auth)
flash_alert(msg)
log.info(msg)
c.domainid = domainid
c.domainname = domain.name
return self.render('/domains/addauth.html')
