mirrors/django
1
0
Fork 0
mirror of https://github.com/django/django.git synced 2025-08-24 10:49:12 +00:00
Code Issues 32 Releases Wiki Activity

magic-removal: Converted a bunch of stuff to use the new model import syntax

Browse Source 
git-svn-id: http://code.djangoproject.com/svn/django/branches/magic-removal@1664 bcc190cf-cafb-0310-a4f2-bffc1f526a37
This commit is contained in:
Adrian Holovaty 2005-12-15 00:53:34 +00:00
parent 9701daeb72
commit 036611724e
10 changed files with 166 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
django/contrib/admin/views/doc.py
View File

@ -6,7 +6,7 @@ from django.core.extensions import DjangoContext, render_to_response
from django.core.exceptions import Http404, ViewDoesNotExist from django.core.exceptions import Http404, ViewDoesNotExist
from django.core import template, urlresolvers from django.core import template, urlresolvers
from django.contrib.admin import utils from django.contrib.admin import utils
from django.models.core import sites from django.models.core import Site
import inspect, os, re import inspect, os, re
# Exclude methods starting with these strings from documentation # Exclude methods starting with these strings from documentation
@ -101,7 +101,7 @@ def view_index(request):
'name': func.__name__, 'name': func.__name__,
'module': func.__module__, 'module': func.__module__,
'site_id': settings_mod.SITE_ID, 'site_id': settings_mod.SITE_ID,
'site': sites.get_object(pk=settings_mod.SITE_ID), 'site': Site.objects.get_object(pk=settings_mod.SITE_ID),
'url': simplify_regex(regex), 'url': simplify_regex(regex),
}) })
return render_to_response('admin_doc/view_index', {'views': views}, context_instance=DjangoContext(request)) return render_to_response('admin_doc/view_index', {'views': views}, context_instance=DjangoContext(request))
@ -200,7 +200,7 @@ def template_detail(request, template):
'exists': os.path.exists(template_file), 'exists': os.path.exists(template_file),
'contents': lambda: os.path.exists(template_file) and open(template_file).read() or '', 'contents': lambda: os.path.exists(template_file) and open(template_file).read() or '',
'site_id': settings_mod.SITE_ID, 'site_id': settings_mod.SITE_ID,
'site': sites.get_object(pk=settings_mod.SITE_ID), 'site': Site.objects.get_object(pk=settings_mod.SITE_ID),
'order': list(settings_mod.TEMPLATE_DIRS).index(dir), 'order': list(settings_mod.TEMPLATE_DIRS).index(dir),
}) })
return render_to_response('admin_doc/template_detail', { return render_to_response('admin_doc/template_detail', {

6
django/contrib/auth/handlers/modpython.py
View File

@ -10,7 +10,7 @@ def authenhandler(req, **kwargs):
# that so that the following import works # that so that the following import works
os.environ.update(req.subprocess_env) os.environ.update(req.subprocess_env)
from django.models.auth import users from django.models.auth import User
# check for PythonOptions # check for PythonOptions
_str_to_bool = lambda s: s.lower() in '1', 'true', 'on', 'yes' _str_to_bool = lambda s: s.lower() in '1', 'true', 'on', 'yes'
@ -27,8 +27,8 @@ def authenhandler(req, **kwargs):
if superuser_only: if superuser_only:
kwargs['is_superuser__exact'] = True kwargs['is_superuser__exact'] = True
try: try:
user = users.get_object(**kwargs) user = User.objects.get_object(**kwargs)
except users.UserDoesNotExist: except User.DoesNotExist:
return apache.HTTP_UNAUTHORIZED return apache.HTTP_UNAUTHORIZED
# check the password and any permission given # check the password and any permission given

22
django/contrib/comments/feeds.py
View File

@ -1,43 +1,43 @@
from django.conf import settings from django.conf import settings
from django.contrib.comments.models import Comment, FreeComment
from django.contrib.syndication.feeds import Feed from django.contrib.syndication.feeds import Feed
from django.core.exceptions import ObjectDoesNotExist from django.core.exceptions import ObjectDoesNotExist
from django.models.core import sites from django.models.core import Site
from django.models.comments import comments, freecomments
class LatestFreeCommentsFeed(Feed): class LatestFreeCommentsFeed(Feed):
"""Feed of latest comments on the current site""" """Feed of latest comments on the current site"""
comments_module = freecomments comments_class = FreeComment
def title(self): def title(self):
if not hasattr(self, '_site'): if not hasattr(self, '_site'):
self._site = sites.get_current() self._site = Site.objects.get_current()
return "%s comments" % self._site.name return "%s comments" % self._site.name
def link(self): def link(self):
if not hasattr(self, '_site'): if not hasattr(self, '_site'):
self._site = sites.get_current() self._site = Site.objects.get_current()
return "http://%s/" % (self._site.domain) return "http://%s/" % (self._site.domain)
def description(self): def description(self):
if not hasattr(self, '_site'): if not hasattr(self, '_site'):
self._site = sites.get_current() self._site = Site.objects.get_current()
return "Latest comments on %s" % self._site.name return "Latest comments on %s" % self._site.name
def items(self): def items(self):
return self.comments_module.get_list(**self._get_lookup_kwargs()) return self.comments_class.objects.get_list(**self._get_lookup_kwargs())
def _get_lookup_kwargs(self): def _get_lookup_kwargs(self):
return { return {
'site__pk' : settings.SITE_ID, 'site__pk': settings.SITE_ID,
'is_public__exact' : True, 'is_public__exact': True,
'limit' : 40, 'limit': 40,
} }
class LatestCommentsFeed(LatestFreeCommentsFeed): class LatestCommentsFeed(LatestFreeCommentsFeed):
"""Feed of latest free comments on the current site""" """Feed of latest free comments on the current site"""
comments_module = comments comments_class = Comment
def _get_lookup_kwargs(self): def _get_lookup_kwargs(self):
kwargs = LatestFreeCommentsFeed._get_lookup_kwargs(self) kwargs = LatestFreeCommentsFeed._get_lookup_kwargs(self)

178
django/contrib/comments/models/comments.py
View File

@ -1,6 +1,63 @@
from django.db import models from django.db import models
from django.models import auth, core from django.models import auth, core
from django.utils.translation import gettext_lazy as _ from django.utils.translation import gettext_lazy as _
import datetime
MIN_PHOTO_DIMENSION = 5
MAX_PHOTO_DIMENSION = 1000
# option codes for comment-form hidden fields
PHOTOS_REQUIRED = 'pr'
PHOTOS_OPTIONAL = 'pa'
RATINGS_REQUIRED = 'rr'
RATINGS_OPTIONAL = 'ra'
IS_PUBLIC = 'ip'
# what users get if they don't have any karma
DEFAULT_KARMA = 5
KARMA_NEEDED_BEFORE_DISPLAYED = 3
class CommentManager(models.Manager):
def get_security_hash(self, options, photo_options, rating_options, target):
"""
Returns the MD5 hash of the given options (a comma-separated string such as
'pa,ra') and target (something like 'lcom.eventtimes:5157'). Used to
validate that submitted form options have not been tampered-with.
"""
from django.conf.settings import SECRET_KEY
import md5
return md5.new(options + photo_options + rating_options + target + SECRET_KEY).hexdigest()
def get_rating_options(self, rating_string):
"""
Given a rating_string, this returns a tuple of (rating_range, options).
>>> s = "scale:1-10|First_category|Second_category"
>>> get_rating_options(s)
([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ['First category', 'Second category'])
"""
rating_range, options = rating_string.split('|', 1)
rating_range = range(int(rating_range[6:].split('-')[0]), int(rating_range[6:].split('-')[1])+1)
choices = [c.replace('_', ' ') for c in options.split('|')]
return rating_range, choices
def get_list_with_karma(self, **kwargs):
"""
Returns a list of Comment objects matching the given lookup terms, with
_karma_total_good and _karma_total_bad filled.
"""
kwargs.setdefault('select', {})
kwargs['select']['_karma_total_good'] = 'SELECT COUNT(*) FROM comments_karma WHERE comments_karma.comment_id=comments.id AND score=1'
kwargs['select']['_karma_total_bad'] = 'SELECT COUNT(*) FROM comments_karma WHERE comments_karma.comment_id=comments.id AND score=-1'
return self.get_list(**kwargs)
def user_is_moderator(self, user):
from django.conf.settings import COMMENTS_MODERATORS_GROUP
if user.is_superuser:
return True
for g in user.get_group_list():
if g.id == COMMENTS_MODERATORS_GROUP:
return True
return False
class Comment(models.Model): class Comment(models.Model):
user = models.ForeignKey(auth.User, raw_id_admin=True) user = models.ForeignKey(auth.User, raw_id_admin=True)
@ -26,22 +83,11 @@ class Comment(models.Model):
ip_address = models.IPAddressField(_('IP address'), blank=True, null=True) ip_address = models.IPAddressField(_('IP address'), blank=True, null=True)
is_removed = models.BooleanField(_('is removed'), help_text=_('Check this box if the comment is inappropriate. A "This comment has been removed" message will be displayed instead.')) is_removed = models.BooleanField(_('is removed'), help_text=_('Check this box if the comment is inappropriate. A "This comment has been removed" message will be displayed instead.'))
site = models.ForeignKey(core.Site) site = models.ForeignKey(core.Site)
objects = CommentManager()
class META: class META:
db_table = 'comments' db_table = 'comments'
verbose_name = _('Comment') verbose_name = _('Comment')
verbose_name_plural = _('Comments') verbose_name_plural = _('Comments')
module_constants = {
# min. and max. allowed dimensions for photo resizing (in pixels)
'MIN_PHOTO_DIMENSION': 5,
'MAX_PHOTO_DIMENSION': 1000,
# option codes for comment-form hidden fields
'PHOTOS_REQUIRED': 'pr',
'PHOTOS_OPTIONAL': 'pa',
'RATINGS_REQUIRED': 'rr',
'RATINGS_OPTIONAL': 'ra',
'IS_PUBLIC': 'ip',
}
ordering = ('-submit_date',) ordering = ('-submit_date',)
admin = models.Admin( admin = models.Admin(
fields = ( fields = (
@ -114,47 +160,6 @@ class Comment(models.Model):
{'user': self.get_user().username, 'date': self.submit_date, {'user': self.get_user().username, 'date': self.submit_date,
'comment': self.comment, 'domain': self.get_site().domain, 'url': self.get_absolute_url()} 'comment': self.comment, 'domain': self.get_site().domain, 'url': self.get_absolute_url()}
def _module_get_security_hash(options, photo_options, rating_options, target):
"""
Returns the MD5 hash of the given options (a comma-separated string such as
'pa,ra') and target (something like 'lcom.eventtimes:5157'). Used to
validate that submitted form options have not been tampered-with.
"""
from django.conf.settings import SECRET_KEY
import md5
return md5.new(options + photo_options + rating_options + target + SECRET_KEY).hexdigest()
def _module_get_rating_options(rating_string):
"""
Given a rating_string, this returns a tuple of (rating_range, options).
>>> s = "scale:1-10|First_category|Second_category"
>>> get_rating_options(s)
([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ['First category', 'Second category'])
"""
rating_range, options = rating_string.split('|', 1)
rating_range = range(int(rating_range[6:].split('-')[0]), int(rating_range[6:].split('-')[1])+1)
choices = [c.replace('_', ' ') for c in options.split('|')]
return rating_range, choices
def _module_get_list_with_karma(**kwargs):
"""
Returns a list of Comment objects matching the given lookup terms, with
_karma_total_good and _karma_total_bad filled.
"""
kwargs.setdefault('select', {})
kwargs['select']['_karma_total_good'] = 'SELECT COUNT(*) FROM comments_karma WHERE comments_karma.comment_id=comments.id AND score=1'
kwargs['select']['_karma_total_bad'] = 'SELECT COUNT(*) FROM comments_karma WHERE comments_karma.comment_id=comments.id AND score=-1'
return get_list(**kwargs)
def _module_user_is_moderator(user):
from django.conf.settings import COMMENTS_MODERATORS_GROUP
if user.is_superuser:
return True
for g in user.get_group_list():
if g.id == COMMENTS_MODERATORS_GROUP:
return True
return False
class FreeComment(models.Model): class FreeComment(models.Model):
# A FreeComment is a comment by a non-registered user. # A FreeComment is a comment by a non-registered user.
content_type = models.ForeignKey(core.ContentType) content_type = models.ForeignKey(core.ContentType)
@ -203,37 +208,19 @@ class FreeComment(models.Model):
get_content_object.short_description = _('Content object') get_content_object.short_description = _('Content object')
class KarmaScore(models.Model): class KarmaScoreManager(models.Manager):
user = models.ForeignKey(auth.User) def vote(self, user_id, comment_id, score):
comment = models.ForeignKey(Comment)
score = models.SmallIntegerField(_('score'), db_index=True)
scored_date = models.DateTimeField(_('score date'), auto_now=True)
class META:
module_name = 'karma'
verbose_name = _('Karma score')
verbose_name_plural = _('Karma scores')
unique_together = (('user', 'comment'),)
module_constants = {
# what users get if they don't have any karma
'DEFAULT_KARMA': 5,
'KARMA_NEEDED_BEFORE_DISPLAYED': 3,
}
def __repr__(self):
return _("%(score)d rating by %(user)s") % {'score': self.score, 'user': self.get_user()}
def _module_vote(user_id, comment_id, score):
try: try:
karma = get_object(comment__id__exact=comment_id, user__id__exact=user_id) karma = self.get_object(comment__id__exact=comment_id, user__id__exact=user_id)
except KarmaScoreDoesNotExist: except self.klass.DoesNotExist:
karma = KarmaScore(None, user_id, comment_id, score, datetime.datetime.now()) karma = self.klass(None, user_id, comment_id, score, datetime.datetime.now())
karma.save() karma.save()
else: else:
karma.score = score karma.score = score
karma.scored_date = datetime.datetime.now() karma.scored_date = datetime.datetime.now()
karma.save() karma.save()
def _module_get_pretty_score(score): def get_pretty_score(self, score):
""" """
Given a score between -1 and 1 (inclusive), returns the same score on a Given a score between -1 and 1 (inclusive), returns the same score on a
scale between 1 and 10 (inclusive), as an integer. scale between 1 and 10 (inclusive), as an integer.
@ -242,20 +229,22 @@ class KarmaScore(models.Model):
return DEFAULT_KARMA return DEFAULT_KARMA
return int(round((4.5 * score) + 5.5)) return int(round((4.5 * score) + 5.5))
class UserFlag(models.Model): class KarmaScore(models.Model):
user = models.ForeignKey(auth.User) user = models.ForeignKey(auth.User)
comment = models.ForeignKey(Comment) comment = models.ForeignKey(Comment)
flag_date = models.DateTimeField(_('flag date'), auto_now_add=True) score = models.SmallIntegerField(_('score'), db_index=True)
scored_date = models.DateTimeField(_('score date'), auto_now=True)
objects = KarmaScoreManager()
class META: class META:
db_table = 'comments_user_flags' verbose_name = _('Karma score')
verbose_name = _('User flag') verbose_name_plural = _('Karma scores')
verbose_name_plural = _('User flags')
unique_together = (('user', 'comment'),) unique_together = (('user', 'comment'),)
def __repr__(self): def __repr__(self):
return _("Flag by %r") % self.get_user() return _("%(score)d rating by %(user)s") % {'score': self.score, 'user': self.get_user()}
def _module_flag(comment, user): class UserFlagManager(models.Manager):
def flag(self, comment, user):
""" """
Flags the given comment by the given user. If the comment has already Flags the given comment by the given user. If the comment has already
been flagged by the user, or it was a comment posted by the user, been flagged by the user, or it was a comment posted by the user,
@ -264,14 +253,28 @@ class UserFlag(models.Model):
if int(comment.user_id) == int(user.id): if int(comment.user_id) == int(user.id):
return # A user can't flag his own comment. Fail silently. return # A user can't flag his own comment. Fail silently.
try: try:
f = get_object(user__id__exact=user.id, comment__id__exact=comment.id) f = self.get_object(user__id__exact=user.id, comment__id__exact=comment.id)
except UserFlagDoesNotExist: except self.klass.DoesNotExist:
from django.core.mail import mail_managers from django.core.mail import mail_managers
f = UserFlag(None, user.id, comment.id, None) f = self.klass(None, user.id, comment.id, None)
message = _('This comment was flagged by %(user)s:\n\n%(text)s') % {'user': user.username, 'text': comment.get_as_text()} message = _('This comment was flagged by %(user)s:\n\n%(text)s') % {'user': user.username, 'text': comment.get_as_text()}
mail_managers('Comment flagged', message, fail_silently=True) mail_managers('Comment flagged', message, fail_silently=True)
f.save() f.save()
class UserFlag(models.Model):
user = models.ForeignKey(auth.User)
comment = models.ForeignKey(Comment)
flag_date = models.DateTimeField(_('flag date'), auto_now_add=True)
objects = UserFlagManager()
class META:
db_table = 'comments_user_flags'
verbose_name = _('User flag')
verbose_name_plural = _('User flags')
unique_together = (('user', 'comment'),)
def __repr__(self):
return _("Flag by %r") % self.get_user()
class ModeratorDeletion(models.Model): class ModeratorDeletion(models.Model):
user = models.ForeignKey(auth.User, verbose_name='moderator') user = models.ForeignKey(auth.User, verbose_name='moderator')
comment = models.ForeignKey(Comment) comment = models.ForeignKey(Comment)
@ -284,4 +287,3 @@ class ModeratorDeletion(models.Model):
def __repr__(self): def __repr__(self):
return _("Moderator deletion by %r") % self.get_user() return _("Moderator deletion by %r") % self.get_user()

32
django/contrib/comments/templatetags/comments.py
View File

@ -1,8 +1,8 @@
"Custom template tags for user comments" from django.contrib.comments.models import Comment, FreeComment
from django.contrib.comments.models import PHOTOS_REQUIRED, PHOTOS_OPTIONAL, RATINGS_REQUIRED, RATINGS_OPTIONAL, IS_PUBLIC
from django.contrib.comments.models import MIN_PHOTO_DIMENSION, MAX_PHOTO_DIMENSION
from django.core import template from django.core import template
from django.core.exceptions import ObjectDoesNotExist from django.core.exceptions import ObjectDoesNotExist
from django.models.comments import comments, freecomments
from django.models.core import contenttypes from django.models.core import contenttypes
import re import re
@ -93,24 +93,24 @@ class CommentFormNode(template.Node):
context['display_form'] = True context['display_form'] = True
context['target'] = '%s:%s' % (self.content_type.id, self.obj_id) context['target'] = '%s:%s' % (self.content_type.id, self.obj_id)
options = [] options = []
for var, abbr in (('photos_required', comments.PHOTOS_REQUIRED), for var, abbr in (('photos_required', PHOTOS_REQUIRED),
('photos_optional', comments.PHOTOS_OPTIONAL), ('photos_optional', PHOTOS_OPTIONAL),
('ratings_required', comments.RATINGS_REQUIRED), ('ratings_required', RATINGS_REQUIRED),
('ratings_optional', comments.RATINGS_OPTIONAL), ('ratings_optional', RATINGS_OPTIONAL),
('is_public', comments.IS_PUBLIC)): ('is_public', IS_PUBLIC)):
context[var] = getattr(self, var) context[var] = getattr(self, var)
if getattr(self, var): if getattr(self, var):
options.append(abbr) options.append(abbr)
context['options'] = ','.join(options) context['options'] = ','.join(options)
if self.free: if self.free:
context['hash'] = comments.get_security_hash(context['options'], '', '', context['target']) context['hash'] = Comment.objects.get_security_hash(context['options'], '', '', context['target'])
default_form = FREE_COMMENT_FORM default_form = FREE_COMMENT_FORM
else: else:
context['photo_options'] = self.photo_options context['photo_options'] = self.photo_options
context['rating_options'] = normalize_newlines(base64.encodestring(self.rating_options).strip()) context['rating_options'] = normalize_newlines(base64.encodestring(self.rating_options).strip())
if self.rating_options: if self.rating_options:
context['rating_range'], context['rating_choices'] = comments.get_rating_options(self.rating_options) context['rating_range'], context['rating_choices'] = Comment.objects.get_rating_options(self.rating_options)
context['hash'] = comments.get_security_hash(context['options'], context['photo_options'], context['rating_options'], context['target']) context['hash'] = Comment.objects.get_security_hash(context['options'], context['photo_options'], context['rating_options'], context['target'])
default_form = COMMENT_FORM default_form = COMMENT_FORM
output = template.Template(default_form).render(context) output = template.Template(default_form).render(context)
context.pop() context.pop()
@ -124,7 +124,7 @@ class CommentCountNode(template.Node):
def render(self, context): def render(self, context):
from django.conf.settings import SITE_ID from django.conf.settings import SITE_ID
get_count_function = self.free and freecomments.get_count or comments.get_count get_count_function = self.free and FreeComment.objects.get_count or Comment.objects.get_count
if self.context_var_name is not None: if self.context_var_name is not None:
self.obj_id = template.resolve_variable(self.context_var_name, context) self.obj_id = template.resolve_variable(self.context_var_name, context)
comment_count = get_count_function(object_id__exact=self.obj_id, comment_count = get_count_function(object_id__exact=self.obj_id,
@ -143,7 +143,7 @@ class CommentListNode(template.Node):
def render(self, context): def render(self, context):
from django.conf.settings import COMMENTS_BANNED_USERS_GROUP, SITE_ID from django.conf.settings import COMMENTS_BANNED_USERS_GROUP, SITE_ID
get_list_function = self.free and freecomments.get_list or comments.get_list_with_karma get_list_function = self.free and FreeComment.objects.get_list or Comment.objects.get_list_with_karma
if self.context_var_name is not None: if self.context_var_name is not None:
try: try:
self.obj_id = template.resolve_variable(self.context_var_name, context) self.obj_id = template.resolve_variable(self.context_var_name, context)
@ -165,7 +165,7 @@ class CommentListNode(template.Node):
if not self.free: if not self.free:
if context.has_key('user') and not context['user'].is_anonymous(): if context.has_key('user') and not context['user'].is_anonymous():
user_id = context['user'].id user_id = context['user'].id
context['user_can_moderate_comments'] = comments.user_is_moderator(context['user']) context['user_can_moderate_comments'] = Comment.objects.user_is_moderator(context['user'])
else: else:
user_id = None user_id = None
context['user_can_moderate_comments'] = False context['user_can_moderate_comments'] = False
@ -230,8 +230,8 @@ class DoCommentForm:
if not opt.isalnum(): if not opt.isalnum():
raise template.TemplateSyntaxError, "Invalid photo directory name in %r tag: '%s'" % (tokens[0], opt) raise template.TemplateSyntaxError, "Invalid photo directory name in %r tag: '%s'" % (tokens[0], opt)
for opt in option_list[1::3] + option_list[2::3]: for opt in option_list[1::3] + option_list[2::3]:
if not opt.isdigit() or not (comments.MIN_PHOTO_DIMENSION <= int(opt) <= comments.MAX_PHOTO_DIMENSION): if not opt.isdigit() or not (MIN_PHOTO_DIMENSION <= int(opt) <= MAX_PHOTO_DIMENSION):
raise template.TemplateSyntaxError, "Invalid photo dimension in %r tag: '%s'. Only values between %s and %s are allowed." % (tokens[0], opt, comments.MIN_PHOTO_DIMENSION, comments.MAX_PHOTO_DIMENSION) raise template.TemplateSyntaxError, "Invalid photo dimension in %r tag: '%s'. Only values between %s and %s are allowed." % (tokens[0], opt, MIN_PHOTO_DIMENSION, MAX_PHOTO_DIMENSION)
# VALIDATION ENDS ######################################### # VALIDATION ENDS #########################################
kwargs[option] = True kwargs[option] = True
kwargs['photo_options'] = args kwargs['photo_options'] = args

34
django/contrib/comments/views/comments.py
View File

@ -3,8 +3,8 @@ from django.core.mail import mail_admins, mail_managers
from django.core.exceptions import Http404, ObjectDoesNotExist from django.core.exceptions import Http404, ObjectDoesNotExist
from django.core.extensions import DjangoContext, render_to_response from django.core.extensions import DjangoContext, render_to_response
from django.models.auth import SESSION_KEY from django.models.auth import SESSION_KEY
from django.models.comments import comments, freecomments from django.contrib.comments.models import Comment, FreeComment, PHOTOS_REQUIRED, PHOTOS_OPTIONAL, RATINGS_REQUIRED, RATINGS_OPTIONAL, IS_PUBLIC
from django.models.core import contenttypes from django.models.core import ContentType
from django.parts.auth.formfields import AuthenticationForm from django.parts.auth.formfields import AuthenticationForm
from django.utils.httpwrappers import HttpResponseRedirect from django.utils.httpwrappers import HttpResponseRedirect
from django.utils.text import normalize_newlines from django.utils.text import normalize_newlines
@ -75,7 +75,7 @@ class PublicCommentManipulator(AuthenticationForm):
def get_comment(self, new_data): def get_comment(self, new_data):
"Helper function" "Helper function"
return comments.Comment(None, self.get_user_id(), new_data["content_type_id"], return Comment(None, self.get_user_id(), new_data["content_type_id"],
new_data["object_id"], new_data.get("headline", "").strip(), new_data["object_id"], new_data.get("headline", "").strip(),
new_data["comment"].strip(), new_data.get("rating1", None), new_data["comment"].strip(), new_data.get("rating1", None),
new_data.get("rating2", None), new_data.get("rating3", None), new_data.get("rating2", None), new_data.get("rating3", None),
@ -87,7 +87,7 @@ class PublicCommentManipulator(AuthenticationForm):
def save(self, new_data): def save(self, new_data):
today = datetime.date.today() today = datetime.date.today()
c = self.get_comment(new_data) c = self.get_comment(new_data)
for old in comments.get_list(content_type__id__exact=new_data["content_type_id"], for old in Comment.objects.get_list(content_type__id__exact=new_data["content_type_id"],
object_id__exact=new_data["object_id"], user__id__exact=self.get_user_id()): object_id__exact=new_data["object_id"], user__id__exact=self.get_user_id()):
# Check that this comment isn't duplicate. (Sometimes people post # Check that this comment isn't duplicate. (Sometimes people post
# comments twice by mistake.) If it is, fail silently by pretending # comments twice by mistake.) If it is, fail silently by pretending
@ -132,7 +132,7 @@ class PublicFreeCommentManipulator(formfields.Manipulator):
def get_comment(self, new_data): def get_comment(self, new_data):
"Helper function" "Helper function"
return freecomments.FreeComment(None, new_data["content_type_id"], return FreeComment(None, new_data["content_type_id"],
new_data["object_id"], new_data["comment"].strip(), new_data["object_id"], new_data["comment"].strip(),
new_data["person_name"].strip(), datetime.datetime.now(), new_data["is_public"], new_data["person_name"].strip(), datetime.datetime.now(), new_data["is_public"],
new_data["ip_address"], False, SITE_ID) new_data["ip_address"], False, SITE_ID)
@ -143,7 +143,7 @@ class PublicFreeCommentManipulator(formfields.Manipulator):
# Check that this comment isn't duplicate. (Sometimes people post # Check that this comment isn't duplicate. (Sometimes people post
# comments twice by mistake.) If it is, fail silently by pretending # comments twice by mistake.) If it is, fail silently by pretending
# the comment was posted successfully. # the comment was posted successfully.
for old_comment in freecomments.get_list(content_type__id__exact=new_data["content_type_id"], for old_comment in FreeComment.objects.get_list(content_type__id__exact=new_data["content_type_id"],
object_id__exact=new_data["object_id"], person_name__exact=new_data["person_name"], object_id__exact=new_data["object_id"], person_name__exact=new_data["person_name"],
submit_date__year=today.year, submit_date__month=today.month, submit_date__year=today.year, submit_date__month=today.month,
submit_date__day=today.day): submit_date__day=today.day):
@ -190,16 +190,16 @@ def post_comment(request):
raise Http404, _("One or more of the required fields wasn't submitted") raise Http404, _("One or more of the required fields wasn't submitted")
photo_options = request.POST.get('photo_options', '') photo_options = request.POST.get('photo_options', '')
rating_options = normalize_newlines(request.POST.get('rating_options', '')) rating_options = normalize_newlines(request.POST.get('rating_options', ''))
if comments.get_security_hash(options, photo_options, rating_options, target) != security_hash: if Comment.objects.get_security_hash(options, photo_options, rating_options, target) != security_hash:
raise Http404, _("Somebody tampered with the comment form (security violation)") raise Http404, _("Somebody tampered with the comment form (security violation)")
# Now we can be assured the data is valid. # Now we can be assured the data is valid.
if rating_options: if rating_options:
rating_range, rating_choices = comments.get_rating_options(base64.decodestring(rating_options)) rating_range, rating_choices = Comment.objects.get_rating_options(base64.decodestring(rating_options))
else: else:
rating_range, rating_choices = [], [] rating_range, rating_choices = [], []
content_type_id, object_id = target.split(':') # target is something like '52:5157' content_type_id, object_id = target.split(':') # target is something like '52:5157'
try: try:
obj = contenttypes.get_object(pk=content_type_id).get_object_for_this_type(pk=object_id) obj = ContentType.objects.get_object(pk=content_type_id).get_object_for_this_type(pk=object_id)
except ObjectDoesNotExist: except ObjectDoesNotExist:
raise Http404, _("The comment form had an invalid 'target' parameter -- the object ID was invalid") raise Http404, _("The comment form had an invalid 'target' parameter -- the object ID was invalid")
option_list = options.split(',') # options is something like 'pa,ra' option_list = options.split(',') # options is something like 'pa,ra'
@ -207,9 +207,9 @@ def post_comment(request):
new_data['content_type_id'] = content_type_id new_data['content_type_id'] = content_type_id
new_data['object_id'] = object_id new_data['object_id'] = object_id
new_data['ip_address'] = request.META.get('REMOTE_ADDR') new_data['ip_address'] = request.META.get('REMOTE_ADDR')
new_data['is_public'] = comments.IS_PUBLIC in option_list new_data['is_public'] = IS_PUBLIC in option_list
manipulator = PublicCommentManipulator(request.user, manipulator = PublicCommentManipulator(request.user,
ratings_required=comments.RATINGS_REQUIRED in option_list, ratings_required=RATINGS_REQUIRED in option_list,
ratings_range=rating_range, ratings_range=rating_range,
num_rating_choices=len(rating_choices)) num_rating_choices=len(rating_choices))
errors = manipulator.get_validation_errors(new_data) errors = manipulator.get_validation_errors(new_data)
@ -236,8 +236,8 @@ def post_comment(request):
'target': target, 'target': target,
'hash': security_hash, 'hash': security_hash,
'rating_options': rating_options, 'rating_options': rating_options,
'ratings_optional': comments.RATINGS_OPTIONAL in option_list, 'ratings_optional': RATINGS_OPTIONAL in option_list,
'ratings_required': comments.RATINGS_REQUIRED in option_list, 'ratings_required': RATINGS_REQUIRED in option_list,
'rating_range': rating_range, 'rating_range': rating_range,
'rating_choices': rating_choices, 'rating_choices': rating_choices,
}, context_instance=DjangoContext(request)) }, context_instance=DjangoContext(request))
@ -279,10 +279,10 @@ def post_free_comment(request):
options, target, security_hash = request.POST['options'], request.POST['target'], request.POST['gonzo'] options, target, security_hash = request.POST['options'], request.POST['target'], request.POST['gonzo']
except KeyError: except KeyError:
raise Http404, _("One or more of the required fields wasn't submitted") raise Http404, _("One or more of the required fields wasn't submitted")
if comments.get_security_hash(options, '', '', target) != security_hash: if Comment.objects.get_security_hash(options, '', '', target) != security_hash:
raise Http404, _("Somebody tampered with the comment form (security violation)") raise Http404, _("Somebody tampered with the comment form (security violation)")
content_type_id, object_id = target.split(':') # target is something like '52:5157' content_type_id, object_id = target.split(':') # target is something like '52:5157'
content_type = contenttypes.get_object(pk=content_type_id) content_type = ContentType.objects.get_object(pk=content_type_id)
try: try:
obj = content_type.get_object_for_this_type(pk=object_id) obj = content_type.get_object_for_this_type(pk=object_id)
except ObjectDoesNotExist: except ObjectDoesNotExist:
@ -292,7 +292,7 @@ def post_free_comment(request):
new_data['content_type_id'] = content_type_id new_data['content_type_id'] = content_type_id
new_data['object_id'] = object_id new_data['object_id'] = object_id
new_data['ip_address'] = request.META['REMOTE_ADDR'] new_data['ip_address'] = request.META['REMOTE_ADDR']
new_data['is_public'] = comments.IS_PUBLIC in option_list new_data['is_public'] = IS_PUBLIC in option_list
manipulator = PublicFreeCommentManipulator() manipulator = PublicFreeCommentManipulator()
errors = manipulator.get_validation_errors(new_data) errors = manipulator.get_validation_errors(new_data)
if errors or request.POST.has_key('preview'): if errors or request.POST.has_key('preview'):
@ -330,7 +330,7 @@ def comment_was_posted(request):
if request.GET.has_key('c'): if request.GET.has_key('c'):
content_type_id, object_id = request.GET['c'].split(':') content_type_id, object_id = request.GET['c'].split(':')
try: try:
content_type = contenttypes.get_object(pk=content_type_id) content_type = ContentType.objects.get_object(pk=content_type_id)
obj = content_type.get_object_for_this_type(pk=object_id) obj = content_type.get_object_for_this_type(pk=object_id)
except ObjectDoesNotExist: except ObjectDoesNotExist:
pass pass

10
django/contrib/redirects/middleware.py
View File

@ -1,4 +1,4 @@
from django.models.redirects import redirects from django.contrib.redirects.models import Redirect
from django.utils import httpwrappers from django.utils import httpwrappers
from django.conf.settings import APPEND_SLASH, SITE_ID from django.conf.settings import APPEND_SLASH, SITE_ID
@ -8,15 +8,15 @@ class RedirectFallbackMiddleware:
return response # No need to check for a redirect for non-404 responses. return response # No need to check for a redirect for non-404 responses.
path = request.get_full_path() path = request.get_full_path()
try: try:
r = redirects.get_object(site__id__exact=SITE_ID, old_path__exact=path) r = Redirect.objects.get_object(site__id__exact=SITE_ID, old_path__exact=path)
except redirects.RedirectDoesNotExist: except Redirect.DoesNotExist:
r = None r = None
if r is None and APPEND_SLASH: if r is None and APPEND_SLASH:
# Try removing the trailing slash. # Try removing the trailing slash.
try: try:
r = redirects.get_object(site__id__exact=SITE_ID, r = Redirect.objects.get_object(site__id__exact=SITE_ID,
old_path__exact=path[:path.rfind('/')]+path[path.rfind('/')+1:]) old_path__exact=path[:path.rfind('/')]+path[path.rfind('/')+1:])
except redirects.RedirectDoesNotExist: except Redirect.DoesNotExist:
pass pass
if r is not None: if r is not None:
if r == '': if r == '':

12
django/core/management.py
View File

@ -427,17 +427,17 @@ install.args = APP_ARGS
def installperms(mod): def installperms(mod):
"Installs any permissions for the given model, if needed." "Installs any permissions for the given model, if needed."
from django.models.auth import permissions from django.models.auth import Permission
from django.models.core import packages from django.models.core import Package
num_added = 0 num_added = 0
package = packages.get_object(pk=mod._MODELS[0]._meta.app_label) package = Package.objects.get_object(pk=mod._MODELS[0]._meta.app_label)
for klass in mod._MODELS: for klass in mod._MODELS:
opts = klass._meta opts = klass._meta
for codename, name in _get_all_permissions(opts): for codename, name in _get_all_permissions(opts):
try: try:
permissions.get_object(name__exact=name, codename__exact=codename, package__label__exact=package.label) Permission.objects.get_object(name__exact=name, codename__exact=codename, package__label__exact=package.label)
except permissions.PermissionDoesNotExist: except Permission.DoesNotExist:
p = permissions.Permission(name=name, package=package, codename=codename) p = Permission(name=name, package=package, codename=codename)
p.save() p.save()
print "Added permission '%r'." % p print "Added permission '%r'." % p
num_added += 1 num_added += 1

6
django/parts/auth/formfields.py
View File

@ -1,4 +1,4 @@
from django.models.auth import users from django.models.auth import User
from django.core import formfields, validators from django.core import formfields, validators
class AuthenticationForm(formfields.Manipulator): class AuthenticationForm(formfields.Manipulator):
@ -28,8 +28,8 @@ class AuthenticationForm(formfields.Manipulator):
def isValidUser(self, field_data, all_data): def isValidUser(self, field_data, all_data):
try: try:
self.user_cache = users.get_object(username__exact=field_data) self.user_cache = User.objects.get_object(username__exact=field_data)
except users.UserDoesNotExist: except User.DoesNotExist:
raise validators.ValidationError, "Please enter a correct username and password. Note that both fields are case-sensitive." raise validators.ValidationError, "Please enter a correct username and password. Note that both fields are case-sensitive."
def isValidPasswordForUser(self, field_data, all_data): def isValidPasswordForUser(self, field_data, all_data):

10
django/views/defaults.py
View File

@ -1,13 +1,13 @@
from django.core.exceptions import Http404, ObjectDoesNotExist from django.core.exceptions import Http404, ObjectDoesNotExist
from django.core.template import Context, loader from django.core.template import Context, loader
from django.models.core import sites, contenttypes from django.models.core import ContentType, Site
from django.utils import httpwrappers from django.utils import httpwrappers
def shortcut(request, content_type_id, object_id): def shortcut(request, content_type_id, object_id):
"Redirect to an object's page based on a content-type ID and an object ID." "Redirect to an object's page based on a content-type ID and an object ID."
# Look up the object, making sure it's got a get_absolute_url() function. # Look up the object, making sure it's got a get_absolute_url() function.
try: try:
content_type = contenttypes.get_object(pk=content_type_id) content_type = ContentType.objects.get_object(pk=content_type_id)
obj = content_type.get_object_for_this_type(pk=object_id) obj = content_type.get_object_for_this_type(pk=object_id)
except ObjectDoesNotExist: except ObjectDoesNotExist:
raise Http404, "Content type %s object %s doesn't exist" % (content_type_id, object_id) raise Http404, "Content type %s object %s doesn't exist" % (content_type_id, object_id)
@ -35,14 +35,14 @@ def shortcut(request, content_type_id, object_id):
elif hasattr(obj, 'get_site'): elif hasattr(obj, 'get_site'):
try: try:
object_domain = obj.get_site().domain object_domain = obj.get_site().domain
except sites.SiteDoesNotExist: except Site.DoesNotExist:
pass pass
# Then, fall back to the current site (if possible) # Then, fall back to the current site (if possible)
else: else:
try: try:
object_domain = sites.get_current().domain object_domain = Site.objects.get_current().domain
except sites.SiteDoesNotExist: except Site.DoesNotExist:
# Finally, give up and use a URL without the domain name # Finally, give up and use a URL without the domain name
return httpwrappers.HttpResponseRedirect(obj.get_absolute_url()) return httpwrappers.HttpResponseRedirect(obj.get_absolute_url())
return httpwrappers.HttpResponseRedirect('http://%s%s' % (object_domain, obj.get_absolute_url())) return httpwrappers.HttpResponseRedirect('http://%s%s' % (object_domain, obj.get_absolute_url()))