def test_post_challenge(self):
        # create an active challenge, with fake questions
        Formula.add('chall-warranty')
        Formula.add('chall-timer')
        category = Category.add('challenge')
        for i in range(Challenge.LIMIT + 1):
            q = Question.objects.create(text='text %s' % i, category=category, active=True)
            for j in range(5):
                Answer.objects.create(correct=j==1, question=q)
        chall = Challenge.create(user_from=self.challuser2, user_to=self.challuser)
        chall.accept()
        response = self.client.get('/api/challenge/{id}/'.format(id=chall.id))
        data = json.loads(response.content)

        self.assertTrue(data)
        self.assertEqual(data['status'], 'A')
        self.assertEqual(data['to'], self.challuser.user.username)
        self.assertEqual(len(data['questions']), Challenge.LIMIT)

        # attempt post
        data = {}
        for q in Question.objects.all():
            answers = []
            for a in q.correct_answers:
                answers.append(str(a.id))

            data[q.id] = ','.join(answers)

        response = self.client.post('/api/challenge/{id}/'.format(id=chall.id), data)
        self.assertEqual(response.status_code, 200)

        data = json.loads(response.content)

        self.assertTrue(data['success'])
        self.assertEqual(data['result']['points'], Challenge.LIMIT * 100)

    def test_frenzy_loss(self):
        """
         If user loses while affected by frenzy he should lose frenzy.percents more points
        """
        initial_points = 100
        loss_points = -10
        warranty_points = -3

        player_frenzy = self._get_player(1).get_extension(ChallengeUser)
        player_dummy = self._get_player(2).get_extension(ChallengeUser)

        scoring.setup_scoring()
        Coin.add('points')
        scoring.score_simple(player_frenzy, 'points', initial_points)

        formula = Formula.get('chall-lost')
        formula.expression = 'points=' + str(loss_points)
        formula.save()

        formula = Formula.get('chall-warranty')
        formula.expression = 'points=' + str(warranty_points)
        formula.save()

        # Apply frenzy
        frenzy = Spell.objects.create(name='challenge-affect-scoring', available=True, price=25, percents=66, type='o')
        obs = PlayerSpellDue.objects.create(player=player_frenzy, source=player_frenzy, spell=frenzy, due=datetime.now() + timedelta(days=1))

        # Win challenge with dummy player to see the amount of points lost by the player affected with frenzy
        chall = Challenge.create(user_from=player_frenzy, user_to=player_dummy, ignore_questions=True)
        chall.set_won_by_player(player_dummy)

        # Player should lose frenzy.percents more points with frenzy applied
        target_points = initial_points + loss_points + frenzy.percents / 100.0 * loss_points + warranty_points

        self.assertEqual(player_frenzy.player_ptr.points, target_points)

    def test_get_challenge(self):
        # create an active challenge
        Formula.add('chall-warranty')
        Formula.add('chall-timer')
        chall = Challenge.create(user_from=self.challuser2, user_to=self.challuser, ignore_questions=True)
        chall.accept()
        response = self.client.get('/api/challenge/{id}/'.format(id=chall.id))
        data = json.loads(response.content)

        self.assertTrue(data)
        self.assertEqual(data['status'], 'A')
        self.assertEqual(data['to'], self.challuser.user.username)

    def test_charge(self):
        """
         Test for Charge spell
        """
        initial_points = 100
        win_points = 10

        player_charge = self._get_player(1).get_extension(ChallengeUser)
        player_dummy = self._get_player(2).get_extension(ChallengeUser)

        scoring.setup_scoring()
        Coin.add('points')
        scoring.score_simple(player_charge, 'points', initial_points)

        formula = Formula.get('chall-won')
        formula.expression = 'points=' + str(win_points)
        formula.save()

        # Apply charge
        charge = Spell.objects.create(name='challenge-affect-scoring-won', available=True, price=10, percents=33, type='p')
        obs = PlayerSpellDue.objects.create(player=player_charge, source=player_charge, spell=charge, due=datetime.now() + timedelta(days=1))

        chall = Challenge.create(user_from=player_charge, user_to=player_dummy, ignore_questions=True)
        chall.set_won_by_player(player_charge)

        # Player should win weakness.percents more points with charge applied
        target_points = initial_points + win_points + charge.percents / 100.0 * win_points
        self.assertEqual(player_charge.player_ptr.points, target_points)

    def test_weakness_and_charge(self):
        """
         If both Weakness and Charge are active, a player should win weakness.percents + charge.percents less/more points
         after winning a challenge
        """
        initial_points = 100
        win_points = 10

        player = self._get_player(1).get_extension(ChallengeUser)
        player_dummy = self._get_player(2).get_extension(ChallengeUser)

        scoring.setup_scoring()
        Coin.add('points')
        scoring.score_simple(player, 'points', initial_points)

        formula = Formula.get('chall-won')
        formula.expression = 'points=' + str(win_points)
        formula.save()

        # Apply charge
        charge = Spell.objects.create(name='challenge-affect-scoring-won', available=True, price=10, percents=33, type='p')
        obs = PlayerSpellDue.objects.create(player=player, source=player, spell=charge, due=datetime.now() + timedelta(days=1))

        # Apply weakness
        weakness = Spell.objects.create(name='challenge-affect-scoring-won', available=True, price=10, percents=-66, type='p')
        obs = PlayerSpellDue.objects.create(player=player, source=player, spell=weakness, due=datetime.now() + timedelta(days=1))

        chall = Challenge.create(user_from=player, user_to=player_dummy, ignore_questions=True)
        chall.set_won_by_player(player)

        percents = (charge.percents + weakness.percents) / 100.0
        target_points = initial_points + win_points + percents * win_points

        self.assertEqual(player.player_ptr.points, target_points)

