Changeset 1691

Timestamp:

07/18/08 12:58:51 (20 months ago)

Author:

JensDiemer

Message:

many updates for the blog plugin

Location:

trunk/pylucid

Files:

• media/PyLucid/internal_page/blog/display_blog.css (modified) (1 diff)
• media/PyLucid/internal_page/blog/display_blog.html (modified) (2 diffs)
• media/PyLucid/internal_page/blog/mod_comments.html (modified) (1 diff)
• media/PyLucid/internal_page/blog/notify_mailtext.html (modified) (1 diff)
• PyLucid/plugins_internal/blog/blog.py (modified) (23 diffs)
• PyLucid/plugins_internal/blog/blog_cfg.py (modified) (3 diffs)
• PyLucid/system/page_msg.py (modified) (5 diffs)
• PyLucid/tools/newforms_utils.py (modified) (1 diff)

trunk/pylucid/media/PyLucid/internal_page/blog/display_blog.css

@@ -112 +112 @@
   margin: 0px;
 }
+.comment .admin_info_line {
+  color:red;
+  line-height: 0px;
+}
 /* -------------------------------------------------------------------------- */
 #input_fields {

trunk/pylucid/media/PyLucid/internal_page/blog/display_blog.html

@@ -2 +2 @@
 {% if create_url %}<p><a href="{{ create_url }}" class="action_link">create a new blog entry</a></p>{% endif %}
 
+{% if not entries %}no blog entry exists{% endif %}
 {% for entry in entries %}
     <fieldset class="entry"><legend class="headline"><a href="{{ entry.detail_url }}">{{ entry.headline }}</a></legend>
@@ -45 +46 @@
                         {{ comment.person_name }}{% if comment.homepage %}</a>{% endif %}:
                       </legend>
+                      {% if not comment.is_public %}
+                          <p class="admin_info_line">not public</p>
+                      {% endif %}
 
                       <div class="admin_links">
                         {% if comment.edit_url %}<a href="{{ comment.edit_url }}">edit</a>{% endif %}
+                        {% if comment.delete_url %}<a href="{{ comment.delete_url }}" onClick="return confirm('Realy want to delete the comment entry?');">delete</a>{% endif %}
                       </div>
 

trunk/pylucid/media/PyLucid/internal_page/blog/mod_comments.html

@@ -3 +3 @@
 {% for comment in comments %}
   <li>
-    <a href="{{ comment.edit_url }}">{{ comment }}</a>
+    <a href="{{ comment.edit_url }}">edit</a>
+    {{ comment.content }}
+    {{ comment.blog_entry.headline }}
   </li>
 {% endfor %}

trunk/pylucid/media/PyLucid/internal_page/blog/notify_mailtext.html

@@ -9 +9 @@
   IP Address...: {{ comment_entry.ip_address }}
   submit time..: {{ comment_entry.createtime }}
-{% if is_spam %}
-This comment is detected as SPAM. It is not saved into the database!
-{% else %}
-Edit this new comment: {{ edit_url }}
-{% endif %}
+
+--[submit messages]------------------------------------------------------------
+{% for line in submit_msg %}
+  {{ line }}
+{% endfor %}
+--[submit messages end]--------------------------------------------------------
+
+{% if edit_url %}Edit this new comment: {{ edit_url }}{% else %}This comment was not saved into the database.{% endif %}
+
 --[comment content]------------------------------------------------------------
 {{ comment_entry.content }}

trunk/pylucid/PyLucid/plugins_internal/blog/blog.py

@@ -32 +32 @@
 from PyLucid.system.BasePlugin import PyLucidBasePlugin
 from PyLucid.tools.content_processors import apply_markup
+from PyLucid.tools.newforms_utils import StripedCharField
 from PyLucid.tools.utils import escape_django_tags
+from PyLucid.system.page_msg import PageMessages
 from PyLucid.models.Page import MARKUPS
