def testIndexCommitment(self):
"""Tests that a commitment shows up in public commitments and in the wall."""
posts = self.team.post_set.count()
# Create a commitment that will appear on the news page.
commitment = Commitment(
type="commitment",
title="Test commitment",
slug="test-commitment",
description="A commitment!",
point_value=10,
)
commitment.save()
member = ActionMember(action=commitment, user=self.user)
member.save()
response = self.client.get(reverse("news_index"))
self.failUnlessEqual(response.status_code, 200)
self.assertEqual(
posts + 1, self.team.post_set.count(),
"One post should have been posted to the wall (public commitment)."
)
self.assertContains(response, commitment.title, 2,
msg_prefix="Commitment title should only appear in the wall and the public " \
"commitments box."
)
def testDeleteRemovesPoints(self):
"""Test that deleting a commitment member after it is completed removes the user's
points."""
points = self.user.get_profile().points()
# Setup to check round points.
(entry, _) = self.user.get_profile().scoreboardentry_set.get_or_create(
round_name=self.current_round)
round_points = entry.points
commitment_member = ActionMember(user=self.user, action=self.commitment,
completion_date=datetime.datetime.today())
commitment_member.save()
commitment_member.award_date = datetime.datetime.today()
commitment_member.approval_status = "approved"
commitment_member.save()
award_date = commitment_member.award_date
commitment_member.delete()
# Verify nothing has changed.
profile = self.user.get_profile()
self.assertTrue(
profile.last_awarded_submission() is None or
profile.last_awarded_submission() < award_date)
self.assertEqual(points, profile.points())
entry = self.user.get_profile().scoreboardentry_set.get(round_name=self.current_round)
self.assertEqual(round_points, entry.points)
self.assertTrue(
entry.last_awarded_submission is None or entry.last_awarded_submission < award_date)
def testPopularActivities(self):
"""Check which activity is the most popular."""
activity_member = ActionMember(user=self.user, action=self.activity)
activity_member.approval_status = "approved"
activity_member.save()
activities = smartgrid.get_popular_actions("activity", "approved")
self.assertEqual(activities[0].title, self.activity.title)
def testPopularActivities(self):
"""Check which activity is the most popular."""
activity_member = ActionMember(user=self.user, action=self.activity)
activity_member.approval_status = "approved"
activity_member.save()
activities = smartgrid.get_popular_actions("activity", "approved")
self.assertEqual(activities[0].title, self.activity.title)
def testCompletedActivity(self):
"""Tests that approved_action works when a task is completed."""
activity = Activity(
type="activity",
name="Test",
title="Test activity",
slug="test-activity",
description="Variable points!",
expected_duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
)
activity.save()
# Test within context of a quest
self.quest.unlock_conditions = "approved_action(slug='test-activity')"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(self.quest not in quests,
"User should not be able to participate in this quest.")
member = ActionMember(user=self.user, action=activity, approval_status="approved")
member.save()
self.assertTrue(approved_action(self.user, slug="test-activity"),
"User should have completed 'Test'.")
self.assertTrue(approved_some_of(self.user, action_type="activity"),
"User should have completed an activity")
quests = get_quests(self.user)
self.assertTrue(self.quest in quests["available_quests"],
"User should be able to participate in this quest.")
self.quest.unlock_conditions = "approved_some_of(action_type='activity')"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(self.quest in quests["available_quests"],
"User should be able to participate in this quest.")
# Test as a completion condition.
self.quest.accept(self.user)
self.quest.completion_conditions = "not approved_action(slug='test-activity')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest not in completed_quests,
"User should not be able to complete the quest.")
self.quest.completion_conditions = "not approved_some_of(action_type='activity')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest not in completed_quests,
"User should not be able to complete the quest.")
self.quest.completion_conditions = "approved_action(slug='test-activity')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest in completed_quests, "User should have completed the quest.")
def testActivityLog(self):
"""
Test that regular activities create the appropriate log.
"""
member = ActionMember(user=self.user, action=self.activity, approval_status='approved')
member.save()
# Check the points log for this user.
log = self.user.pointstransaction_set.all()[0]
self.assertTrue(log.message.startswith(self.activity.type.capitalize()))
def testPopularCommitments(self):
"""Tests that we can retrieve the most popular commitments."""
commitment_member = ActionMember(user=self.user, action=self.commitment)
commitment_member.award_date = datetime.datetime.today()
commitment_member.approval_status = "approved"
commitment_member.save()
commitments = smartgrid.get_popular_actions("commitment", "approved")
self.assertEqual(commitments[0].title, self.commitment.title)
self.assertEqual(commitments[0].completions, 1, "Most popular commitment should have one completion.")
def testActivityLog(self):
"""
Test that regular activities create the appropriate log.
"""
member = ActionMember(user=self.user, action=self.activity, approval_status='approved')
member.save()
# Check the points log for this user.
log = self.user.pointstransaction_set.all()[0]
self.assertTrue(log.message.startswith(self.activity.type.capitalize()))
def testDeleteRemovesPoints(self):
"""Test that deleting a commitment member after it is completed removes the user's
points."""
points = self.user.profile.points()
# Setup to check round points.
(entry, _) = self.user.profile.scoreboardentry_set.get_or_create(
round_name=self.current_round)
round_points = entry.points
commitment_member = ActionMember(user=self.user, action=self.commitment,
completion_date=datetime.datetime.today())
commitment_member.save()
commitment_member.award_date = datetime.datetime.today()
commitment_member.approval_status = "approved"
commitment_member.save()
award_date = commitment_member.award_date
commitment_member.delete()
# Verify nothing has changed.
profile = self.user.profile
self.assertTrue(
profile.last_awarded_submission() is None or
profile.last_awarded_submission() < award_date)
self.assertEqual(points, profile.points())
entry = self.user.profile.scoreboardentry_set.get(round_name=self.current_round)
self.assertEqual(round_points, entry.points)
self.assertTrue(
entry.last_awarded_submission is None or entry.last_awarded_submission < award_date)
def complete_setup_activity(user):
"""complete the setup activity."""
# error out if we can't find to the activity.
activity = get_setup_activity()
members = ActionMember.objects.filter(user=user, action=activity)
if not members:
# if points not awarded, do so.
member = ActionMember(action=activity, user=user)
member.approval_status = "approved"
member.save()
def complete_setup_activity(user):
"""complete the setup activity."""
# error out if we can't find to the activity.
activity = get_setup_activity()
members = ActionMember.objects.filter(user=user, action=activity)
if not members:
# if points not awarded, do so.
member = ActionMember(action=activity, user=user)
member.approval_status = "approved"
member.save()
def signup(request, event):
"""Commit the current user to the activity."""
user = request.user
action_member = ActionMember(user=user, action=event)
action_member.save()
response = HttpResponseRedirect(
reverse("activity_task", args=(event.type, event.slug,)))
value = score_mgr.signup_points()
notification = "You just earned " + str(value) + " points."
response.set_cookie("task_notify", notification)
return response
def testActivityAchievement(self):
"""Check that the user's activity achievements are loaded."""
activity = Activity(
title="Test activity",
description="Testing!",
duration=10,
point_value=10,
slug="test-activity",
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="activity",
)
activity.save()
# Test that profile page has a pending activity.
member = ActionMember(user=self.user,
action=activity,
approval_status="approved")
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(
response,
reverse("activity_task", args=(
activity.type,
activity.slug,
)))
self.assertContains(response, "Test activity")
# Test adding an event to catch a bug.
event = Event(
title="Test event",
slug="test-event",
description="Testing!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
type="event",
event_date=datetime.datetime.today() + datetime.timedelta(days=3),
)
event.save()
member = ActionMember(user=self.user,
action=event,
approval_status="pending")
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(
response,
reverse("activity_task", args=(
activity.type,
activity.slug,
)))
self.assertContains(response, "Pending")
self.assertContains(response, "Activity:")
self.assertContains(response, "Event:")
self.assertNotContains(response,
"You have nothing in progress or pending.")
def testIndexMostPopular(self):
"""Test most popular"""
posts = self.team.post_set.count()
commitment = Commitment(
type="commitment",
title="Test commitment2",
slug="test-commitment2",
description="A commitment2!",
point_value=10,
)
commitment.save()
member = ActionMember(action=commitment, user=self.user)
member.save()
member = ActionMember(action=commitment,
user=self.user,
approval_status="approved",
award_date=datetime.datetime.today())
member.save()
response = self.client.get(reverse("news_index"))
self.failUnlessEqual(response.status_code, 200)
self.assertEqual(
posts + 2, self.team.post_set.count(),
"Two posts should have been posted to the wall (commit and award)."
)
def testCompletionAddsPoints(self):
"""Tests that completing a task adds points."""
points = self.user.get_profile().points()
# Setup to check round points.
(entry, _) = self.user.get_profile().scoreboardentry_set.get_or_create(
round_name=self.current_round)
round_points = entry.points
commitment_member = ActionMember(user=self.user, action=self.commitment,
completion_date=datetime.datetime.today())
commitment_member.save()
# Check that the user's signup point.
self.assertEqual(points + score_mgr.signup_points(), self.user.get_profile().points())
entry = self.user.get_profile().scoreboardentry_set.get(round_name=self.current_round)
self.assertEqual(round_points + score_mgr.signup_points(), entry.points)
commitment_member.award_date = datetime.datetime.today()
commitment_member.approval_status = "approved"
commitment_member.save()
points += commitment_member.action.commitment.point_value
self.assertEqual(points + score_mgr.signup_points(), self.user.get_profile().points())
self.assertEqual(self.user.get_profile().last_awarded_submission(),
commitment_member.award_date)
entry = self.user.get_profile().scoreboardentry_set.get(round_name=self.current_round)
round_points += commitment_member.action.commitment.point_value
self.assertEqual(round_points + score_mgr.signup_points(), entry.points)
self.assertTrue(
abs(entry.last_awarded_submission - commitment_member.award_date) < datetime.timedelta(
minutes=1))
def testVariablePointAchievement(self):
"""Test that a variable point activity appears correctly in the my achievements list."""
activity = Activity(
title="Test activity",
slug="test-activity",
description="Variable points!",
duration=10,
point_range_start=5,
point_range_end=314160,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="activity",
)
activity.save()
points = self.user.get_profile().points()
member = ActionMember(
user=self.user,
action=activity,
approval_status="approved",
)
member.points_awarded = 314159
member.save()
self.assertEqual(
self.user.get_profile().points(), points + 314159,
"Variable number of points should have been awarded.")
# Kludge to change point value for the info bar.
profile = self.user.get_profile()
profile.add_points(3, datetime.datetime.today(), "test")
profile.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(
response,
reverse("activity_task", args=(
activity.type,
activity.slug,
)))
# Note, this test may break if something in the page has the value 314159.
# Try finding another suitable number.
# print response.content
self.assertContains(
response,
"314159",
count=5,
msg_prefix="314159 points should appear for the activity.")
def testRejectionNotifications(self):
"""
Test that notifications are created by rejections and
are marked as read when the member changes back to pending.
"""
notifications = UserNotification.objects.count()
activity_member = ActionMember(user=self.user, action=self.activity,
submission_date=datetime.datetime.today())
activity_member.approval_status = "rejected"
activity_member.submission_date = datetime.datetime.today()
activity_member.save()
self.assertEqual(UserNotification.objects.count(), notifications + 1,
"New notification should have been created.")
notice = activity_member.notifications.all()[0]
self.assertTrue(notice.unread, "Notification should be unread.")
def testSocialBonusAchievement(self):
"""Check that the social bonus appears in the my achievements list."""
# Create a second test user.
user2 = User.objects.create_user("user2", "*****@*****.**")
event = Event.objects.create(
title="Test event",
slug="test-event",
description="Testing!",
duration=10,
point_value=10,
social_bonus=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
type="event",
event_date=datetime.datetime.today(),
)
# Create membership for the two users.
m = ActionMember(
user=self.user,
action=event,
approval_status="approved",
)
m.social_email = "*****@*****.**"
m.save()
m2 = ActionMember(
user=user2,
action=event,
approval_status="approved",
)
m2.social_email = "*****@*****.**"
m2.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(
response, reverse("activity_task", args=(
event.type,
event.slug,
)))
entry = "Event: Test event (Social Bonus)"
self.assertContains(
response,
entry,
count=1,
msg_prefix="Achievements should contain a social bonus entry")
def testCommitmentAchievement(self):
"""Check that the user's commitment achievements are loaded."""
commitment = Commitment(
title="Test commitment",
description="A commitment!",
point_value=10,
type="commitment",
slug="test-commitment",
)
commitment.save()
# Test that profile page has a pending activity.
member = ActionMember(user=self.user, action=commitment)
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response,
reverse("activity_task", args=(commitment.type, commitment.slug,)))
self.assertContains(response, "In Progress")
self.assertContains(response, "Commitment:")
self.assertNotContains(response, "You have nothing in progress or pending.")
# Test that the profile page has a rejected activity
member.award_date = datetime.datetime.today()
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response,
reverse("activity_task", args=(commitment.type, commitment.slug,)))
self.assertNotContains(response, "You have not been awarded anything yet!")
self.assertNotContains(response, "In Progress")
def testApproveAddsPoints(self):
"""Test for verifying that approving a user awards them points."""
points = self.user.get_profile().points()
# Setup to check round points.
(entry, _) = self.user.get_profile().scoreboardentry_set.get_or_create(
round_name=self.current_round)
round_points = entry.points
round_last_awarded = entry.last_awarded_submission
activity_points = self.activity.point_value
activity_member = ActionMember(user=self.user, action=self.activity)
activity_member.save()
# Verify that nothing has changed.
self.assertEqual(points, self.user.get_profile().points())
entry = self.user.get_profile().scoreboardentry_set.get(round_name=self.current_round)
self.assertEqual(round_points, entry.points)
self.assertEqual(round_last_awarded, entry.last_awarded_submission)
activity_member.approval_status = "approved"
activity_member.save()
# Verify overall score changed.
new_points = self.user.get_profile().points()
self.assertEqual(new_points - points, activity_points)
# Verify round score changed.
entry = self.user.get_profile().scoreboardentry_set.get(round_name=self.current_round)
self.assertEqual(round_points + activity_points, entry.points)
self.assertTrue(abs(
activity_member.submission_date - entry.last_awarded_submission) < datetime.timedelta(
minutes=1))
def testDeleteRemovesPoints(self):
"""Test that deleting an approved ActionMember removes their points."""
points = self.user.get_profile().points()
# Setup to check round points.
(entry, _) = self.user.get_profile().scoreboardentry_set.get_or_create(
round_name=self.current_round)
round_points = entry.points
activity_member = ActionMember(user=self.user, action=self.activity)
activity_member.approval_status = "approved"
activity_member.save()
award_date = activity_member.award_date
activity_member.delete()
new_points = self.user.get_profile().points()
self.assertEqual(points, new_points)
self.assertTrue(self.user.get_profile().last_awarded_submission() is None)
entry = self.user.get_profile().scoreboardentry_set.get(round_name=self.current_round)
self.assertEqual(round_points, entry.points)
self.assertTrue(
entry.last_awarded_submission is None or entry.last_awarded_submission < award_date)
def testCompletionAddsPoints(self):
"""Tests that completing a task adds points."""
points = self.user.profile.points()
# Setup to check round points.
(entry, _) = self.user.profile.scoreboardentry_set.get_or_create(
round_name=self.current_round)
round_points = entry.points
commitment_member = ActionMember(user=self.user, action=self.commitment,
completion_date=datetime.datetime.today())
commitment_member.save()
# Check that the user's signup point.
self.assertEqual(points + score_mgr.signup_points(), self.user.profile.points())
entry = self.user.profile.scoreboardentry_set.get(round_name=self.current_round)
self.assertEqual(round_points + score_mgr.signup_points(), entry.points)
commitment_member.award_date = datetime.datetime.today()
commitment_member.approval_status = "approved"
commitment_member.save()
points += commitment_member.action.commitment.point_value
self.assertEqual(points + score_mgr.signup_points(), self.user.profile.points())
self.assertEqual(self.user.profile.last_awarded_submission(),
commitment_member.award_date)
entry = self.user.profile.scoreboardentry_set.get(round_name=self.current_round)
round_points += commitment_member.action.commitment.point_value
self.assertEqual(round_points + score_mgr.signup_points(), entry.points)
self.assertTrue(
abs(entry.last_awarded_submission - commitment_member.award_date) < datetime.timedelta(
minutes=1))
def testRejectedActivity(self):
"""
Test that a rejected activity submission posts a message.
"""
activity = test_utils.create_activity()
member = ActionMember(
action=activity,
user=self.user,
approval_status="rejected",
submission_date=datetime.datetime.today(),
)
member.save()
response = self.client.get(reverse("learn_index"))
self.assertContains(response, 'Your response to <a href="%s' % (
reverse("activity_task", args=(activity.type, activity.slug,)),
))
response = self.client.get(reverse("learn_index"))
self.assertNotContains(response, "notification-box")
def testHasCommitment(self):
"""Tests that has_action works for a commitment in progress."""
commitment = Commitment(
title="Test commitment",
type="commitment",
name="Test",
slug="test-commitment",
description="A commitment!",
point_value=10,
)
commitment.save()
# Test as an unlock condition.
self.quest.unlock_conditions = "completed_action(slug='test-commitment')"
self.quest.save()
self.assertTrue(
self.quest not in get_quests(self.user),
"User should not be able to participate in this quest.")
member = ActionMember(user=self.user, action=commitment)
member.save()
self.assertTrue(completed_action(self.user, slug='test-commitment'),
"User should have a commitment in progress.")
self.assertTrue(completed_some_of(self.user, action_type="commitment"),
"User should have a commitment in progress.")
self.assertTrue(
self.quest in get_quests(self.user)["available_quests"],
"User should be able to participate in this quest.")
self.quest.unlock_conditions = "completed_some_of(action_type='commitment')"
self.quest.save()
self.assertTrue(
self.quest in get_quests(self.user)["available_quests"],
"User should be able to participate in this quest.")
member.award_date = datetime.datetime.today()
member.save()
self.assertTrue(completed_action(self.user, slug='test-commitment'),
"User should have a completed commitment.")
self.assertTrue(completed_some_of(self.user, action_type="commitment"),
"User should have a completed commitment.")
# Test as a completion condition
self.quest.accept(self.user)
self.quest.completion_conditions = "not completed_action(slug='test-commitment')"
self.quest.save()
self.assertTrue(self.quest not in possibly_completed_quests(self.user),
"User should not be able to complete this quest.")
self.quest.completion_conditions = "not completed_some_of(action_type='commitment')"
self.quest.save()
self.assertTrue(self.quest not in possibly_completed_quests(self.user),
"User should not be able to complete this quest.")
self.quest.completion_conditions = "completed_action(slug='test-commitment')"
self.quest.save()
self.assertTrue(self.quest in possibly_completed_quests(self.user),
"User should be able to complete this quest.")
def signup(request, event):
"""Commit the current user to the activity."""
user = request.user
value = None
# Search for an existing activity for this user
if event not in user.action_set.all():
action_member = ActionMember(user=user, action=event)
action_member.save()
response = HttpResponseRedirect(
reverse("activity_task", args=(event.type, event.slug,)))
value = score_mgr.signup_points()
notification = "You just earned " + str(value) + " points."
response.set_cookie("task_notify", notification)
return response
# adding to the existing activity results in redirecting to the task page
return HttpResponseRedirect(reverse("activity_task", args=(event.type, event.slug,)))
def testVariablePointAchievement(self):
"""Test that a variable point activity appears correctly in the my achievements list."""
activity = Activity(
title="Test activity",
slug="test-activity",
description="Variable points!",
duration=10,
point_range_start=5,
point_range_end=314160,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="activity",
)
activity.save()
points = self.user.get_profile().points()
member = ActionMember(
user=self.user,
action=activity,
approval_status="approved",
)
member.points_awarded = 314159
member.save()
self.assertEqual(self.user.get_profile().points(), points + 314159,
"Variable number of points should have been awarded.")
# Kludge to change point value for the info bar.
profile = self.user.get_profile()
profile.add_points(3, datetime.datetime.today(), "test")
profile.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response,
reverse("activity_task", args=(activity.type, activity.slug,)))
# Note, this test may break if something in the page has the value 314159.
# Try finding another suitable number.
# print response.content
self.assertContains(response, "314159", count=5,
msg_prefix="314159 points should appear for the activity.")
def testRejectedActivity(self):
"""
Test that a rejected activity submission posts a message.
"""
activity = test_utils.create_activity()
member = ActionMember(
action=activity,
user=self.user,
approval_status="rejected",
submission_date=datetime.datetime.today(),
)
member.save()
response = self.client.get(reverse("learn_index"))
self.assertContains(
response, 'Your response to <a href="%s' %
(reverse("activity_task", args=(
activity.type,
activity.slug,
)), ))
response = self.client.get(reverse("learn_index"))
self.assertNotContains(response, "notification-box")
def testDeleteRemovesPoints(self):
"""Test that deleting an approved ActionMember removes their points."""
points = self.user.profile.points()
# Setup to check round points.
(entry, _) = self.user.profile.scoreboardentry_set.get_or_create(
round_name=self.current_round)
round_points = entry.points
activity_member = ActionMember(user=self.user, action=self.activity)
activity_member.approval_status = "approved"
activity_member.save()
award_date = activity_member.award_date
activity_member.delete()
new_points = self.user.profile.points()
self.assertEqual(points, new_points)
self.assertTrue(self.user.profile.last_awarded_submission() is None)
entry = self.user.profile.scoreboardentry_set.get(round_name=self.current_round)
self.assertEqual(round_points, entry.points)
self.assertTrue(
entry.last_awarded_submission is None or entry.last_awarded_submission < award_date)
def testApproveAddsPoints(self):
"""Test for verifying that approving a user awards them points."""
points = self.user.profile.points()
# Setup to check round points.
(entry, _) = self.user.profile.scoreboardentry_set.get_or_create(
round_name=self.current_round)
round_points = entry.points
round_last_awarded = entry.last_awarded_submission
activity_points = self.activity.point_value
activity_member = ActionMember(user=self.user, action=self.activity)
activity_member.save()
# Verify that nothing has changed.
self.assertEqual(points, self.user.profile.points())
entry = self.user.profile.scoreboardentry_set.get(round_name=self.current_round)
self.assertEqual(round_points, entry.points)
self.assertEqual(round_last_awarded, entry.last_awarded_submission)
activity_member.approval_status = "approved"
activity_member.save()
# Verify overall score changed.
new_points = self.user.profile.points()
self.assertEqual(new_points - points, activity_points)
# Verify round score changed.
entry = self.user.profile.scoreboardentry_set.get(round_name=self.current_round)
self.assertEqual(round_points + activity_points, entry.points)
self.assertTrue(abs(
activity_member.submission_date - entry.last_awarded_submission) < datetime.timedelta(
minutes=1))
def testCommitmentAchievement(self):
"""Check that the user's commitment achievements are loaded."""
commitment = Commitment(
title="Test commitment",
description="A commitment!",
point_value=10,
type="commitment",
slug="test-commitment",
)
commitment.save()
# Test that profile page has a pending activity.
member = ActionMember(user=self.user, action=commitment)
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response,
reverse("activity_task", args=(commitment.type, commitment.slug,)))
self.assertContains(response, "In Progress")
self.assertContains(response, "Commitment:")
self.assertNotContains(response, "You have nothing in progress or pending.")
# Test that the profile page has a rejected activity
member.award_date = datetime.datetime.today()
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response,
reverse("activity_task", args=(commitment.type, commitment.slug,)))
self.assertNotContains(response, "You have not been awarded anything yet!")
self.assertNotContains(response, "In Progress")
def testNumTasksCompletedWithType(self):
"""test task completed."""
activity = Activity(
type="activity",
name="Test",
slug="test",
title="Test activity",
description="Variable points!",
expected_duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
)
activity.save()
# Test activities
member = ActionMember(user=self.user,
action=activity,
approval_status="pending")
member.save()
self.assertFalse(
approved_some_of_type(self.user, action_type="activity", count=1),
"User with pending activity should not have completed a task.")
# Test within context of a quest
self.quest.unlock_conditions = "approved_some_of_type(action_type='activity', count=1)"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(
self.quest not in quests,
"User should not be able to participate in this quest.")
# Check that the user can now add the quest.
member.approval_status = "approved"
member.save()
quests = get_quests(self.user)
self.assertTrue(self.quest in quests["available_quests"],
"User should be able to participate in this quest.")
# Test as a completion condition.
self.quest.accept(self.user)
self.quest.completion_conditions = "approved_some_of_type(action_type='activity', count=2)"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest not in completed_quests,
"User should not be able to complete the quest.")
self.quest.completion_conditions = "approved_some_of_type(action_type='activity', count=1)"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest in completed_quests,
"User should have completed the quest.")
def testCommitmentsNumCompleted(self):
"""Tests that approved_some_of works for a completed commitment."""
commitment = Commitment(
title="Test commitment",
type="commitment",
slug="test",
name="Test",
description="A commitment!",
point_value=10,
)
commitment.save()
member = ActionMember(user=self.user, action=commitment)
member.save()
self.assertFalse(
approved_some(self.user, count=1),
"User with commitment in progress should not have completed a task."
)
# Test as an unlock condition
self.quest.unlock_conditions = "approved_some(count=1)"
self.quest.save()
self.assertTrue(
self.quest not in get_quests(self.user),
"User should not be able to participate in this quest.")
member.award_date = datetime.datetime.today()
member.approval_status = "approved"
member.save()
self.assertTrue(
approved_some(self.user, count=1),
"User that has a completed commitment did not complete a task.")
self.assertTrue(
self.quest in get_quests(self.user)["available_quests"],
"User should be able to participate in this quest.")
# Test as a completion condition
self.quest.accept(self.user)
self.quest.completion_conditions = "approved_some(count=2)"
self.quest.save()
self.assertTrue(self.quest not in possibly_completed_quests(self.user),
"User should not be able to complete this quest.")
self.quest.completion_conditions = "approved_some(count=1)"
self.quest.save()
self.assertTrue(self.quest in possibly_completed_quests(self.user),
"User should be able to complete this quest.")
def testIndexCommitment(self):
"""Tests that a commitment shows up in public commitments and in the wall."""
posts = self.team.post_set.count()
# Create a commitment that will appear on the news page.
commitment = Commitment(
type="commitment",
title="Test commitment",
slug="test-commitment",
description="A commitment!",
point_value=10,
)
commitment.save()
member = ActionMember(action=commitment, user=self.user)
member.save()
response = self.client.get(reverse("news_index"))
self.failUnlessEqual(response.status_code, 200)
self.assertEqual(posts + 1, self.team.post_set.count(),
"One post should have been posted to the wall (public commitment).")
self.assertContains(response, commitment.title, 2,
msg_prefix="Commitment title should only appear in the wall and the public " \
"commitments box."
)
def testHasCommitment(self):
"""Tests that has_action works for a commitment in progress."""
commitment = Commitment(
title="Test commitment",
type="commitment",
name="Test",
slug="test-commitment",
description="A commitment!",
point_value=10,
)
commitment.save()
# Test as an unlock condition.
self.quest.unlock_conditions = "submitted_action(slug='test-commitment')"
self.quest.save()
self.assertTrue(self.quest not in get_quests(self.user),
"User should not be able to participate in this quest.")
member = ActionMember(user=self.user, action=commitment)
member.save()
self.assertTrue(submitted_action(self.user, slug='test-commitment'),
"User should have a commitment in progress.")
self.assertTrue(submitted_some_of(self.user, action_type="commitment"),
"User should have a commitment in progress.")
self.assertTrue(self.quest in get_quests(self.user)["available_quests"],
"User should be able to participate in this quest.")
self.quest.unlock_conditions = "submitted_some_of(action_type='commitment')"
self.quest.save()
self.assertTrue(self.quest in get_quests(self.user)["available_quests"],
"User should be able to participate in this quest.")
member.award_date = datetime.datetime.today()
member.save()
self.assertTrue(submitted_action(self.user, slug='test-commitment'),
"User should have a completed commitment.")
self.assertTrue(submitted_some_of(self.user, action_type="commitment"),
"User should have a completed commitment.")
# Test as a completion condition
self.quest.accept(self.user)
self.quest.completion_conditions = "not submitted_action(slug='test-commitment')"
self.quest.save()
self.assertTrue(self.quest not in possibly_completed_quests(self.user),
"User should not be able to complete this quest.")
self.quest.completion_conditions = "not submitted_some_of(action_type='commitment')"
self.quest.save()
self.assertTrue(self.quest not in possibly_completed_quests(self.user),
"User should not be able to complete this quest.")
self.quest.completion_conditions = "submitted_action(slug='test-commitment')"
self.quest.save()
self.assertTrue(self.quest in possibly_completed_quests(self.user),
"User should be able to complete this quest.")
def testRejectThenApprove(self):
"""Test that Reject then approve a user removes their points."""
points = self.user.get_profile().points()
activity_member = ActionMember(user=self.user, action=self.activity,
submission_date=datetime.datetime.today())
activity_member.approval_status = "rejected"
activity_member.save()
self.assertEqual(len(mail.outbox), 1, "Check that the rejection sent an email.")
self.assertTrue(activity_member.award_date is None)
self.assertTrue(self.user.get_profile().last_awarded_submission() is None)
activity_member.approval_status = "approved"
activity_member.save()
new_points = self.user.get_profile().points()
self.assertEqual(points + activity_member.points_awarded, new_points)
def testPopularCommitments(self):
"""Tests that we can retrieve the most popular commitments."""
commitment_member = ActionMember(user=self.user, action=self.commitment)
commitment_member.award_date = datetime.datetime.today()
commitment_member.approval_status = "approved"
commitment_member.save()
commitments = smartgrid.get_popular_actions("commitment", "approved")
self.assertEqual(commitments[0].title, self.commitment.title)
self.assertEqual(commitments[0].completions, 1,
"Most popular commitment should have one completion.")
def complete(request, event):
"""complete the event and try to claim point."""
user = request.user
if request.method == "POST":
form = ActivityCodeForm(request.POST, request=request, action=event)
if form.is_valid():
# Approve the activity (confirmation code is validated in
# forms.ActivityTextForm.clean())
code = ConfirmationCode.objects.get(code=form.cleaned_data["response"].lower())
code.is_active = False
code.user = user
code.save()
try:
action_member = ActionMember.objects.get(user=user, action=event)
except ObjectDoesNotExist:
action_member = ActionMember(user=user, action=event)
action_member.approval_status = "approved"
value = event.point_value
action_member.social_email = form.cleaned_data["social_email"].lower()
try:
action_member.save()
except IntegrityError:
messages.error = 'Sorry, but it appears that you have already added this activity.'
return HttpResponseRedirect(
reverse("activity_task", args=(event.type, event.slug,)))
response = HttpResponseRedirect(
reverse("activity_task", args=(event.type, event.slug,)))
if value:
notification = "You just earned " + str(value) + " points."
response.set_cookie("task_notify", notification)
return response
# invalid form
# rebuild the form
form.form_title = "Get your points"
return render_to_response("task.html", {
"action": event,
"form": form,
"completed_count": 0,
"team_members": None,
"display_form": True,
"reminders": None,
}, context_instance=RequestContext(request))
return HttpResponseRedirect(reverse("activity_task", args=(event.type, event.slug,)))
def testRejectThenApprove(self):
"""Test that Reject then approve a user removes their points."""
points = self.user.get_profile().points()
activity_member = ActionMember(user=self.user, action=self.activity, submission_date=datetime.datetime.today())
activity_member.approval_status = "rejected"
activity_member.save()
self.assertEqual(len(mail.outbox), 1, "Check that the rejection sent an email.")
self.assertTrue(activity_member.award_date is None)
self.assertTrue(self.user.get_profile().last_awarded_submission() is None)
activity_member.approval_status = "approved"
activity_member.save()
new_points = self.user.get_profile().points()
self.assertEqual(points + activity_member.points_awarded, new_points)
def testActivityAchievement(self):
"""Check that the user's activity achievements are loaded."""
activity = Activity(
title="Test activity",
slug="test-activity",
description="Testing!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
type="activity",
is_canopy=False
)
activity.save()
# Test that profile page has a pending activity.
member = ActionMember(user=self.user,
action=activity,
approval_status="approved")
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response,
reverse("activity_task", args=(activity.type, activity.slug,)))
self.assertContains(response, "Test activity")
# Test adding an event to catch a bug.
event = Event(
title="Test event",
slug="test-event",
description="Testing!",
duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
type="event",
)
event.save()
member = ActionMember(user=self.user, action=event, approval_status="pending")
member.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response,
reverse("activity_task", args=(activity.type, activity.slug,)))
self.assertContains(response, "Pending")
self.assertContains(response, "Activity:")
self.assertContains(response, "Event:")
self.assertNotContains(response, "You have nothing in progress or pending.")
def testSocialBonusAchievement(self):
"""Check that the social bonus appears in the my achievements list."""
# Create a second test user.
user2 = User.objects.create_user("user2", "*****@*****.**")
event = Event.objects.create(
title="Test event",
slug="test-event",
description="Testing!",
duration=10,
point_value=10,
social_bonus=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
type="event",
event_date=datetime.datetime.today(),
)
# Create membership for the two users.
m = ActionMember(
user=self.user,
action=event,
approval_status="approved",
)
m.social_email = "*****@*****.**"
m.save()
m2 = ActionMember(
user=user2,
action=event,
approval_status="approved",
)
m2.social_email = "*****@*****.**"
m2.save()
response = self.client.get(reverse("profile_index"))
self.assertContains(response, reverse("activity_task", args=(event.type, event.slug,)))
entry = "Event: Test event (Social Bonus)"
self.assertContains(response, entry, count=1,
msg_prefix="Achievements should contain a social bonus entry")
def testNumTasksCompletedWithType(self):
"""test task completed."""
activity = Activity(
type="activity",
name="Test",
slug="test",
title="Test activity",
description="Variable points!",
expected_duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
)
activity.save()
# Test activities
member = ActionMember(user=self.user, action=activity, approval_status="pending")
member.save()
self.assertFalse(approved_some_of(self.user, 1, action_type="activity"),
"User with pending activity should not have completed a task.")
# Test within context of a quest
self.quest.unlock_conditions = "approved_some_of(1, action_type='activity')"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(self.quest not in quests,
"User should not be able to participate in this quest.")
# Check that the user can now add the quest.
member.approval_status = "approved"
member.save()
quests = get_quests(self.user)
self.assertTrue(self.quest in quests["available_quests"],
"User should be able to participate in this quest.")
# Test as a completion condition.
self.quest.accept(self.user)
self.quest.completion_conditions = "approved_some_of(2, action_type='activity')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest not in completed_quests,
"User should not be able to complete the quest.")
self.quest.completion_conditions = "approved_some_of(1, action_type='activity')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest in completed_quests, "User should have completed the quest.")
def testRejectionNotifications(self):
"""
Test that notifications are created by rejections and
are marked as read when the member changes back to pending.
"""
notifications = UserNotification.objects.count()
activity_member = ActionMember(user=self.user, action=self.activity,
submission_date=datetime.datetime.today())
activity_member.approval_status = "rejected"
activity_member.submission_date = datetime.datetime.today()
activity_member.save()
self.assertEqual(UserNotification.objects.count(), notifications + 1,
"New notification should have been created.")
notice = activity_member.notifications.all()[0]
self.assertTrue(notice.unread, "Notification should be unread.")
def testAction(self):
"""Tests submitted_action and approved_action predicates."""
self.assertFalse(submitted_some(self.user, count=1), "Haven't submitted any yet")
action_member = ActionMember(user=self.user, action=self.activity)
action_member.save()
self.assertTrue(submitted_some(self.user, count=1), "Have submitted one.")
self.assertTrue(submitted_action(self.user, self.activity.slug),
"submitted_action should be true")
self.assertFalse(approved_action(self.user, self.activity.slug),
"approved_action should be false")
self.assertFalse(approved_some(self.user, count=1), "Haven't had it approved yet.")
action_member.approval_status = 'approved'
action_member.save()
self.assertTrue(approved_action(self.user, self.activity.slug),
"approved_action should be true")
self.assertTrue(approved_some(self.user, count=1), "Have had one approved.")
def testCommitmentsNumCompleted(self):
"""Tests that approved_some_of works for a completed commitment."""
commitment = Commitment(
title="Test commitment",
type="commitment",
slug="test",
name="Test",
description="A commitment!",
point_value=10,
)
commitment.save()
member = ActionMember(user=self.user, action=commitment)
member.save()
self.assertFalse(approved_some_of(self.user, 1),
"User with commitment in progress should not have completed a task.")
# Test as an unlock condition
self.quest.unlock_conditions = "approved_some_of(1)"
self.quest.save()
self.assertTrue(self.quest not in get_quests(self.user),
"User should not be able to participate in this quest.")
member.award_date = datetime.datetime.today()
member.approval_status = "approved"
member.save()
self.assertTrue(approved_some_of(self.user, 1),
"User that has a completed commitment did not complete a task.")
self.assertTrue(self.quest in get_quests(self.user)["available_quests"],
"User should be able to participate in this quest.")
# Test as a completion condition
self.quest.accept(self.user)
self.quest.completion_conditions = "approved_some_of(2)"
self.quest.save()
self.assertTrue(self.quest not in possibly_completed_quests(self.user),
"User should not be able to complete this quest.")
self.quest.completion_conditions = "approved_some_of(1)"
self.quest.save()
self.assertTrue(self.quest in possibly_completed_quests(self.user),
"User should be able to complete this quest.")
def testAction(self):
"""Tests submitted_action and approved_action predicates."""
self.assertFalse(submitted_some(self.user, count=1),
"Haven't submitted any yet")
action_member = ActionMember(user=self.user, action=self.activity)
action_member.save()
self.assertTrue(submitted_some(self.user, count=1),
"Have submitted one.")
self.assertTrue(submitted_action(self.user, self.activity.slug),
"submitted_action should be true")
self.assertFalse(approved_action(self.user, self.activity.slug),
"approved_action should be false")
self.assertFalse(approved_some(self.user, count=1),
"Haven't had it approved yet.")
action_member.approval_status = 'approved'
action_member.save()
self.assertTrue(approved_action(self.user, self.activity.slug),
"approved_action should be true")
self.assertTrue(approved_some(self.user, count=1),
"Have had one approved.")
def testType(self):
"""Tests the predicates related to action_type."""
self.assertFalse(submitted_some_of_type(self.user, action_type='activity', count=1),
"submitted_some_of_type(activity,1) should be false")
self.assertFalse(submitted_some_of_type(self.user, action_type='commitment', count=1),
"submitted_some_of_type(commitment,1) should be false")
self.assertFalse(submitted_some_of_type(self.user, action_type='event', count=1),
"submitted_some_of_type(event,1) should be false")
self.assertFalse(submitted_all_of_type(self.user, action_type='activity'),
"submitted_all_of_type(activity) should be false")
self.assertFalse(submitted_all_of_type(self.user, action_type='commitment'),
"submitted_all_of_type(commitment) should be false")
self.assertFalse(submitted_all_of_type(self.user, action_type='event'),
"submitted_all_of_type(event) should be false")
action_member_activity = ActionMember(user=self.user, action=self.activity)
action_member_activity.save()
self.assertTrue(submitted_some_of_type(self.user, action_type='activity', count=1),
"submitted_some_of_type(activity,1) should be true")
self.assertFalse(submitted_some_of_type(self.user, action_type='commitment', count=1),
"submitted_some_of_type(commitment,1) should be false")
self.assertFalse(submitted_some_of_type(self.user, action_type='event', count=1),
"submitted_some_of_type(event,1) should be false")
self.assertTrue(submitted_all_of_type(self.user, action_type='activity'),
"submitted_all_of_type(activity) should be true")
self.assertFalse(submitted_all_of_type(self.user, action_type='commitment'),
"submitted_all_of_type(commitment) should be false")
self.assertFalse(submitted_all_of_type(self.user, action_type='event'),
"submitted_all_of_type(event) should be false")
self.assertFalse(approved_some_of_type(self.user, action_type='activity', count=1),
"approved_some_of_type(activity,1) should be false")
self.assertFalse(approved_all_of_type(self.user, action_type='activity'),
"approved_some_of_type(activity) should be false")
action_member_activity.approval_status = 'approved'
action_member_activity.save()
self.assertTrue(approved_some_of_type(self.user, action_type='activity', count=1),
"approved_some_of_type(activity,1) should be true")
self.assertTrue(approved_all_of_type(self.user, action_type='activity'),
"approved_some_of_type(activity) should be true")
self.assertFalse(approved_some_of_type(self.user, action_type='event', count=1),
"approved_some_of_type(event,1) should be false")
self.assertFalse(approved_all_of_type(self.user, action_type='event'),
"approved_some_of_type(event) should be false")
def testIndexMostPopular(self):
"""Test most popular"""
posts = self.team.post_set.count()
commitment = Commitment(
type="commitment",
title="Test commitment2",
slug="test-commitment2",
description="A commitment2!",
point_value=10,
)
commitment.save()
member = ActionMember(action=commitment, user=self.user)
member.save()
member = ActionMember(action=commitment, user=self.user,
approval_status="approved",
award_date=datetime.datetime.today())
member.save()
response = self.client.get(reverse("news_index"))
self.failUnlessEqual(response.status_code, 200)
self.assertEqual(posts + 2, self.team.post_set.count(),
"Two posts should have been posted to the wall (commit and award).")
def add(request, activity):
"""Creates a request for points for an activity."""
user = request.user
if request.method == "POST":
form = _get_form(request, activity)
if form.is_valid():
try:
action_member = ActionMember.objects.get(user=user, action=activity)
except ObjectDoesNotExist:
action_member = ActionMember(user=user, action=activity,
submission_date=datetime.datetime.today())
# Attach image if it is an image form.
if "image_response" in form.cleaned_data:
if activity.confirm_type == "free_image":
action_member.response = form.cleaned_data["response"]
path = activity_image_file_path(user=user,
filename=request.FILES['image_response'].name)
action_member.image = path
action_member.image.storage.save(path, request.FILES["image_response"])
action_member.approval_status = "pending"
# Attach text prompt question if one is provided
elif "question" in form.cleaned_data:
action_member.question = LibraryTextPromptQuestion.objects.get(
pk=form.cleaned_data["question"])
action_member.response = form.cleaned_data["response"]
action_member.approval_status = "pending"
elif activity.confirm_type == "free":
action_member.response = form.cleaned_data["response"]
action_member.approval_status = "pending"
action_member.social_email = form.cleaned_data["social_email"].lower()
try:
action_member.save()
except IntegrityError:
messages.error = 'Sorry, but it appears that you have already added this activity.'
return HttpResponseRedirect(
reverse("activity_task", args=(activity.type, activity.slug,)))
response = HttpResponseRedirect(
reverse("activity_task", args=(activity.type, activity.slug,)))
return response
# invalid form
# rebuild the form
form.form_title = "Get your points"
if activity.confirm_type == "text":
qid = form.data["question"]
question = LibraryTextPromptQuestion.objects.get(pk=qid)
form.action_question = question
return render_to_response("task.html", {
"action": activity,
"form": form,
"completed_count": 0,
"team_members": None,
"display_form": True,
"reminders": None,
}, context_instance=RequestContext(request))
return HttpResponseRedirect(reverse("activity_task", args=(activity.type, activity.slug,)))
def add(request, commitment):
"""Commit the current user to the commitment."""
user = request.user
value = None
if request.method == "GET": # redirect to task page, only allow POST
return HttpResponseRedirect(
reverse("activity_task", args=(commitment.type, commitment.slug,)))
form = CommitmentCommentForm(request.POST, user=request.user.username)
if not form.is_valid():
# invalid form
request.session["form_dict"] = form.data
request.session["form_errors"] = form.errors
return HttpResponseRedirect(
reverse("activity_task",
args=(commitment.type, commitment.slug,)) + "?display_form=True")
# now we have a valid form
if smartgrid.can_complete_commitment(user, commitment):
try:
member = user.actionmember_set.get(action=commitment, award_date=None)
except ObjectDoesNotExist:
# ignore the race condition
return HttpResponseRedirect(
reverse("activity_task", args=(commitment.type, commitment.slug,)))
#commitment end, award full point
member.award_date = datetime.datetime.today()
member.approval_status = "approved"
if form.cleaned_data["social_email"]:
member.social_email = form.cleaned_data["social_email"].lower()
member.save()
value = commitment.point_value
elif smartgrid.can_add_commitment(user):
# User can commit to this commitment. allow to commit to completed commitment again
# as long as the pending does not reach max
member = ActionMember(user=user, action=commitment)
if form:
member.social_email = form.cleaned_data["social_email"].lower()
try:
member.save()
value = score_mgr.signup_points()
except IntegrityError:
messages.error = 'Sorry, but it appears that you are already participating in ' \
'this commitment.'
return HttpResponseRedirect(
reverse("activity_task", args=(commitment.type, commitment.slug,)))
else: # user can not add more than 5 commitment
return HttpResponseRedirect(
reverse("activity_task", args=(commitment.type, commitment.slug,)))
response = HttpResponseRedirect(
reverse("activity_task", args=(commitment.type, commitment.slug,)))
notification = "You just earned " + str(value) + " points."
response.set_cookie("task_notify", notification)
return response
def attend_code(request):
"""Claim the attendance code or the Bonus Points code"""
user = request.user
action_member = None
message = None
social_email = None
if request.is_ajax() and request.method == "POST":
form = EventCodeForm(request.POST)
if form.is_valid():
message, social_email, code, is_bonus = _check_attend_code(user, form)
if message:
return HttpResponse(json.dumps({
"message": message,
"social_email": social_email
}), mimetype="application/json")
if not is_bonus: # It was an event code.
try:
action_member = ActionMember.objects.get(user=user, action=code.action)
except ObjectDoesNotExist:
action_member = ActionMember(user=user, action=code.action)
action_member.approval_status = "approved"
value = code.action.point_value
if "social_email" in form.cleaned_data and \
form.cleaned_data["social_email"] != "Email":
action_member.social_email = form.cleaned_data["social_email"].lower()
# Model save method will award the points.
action_member.save()
else: # It was a bonus point code.
profile = user.get_profile()
value = code.point_value
s = "Bonus Points: claimed {0} points".format(value)
profile.add_points(value,
datetime.datetime.today(),
s)
code.claim_date = datetime.datetime.now()
code.is_active = False
code.user = user
code.save()
notification = "You just earned " + str(value) + " points."
if not is_bonus:
response = HttpResponse(json.dumps({
"redirectUrl": reverse("activity_task",
args=(code.action.type, code.action.slug))
}), mimetype="application/json")
response.set_cookie("task_notify", notification)
else:
response = HttpResponse(json.dumps({
"redirectUrl": reverse("learn_index")}),
mimetype="application/json")
response.set_cookie("bonus_notify", notification)
UserNotification.create_info_notification(user, s)
return response
# At this point there is a form validation error.
return HttpResponse(json.dumps({
"message": "Please input code."
}), mimetype="application/json")
raise Http404
def testFullSpectrum(self):
"""Tests the predicates related to full spectrum."""
self.assertFalse(submitted_some_full_spectrum(self.user, count=1),
"submitted_some_full_spectrum(1) should be false")
self.assertFalse(approved_some_full_spectrum(self.user, count=1),
"approved_some_full_spectrum(1) should be false")
action_member_activity = ActionMember(user=self.user,
action=self.activity)
action_member_activity.save()
self.assertFalse(submitted_some_full_spectrum(self.user, count=1),
"submitted_some_full_spectrum(1) should be false")
self.assertFalse(approved_some_full_spectrum(self.user, count=1),
"approved_some_full_spectrum(1) should be false")
action_member_commitment = ActionMember(user=self.user,
action=self.commitment)
action_member_commitment.save()
action_member_event = ActionMember(user=self.user, action=self.event)
action_member_event.save()
self.assertTrue(submitted_some_full_spectrum(self.user, count=1),
"submitted_some_full_spectrum(1) should be true")
self.assertFalse(approved_some_full_spectrum(self.user, count=1),
"approved_some_full_spectrum(1) should be false")
action_member_activity.approval_status = 'approved'
action_member_activity.save()
self.assertFalse(approved_some_full_spectrum(self.user, count=1),
"approved_some_full_spectrum(1) should be false")
action_member_commitment.approval_status = 'approved'
action_member_commitment.save()
action_member_event.approval_status = 'approved'
action_member_event.save()
self.assertTrue(approved_some_full_spectrum(self.user, count=1),
"approved_some_full_spectrum(1) should be true")
def testType(self):
"""Tests the predicates related to action_type."""
self.assertFalse(
submitted_some_of_type(self.user, action_type='activity', count=1),
"submitted_some_of_type(activity,1) should be false")
self.assertFalse(
submitted_some_of_type(self.user,
action_type='commitment',
count=1),
"submitted_some_of_type(commitment,1) should be false")
self.assertFalse(
submitted_some_of_type(self.user, action_type='event', count=1),
"submitted_some_of_type(event,1) should be false")
self.assertFalse(
submitted_all_of_type(self.user, action_type='activity'),
"submitted_all_of_type(activity) should be false")
self.assertFalse(
submitted_all_of_type(self.user, action_type='commitment'),
"submitted_all_of_type(commitment) should be false")
self.assertFalse(submitted_all_of_type(self.user, action_type='event'),
"submitted_all_of_type(event) should be false")
action_member_activity = ActionMember(user=self.user,
action=self.activity)
action_member_activity.save()
self.assertTrue(
submitted_some_of_type(self.user, action_type='activity', count=1),
"submitted_some_of_type(activity,1) should be true")
self.assertFalse(
submitted_some_of_type(self.user,
action_type='commitment',
count=1),
"submitted_some_of_type(commitment,1) should be false")
self.assertFalse(
submitted_some_of_type(self.user, action_type='event', count=1),
"submitted_some_of_type(event,1) should be false")
self.assertTrue(
submitted_all_of_type(self.user, action_type='activity'),
"submitted_all_of_type(activity) should be true")
self.assertFalse(
submitted_all_of_type(self.user, action_type='commitment'),
"submitted_all_of_type(commitment) should be false")
self.assertFalse(submitted_all_of_type(self.user, action_type='event'),
"submitted_all_of_type(event) should be false")
self.assertFalse(
approved_some_of_type(self.user, action_type='activity', count=1),
"approved_some_of_type(activity,1) should be false")
self.assertFalse(
approved_all_of_type(self.user, action_type='activity'),
"approved_some_of_type(activity) should be false")
action_member_activity.approval_status = 'approved'
action_member_activity.save()
self.assertTrue(
approved_some_of_type(self.user, action_type='activity', count=1),
"approved_some_of_type(activity,1) should be true")
self.assertTrue(
approved_all_of_type(self.user, action_type='activity'),
"approved_some_of_type(activity) should be true")
self.assertFalse(
approved_some_of_type(self.user, action_type='event', count=1),
"approved_some_of_type(event,1) should be false")
self.assertFalse(approved_all_of_type(self.user, action_type='event'),
"approved_some_of_type(event) should be false")
def testLevel(self):
"""Tests the level based predicates."""
level_name = "Level Foo"
level = Level(name=level_name, slug='level-slug', priority=1)
level.save()
loc = Grid(level=level, column=1, row=1, action=self.activity)
loc.save()
loc = Grid(level=level, column=2, row=1, action=self.commitment)
loc.save()
loc = Grid(level=level, column=3, row=1, action=self.event)
loc.save()
self.assertFalse(
submitted_some_of_level(user=self.user,
level_name=level_name,
count=1),
"submitted_some_of_level should be false")
self.assertFalse(
approved_some_of_level(user=self.user,
level_name=level_name,
count=1),
"approved_some_of_level(1) should be false")
self.assertFalse(
submitted_all_of_level(user=self.user, level_name=level_name),
"submitted_all_of_level should be false")
action_member_activity = ActionMember(user=self.user,
action=self.activity)
action_member_activity.save()
self.assertTrue(
submitted_some_of_level(user=self.user,
level_name=level_name,
count=1),
"submitted_some_of_level(1) should be true")
self.assertFalse(
approved_some_of_level(user=self.user,
level_name=level_name,
count=1),
"approved_some_of_level(1) should be false")
self.assertFalse(
submitted_some_of_level(user=self.user,
level_name=level_name,
count=2),
"submitted_some_of_level(2) should be false")
self.assertFalse(
submitted_all_of_level(user=self.user, level_name=level_name),
"submitted_all_of_level should be false")
action_member_commitment = ActionMember(user=self.user,
action=self.commitment)
action_member_commitment.save()
self.assertTrue(
submitted_some_of_level(user=self.user,
level_name=level_name,
count=1),
"submitted_some_of_level(1) should be true")
self.assertTrue(
submitted_some_of_level(user=self.user,
level_name=level_name,
count=2),
"submitted_some_of_level(2) should be true")
self.assertFalse(
approved_some_of_level(user=self.user,
level_name=level_name,
count=1),
"approved_some_of_level(1) should be false")
self.assertFalse(
submitted_some_of_level(user=self.user,
level_name=level_name,
count=3),
"submitted_some_of_level(3) should be false")
self.assertFalse(
submitted_all_of_level(user=self.user, level_name=level_name),
"submitted_all_of_level should be false")
action_member_event = ActionMember(user=self.user, action=self.event)
action_member_event.save()
self.assertTrue(
submitted_some_of_level(user=self.user,
level_name=level_name,
count=1),
"submitted_some_of_level(1) should be true")
self.assertTrue(
submitted_some_of_level(user=self.user,
level_name=level_name,
count=2),
"submitted_some_of_level(2) should be true")
self.assertTrue(
submitted_some_of_level(user=self.user,
level_name=level_name,
count=3),
"submitted_some_of_level(3) should be true")
self.assertTrue(
submitted_all_of_level(user=self.user, level_name=level_name),
"submitted_all_of_level should be true")
self.assertFalse(
approved_some_of_level(user=self.user,
level_name=level_name,
count=1),
"approved_some_of_level(1) should be false")
action_member_activity.approval_status = 'approved'
action_member_activity.save()
self.assertTrue(
approved_some_of_level(user=self.user,
level_name=level_name,
count=1),
"approved_some_of_level(1) should be true")
self.assertFalse(
approved_all_of_level(user=self.user, level_name=level_name),
"approved_all_of_level should be false")
action_member_commitment.approval_status = 'approved'
action_member_commitment.save()
action_member_event.approval_status = 'approved'
action_member_event.save()
self.assertTrue(
approved_some_of_level(user=self.user,
level_name=level_name,
count=3),
"approved_some_of_level(3) should be true")
self.assertTrue(
approved_all_of_level(user=self.user, level_name=level_name),
"approved_all_of_level should be true")
def add(request, commitment):
"""Commit the current user to the commitment."""
user = request.user
value = None
if request.method == "GET": # redirect to task page, only allow POST
return HttpResponseRedirect(
reverse("activity_task", args=(
commitment.type,
commitment.slug,
)))
form = CommitmentCommentForm(request.POST, user=request.user.username)
if not form.is_valid():
# invalid form
request.session["form_dict"] = form.data
request.session["form_errors"] = form.errors
return HttpResponseRedirect(
reverse("activity_task", args=(
commitment.type,
commitment.slug,
)) + "?display_form=True")
# now we have a valid form
if smartgrid.can_complete_commitment(user, commitment):
try:
member = user.actionmember_set.get(action=commitment,
award_date=None)
except ObjectDoesNotExist:
# ignore the race condition
return HttpResponseRedirect(
reverse("activity_task",
args=(
commitment.type,
commitment.slug,
)))
#commitment end, award full point
member.award_date = datetime.datetime.today()
member.approval_status = "approved"
if form.cleaned_data["social_email"]:
member.social_email = form.cleaned_data["social_email"].lower()
member.save()
value = commitment.point_value
elif smartgrid.can_add_commitment(user):
# User can commit to this commitment. allow to commit to completed commitment again
# as long as the pending does not reach max
member = ActionMember(user=user, action=commitment)
if form:
member.social_email = form.cleaned_data["social_email"].lower()
try:
member.save()
value = score_mgr.signup_points()
except IntegrityError:
messages.error = 'Sorry, but it appears that you are already participating in ' \
'this commitment.'
return HttpResponseRedirect(
reverse("activity_task",
args=(
commitment.type,
commitment.slug,
)))
else: # user can not add more than 5 commitment
return HttpResponseRedirect(
reverse("activity_task", args=(
commitment.type,
commitment.slug,
)))
response = HttpResponseRedirect(
reverse("activity_task", args=(
commitment.type,
commitment.slug,
)))
notification = "You just earned " + str(value) + " points."
response.set_cookie("task_notify", notification)
return response
def testCompletedActivity(self):
"""Tests that approved_action works when a task is completed."""
activity = Activity(
type="activity",
name="Test",
title="Test activity",
slug="test-activity",
description="Variable points!",
expected_duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
)
activity.save()
# Test within context of a quest
self.quest.unlock_conditions = "approved_action(action_slug='test-activity')"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(
self.quest not in quests,
"User should not be able to participate in this quest.")
member = ActionMember(user=self.user,
action=activity,
approval_status="approved")
member.save()
self.assertTrue(
approved_action(self.user, action_slug="test-activity"),
"User should have completed 'Test'.")
self.assertTrue(
approved_some_of_type(self.user, action_type="activity"),
"User should have completed an activity")
quests = get_quests(self.user)
self.assertTrue(self.quest in quests["available_quests"],
"User should be able to participate in this quest.")
self.quest.unlock_conditions = "approved_some_of_type(action_type='activity')"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(self.quest in quests["available_quests"],
"User should be able to participate in this quest.")
# Test as a completion condition.
self.quest.accept(self.user)
self.quest.completion_conditions = "not approved_action(action_slug='test-activity')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest not in completed_quests,
"User should not be able to complete the quest.")
self.quest.completion_conditions = "not approved_some_of_type(action_type='activity')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest not in completed_quests,
"User should not be able to complete the quest.")
self.quest.completion_conditions = "approved_action(action_slug='test-activity')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest in completed_quests,
"User should have completed the quest.")
def testNumTasksCompleted(self):
"""Test that completing an activity works with approved_some_of and has_action."""
# put the grid together. First the ColumnName
level = Level(name="Test level", slug="test-level")
level.save()
column = ColumnName(name="Test column", slug="test-column")
column.save()
c_grid = ColumnGrid(level=level, column=1, name=column)
c_grid.save()
# Then the activity
activity = Activity(
type="activity",
name="Test",
slug="test",
title="Test activity",
description="Variable points!",
expected_duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
)
activity.save()
grid = Grid(level=level, column=1, row=1, action=activity)
grid.save()
# Test activities
member = ActionMember(user=self.user, action=activity, approval_status="pending")
member.save()
self.assertFalse(approved_some_of(self.user, 1, category_slug=column.slug),
"User with pending activity should not have completed a task.")
self.assertFalse(approved_some_of(self.user, 1),
"User with pending activity should not have completed a task.")
# Test within context of a quest
self.quest.unlock_conditions = "approved_some_of(1, category_slug='test-column')"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(self.quest not in quests,
"User should not be able to participate in this quest.")
self.quest.unlock_conditions = "approved_some_of(1)"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(self.quest not in quests,
"User should not be able to participate in this quest.")
# Check that the user can now add the quest.
member.approval_status = "approved"
member.save()
quests = get_quests(self.user)
self.assertTrue(self.quest in quests["available_quests"],
"User should be able to participate in this quest.")
self.quest.unlock_conditions = "approved_some_of(1, category_slug='test-column')"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(self.quest in quests["available_quests"],
"User should not be able to participate in this quest.")
# Test as a completion condition.
self.quest.accept(self.user)
self.quest.completion_conditions = "approved_some_of(2, category_slug='test-column')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest not in completed_quests,
"User should not be able to complete the quest.")
self.quest.completion_conditions = "approved_some_of(2)"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest not in completed_quests,
"User should not be able to complete the quest.")
self.quest.completion_conditions = "approved_some_of(1, category_slug='test-column')"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest in completed_quests, "User should have completed the quest.")
def testNumTasksCompleted(self):
"""Test that completing an activity works with approved_some_of and has_action."""
# put the grid together. First the ColumnName
level = Level(name="Test level", slug="test-level")
level.save()
column = ColumnName(name="Test column", slug="test-column")
column.save()
c_grid = ColumnGrid(level=level, column=1, name=column)
c_grid.save()
# Then the activity
activity = Activity(
type="activity",
name="Test",
slug="test",
title="Test activity",
description="Variable points!",
expected_duration=10,
point_value=10,
pub_date=datetime.datetime.today(),
expire_date=datetime.datetime.today() + datetime.timedelta(days=7),
confirm_type="text",
)
activity.save()
grid = Grid(level=level, column=1, row=1, action=activity)
grid.save()
# Test activities
member = ActionMember(user=self.user,
action=activity,
approval_status="pending")
member.save()
self.assertFalse(
approved_some_of_type(self.user, action_type='activity', count=1),
"User with pending activity should not have completed a task.")
self.assertFalse(
approved_some(self.user, count=1),
"User with pending activity should not have completed a task.")
# Test within context of a quest
self.quest.unlock_conditions = "approved_some_of_type(action_type='activity', count=1)"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(
self.quest not in quests,
"User should not be able to participate in this quest.")
self.quest.unlock_conditions = "approved_some(count=1)"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(
self.quest not in quests,
"User should not be able to participate in this quest.")
# Check that the user can now add the quest.
member.approval_status = "approved"
member.save()
quests = get_quests(self.user)
self.assertTrue(self.quest in quests["available_quests"],
"User should be able to participate in this quest.")
self.quest.unlock_conditions = "approved_some_of_type(action_type='activity', count=1)"
self.quest.save()
quests = get_quests(self.user)
self.assertTrue(
self.quest in quests["available_quests"],
"User should not be able to participate in this quest.")
# Test as a completion condition.
self.quest.accept(self.user)
self.quest.completion_conditions = "approved_some_of_type(action_type='activity', count=2)"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest not in completed_quests,
"User should not be able to complete the quest.")
self.quest.completion_conditions = "approved_some(count=2)"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest not in completed_quests,
"User should not be able to complete the quest.")
self.quest.completion_conditions = "approved_some_of_type(action_type='activity', count=1)"
self.quest.save()
completed_quests = possibly_completed_quests(self.user)
self.assertTrue(self.quest in completed_quests,
"User should have completed the quest.")
