def test_added_dossiers(self, browser):
self.login(self.records_manager, browser=browser)
self.set_workflow_state("dossier-state-resolved", self.dossier, self.empty_dossier)
self.dossier1 = create(Builder('dossier')
.having(archival_value=ARCHIVAL_VALUE_UNWORTHY)
.as_expired()
.within(self.leaf_repofolder))
self.dossier2 = create(Builder('dossier')
.having(archival_value=ARCHIVAL_VALUE_SAMPLING)
.as_expired()
.within(self.leaf_repofolder))
ILifeCycle(self.expired_dossier).archival_value = ARCHIVAL_VALUE_WORTHY
ILifeCycle(self.empty_dossier).archival_value = ARCHIVAL_VALUE_UNCHECKED
ILifeCycle(self.dossier).archival_value = ARCHIVAL_VALUE_PROMPT
dossiers = [self.dossier, self.expired_dossier,
self.empty_dossier, self.inactive_dossier, self.dossier1]
disposition = create(Builder('disposition').having(dossiers=dossiers)
.within(self.repository_root))
self.assertItemsEqual(dossiers, disposition.get_dossiers())
self.assertFalse(IAppraisal(disposition).get(self.dossier1))
self.assertTrue(IAppraisal(disposition).get(self.expired_dossier))
self.assertIsNone(IAppraisal(disposition).get(self.empty_dossier))
self.assertIsNone(IAppraisal(disposition).get(self.dossier2))
self.assertIsNone(IAppraisal(disposition).get(self.dossier))
def assert_processes_folder_created(self, parent):
folder_process = parent.get('organigramm-prozesse')
self.assertEqual('0.0. Organigramm, Prozesse', folder_process.Title())
self.assertEqual(u'Organigramm, Prozesse', folder_process.title_de)
self.assertIsNone(folder_process.title_fr)
self.assertEqual('organigramm-prozesse', folder_process.getId())
self.assertEqual(30, ILifeCycle(folder_process).custody_period)
self.assertEqual(u'', folder_process.description)
self.assertEqual(u'', folder_process.former_reference)
self.assertEqual(u'privacy_layer_no',
IClassification(folder_process).privacy_layer)
self.assertEqual(u'unchecked',
IClassification(folder_process).public_trial)
self.assertEqual(
u'',
IClassification(folder_process).public_trial_statement)
self.assertEqual(
"0",
IReferenceNumberPrefix(folder_process).reference_number_prefix)
self.assertEqual(u'', folder_process.referenced_activity)
self.assertEqual(5, ILifeCycle(folder_process).retention_period)
self.assertEqual(date(2005, 1, 1), folder_process.valid_from)
self.assertEqual(date(2020, 1, 1), folder_process.valid_until)
self.assertEqual('repositoryfolder-state-active',
api.content.get_state(folder_process))
self.assertIsNone(getattr(folder_process, 'guid', None))
self.assertIsNone(getattr(folder_process, 'parent_guid', None))
self.assertEqual(
IAnnotations(folder_process)[BUNDLE_GUID_KEY],
index_data_for(folder_process)[GUID_INDEX_NAME])
return folder_process
def test_dossier_creation(self, browser):
self.login(self.regular_user, browser)
payload = {
u'@type': u'opengever.dossier.businesscasedossier',
u'title': u'Sanierung B\xe4rengraben 2016',
u'responsible': self.regular_user.id,
u'custody_period': 30,
u'archival_value': u'unchecked',
u'retention_period': 5,
}
response = browser.open(self.leaf_repofolder.absolute_url(),
data=json.dumps(payload),
method='POST',
headers=self.api_headers)
self.assertEqual(201, response.status_code)
new_object_id = str(response.json['id'])
dossier = self.leaf_repofolder.restrictedTraverse(new_object_id)
self.assertEqual(u'Sanierung B\xe4rengraben 2016', dossier.title)
self.assertEqual(self.regular_user.id, IDossier(dossier).responsible)
self.assertEqual(30, ILifeCycle(dossier).custody_period)
self.assertEqual(u'unchecked', ILifeCycle(dossier).archival_value)
self.assertEqual(5, ILifeCycle(dossier).retention_period)
def assert_dossier_peter_created(self, parent):
dossier_peter = parent.get('dossier-2')
self.assertEqual(
u'archival worthy',
ILifeCycle(dossier_peter).archival_value)
self.assertEqual(
u'Beinhaltet Informationen zum Verfahren',
ILifeCycle(dossier_peter).archival_value_annotation)
self.assertEqual(
u'classified',
IClassification(dossier_peter).classification)
self.assertEqual(
150,
ILifeCycle(dossier_peter).custody_period)
self.assertEqual(
u'Wir haben Hanspeter M\xfcller in einem Verfahren entlassen.',
dossier_peter.description)
self.assertEqual(
date(2007, 1, 1),
IDossier(dossier_peter).start)
self.assertEqual(
date(2011, 1, 6),
IDossier(dossier_peter).end)
self.assertEqual(
tuple(),
IDossier(dossier_peter).keywords)
self.assertEqual(
u'privacy_layer_yes',
IClassification(dossier_peter).privacy_layer)
self.assertEqual(
'7',
IDossier(dossier_peter).reference_number)
self.assertEqual(
[],
IDossier(dossier_peter).relatedDossier)
self.assertEqual(
u'lukas.graf',
IDossier(dossier_peter).responsible)
self.assertEqual(
5,
ILifeCycle(dossier_peter).retention_period)
self.assertIsNone(
ILifeCycle(dossier_peter).retention_period_annotation)
self.assertEqual(
'dossier-state-resolved',
api.content.get_state(dossier_peter))
self.assertEqual(
u'Hanspeter M\xfcller',
dossier_peter.title)
self.assertDictContainsSubset(
{'admin_users':
['Reader', 'Editor', 'Contributor', 'Publisher', 'Reviewer']},
dossier_peter.__ac_local_roles__)
self.assertTrue(dossier_peter.__ac_local_roles_block__)
return dossier_peter
def test_inactive_dossiers_are_always_not_archival_worthy(self):
self.login(self.records_manager)
self.set_workflow_state("dossier-state-inactive", self.empty_dossier)
ILifeCycle(self.inactive_dossier).archival_value = ARCHIVAL_VALUE_WORTHY
ILifeCycle(self.empty_dossier).archival_value = ARCHIVAL_VALUE_SAMPLING
disposition = create(Builder('disposition')
.having(dossiers=[self.inactive_dossier, self.expired_dossier])
.within(self.repository_root))
self.assertFalse(IAppraisal(disposition).get(self.inactive_dossier))
self.assertFalse(IAppraisal(disposition).get(self.empty_dossier))
def __init__(self, dossier, disposition):
self.title = dossier.title
self.intid = getUtility(IIntIds).getId(dossier)
self.url = dossier.absolute_url()
self.reference_number = dossier.get_reference_number()
self.parent = aq_parent(aq_inner(dossier))
self.start = IDossier(dossier).start
self.end = IDossier(dossier).end
self.public_trial = IClassification(dossier).public_trial
self.archival_value = ILifeCycle(dossier).archival_value
self.archival_value_annotation = ILifeCycle(dossier).archival_value_annotation
self.appraisal = IAppraisal(disposition).get(dossier)
self.former_state = dossier.get_former_state()
def test_reset_date_of_submission_for_dropped_dossiers(self, browser):
disposition = create(
Builder('disposition').having(
dossiers=[self.dossier1, self.dossier2, self.dossier3]).within(
self.root))
browser.login().open(disposition, view='edit')
browser.fill({'Dossiers': [self.dossier3]})
browser.find('Save').click()
self.assertEquals(None, ILifeCycle(self.dossier1).date_of_submission)
self.assertEquals(None, ILifeCycle(self.dossier2).date_of_submission)
self.assertEquals(date.today(),
ILifeCycle(self.dossier3).date_of_submission)
def test_when_appraising_final_archival_value_is_stored_on_dossier(self):
self.grant('Archivist')
IAppraisal(self.disposition).update(dossier=self.dossier1,
archive=False)
IAppraisal(self.disposition).update(dossier=self.dossier2,
archive=True)
api.content.transition(self.disposition,
transition='disposition-transition-appraise')
self.assertEquals(ARCHIVAL_VALUE_UNWORTHY,
ILifeCycle(self.dossier1).archival_value)
self.assertEquals(ARCHIVAL_VALUE_WORTHY,
ILifeCycle(self.dossier2).archival_value)
def test_reset_date_of_submission_for_dropped_dossiers(self, browser):
self.login(self.records_manager, browser)
browser.open(self.disposition, view='edit')
browser.fill({'Dossiers': [self.expired_dossier]})
browser.find('Save').click()
self.assertEquals(
None,
ILifeCycle(self.offered_dossier_to_archive).date_of_submission)
self.assertEquals(
None,
ILifeCycle(self.offered_dossier_to_destroy).date_of_submission)
self.assertEquals(date.today(),
ILifeCycle(self.expired_dossier).date_of_submission)
def test_date_of_submission_is_set_today_for_attached_dossiers(
self, browser):
data = {
'paths:list': obj2paths([self.dossier1, self.dossier3]),
'_authenticator': createToken()
}
browser.login().open(self.root,
view='++add++opengever.disposition.disposition',
data=data)
browser.find('Save').click()
self.assertEquals(date.today(),
ILifeCycle(self.dossier1).date_of_submission)
self.assertEquals(date.today(),
ILifeCycle(self.dossier3).date_of_submission)
def test_removed_dossiers_are_added_to_destroyed_dossier_list(self):
self.login(self.regular_user)
intids = getUtility(IIntIds)
expected = []
for dossier in (self.offered_dossier_to_archive,
self.offered_dossier_to_destroy):
expected.append({
'intid':
intids.getId(dossier),
'title':
dossier.title,
'appraisal':
ILifeCycle(dossier).archival_value == ARCHIVAL_VALUE_WORTHY,
'reference_number':
dossier.get_reference_number(),
'repository_title':
safe_unicode(self.leaf_repofolder.Title()),
'former_state':
dossier.get_former_state()
})
self.close_disposition()
self.assertEquals(expected,
list(self.disposition.get_destroyed_dossiers()))
def test_value_rows(self, browser):
self.login(self.records_manager, browser)
ILifeCycle(self.offered_dossier_to_destroy
).archival_value_annotation = "In Absprache mit ARCH."
self.offered_dossier_to_archive.public_trial = 'limited-public'
browser.open(self.disposition, view='download_excel')
data = browser.contents
with NamedTemporaryFile(suffix='.xlsx') as tmpfile:
tmpfile.write(data)
tmpfile.flush()
workbook = load_workbook(tmpfile.name)
rows = list(workbook.active.rows)
self.assertEquals([
u'Client1 1.1 / 12', u'Hannah Baufrau',
datetime(2000, 1, 1, 0, 0),
datetime(2000, 1, 31, 0, 0), u'limited-public',
u'archival worthy', None, u'archival worthy'
], [cell.value for cell in rows[1]])
self.assertEquals([
u'Client1 1.1 / 14', u'Hans Baumann',
datetime(2000, 1, 1, 0, 0),
datetime(2000, 1, 15, 0,
0), u'unchecked', u'not archival worthy',
u'In Absprache mit ARCH.', u'not archival worthy'
], [cell.value for cell in rows[2]])
def assert_leaf_repofolder_created(self, parent):
leaf_repofolder = parent.get('personal')
self.assertEqual('0.3. Personal', leaf_repofolder.Title())
self.assertEqual(u'Personal', leaf_repofolder.title_de)
self.assertIsNone(leaf_repofolder.title_fr)
self.assertEqual('personal', leaf_repofolder.getId())
self.assertEqual(u'prompt', ILifeCycle(leaf_repofolder).archival_value)
self.assertEqual(u'confidential',
IClassification(leaf_repofolder).classification)
self.assertEqual(100, ILifeCycle(leaf_repofolder).custody_period)
self.assertEqual(u'', leaf_repofolder.description)
self.assertEqual(u'', leaf_repofolder.former_reference)
self.assertEqual(u'privacy_layer_yes',
IClassification(leaf_repofolder).privacy_layer)
self.assertEqual(u'private',
IClassification(leaf_repofolder).public_trial)
self.assertEqual(
u'Enth\xe4lt vertrauliche Personaldossiers.',
IClassification(leaf_repofolder).public_trial_statement)
self.assertEqual(
"3",
IReferenceNumberPrefix(leaf_repofolder).reference_number_prefix)
self.assertEqual(u'', leaf_repofolder.referenced_activity)
self.assertEqual(10, ILifeCycle(leaf_repofolder).retention_period)
self.assertEqual(
u'',
ILifeCycle(leaf_repofolder).retention_period_annotation)
self.assertEqual(date(2005, 1, 1), leaf_repofolder.valid_from)
self.assertEqual(date(2050, 1, 1), leaf_repofolder.valid_until)
self.assertEqual('repositoryfolder-state-active',
api.content.get_state(leaf_repofolder))
self.assertIsNone(getattr(leaf_repofolder, 'guid', None))
self.assertIsNone(getattr(leaf_repofolder, 'parent_guid', None))
self.assertEqual(
IAnnotations(leaf_repofolder)[BUNDLE_GUID_KEY],
index_data_for(leaf_repofolder)[GUID_INDEX_NAME])
self.assertDictContainsSubset(
{
'privileged_users':
['Contributor', 'Reviewer', 'Editor', 'Reader'],
'admin_users': ['Publisher']
}, leaf_repofolder.__ac_local_roles__)
self.assertTrue(leaf_repofolder.__ac_local_roles_block__)
return leaf_repofolder
def test_appraisal_is_incomplete_when_not_all_dossiers_are_appraised(self):
self.login(self.records_manager)
self.set_workflow_state("dossier-state-resolved", self.dossier, self.empty_dossier)
ILifeCycle(self.expired_dossier).archival_value = ARCHIVAL_VALUE_WORTHY
ILifeCycle(self.empty_dossier).archival_value = ARCHIVAL_VALUE_UNWORTHY
ILifeCycle(self.dossier).archival_value = ARCHIVAL_VALUE_SAMPLING
disposition = create(Builder('disposition')
.having(dossiers=[self.expired_dossier,
self.empty_dossier,
self.dossier])
.within(self.repository_root))
appraisal = IAppraisal(disposition)
self.assertFalse(appraisal.is_complete())
appraisal.update(dossier=self.dossier, archive=True)
self.assertTrue(appraisal.is_complete())
def test_displays_archival_value_for_repositories(self, browser):
self.login(self.records_manager, browser)
ILifeCycle(
self.leaf_repofolder).archival_value = ARCHIVAL_VALUE_SAMPLING
browser.open(self.disposition, view='overview')
self.assertEquals('Archival value: archival worthy with sampling',
browser.css('.repository_title .meta').first.text)
def test_is_updated_when_editing_the_dossier_list(self, browser):
self.login(self.records_manager, browser=browser)
self.set_workflow_state("dossier-state-resolved", self.empty_dossier)
IDossier(self.empty_dossier).end = date(2000, 1, 1)
ILifeCycle(self.expired_dossier).archival_value = ARCHIVAL_VALUE_WORTHY
ILifeCycle(self.empty_dossier).archival_value = ARCHIVAL_VALUE_UNWORTHY
disposition = create(Builder('disposition')
.having(dossiers=[self.expired_dossier])
.within(self.repository_root))
self.assertEqual([self.expired_dossier], disposition.get_dossiers())
browser.open(disposition, view='edit')
browser.fill({'Dossiers': [self.expired_dossier, self.empty_dossier]})
browser.find('Save').click()
self.assertEqual([self.expired_dossier, self.empty_dossier],
disposition.get_dossiers())
def get_retention_expiration_date(self):
"""Returns the date when the expiration date expires:
The start of the next year (the first of january) after the
retention period.
"""
if IDossier(self).end:
year = IDossier(self).end.year + \
int(ILifeCycle(self).retention_period)
return date(year + 1, 1, 1)
return None
def test_update_appraisal_via_update_view(self, browser):
self.login(self.records_manager, browser=browser)
self.set_workflow_state("dossier-state-resolved", self.empty_dossier)
ILifeCycle(self.expired_dossier).archival_value = ARCHIVAL_VALUE_SAMPLING
ILifeCycle(self.empty_dossier).archival_value = ARCHIVAL_VALUE_UNWORTHY
disposition = create(Builder('disposition')
.having(dossiers=[self.expired_dossier, self.empty_dossier])
.within(self.repository_root))
self.assertFalse(IAppraisal(disposition).get(self.expired_dossier))
self.assertFalse(IAppraisal(disposition).get(self.empty_dossier))
intid = getUtility(IIntIds).getId(self.expired_dossier)
browser.open(disposition, view='update_appraisal_view',
data={'_authenticator': createToken(),
'dossier-id': json.dumps(intid),
'should_be_archived': json.dumps(True)})
self.assertTrue(IAppraisal(disposition).get(self.expired_dossier))
self.assertFalse(IAppraisal(disposition).get(self.empty_dossier))
def test_update_appraisal_for_multiple_dossiers_via_update_view(self, browser):
self.login(self.records_manager, browser=browser)
self.set_workflow_state("dossier-state-resolved", self.empty_dossier)
ILifeCycle(self.expired_dossier).archival_value = ARCHIVAL_VALUE_SAMPLING
ILifeCycle(self.empty_dossier).archival_value = ARCHIVAL_VALUE_UNWORTHY
repository2 = create(Builder('repository').within(self.repository_root))
dossier1 = create(Builder('dossier')
.having(archival_value=ARCHIVAL_VALUE_SAMPLING)
.as_expired()
.within(repository2))
dossier2 = create(Builder('dossier')
.having(archival_value=ARCHIVAL_VALUE_SAMPLING)
.as_expired()
.within(repository2))
disposition = create(Builder('disposition')
.within(self.repository_root)
.having(dossiers=[self.expired_dossier, self.empty_dossier,
dossier1, dossier2]))
self.assertFalse(IAppraisal(disposition).get(self.expired_dossier))
self.assertFalse(IAppraisal(disposition).get(self.empty_dossier))
self.assertFalse(IAppraisal(disposition).get(dossier1))
self.assertFalse(IAppraisal(disposition).get(dossier2))
intids = getUtility(IIntIds)
dossier_ids = [intids.getId(self.expired_dossier),
intids.getId(dossier1),
intids.getId(dossier2)]
browser.open(disposition, view='update_appraisal_view',
data={'_authenticator': createToken(),
'dossier-ids': json.dumps(dossier_ids),
'should_be_archived': json.dumps(True)})
self.assertTrue(IAppraisal(disposition).get(self.expired_dossier))
self.assertFalse(IAppraisal(disposition).get(self.empty_dossier))
self.assertTrue(IAppraisal(disposition).get(dossier1))
self.assertTrue(IAppraisal(disposition).get(dossier2))
def test_date_of_submission_is_set_today_for_attached_dossiers(
self, browser):
self.login(self.records_manager, browser)
with freeze(datetime(2037, 1, 1)):
data = {
'paths:list':
obj2paths([self.expired_dossier, self.inactive_dossier]),
'_authenticator':
createToken()
}
browser.open(self.repository_root,
view='++add++opengever.disposition.disposition',
data=data)
browser.find('Save').click()
self.assertEquals(
date.today(),
ILifeCycle(self.expired_dossier).date_of_submission)
self.assertEquals(
date.today(),
ILifeCycle(self.inactive_dossier).date_of_submission)
def test_when_appraising_final_archival_value_is_stored_on_dossier(self):
self.login(self.archivist)
appraisal = IAppraisal(self.disposition)
self.assertEquals(
ARCHIVAL_VALUE_WORTHY,
ILifeCycle(self.offered_dossier_to_archive).archival_value)
self.assertEquals(
ARCHIVAL_VALUE_UNWORTHY,
ILifeCycle(self.offered_dossier_to_destroy).archival_value)
appraisal.update(dossier=self.offered_dossier_to_archive,
archive=False)
appraisal.update(dossier=self.offered_dossier_to_destroy, archive=True)
api.content.transition(self.disposition,
transition='disposition-transition-appraise')
self.assertEquals(
ARCHIVAL_VALUE_UNWORTHY,
ILifeCycle(self.offered_dossier_to_archive).archival_value)
self.assertEquals(
ARCHIVAL_VALUE_WORTHY,
ILifeCycle(self.offered_dossier_to_destroy).archival_value)
def assert_organization_folder_created(self, root):
folder_organisation = root.get('organisation')
self.assertEqual('0. Organisation', folder_organisation.Title())
self.assertEqual(u'Organisation', folder_organisation.title_de)
self.assertIsNone(folder_organisation.title_fr)
self.assertEqual('organisation', folder_organisation.getId())
self.assertEqual(date(2016, 10, 1),
ILifeCycle(folder_organisation).date_of_cassation)
self.assertEqual(date(2016, 10, 2),
ILifeCycle(folder_organisation).date_of_submission)
self.assertEqual(u'unchecked',
ILifeCycle(folder_organisation).archival_value)
self.assertEqual(
u'',
ILifeCycle(folder_organisation).archival_value_annotation)
self.assertEqual(u'unprotected',
IClassification(folder_organisation).classification)
self.assertEqual(30, ILifeCycle(folder_organisation).custody_period)
self.assertEqual(date(2016, 10, 1),
ILifeCycle(folder_organisation).date_of_cassation)
self.assertEqual(date(2016, 10, 2),
ILifeCycle(folder_organisation).date_of_submission)
self.assertEqual(u'', folder_organisation.description)
self.assertEqual(u'Aktenschrank 123', folder_organisation.location)
self.assertEqual(u'privacy_layer_no',
IClassification(folder_organisation).privacy_layer)
self.assertEqual(u'unchecked',
IClassification(folder_organisation).public_trial)
self.assertEqual(
u'',
IClassification(folder_organisation).public_trial_statement)
self.assertEqual(
"0",
IReferenceNumberPrefix(
folder_organisation).reference_number_prefix)
self.assertEqual(u'', folder_organisation.referenced_activity)
self.assertEqual(5, ILifeCycle(folder_organisation).retention_period)
self.assertEqual(date(2005, 1, 1), folder_organisation.valid_from)
self.assertEqual(date(2030, 1, 1), folder_organisation.valid_until)
self.assertEqual('repositoryfolder-state-active',
api.content.get_state(folder_organisation))
self.assertIsNone(getattr(folder_organisation, 'guid', None))
self.assertIsNone(getattr(folder_organisation, 'parent_guid', None))
self.assertEqual(
IAnnotations(folder_organisation)[BUNDLE_GUID_KEY],
index_data_for(folder_organisation)[GUID_INDEX_NAME])
return folder_organisation
def binding(self):
dossier = arelda.dossierGeverSIP(id=u'_{}'.format(self.obj.UID()))
dossier.titel = self.obj.Title().decode('utf8')
dossier.entstehungszeitraum = arelda.historischerZeitraum()
catalog = getToolByName(self.obj, 'portal_catalog')
oldest_docs = catalog(portal_type=self.document_types,
path='/'.join(self.obj.getPhysicalPath()),
sort_on='created',
sort_order='ascending',
sort_limit=1)
if oldest_docs:
dossier.entstehungszeitraum.von = arelda.historischerZeitpunkt(
oldest_docs[0].created.asdatetime().date())
else:
dossier.entstehungszeitraum.von = NOT_SPECIFIED
latest_docs = catalog(portal_type=self.document_types,
path='/'.join(self.obj.getPhysicalPath()),
sort_on='modified',
sort_order='descending',
sort_limit=1)
if oldest_docs:
dossier.entstehungszeitraum.bis = arelda.historischerZeitpunkt(
latest_docs[0].modified.asdatetime().date())
else:
dossier.entstehungszeitraum.bis = NOT_SPECIFIED
set_classification_attributes(dossier, self.obj)
dossier.aktenzeichen = IReferenceNumber(self.obj).get_number()
dossier_obj = IDossier(self.obj)
if dossier_obj.start:
dossier.eroeffnungsdatum = arelda.historischerZeitpunkt(
dossier_obj.start)
if dossier_obj.end:
dossier.abschlussdatum = arelda.historischerZeitpunkt(
dossier_obj.end)
dossier.schutzfrist = unicode(ILifeCycle(self.obj).custody_period)
for d in self.dossiers.values():
dossier.dossier.append(d.binding())
for doc in self.documents.values():
dossier.dokument.append(doc.binding())
return dossier
def binding(self):
op = arelda.ordnungssystempositionGeverSIP(
id=u'_{}'.format(self.obj.UID()))
op.nummer = IReferenceNumber(self.obj).get_repository_number()
op.titel = self.obj.Title(
prefix_with_reference_number=False).decode('utf8')
set_classification_attributes(op, self.obj)
op.schutzfrist = unicode(ILifeCycle(self.obj).custody_period)
for pos in self.positions.values():
op.ordnungssystemposition.append(pos.binding())
for dossier in self.dossiers.values():
op.dossier.append(dossier.binding())
return op
def get_pre_appraisal(self, dossier):
"""Checks the preselection in the archive_value field and return
it if exists.
Sampling, unchecked and prompt aren't handled as a preselection.
Inactive dossiers are always handled as not archival worthy.
"""
if dossier.get_former_state() == 'dossier-state-inactive':
return False
archival_value = ILifeCycle(dossier).archival_value
if archival_value == ARCHIVAL_VALUE_UNWORTHY:
return False
elif archival_value == ARCHIVAL_VALUE_WORTHY:
return True
# sampling, unchecked, prompt
return None
def test_dispose_activity_is_recorded(self):
self.login(self.records_manager)
actor = ActorLookup(self.records_manager.getId()).lookup()
ILifeCycle(self.expired_dossier).archival_value = ARCHIVAL_VALUE_WORTHY
disposition = create(
Builder('disposition').having(dossiers=[self.expired_dossier]).
in_state('disposition-state-appraised'))
api.content.transition(disposition,
transition='disposition-transition-dispose')
activity = Activity.query.all()[-1]
self.assertEquals('disposition-transition-dispose', activity.kind)
self.assertEquals(
u'Disposition disposed for the archive by {}'.format(
actor.get_link()), activity.summary)
self.assertEquals(u'disposition-transition-dispose', activity.label)
self.assertIsNone(activity.description)
def test_unarchived_dossiers_get_removed_when_closing_disposition(self):
self.login(self.manager)
expected_difference = [
self.offered_dossier_to_archive, self.offered_dossier_to_destroy
]
api.content.transition(obj=self.disposition,
transition='disposition-transition-appraise')
content_before = self.leaf_repofolder.listFolderContents()
ILifeCycle(self.offered_dossier_to_archive
).archival_value = ARCHIVAL_VALUE_UNWORTHY
IAppraisal(self.disposition).initialize(
self.offered_dossier_to_archive)
api.content.transition(
obj=self.disposition,
transition='disposition-transition-appraised-to-closed')
content_after = self.leaf_repofolder.listFolderContents()
self.assertItemsEqual(
expected_difference,
set(content_before).difference(set(content_after)))
def test_list_details_for_each_dossiers(self, browser):
self.login(self.records_manager, browser)
self.offered_dossier_to_archive.public_trial = 'limited-public'
ILifeCycle(self.offered_dossier_to_destroy
).archival_value_annotation = "In Absprache mit ARCH."
browser.open(self.disposition, view='overview')
self.assertEquals([
'Period: Jan 01, 2000 - Jan 31, 2000',
'Period: Jan 01, 2000 - Jan 15, 2000'
],
browser.css('.dispositions .date_period').text)
self.assertEquals(
['Public Trial: limited-public', 'Public Trial: unchecked'],
browser.css('.dispositions .public_trial').text)
self.assertEquals([
'Archival value: archival worthy',
'Archival value: not archival worthy ( In Absprache mit ARCH. )'
],
browser.css('.dispositions .archival_value').text)
def is_archival_worthy(self, dossier):
return ILifeCycle(dossier).archival_value != ARCHIVAL_VALUE_UNWORTHY
def retract(self):
ILifeCycle(self).date_of_submission = None
api.content.transition(obj=self, to_state=self.get_former_state())