def do_update(db):
SubscriptionAttribute.delete_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated, klass)
blogs = set(map(lambda x: x.strip(),
req.args.get('announcer_watch_bloggers').split(',')))
SubscriptionAttribute.add(self.env, req.session.sid,
req.session.authenticated, klass, 'blog', blogs)
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
if req.method == "POST":
with self.env.db_transaction as db:
SubscriptionAttribute.\
delete_by_sid_and_class(self.env, req.session.sid,
req.session.authenticated,
klass, db)
def _map(value):
g = re.match('^component_(.*)', value)
if g:
if req.args.as_bool(value):
return g.groups()[0]
components = set(filter(None, map(_map, req.args.keys())))
SubscriptionAttribute.add(self.env, req.session.sid,
req.session.authenticated, klass,
'ticket', components, db)
d = {}
attrs = filter(None, map(
lambda x: x['target'],
SubscriptionAttribute.find_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated, klass
)
))
for c in model.Component.select(self.env):
if c.name in attrs:
d[c.name] = True
else:
d[c.name] = None
return 'prefs_announcer_joinable_components.html', dict(components=d)
def do_update(db):
SubscriptionAttribute.delete_by_sid_and_class(
self.env, sess.sid, sess.authenticated, klass, db)
SubscriptionAttribute.add(self.env, sess.sid,
sess.authenticated, klass, 'wiki',
(req.args.get('wiki_interests'), ),
db)
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
if req.method == "POST":
with self.env.db_transaction as db:
SubscriptionAttribute.\
delete_by_sid_and_class(self.env, req.session.sid,
req.session.authenticated,
klass, db)
def _map(value):
g = re.match('^joinable_group_(.*)', value)
if g:
if req.args.as_bool(value):
return g.groups()[0]
groups = set(filter(None, map(_map, req.args.keys())))
SubscriptionAttribute.add(self.env, req.session.sid,
req.session.authenticated, klass,
'ticket', groups, db)
attrs = filter(None, map(
lambda x: x['target'],
SubscriptionAttribute.find_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated, klass
)
))
data = dict(joinable_groups={})
for group in self.joinable_groups:
data['joinable_groups'][group] = (group in attrs) and True or None
return 'prefs_announcer_joinable_groups.html', data
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
if req.method == "POST":
with self.env.db_transaction as db:
SubscriptionAttribute.\
delete_by_sid_and_class(self.env, req.session.sid,
req.session.authenticated,
klass, db)
def _map(value):
g = re.match('^joinable_group_(.*)', value)
if g:
if req.args.as_bool(value):
return g.groups()[0]
groups = set(filter(None, map(_map, req.args.keys())))
SubscriptionAttribute.add(self.env, req.session.sid,
req.session.authenticated, klass,
'ticket', groups, db)
attrs = filter(
None,
map(
lambda x: x['target'],
SubscriptionAttribute.find_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated,
klass)))
data = dict(joinable_groups={})
for group in self.joinable_groups:
data['joinable_groups'][group] = (group in attrs) and True or None
return 'prefs_announcer_joinable_groups.html', data
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
if req.method == 'POST':
with self.env.db_transaction as db:
sess = req.session
SubscriptionAttribute\
.delete_by_sid_and_class(self.env, sess.sid,
sess.authenticated,
klass, db)
users = map(lambda x: x.strip(),
req.args.get('announcer_watch_users').split(','))
SubscriptionAttribute.add(self.env, sess.sid,
sess.authenticated, klass, 'user',
users, db)
attrs = filter(
None,
map(
lambda x: x['target'],
SubscriptionAttribute.find_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated,
klass)))
data = dict(announcer_watch_users=','.join(attrs))
return 'prefs_announcer_watch_users.html', data
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
if req.method == "POST":
with self.env.db_transaction as db:
SubscriptionAttribute.\
delete_by_sid_and_class(self.env, req.session.sid,
req.session.authenticated,
klass, db)
def _map(value):
g = re.match('^component_(.*)', value)
if g:
if req.args.as_bool(value):
return g.groups()[0]
components = set(filter(None, map(_map, req.args.keys())))
SubscriptionAttribute.add(self.env, req.session.sid,
req.session.authenticated, klass,
'ticket', components, db)
d = {}
attrs = filter(
None,
map(
lambda x: x['target'],
SubscriptionAttribute.find_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated,
klass)))
for c in model.Component.select(self.env):
if c.name in attrs:
d[c.name] = True
else:
d[c.name] = None
return 'prefs_announcer_joinable_components.html', dict(components=d)
def do_update(db):
SubscriptionAttribute.delete_by_sid_and_class(self.env,
req.session.sid, req.session.authenticated, klass, db)
users = map(lambda x: x.strip(),
req.args.get("announcer_watch_users").split(','))
SubscriptionAttribute.add(self.env, req.session.sid,
req.session.authenticated, klass, 'user', users, db)
def set_unwatch(self, sid, authenticated, realm, target):
klass = self.__class__.__name__
(attr,) = SubscriptionAttribute.find_by_sid_class_realm_and_target(
self.env, sid, authenticated, klass, realm, target
)
if attr:
SubscriptionAttribute.delete(self.env, attr["id"])
def do_update(db):
sess = req.session
SubscriptionAttribute.delete_by_sid_and_class(
self.env, sess.sid, sess.authenticated, klass, db)
users = map(lambda x: x.strip(),
req.args.get("announcer_watch_users").split(','))
SubscriptionAttribute.add(self.env, sess.sid,
sess.authenticated, klass, 'user',
users, db)
def do_update(db):
SubscriptionAttribute.delete_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated,
klass)
blogs = set(
map(lambda x: x.strip(),
req.args.get('announcer_watch_bloggers').split(',')))
SubscriptionAttribute.add(self.env, req.session.sid,
req.session.authenticated, klass,
'blog', blogs)
def do_update(db):
SubscriptionAttribute.delete_by_sid_and_class(self.env,
req.session.sid, req.session.authenticated, klass, db)
def _map(value):
g = re.match('^joinable_group_(.*)', value)
if g:
if istrue(req.args.get(value)):
return g.groups()[0]
groups = set(filter(None, map(_map,req.args.keys())))
SubscriptionAttribute.add(self.env, req.session.sid,
req.session.authenticated, klass, 'ticket', groups, db)
def do_update(db):
SubscriptionAttribute.delete_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated, klass, db
)
def _map(value):
g = re.match("^component_(.*)", value)
if g:
if istrue(req.args.get(value)):
return g.groups()[0]
components = set(filter(None, map(_map, req.args.keys())))
SubscriptionAttribute.add(
self.env, req.session.sid, req.session.authenticated, klass, "ticket", components, db
)
def do_update(db):
SubscriptionAttribute.delete_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated,
klass, db)
def _map(value):
g = re.match('^component_(.*)', value)
if g:
if istrue(req.args.get(value)):
return g.groups()[0]
components = set(filter(None, map(_map, req.args.keys())))
SubscriptionAttribute.add(self.env, req.session.sid,
req.session.authenticated, klass,
'ticket', components, db)
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
if req.method == "POST":
@self.env.with_transaction()
def do_update(db):
SubscriptionAttribute.delete_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated, klass, db
)
def _map(value):
g = re.match("^joinable_group_(.*)", value)
if g:
if istrue(req.args.get(value)):
return g.groups()[0]
groups = set(filter(None, map(_map, req.args.keys())))
SubscriptionAttribute.add(
self.env, req.session.sid, req.session.authenticated, klass, "ticket", groups, db
)
attrs = filter(
None,
map(
lambda x: x["target"],
SubscriptionAttribute.find_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated, klass
),
),
)
data = dict(joinable_groups={})
for group in self.joinable_groups:
data["joinable_groups"][group] = (group in attrs) and True or None
return "prefs_announcer_joinable_groups.html", data
def do_update(db):
attrs = SubscriptionAttribute.find_by_sid_class_and_target(
self.env, req.session.sid, req.session.authenticated,
klass, name)
if attrs:
SubscriptionAttribute.delete_by_sid_class_and_target(
self.env, req.session.sid, req.session.authenticated,
klass, name)
req.session['_blog_watch_message_'] = \
_('You are no longer watching this blog post.')
else:
SubscriptionAttribute.add(
self.env, req.session.sid, req.session.authenticated,
klass, 'blog', (name,))
req.session['_blog_watch_message_'] = \
_('You are now watching this blog post.')
def matches(self, event):
if event.realm != 'wiki':
return
if event.category not in ('changed', 'created', 'attachment added',
'deleted', 'version deleted'):
return
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_class_and_realm(
self.env, klass, 'wiki')
def match(pattern):
for raw in pattern['target'].split(' '):
if raw != '':
pat = urllib.unquote(raw).replace('*', '.*')
if re.match(pat, event.target.name):
return True
sids = set(
map(lambda x: (x['sid'], x['authenticated']), filter(match,
attrs)))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def post_process_request(self, req, template, data, content_type):
if 'BLOG_VIEW' not in req.perm:
return (template, data, content_type)
if '_blog_watch_message_' in req.session:
add_notice(req, req.session['_blog_watch_message_'])
del req.session['_blog_watch_message_']
if req.authname == "anonymous":
return (template, data, content_type)
# FullBlogPlugin sets the blog_path arg in pre_process_request
name = req.args.get('blog_path')
if not name:
return (template, data, content_type)
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_sid_class_and_target(
self.env, req.session.sid, req.session.authenticated, klass, name)
if attrs:
add_ctxtnav(
req, tag.a(_('Unwatch This'), href=req.href.blog_watch(name)))
else:
add_ctxtnav(req,
tag.a(_('Watch This'), href=req.href.blog_watch(name)))
return (template, data, content_type)
def post_process_request(self, req, template, data, content_type):
if 'BLOG_VIEW' not in req.perm:
return (template, data, content_type)
if '_blog_watch_message_' in req.session:
add_notice(req, req.session['_blog_watch_message_'])
del req.session['_blog_watch_message_']
if req.authname == "anonymous":
return (template, data, content_type)
# FullBlogPlugin sets the blog_path arg in pre_process_request
name = req.args.get('blog_path')
if not name:
return (template, data, content_type)
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_sid_class_and_target(
self.env, req.session.sid, req.session.authenticated, klass, name)
if attrs:
add_ctxtnav(req, tag.a(_('Unwatch This'),
href=req.href.blog_watch(name)))
else:
add_ctxtnav(req, tag.a(_('Watch This'),
href=req.href.blog_watch(name)))
return (template, data, content_type)
def do_update(db):
attrs = SubscriptionAttribute.find_by_sid_class_and_target(
self.env, req.session.sid, req.session.authenticated, klass,
name)
if attrs:
SubscriptionAttribute.delete_by_sid_class_and_target(
self.env, req.session.sid, req.session.authenticated,
klass, name)
req.session['_blog_watch_message_'] = \
_('You are no longer watching this blog post.')
else:
SubscriptionAttribute.add(self.env, req.session.sid,
req.session.authenticated, klass,
'blog', (name, ))
req.session['_blog_watch_message_'] = \
_('You are now watching this blog post.')
def matches(self, event):
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_class_realm_and_target(self.env, klass, "user", event.author)
sids = set(map(lambda x: (x["sid"], x["authenticated"]), attrs))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def is_watching(self, sid, authenticated, realm, target):
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_sid_class_realm_and_target(
self.env, sid, authenticated, klass, realm, target)
if attrs:
return True
else:
return False
def is_watching(self, sid, authenticated, realm, target):
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_sid_class_realm_and_target(
self.env, sid, authenticated, klass, realm, target)
if attrs:
return True
else:
return False
def matches(self, event):
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_class_realm_and_target(
self.env, klass, event.realm, get_target_id(event.target))
sids = set(map(lambda x: (x['sid'], x['authenticated']), attrs))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def matches(self, event):
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_class_realm_and_target(self.env,
klass, event.realm, self._get_target_id(event.target))
sids = set(map(lambda x: (x['sid'],x['authenticated']), attrs))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
if req.method == "POST":
with self.env.db_transaction:
SubscriptionAttribute.delete_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated,
klass)
blogs = set(map(lambda x: x.strip(),
req.args.get(
'announcer_watch_bloggers').split(',')))
SubscriptionAttribute.add(self.env, req.session.sid,
req.session.authenticated, klass,
'blog', blogs)
attrs = SubscriptionAttribute.\
find_by_sid_and_class(self.env, req.session.sid,
req.session.authenticated, klass)
data = {'sids': ','.join(set(map(lambda x: x['target'], attrs)))}
return 'prefs_announcer_watch_bloggers.html', dict(data=data)
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
sess = req.session
if req.method == 'POST':
with self.env.db_transaction as db:
SubscriptionAttribute.\
delete_by_sid_and_class(self.env, sess.sid,
sess.authenticated, klass, db)
SubscriptionAttribute.add(self.env, sess.sid,
sess.authenticated, klass, 'wiki',
(req.args.get('wiki_interests'),),
db)
(interests,) = SubscriptionAttribute.find_by_sid_and_class(
self.env, sess.sid, sess.authenticated, klass) or (
{'target': ''},)
return 'prefs_announcer_wiki.html', dict(
wiki_interests='\n'.join(
urllib.unquote(x) for x in interests['target'].split(' ')))
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
sess = req.session
if req.method == 'POST':
with self.env.db_transaction as db:
SubscriptionAttribute.\
delete_by_sid_and_class(self.env, sess.sid,
sess.authenticated, klass, db)
SubscriptionAttribute.add(self.env, sess.sid,
sess.authenticated, klass, 'wiki',
(req.args.get('wiki_interests'), ),
db)
(interests, ) = SubscriptionAttribute.find_by_sid_and_class(
self.env, sess.sid, sess.authenticated, klass) or ({
'target': ''
}, )
return 'prefs_announcer_wiki.html', dict(wiki_interests='\n'.join(
urllib.unquote(x) for x in interests['target'].split(' ')))
def process_request(self, req):
klass = self.__class__.__name__
m = re.match(r'^/blog_watch/(.*)', req.path_info)
(name,) = m.groups()
with self.env.db_transaction:
attrs = SubscriptionAttribute.find_by_sid_class_and_target(
self.env, req.session.sid, req.session.authenticated,
klass, name)
if attrs:
SubscriptionAttribute.delete_by_sid_class_and_target(
self.env, req.session.sid, req.session.authenticated,
klass, name)
req.session['_blog_watch_message_'] = \
_("You are no longer watching this blog post.")
else:
SubscriptionAttribute.add(
self.env, req.session.sid, req.session.authenticated,
klass, 'blog', (name,))
req.session['_blog_watch_message_'] = \
_("You are now watching this blog post.")
req.redirect(req.href.blog(name))
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
if req.method == 'POST':
with self.env.db_transaction as db:
sess = req.session
SubscriptionAttribute\
.delete_by_sid_and_class(self.env, sess.sid,
sess.authenticated,
klass, db)
users = map(lambda x: x.strip(),
req.args.get('announcer_watch_users').split(','))
SubscriptionAttribute.add(self.env, sess.sid,
sess.authenticated, klass, 'user',
users, db)
attrs = filter(None, map(
lambda x: x['target'],
SubscriptionAttribute.find_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated, klass
)
))
data = dict(announcer_watch_users=','.join(attrs))
return 'prefs_announcer_watch_users.html', data
def matches(self, event):
if event.realm != 'blog':
return
if event.category not in ('post created', 'post changed',
'post deleted', 'comment created',
'comment changed', 'comment deleted'):
return
klass = self.__class__.__name__
sids = set(map(lambda x: (x['sid'], x['authenticated']),
SubscriptionAttribute.find_by_class_realm_and_target(
self.env, klass, 'blog', event.blog_post.author)))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def matches(self, event):
if event.realm != 'blog':
return
if not event.category in ('post created', 'post changed',
'post deleted', 'comment created',
'comment changed', 'comment deleted'):
return
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_class_realm_and_target(
self.env, klass, 'blog', event.blog_post.name)
sids = set(map(lambda x: (x['sid'], x['authenticated']), attrs))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def matches(self, event):
if event.realm != "ticket":
return
if event.category not in ("changed", "created", "attachment added"):
return
component = event.target["component"]
if not component:
return
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_class_realm_and_target(self.env, klass, "ticket", component)
sids = set(map(lambda x: (x["sid"], x["authenticated"]), attrs))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def test_add_delete(self):
attr = SubscriptionAttribute(self.env)
attr.add(self.env, 'user', 1, 'GeneralWikiSubscriber','wiki',
('TracWiki', 'TracWiki'))
cursor = self.db.cursor()
cursor.execute("SELECT COUNT(*) FROM subscription_attribute")
count = cursor.fetchone()
self.assertEqual(count[0], 2)
attr.delete(self.env, 1)
# Make sure, that we really deleted the 1st attribute.
cursor.execute("SELECT target FROM subscription_attribute")
for attribute in cursor.fetchone():
self.assertEqual(attribute, 'TracWiki')
cursor.execute("SELECT COUNT(*) FROM subscription_attribute")
count = cursor.fetchone()
self.assertEqual(count[0], 1)
# Deleting non-existent subscriptions is handled gracefully.
attr.delete(self.env, 1)
def matches(self, event):
if event.realm != 'ticket':
return
if event.category not in ('changed', 'created', 'attachment added'):
return
component = event.target['component']
if not component:
return
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_class_realm_and_target(
self.env, klass, 'ticket', component)
sids = set(map(lambda x: (x['sid'], x['authenticated']), attrs))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def matches(self, event):
if event.realm != 'ticket':
return
if event.category not in ('changed', 'created', 'attachment added'):
return
component = event.target['component']
if not component:
return
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_class_realm_and_target(
self.env, klass, 'ticket', component)
sids = set(map(lambda x: (x['sid'], x['authenticated']), attrs))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
if req.method == "POST":
@self.env.with_transaction()
def do_update(db):
SubscriptionAttribute.delete_by_sid_and_class(self.env,
req.session.sid, req.session.authenticated, klass, db)
SubscriptionAttribute.add(self.env, req.session.sid,
req.session.authenticated, klass,
'wiki', req.args.get('wiki_interests', db))
(interests,) = SubscriptionAttribute.find_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated, klass
) or ({'target':''},)
return "prefs_announcer_wiki.html", dict(
wiki_interests = '\n'.join(
urllib.unquote(x) for x in interests['target'].split(' ')
)
)
def matches(self, event):
if event.realm != "wiki":
return
if event.category not in ("changed", "created", "attachment added", "deleted", "version deleted"):
return
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_class_and_realm(self.env, klass, "wiki")
def match(pattern):
for raw in pattern["target"].split(" "):
if raw != "":
pat = urllib.unquote(raw).replace("*", ".*")
if re.match(pat, event.target.name):
return True
sids = set(map(lambda x: (x["sid"], x["authenticated"]), filter(match, attrs)))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
sess = req.session
if req.method == "POST":
@self.env.with_transaction()
def do_update(db):
SubscriptionAttribute.delete_by_sid_and_class(self.env, sess.sid, sess.authenticated, klass, db)
SubscriptionAttribute.add(
self.env, sess.sid, sess.authenticated, klass, "wiki", (req.args.get("wiki_interests"),), db
)
(interests,) = SubscriptionAttribute.find_by_sid_and_class(self.env, sess.sid, sess.authenticated, klass) or (
{"target": ""},
)
return (
"prefs_announcer_wiki.html",
dict(wiki_interests="\n".join(urllib.unquote(x) for x in interests["target"].split(" "))),
)
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
if req.method == "POST":
@self.env.with_transaction()
def do_update(db):
SubscriptionAttribute.delete_by_sid_and_class(self.env,
req.session.sid, req.session.authenticated, klass, db)
users = map(lambda x: x.strip(),
req.args.get("announcer_watch_users").split(','))
SubscriptionAttribute.add(self.env, req.session.sid,
req.session.authenticated, klass, 'user', users, db)
attrs = filter(None, map(
lambda x: x['target'],
SubscriptionAttribute.find_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated, klass
)
))
return "prefs_announcer_watch_users.html", dict(data=dict(
announcer_watch_users=','.join(attrs)
))
def matches(self, event):
if event.realm != "ticket":
return
if event.category not in ("changed", "created", "attachment added"):
return
klass = self.__class__.__name__
ticket = event.target
sids = set()
cc = event.target["cc"] or ""
for chunk in re.split("\s|,", cc):
chunk = chunk.strip()
if chunk and chunk.startswith("@"):
member = None
grp = chunk[1:]
attrs = SubscriptionAttribute.find_by_class_realm_and_target(self.env, klass, "ticket", grp)
sids.update(set(map(lambda x: (x["sid"], x["authenticated"]), attrs)))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def render_announcement_preference_box(self, req, panel):
klass = self.__class__.__name__
if req.method == "POST":
@self.env.with_transaction()
def do_update(db):
SubscriptionAttribute.delete_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated, klass, db
)
def _map(value):
g = re.match("^component_(.*)", value)
if g:
if istrue(req.args.get(value)):
return g.groups()[0]
components = set(filter(None, map(_map, req.args.keys())))
SubscriptionAttribute.add(
self.env, req.session.sid, req.session.authenticated, klass, "ticket", components, db
)
d = {}
attrs = filter(
None,
map(
lambda x: x["target"],
SubscriptionAttribute.find_by_sid_and_class(
self.env, req.session.sid, req.session.authenticated, klass
),
),
)
for c in model.Component.select(self.env):
if c.name in attrs:
d[c.name] = True
else:
d[c.name] = None
return "prefs_announcer_joinable_components.html", dict(components=d)
def matches(self, event):
if event.realm != 'wiki':
return
if event.category not in ('changed', 'created', 'attachment added',
'deleted', 'version deleted'):
return
klass = self.__class__.__name__
attrs = SubscriptionAttribute.find_by_class_and_realm(
self.env, klass, 'wiki')
def match(pattern):
for raw in pattern['target'].split(' '):
if raw != '':
pat = urllib.unquote(raw).replace('*', '.*')
if re.match(pat, event.target.name):
return True
sids = set(map(lambda x: (x['sid'],x['authenticated']), filter(match, attrs)))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def matches(self, event):
if event.realm != 'ticket':
return
if event.category not in ('changed', 'created', 'attachment added'):
return
klass = self.__class__.__name__
ticket = event.target
sids = set()
cc = event.target['cc'] or ''
for chunk in re.split('\s|,', cc):
chunk = chunk.strip()
if chunk and chunk.startswith('@'):
member = None
grp = chunk[1:]
attrs = SubscriptionAttribute.find_by_class_realm_and_target(
self.env, klass, 'ticket', grp)
sids.update(set(map(
lambda x: (x['sid'],x['authenticated']), attrs)))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def matches(self, event):
if event.realm != 'ticket':
return
if event.category not in ('changed', 'created', 'attachment added'):
return
klass = self.__class__.__name__
ticket = event.target
sids = set()
cc = event.target['cc'] or ''
for chunk in re.split('\s|,', cc):
chunk = chunk.strip()
if chunk and chunk.startswith('@'):
member = None
grp = chunk[1:]
attrs = SubscriptionAttribute.find_by_class_realm_and_target(
self.env, klass, 'ticket', grp)
sids.update(
set(map(lambda x: (x['sid'], x['authenticated']), attrs)))
for i in Subscription.find_by_sids_and_class(self.env, sids, klass):
yield i.subscription_tuple()
def wiki_page_deleted(self, page):
klass = self.__class__.__name__
SubscriptionAttribute.delete_by_class_realm_and_target(
self.env, klass, 'wiki', get_target_id(page))
def ticket_deleted(self, ticket):
klass = self.__class__.__name__
SubscriptionAttribute.delete_by_class_realm_and_target(
self.env, klass, 'ticket', get_target_id(ticket))
def set_unwatch(self, sid, authenticated, realm, target):
klass = self.__class__.__name__
(attr, ) = SubscriptionAttribute.find_by_sid_class_realm_and_target(
self.env, sid, authenticated, klass, realm, target)
if attr:
SubscriptionAttribute.delete(self.env, attr['id'])
def set_watch(self, sid, authenticated, realm, target):
klass = self.__class__.__name__
SubscriptionAttribute.add(self.env, sid, authenticated, klass, realm,
(target, ))
def test_init(self):
# Examine properties of the initialized objekt.
fields = ('id', 'sid', 'authenticated', 'class', 'realm', 'target')
attr = SubscriptionAttribute(self.env)
for field in fields:
self.assertEqual(attr[field], None)
def ticket_deleted(self, ticket):
klass = self.__class__.__name__
SubscriptionAttribute.delete_by_class_realm_and_target(
self.env, klass, 'ticket', get_target_id(ticket))
