This repository has been archived by the owner on Jul 17, 2018. It is now read-only.
/
__init__.py
275 lines (215 loc) · 9.02 KB
/
__init__.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
from django.db.models import IntegerField, PositiveIntegerField
from django.conf import settings
import forms
import itertools
from models import Vote, Score
if 'django.contrib.contenttypes' not in settings.INSTALLED_APPS:
raise ImportError("djangoratings requires django.contrib.contenttypes in your INSTALLED_APPS")
from django.contrib.contenttypes.models import ContentType
__all__ = ('Rating', 'RatingField', 'AnonymousRatingField')
try:
from hashlib import md5
except ImportError:
from md5 import new as md5
def md5_hexdigest(value):
return md5(value).hexdigest()
class Rating(object):
def __init__(self, score, votes):
self.score = score
self.votes = votes
class RatingManager(object):
def __init__(self, instance, field):
self.content_type = None
self.instance = instance
self.field = field
self.votes_field_name = "%s_votes" % (self.field.name,)
self.score_field_name = "%s_score" % (self.field.name,)
def get_percent(self):
"""get_percent()
Returns the weighted percentage of the score from min-max values"""
if not (self.votes and self.score):
return 0
return 100/self.field.range*self.get_rating()
def get_real_percent(self):
"""get_real_percent()
Returns the unmodified percentage of the score based on a 0-point scale."""
if not (self.votes and self.score):
return 0
return 100/self.field.range*self.get_real_rating()
def get_ratings(self):
"""get_ratings()
Returns a Vote QuerySet for this rating field."""
return Vote.objects.filter(content_type=self.get_content_type(), object_id=self.instance.id, key=self.field.key)
def get_rating(self):
"""get_rating()
Returns the weighted average rating."""
if not (self.votes and self.score):
return 0
return float(self.score)/(self.votes+self.field.weight)
def get_opinion_percent(self):
"""get_opinion_percent()
Returns a neutral-based percentage."""
return (self.get_percent()+100)/2
def get_real_rating(self):
"""get_rating()
Returns the unmodified average rating."""
if not (self.votes and self.score):
return 0
return float(self.score)/self.votes
def get_rating_for_user(self, user, ip_address):
"""get_rating_for_user(user, ip_address)
Returns the rating for a user or anonymous IP."""
kwargs = dict(
content_type = self.get_content_type(),
object_id = self.instance.id,
key = self.field.key,
)
if user and not user.is_authenticated():
kwargs['user__isnull'] = True
kwargs['ip_address'] = ip_address
else:
kwargs['user'] = user
try:
rating = Vote.objects.get(**kwargs)
return rating.score
except Vote.DoesNotExist:
pass
return
def add(self, score, user, ip_address):
"""add(score, user, ip_address)
Used to add a rating to an object."""
if score < 1 or score > self.field.range:
raise ValueError("%s is not a valid choice for %s" % (score, self.field.name))
is_anonymous = (user is None or not user.is_authenticated())
if is_anonymous and not self.field.allow_anonymous:
raise TypeError("user must be a user, not '%r'" % (user,))
if is_anonymous:
user = None
defaults = dict(
score = score,
ip_address = ip_address,
)
kwargs = dict(
content_type = self.get_content_type(),
object_id = self.instance.id,
key = self.field.key,
user = user,
)
if not user:
kwargs['ip_address'] = ip_address
try:
rating, created = Vote.objects.get(**kwargs), False
except Vote.DoesNotExist:
kwargs.update(defaults)
rating, created = Vote.objects.create(**kwargs), True
has_changed = False
if not created:
if self.field.can_change_vote:
has_changed = True
self.score -= rating.score
rating.score = score
rating.save()
else:
return
else:
has_changed = True
self.votes += 1
if has_changed:
self.score += rating.score
self.instance.save()
#setattr(self.instance, self.field.name, Rating(score=self.score, votes=self.votes))
defaults = dict(
score = self.score,
votes = self.votes,
)
kwargs = dict(
content_type = self.get_content_type(),
object_id = self.instance.id,
key = self.field.key,
)
try:
score, created = Score.objects.get(**kwargs), False
except Score.DoesNotExist:
kwargs.update(defaults)
score, created = Score.objects.create(**kwargs), True
if not created:
score.__dict__.update(defaults)
score.save()
def _get_votes(self, default=None):
return getattr(self.instance, self.votes_field_name, default)
def _set_votes(self, value):
return setattr(self.instance, self.votes_field_name, value)
votes = property(_get_votes, _set_votes)
def _get_score(self, default=None):
return getattr(self.instance, self.score_field_name, default)
def _set_score(self, value):
return setattr(self.instance, self.score_field_name, value)
score = property(_get_score, _set_score)
def get_content_type(self):
if self.content_type is None:
self.content_type = ContentType.objects.get_for_model(self.instance,)
return self.content_type
class RatingCreator(object):
def __init__(self, field):
self.field = field
self.votes_field_name = "%s_votes" % (self.field.name,)
self.score_field_name = "%s_score" % (self.field.name,)
# we need a unique key incase there are multiple ratings on a model
self._rating_manager = None
def __get__(self, instance, type=None):
if instance is None:
return self.field
#raise AttributeError('Can only be accessed via an instance.')
return RatingManager(instance, self.field)
def __set__(self, instance, value):
if isinstance(value, Rating):
setattr(instance, self.votes_field_name, value.votes)
setattr(instance, self.score_field_name, value.score)
else:
raise TypeError("%s value must be a Rating instance, not '%r'" % (self.field.name, value))
class RatingField(IntegerField):
"""
A rating field contributes two columns to the model instead of the standard single column.
"""
def __init__(self, *args, **kwargs):
if 'choices' in kwargs:
raise TypeError("%s invalid attribute 'choices'" % (self.__class__.__name__,))
self.can_change_vote = kwargs.pop('can_change_vote', False)
self.weight = kwargs.pop('weight', 0)
self.range = kwargs.pop('range', 2)
self.allow_anonymous = kwargs.pop('allow_anonymous', False)
kwargs['editable'] = False
kwargs['default'] = 0
kwargs['blank'] = True
super(RatingField, self).__init__(*args, **kwargs)
def contribute_to_class(self, cls, name):
self.name = name
# Votes tally field
votes_field = PositiveIntegerField(
editable=False, default=0, blank=True)
cls.add_to_class("%s_votes" % (self.name,), votes_field)
# Score sum field
score_field = IntegerField(
editable=False, default=0, blank=True)
cls.add_to_class("%s_score" % (self.name,), score_field)
self.key = md5_hexdigest(self.name)
setattr(cls, name, RatingCreator(self))
def get_db_prep_save(self, value):
# XXX: what happens here?
pass
def get_db_prep_lookup(self, lookup_type, value):
# TODO: hack in support for __score and __votes
raise NotImplementedError(self.get_db_prep_lookup)
if lookup_type == 'exact':
return [self.get_db_prep_save(value)]
elif lookup_type == 'in':
return [self.get_db_prep_save(v) for v in value]
else:
return super(RatingField, self).get_db_prep_lookup(lookup_type, value)
def formfield(self, **kwargs):
defaults = {'form_class': forms.RatingField}
defaults.update(kwargs)
return super(RatingField, self).formfield(**defaults)
# TODO: flatten_data method
class AnonymousRatingField(RatingField):
allow_anonymous = True