def test_SortedSelectedOrganizationsElephantVocabulary(self):
""" Test sorted elephant vocabulary """
factory_all = getUtility(
IVocabularyFactory, 'collective.contact.plonegroup.organization_services')
vocab_all = factory_all(self.portal)
vocab_all_values = [v.value for v in vocab_all]
self.assertEqual(len(vocab_all), 3)
self.assertListEqual([v.title for v in vocab_all],
['Department 1', 'Department 1 - Service 1', 'Department 2'])
set_registry_organizations([vocab_all_values[2], vocab_all_values[0]])
factory_wrp = getUtility(
IVocabularyFactory,
'collective.contact.plonegroup.browser.settings.SortedSelectedOrganizationsElephantVocabulary')
vocab_wrp = factory_wrp(self.portal)
self.assertEqual(len(vocab_wrp), 3)
# values are shown sorted, no matter how it is selected in plonegroup organizations
self.assertListEqual([v.title for v in vocab_wrp], [u'Department 1', u'Department 2'])
self.assertListEqual(sorted([v.token for v in vocab_wrp]),
sorted(get_registry_organizations()))
self.assertEqual(vocab_wrp.getTerm(vocab_all_values[1]).title, u'Department 1 - Service 1')
# vocabulary use caching, when new values added, the vocabulary is correct
own_orga = get_own_organization()
own_orga.invokeFactory('organization', 'department3', title='Department 3')
set_registry_organizations(
[vocab_all_values[2],
vocab_all_values[0],
own_orga['department3'].UID()])
vocab_wrp = factory_wrp(self.portal)
self.assertListEqual(
[v.title for v in vocab_wrp],
[u'Department 1', u'Department 2', u'Department 3'])
self.assertListEqual(
sorted([v.token for v in vocab_wrp]),
sorted(get_registry_organizations()))
def test_contact_plonegroup_change(self):
e_groups = [('%s_encodeur' % uid, ('Contributor', ))
for uid in get_registry_organizations()]
e_groups.append(('admin', ('Owner', )))
e_groups.append(('expedition', ('Contributor', )))
e_groups.append(('dir_general', ('Contributor', )))
self.assertSetEqual(set(self.omf.get_local_roles()), set(e_groups))
self.assertEqual(len(self.omf.get_local_roles()), 14)
set_registry_organizations(get_registry_organizations()[:3])
self.assertEqual(len(self.omf.get_local_roles()), 6)
def test_detectContactPlonegroupChange(self):
"""Test if group creation works correctly"""
group_ids = [group.id for group in api.group.get_groups()]
organizations = get_registry_organizations()
for uid in organizations:
self.assertIn('%s_director' % uid, group_ids)
self.assertIn('%s_worker' % uid, group_ids)
d1_d_group = api.group.get(groupname='%s_director' % organizations[0])
self.assertEquals(d1_d_group.getProperty('title'), 'Department 1 (Director)')
d1s1_d_group = api.group.get(groupname='%s_director' % organizations[1])
self.assertEquals(d1s1_d_group.getProperty('title'), 'Department 1 - Service 1 (Director)')
# Changing function title
set_registry_functions([{'fct_title': u'Directors',
'fct_id': u'director',
'fct_orgs': [],
'fct_management': False,
'enabled': True},
{'fct_title': u'Worker',
'fct_id': u'worker',
'fct_orgs': [],
'fct_management': False,
'enabled': True}])
d1_d_group = api.group.get(groupname='%s_director' % organizations[0])
self.assertEquals(d1_d_group.getProperty('title'), 'Department 1 (Directors)')
d1s1_d_group = api.group.get(groupname='%s_director' % organizations[1])
self.assertEquals(d1s1_d_group.getProperty('title'), 'Department 1 - Service 1 (Directors)')
# Adding new organization
own_orga = get_own_organization()
own_orga['department2'].invokeFactory('organization', 'service2', title='Service 2')
# append() method on the registry doesn't trigger the event. += too
newValue = get_registry_organizations() + [own_orga['department2']['service2'].UID()]
set_registry_organizations(newValue)
group_ids = [group.id for group in api.group.get_groups()]
last_uid = get_registry_organizations()[-1]
self.assertIn('%s_director' % last_uid, group_ids)
self.assertIn('%s_worker' % last_uid, group_ids)
# Adding new function
newValue = get_registry_functions() + [{'fct_title': u'Chief',
'fct_id': u'chief',
'fct_orgs': [],
'fct_management': False,
'enabled': True}]
set_registry_functions(newValue)
group_ids = [group.id for group in api.group.get_groups() if '_' in group.id]
self.assertEquals(len(group_ids), 12)
for uid in get_registry_organizations():
self.assertIn('%s_director' % uid, group_ids)
self.assertIn('%s_chief' % uid, group_ids)
self.assertIn('%s_worker' % uid, group_ids)
def test_validateSettingsSelectFunctionOrgsOnExistingFunction(self):
"""Selecting 'fct_orgs' for an existing function (so for which Plone groups are already created),
is only possible if groups that will be deleted (Plone groups of organizations not selected
as 'fct_orgs') are empty."""
# add a user to group department1 director
own_orga = get_own_organization()
dep1 = own_orga['department1']
dep2 = own_orga['department2']
plone_group_id = get_plone_group_id(dep1.UID(), 'director')
api.group.add_user(groupname=plone_group_id, username=TEST_USER_ID)
invariants = validator.InvariantsValidator(
None, None, None, settings.IContactPlonegroupConfig, None)
orgs = get_registry_organizations()
functions = get_registry_functions()
data = {'organizations': orgs, 'functions': functions}
# set dep2 as 'fct_orgs' of 'director' function
director = functions[0]
director['fct_orgs'] = [dep2.UID()]
errors = invariants.validate(data)
self.assertTrue(isinstance(errors[0], Invalid))
error_msg = translate(
msgid=u"can_not_select_function_orgs_every_other_plone_groups_not_empty",
domain='collective.contact.plonegroup',
mapping={'function': 'director',
'plone_group_id': plone_group_id})
self.assertEqual(translate(errors[0].message), error_msg)
# remove user from plone group, now it validates
api.group.remove_user(groupname=plone_group_id, username=TEST_USER_ID)
self.assertFalse(invariants.validate(data))
def test_validateSettingsRemoveFunction(self):
"""A function may only be removed if every linked Plone groups are empty."""
# add a user to group department1 director
own_orga = get_own_organization()
dep1 = own_orga['department1']
plone_group_id = get_plone_group_id(dep1.UID(), 'director')
api.group.add_user(groupname=plone_group_id, username=TEST_USER_ID)
invariants = validator.InvariantsValidator(
None, None, None, settings.IContactPlonegroupConfig, None)
orgs = get_registry_organizations()
functions = get_registry_functions()
data = {'organizations': orgs, 'functions': functions}
# for now it validates correctly
self.assertFalse(invariants.validate(data))
# remove 'director'
functions.pop(0)
errors = invariants.validate(data)
self.assertTrue(isinstance(errors[0], Invalid))
error_msg = translate(
msgid=u"can_not_remove_function_every_plone_groups_not_empty",
domain='collective.contact.plonegroup',
mapping={'removed_function': 'director',
'plone_group_id': plone_group_id})
self.assertEqual(translate(errors[0].message), error_msg)
# remove user from plone group, now it validates
api.group.remove_user(groupname=plone_group_id, username=TEST_USER_ID)
self.assertFalse(invariants.validate(data))
def get_org_user(directory, keys, userid=''):
"""Get internal org corresponding to keys"""
f_user = None
f_org = directory['plonegroup-organization']
for key in keys:
if key not in f_org:
continue
f_org = f_org[key]
if key == keys[-1]:
users = [u.getId() for u in api.user.get_users(groupname='{}_editeur'.format(f_org.UID()))]
if userid in users:
f_user = userid
elif users:
f_user = users[0]
break
else: # if the demo org has been deleted, we search another org with a configured user
f_org = None
orgs = get_registry_organizations()
for org in orgs:
users = [u.getId() for u in api.user.get_users(groupname='{}_editeur'.format(org))]
if userid in users:
f_org = org
f_user = userid
break
elif users:
f_org = org
f_user = users[0]
return f_org, f_user
def test_adaptPloneGroupDefinition(self):
""" Test event when an organization is changed """
organizations = get_registry_organizations()
own_orga = get_own_organization()
# an organization is modified
own_orga['department1'].title = 'Department 1 changed'
event.notify(ObjectModifiedEvent(own_orga['department1']))
d1_d_group = api.group.get(groupname='%s_director' % organizations[0])
self.assertEquals(d1_d_group.getProperty('title'), 'Department 1 changed (Director)')
d1s1_d_group = api.group.get(groupname='%s_director' % organizations[1])
self.assertEquals(d1s1_d_group.getProperty('title'), 'Department 1 changed - Service 1 (Director)')
# an organization is moved (service1 in department2)
clipboard = own_orga['department1'].manage_cutObjects(['service1'])
own_orga['department2'].manage_pasteObjects(clipboard)
# the event IObjectMovedEvent is triggered
d1s1_d_group = api.group.get(groupname='%s_director' % organizations[1])
self.assertEquals(d1s1_d_group.getProperty('title'), 'Department 2 - Service 1 (Director)')
# a configured organization is deleted. Exception raised
self.assertRaises(Redirect, own_orga['department2'].manage_delObjects, ids=['service1'])
# THIS IS A KNOWN ERROR: the organization is deleted despite the exception !!!!!!!
self.assertFalse('service1' in own_orga['department2'])
# an unused organization is deleted. No exception
own_orga['department2'].invokeFactory('organization', 'service3', title='Service 3')
own_orga['department2'].manage_delObjects(ids=['service3'])
self.assertFalse('service3' in own_orga['department2'])
def test_validateSettingsSelectFunctionOrgsOnExistingFunction(self):
"""Selecting 'fct_orgs' for an existing function (so for which Plone groups are already created),
is only possible if groups that will be deleted (Plone groups of organizations not selected
as 'fct_orgs') are empty."""
# add a user to group department1 director
own_orga = get_own_organization()
dep1 = own_orga['department1']
dep2 = own_orga['department2']
plone_group_id = get_plone_group_id(dep1.UID(), 'director')
api.group.add_user(groupname=plone_group_id, username=TEST_USER_ID)
invariants = validator.InvariantsValidator(
None, None, None, settings.IContactPlonegroupConfig, None)
orgs = get_registry_organizations()
functions = get_registry_functions()
data = {'organizations': orgs, 'functions': functions}
# set dep2 as 'fct_orgs' of 'director' function
director = functions[0]
director['fct_orgs'] = [dep2.UID()]
errors = invariants.validate(data)
self.assertTrue(isinstance(errors[0], Invalid))
error_msg = translate(
msgid=u"can_not_select_function_orgs_every_other_plone_groups_not_empty",
domain='collective.contact.plonegroup',
mapping={'function': 'director',
'plone_group_id': plone_group_id})
self.assertEqual(translate(errors[0].message), error_msg)
# remove user from plone group, now it validates
api.group.remove_user(groupname=plone_group_id, username=TEST_USER_ID)
self.assertFalse(invariants.validate(data))
def test_validateSettingsDisableFunction(self):
"""A function may only be disabled (enabled=False)
if every linked Plone groups are empty."""
# add a user to group department1 director
own_orga = get_own_organization()
dep1 = own_orga['department1']
plone_group_id = get_plone_group_id(dep1.UID(), 'director')
api.group.add_user(groupname=plone_group_id, username=TEST_USER_ID)
invariants = validator.InvariantsValidator(
None, None, None, settings.IContactPlonegroupConfig, None)
orgs = get_registry_organizations()
functions = get_registry_functions()
data = {'organizations': orgs, 'functions': functions}
# for now it validates correctly
self.assertFalse(invariants.validate(data))
# disable 'director'
functions[0]['enabled'] = False
errors = invariants.validate(data)
self.assertTrue(isinstance(errors[0], Invalid))
error_msg = translate(
msgid=u"can_not_disable_suffix_plone_groups_not_empty",
domain='collective.contact.plonegroup',
mapping={'removed_function': 'director',
'plone_group_id': plone_group_id})
self.assertEqual(translate(errors[0].message), error_msg)
# remove user from plone group, now it validates
api.group.remove_user(groupname=plone_group_id, username=TEST_USER_ID)
self.assertFalse(invariants.validate(data))
def group_deleted(event):
"""
Raises exception if group cannot be deleted
"""
group = event.principal
portal = api.portal.get()
request = portal.REQUEST
parts = group.split('_')
if len(parts) == 1:
return
org_uid = parts[0]
group_suffix = '_'.join(parts[1:])
if org_uid in get_registry_organizations(
) and group_suffix in get_all_suffixes(org_uid):
orga = api.content.find(UID=org_uid)[0].getObject()
api.portal.show_message(message=_(
"You cannot delete the group '${group}', linked to used organization "
"'${orga}'.",
mapping={
'group': group,
'orga': safe_unicode(orga.Title())
}),
request=request,
type='error')
raise Redirect(request.get('ACTUAL_URL'))
def test_adaptPloneGroupDefinition(self):
""" Test event when an organization is changed """
organizations = get_registry_organizations()
own_orga = get_own_organization()
# an organization is modified
own_orga['department1'].title = 'Department 1 changed'
event.notify(ObjectModifiedEvent(own_orga['department1']))
d1_d_group = api.group.get(groupname='%s_director' % organizations[0])
self.assertEquals(d1_d_group.getProperty('title'), 'Department 1 changed (Director)')
d1s1_d_group = api.group.get(groupname='%s_director' % organizations[1])
self.assertEquals(d1s1_d_group.getProperty('title'), 'Department 1 changed - Service 1 (Director)')
# an organization is moved (service1 in department2)
clipboard = own_orga['department1'].manage_cutObjects(['service1'])
own_orga['department2'].manage_pasteObjects(clipboard)
# the event IObjectMovedEvent is triggered
d1s1_d_group = api.group.get(groupname='%s_director' % organizations[1])
self.assertEquals(d1s1_d_group.getProperty('title'), 'Department 2 - Service 1 (Director)')
# a configured organization is deleted. Exception raised
self.assertRaises(Redirect, own_orga['department2'].manage_delObjects, ids=['service1'])
# THIS IS A KNOWN ERROR: the organization is deleted despite the exception !!!!!!!
self.assertFalse('service1' in own_orga['department2'])
# an unused organization is deleted. No exception
own_orga['department2'].invokeFactory('organization', 'service3', title='Service 3')
own_orga['department2'].manage_delObjects(ids=['service3'])
self.assertFalse('service3' in own_orga['department2'])
def test_OdmUtilsMethods_can_be_sent(self):
omail = sub_create(self.portal['outgoing-mail'],
'dmsoutgoingmail',
datetime.now(),
'test-id',
title=u'test')
self.assertEqual(api.content.get_state(omail), 'created')
view = OdmUtilsMethods(omail, omail.REQUEST)
# no treating_groups
self.assertFalse(view.can_be_sent())
omail.treating_groups = get_registry_organizations()[
0] # direction-generale
# admin
self.assertTrue(view.can_be_sent())
setRoles(self.portal, TEST_USER_ID, ['Member'])
# define as email
omail.send_modes = [u'email']
self.assertTrue(omail.is_email())
self.assertFalse(view.can_be_sent())
omail.email_status = u'sent at ...'
self.assertTrue(view.can_be_sent())
# define as normal mail
omail.send_modes = [u'post']
self.assertFalse(omail.is_email())
self.assertFalse(view.can_be_sent())
createContentInContainer(omail, 'dmsommainfile')
self.assertTrue(view.can_be_sent())
def om_n_plus_1_wfadaptation(context):
"""
Add n_plus_1 level in outgoingmail_workflow
"""
if not context.readDataFile("imiodmsmail_singles_marker.txt"):
return
logger.info('Apply n_plus_1 level on outgoingmail_workflow')
site = context.getSite()
n_plus_1_params = {
'validation_level': 1,
'state_title': u'À valider par le chef de service',
'forward_transition_title': u'Proposer au chef de service',
'backward_transition_title': u'Renvoyer au chef de service',
'function_title': u'N+1',
'validated_from_created': False
}
sva = OMServiceValidation()
adapt_is_applied = sva.patch_workflow('outgoingmail_workflow',
**n_plus_1_params)
if adapt_is_applied:
add_applied_adaptation(
'imio.dms.mail.wfadaptations.OMServiceValidation',
'outgoingmail_workflow', True, **n_plus_1_params)
# Add users to activated groups
if 'chef' in [u.id for u in api.user.get_users()]:
for uid in get_registry_organizations():
site.acl_users.source_groups.addPrincipalToGroup(
'chef', "%s_n_plus_1" % uid)
def test_OdmUtilsMethods_can_do_transition1(self):
# self.assertEqual(api.content.get_state(self.omail), 'created')
view = OdmUtilsMethods(self.omail, self.omail.REQUEST)
setRoles(self.portal, TEST_USER_ID, ['Reviewer', 'Manager'])
# no treating_groups: NOK
self.assertIsNone(self.omail.treating_groups)
self.assertFalse(view.can_do_transition('propose_to_n_plus_1'))
self.assertFalse(view.can_do_transition('back_to_n_plus_1'))
# tg ok, no user in group
self.omail.treating_groups = get_registry_organizations()[0]
groupname = '{}_n_plus_1'.format(self.omail.treating_groups)
api.group.remove_user(groupname=groupname, username='******')
self.assertFalse(group_has_user(groupname))
self.assertFalse(view.can_do_transition('propose_to_n_plus_1'))
# tg ok, user in group
api.group.add_user(groupname=groupname, username='******')
self.assertTrue(group_has_user(groupname))
self.assertTrue(view.can_do_transition('propose_to_n_plus_1'))
# we do transition
api.content.transition(self.omail, transition='propose_to_n_plus_1')
createContentInContainer(
self.omail,
'dmsommainfile') # add a file so it's possible to do transition
api.content.transition(self.omail, transition='propose_to_be_signed')
self.assertEqual(api.content.get_state(self.omail), 'to_be_signed')
# tg ok, user in group
self.assertTrue(view.can_do_transition('back_to_n_plus_1'))
# tg ok, no user in group
api.group.remove_user(groupname=groupname, username='******')
self.assertFalse(group_has_user(groupname))
self.assertFalse(view.can_do_transition('back_to_n_plus_1'))
def test_IdmUtilsMethods_can_do_transition0(self):
imail = sub_create(self.portal['incoming-mail'], 'dmsincomingmail',
datetime.now(), 'my-id')
self.assertEqual(api.content.get_state(imail), 'created')
view = IdmUtilsMethods(imail, imail.REQUEST)
# no treating_group nor title: NOK
self.assertFalse(view.can_do_transition('propose_to_agent'))
imail.title = u'test'
# tg ok, state ok, assigner_user nok but auc ok: OK
imail.treating_groups = get_registry_organizations()[0]
self.assertTrue(view.can_do_transition('propose_to_agent'))
# tg ok, state ok, assigner_user nok, auc nok: NOK
setRoles(self.portal, TEST_USER_ID, ['Reviewer'])
api.portal.set_registry_record(AUC_RECORD, 'mandatory')
self.assertFalse(view.can_do_transition('propose_to_agent'))
# tg ok, state ok, assigner_user nok, auc ok: OK
api.portal.set_registry_record(AUC_RECORD, 'no_check')
self.assertTrue(view.can_do_transition('propose_to_agent'))
# tg ok, state ok, assigner_user ok, auc nok: OK
imail.assigned_user = '******'
api.portal.set_registry_record(AUC_RECORD, 'mandatory')
self.assertTrue(view.can_do_transition('propose_to_agent'))
# WE DO TRANSITION
api.content.transition(imail, 'propose_to_agent')
self.assertEqual(api.content.get_state(imail), 'proposed_to_agent')
# tg ok, state ok, (assigner_user nok, auc nok): OK
imail.assigned_user = None
self.assertTrue(view.can_do_transition('back_to_creation'))
self.assertTrue(view.can_do_transition('back_to_manager'))
self.assertFalse(view.can_do_transition('unknown'))
def test_TaskUtilsMethods_can_do_transition1(self):
task = get_object(oid='courrier1', ptype='dmsincomingmail')['tache1']
api.content.transition(task, transition='do_to_assign')
self.assertEqual(api.content.get_state(task), 'to_do')
view = TaskUtilsMethods(task, task.REQUEST)
setRoles(self.portal, TEST_USER_ID, ['Editor', 'Reviewer'])
# no assigned_group: NOK
task.assigned_group = None
self.assertFalse(view.can_do_transition('back_in_created2'))
self.assertFalse(view.can_do_transition('back_in_to_assign'))
# ag ok, no user in group
task.assigned_group = get_registry_organizations()[0]
groupname = '{}_n_plus_1'.format(task.assigned_group)
self.assertFalse(group_has_user(groupname))
self.assertTrue(view.can_do_transition('back_in_created2'))
self.assertFalse(view.can_do_transition('back_in_to_assign'))
# ag ok, user in group
api.group.add_user(groupname=groupname, username='******')
self.assertTrue(group_has_user(groupname))
self.assertFalse(view.can_do_transition('back_in_created2'))
self.assertTrue(view.can_do_transition('back_in_to_assign'))
# we do transition
api.content.transition(task, transition='back_in_to_assign')
api.content.transition(task, transition='back_in_created')
api.content.transition(task, transition='do_to_assign')
self.assertEqual(api.content.get_state(task), 'to_assign')
def AssignedUsersWithDeactivatedVocabulary__call__(self, context):
factory = getUtility(IVocabularyFactory, 'plone.principalsource.Users')
vocab = factory(context) # terms as username, userid, fullname
a_terms = []
d_terms = []
active_orgs = get_registry_organizations()
functions = [dic['fct_id'] for dic in get_registry_functions()]
for term in vocab:
for group in api.group.get_groups(username=term.value):
if group.id == 'AuthenticatedUsers':
continue
parts = group.id.split('_')
if len(parts) != 1:
group_suffix = '_'.join(parts[1:])
if group_suffix in functions and parts[
0] not in active_orgs: # not an active org
continue
term.title = term.title.decode('utf8')
a_terms.append(term)
break
else:
term.title = _tr(
'${element_title} (Inactive)',
mapping={'element_title': safe_unicode(term.title)})
d_terms.append(term)
return SimpleVocabulary(
[SimpleTerm(EMPTY_STRING, EMPTY_STRING, _('Empty value'))] +
humansorted(a_terms, key=attrgetter('title')) +
humansorted(d_terms, key=attrgetter('title')))
def setUp(self):
self.portal = self.layer['portal']
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.pw = self.portal.portal_workflow
self.imw = self.pw['incomingmail_workflow']
self.imail = sub_create(self.portal['incoming-mail'],
'dmsincomingmail', datetime.now(), 'test',
**{'title': u'test'})
api.group.create('abc_group_encoder', 'ABC group encoder')
self.portal.portal_setup.runImportStepFromProfile(
'profile-imio.dms.mail:singles',
'imiodmsmail-im_n_plus_1_wfadaptation',
run_dependencies=False)
sva = IMServiceValidation()
n_plus_2_params = {
'validation_level': 2,
'state_title': u'Valider par le chef de département',
'forward_transition_title': u'Proposer au chef de département',
'backward_transition_title': u'Renvoyer au chef de département',
'function_title': u'chef de département'
}
adapt_is_applied = sva.patch_workflow('incomingmail_workflow',
**n_plus_2_params)
if adapt_is_applied:
add_applied_adaptation(
'imio.dms.mail.wfadaptations.IMServiceValidation',
'incomingmail_workflow', True, **n_plus_2_params)
for uid in get_registry_organizations():
self.portal.acl_users.source_groups.addPrincipalToGroup(
'chef', "%s_n_plus_2" % uid)
def select_organization(org_uid, remove=False):
"""Select organization in ORGANIZATIONS_REGISTRY."""
plonegroup_organizations = get_registry_organizations()
if remove:
plonegroup_organizations.remove(org_uid)
else:
plonegroup_organizations.append(org_uid)
set_registry_organizations(plonegroup_organizations)
def test_group_deleted(self):
request = self.portal.REQUEST
# protected group
self.assertRaises(Redirect, api.group.delete, groupname='expedition')
smi = IStatusMessage(request)
msgs = smi.show()
self.assertEqual(msgs[0].message,
u"You cannot delete the group 'expedition'.")
# is used in content
group = '%s_editeur' % get_registry_organizations()[0]
# we remove this organization to escape plonegroup subscriber
set_registry_organizations(get_registry_organizations()[1:])
self.assertRaises(Redirect, api.group.delete, groupname=group)
msgs = smi.show()
self.assertEqual(
msgs[0].message,
u"You cannot delete the group '%s', used in 'Assigned group' index."
% group)
def test_dmsincomingmail_transition(self):
self.assertEqual(api.content.get_state(self.imail), 'created')
self.imail.treating_groups = get_registry_organizations()[
1] # direction-generale secretariat
api.content.transition(self.imail, 'propose_to_agent')
login(self.portal, 'agent')
self.assertIsNone(self.imail.assigned_user)
api.content.transition(self.imail, 'close')
self.assertEqual(self.imail.assigned_user, 'agent')
def test_AssignedGroupColumn(self):
group0 = get_registry_organizations()[0]
imail = sub_create(self.portal['incoming-mail'], 'dmsincomingmail',
datetime.now(), 'my-id')
task = createContentInContainer(imail,
'task',
id='testid1',
assigned_group=group0)
col = AssignedGroupColumn(self.portal, self.portal.REQUEST, None)
self.assertEqual(
col.renderCell(task).encode('utf8'), "Direction générale")
def test_dmsdocument_modified(self):
# owner changing test
orgs = get_registry_organizations()
with api.env.adopt_user(username='******'):
imail = sub_create(
self.portal['incoming-mail'], 'dmsincomingmail',
datetime.now(), 'my-id', **{
'title': u'IMail created by scanner',
'treating_groups': orgs[0]
})
dfile = createContentInContainer(
imail, 'dmsmainfile', **{'title': 'File created by scanner'})
self.assertEquals(imail.Creator(), 'scanner')
self.assertEquals(imail.owner_info()['id'], 'scanner')
self.assertEquals(imail.get_local_roles_for_userid('scanner'),
('Owner', ))
self.assertEquals(dfile.Creator(), 'scanner')
self.assertEquals(dfile.owner_info()['id'], 'scanner')
self.assertEquals(dfile.get_local_roles_for_userid('scanner'),
('Owner', ))
with api.env.adopt_user(username='******'):
imail.setTitle('IMail modified by encodeur')
zope.event.notify(ObjectModifiedEvent(imail))
self.assertEquals(imail.Creator(), 'encodeur')
self.assertEquals(imail.owner_info()['id'], 'encodeur')
self.assertEquals(imail.get_local_roles_for_userid('encodeur'),
('Owner', ))
self.assertEquals(imail.get_local_roles_for_userid('scanner'), ())
self.assertEquals(dfile.Creator(), 'encodeur')
self.assertEquals(dfile.owner_info()['id'], 'encodeur')
self.assertEquals(dfile.get_local_roles_for_userid('encodeur'),
('Owner', ))
self.assertEquals(dfile.get_local_roles_for_userid('scanner'), ())
# tasks update test
task1 = api.content.create(container=imail,
type='task',
title='task1',
id='t1',
assigned_group=orgs[1])
self.assertListEqual(task1.parents_assigned_groups, [orgs[0]])
task2 = api.content.create(container=task1,
type='task',
title='task2',
id='t2',
assigned_group=orgs[2])
self.assertListEqual(task2.parents_assigned_groups, [orgs[0], orgs[1]])
imail.treating_groups = orgs[4]
zope.event.notify(
ObjectModifiedEvent(imail, Attributes(Interface,
'treating_groups')))
self.assertListEqual(task1.parents_assigned_groups, [orgs[4]])
self.assertListEqual(task2.parents_assigned_groups, [orgs[4], orgs[1]])
def setUp(self):
self.portal = self.layer['portal']
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.pw = self.portal.portal_workflow
self.tw = self.pw['task_workflow']
self.portal.portal_setup.runImportStepFromProfile(
'profile-imio.dms.mail:singles',
'imiodmsmail-task_n_plus_1_wfadaptation',
run_dependencies=False)
for uid in get_registry_organizations():
groupname = "%s_n_plus_1" % uid
if group_has_user(groupname):
api.group.remove_user(groupname=groupname, username='******')
def test_detectContactPlonegroupChange(self):
"""Test if group creation works correctly"""
group_ids = [group.id for group in api.group.get_groups()]
organizations = get_registry_organizations()
for uid in organizations:
self.assertIn('%s_director' % uid, group_ids)
self.assertIn('%s_worker' % uid, group_ids)
d1_d_group = api.group.get(groupname='%s_director' % organizations[0])
self.assertEquals(d1_d_group.getProperty('title'), 'Department 1 (Director)')
d1s1_d_group = api.group.get(groupname='%s_director' % organizations[1])
self.assertEquals(d1s1_d_group.getProperty('title'), 'Department 1 - Service 1 (Director)')
# Changing function title
set_registry_functions([{'fct_title': u'Directors', 'fct_id': u'director', 'fct_orgs': []},
{'fct_title': u'Worker', 'fct_id': u'worker', 'fct_orgs': []}])
d1_d_group = api.group.get(groupname='%s_director' % organizations[0])
self.assertEquals(d1_d_group.getProperty('title'), 'Department 1 (Directors)')
d1s1_d_group = api.group.get(groupname='%s_director' % organizations[1])
self.assertEquals(d1s1_d_group.getProperty('title'), 'Department 1 - Service 1 (Directors)')
# Adding new organization
own_orga = get_own_organization()
own_orga['department2'].invokeFactory('organization', 'service2', title='Service 2')
# append() method on the registry doesn't trigger the event. += too
newValue = get_registry_organizations() + [own_orga['department2']['service2'].UID()]
set_registry_organizations(newValue)
group_ids = [group.id for group in api.group.get_groups()]
last_uid = get_registry_organizations()[-1]
self.assertIn('%s_director' % last_uid, group_ids)
self.assertIn('%s_worker' % last_uid, group_ids)
# Adding new function
newValue = get_registry_functions() + [{'fct_title': u'Chief', 'fct_id': u'chief', 'fct_orgs': []}]
set_registry_functions(newValue)
group_ids = [group.id for group in api.group.get_groups() if '_' in group.id]
self.assertEquals(len(group_ids), 12)
for uid in get_registry_organizations():
self.assertIn('%s_director' % uid, group_ids)
self.assertIn('%s_chief' % uid, group_ids)
self.assertIn('%s_worker' % uid, group_ids)
def test_user_related_modification(self):
voc_inst = AssignedUsersWithDeactivatedVocabulary()
voc_list = [(t.value, t.title) for t in voc_inst(self.imail)]
self.assertListEqual(voc_list,
[('__empty_string__', u'Empty value'),
('agent', u'Fred Agent'),
('encodeur', u'Jean Encodeur'),
('lecteur', u'Jef Lecteur'),
('dirg', u'Maxime DG'), ('chef', u'Michel Chef'),
('scanner', u'Scanner'),
('agent1', u'Stef Agent'),
('test-user', u'test-user (Désactivé)')])
# we change a user property
member = api.user.get(userid='chef')
member.setMemberProperties({'fullname': 'Michel Chef 2'})
# we simulate the user form change event
zope.event.notify(
ConfigurationChangedEvent(
UserDataConfiglet(self.portal, self.portal.REQUEST), {}))
voc_list = [(t.value, t.title) for t in voc_inst(self.imail)]
self.assertListEqual(voc_list,
[('__empty_string__', u'Empty value'),
('agent', u'Fred Agent'),
('encodeur', u'Jean Encodeur'),
('lecteur', u'Jef Lecteur'),
('dirg', u'Maxime DG'),
('chef', u'Michel Chef 2'),
('scanner', u'Scanner'),
('agent1', u'Stef Agent'),
('test-user', u'test-user (Désactivé)')])
# we change the activated services
set_registry_organizations(
get_registry_organizations()[0:1]) # only keep Direction générale
api.group.remove_user(
groupname='createurs_dossier',
username='******') # remove agent from global group
voc_list = [(t.value, t.title) for t in voc_inst(self.imail)]
self.assertListEqual(voc_list,
[('__empty_string__', u'Empty value'),
('encodeur', u'Jean Encodeur'),
('dirg', u'Maxime DG'),
('chef', u'Michel Chef 2'),
('scanner', u'Scanner'),
('agent', u'Fred Agent (Désactivé)'),
('lecteur', u'Jef Lecteur (Désactivé)'),
('agent1', u'Stef Agent (Désactivé)'),
('test-user', u'test-user (Désactivé)')])
# wrong configuration change
zope.event.notify(ConfigurationChangedEvent(self.portal, {}))
def test_create_persons_from_users(self):
pf = self.portal['contacts']['personnel-folder']
self.assertListEqual(pf.objectIds(),
['chef', 'dirg', 'agent1', 'agent'])
member = self.portal.portal_registration.addMember(
id='newuser', password='******')
member.setMemberProperties({
'fullname': 'Leloup Pierre',
'email': '*****@*****.**'
})
orgs = get_registry_organizations()
api.group.add_user(groupname='%s_encodeur' % orgs[0],
username='******')
# with the added subscriber, the person and held_position are already added
api.content.delete(pf['newuser'])
self.portal.portal_setup.runImportStepFromProfile(
'imio.dms.mail:singles',
'imiodmsmail-create-persons-from-users-inverted',
run_dependencies=False)
# person
self.assertListEqual(pf.objectIds(),
['chef', 'dirg', 'agent1', 'agent', 'newuser'])
nu_p = pf['newuser']
self.assertEqual(nu_p.firstname, 'Pierre')
self.assertEqual(nu_p.lastname, 'Leloup')
self.assertEqual(nu_p.portal_type, 'person')
# held position
self.assertIn(orgs[0], nu_p)
nu_hp = nu_p[orgs[0]]
self.assertEqual(nu_hp.portal_type, 'held_position')
self.assertEqual(
nu_hp.position.to_path,
'/plone/contacts/plonegroup-organization/direction-generale')
# mixed with manual content
api.content.rename(obj=nu_p, new_id='newuser_renamed')
api.content.rename(obj=nu_hp, new_id='%s_renamed' % orgs[0])
api.group.add_user(groupname='%s_encodeur' % orgs[1],
username='******')
api.content.delete(pf['newuser_renamed'][orgs[1]])
self.portal.portal_setup.runImportStepFromProfile(
'imio.dms.mail:singles',
'imiodmsmail-create-persons-from-users-inverted',
run_dependencies=False)
self.assertListEqual(
pf.objectIds(),
['chef', 'dirg', 'agent1', 'agent', 'newuser_renamed'])
self.assertListEqual(nu_p.objectIds(),
['%s_renamed' % orgs[0], orgs[1]])
def __call__(self, context):
vocab = super(SelectedOrganizationsElephantVocabulary,
self).__call__(context)
terms = vocab.by_value
ordered_terms = []
for uid in get_registry_organizations():
if uid in terms:
ordered_terms.append(terms[uid])
del terms[uid]
extra_uids = terms.keys()
extra_terms = terms.values()
# ordered_vocab = SearchableSimpleVocabulary(ordered_terms + extra_terms) # bug in widget, trac #15186
ordered_vocab = SimpleVocabulary(ordered_terms + extra_terms)
wrapped_vocab = wrap_vocabulary(ordered_vocab,
hidden_terms=extra_uids)(context)
return wrapped_vocab
def test_SelectedOrganizationsElephantVocabulary(self):
""" Test elephant vocabulary """
factory_all = getUtility(IVocabularyFactory, 'collective.contact.plonegroup.organization_services')
vocab_all = factory_all(self.portal)
vocab_all_values = [v.value for v in vocab_all]
self.assertEqual(len(vocab_all), 3)
self.assertListEqual([v.title for v in vocab_all],
['Department 1', 'Department 1 - Service 1', 'Department 2'])
set_registry_organizations([vocab_all_values[2], vocab_all_values[0]])
factory_wrp = getUtility(IVocabularyFactory, "collective.contact.plonegroup.selected_organization_services")
vocab_wrp = factory_wrp(self.portal)
self.assertEqual(len(vocab_wrp), 3)
# values are sorted by title
self.assertListEqual(sorted([v.value for v in vocab_wrp]), sorted(get_registry_organizations()))
self.assertListEqual([v.title for v in vocab_wrp], ['Department 1', 'Department 2'])
self.assertEqual(vocab_wrp.getTerm(vocab_all_values[1]).title, 'Department 1 - Service 1')
def adaptPloneGroupDefinition(organization, event):
"""
Manage an organization change
"""
# zope.lifecycleevent.ObjectRemovedEvent : delete
# zope.lifecycleevent.ObjectModifiedEvent : edit, rename
# is the container who's modified at creation ?
# bypass if we are removing the Plone Site
if IContainerModifiedEvent.providedBy(event) or \
event.object.portal_type == 'Plone Site':
return
# is the current organization a part of own organization
organization_path = '/'.join(organization.getPhysicalPath())
if not organization_path.startswith(
get_own_organization_path(
not_found_value='unfound')): # can be unfound too
return
portal = getSite()
# when an organization is removed (and its content), we check if it is used in plonegroup configuration
registry_orgs = get_registry_organizations()
if IObjectRemovedEvent.providedBy(
event) and organization.UID() in registry_orgs:
smi = IStatusMessage(organization.REQUEST)
smi.addStatusMessage(_('You cannot delete this item !'), type='error')
smi.addStatusMessage(_(
"This organization or a contained organization is used in plonegroup "
"configuration ! Remove it first from the configuration !"),
type='error')
view_url = getMultiAdapter((organization, organization.REQUEST),
name=u'plone_context_state').view_url()
organization.REQUEST['RESPONSE'].redirect(view_url)
raise Redirect(view_url)
return
pcat = portal.portal_catalog
brains = pcat(portal_type='organization', path=organization_path)
changes = False
for brain in brains:
orga = brain.getObject()
orga_uid = orga.UID()
if orga_uid in registry_orgs:
if addOrModifyOrganizationGroups(orga, orga_uid):
changes = True
if changes:
invalidate_sopgv_cache()
invalidate_sov_cache()
invalidate_soev_cache()
invalidate_ssoev_cache()
def addUsers(self, org_descriptors):
'''Creates Plone users and add it to linked Plone groups.'''
plone_utils = self.portal.plone_utils
# if we are in dev, we use DEFAULT_USER_PASSWORD, else we will generate a
# password that is compliant with the current password policy...
if is_develop_environment():
password = DEFAULT_USER_PASSWORD
else:
password = generate_password()
msg = "The password used for added users is %s" % (
password or DEFAULT_USER_PASSWORD)
logger.info(msg)
# add a portal_message so admin adding the Plone site knows password
plone_utils.addPortalMessage(msg, 'warning')
member_tool = api.portal.get_tool('portal_membership')
own_org = get_own_organization()
plonegroup_org_uids = get_registry_organizations()
for org_descr in org_descriptors:
if org_descr.parent_path:
# find parent organization following parent path from container
container = own_org.restrictedTraverse(org_descr.parent_path)
else:
container = own_org
org = container.get(org_descr.id)
# Create users
for userDescr in org_descr.getUsers():
# if we defined a generated password here above, we use it
# either we use the password provided in the applied profile
if password:
userDescr.password = password
self.addUser(userDescr)
# Add users in the correct Plone groups.
org_uid = org.UID()
if org_uid in plonegroup_org_uids:
for suffix in get_all_suffixes(org_uid):
plone_group = get_plone_group(org_uid, suffix)
group_members = plone_group.getMemberIds()
# protect in case we have suffixes only for some groups
for userDescr in getattr(org_descr, suffix, []):
if userDescr.id not in group_members:
api.group.add_user(group=plone_group,
username=userDescr.id)
if userDescr.create_member_area:
member_tool.createMemberArea(userDescr.id)
def test_encodeur_active_orgs1(self):
factory = getUtility(IVocabularyFactory,
u'collective.dms.basecontent.treating_groups')
all_titles = [t.title for t in factory(self.omail)]
login(self.portal, 'agent')
self.assertListEqual(
[t.title for t in encodeur_active_orgs(self.omail)],
[t for i, t in enumerate(all_titles) if i not in (0, 4, 7)])
org1, org2 = get_registry_organizations()[0:2]
with api.env.adopt_roles(['Manager']):
self.omail.treating_groups = org2
api.group.add_user(groupname='{}_n_plus_1'.format(org2),
username=TEST_USER_ID)
api.content.transition(obj=self.omail,
transition='propose_to_n_plus_1')
self.assertListEqual(
[t.title for t in encodeur_active_orgs(self.omail)], all_titles)
def getSelectedOrganizations(separator=' - ', first_index=1):
""" Return a list of tuples (uid, title) """
ret = []
registry_orgs = get_registry_organizations()
# needed to get as manager because plone.formwidget.masterselect calls ++widget++ as Anonymous
if api.user.is_anonymous():
with api.env.adopt_roles(['Manager']):
for orga_uid in registry_orgs:
title = unrestrictedUuidToObject(orga_uid).get_full_title(
separator=separator, first_index=first_index)
ret.append((orga_uid, title))
else:
for orga_uid in registry_orgs:
title = uuidToObject(orga_uid).get_full_title(
separator=separator, first_index=first_index)
ret.append((orga_uid, title))
return ret
def __call__(self, context):
terms = []
users = {}
titles = []
for uid in get_registry_organizations():
members = get_selected_org_suffix_users(uid, ['actioneditor'])
for member in members:
title = member.getUser().getProperty('fullname') or member.getUserName()
if title not in titles:
titles.append(title)
users[title] = [member]
elif member not in users[title]:
users[title].append(member)
for tit in sorted(titles):
for mb in users[tit]:
terms.append(SimpleTerm(mb.getMemberId(), mb.getMemberId(), tit))
# terms.insert(0, SimpleTerm(EMPTY_STRING, EMPTY_STRING, _('Empty value')))
return SimpleVocabulary(terms)
def test_view(self):
setRoles(self.portal, TEST_USER_ID, ['Contributor', 'Reviewer'])
imail = sub_create(self.portal['incoming-mail'], 'dmsincomingmail', datetime.now(), 'my-id')
self.assertEqual(api.content.get_state(imail), 'created')
view = IMView(imail, imail.REQUEST)
api.portal.set_registry_record(AUC_RECORD, 'mandatory')
view.update() # BEWARE can be called only once (plone.autoform.view.py) !
# no treating_groups: cannot do anything
self.assertEquals(view.widgets['ITask.assigned_user'].field.description, u'')
# no assigned_user but mandatory
imail.treating_groups = get_registry_organizations()[0]
view.updateWidgets() # because update() can be called only once
self.assertEquals(view.widgets['ITask.assigned_user'].field.description,
u'You must select an assigned user before you can propose to an agent !')
# no assigned user but mandatory only for n_plus_1 level
api.portal.set_registry_record(AUC_RECORD, 'n_plus_1')
view.updateWidgets()
self.assertEquals(view.widgets['ITask.assigned_user'].field.description, u'')
