def record_digest(self, userid):
digest = Digest.query.get_by_userid(userid)
if not digest:
digest = Digest(userid=userid, last_dispatch=utcnow_tz_aware())
create_session().add(digest)
digest.last_dispatch = utcnow_tz_aware()
def record_digest(self, userid):
digest = Digest.query.get_by_userid(userid)
if not digest:
digest = Digest(userid=userid, last_dispatch=utcnow_tz_aware())
create_session().add(digest)
digest.last_dispatch = utcnow_tz_aware()
def test_is_valid(self):
lock1 = Lock(object_type='Meeting',
object_id=1,
creator=TEST_USER_ID,
time=utcnow_tz_aware() - timedelta(seconds=300))
self.session.add(lock1)
lock2 = Lock(object_type='Meeting',
object_id=2,
creator=TEST_USER_ID,
time=utcnow_tz_aware() - timedelta(seconds=800))
self.session.add(lock2)
self.assertTrue(lock1.is_valid())
self.assertFalse(lock2.is_valid())
def test_valid_locks_query(self):
valid = Lock(object_type='Meeting',
object_id=1,
creator=TEST_USER_ID,
time=utcnow_tz_aware() - timedelta(seconds=300))
self.session.add(valid)
invalid = Lock(object_type='Meeting',
object_id=2,
creator=TEST_USER_ID,
time=utcnow_tz_aware() - timedelta(seconds=800))
self.session.add(invalid)
query = Lock.query.valid_locks('Meeting', 1)
self.assertEquals([valid], query.all())
def test_valid_locks_query(self):
valid = Lock(object_type='Meeting',
object_id=1,
creator=TEST_USER_ID,
time=utcnow_tz_aware() - timedelta(seconds=300))
self.session.add(valid)
invalid = Lock(object_type='Meeting',
object_id=2,
creator=TEST_USER_ID,
time=utcnow_tz_aware() - timedelta(seconds=800))
self.session.add(invalid)
query = Lock.query.valid_locks('Meeting', 1)
self.assertEquals([valid], query.all())
def test_meetings_display(self, browser):
with self.login(self.committee_responsible):
start = utcnow_tz_aware() + timedelta(days=5)
meeting_dossier = create(
Builder('meeting_dossier').within(
self.leaf_repofolder).titled(u'Sitzungsdossier f').having(
start=start.date(),
responsible=self.committee_responsible.getId()))
meeting = create(
Builder('meeting').having(
title=u'f. Sitzung der Rechnungspr\xfcfungskommission',
committee=self.committee.load_model(),
location=u'B\xfcren an der Aare',
start=start).link_with(meeting_dossier))
self.login(self.meeting_user, browser)
browser.open(self.committee_container,
view='tabbedview_view-committees')
self.assertEquals([
'Last Meeting: Sep 12, 2016', 'Next Meeting: {}'.format(
meeting.get_date())
],
browser.css('#committees_view .meetings li').text)
last_meeting = browser.css('#committees_view .meetings li a')[0]
next_meeting = browser.css('#committees_view .meetings li a')[1]
self.assertEquals(self.meeting.model.get_url(),
last_meeting.get('href'))
self.assertEquals(meeting.get_url(), next_meeting.get('href'))
def test_is_valid(self):
lock1 = Lock(object_type='Meeting',
object_id=1,
creator=TEST_USER_ID,
time=utcnow_tz_aware() - timedelta(seconds=300))
self.session.add(lock1)
lock2 = Lock(object_type='Meeting',
object_id=2,
creator=TEST_USER_ID,
time=utcnow_tz_aware() - timedelta(seconds=800))
self.session.add(lock2)
self.assertTrue(lock1.is_valid())
self.assertFalse(lock2.is_valid())
def _past_meetings(self, committee):
query = self._committee_meetings(committee)
query = query.filter(
Meeting.workflow_state != Meeting.STATE_CANCELLED.name)
query = query.filter(Meeting.start < utcnow_tz_aware())
query = query.order_by(Meeting.start.desc())
return query
def _past_meetings(self, committee):
query = self._committee_meetings(committee)
query = query.filter(
Meeting.workflow_state != Meeting.STATE_CANCELLED.name)
query = query.filter(Meeting.start < utcnow_tz_aware())
query = query.order_by(Meeting.start.desc())
return query
def test_meetings_display(self, browser):
with self.login(self.committee_responsible):
start = utcnow_tz_aware() + timedelta(days=5)
meeting_dossier = create(
Builder('meeting_dossier')
.within(self.leaf_repofolder)
.titled(u'Sitzungsdossier f')
.having(start=start.date(),
responsible=self.committee_responsible.getId()))
meeting = create(
Builder('meeting')
.having(title=u'f. Sitzung der Rechnungspr\xfcfungskommission',
committee=self.committee.load_model(),
location=u'B\xfcren an der Aare',
start=start)
.link_with(meeting_dossier))
self.login(self.meeting_user, browser)
browser.open(self.committee_container,
view='tabbedview_view-committees')
self.assertEquals(
['Last Meeting: Sep 12, 2016',
'Next Meeting: {}'.format(meeting.get_date())],
browser.css('#committees_view .meetings li').text)
last_meeting = browser.css('#committees_view .meetings li a')[0]
next_meeting = browser.css('#committees_view .meetings li a')[1]
self.assertEquals(self.meeting.model.get_url(),
last_meeting.get('href'))
self.assertEquals(meeting.get_url(), next_meeting.get('href'))
def test_lock_info_returns_an_list_of_dicts_of_all_valid_locks(self):
# valid
lock1 = create(Builder('lock')
.of_obj(self.wrapper)
.having(time=utcnow_tz_aware() - timedelta(seconds=100)))
self.assertEquals(
[{'creator': TEST_USER_ID,
'time': lock1.time,
'token': 'Meeting:1',
'type': STEALABLE_LOCK}],
ILockable(self.wrapper).lock_info())
# invalid
lock1.time = utcnow_tz_aware() - timedelta(seconds=800)
self.assertEquals([], ILockable(self.wrapper).lock_info())
def test_locked_is_false_if_lock_is_invalid(self):
create(Builder('lock')
.of_obj(self.wrapper)
.having(time=utcnow_tz_aware() - timedelta(seconds=800)))
lockable = ILockable(self.wrapper)
self.assertFalse(lockable.locked())
def update_invitation(self, iid, **updates):
self._write_invitations[iid]['updated'] = utcnow_tz_aware()
for key, value in updates.items():
if key in ('recipient', 'inviter', 'role'):
self._write_invitations[iid][key] = value
elif key == 'target':
self._write_invitations[iid]['target_uuid'] = IUUID(value)
else:
raise KeyError(key)
def test_unique_constraint_on_type_id_and_locktype(self):
lock1 = Lock(object_type='Meeting',
object_id=1,
creator=TEST_USER_ID,
lock_type=u'plone.locking.stealable',
time=utcnow_tz_aware() - timedelta(seconds=300))
self.session.add(lock1)
with self.assertRaises(IntegrityError):
lock2 = Lock(object_type='Meeting',
object_id=1,
creator=TEST_USER_ID,
lock_type=u'plone.locking.stealable',
time=utcnow_tz_aware())
self.session.add(lock2)
transaction.commit()
transaction.abort()
def test_unique_constraint_on_type_id_and_locktype(self):
lock1 = Lock(object_type='Meeting',
object_id=1,
creator=TEST_USER_ID,
lock_type=u'plone.locking.stealable',
time=utcnow_tz_aware() - timedelta(seconds=300))
self.session.add(lock1)
with self.assertRaises(IntegrityError):
lock2 = Lock(object_type='Meeting',
object_id=1,
creator=TEST_USER_ID,
lock_type=u'plone.locking.stealable',
time=utcnow_tz_aware())
self.session.add(lock2)
transaction.commit()
transaction.abort()
def test_during_lock_creation_the_expired_locks_gets_cleared(self):
lock_1 = create(Builder('lock')
.having(object_type='Meeting',
object_id=12345,
time=utcnow_tz_aware() - timedelta(seconds=1000)))
lock_2 = create(Builder('lock')
.having(object_type='Meeting',
object_id=56789,
time=utcnow_tz_aware() - timedelta(seconds=800)))
ILockable(self.wrapper).lock()
locks = Lock.query.all()
self.assertEquals(1, len(locks))
self.assertNotIn(lock_1, locks)
self.assertNotIn(lock_2, locks)
def update_invitation(self, iid, **updates):
self._write_invitations[iid]['updated'] = utcnow_tz_aware()
for key, value in updates.items():
if key in ('recipient', 'inviter', 'role'):
self._write_invitations[iid][key] = value
elif key == 'target':
self._write_invitations[iid]['target_uuid'] = IUUID(value)
else:
raise KeyError(key)
def test_lock_creation_removes_expired_locks_for_same_object(self):
expired_lock = create(
Builder('lock').of_obj(self.wrapper).having(
time=utcnow_tz_aware() - timedelta(seconds=1000)))
ILockable(self.wrapper).lock()
locks = Lock.query.all()
self.assertEquals(1, len(locks))
self.assertNotIn(expired_lock, locks)
def insert_default_modified(self):
"""Insert time of migration as last modified timestamp."""
meeting_table = table(
'meetings',
column('id'),
column('modified'),
)
self.execute(meeting_table.update().values(modified=utcnow_tz_aware()))
def insert_default_modified(self):
"""Insert time of migration as last modified timestamp."""
meeting_table = table(
'meetings',
column('id'),
column('modified'),
)
self.execute(meeting_table.update().values(modified=utcnow_tz_aware()))
def add_invitation(self, target, recipient, inviter, role):
iid = self._generate_iid()
self._write_invitations[iid] = PersistentMapping({
'iid': iid,
'target_uuid': IUUID(target),
'recipient': recipient,
'inviter': inviter,
'role': role,
'created': utcnow_tz_aware(),
'updated': None})
return iid
def update_model(self, data):
"""Manually set the modified timestamp when updating meetings."""
super(Meeting, self).update_model(data)
self.modified = utcnow_tz_aware()
meeting_dossier = self.get_dossier()
title = data.get('title')
if meeting_dossier and title:
meeting_dossier.title = title
meeting_dossier.reindexObject()
def update_model(self, data):
"""Manually set the modified timestamp when updating meetings."""
super(Meeting, self).update_model(data)
self.modified = utcnow_tz_aware()
meeting_dossier = self.get_dossier()
title = data.get('title')
if meeting_dossier and title:
meeting_dossier.title = title
meeting_dossier.reindexObject()
def test_lock_creation_removes_expired_locks_for_same_object(self):
expired_lock = create(
Builder('lock')
.of_obj(self.wrapper)
.having(time=utcnow_tz_aware() - timedelta(seconds=1000)))
ILockable(self.wrapper).lock()
locks = Lock.query.all()
self.assertEquals(1, len(locks))
self.assertNotIn(expired_lock, locks)
def __init__(self, context, timestamp=None, uuid=None):
timestamp = timestamp or utcnow_tz_aware()
if uuid is None:
uuid = uuid4()
elif isinstance(uuid, basestring):
uuid = UUID(uuid)
self.context = context
self.timestamp = timestamp
self.data = PersistentMapping(created=timestamp,
userid=unicode(
api.user.get_current().getId()),
history_type=self.history_type,
uuid=uuid)
def create_job(self):
self._cleanup_old_jobs()
self._prepare_committee_annotations()
job_id = str(uuid.uuid4())
zip_job_data = PersistentMapping()
zip_job_data['job_id'] = job_id
zip_job_data['timestamp'] = utcnow_tz_aware()
zip_job_data['documents'] = OOBTree()
self._zip_jobs[job_id] = zip_job_data
return ZipJob(zip_job_data)
def create_job(self):
self._cleanup_old_jobs()
self._prepare_committee_annotations()
job_id = str(uuid.uuid4())
zip_job_data = PersistentMapping()
zip_job_data['job_id'] = job_id
zip_job_data['timestamp'] = utcnow_tz_aware()
zip_job_data['documents'] = OOBTree()
self._zip_jobs[job_id] = zip_job_data
return ZipJob(zip_job_data)
def __init__(self, context, timestamp=None, uuid=None):
timestamp = timestamp or utcnow_tz_aware()
if uuid is None:
uuid = uuid4()
elif isinstance(uuid, basestring):
uuid = UUID(uuid)
self.context = context
self.timestamp = timestamp
self.data = PersistentMapping(
created=timestamp,
userid=unicode(api.user.get_current().getId()),
history_type=self.history_type,
uuid=uuid)
def is_interval_expired(self, userid):
"""Returns true it the time since the last dispatch expires the defined
interval for the given user.
The calculation has been made with a tolerance of 1 hour.
"""
digest = Digest.query.get_by_userid(userid)
if not digest:
# no digests sent yet, so digest schould be send
return True
interval = timedelta(hours=DIGEST_INTERVAL_HOURS - DIGEST_TOLERANCE)
expired = utcnow_tz_aware() - interval
return digest.last_dispatch <= expired
def is_interval_expired(self, userid):
"""Returns true it the time since the last dispatch expires the defined
interval for the given user.
The calculation has been made with a tolerance of 1 hour.
"""
digest = Digest.query.get_by_userid(userid)
if not digest:
# no digests sent yet, so digest schould be send
return True
interval = timedelta(hours=DIGEST_INTERVAL_HOURS - DIGEST_TOLERANCE)
expired = utcnow_tz_aware() - interval
return digest.last_dispatch <= expired
def _cleanup_old_jobs(self):
"""Remove expired zip jobs.
The zip jobs are only kept for a relatively short amount of time as
they are a temporary thing.
"""
to_remove = set()
now = utcnow_tz_aware()
expiration_delta = timedelta(days=ZIP_EXPIRATION_DAYS)
for zip_job_data in self._zip_jobs.values():
delta = now - zip_job_data['timestamp']
if delta > expiration_delta:
to_remove.add(zip_job_data['job_id'])
for job_id in to_remove:
self.remove_job(job_id)
def _cleanup_old_jobs(self):
"""Remove expired zip jobs.
The zip jobs are only kept for a relatively short amount of time as
they are a temporary thing.
"""
to_remove = set()
now = utcnow_tz_aware()
expiration_delta = timedelta(days=ZIP_EXPIRATION_DAYS)
for zip_job_data in self._zip_jobs.values():
delta = now - zip_job_data['timestamp']
if delta > expiration_delta:
to_remove.add(zip_job_data['job_id'])
for job_id in to_remove:
self.remove_job(job_id)
def add_invitation(self, target, recipient, inviter, role):
iid = self._generate_iid()
self._write_invitations[iid] = PersistentMapping({
'iid':
iid,
'target_uuid':
IUUID(target),
'recipient':
recipient,
'inviter':
inviter,
'role':
role,
'created':
utcnow_tz_aware(),
'updated':
None
})
return iid
def test_edit_meeting_reports_write_conflicts(self, tab1):
self.login(self.committee_responsible, tab1)
with tab1.clone() as tab2:
with freeze(utcnow_tz_aware()) as clock:
tab1.open(self.meeting, view='edit-meeting')
tab2.open(self.meeting, view='edit-meeting')
tab1.fill({'Title': u'Title by tab 1'}).save()
statusmessages.assert_message('Changes saved', browser=tab1)
self.assertEquals(u'Title by tab 1', plone.first_heading(browser=tab1))
create_session().flush()
clock.forward(minutes=1)
tab2.fill({'Title': u'Title by tab 2'}).save()
statusmessages.assert_message(
'Your changes were not saved,'
' the protocol has been modified in the meantime.', browser=tab2)
tab2.open(self.meeting)
self.assertEquals(u'Title by tab 1', plone.first_heading(browser=tab2))
def _past_meetings(self, committee):
query = self._committee_meetings(committee)
query = query.filter(Meeting.start < utcnow_tz_aware())
query = query.order_by(desc(Meeting.start))
return query
def update_changed_date(context, event):
IChanged(context).changed = utcnow_tz_aware()
context.reindexObject(idxs=["changed"])
def _upcoming_meetings(self, committee):
query = self._committee_meetings(committee)
query = query.filter(Meeting.start >= utcnow_tz_aware())
query = query.order_by(Meeting.start)
return query
def _past_meetings(self, committee):
query = self._committee_meetings(committee)
query = query.filter(Meeting.start < utcnow_tz_aware())
query = query.order_by(desc(Meeting.start))
return query
def test_update_invitation(self):
self.login(self.workspace_admin)
storage = getUtility(IInvitationStorage)
creation_date = datetime(2017, 1, 1, 1, 1, tzinfo=pytz.UTC)
with freeze(creation_date) as clock:
iid = self.add_invitation()
self.assertDictEqual(
{'iid': iid,
'target_uuid': IUUID(self.workspace),
'recipient': 'hans.peter',
'inviter': 'gunther.frohlich',
'role': 'WorkspaceGuest',
'created': creation_date,
'updated': None},
storage.get_invitation(iid))
clock.forward(hours=1)
storage.update_invitation(iid, role='WorkspaceMember')
self.assertDictEqual(
{'iid': iid,
'target_uuid': IUUID(self.workspace),
'recipient': 'hans.peter',
'inviter': 'gunther.frohlich',
'role': 'WorkspaceMember',
'created': creation_date,
'updated': utcnow_tz_aware()},
storage.get_invitation(iid))
clock.forward(hours=1)
storage.update_invitation(iid, recipient='fritz', inviter='hans')
self.assertDictEqual(
{'iid': iid,
'target_uuid': IUUID(self.workspace),
'recipient': 'fritz',
'inviter': 'hans',
'role': 'WorkspaceMember',
'created': creation_date,
'updated': utcnow_tz_aware()},
storage.get_invitation(iid))
clock.forward(hours=1)
storage.update_invitation(iid, target=self.workspace_folder)
self.assertDictEqual(
{'iid': iid,
'target_uuid': IUUID(self.workspace_folder),
'recipient': 'fritz',
'inviter': 'hans',
'role': 'WorkspaceMember',
'created': creation_date,
'updated': utcnow_tz_aware()},
storage.get_invitation(iid))
with self.assertRaises(KeyError):
storage.update_invitation(iid, target_uuid='new')
with self.assertRaises(KeyError):
storage.update_invitation(iid, created='new')
with self.assertRaises(KeyError):
storage.update_invitation(iid, updated='new')
def test_update_invitation(self):
self.login(self.workspace_admin)
storage = getUtility(IInvitationStorage)
creation_date = datetime(2017, 1, 1, 1, 1, tzinfo=pytz.UTC)
with freeze(creation_date) as clock:
iid = self.add_invitation()
self.assertDictEqual(
{
'iid': iid,
'target_uuid': IUUID(self.workspace),
'recipient': 'hans.peter',
'inviter': 'gunther.frohlich',
'role': 'WorkspaceGuest',
'created': creation_date,
'updated': None
}, storage.get_invitation(iid))
clock.forward(hours=1)
storage.update_invitation(iid, role='WorkspaceMember')
self.assertDictEqual(
{
'iid': iid,
'target_uuid': IUUID(self.workspace),
'recipient': 'hans.peter',
'inviter': 'gunther.frohlich',
'role': 'WorkspaceMember',
'created': creation_date,
'updated': utcnow_tz_aware()
}, storage.get_invitation(iid))
clock.forward(hours=1)
storage.update_invitation(iid, recipient='fritz', inviter='hans')
self.assertDictEqual(
{
'iid': iid,
'target_uuid': IUUID(self.workspace),
'recipient': 'fritz',
'inviter': 'hans',
'role': 'WorkspaceMember',
'created': creation_date,
'updated': utcnow_tz_aware()
}, storage.get_invitation(iid))
clock.forward(hours=1)
storage.update_invitation(iid, target=self.workspace_folder)
self.assertDictEqual(
{
'iid': iid,
'target_uuid': IUUID(self.workspace_folder),
'recipient': 'fritz',
'inviter': 'hans',
'role': 'WorkspaceMember',
'created': creation_date,
'updated': utcnow_tz_aware()
}, storage.get_invitation(iid))
with self.assertRaises(KeyError):
storage.update_invitation(iid, target_uuid='new')
with self.assertRaises(KeyError):
storage.update_invitation(iid, created='new')
with self.assertRaises(KeyError):
storage.update_invitation(iid, updated='new')
def _upcoming_meetings(self, committee):
query = self._committee_meetings(committee)
query = query.filter(Meeting.start >= utcnow_tz_aware())
query = query.order_by(Meeting.start)
return query
from plone.dexterity.utils import createContentInContainer
from plone.dexterity.utils import iterSchemataForType
from plone.namedfile.file import NamedBlobFile
from z3c.form.browser.checkbox import CheckBoxWidget
from z3c.form.browser.checkbox import SingleCheckBoxWidget
from z3c.form.interfaces import IDataConverter
from z3c.form.interfaces import IGroupForm
from zope.schema import getFieldsInOrder
from zope.schema import List
import json
import textwrap
# changed is timezone aware, so we need a timezone aware FROZEN_NOW, but dates
# in GEVER are timezone naive, so to avoid this test failing when timezone
# offset leads to a date shift, we define a timezone naive FROZEN_TODAY.
FROZEN_NOW = utcnow_tz_aware()
with freeze(FROZEN_NOW):
FROZEN_TODAY = date.today()
DEFAULT_TITLE = u'My title'
DEFAULT_CLIENT = u'fa'
REPOROOT_REQUIREDS = {
'title_de': DEFAULT_TITLE,
}
REPOROOT_DEFAULTS = {}
REPOROOT_FORM_DEFAULTS = {}
REPOROOT_MISSING_VALUES = {
'title_fr': None,
'valid_from': None,
'valid_until': None,
def lowest_valid():
return utcnow_tz_aware() - timedelta(seconds=DEFAULTTIMEOUT)
def refresh_lock(self, lock_type=STEALABLE_LOCK):
if not self.locked():
return
lock = self._get_lock(lock_type)
lock.time = utcnow_tz_aware()
def update_model(self, data):
"""Manually set the modified timestamp when updating meetings."""
super(Meeting, self).update_model(data)
self.modified = utcnow_tz_aware()
def refresh_lock(self, lock_type=STEALABLE_LOCK):
if not self.locked():
return
lock = self._get_lock(lock_type)
lock.time = utcnow_tz_aware()
def test_locked_is_true_if_a_valid_lock_exists(self):
create(Builder('lock')
.of_obj(self.wrapper)
.having(time=utcnow_tz_aware() - timedelta(seconds=100)))
lockable = ILockable(self.wrapper)
self.assertTrue(lockable.locked())
def update_changed_date(context, event):
IChanged(context).changed = utcnow_tz_aware()
context.reindexObject(idxs=["changed"])
def lowest_valid():
return utcnow_tz_aware() - timedelta(seconds=DEFAULTTIMEOUT)
from plone.dexterity.utils import iterSchemataForType
from plone.namedfile.file import NamedBlobFile
from z3c.form.browser.checkbox import CheckBoxWidget
from z3c.form.browser.checkbox import SingleCheckBoxWidget
from z3c.form.interfaces import IDataConverter
from z3c.form.interfaces import IGroupForm
from zope.schema import getFieldsInOrder
from zope.schema import List
import json
import textwrap
# changed is timezone aware, so we need a timezone aware FROZEN_NOW, but dates
# in GEVER are timezone naive, so to avoid this test failing when timezone
# offset leads to a date shift, we define a timezone naive FROZEN_TODAY.
FROZEN_NOW = utcnow_tz_aware()
with freeze(FROZEN_NOW):
FROZEN_TODAY = date.today()
DEFAULT_TITLE = u'My title'
DEFAULT_CLIENT = u'fa'
REPOROOT_REQUIREDS = {
'title_de': DEFAULT_TITLE,
}
REPOROOT_DEFAULTS = {}
REPOROOT_FORM_DEFAULTS = {}
REPOROOT_MISSING_VALUES = {
'title_fr': None,
'valid_from': None,
'valid_until': None,
