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())