+
+from PyLucid.plugins_internal.blog.blog_cfg import DONT_CHECK, REJECT_SPAM, \
+                                                                    MODERATED
 
 # Don't send mails, display them only.
@@ -50 +55 @@
     ip_address = models.IPAddressField(_('ip address'),)
     person_name = models.CharField(
-        _("person's name"), max_length=50
+        _("person's name"), max_length=50,
+        help_text=_("Your full name (will be published) (required)"),
     )
     email = models.EmailField(
         _('e-mail address'),
-        help_text=_("Only for internal use."),
+        help_text=_("Only for internal use. (will not be published) (required)"),
     )
     homepage = models.URLField(
@@ -90 +96 @@
 
 
+
 class BlogCommentForm(forms.ModelForm):
     """
-    Add a comment.
+    Add a new comment.
     """
     person_name = forms.CharField(
@@ -98 +105 @@
         help_text=_("Your name."),
     )
-    content = forms.CharField(
+    content = StripedCharField(
         label = _('content'), min_length=5, max_length=3000,
         help_text=_("Your comment to this blog entry."),
@@ -107 +114 @@
         model = BlogComment
         # Using a subset of fields on the form
-        fields = ('person_name', 'email', "homepage", "comment")
-
+        fields = ('person_name', 'email', "homepage")
+
+
+class AdminCommentForm(BlogCommentForm):
+    """
+    Form for editing a existing comment. Only for Admins
+    """
+    class Meta:
+        model = BlogComment
+        fields = (
+            'ip_address', 'person_name', 'email', "homepage",
+            "content", "is_public",
+            "createtime", "lastupdatetime", "createby", "lastupdateby"
+        )
 
 #______________________________________________________________________________
@@ -244 +263 @@
 
 
+
 class blog(PyLucidBasePlugin):
 
@@ -251 +271 @@
         super(blog, self).__init__(*args, **kwargs)
 
+        # Log info about handling blog comment submissions
+        self.submit_msg = PageMessages(
+            self.request, use_django_msg=False, html=False
+        )
+
         # Get the default preference entry.
         self.preferences = self.get_preferences()
@@ -258 +283 @@
 
 
-    def _add_comment_edit_url(self, comments):
+    def _add_comment_admin_urls(self, comments):
         for comment in comments:
             comment.edit_url = self.URLs.methodLink(
                 "edit_comment", comment.id
+            )
+            comment.delete_url = self.URLs.methodLink(
+                "delete_comment", comment.id
             )
 
@@ -287 +315 @@
                 if self.request.user.is_staff:
                     comments = comments.all()
-                    self._add_comment_edit_url(comments)
+                    self._add_comment_admin_urls(comments)
                 else:
                     comments = comments.filter(is_public = True).all()
@@ -347 +375 @@
 
         self.current_page.title += " - " + blog_entry.headline
-
 
         if blog_entry.is_public != True:
@@ -363 +390 @@
             #self.page_msg(self.request.POST)
             if form.is_valid():
-                ok = self._save_new_comment(blog_entry, form)
+                ok = self._save_new_comment(
+                    blog_entry, clean_data = form.cleaned_data
+                )
                 if ok:
                     return self._list_entries([blog_entry], full_comments=True)
@@ -437 +466 @@
                     blog_obj.save()
                     self.page_msg.green("New blog entry created.")
+                    tags_string = form.cleaned_data["tags"]
                 else:
                     # Update a existing blog entry
+                    tags_string = form.cleaned_data.pop("tags")
+                    self.page_msg.green("Update existing blog entry.")
                     blog_obj.lastupdateby = self.request.user
                     for k,v in form.cleaned_data.iteritems():
                         setattr(blog_obj, k, v)
-                    self.page_msg.green("Update existing blog entry.")
-
-                tags_string = form.cleaned_data["tags"]
+
                 tag_objects, new_tags = BlogTag.objects.get_or_creates(
                     tags_string
@@ -525 +555 @@
     # COMMENTS
 
-    def _send_notify(self, mail_title, blog_entry, is_spam, comment_entry):
+    def _send_notify(self, mail_title, blog_entry, comment_entry):
         """
         Send a email noitify for a submited blog comment.
@@ -534 +564 @@
                 self.URLs.methodLink("edit", blog_entry.id)
             ),
-            "is_spam": is_spam,
             "comment_entry": comment_entry,
+            "submit_msg": self.submit_msg,
         }
 
-        if not is_spam:
+        if hasattr(comment_entry, "id"):
             # Add edit link into the mail
             email_context["edit_url"] = self.URLs.make_absolute_url(
@@ -554 +584 @@
 
         send_mail_kwargs = {
+            "from_email": settings.DEFAULT_FROM_EMAIL,
             "subject": "%s %s" % (settings.EMAIL_SUBJECT_PREFIX, mail_title),
 #                from_email = sender,
@@ -569 +600 @@
             return
         else:
-            send_mail(message = emailtext,**send_mail_kwargs)
-
-    def _check_spam(self, blog_entry, form_cleaned_data, content_lower):
-        """
-        Check if the submitted comment is spam.
-        Display error messages and handle email notify.
-        """
-        contains_spam = self._check_wordlist(
-            content_lower, pref_key = "spam_keywords"
-        )
-        if not contains_spam:
-            # The submitted content contains no spam keyword
-            return False
-
-        self.page_msg.red("Sorry, your comment identify as spam.")
-
+            send_mail(message = emailtext, **send_mail_kwargs)
+
+    def _reject_spam_comment(self, blog_entry, clean_data):
+        """
+        Reject a submited comment as spam:
+        1. Display page_msg
+        2. Handle email notify.
+        """
         if not self.preferences["spam_notify"]:
             # Don't send spam notify email
-            return True
+            return
 
         # Add ID Adress for notify mail text
-        form_cleaned_data["ip_address"] = self.request.META.get('REMOTE_ADDR')
-        form_cleaned_data["createtime"] = datetime.datetime.now()
+        clean_data["ip_address"] = self.request.META.get('REMOTE_ADDR')
+        clean_data["createtime"] = datetime.datetime.now()
 
         self._send_notify(
             mail_title = _("blog comment as spam detected."),
-            blog_entry = blog_entry, is_spam = True,
-            comment_entry = form_cleaned_data
-        )
-        return True
-
-    def _save_new_comment(self, blog_entry, form):
+            blog_entry = blog_entry, comment_entry = clean_data
+        )
+
+    def _check_comment_submit(self, blog_entry, content):
+        """
+        Check the submit of a new blog comment
+        """
+        if self.request.user.is_staff:
+            # Don't check comments from staff users
+            self.submit_msg("comment submit by page member.")
+            return _("new blog comment from page member published.")
+
+        # Check the http referer, exception would be raised if something wrong
+        self._check_referer(blog_entry)
+
+        content_lower = content.lower()
+
+        # check SPAM keywords
+        spam_keyword = self._check_wordlist(
+            content_lower, pref_key = "spam_keywords"
+        )
+        if spam_keyword:
+            raise RejectSpam(
+                "Comment contains SPAM keyword: '%s'" % spam_keyword
+            )
+
+        # check mod_keywords
+        mod_keyword = self._check_wordlist(
+            content_lower, pref_key = "mod_keywords"
+        )
+        if mod_keyword:
+            raise ModerateSubmit(
+                "Comment contains mod_keyword: '%s'" % mod_keyword
+            )
+
+
+
+    def _save_new_comment(self, blog_entry, clean_data):
         """
         Save a valid submited comment form into the database.
@@ -609 +664 @@
         Send notify emails.
         """
-        content = form.cleaned_data["content"]
-        content = content.strip()
-        content_lower = content.lower()
-
-        if self.request.user.is_staff:
-            # Don't check comments from staff users
+        content = clean_data["content"]
+
+        try:
+            mail_title = self._check_comment_submit(blog_entry, content)
+        except RejectSpam, msg:
+            self.page_msg.red("Sorry, your comment identify as spam.")
+            self.submit_msg(msg)
+            # Display page_msg and handle email notify:
+            self._reject_spam_comment(blog_entry, clean_data)
+            return False
+        except ModerateSubmit, msg:
+            self.page_msg(_("Your comment must wait for authorization."))
+            mail_title = _("Blog comment moderation needed.")
+            self.submit_msg(msg)
+            is_public = False
+        else:
+            self.submit_msg("Blog comment published.")
+            mail_title = _("Blog comment published.")
             is_public = True
-            mail_title = _("new blog comment from page member published.")
-        else:
-            is_spam = self._check_spam(
-                blog_entry, form.cleaned_data, content_lower
-            )
-            if is_spam != False:
-                # Is spam: page_msg and notify was handled by _ckeck_spam()
-                return False
-
-            should_moderated = self._check_wordlist(
-                content_lower, pref_key = "mod_keywords"
-            )
-            if should_moderated:
-                self.page_msg(_("Your comment must wait for authorization."))
-                mail_title = _("new blog comment waits for moderation.")
-                is_public = False
-            else:
-                mail_title = _("blog comment published.")
-                is_public = True
 
         content = escape_django_tags(content)
@@ -641 +689 @@
             blog_entry = blog_entry,
             ip_address = self.request.META.get('REMOTE_ADDR'),
-            person_name = form.cleaned_data["person_name"],
-            email = form.cleaned_data["email"],
-            homepage = form.cleaned_data["homepage"],
+            person_name = clean_data["person_name"],
+            email = clean_data["email"],
+            homepage = clean_data["homepage"],
             content = content,
             is_public = is_public,
@@ -653 +701 @@
         # Send a notify email
         self._send_notify(
-            mail_title, blog_entry, is_spam=False, comment_entry=new_comment
-        )
-
-        self.page_msg.green("comment saved.")
+            mail_title, blog_entry, comment_entry=new_comment
+        )
+
+        self.page_msg.green("Your comment saved.")
         return True
 
@@ -674 +722 @@
     def _check_wordlist(self, content, pref_key):
         """
-        Simple check, if the content contains one keyword.
+        Simple check, if the content contains one of the keywords.
+        If a keyword found, returns it else returns None
         """
         keywords = self._get_wordlist(pref_key)
         for keyword in keywords:
             if keyword in content:
-                return True
-        return False
-
-    def edit_comment(self, urlargs):
-        """
-        Edit a comment (only for admins)
+                return keyword
+
+    def _check_referer(self, blog_entry):
+        """
+        Check if the referer is ok.
+        raise RejectSpam() or ModerateSubmit() if referer is wrong.
+        """
+        check_referer = self.preferences["check_referer"]
+        if check_referer == DONT_CHECK:
+            # We should not check the referer
+            return
+
+        referer = self.request.META["HTTP_REFERER"]
+        should_be = self.URLs.make_absolute_url(
+            self.URLs.methodLink("detail", blog_entry.id)
+        )
+        self.submit_msg("http referer: '%s' - '%s'" % (referer, should_be))
+
+        if referer == should_be:
+            # Referer is ok
+            return
+
+        msg = "Wrong http referer"
+
+        # Something wrong with the referer
+        if check_referer == REJECT_SPAM:
+            # We should it rejected as spam
+            raise RejectSpam(msg)
+        elif check_referer == MODERATED:
+            # We should moderate the comment
+            raise ModerateSubmit(msg)
+        else:
+            # Should never appear
+            raise AttributeError("Wrong check_referer value?!?")
+
+    def _delete_comment(self, comment_entry):
+        """
+        Delete one comment entry. Display page_msg.
+        Used in delete_comment() and edit_comment().
+        """
+        old_id = comment_entry.id
+        comment_entry.delete()
+        self.page_msg.green(_("Comment entry %s deleted." % old_id))
+
+    def delete_comment(self, urlargs):
+        """
+        Delete a comment (only for admins)
         """
         comment_entry = self._get_entry_from_url(urlargs, model=BlogComment)
@@ -691 +781 @@
             return
 
-        CommentForm = forms.form_for_instance(comment_entry)
-
         blog_entry = comment_entry.blog_entry # ForeignKey("BlogEntry")
 
+        self._delete_comment(comment_entry)
+
+        return self._list_entries(
+            [blog_entry], context={}, full_comments=True
+        )
+
+
+    def edit_comment(self, urlargs):
+        """
+        Edit a comment (only for admins)
+        """
+        comment_entry = self._get_entry_from_url(urlargs, model=BlogComment)
+        if not comment_entry:
+            # Wrong url, page_msg was send to the user
+            return
+
+#        CommentForm = AdminCommentForm
+#
+#
+#        CommentForm = forms.form_for_instance(
+#            instance=comment_entry#, form=BlogCommentForm
+#        )
+
+        blog_entry = comment_entry.blog_entry # ForeignKey("BlogEntry")
+
         if self.request.method == 'POST':
-            form = CommentForm(self.request.POST)
+#            form = CommentForm(self.request.POST)
+            form = AdminCommentForm(self.request.POST, instance=comment_entry)
             #self.page_msg(self.request.POST)
             if form.is_valid():
                 if "delete" in self.request.POST:
-                    comment_entry.delete()
-                    self.page_msg.green("Comment deleted.")
+                    self._delete_comment(comment_entry)
                 else:
                     form.save()
                     self.page_msg.green("Saved.")
-                return self._list_entries([blog_entry], context={}, full_comments=True)
+                return self._list_entries(
+                    [blog_entry], context={}, full_comments=True
+                )
         else:
-            form = CommentForm()
+#            form = CommentForm()
+            form = AdminCommentForm(instance=comment_entry)
 
         context = {
@@ -725 +841 @@
 
         comments = BlogComment.objects.filter(is_public=False)
-        self._add_comment_edit_url(comments)
-        self.page_msg(comments)
+        self._add_comment_admin_urls(comments)
 
         context = {
@@ -733 +848 @@
 
         self._render_template("mod_comments", context)#, debug=2)
+
+
+
+class WrongReferer(Exception):
+    """
+    A comment submit was made with a wrong http referer information
+    """
+    pass
+
+class RejectSpam(Exception):
+    """
+    A submission was identify as SPAM
+    """
+    pass
+
+class ModerateSubmit(Exception):
+    """
+    A submitted comment should be moderated
+    """
+    pass

trunk/pylucid/PyLucid/plugins_internal/blog/blog_cfg.py

@@ -18 +18 @@
 
 from PyLucid.models.Page import MARKUPS
+
+DONT_CHECK = 0
+REJECT_SPAM = 1
+MODERATED = 2
+
+ACTIONS = (
+    (DONT_CHECK,    _("don't check")),
+    (REJECT_SPAM,   _("reject as spam")),
+    (MODERATED,     _("hide, for later moderation")),
+)
 
 class PreferencesForm(forms.Form):
@@ -93 +103 @@
     )
 
+    check_referer = forms.ChoiceField(
+        choices = ACTIONS,
+        initial = MODERATED,
+        help_text = _(
+            "What to do, if http referer contains not your domain?"
+        ),
+    )
 
 # Optional, this Plugin can't have multiple preferences
@@ -139 +156 @@
         "must_admin": True,
     },
+    "delete_comment": {
+        "must_login": True,
+        "must_admin": True,
+    },
     "mod_comments": {
         "must_login": True,

trunk/pylucid/PyLucid/system/page_msg.py

@@ -2 +2 @@
 
 """
-A small Wrapper aound djangos user messages system:
-http://www.djangoproject.com/documentation/authentication/#messages
+    The PyLucid page message system
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-enhanced features:
-  - easy callable to print a messages
-  - simple color output: self.page_msg.green()
-  - use pprint for dicts and lists
-  - special debug mode: Inserts informationen, where from the message has come.
+    A small Wrapper aound djangos user messages system.
 
-In PyLucid modules/plugins, you can use the old system, but it use the django
-messages to store the data:
-  self.page_msg("I am a new django user message in the old PyLucid style ;)")
-  self.page_msg.red("Alert!")
+    enhanced features:
+      - easy callable to print a messages
+      - simple color output: self.page_msg.green()
+      - use pprint for dicts and lists
+      - special debug mode:
+          Inserts informationen, where from the message has come.
+
+    Can also used in Plugin for storing internal messages.
+
+    Links
+    ~~~~~
+    http://www.pylucid.org/_goto/134/plugin-output/
+    http://www.djangoproject.com/documentation/authentication/#messages
 
 
-Last commit info:
-----------------------------------
-$LastChangedDate$
-$Rev$
-$Author$
+    Last commit info:
+    ~~~~~~~~~~~~~~~~~
+    $LastChangedDate$
+    $Rev$
+    $Author$
 
-Created by Jens Diemer
-
-license:
-    GNU General Public License v2 or above
-    http://www.opensource.org/licenses/gpl-license.php
+    :copyleft: 2008 by the PyLucid team, see AUTHORS for more details.
+    :license: GNU GPL v3 or above, see LICENSE for more details.
 """
 
@@ -43 +45 @@
 class PageMessages(object):
     """
-    http://www.djangoproject.com/documentation/authentication/#messages
+    The page message container.
     """
-    def __init__(self, request):
-        try:
-            self.messages = request.user.get_and_delete_messages()
-        except AttributeError:
-            # In the _install section we have no user
-            self.messages = []
+    def __init__(self, request, use_django_msg=True, html=True):
+        self.html = html # Should we generate colored html output?
+
+        self.messages = []
+        if use_django_msg:
+            try:
+                self.messages = request.user.get_and_delete_messages()
+            except AttributeError:
+                # In the _install section we have no user
+                pass
 
         self.debug_mode = getattr(request, "debug", False)
@@ -80 +86 @@
 
     def append_color_data(self, color, *msg):
-        msg = '<span style="color:%s;">%s</span>' % (
-            color, self.prepare(*msg)
-        )
+        if self.html:
+            msg = '<span style="color:%s;">%s</span>' % (
+                color, self.prepare(*msg)
+            )
+        else:
+            msg = self.prepare(*msg)
+
         #~ self.request.user.message_set.create(message=msg)
         msg = mark_safe(msg) # turn djngo auto-escaping off
@@ -130 +140 @@
                 for line in item:
                     line = self.encode_and_prepare(line)
-                    result.append("%s<br />\n" % line)
+                    if self.html:
+                        result.append("%s<br />\n" % line)
+                    else:
+                        result.append("%s\n" % line)
             else:
                 item = self.encode_and_prepare(item)
@@ -150 +163 @@
 
         return escape(txt)
-
 
     #________________________________________________________________

trunk/pylucid/PyLucid/tools/newforms_utils.py

@@ -84 +84 @@
 
 
+class StripedCharField(forms.CharField):
+    """
+    Same as forms.CharField but stripes the output.
+    
+    >>> f = StripedCharField()
+    >>> f.clean('\\n\\n[\\nTEST\\n]\\n\\n')
+    u'[\\nTEST\\n]'
+    """
+    def clean(self, value):
+        value = super(StripedCharField, self).clean(value)
+        return value.strip()
+
+
 if __name__ == "__main__":
     import doctest