def notification_function_initial_results(arguments):
assert hasattr(arguments, 'user') and \
hasattr(arguments, 'submission')
pi = arguments.submission.problem_instance
request = RequestFactory().get('/', data={'name': u'test'})
request.user = arguments.user
request.contest = pi.contest
request.timestamp = datetime.now().replace(tzinfo=utc)
# Check if any initial result is visible for user
if not pi.controller \
.can_see_submission_status(request, arguments.submission):
return
if pi.contest:
url = reverse('submission',
kwargs={'contest_id': pi.contest.pk,
'submission_id': arguments.submission.pk})
elif pi.problem.problemsite:
url = reverse('problem_site', kwargs={
'site_key': pi.problem.problemsite.url_key}) \
+ '?key=submissions'
else:
url = ''
message = ugettext_noop("Initial result for task %(short_name)s is ready")
message_arguments = {'short_name': pi.short_name,
'address': url}
NotificationHandler.send_notification(arguments.user,
'initial_results', message, message_arguments)
def notification_function_submission_judged(arguments):
assert hasattr(arguments, 'user') and \
hasattr(arguments, 'submission')
pi = arguments.submission.problem_instance
request = RequestFactory().get('/', data={'name': u'test'})
request.user = arguments.user
request.contest = pi.contest
request.timestamp = datetime.now().replace(tzinfo=utc)
# Check if the final report is visible to the user
if not pi.contest.controller.can_see_submission_score(request,
arguments.submission):
return
url = reverse('submission',
kwargs={'contest_id': pi.contest.pk,
'submission_id': arguments.submission.pk})
message = pi.contest.controller \
.get_notification_message_submission_judged(arguments.submission)
message_arguments = {'short_name': pi.short_name,
'address': url}
NotificationHandler.send_notification(arguments.user,
'submission_judged', message, message_arguments)
def notification_function(arguments):
message = "Test"
message_arguments = {}
user = User.objects.get(username='******')
NotificationHandler.send_notification(user,
'test_notification', message, message_arguments)
flags['got_notification'] = True
def notification_function_submission_judged(arguments):
assert hasattr(arguments, 'user') and hasattr(arguments, 'submission')
pi = arguments.submission.problem_instance
request = RequestFactory().get('/', data={'name': u'test'})
request.user = arguments.user
request.contest = pi.contest
request.timestamp = datetime.now().replace(tzinfo=utc)
# Check if the final report is visible to the user
if not pi.contest.controller.can_see_submission_score(
request, arguments.submission):
return
url = reverse(
'submission',
kwargs={
'contest_id': pi.contest.pk,
'submission_id': arguments.submission.pk
},
)
message = pi.contest.controller.get_notification_message_submission_judged(
arguments.submission)
message_arguments = {
'short_name': pi.short_name,
'contest_name': pi.contest.name,
'task_name': six.text_type(pi),
'score': six.text_type(arguments.submission.score),
'address': url,
}
NotificationHandler.send_notification(arguments.user, 'submission_judged',
message, message_arguments)
def handle(self, *args, **options):
message = ' '.join(options['message'])
if options['user']:
try:
users = [User.objects.get(username=options['user'])]
except User.DoesNotExist:
raise CommandError("specified user does not exist")
elif options['contest']:
try:
contest = Contest.objects.get(name=options['contest'])
users = contest.controller.registration_controller() \
.filter_participants(User.objects.all())
except Contest.DoesNotExist:
raise CommandError("specified contest does not exist")
arguments = {}
if options['details']:
arguments.update({'details': options['details']})
if options['address']:
arguments.update({'address': options['address']})
if options['popup']:
arguments.update({'popup': True})
for user in users:
NotificationHandler.send_notification(
user, 'custom_notification', message, arguments)
print("Notification sent to", user.username)
def handle(self, *args, **options):
self.validate_options(args, options)
message = ' '.join(args)
if options['user']:
try:
users = [User.objects.get(username=options['user'])]
except User.DoesNotExist:
raise CommandError("specified user does not exist")
elif options['contest']:
try:
contest = Contest.objects.get(name=options['contest'])
users = contest.controller.registration_controller() \
.filter_participants(User.objects.all())
except Contest.DoesNotExist:
raise CommandError("specified contest does not exist")
arguments = {}
if options['details']:
arguments.update({'details': options['details']})
if options['address']:
arguments.update({'address': options['address']})
if options['popup']:
arguments.update({'popup': True})
for user in users:
NotificationHandler.send_notification(user, 'custom_notification',
message, arguments)
print "Notification sent to", user.username
def notification_function(arguments):
message = "Test"
message_arguments = {}
user = User.objects.get(username='******')
NotificationHandler.send_notification(user, 'test_notification',
message, message_arguments)
flags['got_notification'] = True
def notification_function_initial_results(arguments):
assert hasattr(arguments, 'user') and hasattr(arguments, 'submission')
pi = arguments.submission.problem_instance
request = RequestFactory().get('/', data={'name': u'test'})
request.user = arguments.user
request.contest = pi.contest
request.timestamp = datetime.now().replace(tzinfo=utc)
# Check if any initial result is visible for user
if not pi.controller.can_see_submission_status(request,
arguments.submission):
return
if pi.contest:
url = reverse(
'submission',
kwargs={
'contest_id': pi.contest.pk,
'submission_id': arguments.submission.pk,
},
)
elif pi.problem.problemsite:
url = (reverse('problem_site',
kwargs={'site_key': pi.problem.problemsite.url_key}) +
'?key=submissions')
else:
url = ''
message = ugettext_noop("Initial result for task %(short_name)s is ready")
message_arguments = {'short_name': pi.short_name, 'address': url}
NotificationHandler.send_notification(arguments.user, 'initial_results',
message, message_arguments)
def notification_function_answer(arguments):
assert hasattr(arguments, 'user') \
and hasattr(arguments, 'question_instance') \
and hasattr(arguments, 'answer_instance'), \
"The log doesn't have user, question_instance or answer_instance" \
" value in the extra map"
message = _("Your question was answered.")
message_arguments = {
'link': arguments.question_instance.get_absolute_url()
}
NotificationHandler.send_notification(arguments.user, 'question_answered',
message, message_arguments)
def notification_function_public(arguments):
assert hasattr(arguments, 'contest') \
and hasattr(arguments, 'message_instance'), \
"The log doesn't have contest or message_instance value" \
" in the extra map"
message = _("New public message.")
message_arguments = {'link': arguments.message_instance.get_absolute_url()}
controller = arguments.contest.controller
for user in controller.users_to_receive_public_message_notification():
NotificationHandler.send_notification(user, 'new_public_message',
message, message_arguments)
def notification_function_answer(arguments):
assert hasattr(arguments, 'user') \
and hasattr(arguments, 'question_instance') \
and hasattr(arguments, 'answer_instance'), \
"The log doesn't have user, question_instance or answer_instance" \
" value in the extra map"
message_details = arguments.question_instance.topic + ': ' + \
arguments.question_instance.content
message = ugettext_noop("Your question was answered.")
message_arguments = {'address': arguments.question_instance
.get_absolute_url(),
'details': message_details[:MAX_DETAILS_LENGTH]}
NotificationHandler.send_notification(arguments.user,
'question_answered', message, message_arguments)
def notification_function_answer(arguments):
assert hasattr(arguments, 'user') \
and hasattr(arguments, 'question_instance') \
and hasattr(arguments, 'answer_instance'), \
"The log doesn't have user, question_instance or answer_instance" \
" value in the extra map"
message_details = arguments.question_instance.topic + ': ' + \
arguments.question_instance.content
message = ugettext_noop("Your question was answered.")
message_arguments = {'address': arguments.question_instance
.get_absolute_url(),
'details': message_details[:MAX_DETAILS_LENGTH]}
NotificationHandler.send_notification(arguments.user,
'question_answered', message, message_arguments)
def test_notification_registration(self):
flags = {}
flags['got_notification'] = False
def notification_function(arguments):
message = "Test"
message_arguments = {}
user = User.objects.get(username='******')
NotificationHandler.send_notification(user,
'test_notification', message, message_arguments)
flags['got_notification'] = True
NotificationHandler.register_notification('test_notification',
notification_function)
logger = logging.getLogger('oioioi')
logger.info("Test notification",
extra={'notification': 'test_notification'})
self.assertTrue(flags['got_notification'])
def test_notification_registration(self):
flags = {}
flags['got_notification'] = False
def notification_function(arguments):
message = "Test"
message_arguments = {}
user = User.objects.get(username='******')
NotificationHandler.send_notification(user,
'test_notification', message, message_arguments)
flags['got_notification'] = True
NotificationHandler.register_notification('test_notification',
notification_function)
logger = logging.getLogger('oioioi')
logger.info("Test notification", extra=
{'notification': 'test_notification'})
self.assertTrue(flags['got_notification'])
def notification_function_public(arguments):
assert hasattr(arguments, 'contest') \
and hasattr(arguments, 'message_instance'), \
"The log doesn't have contest or message_instance value" \
" in the extra map"
message_details = arguments.message_instance.topic + ': ' + \
arguments.message_instance.content
message = ugettext_noop("New public message.")
message_arguments = {
'address': arguments.message_instance.get_absolute_url(),
'details': message_details[:MAX_DETAILS_LENGTH]
}
controller = arguments.contest.controller
for user in controller.users_to_receive_public_message_notification():
NotificationHandler.send_notification(user, 'new_public_message',
message, message_arguments)
def notification_function_public(arguments):
assert hasattr(arguments, 'contest') \
and hasattr(arguments, 'message_instance'), \
"The log doesn't have contest or message_instance value" \
" in the extra map"
message_details = arguments.message_instance.topic + ': ' + \
arguments.message_instance.content
message = ugettext_noop("New public message.")
message_arguments = {
'address': arguments.message_instance.get_absolute_url(),
'details': message_details[:MAX_DETAILS_LENGTH]
}
controller = arguments.contest.controller
for user in controller.users_to_receive_public_message_notification():
NotificationHandler.send_notification(user,
'new_public_message', message, message_arguments)
def friendship_notification(arguments):
assert hasattr(arguments, 'type') \
and hasattr(arguments, 'sender') \
and hasattr(arguments, 'recipient'), \
"The log doesn't have type, sender or recipient " \
"value in the extra map"
link_target_user = arguments.sender
notification_recipient = arguments.recipient
url = reverse('view_profile',
kwargs={'username': link_target_user.username})
message_arguments = {
'sender': arguments.sender.username,
'recipient': arguments.recipient.username,
'address': url
}
message = TYPE_TO_TEXT[arguments.type]
NotificationHandler.send_notification(notification_recipient,
'friends', message, message_arguments)
'ended': ugettext_noop("User %(sender)s no longer "
"wants to be your friend."),
}
def friendship_notification(arguments):
assert hasattr(arguments, 'type') \
and hasattr(arguments, 'sender') \
and hasattr(arguments, 'recipient'), \
"The log doesn't have type, sender or recipient " \
"value in the extra map"
link_target_user = arguments.sender
notification_recipient = arguments.recipient
url = reverse('view_profile',
kwargs={'username': link_target_user.username})
message_arguments = {
'sender': arguments.sender.username,
'recipient': arguments.recipient.username,
'address': url
}
message = TYPE_TO_TEXT[arguments.type]
NotificationHandler.send_notification(notification_recipient,
'friends', message, message_arguments)
NotificationHandler.register_notification('friends', friendship_notification)
# Check if any initial result is visible for user
if not pi.controller.can_see_submission_status(request,
arguments.submission):
return
if pi.contest:
url = reverse(
'submission',
kwargs={
'contest_id': pi.contest.pk,
'submission_id': arguments.submission.pk,
},
)
elif pi.problem.problemsite:
url = (reverse('problem_site',
kwargs={'site_key': pi.problem.problemsite.url_key}) +
'?key=submissions')
else:
url = ''
message = ugettext_noop("Initial result for task %(short_name)s is ready")
message_arguments = {'short_name': pi.short_name, 'address': url}
NotificationHandler.send_notification(arguments.user, 'initial_results',
message, message_arguments)
NotificationHandler.register_notification(
'initial_results', notification_function_initial_results)
message_details = (
arguments.question_instance.topic + ': ' + arguments.question_instance.content
)
message = ugettext_noop("Your question was answered.")
message_arguments = {
'address': arguments.question_instance.get_absolute_url(),
'details': message_details[:MAX_DETAILS_LENGTH],
}
NotificationHandler.send_notification(
arguments.user, 'question_answered', message, message_arguments
)
NotificationHandler.register_notification(
'question_answered', notification_function_answer
)
def notification_function_public(arguments):
assert hasattr(arguments, 'contest') and hasattr(arguments, 'message_instance'), (
"The log doesn't have contest or message_instance value" " in the extra map"
)
message_details = (
arguments.message_instance.topic + ': ' + arguments.message_instance.content
)
message = ugettext_noop("New public message.")
message_arguments = {
'address': arguments.message_instance.get_absolute_url(),
'details': message_details[:MAX_DETAILS_LENGTH],
and hasattr(arguments, 'question_instance') \
and hasattr(arguments, 'answer_instance'), \
"The log doesn't have user, question_instance or answer_instance" \
" value in the extra map"
message_details = arguments.question_instance.topic + ': ' + \
arguments.question_instance.content
message = ugettext_noop("Your question was answered.")
message_arguments = {'address': arguments.question_instance
.get_absolute_url(),
'details': message_details[:MAX_DETAILS_LENGTH]}
NotificationHandler.send_notification(arguments.user,
'question_answered', message, message_arguments)
NotificationHandler.register_notification('question_answered',
notification_function_answer)
def notification_function_public(arguments):
assert hasattr(arguments, 'contest') \
and hasattr(arguments, 'message_instance'), \
"The log doesn't have contest or message_instance value" \
" in the extra map"
message_details = arguments.message_instance.topic + ': ' + \
arguments.message_instance.content
message = ugettext_noop("New public message.")
message_arguments = {
'address': arguments.message_instance.get_absolute_url(),
'details': message_details[:MAX_DETAILS_LENGTH]
}
def notification_function_submission_judged(arguments):
assert hasattr(arguments, 'user') and \
hasattr(arguments, 'submission')
pi = arguments.submission.problem_instance
request = RequestFactory().get('/', data={'name': u'test'})
request.user = arguments.user
request.contest = pi.contest
request.timestamp = datetime.now().replace(tzinfo=utc)
# Check if the final report is visible to the user
if not pi.contest.controller.can_see_submission_score(request,
arguments.submission):
return
url = reverse('submission',
kwargs={'contest_id': pi.contest.pk,
'submission_id': arguments.submission.pk})
message = pi.contest.controller \
.get_notification_message_submission_judged(arguments.submission)
message_arguments = {'short_name': pi.short_name,
'address': url}
NotificationHandler.send_notification(arguments.user,
'submission_judged', message, message_arguments)
NotificationHandler.register_notification('submission_judged',
notification_function_submission_judged)
# Check if the final report is visible to the user
if not pi.contest.controller.can_see_submission_score(
request, arguments.submission):
return
url = reverse(
'submission',
kwargs={
'contest_id': pi.contest.pk,
'submission_id': arguments.submission.pk
},
)
message = pi.contest.controller.get_notification_message_submission_judged(
arguments.submission)
message_arguments = {
'short_name': pi.short_name,
'contest_name': pi.contest.name,
'task_name': six.text_type(pi),
'score': six.text_type(arguments.submission.score),
'address': url,
}
NotificationHandler.send_notification(arguments.user, 'submission_judged',
message, message_arguments)
NotificationHandler.register_notification(
'submission_judged', notification_function_submission_judged)
request = RequestFactory().get('/', data={'name': u'test'})
request.user = arguments.user
request.contest = pi.contest
request.timestamp = datetime.now().replace(tzinfo=utc)
# Check if any initial result is visible for user
if not pi.controller \
.can_see_submission_status(request, arguments.submission):
return
if pi.contest:
url = reverse('submission',
kwargs={'contest_id': pi.contest.pk,
'submission_id': arguments.submission.pk})
elif pi.problem.problemsite:
url = reverse('problem_site', kwargs={
'site_key': pi.problem.problemsite.url_key}) \
+ '?key=submissions'
else:
url = ''
message = ugettext_noop("Initial result for task %(short_name)s is ready")
message_arguments = {'short_name': pi.short_name,
'address': url}
NotificationHandler.send_notification(arguments.user,
'initial_results', message, message_arguments)
NotificationHandler.register_notification('initial_results',
notification_function_initial_results)
