def test_notice_collection_own_user_id(session):
users = UserCollection(session)
user_a = users.add(username='******', password='******', role='admin')
user_b = users.add(username='******', password='******', role='admin')
user_c = users.add(username='******', password='******', role='admin')
collection = GazetteNoticeCollection(session)
for title, user, annotators in (
('A', user_a, []),
('B', user_b, [user_a]),
('C', user_c, [user_a, user_b]),
):
notice = collection.add(title=title,
text='Text',
organization_id='100',
category_id='11',
issues=['2017-46'],
user=user)
for annotator in annotators:
notice.changes.append(
GazetteNoticeChange(
channel_id=str(notice.id),
owner=str(annotator.id),
))
assert collection.query().count() == 3
collection.own_user_id = str(user_a.id)
assert collection.query().count() == 3
collection.own_user_id = str(user_b.id)
assert collection.query().count() == 2
collection.own_user_id = str(user_c.id)
assert collection.query().count() == 1
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 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 test_notice_change(session):
users = UserCollection(session)
session.add(GazetteNoticeChange(text='text', channel_id='channel'))
session.flush()
change = session.query(GazetteNoticeChange).one()
assert change.text == 'text'
assert change.channel_id == 'channel'
assert change.user is None
assert change.user_name is None
assert change._user_name is None
assert change.notice is None
assert change.event is None
# Add user
change.event = 'event'
user = users.add('*****@*****.**', 'test', 'editor')
change.user = user
session.flush()
session.refresh(change)
assert change.text == 'text'
assert change.channel_id == 'channel'
assert change.user == user
assert change.user_name == '*****@*****.**'
assert change._user_name == '*****@*****.**'
assert change.notice is None
assert change.event == 'event'
assert user.changes == [change]
# Add to notice
session.add(GazetteNotice(state='drafted', title='title', name='notice'))
session.flush()
notice = session.query(GazetteNotice).one()
change.notice = notice
assert notice.changes.one() == change
# Rename user
user.realname = 'Peter'
session.flush()
session.refresh(change)
assert change.user == user
assert change.user_name == 'Peter'
assert change._user_name == 'Peter'
assert user.changes == [change]
# Delete user
users.delete(user.username)
session.flush()
session.refresh(change)
assert change.user is None
assert change.user_name == '(Peter)'
assert change._user_name == 'Peter'
def test_vacation_activity_form(session, test_password):
users = UserCollection(session)
users.add(username='******',
realname='Robert Baratheon',
password='******',
role='admin')
users.add(username='******',
realname=None,
password='******',
role='editor')
users.add(username='******',
realname=None,
password='******',
role='member')
form = VacationActivityForm()
form.request = Bunch(is_admin=True,
current_username='******',
session=session)
form.on_request()
assert form.username.data == '*****@*****.**'
assert form.username.choices == [('*****@*****.**',
'*****@*****.**'),
('*****@*****.**', 'Robert Baratheon')]
form.request.is_admin = False
form.on_request()
assert form.username is None
def test_notice_ownership(session):
users = UserCollection(session)
groups = UserGroupCollection(session)
user = users.add('[email protected]', '1234', 'admin', realname='user')
group = groups.add(name='group')
notice = OfficialNotice(
title='title',
state='drafted',
text='Text',
)
notice.user = user
notice.group = group
session.add(notice)
session.flush()
notice = session.query(OfficialNotice).one()
notice.user == user
notice.user.realname == 'user'
notice.group == group
notice.group.name == 'group'
def test_notice_collection_on_request(session):
collection = GazetteNoticeCollection(session)
collection.on_request(DummyRequest(None))
assert collection.own_user_id is None
collection.own = True
collection.on_request(DummyRequest(None))
assert collection.own_user_id is None
collection.on_request(DummyRequest(None, DummyIdentity(None)))
assert collection.own_user_id is None
collection.on_request(DummyRequest(None, DummyIdentity('[email protected]')))
assert collection.own_user_id is None
users = UserCollection(session)
user = users.add(username='******', password='******', role='admin')
collection.on_request(DummyRequest(None, DummyIdentity('[email protected]')))
assert collection.own_user_id == str(user.id)
def test_notice_collection_count_by_group(session):
collection = GazetteNoticeCollection(session)
assert collection.count_by_group() == []
groups = UserGroupCollection(session)
group_a = groups.add(name='A')
group_b = groups.add(name='B')
groups.add(name='C')
users = UserCollection(session)
user_a = users.add('*****@*****.**', 'pw', 'editor', group=group_a)
user_b = users.add('*****@*****.**', 'pw', 'editor', group=group_a)
user_c = users.add('*****@*****.**', 'pw', 'admin')
user_d = users.add('*****@*****.**', 'pw', 'publisher')
user_e = users.add('*****@*****.**', 'pw', 'publisher', group=group_b)
user_f = users.add('*****@*****.**', 'pw', 'publisher')
user_g = users.add('*****@*****.**', 'pw', 'publisher')
user_h = users.add('*****@*****.**', 'pw', 'publisher')
for user, count in (
(user_a, 2),
(user_b, 4),
(user_c, 1),
(user_d, 7),
(user_e, 2),
(user_f, 3),
(user_g, 6),
(user_h, 2),
):
for x in range(count):
collection.add(title='',
text='',
organization_id='',
category_id='',
issues=['2017-{}'.format(y) for y in range(x)],
user=user)
assert collection.count_by_group() == [('A', 7), ('B', 1)]
assert collection.count_by_group() == \
collection.for_state('drafted').count_by_group()
collection.issues = ['2017-2', '2017-4']
assert collection.count_by_group() == [('A', 1)]
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
def test_notice_collection_search(session):
groups = UserGroupCollection(session)
group_a = groups.add(name='GroupA')
group_b = groups.add(name='GroupB1')
users = UserCollection(session)
user_a = users.add('*****@*****.**', 'password', 'editor', realname='Hans')
user_b = users.add('*****@*****.**', 'password', 'editor')
notices = OfficialNoticeCollection(session)
notice = notices.add(title='First',
text='Lorem Ipsum',
category='Cat1',
group=group_a)
notice.state = 'drafted'
notice = notices.add(title='Second',
text='A text',
category='Cat1',
organization='Org1',
user=user_a,
group=group_b)
notice.state = 'submitted'
notice = notices.add(title='Third', text='Anöther text', category='Cat2')
notice.state = 'drafted'
notice = notices.add(title='Fourth',
text='A fourth text',
organization='Org2')
notice.state = 'published'
notice = notices.add(title='Fifth', text='Lorem Ipsum', user=user_a)
notice.state = 'rejected'
notice = notices.add(title='Sixt',
text='<p>Six</p>',
author_name='Cysat',
note='Papanikolaou',
user=user_b,
group=group_a)
notice.state = 'published'
notice = notices.add(title='Sübent',
text='Sübent',
author_place='Wynmärkt')
notice.state = 'drafted'
assert notices.query().count() == 7
assert notices.for_term('Third').query().count() == 1
assert notices.for_term('ourth').query().count() == 1
assert notices.for_term('ipsum').query().count() == 2
assert notices.for_term('ipsum').for_state('rejected').query().count() == 1
assert notices.for_term('six').query().count() == 1
assert notices.for_term('six').for_state('rejected').query().count() == 0
assert notices.for_term('üb').query().count() == 1
assert notices.for_term('Cat1').query().count() == 2
assert notices.for_term('Cat2').query().count() == 1
assert notices.for_term('Cat').query().count() == 3
assert notices.for_term('Org1').query().count() == 1
assert notices.for_term('Org').query().count() == 4
assert notices.for_term('@example.org').query().count() == 3
assert notices.for_term('ans').query().count() == 2
assert notices.for_term('group').query().count() == 3
assert notices.for_term('groupb').query().count() == 1
assert notices.for_term('Cysat').query().count() == 1
assert notices.for_term('Wynmärkt').query().count() == 1
assert notices.for_term('Papanikolaou').query().count() == 1
assert notices.for_term(str(notice.id).split('-')[0]).query().count() == 1
def test_notice_collection_order(session):
groups = UserGroupCollection(session)
group_c = groups.add(name='C').id
group_d = groups.add(name='D').id
users = UserCollection(session)
user_a = users.add('*****@*****.**', 'password', 'editor', realname='o').id
user_b = users.add('*****@*****.**', 'password', 'editor', realname='p').id
user_c = users.add('*****@*****.**', 'password', 'editor').id
date_1 = datetime(2007, 10, 10, tzinfo=timezone.utc)
date_2 = datetime(2007, 11, 11, tzinfo=timezone.utc)
date_3 = datetime(2007, 12, 12, tzinfo=timezone.utc)
notices = OfficialNoticeCollection(session)
for title, text, user, group, organization, category, first_issue in (
('A', 'g', user_a, group_c, 'p', 'X', date_1),
('B', 'g', user_b, group_d, 'q', 'X', date_1),
('B', 'h', None, None, 'p', 'X', date_2),
('C', 'h', user_a, None, 'q', 'X', date_1),
('D', 'i', user_b, group_d, 'p', 'Y', date_1),
('E', 'j', user_c, group_c, 'q', 'Y', date_3),
):
notices.add(
title=title,
text=text,
user_id=user,
group_id=group,
organization=organization,
category=category,
first_issue=first_issue,
)
# Default ordering by issue date
result = [n.first_issue for n in notices.query()]
assert result == [date_1, date_1, date_1, date_1, date_2, date_3]
# Explicit direction
result = [n.title for n in notices.for_order('title', 'asc').query()]
assert result == ['A', 'B', 'B', 'C', 'D', 'E']
result = [n.title for n in notices.for_order('title', 'desc').query()]
assert result == ['E', 'D', 'C', 'B', 'B', 'A']
result = [n.title for n in notices.for_order('title', '').query()]
assert result == ['A', 'B', 'B', 'C', 'D', 'E']
result = [n.title for n in notices.for_order('title', 'xxx').query()]
assert result == ['A', 'B', 'B', 'C', 'D', 'E']
# Default direction
# ... default
result = [
n.title
for n in notices.for_order('text', 'desc').for_order('title').query()
]
assert result == ['A', 'B', 'B', 'C', 'D', 'E']
# ... flip direction
result = [
n.title
for n in notices.for_order('title', 'asc').for_order('title').query()
]
assert result == ['E', 'D', 'C', 'B', 'B', 'A']
# Invalid
result = [n.first_issue for n in notices.for_order('result').query()]
assert result == [date_1, date_1, date_1, date_1, date_2, date_3]
result = [n.first_issue for n in notices.for_order('users').query()]
assert result == [date_1, date_1, date_1, date_1, date_2, date_3]
result = [n.first_issue for n in notices.for_order(None).query()]
assert result == [date_1, date_1, date_1, date_1, date_2, date_3]
# Valid
result = [n.text for n in notices.for_order('text').query()]
assert result == ['g', 'g', 'h', 'h', 'i', 'j']
# ... user_id
result = [n.user_id for n in notices.for_order('user_id').query()]
assert result == sorted(2 * [user_a] + 2 * [user_b] + [user_c]) + [None]
# ... organization
result = [
n.organization for n in notices.for_order('organization').query()
]
assert result == ['p', 'p', 'p', 'q', 'q', 'q']
# ... category
result = [n.category for n in notices.for_order('category').query()]
assert result == ['X', 'X', 'X', 'X', 'Y', 'Y']
# ... name
result = [n.name for n in notices.for_order('name').query()]
assert result == ['a', 'b', 'b-1', 'c', 'd', 'e']
# ... group.name
result = [
n.group.name if n.group else None
for n in notices.for_order('group.name').query()
]
assert result == [None, None, 'C', 'C', 'D', 'D']
# ... user.name(s)
result = [
n.user.realname if n.user else None
for n in notices.for_order('user.realname').query()
]
assert result == [None, None, 'o', 'o', 'p', 'p']
result = [
n.user.username if n.user else None
for n in notices.for_order('user.username').query()
]
assert result == [
None, '*****@*****.**', '*****@*****.**', '*****@*****.**',
'*****@*****.**', '*****@*****.**'
]
result = [
n.user.realname or n.user.username if n.user else None
for n in notices.for_order('user.name').query()
]
assert result == [None, '*****@*****.**', 'o', 'o', 'p', 'p']
def test_notice_collection_users_and_groups(session):
groups = UserGroupCollection(session)
group_ab = groups.add(name='AB')
group_c = groups.add(name='C')
group_d = groups.add(name='D')
users = UserCollection(session)
user_a = users.add('*****@*****.**', 'password', 'editor', group=group_ab)
user_b = users.add('*****@*****.**', 'password', 'editor', group=group_ab)
user_c = users.add('*****@*****.**', 'password', 'editor', group=group_c)
user_d = users.add('*****@*****.**', 'password', 'editor', group=group_d)
user_e = users.add('*****@*****.**', 'password', 'editor')
notices = OfficialNoticeCollection(session)
for title, user in (
('A1', user_a),
('A2', user_a),
('A3', user_a),
('B1', user_b),
('B2', user_b),
('C1', user_c),
('C2', user_c),
('D1', user_d),
('D2', user_d),
('D3', user_d),
):
notices.add(title=title,
text='text',
user_id=user.id,
group_id=user.group.id if user.group else None)
assert notices.query().count() == 10
# test users
notices.user_ids = [user_a.id]
assert sorted([n.title for n in notices.query()]) == ['A1', 'A2', 'A3']
notices.user_ids = [user_b.id]
assert sorted([n.title for n in notices.query()]) == ['B1', 'B2']
notices.user_ids = [user_c.id]
assert sorted([n.title for n in notices.query()]) == ['C1', 'C2']
notices.user_ids = [user_d.id]
assert sorted([n.title for n in notices.query()]) == ['D1', 'D2', 'D3']
notices.user_ids = [user_e.id]
assert sorted([n.title for n in notices.query()]) == []
notices.user_ids = [user_b.id, user_c.id]
assert sorted([n.title
for n in notices.query()]) == ['B1', 'B2', 'C1', 'C2']
# test groups
notices.user_ids = []
notices.group_ids = [group_ab.id]
assert sorted([n.title for n in notices.query()
]) == ['A1', 'A2', 'A3', 'B1', 'B2']
notices.group_ids = [group_c.id]
assert sorted([n.title for n in notices.query()]) == ['C1', 'C2']
notices.group_ids = [group_d.id]
assert sorted([n.title for n in notices.query()]) == ['D1', 'D2', 'D3']
notices.group_ids = [group_ab.id, group_d.id]
assert sorted([n.title for n in notices.query()
]) == ['A1', 'A2', 'A3', 'B1', 'B2', 'D1', 'D2', 'D3']
# test users and groups
notices.group_ids = [group_ab.id, group_d.id]
notices.user_ids = [user_b.id, user_d.id]
assert sorted([n.title for n in notices.query()
]) == ['B1', 'B2', 'D1', 'D2', 'D3']
def test_notification_template_send_form(session):
activities = ActivityCollection(session, type='vacation')
attendees = AttendeeCollection(session)
periods = PeriodCollection(session)
occasions = OccasionCollection(session)
bookings = BookingCollection(session)
users = UserCollection(session)
admin = users.add(username='******',
realname='Robert Baratheon',
password='******',
role='admin')
organiser = users.add(username='******',
realname=None,
password='******',
role='editor')
users.add(username='******',
realname=None,
password='******',
role='member')
prebooking = tuple(d.date() for d in (datetime.now() - timedelta(days=1),
datetime.now() + timedelta(days=1)))
execution = tuple(d.date() for d in (datetime.now() + timedelta(days=10),
datetime.now() + timedelta(days=12)))
period = periods.add(title="Ferienpass 2016",
prebooking=prebooking,
execution=execution,
active=True)
foo = activities.add("Foo", username='******')
foo.propose().accept()
bar = activities.add("Bar", username='******')
bar.propose().accept()
o1 = occasions.add(
start=datetime(2016, 11, 25, 8),
end=datetime(2016, 11, 25, 16),
age=(0, 10),
spots=(0, 2),
timezone="Europe/Zurich",
activity=foo,
period=period,
)
o1.username = admin.username
o2 = occasions.add(
start=datetime(2016, 11, 25, 17),
end=datetime(2016, 11, 25, 20),
age=(0, 10),
spots=(0, 2),
timezone="Europe/Zurich",
activity=bar,
period=period,
)
o2.username = organiser.username
a1 = attendees.add(admin, 'Dustin', date(2000, 1, 1), 'male')
a2 = attendees.add(organiser, 'Mike', date(2000, 1, 1), 'female')
b1 = bookings.add(admin, a1, o1)
b1.state = 'accepted'
b1.cost = 100
b2 = bookings.add(organiser, a2, o2)
b2.state = 'accepted'
b2.cost = 100
transaction.commit()
# create a mock request
def invoice_collection(user_id=None, period_id=None):
return InvoiceCollection(session, user_id=user_id, period_id=period_id)
def request(admin):
return Bunch(app=Bunch(
active_period=periods.active(),
org=Bunch(geo_provider='geo-mapbox'),
invoice_collection=invoice_collection,
periods=periods.query().all(),
),
session=session,
include=lambda *args: None,
model=None,
is_admin=admin,
is_organiser_only=not admin and True or False,
is_manager=admin and True or False,
translate=lambda text, *args, **kwargs: text,
locale='de_CH',
current_username=(admin and '*****@*****.**'
or '*****@*****.**'))
# in the beginning there are no recipients
form = NotificationTemplateSendForm()
form.model = None
form.request = request(admin=True)
assert form.has_choices # we still have choices (like send to users)
assert not form.occasion.choices
# once the request is processed, the occasions are added
form.on_request()
assert form.has_choices
assert len(form.occasion.choices) == 2
assert len(form.send_to.choices) == 7
# if the period is inactive, there are no occasions
periods.query().one().active = False
transaction.commit()
form = NotificationTemplateSendForm()
form.model = None
form.request = request(admin=True)
form.on_request()
assert len(form.occasion.choices) == 0
# if the period is active but not confirmed, there are no recipients
period = periods.query().one()
period.active = True
period.confirmed = False
transaction.commit()
form = NotificationTemplateSendForm()
form.model = None
form.request = request(admin=True)
form.on_request()
occasions = [c[0] for c in form.occasion.choices]
# with organisers
assert len(form.recipients_by_occasion(occasions, True)) == 2
# without
assert len(form.recipients_by_occasion(occasions, False)) == 0
# the number of users is indepenedent of the period
assert len(form.recipients_by_role(('admin', 'editor', 'member'))) == 3
assert len(form.recipients_by_role(('admin', 'editor'))) == 2
assert len(form.recipients_by_role(('admin', ))) == 1
# if the period is confirmed, there are accepted recipients
period = periods.query().one()
period.active = True
period.confirmed = True
transaction.commit()
assert len(form.recipients_by_occasion(occasions)) == 2
# only accepted bookings are counted
parent = admin.username
bookings.query().filter_by(username=parent).one().state = 'cancelled'
transaction.commit()
# without organisers
assert len(form.recipients_by_occasion(occasions, False)) == 1
# with
assert len(form.recipients_by_occasion(occasions, True)) == 2
# inactive users may be exluded
form.state.data = ['active']
assert len(form.recipients_pool) == 3
form.state.data = ['active', 'inactive']
assert len(form.recipients_pool) == 3
form.state.data = ['inactive']
assert len(form.recipients_pool) == 0
# bookings count towards the wishlist if the period is active,
period = periods.query().one()
period.active = True
period.confirmed = False
transaction.commit()
form.request = request(admin=True)
# do not count cancelled bookings...
assert len(form.recipients_with_wishes()) == 2
assert len(form.recipients_with_bookings()) == 0
# otherwise they count towards the bookings
period = periods.query().one()
period.confirmed = True
transaction.commit()
form.request = request(admin=True)
assert len(form.recipients_with_wishes()) == 0
assert len(form.recipients_with_bookings()) == 2
# count the active organisers
form.request = request(admin=True)
assert len(form.recipients_which_are_active_organisers()) == 2
# count the users with unpaid bills
form.request = request(admin=True)
assert len(form.recipients_with_unpaid_bills()) == 0
period = periods.query().one()
billing = BillingCollection(request=Bunch(
session=session, app=Bunch(invoice_collection=invoice_collection)),
period=period)
billing.create_invoices()
transaction.commit()
form.request = request(admin=True)
assert len(form.recipients_with_unpaid_bills()) == 1
# organisers are not counted as active if the occasion has been cancelled
occasions = OccasionCollection(session)
occasions.query().first().cancelled = True
transaction.commit()
form.request = request(admin=True)
assert len(form.recipients_which_are_active_organisers()) == 1
for occasion in occasions.query():
occasion.cancelled = False
transaction.commit()
form.request = request(admin=True)
assert len(form.recipients_which_are_active_organisers()) == 2
def test_notice_user_and_group(session):
users = UserCollection(session)
groups = UserGroupCollection(session)
session.add(GazetteNotice(title='notice'))
session.flush()
notice = session.query(GazetteNotice).one()
assert notice.user is None
assert notice.user_id is None
assert notice.user_name is None
assert notice._user_name is None
assert notice.group is None
assert notice.group_id is None
assert notice.group_name is None
assert notice._group_name is None
# add user and group
user = users.add('[email protected]', 'p', 'editor', realname='user')
group = groups.add(name='group')
notice.user = user
notice.group = group
session.flush()
session.refresh(notice)
assert notice.user == user
assert notice.user_id == user.id
assert notice.user_name == 'user'
assert notice._user_name == 'user'
assert notice.group == group
assert notice.group_id == group.id
assert notice.group_name == 'group'
assert notice._group_name == 'group'
# rename user and group
user.realname = 'xxx'
group.name = 'yyy'
session.flush()
session.refresh(notice)
assert notice.user == user
assert notice.user_id == user.id
assert notice.user_name == 'xxx'
assert notice._user_name == 'xxx'
assert notice.group == group
assert notice.group_id == group.id
assert notice.group_name == 'yyy'
assert notice._group_name == 'yyy'
# delete user and group
users.delete(user.username)
groups.delete(group)
session.flush()
session.refresh(notice)
assert notice.user is None
assert notice.user_id is None
assert notice.user_name == '(xxx)'
assert notice._user_name == 'xxx'
assert notice.group is None
assert notice.group_id is None
assert notice.group_name == '(yyy)'
assert notice._group_name == 'yyy'
def test_user_form(session):
# Test apply / update
users = UserCollection(session)
user = users.add(
username='******',
realname='User',
role='editor',
password='******',
)
user.phone_number = '+41415554433'
groups = UserGroupCollection(session)
group = groups.add(name='Group A')
form = UserForm()
form.apply_model(user)
assert form.username.data == '*****@*****.**'
assert form.role.data == 'editor'
assert form.name.data == 'User'
assert form.group.data == ''
assert form.phone_number.data == '+41415554433'
user.group = group
session.flush()
form.apply_model(user)
assert form.group.data == str(group.id)
form.username.data = '*****@*****.**'
form.role.data = 'publisher'
form.name.data = 'Publisher'
form.group.data = ''
form.phone_number.data = '0415554434'
form.update_model(user)
assert user.username == '*****@*****.**'
assert user.role == 'publisher'
assert user.realname == 'Publisher'
assert user.group_id is None
assert user.phone_number == '+41415554434'
session.flush()
session.refresh(user)
assert user.group is None
# Test validation
form = UserForm()
form.request = DummyRequest(session)
assert not form.validate()
# ... admins can not be created
for role, result in (('admin', False), ('editor', True), ('member', True)):
form = UserForm(
DummyPostData({
'role': role,
'name': 'User',
'username': '******',
'group': ''
}))
form.request = DummyRequest(session, private=True, secret=True)
form.on_request()
assert form.validate() == result
# ... existing email
form = UserForm(
DummyPostData({
'role': 'editor',
'name': 'User',
'username': '******',
'group': ''
}))
form.request = DummyRequest(session, private=True, secret=True)
form.on_request()
assert not form.validate()
assert 'This value already exists.' in form.errors['username']
form.model = user
form.validate()
def test_notice_form(session, categories, organizations, issues):
users = UserCollection(session)
user = users.add(
username='******',
realname='User',
role='editor',
password='******',
)
user.phone_number = '+41415554433'
notice = GazetteNotice(
title='Title',
text='A <b>text</b>.',
author_place='Govikon',
author_name='State Chancellerist',
author_date=standardize_date(datetime(2018, 1, 1), 'UTC'),
)
notice.organization_id = '200'
notice.category_id = '13'
notice.issues = ['2017-43']
notice.user = user
# Test apply / update
form = NoticeForm()
form.request = DummyRequest(session)
form.apply_model(notice)
assert form.title.data == 'Title'
assert form.organization.data == '200'
assert form.category.data == '13'
assert form.print_only.data is False
assert form.at_cost.data == 'no'
assert form.billing_address.data == ''
assert form.text.data == 'A <b>text</b>.'
assert form.author_place.data == 'Govikon'
assert form.author_name.data == 'State Chancellerist'
assert form.author_date.data == standardize_date(datetime(2018, 1, 1),
'UTC')
assert form.issues.data == ['2017-43']
assert form.phone_number.data == '+41415554433'
form.title.data = 'Notice'
form.organization.data = '300'
form.category.data = '11'
form.print_only.data = True
form.at_cost.data = 'yes'
form.billing_address.data = 'someone\nsomewhere'
form.text.data = 'A <b>notice</b>.'
form.author_place.data = 'Govtown'
form.author_name.data = 'Bureau of Public Affairs'
form.author_date.data = standardize_date(datetime(2019, 1, 1), 'UTC')
form.issues.data = ['2017-44']
form.phone_number.data = '796662211'
form.update_model(notice)
assert notice.title == 'Notice'
assert notice.organization == 'Municipality'
assert notice.category == 'Education'
assert notice.print_only is True
assert notice.at_cost is True
assert notice.billing_address == 'someone\nsomewhere'
assert notice.text == 'A <b>notice</b>.'
assert notice.author_place == 'Govtown'
assert notice.author_name == 'Bureau of Public Affairs'
assert notice.author_date == standardize_date(datetime(2019, 1, 1), 'UTC')
assert notice.issues == {'2017-44': None}
assert notice.first_issue == standardize_date(datetime(2017, 11, 3), 'UTC')
assert user.phone_number == '+41796662211'
# Test validation
form = NoticeForm()
form.request = DummyRequest(session)
assert not form.validate()
form = NoticeForm()
form.request = DummyRequest(session)
form.issues.choices = [('2017-5', '2017-5')]
form.organization.choices = [('onegov', 'onegov')]
form.category.choices = [('important', 'important')]
form.process(
DummyPostData({
'title': 'Title',
'organization': 'onegov',
'category': 'important',
'issues': ['2017-5'],
'text': 'Text',
'author_place': 'Govtown',
'author_name': 'Bureau of Public Affairs',
'author_date': '2019-01-01'
}))
assert form.validate()
# Test UTC conversion
assert form.author_date.data == date(2019, 1, 1)
assert form.author_date_utc == standardize_date(datetime(2019, 1, 1),
'UTC')
assert NoticeForm().author_date_utc is None
# Test on request
with freeze_time("2017-11-01 14:00"):
form = NoticeForm()
form.model = None
form.request = DummyRequest(session)
form.on_request()
assert form.organization.choices == [('', 'Select one'),
('100', 'State Chancellery'),
('200', 'Civic Community'),
('300', 'Municipality'),
('410',
'Evangelical Reformed Parish'),
('430', 'Catholic Parish'),
('500', 'Corporation')]
assert form.issues.choices == [
('2017-45', 'No. 45, Freitag 10.11.2017'),
('2017-46', 'No. 46, Freitag 17.11.2017'),
('2017-47', 'No. 47, Freitag 24.11.2017'),
('2017-48', 'No. 48, Freitag 01.12.2017'),
('2017-49', 'No. 49, Freitag 08.12.2017'),
('2017-50', 'No. 50, Freitag 15.12.2017'),
('2017-51', 'No. 51, Freitag 22.12.2017'),
('2017-52', 'No. 52, Freitag 29.12.2017'),
('2018-1', 'No. 1, Freitag 05.01.2018'),
]
assert form.category.choices == [
('13', 'Commercial Register'),
('11', 'Education'),
('14', 'Elections'),
('12', 'Submissions'),
]
assert form.print_only is None
form = NoticeForm()
form.model = None
form.request = DummyRequest(session, private=True)
form.on_request()
assert form.organization.choices == [('', 'Select one'),
('100', 'State Chancellery'),
('200', 'Civic Community'),
('300', 'Municipality'),
('410',
'Evangelical Reformed Parish'),
('430', 'Catholic Parish'),
('500', 'Corporation')]
assert form.issues.choices == [
('2017-44', 'No. 44, Freitag 03.11.2017'),
('2017-45', 'No. 45, Freitag 10.11.2017'),
('2017-46', 'No. 46, Freitag 17.11.2017'),
('2017-47', 'No. 47, Freitag 24.11.2017'),
('2017-48', 'No. 48, Freitag 01.12.2017'),
('2017-49', 'No. 49, Freitag 08.12.2017'),
('2017-50', 'No. 50, Freitag 15.12.2017'),
('2017-51', 'No. 51, Freitag 22.12.2017'),
('2017-52', 'No. 52, Freitag 29.12.2017'),
('2018-1', 'No. 1, Freitag 05.01.2018'),
]
assert form.category.choices == [
('13', 'Commercial Register'),
('11', 'Education'),
('14', 'Elections'),
('12', 'Submissions'),
]
assert form.issues.render_kw['data-hot-issue'] == '2017-44'
assert form.print_only is not None
def test_unrestricted_notice_form(session, categories, organizations, issues):
users = UserCollection(session)
user = users.add(
username='******',
realname='User',
role='editor',
password='******',
)
user.phone_number = '+41415554433'
notice = GazetteNotice(title='Title', text='A <b>text</b>.')
notice.organization_id = '200'
notice.category_id = '13'
notice.note = 'note'
notice.issues = ['2017-43']
notice.user = user
# Test apply / update
form = UnrestrictedNoticeForm()
form.request = DummyRequest(session)
form.apply_model(notice)
assert form.title.data == 'Title'
assert form.organization.data == '200'
assert form.category.data == '13'
assert form.text.data == 'A <b>text</b>.'
assert form.issues.data == ['2017-43']
assert form.phone_number.data == '+41415554433'
assert form.note.data == 'note'
form.title.data = 'Notice'
form.organization.data = '300'
form.category.data = '11'
form.text.data = 'A <b>notice</b>.'
form.issues.data = ['2017-44']
form.phone_number.data = '796662211'
form.note.data = 'A note'
form.update_model(notice)
assert notice.title == 'Notice'
assert notice.organization == 'Municipality'
assert notice.category == 'Education'
assert notice.text == 'A <b>notice</b>.'
assert notice.issues == {'2017-44': None}
assert notice.first_issue == standardize_date(datetime(2017, 11, 3), 'UTC')
assert notice.note == 'A note'
assert user.phone_number == '+41796662211'
notice.state = 'published'
form.issues.data = ['2017-45']
form.update_model(notice)
assert notice.issues == {'2017-44': None}
# Test on request
with freeze_time("2019-11-01 14:00"):
form = UnrestrictedNoticeForm()
form.model = None
form.request = DummyRequest(session)
form.on_request()
assert form.organization.choices == [('', 'Select one'),
('100', 'State Chancellery'),
('200', 'Civic Community'),
('300', 'Municipality'),
('410',
'Evangelical Reformed Parish'),
('420', '(Sikh Community)'),
('430', 'Catholic Parish'),
('500', 'Corporation')]
assert form.issues.choices == [
('2017-40', 'No. 40, Freitag 06.10.2017'),
('2017-41', 'No. 41, Freitag 13.10.2017'),
('2017-42', 'No. 42, Freitag 20.10.2017'),
('2017-43', 'No. 43, Freitag 27.10.2017'),
('2017-44', 'No. 44, Freitag 03.11.2017'),
('2017-45', 'No. 45, Freitag 10.11.2017'),
('2017-46', 'No. 46, Freitag 17.11.2017'),
('2017-47', 'No. 47, Freitag 24.11.2017'),
('2017-48', 'No. 48, Freitag 01.12.2017'),
('2017-49', 'No. 49, Freitag 08.12.2017'),
('2017-50', 'No. 50, Freitag 15.12.2017'),
('2017-51', 'No. 51, Freitag 22.12.2017'),
('2017-52', 'No. 52, Freitag 29.12.2017'),
('2018-1', 'No. 1, Freitag 05.01.2018')
]
assert form.category.choices == [
('13', 'Commercial Register'),
('10', '(Complaints)'),
('11', 'Education'),
('14', 'Elections'),
('12', 'Submissions'),
]
# Test disable issues
form = UnrestrictedNoticeForm()
form.model = None
form.request = DummyRequest(session)
form.on_request()
form.disable_issues()
assert form.issues.validators == []
assert all([field.render_kw['disabled'] for field in form.issues])
def test_unrestricted_user_form(session):
municipalities = MunicipalityCollection(session)
municipality_1 = municipalities.add(name="Aesch", bfs_number=82)
municipality_2 = municipalities.add(name="Adlikon", bfs_number=21)
# Test choices
form = UnrestrictedUserForm()
form.request = Request(session)
form.request.identity.userid = '*****@*****.**'
form.request.identity.role = 'admin'
form.on_request()
assert [c[1] for c in form.municipality_id.choices
] == ["- none -", "Adlikon (21)", "Aesch (82)"]
assert form.role.choices == [('admin', "Admin"), ('editor', "Editor"),
('member', "Member")]
# Test apply / update
user = User()
form.role.data = "member"
form.municipality_id.data = None
form.realname.data = "Petra Muster"
form.username.data = "*****@*****.**"
form.contact.data = False
logged_out = form.update_model(user)
assert user.role == 'member'
assert user.realname == "Petra Muster"
assert user.username == "*****@*****.**"
assert user.group_id is None
assert user.data['contact'] is False
assert user.password_hash
assert user.modified
assert logged_out is False
users = UserCollection(session)
user = users.add(
realname="Hans Muster",
username="******",
role='member',
password='******',
)
user.group_id = municipality_1.id
user.logout_all_sessions = MagicMock()
password_hash = user.password_hash
form.apply_model(user)
assert form.role.data == 'member'
assert form.municipality_id.data == municipality_1.id.hex
assert form.realname.data == "Hans Muster"
assert form.username.data == "*****@*****.**"
assert form.contact.data is False
form.role.data = 'admin'
form.municipality_id.data = municipality_2.id.hex
form.realname.data = "Hans-Peter Muster"
form.username.data = "*****@*****.**"
form.contact.data = True
logged_out = form.update_model(user)
assert user.realname == "Hans-Peter Muster"
assert user.username == "*****@*****.**"
assert user.group_id == municipality_2.id.hex
assert user.data['contact'] is True
assert user.password_hash == password_hash
assert user.logout_all_sessions.called is True
assert logged_out is False
form.request.identity.userid = "*****@*****.**"
logged_out = form.update_model(user)
assert user.realname == "Hans-Peter Muster"
assert user.username == "*****@*****.**"
assert user.group_id == municipality_2.id.hex
assert user.data['contact'] is True
assert user.password_hash == password_hash
assert user.logout_all_sessions.called is True
assert logged_out is True
# Test validation
form = UnrestrictedUserForm()
form.request = Request(session, groupid=municipality_1.id.hex)
form.on_request()
assert not form.validate()
form = UnrestrictedUserForm(
PostData({
'role': 'member',
'realname': "Hans-Peter Muster",
'username': "******"
}))
form.request = Request(session, groupid=municipality_1.id.hex)
form.on_request()
assert not form.validate()
assert form.errors == {'username': ['This value already exists.']}
form = UnrestrictedUserForm(
PostData({
'role': 'member',
'realname': "Hans Muster",
'username': "******"
}))
form.request = Request(session, groupid=municipality_1.id.hex)
form.on_request()
assert form.validate()
form = UnrestrictedUserForm(
PostData({
'role': 'editor',
'municipality_id': municipality_2.id.hex,
'realname': "Hans Muster",
'username': "******"
}))
form.request = Request(session, groupid=municipality_1.id.hex)
form.on_request()
assert form.validate()
def test_user_form(session):
municipalities = MunicipalityCollection(session)
municipality = municipalities.add(name="Aesch", bfs_number=82)
# Test apply / update
form = UserForm()
form.request = Request(session, groupid=municipality.id.hex)
form.request.identity.userid = '*****@*****.**'
form.request.identity.role = 'editor'
user = User()
form.realname.data = "Petra Muster"
form.username.data = "*****@*****.**"
form.contact.data = False
logged_out = form.update_model(user)
assert user.realname == "Petra Muster"
assert user.username == "*****@*****.**"
assert user.group_id == municipality.id.hex
assert user.role == 'member'
assert user.data['contact'] is False
assert user.password_hash
assert user.modified
assert logged_out is False
users = UserCollection(session)
user = users.add(
realname="Hans Muster",
username="******",
role='invalid',
password='******',
)
user.logout_all_sessions = MagicMock()
password_hash = user.password_hash
form.apply_model(user)
assert form.realname.data == "Hans Muster"
assert form.username.data == "*****@*****.**"
assert form.contact.data is False
form.realname.data = "Hans-Peter Muster"
form.username.data = "*****@*****.**"
form.contact.data = True
logged_out = form.update_model(user)
assert user.realname == "Hans-Peter Muster"
assert user.username == "*****@*****.**"
assert user.group_id == municipality.id.hex
assert user.role == 'member'
assert user.data['contact'] is True
assert user.password_hash == password_hash
assert user.logout_all_sessions.called is True
assert logged_out is False
form.request.identity.userid = "*****@*****.**"
logged_out = form.update_model(user)
assert user.realname == "Hans-Peter Muster"
assert user.username == "*****@*****.**"
assert user.group_id == municipality.id.hex
assert user.role == 'editor'
assert user.data['contact'] is True
assert user.password_hash == password_hash
assert user.logout_all_sessions.called is True
assert logged_out is True
# Test validation
form = UserForm()
form.request = Request(session, groupid=municipality.id.hex)
assert not form.validate()
form = UserForm(
PostData({
'realname': "Hans-Peter Muster",
'username': "******"
}))
form.request = Request(session, groupid=municipality.id.hex)
assert not form.validate()
assert form.errors == {'username': ['This value already exists.']}
form = UserForm(
PostData({
'realname': "Hans Muster",
'username': "******"
}))
form.request = Request(session, groupid=municipality.id.hex)
assert form.validate()
