| 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 import template |
| from django.template import loader |
| from django.core.exceptions import ObjectDoesNotExist |
| from django.contrib.contenttypes.models import ContentType |
| from django.utils.encoding import smart_str |
| import re |
| |
| register = template.Library() |
| |
| COMMENT_FORM = 'comments/form.html' |
| FREE_COMMENT_FORM = 'comments/freeform.html' |
| |
| class CommentFormNode(template.Node): |
| def __init__(self, content_type, obj_id_lookup_var, obj_id, free, |
| photos_optional=False, photos_required=False, photo_options='', |
| ratings_optional=False, ratings_required=False, rating_options='', |
| is_public=True): |
| self.content_type = content_type |
| if obj_id_lookup_var is not None: |
| obj_id_lookup_var = template.Variable(obj_id_lookup_var) |
| self.obj_id_lookup_var, self.obj_id, self.free = obj_id_lookup_var, obj_id, free |
| self.photos_optional, self.photos_required = photos_optional, photos_required |
| self.ratings_optional, self.ratings_required = ratings_optional, ratings_required |
| self.photo_options, self.rating_options = photo_options, rating_options |
| self.is_public = is_public |
| |
| def render(self, context): |
| from django.conf import settings |
| from django.utils.text import normalize_newlines |
| import base64 |
| context.push() |
| if self.obj_id_lookup_var is not None: |
| try: |
| self.obj_id = self.obj_id_lookup_var.resolve(context) |
| except template.VariableDoesNotExist: |
| return '' |
| # Validate that this object ID is valid for this content-type. |
| # We only have to do this validation if obj_id_lookup_var is provided, |
| # because do_comment_form() validates hard-coded object IDs. |
| try: |
| self.content_type.get_object_for_this_type(pk=self.obj_id) |
| except ObjectDoesNotExist: |
| context['display_form'] = False |
| else: |
| context['display_form'] = True |
| else: |
| context['display_form'] = True |
| context['target'] = '%s:%s' % (self.content_type.id, self.obj_id) |
| options = [] |
| for var, abbr in (('photos_required', PHOTOS_REQUIRED), |
| ('photos_optional', PHOTOS_OPTIONAL), |
| ('ratings_required', RATINGS_REQUIRED), |
| ('ratings_optional', RATINGS_OPTIONAL), |
| ('is_public', IS_PUBLIC)): |
| context[var] = getattr(self, var) |
| if getattr(self, var): |
| options.append(abbr) |
| context['options'] = ','.join(options) |
| if self.free: |
| context['hash'] = Comment.objects.get_security_hash(context['options'], '', '', context['target']) |
| default_form = loader.get_template(FREE_COMMENT_FORM) |
| else: |
| context['photo_options'] = self.photo_options |
| context['rating_options'] = normalize_newlines(base64.encodestring(self.rating_options).strip()) |
| if self.rating_options: |
| context['rating_range'], context['rating_choices'] = Comment.objects.get_rating_options(self.rating_options) |
| context['hash'] = Comment.objects.get_security_hash(context['options'], context['photo_options'], context['rating_options'], context['target']) |
| context['logout_url'] = settings.LOGOUT_URL |
| default_form = loader.get_template(COMMENT_FORM) |
| output = default_form.render(context) |
| context.pop() |
| return output |
| |
| class CommentCountNode(template.Node): |
| def __init__(self, package, module, context_var_name, obj_id, var_name, free): |
| self.package, self.module = package, module |
| if context_var_name is not None: |
| context_var_name = template.Variable(context_var_name) |
| self.context_var_name, self.obj_id = context_var_name, obj_id |
| self.var_name, self.free = var_name, free |
| |
| def render(self, context): |
| from django.conf import settings |
| manager = self.free and FreeComment.objects or Comment.objects |
| if self.context_var_name is not None: |
| self.obj_id = self.context_var_name.resolve(context) |
| comment_count = manager.filter(object_id__exact=self.obj_id, |
| content_type__app_label__exact=self.package, |
| content_type__model__exact=self.module, site__id__exact=settings.SITE_ID).count() |
| context[self.var_name] = comment_count |
| return '' |
| |
| class CommentListNode(template.Node): |
| def __init__(self, package, module, context_var_name, obj_id, var_name, free, ordering, extra_kwargs=None): |
| self.package, self.module = package, module |
| if context_var_name is not None: |
| context_var_name = template.Variable(context_var_name) |
| self.context_var_name, self.obj_id = context_var_name, obj_id |
| self.var_name, self.free = var_name, free |
| self.ordering = ordering |
| self.extra_kwargs = extra_kwargs or {} |
| |
| def render(self, context): |
| from django.conf import settings |
| get_list_function = self.free and FreeComment.objects.filter or Comment.objects.get_list_with_karma |
| if self.context_var_name is not None: |
| try: |
| self.obj_id = self.context_var_name.resolve(context) |
| except template.VariableDoesNotExist: |
| return '' |
| kwargs = { |
| 'object_id__exact': self.obj_id, |
| 'content_type__app_label__exact': self.package, |
| 'content_type__model__exact': self.module, |
| 'site__id__exact': settings.SITE_ID, |
| } |
| kwargs.update(self.extra_kwargs) |
| comment_list = get_list_function(**kwargs).order_by(self.ordering + 'submit_date').select_related() |
| if not self.free and settings.COMMENTS_BANNED_USERS_GROUP: |
| comment_list = comment_list.extra(select={'is_hidden': 'user_id IN (SELECT user_id FROM auth_user_groups WHERE group_id = %s)' % settings.COMMENTS_BANNED_USERS_GROUP}) |
| |
| if not self.free: |
| if 'user' in context and context['user'].is_authenticated(): |
| user_id = context['user'].id |
| context['user_can_moderate_comments'] = Comment.objects.user_is_moderator(context['user']) |
| else: |
| user_id = None |
| context['user_can_moderate_comments'] = False |
| # Only display comments by banned users to those users themselves. |
| if settings.COMMENTS_BANNED_USERS_GROUP: |
| comment_list = [c for c in comment_list if not c.is_hidden or (user_id == c.user_id)] |
| |
| context[self.var_name] = comment_list |
| return '' |
| |
| class DoCommentForm: |
| """ |
| Displays a comment form for the given params. |
| |
| Syntax:: |
| |
| {% comment_form for [pkg].[py_module_name] [context_var_containing_obj_id] with [list of options] %} |
| |
| Example usage:: |
| |
| {% comment_form for lcom.eventtimes event.id with is_public yes photos_optional thumbs,200,400 ratings_optional scale:1-5|first_option|second_option %} |
| |
| ``[context_var_containing_obj_id]`` can be a hard-coded integer or a variable containing the ID. |
| """ |
| def __init__(self, free): |
| self.free = free |
| |
| def __call__(self, parser, token): |
| tokens = token.contents.split() |
| if len(tokens) < 4: |
| raise template.TemplateSyntaxError, "%r tag requires at least 3 arguments" % tokens[0] |
| if tokens[1] != 'for': |
| raise template.TemplateSyntaxError, "Second argument in %r tag must be 'for'" % tokens[0] |
| try: |
| package, module = tokens[2].split('.') |
| except ValueError: # unpack list of wrong size |
| raise template.TemplateSyntaxError, "Third argument in %r tag must be in the format 'package.module'" % tokens[0] |
| try: |
| content_type = ContentType.objects.get(app_label__exact=package, model__exact=module) |
| except ContentType.DoesNotExist: |
| raise template.TemplateSyntaxError, "%r tag has invalid content-type '%s.%s'" % (tokens[0], package, module) |
| obj_id_lookup_var, obj_id = None, None |
| if tokens[3].isdigit(): |
| obj_id = tokens[3] |
| try: # ensure the object ID is valid |
| content_type.get_object_for_this_type(pk=obj_id) |
| except ObjectDoesNotExist: |
| raise template.TemplateSyntaxError, "%r tag refers to %s object with ID %s, which doesn't exist" % (tokens[0], content_type.name, obj_id) |
| else: |
| obj_id_lookup_var = tokens[3] |
| kwargs = {} |
| if len(tokens) > 4: |
| if tokens[4] != 'with': |
| raise template.TemplateSyntaxError, "Fourth argument in %r tag must be 'with'" % tokens[0] |
| for option, args in zip(tokens[5::2], tokens[6::2]): |
| option = smart_str(option) |
| if option in ('photos_optional', 'photos_required') and not self.free: |
| # VALIDATION ############################################## |
| option_list = args.split(',') |
| if len(option_list) % 3 != 0: |
| raise template.TemplateSyntaxError, "Incorrect number of comma-separated arguments to %r tag" % tokens[0] |
| for opt in option_list[::3]: |
| if not opt.isalnum(): |
| 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]: |
| 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, MIN_PHOTO_DIMENSION, MAX_PHOTO_DIMENSION) |
| # VALIDATION ENDS ######################################### |
| kwargs[option] = True |
| kwargs['photo_options'] = args |
| elif option in ('ratings_optional', 'ratings_required') and not self.free: |
| # VALIDATION ############################################## |
| if 2 < len(args.split('|')) > 9: |
| raise template.TemplateSyntaxError, "Incorrect number of '%s' options in %r tag. Use between 2 and 8." % (option, tokens[0]) |
| if re.match('^scale:\d+\-\d+\:$', args.split('|')[0]): |
| raise template.TemplateSyntaxError, "Invalid 'scale' in %r tag's '%s' options" % (tokens[0], option) |
| # VALIDATION ENDS ######################################### |
| kwargs[option] = True |
| kwargs['rating_options'] = args |
| elif option in ('is_public'): |
| kwargs[option] = (args == 'true') |
| else: |
| raise template.TemplateSyntaxError, "%r tag got invalid parameter '%s'" % (tokens[0], option) |
| return CommentFormNode(content_type, obj_id_lookup_var, obj_id, self.free, **kwargs) |
| |
| class DoCommentCount: |
| """ |
| Gets comment count for the given params and populates the template context |
| with a variable containing that value, whose name is defined by the 'as' |
| clause. |
| |
| Syntax:: |
| |
| {% get_comment_count for [pkg].[py_module_name] [context_var_containing_obj_id] as [varname] %} |
| |
| Example usage:: |
| |
| {% get_comment_count for lcom.eventtimes event.id as comment_count %} |
| |
| Note: ``[context_var_containing_obj_id]`` can also be a hard-coded integer, like this:: |
| |
| {% get_comment_count for lcom.eventtimes 23 as comment_count %} |
| """ |
| def __init__(self, free): |
| self.free = free |
| |
| def __call__(self, parser, token): |
| tokens = token.contents.split() |
| # Now tokens is a list like this: |
| # ['get_comment_list', 'for', 'lcom.eventtimes', 'event.id', 'as', 'comment_list'] |
| if len(tokens) != 6: |
| raise template.TemplateSyntaxError, "%r tag requires 5 arguments" % tokens[0] |
| if tokens[1] != 'for': |
| raise template.TemplateSyntaxError, "Second argument in %r tag must be 'for'" % tokens[0] |
| try: |
| package, module = tokens[2].split('.') |
| except ValueError: # unpack list of wrong size |
| raise template.TemplateSyntaxError, "Third argument in %r tag must be in the format 'package.module'" % tokens[0] |
| try: |
| content_type = ContentType.objects.get(app_label__exact=package, model__exact=module) |
| except ContentType.DoesNotExist: |
| raise template.TemplateSyntaxError, "%r tag has invalid content-type '%s.%s'" % (tokens[0], package, module) |
| var_name, obj_id = None, None |
| if tokens[3].isdigit(): |
| obj_id = tokens[3] |
| try: # ensure the object ID is valid |
| content_type.get_object_for_this_type(pk=obj_id) |
| except ObjectDoesNotExist: |
| raise template.TemplateSyntaxError, "%r tag refers to %s object with ID %s, which doesn't exist" % (tokens[0], content_type.name, obj_id) |
| else: |
| var_name = tokens[3] |
| if tokens[4] != 'as': |
| raise template.TemplateSyntaxError, "Fourth argument in %r must be 'as'" % tokens[0] |
| return CommentCountNode(package, module, var_name, obj_id, tokens[5], self.free) |
| |
| class DoGetCommentList: |
| """ |
| Gets comments for the given params and populates the template context with a |
| special comment_package variable, whose name is defined by the ``as`` |
| clause. |
| |
| Syntax:: |
| |
| {% get_comment_list for [pkg].[py_module_name] [context_var_containing_obj_id] as [varname] (reversed) %} |
| |
| Example usage:: |
| |
| {% get_comment_list for lcom.eventtimes event.id as comment_list %} |
| |
| Note: ``[context_var_containing_obj_id]`` can also be a hard-coded integer, like this:: |
| |
| {% get_comment_list for lcom.eventtimes 23 as comment_list %} |
| |
| To get a list of comments in reverse order -- that is, most recent first -- |
| pass ``reversed`` as the last param:: |
| |
| {% get_comment_list for lcom.eventtimes event.id as comment_list reversed %} |
| """ |
| def __init__(self, free): |
| self.free = free |
| |
| def __call__(self, parser, token): |
| tokens = token.contents.split() |
| # Now tokens is a list like this: |
| # ['get_comment_list', 'for', 'lcom.eventtimes', 'event.id', 'as', 'comment_list'] |
| if not len(tokens) in (6, 7): |
| raise template.TemplateSyntaxError, "%r tag requires 5 or 6 arguments" % tokens[0] |
| if tokens[1] != 'for': |
| raise template.TemplateSyntaxError, "Second argument in %r tag must be 'for'" % tokens[0] |
| try: |
| package, module = tokens[2].split('.') |
| except ValueError: # unpack list of wrong size |
| raise template.TemplateSyntaxError, "Third argument in %r tag must be in the format 'package.module'" % tokens[0] |
| try: |
| content_type = ContentType.objects.get(app_label__exact=package,model__exact=module) |
| except ContentType.DoesNotExist: |
| raise template.TemplateSyntaxError, "%r tag has invalid content-type '%s.%s'" % (tokens[0], package, module) |
| var_name, obj_id = None, None |
| if tokens[3].isdigit(): |
| obj_id = tokens[3] |
| try: # ensure the object ID is valid |
| content_type.get_object_for_this_type(pk=obj_id) |
| except ObjectDoesNotExist: |
| raise template.TemplateSyntaxError, "%r tag refers to %s object with ID %s, which doesn't exist" % (tokens[0], content_type.name, obj_id) |
| else: |
| var_name = tokens[3] |
| if tokens[4] != 'as': |
| raise template.TemplateSyntaxError, "Fourth argument in %r must be 'as'" % tokens[0] |
| if len(tokens) == 7: |
| if tokens[6] != 'reversed': |
| raise template.TemplateSyntaxError, "Final argument in %r must be 'reversed' if given" % tokens[0] |
| ordering = "-" |
| else: |
| ordering = "" |
| return CommentListNode(package, module, var_name, obj_id, tokens[5], self.free, ordering) |
| |
| # registration comments |
| register.tag('get_comment_list', DoGetCommentList(False)) |
| register.tag('comment_form', DoCommentForm(False)) |
| register.tag('get_comment_count', DoCommentCount(False)) |
| # free comments |
| register.tag('get_free_comment_list', DoGetCommentList(True)) |
| register.tag('free_comment_form', DoCommentForm(True)) |
| register.tag('get_free_comment_count', DoCommentCount(True)) |