def karma_group_view(request, group):
    group_id = group
    group = get_object_or_404(PlayerGroup, pk=group)
    players = group.players.all()
    if request.method == 'POST':
        form = KarmaBonusForm(request.POST, players=players)
        if form.is_valid():
            formula = Formula.get('bonus-karma')
            if formula is None:
                messages.error(request, 'No such formula, bonus-karma')
            else:
                for player, entry in zip(players, form.fields):
                    # get amount of karma points for current player
                    karma_points = form.cleaned_data[entry]
                    # if karma points are zero then skip
                    if karma_points == 0:
                        continue
                    # compute formula and calculate amount of bonus given
                    amount = eval(formula.expression.format(**{'karma_points': karma_points}).split('=')[1])
                    # apply scoring
                    scoring.score(player, None, formula, external_id=request.user.get_profile().id, **{'karma_points': karma_points})
                    # add activity (parse formula expression to get the coin from formula)
                    add_activity(player, _(
                        'received {amount} {coin} bonus for {karma_points} Karma Points'),
                                amount=amount, coin=formula.expression.split('=')[0], karma_points=karma_points,
                                reason='Bonus for Karma')
                    messages.info(request, 'Successfully given bonus')
            return redirect('karma_group', **{'group': group_id})
    else:
        form = KarmaBonusForm(players=players)
    return render_to_response('cpanel/karma_group.html',
                              {'form':form, 'group':group},
                              context_instance=RequestContext(request))

def score_simple(player, coin, amount, game=None, formula=None,
    external_id=None, percents=100):
    """ Give amount of coin to the player.
    """
    if not isinstance(game, Game) and game is not None:
        game = game.get_instance()

    if not isinstance(player, Player):
        raise InvalidScoreCall()

    user = player.user
    player = user.get_profile()
    user = player.user

    coin = Coin.get(coin)
    formula = Formula.get(formula)

    computed_amount = 1.0 * amount * percents / 100
    hs = History.add(user=user, coin=coin, amount=computed_amount,
            game=game, formula=formula, external_id=external_id, percents=percents)

    # update user.points asap
    if coin.name == 'points':
        if player.magic.has_modifier('top-disguise'):
            computed_amount = 1.0 * computed_amount * player.magic.modifier_percents('top-disguise') / 100

        player.points += computed_amount
        player.save()
        update_points(player, game)

    logging.debug("Scored %s with %f %s" % (user, computed_amount, coin))
    return hs

