def import_editors_and_groups(request, app):
request.locale = locale
headers = {
'group': request.translate(_("Group")),
'name': request.translate(_("Name")),
'email': request.translate(_("E-Mail"))
}
session = app.session()
users = UserCollection(session)
groups = UserGroupCollection(session)
if clear:
click.secho("Deleting all editors", fg='yellow')
for user in users.query().filter(User.role == 'member'):
session.delete(user)
click.secho("Deleting all groups", fg='yellow')
for group in groups.query():
session.delete(group)
csvfile = convert_xls_to_csv(
file, sheet_name=request.translate(_("Editors"))
)
csv = CSVFile(csvfile, expected_headers=headers.values())
lines = list(csv.lines)
columns = {
key: csv.as_valid_identifier(value)
for key, value in headers.items()
}
added_groups = {}
for group in set([line.gruppe for line in lines]):
added_groups[group] = groups.add(name=group)
count = len(added_groups)
click.secho(f"{count} group(s) imported", fg='green')
count = 0
for line in lines:
count += 1
email = getattr(line, columns['email'])
realname = getattr(line, columns['name'])
group = getattr(line, columns['group'])
group = added_groups[group] if group else None
users.add(
username=email,
realname=realname,
group=group,
password=random_password(),
role='member',
)
click.secho(f"{count} editor(s) imported", fg='green')
if dry_run:
transaction.abort()
click.secho("Aborting transaction", fg='yellow')
def recipients_pool(self):
users = UserCollection(self.request.session)
users = users.query()
if self.state.data == ['active']:
users = users.filter(User.active == True)
elif self.state.data == ['inactive']:
users = users.filter(User.active == False)
elif self.state.data != ['active', 'inactive']:
return set()
return {u.username for u in users.with_entities(User.username)}
def add_town(self, name, user, color, request):
current_schema = self.app.session_manager.current_schema
password = random_password(16)
try:
schema = self.get_schema(name)
custom_config = self.config['configuration']
self.app.session_manager.set_current_schema(schema)
session = self.app.session_manager.session()
if session.query(Organisation).first():
raise AlreadyExistsError
with self.app.temporary_depot(schema, **custom_config):
create_new_organisation(self.app, name=name, reply_to=user)
org = session.query(Organisation).first()
org.theme_options['primary-color'] = color
users = UserCollection(self.app.session_manager.session())
assert not users.query().first()
users.add(user, password, 'admin')
title = request.translate(_("Welcome to OneGov Cloud"))
welcome_mail = render_template(
'mail_welcome.pt', request, {
'url': 'https://{}'.format(self.get_domain(name)),
'mail': user,
'layout': MailLayout(self, request),
'title': title,
'org': name
})
self.app.es_perform_reindex()
self.app.send_transactional_email(subject=title,
receivers=(user, ),
content=welcome_mail,
reply_to='*****@*****.**')
finally:
self.app.session_manager.set_current_schema(current_schema)
return {
'info': [
(_("Username"), user),
(_("Password"), password),
],
'url': 'https://{}'.format(self.get_domain(name))
}
def add_town(self, name, user, color, request):
current_schema = self.app.session_manager.current_schema
password = random_password(16)
try:
self.app.session_manager.set_current_schema(self.get_schema(name))
session = self.app.session_manager.session()
if session.query(Organisation).first():
raise AlreadyExistsError
create_new_organisation(self.app, name=name, reply_to=user)
org = session.query(Organisation).first()
org.theme_options['primary-color'] = color
users = UserCollection(self.app.session_manager.session())
assert not users.query().first()
users.add(user, password, 'admin')
title = request.translate(_("Welcome to OneGov Cloud"))
welcome_mail = render_template('mail_welcome.pt', request, {
'url': 'https://{}'.format(self.get_domain(name)),
'mail': user,
'layout': MailLayout(self, request),
'title': title,
'org': name
})
self.app.send_email(
subject=title,
receivers=(user, ),
content=welcome_mail,
reply_to='*****@*****.**'
)
finally:
self.app.session_manager.set_current_schema(current_schema)
return {
'info': [
(_("Username"), user),
(_("Password"), password),
],
'url': 'https://{}'.format(self.get_domain(name))
}
def view_billing_import(self, request, form):
uploaded = 'account-statement' in request.browser_session
if form.submitted(request):
request.browser_session['account-statement'] = {
'invoice': form.period.data,
'data': form.xml.data['data']
}
uploaded = True
elif not request.POST and uploaded:
del request.browser_session['account-statement']
uploaded = False
if uploaded:
cache = request.browser_session['account-statement']
binary = BytesIO(b64decode(cache['data']))
xml = GzipFile(filename='', mode='r', fileobj=binary).read()
xml = xml.decode('utf-8')
transactions = list(
match_iso_20022_to_usernames(xml,
request.session,
period_id=cache['invoice']))
if not transactions:
del request.browser_session['account-statement']
request.alert(_("No transactions were found in the given file"))
uploaded = False
form.xml.data = None
else:
transactions.sort(key=lambda t: t.order)
else:
transactions = None
users = UserCollection(request.session)
users = {
u.username: (u.realname or u.username)
for u in users.query().with_entities(User.username, User.realname)
}
layout = BillingCollectionImportLayout(self, request)
return {
'layout':
layout,
'title':
_("Import Bank Statement"),
'form':
form if not uploaded else None,
'button_text':
_("Preview"),
'transactions':
transactions,
'uploaded':
uploaded,
'users':
users,
'user_link':
lambda u: request.class_link(InvoiceCollection, {'username': u}),
'success_count':
transactions and sum(1 for t in transactions if t.state == 'success'),
'model':
self,
'post_url':
layout.csrf_protected_url(request.link(self, 'execute-import'))
}
def test_notice_collection_query_deleted_user(session):
groups = UserGroupCollection(session)
group_a = groups.add(name="Group A")
group_b = groups.add(name="Group B")
users = UserCollection(session)
user_a = users.add(realname="User A",
username='******',
password='******',
role='admin',
group=group_a)
user_b = users.add(realname="User B",
username='******',
password='******',
role='admin',
group=group_b)
notices = GazetteNoticeCollection(session)
notice_a = notices.add(title='A',
text='Text',
organization_id='100',
category_id='11',
issues=['2017-46'],
user=user_a)
notice_b = notices.add(title='B',
text='Text',
organization_id='100',
category_id='11',
issues=['2017-46'],
user=user_b)
assert notices.query().count() == 2
assert notice_a.user is not None
assert notice_b.user is not None
assert notice_a.group is not None
assert notice_b.group is not None
assert notices.for_term("User A").query().one() == notice_a
assert notices.for_term("User B").query().one() == notice_b
assert notices.for_term("Group A").query().one() == notice_a
assert notices.for_term("Group B").query().one() == notice_b
users.delete(user_a.username)
users.delete(user_b.username)
groups.delete(group_a)
groups.delete(group_b)
commit()
assert users.query().count() == 0
assert groups.query().count() == 0
notice_a = notices.query().filter(GazetteNotice.title == 'A').one()
notice_b = notices.query().filter(GazetteNotice.title == 'B').one()
assert notice_a.user is None
assert notice_b.user is None
assert notice_a.group is None
assert notice_b.group is None
assert notices.query().count() == 2
assert notices.for_term("User A").query().one() == notice_a
assert notices.for_term("User B").query().one() == notice_b
assert notices.for_term("Group A").query().one() == notice_a
assert notices.for_term("Group B").query().one() == notice_b
