~widelands-dev/widelands-website/django_staticfiles

« back to all changes in this revision

Viewing changes to djangoratings/views.py

  • Committer: franku
  • Date: 2018-11-21 17:54:32 UTC
  • mfrom: (508.1.1 widelands)
  • Revision ID: somal@arcor.de-20181121175432-8rc3h0332xmgmma4
merged trunk, resolved conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
from django.contrib.contenttypes.models import ContentType
2
 
from django.core.exceptions import ObjectDoesNotExist
3
 
from django.http import HttpResponse, Http404
4
 
 
5
 
from exceptions import *
6
 
from django.conf import settings
7
 
from default_settings import RATINGS_VOTES_PER_IP
8
 
from wl_utils import get_real_ip
9
 
 
10
 
 
11
 
class AddRatingView(object):
12
 
 
13
 
    def __call__(self, request, content_type_id, object_id, field_name, score):
14
 
        """__call__(request, content_type_id, object_id, field_name, score)
15
 
 
16
 
        Adds a vote to the specified model field.
17
 
 
18
 
        """
19
 
 
20
 
        try:
21
 
            instance = self.get_instance(content_type_id, object_id)
22
 
        except ObjectDoesNotExist:
23
 
            raise Http404('Object does not exist')
24
 
 
25
 
        context = self.get_context(request)
26
 
        context['instance'] = instance
27
 
 
28
 
        try:
29
 
            field = getattr(instance, field_name)
30
 
        except AttributeError:
31
 
            return self.invalid_field_response(request, context)
32
 
 
33
 
        context.update({
34
 
            'field': field,
35
 
            'score': score,
36
 
        })
37
 
 
38
 
        had_voted = bool(field.get_rating_for_user(
39
 
            request.user, get_real_ip(request), request.COOKIES))
40
 
 
41
 
        context['had_voted'] = had_voted
42
 
 
43
 
        try:
44
 
            adds = field.add(score, request.user,
45
 
                             get_real_ip(request), request.COOKIES)
46
 
        except IPLimitReached:
47
 
            return self.too_many_votes_from_ip_response(request, context)
48
 
        except AuthRequired:
49
 
            return self.authentication_required_response(request, context)
50
 
        except InvalidRating:
51
 
            return self.invalid_rating_response(request, context)
52
 
        except CannotChangeVote:
53
 
            return self.cannot_change_vote_response(request, context)
54
 
        except CannotDeleteVote:
55
 
            return self.cannot_delete_vote_response(request, context)
56
 
        if had_voted:
57
 
            return self.rating_changed_response(request, context, adds)
58
 
        return self.rating_added_response(request, context, adds)
59
 
 
60
 
    def get_context(self, request, context={}):
61
 
        return context
62
 
 
63
 
    def render_to_response(self, template, context, request):
64
 
        raise NotImplementedError
65
 
 
66
 
    def too_many_votes_from_ip_response(self, request, context):
67
 
        response = HttpResponse(
68
 
            'Too many votes from this IP address for this object.')
69
 
        return response
70
 
 
71
 
    def rating_changed_response(self, request, context, adds={}):
72
 
        response = HttpResponse('Vote changed.')
73
 
        if 'cookie' in adds:
74
 
            cookie_name, cookie = adds['cookie_name'], adds['cookie']
75
 
            if 'deleted' in adds:
76
 
                response.delete_cookie(cookie_name)
77
 
            else:
78
 
                # TODO: move cookie max_age to settings
79
 
                response.set_cookie(cookie_name, cookie, 31536000, path='/')
80
 
        return response
81
 
 
82
 
    def rating_added_response(self, request, context, adds={}):
83
 
        response = HttpResponse('Vote recorded.')
84
 
        if 'cookie' in adds:
85
 
            cookie_name, cookie = adds['cookie_name'], adds['cookie']
86
 
            if 'deleted' in adds:
87
 
                response.delete_cookie(cookie_name)
88
 
            else:
89
 
                # TODO: move cookie max_age to settings
90
 
                response.set_cookie(cookie_name, cookie, 31536000, path='/')
91
 
        return response
92
 
 
93
 
    def authentication_required_response(self, request, context):
94
 
        response = HttpResponse('You must be logged in to vote.')
95
 
        response.status_code = 403
96
 
        return response
97
 
 
98
 
    def cannot_change_vote_response(self, request, context):
99
 
        response = HttpResponse('You have already voted.')
100
 
        response.status_code = 403
101
 
        return response
102
 
 
103
 
    def cannot_delete_vote_response(self, request, context):
104
 
        response = HttpResponse('You can\'t delete this vote.')
105
 
        response.status_code = 403
106
 
        return response
107
 
 
108
 
    def invalid_field_response(self, request, context):
109
 
        response = HttpResponse('Invalid field name.')
110
 
        response.status_code = 403
111
 
        return response
112
 
 
113
 
    def invalid_rating_response(self, request, context):
114
 
        response = HttpResponse('Invalid rating value.')
115
 
        response.status_code = 403
116
 
        return response
117
 
 
118
 
    def get_instance(self, content_type_id, object_id):
119
 
        return ContentType.objects.get(pk=content_type_id)\
120
 
            .get_object_for_this_type(pk=object_id)
121
 
 
122
 
 
123
 
class AddRatingFromModel(AddRatingView):
124
 
 
125
 
    def __call__(self, request, model, app_label, object_id, field_name, score):
126
 
        """__call__(request, model, app_label, object_id, field_name, score)
127
 
 
128
 
        Adds a vote to the specified model field.
129
 
 
130
 
        """
131
 
        try:
132
 
            content_type = ContentType.objects.get(
133
 
                model=model, app_label=app_label)
134
 
        except ContentType.DoesNotExist:
135
 
            raise Http404('Invalid `model` or `app_label`.')
136
 
 
137
 
        return super(AddRatingFromModel, self).__call__(request, content_type.id,
138
 
                                                        object_id, field_name, score)