def set_user_preferences_from_request(request):
"""Sets user subscription preferences using data from a request.
Expects data sent by form built with `sitemessage_prefs_table` template tag.
:param request:
:rtype: bool
:return: Flag, whether prefs were found in the request.
"""
prefs = []
for pref in request.POST.getlist(_PREF_POST_KEY):
message_alias, messenger_alias = pref.split(_ALIAS_SEP)
try:
get_registered_message_type(message_alias)
get_registered_messenger_object(messenger_alias)
except (UnknownMessengerError, UnknownMessageTypeError):
pass
else:
prefs.append((message_alias, messenger_alias))
Subscription.replace_for_user(request.user, prefs)
return bool(prefs)
def test_get_for_user(self, user):
r = Subscription.get_for_user(user)
assert list(r) == []
assert Subscription.get_for_user(user).count() == 0
Subscription.create(user, 'message', 'messenger')
assert Subscription.get_for_user(user).count() == 1
def test_get_for_user(self, user):
r = Subscription.get_for_user(user)
assert list(r) == []
assert Subscription.get_for_user(user).count() == 0
Subscription.create(user, 'message', 'messenger')
assert Subscription.get_for_user(user).count() == 1
def test_subscription(user_create):
user1 = user_create(attributes=dict(username='******'))
user2 = user_create(attributes=dict(username='******'))
user2.is_active = False
user2.save()
Subscription.create(user1.id, MessagePlainForTest, MessengerForTest)
Subscription.create(user2.id, MessagePlainForTest, MessengerForTest)
assert len(MessagePlainForTest.get_subscribers(active_only=False)) == 2
assert len(MessagePlainForTest.get_subscribers(active_only=True)) == 1
def test_subscription(user_create):
user1 = user_create(attributes=dict(username='******'))
user2 = user_create(attributes=dict(username='******'))
user2.is_active = False
user2.save()
Subscription.create(user1.id, MessagePlainForTest, MessengerForTest)
Subscription.create(user2.id, MessagePlainForTest, MessengerForTest)
assert len(MessagePlainForTest.get_subscribers(active_only=False)) == 2
assert len(MessagePlainForTest.get_subscribers(active_only=True)) == 1
def test_prepare_undispatched():
m, d = Message.create('testplain', {MessageBase.SIMPLE_TEXT_ID: 'abc'})
Subscription.create('fred', 'testplain', 'test_messenger')
Subscription.create('colon', 'testplain', 'test_messenger')
dispatches = prepare_dispatches()
assert len(dispatches) == 2
assert dispatches[0].address == 'fred'
assert dispatches[1].address == 'colon'
def test_prepare_undispatched():
m, d = Message.create('testplain', {MessageBase.SIMPLE_TEXT_ID: 'abc'})
Subscription.create('fred', 'testplain', 'test_messenger')
Subscription.create('colon', 'testplain', 'test_messenger')
dispatches = prepare_dispatches()
assert len(dispatches) == 2
assert dispatches[0].address == 'fred'
assert dispatches[1].address == 'colon'
def test_unsubscribe(self, setup):
self.view_name = 'sitemessage_unsubscribe'
sig_unsubscribe_success.connect(self.catcher_success, weak=False)
sig_unsubscribe_failed.connect(self.catcher_fail, weak=False)
self.generic_view_test()
subscr = Subscription(
message_cls=self.msg_type, messenger_cls=MessengerForTest.alias, recipient=self.user
)
subscr.save()
assert len(Subscription.objects.all()) == 1
self.send_request(self.msg_model.id, self.dispatch.id, self.dispatch_hash, self.STATUS_SUCCESS)
assert len(Subscription.objects.all()) == 0
def test_unsubscribe(self, setup):
self.view_name = 'sitemessage_unsubscribe'
sig_unsubscribe_success.connect(self.catcher_success, weak=False)
sig_unsubscribe_failed.connect(self.catcher_fail, weak=False)
self.generic_view_test()
subscr = Subscription(message_cls=self.msg_type,
messenger_cls=MessengerForTest.alias,
recipient=self.user)
subscr.save()
assert len(Subscription.objects.all()) == 1
self.send_request(self.msg_model.id, self.dispatch.id,
self.dispatch_hash, self.STATUS_SUCCESS)
assert len(Subscription.objects.all()) == 0
def test_create(self, user):
s = Subscription.create('abc', 'message', 'messenger')
assert s.time_created is not None
assert s.recipient is None
assert s.address == 'abc'
assert s.message_cls == 'message'
assert s.messenger_cls == 'messenger'
s = Subscription.create(user, 'message', 'messenger')
assert s.time_created is not None
assert s.address is None
assert s.recipient_id == user.id
assert s.message_cls == 'message'
assert s.messenger_cls == 'messenger'
def test_create(self, user):
s = Subscription.create('abc', 'message', 'messenger')
assert s.time_created is not None
assert s.recipient is None
assert s.address == 'abc'
assert s.message_cls == 'message'
assert s.messenger_cls == 'messenger'
s = Subscription.create(user, 'message', 'messenger')
assert s.time_created is not None
assert s.address is None
assert s.recipient_id == user.id
assert s.message_cls == 'message'
assert s.messenger_cls == 'messenger'
def test_replace_for_user(self, user):
new_prefs = [('message3', 'messenger3')]
assert Subscription.replace_for_user(user, new_prefs)
Subscription.create(user, 'message', 'messenger')
Subscription.create(user, 'message2', 'messenger2')
assert Subscription.get_for_user(user).count() == 3
Subscription.replace_for_user(user, new_prefs)
s = Subscription.get_for_user(user)
assert s.count() == 1
s = s[0]
assert s.message_cls == 'message3'
assert s.messenger_cls == 'messenger3'
def test_replace_for_user(self, user):
new_prefs = [('message3', 'messenger3')]
assert Subscription.replace_for_user(user, new_prefs)
Subscription.create(user, 'message', 'messenger')
Subscription.create(user, 'message2', 'messenger2')
assert Subscription.get_for_user(user).count() == 3
Subscription.replace_for_user(user, new_prefs)
s = Subscription.get_for_user(user)
assert s.count() == 1
s = s[0]
assert s.message_cls == 'message3'
assert s.messenger_cls == 'messenger3'
def test_get_for_message_cls(self):
assert Subscription.get_for_message_cls('mymsg').count() == 0
Subscription.create('aaa', 'mymsg', 'messenger')
Subscription.create('bbb', 'mymsg', 'messenger2')
assert Subscription.get_for_message_cls('mymsg').count() == 2
def test_get_for_message_cls(self):
assert Subscription.get_for_message_cls('mymsg').count() == 0
Subscription.create('aaa', 'mymsg', 'messenger')
Subscription.create('bbb', 'mymsg', 'messenger2')
assert Subscription.get_for_message_cls('mymsg').count() == 2
def test_get_user_preferences_for_ui(template_render_tag, template_context, user):
messengers_titles, prefs = get_user_preferences_for_ui(user)
assert len(prefs.keys()) == 3
assert len(messengers_titles) == 8
from .testapp.sitemessages import MessageForTest, MessengerForTest
Subscription.create(user, MessageForTest, MessengerForTest)
user_prefs = get_user_preferences_for_ui(
user,
message_filter=lambda m: m.alias == 'test_message',
messenger_filter=lambda m: m.alias in ['smtp', 'test_messenger']
)
messengers_titles, prefs = user_prefs
assert len(prefs.keys()) == 1
assert len(messengers_titles) == 2
assert 'E-mail' in messengers_titles
assert 'Test messenger' in messengers_titles
html = template_render_tag(
'sitemessage',
'sitemessage_prefs_table from user_prefs',
template_context({'user_prefs': user_prefs})
)
assert 'class="sitemessage_prefs' in html
assert 'E-mail</th>' in html
assert 'Test messenger</th>' in html
assert 'value="test_message|smtp"' in html
assert 'value="test_message|test_messenger" checked' in html
prefs_row = prefs.popitem()
assert prefs_row[0] == 'Test message type'
assert ('test_message|smtp', True, False) in prefs_row[1]
assert ('test_message|test_messenger', True, True) in prefs_row[1]
def handle(self, *args, **options):
self.stdout.write('Starting migration ...\n')
try:
subscribers = User.objects.filter(digest_enabled=True).values_list(
'id', flat=True)
targets = []
for subscriber in subscribers:
targets.append(
Subscription(message_cls='digest',
messenger_cls='smtp',
recipient_id=subscriber))
self.stdout.write('User ID %s subscribed ...\n' % subscriber)
Subscription.objects.bulk_create(targets)
except Exception as e:
self.stderr.write(self.style.ERROR('Migration failed: %s\n' % e))
print_exc()
else:
self.stdout.write('All is done. Total subscribers: %s\n' %
len(targets))
def get_user_preferences_for_ui(user,
message_filter=None,
messenger_filter=None,
new_messengers_titles=None):
"""Returns a two element tuple with user subscription preferences to render in UI.
Message types with the same titles are merged into one row.
First element:
A list of messengers titles.
Second element:
User preferences dictionary indexed by message type titles.
Preferences (dictionary values) are lists of tuples:
(preference_alias, is_supported_by_messenger_flag, user_subscribed_flag)
Example:
{'My message type': [('test_message|smtp', True, False), ...]}
:param User user:
:param callable|None message_filter: A callable accepting a message object to filter out message types
:param callable|None messenger_filter: A callable accepting a messenger object to filter out messengers
:rtype: tuple
"""
if new_messengers_titles is None:
new_messengers_titles = {}
msgr_to_msg = defaultdict(set)
msg_titles = OrderedDict()
msgr_titles = OrderedDict()
for msgr in get_registered_messenger_objects().values():
if not (messenger_filter is None
or messenger_filter(msgr)) or not msgr.allow_user_subscription:
continue
msgr_alias = msgr.alias
msgr_title = new_messengers_titles.get(msgr.alias) or msgr.title
for msg in get_registered_message_types().values():
if not (message_filter is None
or message_filter(msg)) or not msg.allow_user_subscription:
continue
msgr_supported = msg.supported_messengers
is_supported = (not msgr_supported or msgr.alias in msgr_supported)
if not is_supported:
continue
msg_alias = msg.alias
msg_titles.setdefault('%s' % msg.title, []).append(msg_alias)
msgr_to_msg[msgr_alias].update((msg_alias, ))
msgr_titles[msgr_title] = msgr_alias
def sort_titles(titles):
return OrderedDict(
sorted([(k, v) for k, v in titles.items()], key=itemgetter(0)))
msgr_titles = sort_titles(msgr_titles)
user_prefs = OrderedDict()
user_subscriptions = [
'%s%s%s' % (pref.message_cls, _ALIAS_SEP, pref.messenger_cls)
for pref in Subscription.get_for_user(user)
]
for msg_title, msg_aliases in sort_titles(msg_titles).items():
for __, msgr_alias in msgr_titles.items():
msg_candidates = msgr_to_msg[msgr_alias].intersection(msg_aliases)
alias = ''
msg_supported = False
subscribed = False
if msg_candidates:
alias = '%s%s%s' % (msg_candidates.pop(), _ALIAS_SEP,
msgr_alias)
msg_supported = True
subscribed = alias in user_subscriptions
user_prefs.setdefault(msg_title, []).append(
(alias, msg_supported, subscribed))
return msgr_titles.keys(), user_prefs
def test_str(self):
s = Subscription()
s.address = 'aaa'
assert 'aaa' in str(s)
def test_cancel(self, user):
Subscription.create('abc', 'message', 'messenger')
Subscription.create('abc', 'message1', 'messenger')
Subscription.create('abc', 'message', 'messenger1')
assert Subscription.objects.filter(address='abc').count() == 3
Subscription.cancel('abc', 'message', 'messenger')
assert Subscription.objects.filter(address='abc').count() == 2
Subscription.create(user, 'message', 'messenger')
assert Subscription.objects.filter(recipient=user).count() == 1
Subscription.cancel(user, 'message', 'messenger')
assert Subscription.objects.filter(recipient=user).count() == 0
def test_cancel(self, user):
Subscription.create('abc', 'message', 'messenger')
Subscription.create('abc', 'message1', 'messenger')
Subscription.create('abc', 'message', 'messenger1')
assert Subscription.objects.filter(address='abc').count() == 3
Subscription.cancel('abc', 'message', 'messenger')
assert Subscription.objects.filter(address='abc').count() == 2
Subscription.create(user, 'message', 'messenger')
assert Subscription.objects.filter(recipient=user).count() == 1
Subscription.cancel(user, 'message', 'messenger')
assert Subscription.objects.filter(recipient=user).count() == 0
def test_str(self):
s = Subscription()
s.address = 'aaa'
assert 'aaa' in str(s)
