def test_support_no_support_novaideo_config(self):
# SetUp the 'no_support' Nova-Ideo configuration
self.no_support_novaideo_config()
context = self.request.root
idea = Idea(
title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creatandpublish')
# Execute the action
actions[0].execute(
context, self.request, {'_object_data': idea})
idea_result = context.ideas[0]
# Members can't support the published idea
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
alice_oid = get_oid(alice)
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
expected_actions = [
'seeworkinggroups', 'duplicate',
'comment', 'present', 'associate', 'see']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 6)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
def test_submit_idea_moderation_conf(self):
# SetUp the 'moderation' Nova-Ideo configuration
self.moderation_novaideo_config()
idea_result = self.create_idea()
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='submit')
# Submit the idea
submit_action = actions[0]
submit_action.execute(
idea_result, self.request, {})
self.assertIn('submitted', idea_result.state)
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
expected_actions = [
'duplicate', 'associate', 'see',
'publish_moderation', 'archive']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 5)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
# Other member actions
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 0)
def test_archive_idea_moderation_conf(self):
# SetUp the 'moderation' Nova-Ideo configuration
self.moderation_novaideo_config()
idea_result = self.create_idea()
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='submit')
# Submit the idea
submit_action = actions[0]
submit_action.execute(
idea_result, self.request, {})
# Archive the idea
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='archive')
publish_action = actions[0]
publish_action.execute(
idea_result, self.request, {
'explanation': 'test'
})
self.assertIn('archived', idea_result.state)
# Actions
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
expected_actions = ['delidea', 'recuperate', 'associate', 'see']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 4)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
def test_publish_idea_moderation_conf(self):
# SetUp the 'moderation' Nova-Ideo configuration
self.moderation_novaideo_config()
idea_result = self.create_idea()
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='submit')
# Submit the idea
submit_action = actions[0]
submit_action.execute(
idea_result, self.request, {})
# Publish the idea
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='publish_moderation')
publish_action = actions[0]
publish_action.execute(
idea_result, self.request, {})
self.assertIn('submitted_support', idea_result.state)
self.assertIn('published', idea_result.state)
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
# User == sd Admin (No tokens, he can't support)
expected_actions = [
'seeworkinggroups', 'duplicate',
'comment', 'present', 'associate',
'see', 'moderationarchive']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 7)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
def test_submit_idea_moderation_conf(self):
# SetUp the 'moderation' Nova-Ideo configuration
self.moderation_novaideo_config()
idea_result = self.create_idea()
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement',
node_id='submit')
# Submit the idea
submit_action = actions[0]
submit_action.execute(idea_result, self.request, {})
self.assertIn('submitted', idea_result.state)
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement')
expected_actions = [
'duplicate', 'associate', 'see', 'publish_moderation', 'archive'
]
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 5)
self.assertTrue(all(a in expected_actions for a in actions_ids))
# Other member actions
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement')
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 0)
def test_publish_idea_moderation_conf(self):
# SetUp the 'moderation' Nova-Ideo configuration
self.moderation_novaideo_config()
idea_result = self.create_idea()
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement',
node_id='submit')
# Submit the idea
submit_action = actions[0]
submit_action.execute(idea_result, self.request, {})
# Publish the idea
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement',
node_id='publish_moderation')
publish_action = actions[0]
publish_action.execute(idea_result, self.request, {})
self.assertIn('submitted_support', idea_result.state)
self.assertIn('published', idea_result.state)
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement')
# User == sd Admin (No tokens, he can't support)
expected_actions = [
'seeworkinggroups', 'duplicate', 'comment', 'present', 'associate',
'see', 'moderationarchive'
]
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 7)
self.assertTrue(all(a in expected_actions for a in actions_ids))
def test_archive_idea_moderation_conf(self):
# SetUp the 'moderation' Nova-Ideo configuration
self.moderation_novaideo_config()
idea_result = self.create_idea()
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement',
node_id='submit')
# Submit the idea
submit_action = actions[0]
submit_action.execute(idea_result, self.request, {})
# Archive the idea
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement',
node_id='archive')
publish_action = actions[0]
publish_action.execute(idea_result, self.request,
{'explanation': 'test'})
self.assertIn('archived', idea_result.state)
# Actions
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement')
expected_actions = ['delidea', 'recuperate', 'associate', 'see']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 4)
self.assertTrue(all(a in expected_actions for a in actions_ids))
def test_support_no_support_novaideo_config(self):
# SetUp the 'no_support' Nova-Ideo configuration
self.no_support_novaideo_config()
context = self.request.root
idea = Idea(title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(context,
self.request,
process_id='ideamanagement',
node_id='creatandpublish')
# Execute the action
actions[0].execute(context, self.request, {'_object_data': idea})
idea_result = context.ideas[0]
# Members can't support the published idea
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
alice_oid = get_oid(alice)
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement')
expected_actions = [
'seeworkinggroups', 'duplicate', 'comment', 'present', 'associate',
'see'
]
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 6)
self.assertTrue(all(a in expected_actions for a in actions_ids))
def test_create_idea_default_conf(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
context = self.request.root
idea = Idea(
title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creat')
self.assertEqual(len(actions), 1)
create_action = actions[0]
self.assertEqual(create_action.node_id, 'creat')
self.assertEqual(create_action.process_id, 'ideamanagement')
# Execute the action
create_action.execute(
context, self.request, {'_object_data': idea})
ideas = context.ideas
self.assertEqual(len(ideas), 1)
idea_result = ideas[0]
self.assertIs(idea_result, idea)
self.assertIs(idea_result.author, self.request.user)
self.assertIn('to work', idea_result.state)
# Test the merge of keywords
self.assertEqual(len(context.keywords), 0)
# Test if we have a single action
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creat')
self.assertEqual(len(actions), 1)
# Owner actions
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
expected_actions = [
'duplicate', 'edit',
'publish', 'abandon',
'associate', 'see']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 6)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
# Other member actions
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 0)
def test_create_idea_default_conf(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
context = self.request.root
idea = Idea(
title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creat')
self.assertEqual(len(actions), 1)
create_action = actions[0]
self.assertEqual(create_action.node_id, 'creat')
self.assertEqual(create_action.process_id, 'ideamanagement')
# Execute the action
create_action.execute(
context, self.request, {'_object_data': idea})
ideas = context.ideas
self.assertEqual(len(ideas), 1)
idea_result = ideas[0]
self.assertIs(idea_result, idea)
self.assertIs(idea_result.author, self.request.user)
self.assertIn('to work', idea_result.state)
# Test the merge of keywords
self.assertEqual(len(context.keywords), 0)
# Test if we have a single action
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creat')
self.assertEqual(len(actions), 1)
# Owner actions
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
expected_actions = [
'duplicate', 'edit',
'publish', 'abandon',
'associate', 'see']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 6)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
# Other member actions
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 0)
def test_duplicate(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
context = self.request.root
idea = Idea(title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(context,
self.request,
process_id='ideamanagement',
node_id='creatandpublish')
actions[0].execute(context, self.request, {'_object_data': idea})
idea_result = context.ideas[0]
# duplicate
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement',
node_id='duplicate')
actions[0].execute(
idea_result, self.request, {
'title': 'Duplicated idea',
'text': 'Idea text',
'keywords': ['dup 1'],
'attached_files': []
})
self.assertTrue(len(context.ideas), 2)
new_idea = context.ideas[1]
self.assertIn('to work', new_idea.state)
self.assertEqual('Duplicated idea', new_idea.title)
self.assertEqual('Idea text', new_idea.text)
keywords = ['dup 1']
self.assertTrue(all(a in keywords for a in new_idea.keywords))
self.assertIs(idea_result, new_idea.originalentity)
self.assertIn(new_idea, idea_result.duplicates)
# new idea actions: can't publish ==> the same text
actions = getAllBusinessAction(new_idea,
self.request,
process_id='ideamanagement')
expected_actions = ['duplicate', 'edit', 'abandon', 'associate', 'see']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 5)
self.assertTrue(all(a in expected_actions for a in actions_ids))
# edit the text of the new idea
new_idea.text = 'Duplicated text'
# new idea actions: can publish
actions = getAllBusinessAction(new_idea,
self.request,
process_id='ideamanagement')
expected_actions = [
'duplicate', 'edit', 'abandon', 'associate', 'see', 'publish'
]
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 6)
self.assertTrue(all(a in expected_actions for a in actions_ids))
def test_abandon_recuperate_del_idea(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
idea_result = self.create_idea()
self.assertEqual(len(alice.ideas), 1)
self.assertEqual(len(alice.contents), 1)
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='abandon')
# abandon the idea
abandon_action = actions[0]
abandon_action.execute(
idea_result, self.request, {})
self.assertIn('archived', idea_result.state)
# actions
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
expected_actions = ['delidea', 'recuperate', 'associate', 'see']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 4)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
# recuperate
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='recuperate')
# recuperate the idea
recuperate_action = actions[0]
recuperate_action.execute(
idea_result, self.request, {})
self.assertIn('to work', idea_result.state)
# abandon
abandon_action.execute(
idea_result, self.request, {})
# delete
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='delidea')
# delete the idea
delidea_action = actions[0]
delidea_action.execute(
idea_result, self.request, {})
self.assertEqual(len(self.request.root.ideas), 0)
self.assertEqual(len(alice.ideas), 0)
self.assertEqual(len(alice.contents), 0)
def test_abandon_recuperate_del_idea(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
idea_result = self.create_idea()
self.assertEqual(len(alice.ideas), 1)
self.assertEqual(len(alice.contents), 1)
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='abandon')
# abandon the idea
abandon_action = actions[0]
abandon_action.execute(
idea_result, self.request, {})
self.assertIn('archived', idea_result.state)
# actions
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
expected_actions = ['delidea', 'recuperate', 'associate', 'see']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 4)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
# recuperate
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='recuperate')
# recuperate the idea
recuperate_action = actions[0]
recuperate_action.execute(
idea_result, self.request, {})
self.assertIn('to work', idea_result.state)
# abandon
abandon_action.execute(
idea_result, self.request, {})
# delete
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='delidea')
# delete the idea
delidea_action = actions[0]
delidea_action.execute(
idea_result, self.request, {})
self.assertEqual(len(self.request.root.ideas), 0)
self.assertEqual(len(alice.ideas), 0)
self.assertEqual(len(alice.contents), 0)
def test_create_and_publish_idea_moderation_conf(self):
# SetUp the 'moderation' Nova-Ideo configuration
self.moderation_novaideo_config()
context = self.request.root
idea = Idea(
title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creatandpublish')
self.assertEqual(len(actions), 1)
create_action = actions[0]
self.assertEqual(create_action.node_id, 'creatandpublish')
self.assertEqual(create_action.process_id, 'ideamanagement')
# Execute the action
create_action.execute(
context, self.request, {'_object_data': idea})
ideas = context.ideas
self.assertEqual(len(ideas), 1)
idea_result = ideas[0]
self.assertIs(idea_result, idea)
self.assertIs(idea_result.author, self.request.user)
self.assertIn('submitted', idea_result.state)
# Test the merge of keywords
self.assertEqual(len(context.keywords), 0)
# Admin (Owner) actions
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
# User == sd Admin (No tokens, he can't support)
expected_actions = [
'duplicate', 'associate', 'see',
'publish_moderation', 'archive']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 5)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
# Other member actions
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 0)
def test_create_and_publish_idea_moderation_conf(self):
# SetUp the 'moderation' Nova-Ideo configuration
self.moderation_novaideo_config()
context = self.request.root
idea = Idea(
title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creatandpublish')
self.assertEqual(len(actions), 1)
create_action = actions[0]
self.assertEqual(create_action.node_id, 'creatandpublish')
self.assertEqual(create_action.process_id, 'ideamanagement')
# Execute the action
create_action.execute(
context, self.request, {'_object_data': idea})
ideas = context.ideas
self.assertEqual(len(ideas), 1)
idea_result = ideas[0]
self.assertIs(idea_result, idea)
self.assertIs(idea_result.author, self.request.user)
self.assertIn('submitted', idea_result.state)
# Test the merge of keywords
self.assertEqual(len(context.keywords), 0)
# Admin (Owner) actions
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
# User == sd Admin (No tokens, he can't support)
expected_actions = [
'duplicate', 'associate', 'see',
'publish_moderation', 'archive']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 5)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
# Other member actions
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 0)
def test_comment(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
bob = add_user({
'first_name': 'Bob',
'last_name': 'Bob',
'email': '*****@*****.**'
}, self.request)
self.request.user = alice
context = self.request.root
idea = Idea(
title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creatandpublish')
actions[0].execute(
context, self.request, {'_object_data': idea})
idea_result = context.ideas[0]
self.assertTrue(idea_result.channel is not None)
self.assertEqual(idea_result.channel.len_comments, 0)
# comment
self.request.user = bob
comment = Comment(
comment='The comment',
intention='Remark'
)
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='comment')
actions[0].execute(
idea_result, self.request, {
'_object_data': comment,
})
self.assertEqual(idea_result.channel.len_comments, 1)
self.assertIn(comment, idea_result.channel.comments)
self.assertIn('published', comment.state)
self.assertIs(bob, comment.author)
self.assertEqual(len(bob.following_channels), 1)
self.assertIn(idea_result.channel, bob.following_channels)
def test_comment(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
bob = add_user({
'first_name': 'Bob',
'last_name': 'Bob',
'email': '*****@*****.**'
}, self.request)
self.request.user = alice
context = self.request.root
idea = Idea(
title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creatandpublish')
actions[0].execute(
context, self.request, {'_object_data': idea})
idea_result = context.ideas[0]
self.assertTrue(idea_result.channel is not None)
self.assertEqual(idea_result.channel.len_comments, 0)
# comment
self.request.user = bob
comment = Comment(
comment='The comment',
intention='Remark'
)
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='comment')
actions[0].execute(
idea_result, self.request, {
'_object_data': comment,
})
self.assertEqual(idea_result.channel.len_comments, 1)
self.assertIn(comment, idea_result.channel.comments)
self.assertIn('published', comment.state)
self.assertIs(bob, comment.author)
self.assertEqual(len(bob.following_channels), 1)
self.assertIn(idea_result.channel, bob.following_channels)
def replies_to_comment(replies, source, comment_action):
for reply in replies.values():
comment_data = reply['data']
comment = Comment(
intention=_('Remark'),
comment=comment_data.pop('text'),
files=comment_data.pop('attached_files')
)
if comment_action:
comment_action.execute(
source, request, {
'_object_data': comment,
'user': comment_data.pop('author'),
'alert': False,
})
sub_replies = reply['replies']
if sub_replies:
comment_actions = getAllBusinessAction(
comment, request,
process_id='commentmanagement', node_id='respond',
process_discriminator='Application')
if comment_actions:
replies_to_comment(
sub_replies, comment, comment_actions[0])
def get_actions(self,
contexts,
request,
process_or_id=None,
action_id=None,
process_discriminator=None,
isautomatic=False):
all_actions = []
process_id = None
process = None
if process_or_id and isinstance(process_or_id, basestring):
process_id = process_or_id
elif process_or_id:
process = process_or_id
for context in contexts:
actions = getAllBusinessAction(
context, request,
isautomatic=isautomatic,
process_id=process_id,
node_id=action_id,
process_discriminator=process_discriminator)
if process:
actions = [action for action in actions
if action.process is process]
# actions = sorted(actions, key=lambda action: action.node_id)
p_actions = [(context, a) for a in actions]
all_actions.extend(p_actions)
return all_actions
def __call__(self):
root = getSite()
actions = []
for action_class, data in self.actions.items():
item_actions = getAllBusinessAction(root,
self.request,
process_id=data[0],
node_id=data[1])
action = None
if item_actions:
action = item_actions[0]
actions.append({
'title':
action_class.title,
'action':
action,
'unavailable_link':
getattr(action_class, 'unavailable_link', None),
'order':
getattr(action_class, 'style_order', 100),
'style_btn':
data[2],
'style_picto':
getattr(action_class, 'style_picto', '')
})
actions = sorted(actions, key=lambda e: e['order'])
return {'items': actions}
def test_edit_idea(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
idea_result = self.create_idea()
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='edit')
# Edit the idea
edit_action = actions[0]
edit_action.execute(
idea_result, self.request, {
'title': 'Edited idea',
'text': 'Edited idea text',
'keywords': ['edit 1'],
'attached_files': []
})
self.assertIn('to work', idea_result.state)
self.assertEqual('Edited idea', idea_result.title)
self.assertEqual('Edited idea text', idea_result.text)
keywords = ['edit 1']
self.assertTrue(all(a in keywords
for a in idea_result.keywords))
# New version
version = idea_result.version
self.assertTrue(version is not None)
self.assertIn('version', version.state)
self.assertIn('archived', version.state)
self.assertEqual('Idea title', version.title)
self.assertEqual('Idea text', version.text)
keywords = ["keyword 1", "keyword 2"]
self.assertTrue(all(a in keywords
for a in version.keywords))
# version actions
actions = getAllBusinessAction(
version, self.request,
process_id='ideamanagement')
expected_actions = ['duplicate', 'associate', 'see']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 3)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
def test_edit_idea(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
idea_result = self.create_idea()
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='edit')
# Edit the idea
edit_action = actions[0]
edit_action.execute(
idea_result, self.request, {
'title': 'Edited idea',
'text': 'Edited idea text',
'keywords': ['edit 1'],
'attached_files': []
})
self.assertIn('to work', idea_result.state)
self.assertEqual('Edited idea', idea_result.title)
self.assertEqual('Edited idea text', idea_result.text)
keywords = ['edit 1']
self.assertTrue(all(a in keywords
for a in idea_result.keywords))
# New version
version = idea_result.version
self.assertTrue(version is not None)
self.assertIn('version', version.state)
self.assertIn('archived', version.state)
self.assertEqual('Idea title', version.title)
self.assertEqual('Idea text', version.text)
keywords = ["keyword 1", "keyword 2"]
self.assertTrue(all(a in keywords
for a in version.keywords))
# version actions
actions = getAllBusinessAction(
version, self.request,
process_id='ideamanagement')
expected_actions = ['duplicate', 'associate', 'see']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 3)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
def create_idea(request, title, text, keywords):
"""Create an Idea."""
container = request.root
idea = Idea(title=title, text=text, keywords=keywords)
actions = getAllBusinessAction(container,
request,
process_id='ideamanagement',
node_id='creatandpublish')
create_action = actions[0]
create_action.execute(container, request, {'_object_data': idea})
def test_present(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
bob = add_user({
'first_name': 'Bob',
'last_name': 'Bob',
'email': '*****@*****.**'
}, self.request)
self.request.user = alice
context = self.request.root
idea = Idea(
title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creatandpublish')
actions[0].execute(
context, self.request, {'_object_data': idea})
idea_result = context.ideas[0]
# present
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='present')
actions[0].execute(
idea_result, self.request, {
'members': [bob],
'subject': 'Subject',
'message': 'Message',
'send_to_me': False,
})
self.assertEqual(idea_result.len_contacted, 1)
self.assertIn(bob, idea_result.persons_contacted)
def test_present(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
bob = add_user({
'first_name': 'Bob',
'last_name': 'Bob',
'email': '*****@*****.**'
}, self.request)
self.request.user = alice
context = self.request.root
idea = Idea(
title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creatandpublish')
actions[0].execute(
context, self.request, {'_object_data': idea})
idea_result = context.ideas[0]
# present
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='present')
actions[0].execute(
idea_result, self.request, {
'members': [bob],
'subject': 'Subject',
'message': 'Message',
'send_to_me': False,
})
self.assertEqual(idea_result.len_contacted, 1)
self.assertIn(bob, idea_result.persons_contacted)
def start(self, context, request, appstruct, **kw):
result = super(ImproveProposalAndExplain, self).start(context, request, appstruct, **kw)
amendment = result.get('newcontext', None)
if amendment:
explanations_actions = getAllBusinessAction(
amendment,
request,
node_id="explanation",
process_id="amendmentmanagement")
if explanations_actions:
explanations_actions[0].execute(amendment, request, {})
return {'newcontext': amendment}
def get_action(action_id, context, request):
node_process = action_id.split('.')
if len(node_process) == 2:
process_id, node_id = node_process
node_actions = getAllBusinessAction(
context,
request,
process_id=process_id,
node_id=node_id,
process_discriminator='Application')
if node_actions:
return node_actions[0]
return None
def create_idea(request, title, text, keywords):
"""Create an Idea."""
container = request.root
idea = Idea(
title=title,
text=text,
keywords=keywords
)
actions = getAllBusinessAction(
container, request, process_id='ideamanagement',
node_id='creatandpublish')
create_action = actions[0]
create_action.execute(
container, request, {'_object_data': idea})
def start(self, context, request, appstruct, **kw):
result = super(ImproveProposalAndExplain,
self).start(context, request, appstruct, **kw)
amendment = result.get('newcontext', None)
if amendment:
explanations_actions = getAllBusinessAction(
amendment,
request,
node_id="explanation",
process_id="amendmentmanagement")
if explanations_actions:
explanations_actions[0].execute(amendment, request, {})
return {'newcontext': amendment}
def create_idea(self):
context = self.request.root
idea = Idea(title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(context,
self.request,
process_id='ideamanagement',
node_id='creat')
create_action = actions[0]
# Excute the action
create_action.execute(context, self.request, {'_object_data': idea})
ideas = context.ideas
return ideas[0]
def test_create_idea_moderation_conf(self):
# SetUp the 'moderation' Nova-Ideo configuration
self.moderation_novaideo_config()
idea_result = self.create_idea()
self.assertIn('to work', idea_result.state)
# can submit, can't publish
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement')
expected_actions = [
'duplicate', 'edit', 'abandon', 'associate', 'see', 'submit'
]
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 6)
self.assertTrue(all(a in expected_actions for a in actions_ids))
def get_actions(context, request, args):
process_id = args.get('process_id', '')
node_ids = args.get('node_ids', '')
if not node_ids:
return [
ActionCall(a, context)
for a in getAllBusinessAction(context,
request,
process_id=process_id,
process_discriminator='Application')
]
result = []
for node_id in node_ids:
result.extend([
ActionCall(a, context)
for a in getAllBusinessAction(context,
request,
process_id=process_id,
node_id=node_id,
process_discriminator='Application')
])
return result
def test_create_idea_moderation_conf(self):
# SetUp the 'moderation' Nova-Ideo configuration
self.moderation_novaideo_config()
idea_result = self.create_idea()
self.assertIn('to work', idea_result.state)
# can submit, can't publish
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
expected_actions = [
'duplicate', 'edit', 'abandon',
'associate', 'see', 'submit']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 6)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
def create_idea(self):
context = self.request.root
idea = Idea(
title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creat')
create_action = actions[0]
# Excute the action
create_action.execute(
context, self.request, {'_object_data': idea})
ideas = context.ideas
return ideas[0]
def _update_action_view(self, node_id=None, process_id=None):
action_uid = self.params('action_uid')
action = None
try:
action = get_obj(int(action_uid))
except Exception:
pass
if action is None:
if not node_id:
node_process = self.params('node_id').split('.')
process_id = node_process[0]
node_id = node_process[1]
node_actions = getAllBusinessAction(
self.context,
self.request,
process_id=process_id,
node_id=node_id,
process_discriminator='Application')
if node_actions:
action = node_actions[0]
if action is not None:
action_id = action.process_id + '.' + action.node_id
node_view = DEFAULTMAPPING_ACTIONS_VIEWS[action.__class__]
node_view_instance = node_view(self.context,
self.request,
behaviors=[action],
only_form=True)
view_result = node_view_instance()
return {
'status': True,
'action_obj': action,
'action_uid': action_id,
'view_data': (node_view_instance, view_result)
}
return {
'status': False,
'action_obj': None,
'action_uid': None,
'view_data': None
}
def _update_action_view(self, node_id=None, process_id=None):
action_uid = self.params('action_uid')
action = None
try:
action = get_obj(int(action_uid))
except Exception:
pass
if action is None:
if not node_id:
node_process = self.params('node_id').split('.')
process_id = node_process[0]
node_id = node_process[1]
node_actions = getAllBusinessAction(
self.context, self.request,
process_id=process_id, node_id=node_id,
process_discriminator='Application')
if node_actions:
action = node_actions[0]
if action is not None:
action_id = action.process_id + '.' + action.node_id
node_view = DEFAULTMAPPING_ACTIONS_VIEWS[action.__class__]
node_view_instance = node_view(
self.context, self.request,
behaviors=[action],
only_form=True)
view_result = node_view_instance()
return {
'status': True,
'action_obj': action,
'action_uid': action_id,
'view_data': (node_view_instance, view_result)}
return {
'status': False,
'action_obj': None,
'action_uid': None,
'view_data': None}
def update(self):
allactions = getAllBusinessAction(self.context, self.request, True)
allactions.sort(key=lambda x: x.title)
views = []
for action in allactions:
views.append(action.action_view)
if views:
indexmultiview = MultipleView(
self.context, self.request, self.parent)
indexmultiview.wrapper_template = 'templates/views_templates/empty_view_wrapper.pt'
indexmultiview.template = 'templates/views_templates/simple_multipleview.pt'
indexmultiview.css_class = 'index-view'
indexmultiview.coordinates = self.coordinates
indexmultiview._init_views(views)
indexmultiview.before_update()
return indexmultiview.update()
error = ViewError()
error.principalmessage = IndexViewErrorPrincipalmessage
error.causes = IndexViewErrorCauses
raise error
def update(self):
allactions = getAllBusinessAction(self.context, self.request, True)
allactions.sort(key=lambda x: x.title)
views = []
for action in allactions:
views.append(action.action_view)
if views:
indexmultiview = MultipleView(self.context, self.request,
self.parent)
indexmultiview.wrapper_template = 'templates/views_templates/empty_view_wrapper.pt'
indexmultiview.template = 'templates/views_templates/simple_multipleview.pt'
indexmultiview.css_class = 'index-view'
indexmultiview.coordinates = self.coordinates
indexmultiview._init_views(views)
indexmultiview.before_update()
return indexmultiview.update()
error = ViewError()
error.principalmessage = IndexViewErrorPrincipalmessage
error.causes = IndexViewErrorCauses
raise error
def __call__(self):
root = getSite()
actions = []
for action_class, data in self.actions.items():
item_actions = getAllBusinessAction(
root,
self.request,
process_id=data[0],
node_id=data[1])
action = None
if item_actions:
action = item_actions[0]
actions.append({'title': action_class.title,
'action': action,
'unavailable_link': getattr(
action_class, 'unavailable_link', None),
'order': getattr(action_class, 'style_order', 100),
'style_btn': data[2],
'style_picto': getattr(action_class,
'style_picto', '')})
actions = sorted(actions, key=lambda e: e['order'])
return {'items': actions}
def actions_getter():
return [a for a in getAllBusinessAction(
root, process_discriminator='Application')
if getattr(a, 'style', '') == 'button']
def actions(self):
allactions = getAllBusinessAction(self)
return [ActionCall(a, self) for a in allactions]
def test_support_withdraw_oppose_idea(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
context = self.request.root
idea = Idea(
title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creatandpublish')
# Execute the action
actions[0].execute(
context, self.request, {'_object_data': idea})
idea_result = context.ideas[0]
# Other member actions
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
alice_oid = get_oid(alice)
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='support')
support_action = actions[0]
support_action.execute(
idea_result, self.request, {})
self.assertEqual(idea_result.len_support, 1)
self.assertIs(idea_result.evaluation(alice), 'support')
self.assertEqual(idea_result.len_opposition, 0)
self.assertEqual(len(alice.evaluated_objs()), 1)
self.assertEqual(len(idea_result._support_history), 1)
# _support_history = [(user_oid, date, type[1, 0, -1])]
self.assertIs(idea_result._support_history[0][0], alice_oid)
# 1 == support
self.assertEqual(idea_result._support_history[0][2], 1)
# Alice can't support. Alice can withdraw the token
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
expected_actions = [
'seeworkinggroups', 'duplicate',
'comment', 'present', 'associate',
'see', 'withdraw_token', 'oppose']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 8)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
# Withdraw
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='withdraw_token')
withdraw_token_action = actions[0]
withdraw_token_action.execute(
idea_result, self.request, {})
self.assertEqual(idea_result.len_support, 0)
self.assertEqual(idea_result.len_opposition, 0)
self.assertEqual(len(alice.evaluated_objs()), 0)
self.assertEqual(len(idea_result._support_history), 2)
self.assertIs(idea_result._support_history[1][0], alice_oid)
# -1 == withdraw
self.assertEqual(idea_result._support_history[1][2], -1)
# Alice can support and can oppose
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
expected_actions = [
'seeworkinggroups', 'duplicate',
'comment', 'present', 'associate',
'see', 'support', 'oppose']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 8)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
# oppose
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='oppose')
oppose_action = actions[0]
oppose_action.execute(
idea_result, self.request, {})
self.assertEqual(idea_result.len_support, 0)
self.assertEqual(idea_result.len_opposition, 1)
self.assertEqual(len(alice.evaluated_objs()), 1)
self.assertEqual(len(idea_result._support_history), 3)
self.assertIs(idea_result._support_history[2][0], alice_oid)
# 0 == oppose
self.assertEqual(idea_result._support_history[2][2], 0)
# Alice can't support and cant oppose. Alice can withdraw the token
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
expected_actions = [
'seeworkinggroups', 'duplicate',
'comment', 'present', 'associate',
'see', 'withdraw_token', 'support']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 8)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
def actions(self):
allactions = getAllBusinessAction(self)
return [ActionCall(a, self) for a in allactions]
def test_duplicate(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
context = self.request.root
idea = Idea(
title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creatandpublish')
actions[0].execute(
context, self.request, {'_object_data': idea})
idea_result = context.ideas[0]
# duplicate
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='duplicate')
actions[0].execute(
idea_result, self.request, {
'title': 'Duplicated idea',
'text': 'Idea text',
'keywords': ['dup 1'],
'attached_files': []
})
self.assertTrue(len(context.ideas), 2)
new_idea = context.ideas[1]
self.assertIn('to work', new_idea.state)
self.assertEqual('Duplicated idea', new_idea.title)
self.assertEqual('Idea text', new_idea.text)
keywords = ['dup 1']
self.assertTrue(all(a in keywords
for a in new_idea.keywords))
self.assertIs(idea_result, new_idea.originalentity)
self.assertIn(new_idea, idea_result.duplicates)
# new idea actions: can't publish ==> the same text
actions = getAllBusinessAction(
new_idea, self.request,
process_id='ideamanagement')
expected_actions = ['duplicate', 'edit', 'abandon', 'associate', 'see']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 5)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
# edit the text of the new idea
new_idea.text = 'Duplicated text'
# new idea actions: can publish
actions = getAllBusinessAction(
new_idea, self.request,
process_id='ideamanagement')
expected_actions = [
'duplicate', 'edit',
'abandon', 'associate',
'see', 'publish']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 6)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
def actions_getter():
return [
a for a in getAllBusinessAction(
root, process_discriminator='Application')
if getattr(a, 'style', '') == 'button'
]
def test_examine_examination_config(self):
self.examination_novaideo_config()
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
# Bob is an Examiner
bob = add_user(
{
'first_name': 'Bob',
'last_name': 'Bob',
'email': '*****@*****.**'
}, self.request, ('Examiner', ))
self.request.user = alice
context = self.request.root
idea = Idea(title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(context,
self.request,
process_id='ideamanagement',
node_id='creatandpublish')
actions[0].execute(context, self.request, {'_object_data': idea})
idea_result = context.ideas[0]
# Alice support the idea
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement',
node_id='support')
support_action = actions[0]
support_action.execute(idea_result, self.request, {})
self.assertEqual(idea_result.len_support, 1)
self.assertEqual(len(alice.evaluated_objs()), 1)
# Alice can't examine
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement')
actions_ids = [a.node_id for a in actions]
self.assertFalse('makeitsopinion' in actions_ids)
# Bob can examine
self.request.user = bob
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement')
actions_ids = [a.node_id for a in actions]
self.assertTrue('makeitsopinion' in actions_ids)
# makeitsopinion
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement',
node_id='makeitsopinion')
actions[0].execute(idea_result, self.request, {
'_csrf_token_': 'none',
'opinion': 'to_study',
'explanation': 'test'
})
self.assertIn('examined', idea_result.state)
self.assertIn('published', idea_result.state)
self.assertIn('to_study', idea_result.state)
# Tokens are not removed from the idea
self.assertEqual(idea_result.len_support, 1)
# Tokens are removed from the user object
self.assertEqual(len(alice.evaluated_objs()), 0)
# actions: can't support
self.request.user = alice
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement')
expected_actions = [
'duplicate', 'comment', 'present', 'associate', 'see'
]
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 5)
self.assertTrue(all(a in expected_actions for a in actions_ids))
def test_support_withdraw_oppose_idea(self):
# SetUp the default Nova-Ideo configuration
self.default_novaideo_config()
context = self.request.root
idea = Idea(title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(context,
self.request,
process_id='ideamanagement',
node_id='creatandpublish')
# Execute the action
actions[0].execute(context, self.request, {'_object_data': idea})
idea_result = context.ideas[0]
# Other member actions
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
self.request.user = alice
alice_oid = get_oid(alice)
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement',
node_id='support')
support_action = actions[0]
support_action.execute(idea_result, self.request, {})
self.assertEqual(idea_result.len_support, 1)
self.assertIs(idea_result.evaluation(alice), 'support')
self.assertEqual(idea_result.len_opposition, 0)
self.assertEqual(len(alice.evaluated_objs()), 1)
self.assertEqual(len(idea_result._support_history), 1)
# _support_history = [(user_oid, date, type[1, 0, -1])]
self.assertIs(idea_result._support_history[0][0], alice_oid)
# 1 == support
self.assertEqual(idea_result._support_history[0][2], 1)
# Alice can't support. Alice can withdraw the token
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement')
expected_actions = [
'seeworkinggroups', 'duplicate', 'comment', 'present', 'associate',
'see', 'withdraw_token', 'oppose'
]
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 8)
self.assertTrue(all(a in expected_actions for a in actions_ids))
# Withdraw
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement',
node_id='withdraw_token')
withdraw_token_action = actions[0]
withdraw_token_action.execute(idea_result, self.request, {})
self.assertEqual(idea_result.len_support, 0)
self.assertEqual(idea_result.len_opposition, 0)
self.assertEqual(len(alice.evaluated_objs()), 0)
self.assertEqual(len(idea_result._support_history), 2)
self.assertIs(idea_result._support_history[1][0], alice_oid)
# -1 == withdraw
self.assertEqual(idea_result._support_history[1][2], -1)
# Alice can support and can oppose
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement')
expected_actions = [
'seeworkinggroups', 'duplicate', 'comment', 'present', 'associate',
'see', 'support', 'oppose'
]
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 8)
self.assertTrue(all(a in expected_actions for a in actions_ids))
# oppose
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement',
node_id='oppose')
oppose_action = actions[0]
oppose_action.execute(idea_result, self.request, {})
self.assertEqual(idea_result.len_support, 0)
self.assertEqual(idea_result.len_opposition, 1)
self.assertEqual(len(alice.evaluated_objs()), 1)
self.assertEqual(len(idea_result._support_history), 3)
self.assertIs(idea_result._support_history[2][0], alice_oid)
# 0 == oppose
self.assertEqual(idea_result._support_history[2][2], 0)
# Alice can't support and cant oppose. Alice can withdraw the token
actions = getAllBusinessAction(idea_result,
self.request,
process_id='ideamanagement')
expected_actions = [
'seeworkinggroups', 'duplicate', 'comment', 'present', 'associate',
'see', 'withdraw_token', 'support'
]
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 8)
self.assertTrue(all(a in expected_actions for a in actions_ids))
def start(self, context, request, appstruct, **kw):
novaideo_catalog = find_catalog('novaideo')
dace_catalog = find_catalog('dace')
identifier_index = novaideo_catalog['identifier']
object_provides_index = dace_catalog['object_provides']
query = object_provides_index.any([Iidea.__identifier__]) &\
identifier_index.any([YAMMER_CONNECTOR_ID+'_'+i for i in appstruct['messages']])
ideas = list(query.execute().all())
current_ideas = [i.source_data[YAMMER_CONNECTOR_ID]['id'] for i in ideas]
messages = [m for m in appstruct['messages'] if m not in current_ideas]
if not messages:
return {}
root = getSite()
yammer_connectors = list(root.get_connectors(YAMMER_CONNECTOR_ID))
yammer_connector = yammer_connectors[0] if yammer_connectors else None
access_token = yammer_connector.get_access_tokens(get_current()).get('access_token', None) \
if yammer_connector else None
def replies_to_comment(replies, source, comment_action):
for reply in replies.values():
comment_data = reply['data']
comment = Comment(
intention=_('Remark'),
comment=comment_data.pop('text'),
files=comment_data.pop('attached_files')
)
if comment_action:
comment_action.execute(
source, request, {
'_object_data': comment,
'user': comment_data.pop('author'),
'alert': False,
})
sub_replies = reply['replies']
if sub_replies:
comment_actions = getAllBusinessAction(
comment, request,
process_id='commentmanagement', node_id='respond',
process_discriminator='Application')
if comment_actions:
replies_to_comment(
sub_replies, comment, comment_actions[0])
if yammer_connector and access_token:
for m_id in messages:
idea_data, replies = get_message_data(
request, int(m_id), access_token, True, True)
if idea_data:
author = idea_data.pop('author')
idea = Idea(**idea_data)
root.addtoproperty('ideas', idea)
if root.support_ideas:
idea.state = PersistentList(
['submitted_support', 'published'])
else:
idea.state = PersistentList(
['published', 'submitted_support'])
idea.init_published_at()
grant_roles(user=author, roles=(('Owner', idea), ))
idea.setproperty('author', author)
idea.subscribe_to_channel(author)
idea.format(request)
idea.set_source_data({
'app_name': YAMMER_CONNECTOR_ID,
'id': m_id
})
idea.reindex()
# add comments
comment_actions = getAllBusinessAction(
idea, request,
process_id='ideamanagement', node_id='comment',
process_discriminator='Application')
if comment_actions:
replies_to_comment(replies, idea, comment_actions[0])
return {}
def test_examine_examination_config(self):
self.examination_novaideo_config()
alice = add_user({
'first_name': 'Alice',
'last_name': 'Alice'
}, self.request)
# Bob is an Examiner
bob = add_user({
'first_name': 'Bob',
'last_name': 'Bob',
'email': '*****@*****.**'
}, self.request, ('Examiner', ))
self.request.user = alice
context = self.request.root
idea = Idea(
title="Idea title",
text="Idea text",
keywords=["keyword 1", "keyword 2"])
# Find the 'creat' action of the idea management process
actions = getAllBusinessAction(
context, self.request,
process_id='ideamanagement',
node_id='creatandpublish')
actions[0].execute(
context, self.request, {'_object_data': idea})
idea_result = context.ideas[0]
# Alice support the idea
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='support')
support_action = actions[0]
support_action.execute(
idea_result, self.request, {})
self.assertEqual(idea_result.len_support, 1)
self.assertEqual(len(alice.evaluated_objs()), 1)
# Alice can't examine
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
actions_ids = [a.node_id for a in actions]
self.assertFalse('makeitsopinion' in actions_ids)
# Bob can examine
self.request.user = bob
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
actions_ids = [a.node_id for a in actions]
self.assertTrue('makeitsopinion' in actions_ids)
# makeitsopinion
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement',
node_id='makeitsopinion')
actions[0].execute(
idea_result, self.request, {
'_csrf_token_': 'none',
'opinion': 'to_study',
'explanation': 'test'})
self.assertIn('examined', idea_result.state)
self.assertIn('published', idea_result.state)
self.assertIn('to_study', idea_result.state)
# Tokens are not removed from the idea
self.assertEqual(idea_result.len_support, 1)
# Tokens are removed from the user object
self.assertEqual(len(alice.evaluated_objs()), 0)
# actions: can't support
self.request.user = alice
actions = getAllBusinessAction(
idea_result, self.request,
process_id='ideamanagement')
expected_actions = [
'duplicate', 'comment',
'present', 'associate', 'see']
actions_ids = [a.node_id for a in actions]
self.assertEqual(len(actions_ids), 5)
self.assertTrue(all(a in expected_actions
for a in actions_ids))
