def process_aux(row, domainid):
"process auxillary domain data"
try:
session_dict = {}
token = make_csrf(session_dict)
# domain alias
fields = getkeys(row, 'da')
post_data = dict2mdict(fields)
post_data.add('domain', str(domainid))
post_data.add('csrf_token', token)
form = AddDomainAlias(post_data, csrf_context=session_dict)
qry = Session.query(Domain).filter(Domain.id == domainid)
form.domain.query = qry
if form.validate():
mod = DomainAlias()
savemodel(mod, form)
# delivery server
fields = getkeys(row, 'ds')
post_data = dict2mdict(fields)
post_data.add('csrf_token', token)
form = AddDeliveryServerForm(post_data, csrf_context=session_dict)
if form.validate():
mod = DeliveryServer()
savemodel(mod, form, domainid)
# authentication server
fields = getkeys(row, 'as')
post_data = dict2mdict(fields)
post_data.add('csrf_token', token)
form = AddAuthForm(post_data, csrf_context=session_dict)
if form.validate():
mod = AuthServer()
savemodel(mod, form, domainid)
except TypeError:
pass
def process_aux(row, domainid):
"process auxillary domain data"
try:
session_dict = {}
token = make_csrf(session_dict)
# domain alias
fields = getkeys(row, 'da')
post_data = dict2mdict(fields)
post_data.add('domain', str(domainid))
post_data.add('csrf_token', token)
form = AddDomainAlias(post_data, csrf_context=session_dict)
qry = Session.query(Domain).filter(Domain.id == domainid)
form.domain.query = qry
if form.validate():
mod = DomainAlias()
savemodel(mod, form)
# delivery server
fields = getkeys(row, 'ds')
post_data = dict2mdict(fields)
post_data.add('csrf_token', token)
form = AddDeliveryServerForm(post_data, csrf_context=session_dict)
if form.validate():
mod = DeliveryServer()
savemodel(mod, form, domainid)
# authentication server
fields = getkeys(row, 'as')
post_data = dict2mdict(fields)
post_data.add('csrf_token', token)
form = AddAuthForm(post_data, csrf_context=session_dict)
if form.validate():
mod = AuthServer()
savemodel(mod, form, domainid)
except TypeError:
pass
def add_address(row, user, requester):
"Add address"
session_dict = {}
token = make_csrf(session_dict)
fields = getkeys(row, 'af')
post_data = dict2mdict(fields)
post_data.add('csrf_token', token)
form = AddressForm(post_data, csrf_context=session_dict)
if form.validate():
try:
if requester.is_domain_admin:
# check if they own the domain
domainname = form.address.data.split('@')[1]
Session.query(Domain).options(
joinedload('organizations')).join(
domain_owners,
(oa, domain_owners.c.organization_id ==
oa.c.organization_id))\
.filter(oa.c.user_id == user.id)\
.filter(Domain.name == domainname).one()
addr = Address(address=form.address.data)
addr.enabled = form.enabled.data
addr.user = user
Session.add(addr)
Session.commit()
except (IntegrityError, NoResultFound):
pass
def add_address(row, user, requester):
"Add address"
session_dict = {}
token = make_csrf(session_dict)
fields = getkeys(row, 'af')
post_data = dict2mdict(fields)
post_data.add('csrf_token', token)
form = AddressForm(post_data, csrf_context=session_dict)
if form.validate():
try:
if requester.is_domain_admin:
# check if they own the domain
domainname = form.address.data.split('@')[1]
Session.query(Domain).options(
joinedload('organizations')).join(
domain_owners,
(oa, domain_owners.c.organization_id ==
oa.c.organization_id))\
.filter(oa.c.user_id == user.id)\
.filter(Domain.name == domainname).one()
addr = Address(address=form.address.data)
addr.enabled = form.enabled.data
addr.user = user
Session.add(addr)
Session.commit()
except (IntegrityError, NoResultFound):
pass
def importdomains(orgid, filename, skipfirst):
"Import domains"
logger = importdomains.get_logger()
results = dict(rows=[], global_error=[])
keys = tuple(DOMAINFIELDS + DAFIELDS + DSFIELDS + ASFIELDS)
translator = _get_translator(None)
pylons.translator._push_object(translator)
try:
with open(filename, 'rU') as handle:
dialect = csv.Sniffer().sniff(handle.read(1024))
handle.seek(0)
rows = csv.DictReader(handle, fieldnames=keys, dialect=dialect)
query = Session.query(Group).filter(Group.id == orgid)
org = query.one()
logger.info("Importing domains from file: %s for: %s" %
(filename, org.name))
try:
count = 1
for row in rows:
if skipfirst and (count == 1):
count += 1
continue
result = dict(id=None,
name=row['name'],
imported=False,
error=None)
try:
session_dict = {}
token = make_csrf(session_dict)
fields = getkeys(row)
post_data = dict2mdict(fields)
post_data.add('csrf_token', token)
form = AddDomainForm(post_data,
csrf_context=session_dict)
form.organizations.query = query
if form.validate():
# insert to db
domain = Domain()
for field in form:
if field.name != 'csrf_token':
setattr(domain, field.name, field.data)
domain.organizations.append(org)
Session.add(domain)
Session.commit()
result['id'] = domain.id
result['imported'] = True
logger.info("Imported domain: %s" % row['name'])
# process other data
process_aux(row, domain.id)
else:
logger.info("Import failed domain: %s" %
row['name'])
if isinstance(form.errors, dict):
errors = []
for field in form.errors:
themsg = u'%s: %s' % (field,
unicode(form.errors[field][0]))
errors.append(themsg)
result['error'] = u', '.join(errors)
else:
result['error'] = form.errors
except TypeError, err:
logger.info("Import failed domain: %s" % row['name'])
result['error'] = str(err)
except IntegrityError, err:
Session.rollback()
logger.info("Import failed domain: %s" % row['name'])
result['error'] = 'Domain already exists'
finally:
count += 1
results['rows'].append(result)
def importdomains(orgid, filename, skipfirst):
"Import domains"
logger = importdomains.get_logger()
results = dict(rows=[], global_error=[])
keys = tuple(DOMAINFIELDS + DAFIELDS + DSFIELDS + ASFIELDS)
translator = _get_translator(None)
pylons.translator._push_object(translator)
try:
with open(filename, 'rU') as handle:
dialect = csv.Sniffer().sniff(handle.read(1024))
handle.seek(0)
rows = csv.DictReader(handle, fieldnames=keys, dialect=dialect)
query = Session.query(Group).filter(Group.id == orgid)
org = query.one()
logger.info("Importing domains from file: %s for: %s" %
(filename, org.name))
try:
count = 1
for row in rows:
if skipfirst and (count == 1):
count += 1
continue
result = dict(id=None,
name=row['name'],
imported=False,
error=None)
try:
session_dict = {}
token = make_csrf(session_dict)
fields = getkeys(row)
post_data = dict2mdict(fields)
post_data.add('csrf_token', token)
form = AddDomainForm(post_data,
csrf_context=session_dict)
form.organizations.query = query
if form.validate():
# insert to db
domain = Domain()
for field in form:
if field.name != 'csrf_token':
setattr(domain, field.name, field.data)
domain.organizations.append(org)
Session.add(domain)
Session.commit()
result['id'] = domain.id
result['imported'] = True
logger.info("Imported domain: %s" % row['name'])
# process other data
process_aux(row, domain.id)
else:
logger.info("Import failed domain: %s" %
row['name'])
if isinstance(form.errors, dict):
errors = []
for field in form.errors:
themsg = u'%s: %s' % (
field, unicode(form.errors[field][0]))
errors.append(themsg)
result['error'] = u', '.join(errors)
else:
result['error'] = form.errors
except TypeError, err:
logger.info("Import failed domain: %s" % row['name'])
result['error'] = str(err)
except IntegrityError, err:
Session.rollback()
logger.info("Import failed domain: %s" % row['name'])
result['error'] = 'Domain already exists'
finally:
count += 1
results['rows'].append(result)
def importaccounts(domid, filename, skipfirst, userid):
"import accounts"
logger = importaccounts.get_logger()
results = dict(rows=[], global_error=[])
keys = tuple(ACCOUNTFIELDS + ADDRESSFIELDS)
translator = _get_translator(None)
pylons.translator._push_object(translator)
try:
with open(filename, 'rU') as handle:
dialect = csv.Sniffer().sniff(handle.read(1024))
handle.seek(0)
rows = csv.DictReader(handle, fieldnames=keys, dialect=dialect)
query = Session.query(Domain).filter(Domain.id == domid)
domain = query.one()
requester = Session.query(User).get(userid)
logger.info("Importing accounts from file: %s for: %s" %
(filename, domain.name))
try:
count = 1
for row in rows:
if skipfirst and (count == 1):
count += 1
continue
result = dict(id=None,
username=row['username'],
imported=False,
error=None)
try:
session_dict = {}
token = make_csrf(session_dict)
fields = getkeys(row)
post_data = dict2mdict(fields)
post_data.add('password2', row['password1'])
post_data.add('domains', domid)
post_data.add('csrf_token', token)
form = AddUserForm(post_data,
csrf_context=session_dict)
form.domains.query = query
if form.validate():
# db insert
if domain.name != form.email.data.split('@')[1]:
raise TypeError(
'Cannot import: %s into domain: %s' %
(form.email.data, domain.name))
user = User(form.username.data, form.email.data)
for attr in ['firstname', 'lastname', 'email',
'active', 'account_type', 'send_report',
'spam_checks', 'low_score', 'high_score',
'timezone']:
setattr(user, attr, getattr(form, attr).data)
user.local = True
user.set_password(form.password1.data)
if user.is_peleb:
user.domains = [domain]
Session.add(user)
Session.commit()
result['id'] = user.id
result['imported'] = True
logger.info("Imported account: %s" %
row['username'])
# address add
add_address(row, user, requester)
else:
logger.info("Import failed account: %s" %
row['username'])
if isinstance(form.errors, dict):
errors = []
for field in form.errors:
themsg = u'%s: %s' % (field,
unicode(form.errors[field][0]))
errors.append(themsg)
result['error'] = u', '.join(errors)
else:
result['error'] = form.errors
except TypeError, err:
logger.info("Import failed account: %s" %
row['username'])
result['error'] = str(err)
except IntegrityError, err:
Session.rollback()
logger.info("Import failed account: %s" %
row['username'])
result['error'] = 'Account already exists'
finally:
count += 1
results['rows'].append(result)
def importaccounts(domid, filename, skipfirst, userid):
"import accounts"
logger = importaccounts.get_logger()
results = dict(rows=[], global_error=[])
keys = tuple(ACCOUNTFIELDS + ADDRESSFIELDS)
translator = _get_translator(None)
pylons.translator._push_object(translator)
try:
with open(filename, 'rU') as handle:
dialect = csv.Sniffer().sniff(handle.read(1024))
handle.seek(0)
rows = csv.DictReader(handle, fieldnames=keys, dialect=dialect)
query = Session.query(Domain).filter(Domain.id == domid)
domain = query.one()
requester = Session.query(User).get(userid)
logger.info("Importing accounts from file: %s for: %s" %
(filename, domain.name))
try:
count = 1
for row in rows:
if skipfirst and (count == 1):
count += 1
continue
result = dict(id=None,
username=row['username'],
imported=False,
error=None)
try:
session_dict = {}
token = make_csrf(session_dict)
fields = getkeys(row)
post_data = dict2mdict(fields)
post_data.add('password2', row['password1'])
post_data.add('domains', domid)
post_data.add('csrf_token', token)
form = AddUserForm(post_data,
csrf_context=session_dict)
form.domains.query = query
if form.validate():
# db insert
if domain.name != form.email.data.split('@')[1]:
raise TypeError(
'Cannot import: %s into domain: %s' %
(form.email.data, domain.name))
user = User(form.username.data, form.email.data)
for attr in [
'firstname', 'lastname', 'email', 'active',
'account_type', 'send_report',
'spam_checks', 'low_score', 'high_score',
'timezone'
]:
setattr(user, attr, getattr(form, attr).data)
user.local = True
user.set_password(form.password1.data)
if user.is_peleb:
user.domains = [domain]
Session.add(user)
Session.commit()
result['id'] = user.id
result['imported'] = True
logger.info("Imported account: %s" %
row['username'])
# address add
add_address(row, user, requester)
else:
logger.info("Import failed account: %s" %
row['username'])
if isinstance(form.errors, dict):
errors = []
for field in form.errors:
themsg = u'%s: %s' % (
field, unicode(form.errors[field][0]))
errors.append(themsg)
result['error'] = u', '.join(errors)
else:
result['error'] = form.errors
except TypeError, err:
logger.info("Import failed account: %s" %
row['username'])
result['error'] = str(err)
except IntegrityError, err:
Session.rollback()
logger.info("Import failed account: %s" %
row['username'])
result['error'] = 'Account already exists'
finally:
count += 1
results['rows'].append(result)
