def setUp(self):
"""
"""
app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
self.tool = getToolByName(self.portal, SUBSCRIPTION_TOOL, None)
self.markRequestWithLayer()
self.portal_url = self.portal.absolute_url()
self.browser = Browser(app)
self.browser.addHeader('Authorization', 'Basic %s:%s' % (SITE_OWNER_NAME, SITE_OWNER_PASSWORD,))
#Create some rules
for x in ["first", "second", "third"]:
#set some rules
rule = Rule()
rule.event = IObjectAddedEvent
rule.title = "%s rule" % x
#add the rules to rule's storage
storage = getUtility(IRuleStorage)
chooser = INameChooser(storage)
storage[chooser.chooseName(None, rule)] = rule
#set the action and add it to the rule
action = MailSubscriptionsAction()
action.subject = "Test %s action subject" % x
rule.actions.append(action)
email1 = "*****@*****.**"
email2 = "*****@*****.**"
self.tool.registerUser(action.actionUID, email1)
self.tool.registerUser(action.actionUID, email2)
transaction.commit()
def setUp(self):
"""
"""
app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
self.tool = getToolByName(self.portal, SUBSCRIPTION_TOOL, None)
self.markRequestWithLayer()
self.portal_url = self.portal.absolute_url()
self.browser = Browser(app)
self.browser.addHeader(
'Authorization', 'Basic %s:%s' % (
SITE_OWNER_NAME,
SITE_OWNER_PASSWORD,
))
#Create some rules
for x in ["first", "second", "third"]:
#set some rules
rule = Rule()
rule.event = IObjectAddedEvent
rule.title = "%s rule" % x
#add the rules to rule's storage
storage = getUtility(IRuleStorage)
chooser = INameChooser(storage)
storage[chooser.chooseName(None, rule)] = rule
#set the action and add it to the rule
action = MailSubscriptionsAction()
action.subject = "Test %s action subject" % x
rule.actions.append(action)
email1 = "*****@*****.**"
email2 = "*****@*****.**"
self.tool.registerUser(action.actionUID, email1)
self.tool.registerUser(action.actionUID, email2)
transaction.commit()
def createRule(self, context, rule_context, rule_id, rule_title, rule_description,
rule_event, message, subject, for_types=None, area_id=None):
"""
Enabled types are taken from the Plone registry, or you can manually set them using for_types
Id of the area (used for getting the notification group) is taken from current area, or by area_id param
"""
registry = queryUtility(IRegistry)
settings = registry.forInterface(IGroupwareNotifySettings, check=False)
#create the rule
rule = Rule()
rule.__name__ = rule_id
rule.event = rule_event
rule.title = rule_title
rule.description = rule_description
#add the rule to rule's storage
storage = getUtility(IRuleStorage)
# chooser = INameChooser(storage)
if rule_id not in storage.keys():
storage[rule_id] = rule
#set the action and add it to the rule
action = MailForGroupwareNotificationAction(area_id)
if settings and settings.default_email_sender:
action.source = settings.default_email_sender
action.sender = None
action.subject = subject
action.message = message
rule.actions.append(action)
if not for_types:
#set the condition and add it to the rule
if settings:
behavior = ISelectableConstrainTypes(rule_context)
allowed_types = behavior.getLocallyAllowedTypes()
types_list = set(allowed_types).difference(settings.black_list)
condition = PortalTypeCondition()
condition.check_types=tuple(types_list)
rule.conditions.append(condition)
else:
# explicit types
condition=PortalTypeCondition()
condition.check_types=tuple(for_types)
rule.conditions.append(condition)
logger.info('Created rule %s' % rule_id)
#assignment
rule_id=rule.id.replace('++rule++','')
assignable = IRuleAssignmentManager(rule_context)
assignable[rule_id] = RuleAssignment(rule_id)
assignable[rule_id].bubbles=True
get_assignments(storage[rule_id]).insert('/'.join(rule_context.getPhysicalPath()))
logger.info('Enabled rule %s on %s' % (rule_id, rule_context.Title().decode('utf-8')))
def test_already_registered_email(self):
"""
try to re-register an email for the same rule id
"""
rule = Rule()
rule.event = IObjectAddedEvent
rule.title = "Test rule"
#add the rule to rule's storage
storage = getUtility(IRuleStorage)
chooser = INameChooser(storage)
storage[chooser.chooseName(None, rule)] = rule
#set the action and add it to the rule
action = MailSubscriptionsAction()
action.subject = "Test Rule subject"
action.message = "Test Rule message"
rule.actions.append(action)
tool = getToolByName(self.portal, SUBSCRIPTION_TOOL, None)
email = "*****@*****.**"
result, msg = tool.registerUser(action.actionUID, email)
result2, msg2 = tool.registerUser(action.actionUID, email)
self.assertTrue(result)
self.assertFalse(result2)
self.assertEquals(msg2, 'already_subscribed_error')
def setUp(self):
"""
"""
self.portal = self.layer['portal']
self.request = self.layer['request']
self.markRequestWithLayer()
# Creating empty value for ACTUAL_URL to prevent KeyError
self.request['ACTUAL_URL'] = ''
app = self.layer['app']
#set some things
#create a test user with email
self.acl_users = getToolByName(self.portal, 'acl_users')
self.acl_users.userFolderAddUser('user1', 'secret', ['Member'], [])
self.user1 = self.acl_users.getUser('user1')
self.user1.setProperties(email='*****@*****.**')
#now set some rules
self.tool = getToolByName(self.portal, SUBSCRIPTION_TOOL, None)
self.portal_url = self.portal.absolute_url()
self.browser = Browser(app)
for x in ["first", "second", "third"]:
#set some rules
rule = Rule()
rule.event = IObjectAddedEvent
rule.title = "%s rule" % x
#add the rules to rule's storage
storage = getUtility(IRuleStorage)
chooser = INameChooser(storage)
storage[chooser.chooseName(None, rule)] = rule
#set the action and add it to the rule
action = MailSubscriptionsAction()
action.subject = "Test %s action subject" % x
rule.actions.append(action)
#set one only norobots question
registry = queryUtility(IRegistry)
settings = registry.forInterface(INorobotsWidgetSettings, check=False)
settings.questions = (u'What is 4 + 4 ?::8', )
transaction.commit()
def setUp(self):
"""
"""
self.portal = self.layer['portal']
self.request = self.layer['request']
self.markRequestWithLayer()
# Creating empty value for ACTUAL_URL to prevent KeyError
self.request['ACTUAL_URL'] = ''
app = self.layer['app']
#set some things
#create a test user with email
self.acl_users = getToolByName(self.portal, 'acl_users')
self.acl_users.userFolderAddUser('user1', 'secret', ['Member'], [])
self.user1 = self.acl_users.getUser('user1')
self.user1.setProperties(email='*****@*****.**')
#now set some rules
self.tool = getToolByName(self.portal, SUBSCRIPTION_TOOL, None)
self.portal_url = self.portal.absolute_url()
self.browser = Browser(app)
for x in ["first", "second", "third"]:
#set some rules
rule = Rule()
rule.event = IObjectAddedEvent
rule.title = "%s rule" % x
#add the rules to rule's storage
storage = getUtility(IRuleStorage)
chooser = INameChooser(storage)
storage[chooser.chooseName(None, rule)] = rule
#set the action and add it to the rule
action = MailSubscriptionsAction()
action.subject = "Test %s action subject" % x
rule.actions.append(action)
#set one only norobots question
registry = queryUtility(IRegistry)
settings = registry.forInterface(INorobotsWidgetSettings, check=False)
settings.questions = (u'What is 4 + 4 ?::8',)
transaction.commit()
def _initRules(self, node):
"""Import rules from the given node
"""
site = self.environ.getSite()
storage = queryUtility(IRuleStorage)
if storage is None:
return
for child in node.childNodes:
if child.nodeName == 'rule':
rule = None
name = child.getAttribute('name')
if name:
rule = storage.get(name, None)
if rule is None:
rule = Rule()
if not name:
chooser = INameChooser(storage)
name = chooser.chooseName(None, rule)
storage[name] = rule
else:
# Clear out conditions and actions since we're expecting
# new ones
del rule.conditions[:]
del rule.actions[:]
rule.title = child.getAttribute('title')
rule.description = child.getAttribute('description')
event_name = child.getAttribute('event')
rule.event = _resolveDottedName(event_name)
if not rule.event:
raise ImportError('Can not import {0}'.format(event_name))
rule.enabled = as_bool(child.getAttribute('enabled'), True)
rule.stop = as_bool(child.getAttribute('stop-after'))
rule.cascading = as_bool(child.getAttribute('cascading'))
# Aq-wrap to enable complex setters for elements below
# to work
rule = rule.__of__(site)
for rule_config_node in child.childNodes:
if rule_config_node.nodeName == 'conditions':
for condition_node in rule_config_node.childNodes:
if not condition_node.nodeName == 'condition':
continue
type_ = condition_node.getAttribute('type')
element_type = getUtility(IRuleCondition,
name=type_)
if element_type.factory is None:
continue
condition = element_type.factory()
# Aq-wrap in case of complex setters
condition = condition.__of__(rule)
handler = IRuleElementExportImportHandler(
condition)
handler.import_element(condition_node)
rule.conditions.append(aq_base(condition))
elif rule_config_node.nodeName == 'actions':
for action_node in rule_config_node.childNodes:
if not action_node.nodeName == 'action':
continue
type_ = action_node.getAttribute('type')
element_type = getUtility(IRuleAction, name=type_)
if element_type.factory is None:
continue
action = element_type.factory()
# Aq-wrap in case of complex setters
action = action.__of__(rule)
handler = IRuleElementExportImportHandler(action)
handler.import_element(action_node)
rule.actions.append(aq_base(action))
elif child.nodeName == 'assignment':
location = child.getAttribute('location')
if location.startswith('/'):
location = location[1:]
try:
container = site.unrestrictedTraverse(str(location))
except KeyError:
continue
name = child.getAttribute('name')
api.assign_rule(
container,
name,
enabled=as_bool(child.getAttribute('enabled')),
bubbles=as_bool(child.getAttribute('bubbles')),
insert_before=child.getAttribute('insert-before'),
)
def _initRules(self, node):
"""Import rules from the given node
"""
site = self.environ.getSite()
storage = queryUtility(IRuleStorage)
if storage is None:
return
for child in node.childNodes:
if child.nodeName == 'rule':
rule = None
name = child.getAttribute('name')
if name:
rule = storage.get(name, None)
if rule is None:
rule = Rule()
if not name:
chooser = INameChooser(storage)
name = chooser.chooseName(None, rule)
storage[name] = rule
else:
# Clear out conditions and actions since we're expecting new ones
del rule.conditions[:]
del rule.actions[:]
rule.title = child.getAttribute('title')
rule.description = child.getAttribute('description')
event_name = child.getAttribute('event')
rule.event = _resolveDottedName(event_name)
if not rule.event:
raise ImportError("Can not import %s" % event_name)
rule.enabled = as_bool(child.getAttribute('enabled'), True)
rule.stop = as_bool(child.getAttribute('stop-after'))
rule.cascading = as_bool(child.getAttribute('cascading'))
# Aq-wrap to enable complex setters for elements below
# to work
rule = rule.__of__(site)
for rule_config_node in child.childNodes:
if rule_config_node.nodeName == 'conditions':
for condition_node in rule_config_node.childNodes:
if not condition_node.nodeName == 'condition':
continue
type_ = condition_node.getAttribute('type')
element_type = getUtility(IRuleCondition, name=type_)
if element_type.factory is None:
continue
condition = element_type.factory()
# Aq-wrap in case of complex setters
condition = condition.__of__(rule)
handler = IRuleElementExportImportHandler(condition)
handler.import_element(condition_node)
rule.conditions.append(aq_base(condition))
elif rule_config_node.nodeName == 'actions':
for action_node in rule_config_node.childNodes:
if not action_node.nodeName == 'action':
continue
type_ = action_node.getAttribute('type')
element_type = getUtility(IRuleAction, name=type_)
if element_type.factory is None:
continue
action = element_type.factory()
# Aq-wrap in case of complex setters
action = action.__of__(rule)
handler = IRuleElementExportImportHandler(action)
handler.import_element(action_node)
rule.actions.append(aq_base(action))
elif child.nodeName == 'assignment':
location = child.getAttribute('location')
if location.startswith("/"):
location = location[1:]
try:
container = site.unrestrictedTraverse(str(location))
except KeyError:
continue
name = child.getAttribute('name')
api.assign_rule(container, name,
enabled=as_bool(child.getAttribute('enabled')),
bubbles=as_bool(child.getAttribute('bubbles')),
insert_before=child.getAttribute('insert-before'),
)
def _initRules(self, node):
"""Import rules from the given node
"""
site = self.environ.getSite()
storage = queryUtility(IRuleStorage)
if storage is None:
return
for child in node.childNodes:
if child.nodeName == 'rule':
rule = None
name = child.getAttribute('name')
if name:
rule = storage.get(name, None)
if rule is None:
rule = Rule()
if not name:
chooser = INameChooser(storage)
name = chooser.chooseName(None, rule)
storage[name] = rule
else:
# Clear out conditions and actions since we're expecting new ones
del rule.conditions[:]
del rule.actions[:]
rule.title = child.getAttribute('title')
rule.description = child.getAttribute('description')
event_name = child.getAttribute('event')
rule.event = _resolveDottedName(event_name)
if not rule.event:
raise ImportError("Can not import %s" % event_name)
rule.enabled = as_bool(child.getAttribute('enabled'), True)
rule.stop = as_bool(child.getAttribute('stop-after'))
# Aq-wrap to enable complex setters for elements below
# to work
rule = rule.__of__(site)
for rule_config_node in child.childNodes:
if rule_config_node.nodeName == 'conditions':
for condition_node in rule_config_node.childNodes:
if not condition_node.nodeName == 'condition':
continue
type_ = condition_node.getAttribute('type')
element_type = getUtility(IRuleCondition,
name=type_)
if element_type.factory is None:
continue
condition = element_type.factory()
# Aq-wrap in case of complex setters
condition = condition.__of__(rule)
handler = IRuleElementExportImportHandler(
condition)
handler.import_element(condition_node)
rule.conditions.append(aq_base(condition))
elif rule_config_node.nodeName == 'actions':
for action_node in rule_config_node.childNodes:
if not action_node.nodeName == 'action':
continue
type_ = action_node.getAttribute('type')
element_type = getUtility(IRuleAction, name=type_)
if element_type.factory is None:
continue
action = element_type.factory()
# Aq-wrap in case of complex setters
action = action.__of__(rule)
handler = IRuleElementExportImportHandler(action)
handler.import_element(action_node)
rule.actions.append(aq_base(action))
elif child.nodeName == 'assignment':
location = child.getAttribute('location')
if location.startswith("/"):
location = location[1:]
try:
container = site.unrestrictedTraverse(str(location))
except KeyError:
continue
assignable = IRuleAssignmentManager(container, None)
if assignable is None:
continue
name = child.getAttribute('name')
assignment = assignable.get(name, None)
if assignment is None:
assignment = assignable[name] = RuleAssignment(name)
assignment.enabled = as_bool(child.getAttribute('enabled'))
assignment.bubbles = as_bool(child.getAttribute('bubbles'))
insert_before = child.getAttribute('insert-before')
if insert_before:
position = None
keys = list(assignable.keys())
if insert_before == "*":
position = 0
elif insert_before in keys:
position = keys.index(insert_before)
if position is not None:
keys.remove(name)
keys.insert(position, name)
assignable.updateOrder(keys)
path = '/'.join(container.getPhysicalPath())
get_assignments(storage[name]).insert(path)