def bonus(request, player_id):
    player = get_object_or_404(Player, pk=player_id)

    if request.method == 'POST':
        form = BonusForm(request.POST)
        if form.is_valid():
            coin, amount = form.cleaned_data['coin'], form.cleaned_data['amount']
            formula = Formula.get('bonus-%s' % coin.name)
            if formula is None:
                messages.error(request, 'No such formula, bonus-%s' % coin.name)
            else:
                scoring.score(player, None, formula, external_id=request.user.get_profile().id, **{coin.name: amount})
                if form.cleaned_data['reason']:
                    add_activity(player, _('received {amount} {coin} bonus for {reason}'), amount=amount, coin=coin, reason=form.cleaned_data['reason'])
                messages.info(request, 'Successfully given bonus')
            return redirect('player_profile', id=player.id)
    else:
        form = BonusForm()

    bonuses = scoring.History.objects.filter(user=player, formula__name__startswith='bonus-').order_by('-timestamp')
    penalties = scoring.History.objects.filter(user=player, formula__name__startswith='penalty-').order_by('-timestamp')

    return render_to_response('cpanel/bonus.html', {'target_player': player, 'form': form, 'bonuses': bonuses, 'penalties': penalties},
        context_instance=RequestContext(request)
    )

def calculate(formula, **params):
    """ Calculate formula and return a dictionary of coin and amounts """
    formula = Formula.get(formula)
    if formula is None:
        raise InvalidFormula(formula)

    if not formula.formula:
        return {}

    ret = {}
    try:
        frml = formula.formula.format(**params)
        # Apparently, Python does not allow assignments inside eval
        # Using this workaround for now
        ass = frml.split(";")
        for a in ass:
            asp = a.split("=")
            coin = asp[0].strip()
            expr = "=".join(asp[1:])
            try:
                result = eval(expr)
            except ZeroDivisionError as e:
                result = 0
            ret[coin] = result
    except Exception as e:
        logging.exception(e)
        raise FormulaParsingError(formula)

    return ret

def score_simple(player, coin, amount, game=None, formula=None,
    external_id=None, percents=100):
    """ Give amount of coin to the player.
    """
    if not isinstance(game, Game) and game is not None:
        game = game.get_instance()

    if not isinstance(player, Player):
        raise InvalidScoreCall()

    user = player.user

    coin = Coin.get(coin)
    formula = Formula.get(formula)

    computed_amount = 1.0 * amount * percents / 100
    hs = History.objects.create(user=user, coin=coin, amount=computed_amount,
        game=game, formula=formula, external_id=external_id, percents=percents)

    # update user.points asap
    if coin.id == 'points':
        player.points += computed_amount
        player.save()
        update_points(player, game)

    logging.debug("Scored %s with %f %s" % (user, computed_amount, coin))
    return hs

    def test_list_active(self):
        response = self.client.get('/api/challenge/list/')

        self.assertEqual(response.status_code, 200)

        data = json.loads(response.content)
        self.assertFalse(data)

        # create an active challenge
        Formula.add('chall-warranty')
        chall = Challenge.create(user_from=self.challuser2, user_to=self.challuser, ignore_questions=True)
        response = self.client.get('/api/challenge/list/')
        data = json.loads(response.content)

        self.assertTrue(data)
        data = data[0]
        self.assertEqual(data['id'], chall.id)

def unset(user, game, formula, external_id=None, **params):
    """ Remove all history records by the external_id, formula and game given to the user """
    formula = Formula.get(formula)
    for history in History.objects.filter(user=user, game=game.get_instance(), formula=formula, external_id=external_id):
        if history.coin.name == 'points':
            user.points -= history.amount
        history.delete()
    user.save()
    update_points(user, game)

    def test_buy_spell(self):
         Coin.add('gold')
         Formula.add('buy-spell', expression="gold=-{price}")
         spell = Spell.objects.create(name='test-spell', available=True, price=10)
         player = User.objects.create_user('test', '[email protected]', password='test').get_profile()

         scoring.score_simple(player, 'gold', 100)
         self.assertEqual(player.coins['gold'], 100)

         response = self.client.get(reverse('bazaar_home'))
         self.assertTrue('test-spell' in response.content)

         self.client.login(username='test', password='test')
         response = self.client.get(reverse('bazaar_buy', kwargs={'spell': spell.id}))
         self.assertFalse('error' in response.content)

         player = Player.objects.get(user__username='test')
         self.assertEqual(player.coins['gold'], 90)

def rollback(user, game, formula, external_id=None, **params):
    if game != None:
        game = game.get_instance()
    formula = Formula.get(formula)
    for history in History.objects.filter(user=user, game=game, formula=formula, external_id=external_id):
        if history.coin.name == 'points':
            user.points -= history.amount
        history.delete()
    user.save()

    def test_buy_spell(self):
        Coin.add("gold")
        Formula.add("buy-spell", definition="gold=-{price}")
        spell = Spell.objects.create(name="test-spell", available=True, price=10)
        player = User.objects.create_user("test", "[email protected]", password="test").get_profile()

        scoring.score_simple(player, "gold", 100)
        self.assertEqual(player.coins["gold"], 100)

        # TODO: interface test should not be here
        response = self.client.get(reverse("bazaar_home"))
        self.assertTrue("test-spell" in response.content)

        self.client.login(username="test", password="test")
        response = self.client.get(reverse("bazaar_buy", kwargs={"spell": spell.id}))
        self.assertFalse("error" in response.content)

        player = Player.objects.get(user__username="test")
        self.assertEqual(player.coins["gold"], 90)

def calculate(formula, **params):
    """ Calculate formula and return a dictionary of coin and amounts """
    formula = Formula.get(formula)
    if formula is None:
        raise InvalidFormula(formula)

    if not formula.expression:
        return {}

    return calculate_expression(formula.expression, formula, **params)

def rollback(user, game, formula, external_id=None, **params):
    if game is not None:
        game = game.get_instance()
    formula = Formula.get(formula)
    user = user.user.get_profile() # make sure you are working on fresh Player
    for history in History.objects.filter(user=user, game=game, formula=formula, external_id=external_id):
        if history.coin.name == 'points':
            user.points -= history.amount
        history.delete()
    user.save()

 def activity_handler(cls, sender, **kwargs):
     action = kwargs.get('action', None)
     rules = filter(lambda x : x[2]==action, cls.SECURITY_RULES)
     for rule in rules:
         # check if rule is not disabled
         if not BoolSetting.objects.get(pk__startswith='disable-%s' % rule[0]).get_value():
             (guilty, player, external_id) = SecurityInspector.check(rule[0], **kwargs)
             if guilty:
                 formula = Formula.get('%s-infraction' % rule[0], 'general-infraction')
                 cls.penalise(player, formula, external_id)

    def test_variable_timer(self):
        formula = Formula.add('chall-timer')
        formula.expression = 'tlimit=10'
        formula.save()

        self.assertEqual(scoring.timer(self.chall_user, ChallengeGame, 'chall-timer', level=self.chall_user.level_no), 10)

        formula.expression = 'tlimit={level}'
        formula.save()

        self.assertEqual(scoring.timer(self.chall_user, ChallengeGame, 'chall-timer', level=self.chall_user.level_no), self.chall_user.level_no)

    def test_paralyze(self):
        """
         Test if Paralyze spell works
        """
        Formula.add('chall-warranty')

        player = self._get_player()
        chall_user = player.get_extension(ChallengeUser)

        # Check if player can launch before spell is cast
        self.assertTrue(chall_user.can_launch())

        # Create and add spell to user
        paralyze = Spell.objects.create(name='challenge-cannot-challenge', available=True, price=10, percents=100, type='n')
        obs = PlayerSpellDue.objects.create(player=chall_user, source=chall_user, spell=paralyze, due=datetime.now() + timedelta(days=1))

        # Check if player has the modifier
        self.assertTrue(chall_user.magic.has_modifier('challenge-cannot-challenge'))

        # Player should not be able to launch challenge with Paralyze on
        self.assertFalse(chall_user.can_launch())