Create notification messages

MoinMoin/util/notifications.py

 # Copyright: 2013 MoinMoin:AnaBalica
 # License: GNU GPL v2 (or any later version), see LICENSE.txt for details.
 
 """
     MoinMoin - Notifications
 """
 
 from urlparse import urljoin
 from whoosh.query import Term, And
 
 from flask import url_for, g as flaskg
 
 from MoinMoin.constants.keys import (ACTION_COPY, ACTION_RENAME, ACTION_REVERT,
-                                     ACTION_SAVE, ACTION_TRASH, ALL_REVS, MTIME,
-                                     NAME_EXACT, WIKINAME)
+                                     ACTION_SAVE, ACTION_TRASH, ALL_REVS, MTIME, NAME_EXACT, WIKINAME)
 from MoinMoin.i18n import _, L_, N_
 from MoinMoin.themes import render_template
 from MoinMoin.util.diff_text import diff as text_diff
 from MoinMoin.util.diff_datastruct import make_text_diff, diff as dict_diff
 
 from MoinMoin import log
 logging = log.getLogger(__name__)
 
 # additional action values
 ACTION_CREATE = u"CREATE"
@@ skipping 12 matching lines @@
     html_template = "mail/notification_main.html"
 
     def __init__(self, app, item_name, revs, **kwargs):
         self.app = app
         self.item_name = item_name
         self.revs = revs
         self.action = kwargs.get('action', None)
         self.content = kwargs.get('content', None)
         self.meta = kwargs.get('meta', None)
         self.comment = kwargs.get('comment', None)
+        self.wiki_name = self.app.cfg.interwikiname
 
         if self.action == ACTION_SAVE:
             self.action = ACTION_CREATE if len(self.revs) == 1 else ACTION_MODIFY
 
-        self.change_actions = {ACTION_CREATE: L_("has been created"),
-                               ACTION_MODIFY: L_("has been modified"),
-                               ACTION_RENAME: L_("has been renamed"),
-                               ACTION_COPY: L_("has been copied"),
-                               ACTION_REVERT: L_("has been reverted"),
-                               ACTION_TRASH: L_("has been deleted"),
-                               DESTROY_REV: L_("has one revision destroyed"),
-                               DESTROY_ALL: L_("has been destroyed"),

[Thomas.J.Waldmann, 2013/08/19 21:41:10]

that is unlikely to work for all languages.

you are assuming that all languages have the same way / order to build the
complete sentence and it is not flexible to cope with other ways/orders.

+        template_message = "The '%(item_name)s' item on '%(wiki_name)s' has {0} by %(user_name)s:"
+        user_name = flaskg.user.name0
+        self.notification_sentence = {ACTION_CREATE: L_(template_message.format(
+            "been created"), item_name=self.item_name, wiki_name=self.wiki_name, user_name=user_name),
+                                      ACTION_MODIFY: L_(template_message.format(
+            "been modified"), item_name=self.item_name, wiki_name=self.wiki_name, user_name=user_name),
+                                      ACTION_RENAME: L_(template_message.format(
+            "been renamed"), item_name=self.item_name, wiki_name=self.wiki_name, user_name=user_name),
+                                      ACTION_COPY: L_(template_message.format(
+            "been copied"), item_name=self.item_name, wiki_name=self.wiki_name, user_name=user_name),
+                                      ACTION_REVERT: L_(template_message.format(
+            "been reverted"), item_name=self.item_name, wiki_name=self.wiki_name, user_name=user_name),
+                                      ACTION_TRASH: L_(template_message.format(
+            "been deleted"), item_name=self.item_name, wiki_name=self.wiki_name, user_name=user_name),
+                                      DESTROY_REV: L_(template_message.format(
+            "one revision destroyed"), item_name=self.item_name, wiki_name=self.wiki_name, user_name=user_name),
+                                      DESTROY_ALL: L_(template_message.format(
+            "been destroyed"), item_name=self.item_name, wiki_name=self.wiki_name, user_name=user_name),
         }
 
     def get_content_diff(self):
         """ Create a content diff for the last item change
 
         :return: list of diff lines
         """
-        if self.action in (DESTROY_REV, DESTROY_ALL, ):

[Thomas.J.Waldmann, 2013/08/19 21:41:10]

well, this works, but i rather think of a list in such cases than a tuple.

a list often has elements of same kind. the position has no special meaning
except order. like a list of actions, items, names, ...

a tuple more often has elements of different kinds and position ofter has a
special meaning other than just order. like (x, y, z) giving coordinates in 3
dimensions, like (firstname, lastname, street, zipcode, city)

+        if self.action in [DESTROY_REV, DESTROY_ALL, ]:
             content_diff = text_diff(self.content.get_data().splitlines(), [])
         elif self.action == ACTION_TRASH:
             content_diff = text_diff(self.revs[0].data.readlines(), [])

[Thomas.J.Waldmann, 2013/08/19 21:41:10]

where do you check that it really IS text?

should the diff computation rather be a method of the specific item class, like
we already have in MoinMoin.items?

[ana.balica, 2013/08/21 14:03:26]

I almost forgot about other Content types.
What about binary, image files? Are we going to show simply the diff url? Or
also include the diffraw image for instance?

         else:
             new_content = self.revs[0].data.readlines()
             if len(self.revs) == 1:
                 old_content = ""
             else:
                 old_content = self.revs[1].data.readlines()
             content_diff = text_diff(old_content, new_content)
         content_diff = [line.strip() for line in content_diff]
         return content_diff
 
     def get_meta_diff(self):
         """ Create a meta diff for the last item change
 
         :return: a list of tuples of the format (<change type>, <basekeys>, <value>)
                  that can be used to format a diff
         """
-        if self.action in (DESTROY_REV, DESTROY_ALL, ):
+        if self.action in [DESTROY_REV, DESTROY_ALL, ]:
             meta_diff = dict_diff(dict(self.meta), dict())
         elif self.action == ACTION_TRASH:
             meta_diff = dict_diff(self.revs[0].meta._meta, dict())

[Thomas.J.Waldmann, 2013/08/19 21:41:10]

looks a bit like these 2 cases could get implemented in somehow same way

         else:
             new_meta = self.revs[0].meta._meta
             if len(self.revs) == 1:
                 old_meta = dict()
             else:
                 old_meta = self.revs[1].meta._meta
             meta_diff = dict_diff(old_meta, new_meta)

[Thomas.J.Waldmann, 2013/08/19 21:41:10]

even this...

         return meta_diff
 
     def generate_diff_url(self, domain):
         """ Generate the URL that leads to diff page of the last 2 revisions
 
         :param domain: domain name
         :return: the absolute URL to the diff page
         """
         if not self.revs:
             return u""
         if len(self.revs) == 1:
             revid1 = revid2 = self.revs[0].revid

[Thomas.J.Waldmann, 2013/08/19 21:41:10]

what does the diff show here?

[ana.balica, 2013/08/21 14:03:26]

Hm... nothing. And there is no view that can show a diff of a new item (a single
revision).
What URL than should we provide? Or none?

         else:
             revid1 = self.revs[1].revid
             revid2 = self.revs[0].revid
         diff_rel_url = url_for('frontend.diff', item_name=self.item_name, rev1=revid1, rev2=revid2)
         return urljoin(domain, diff_rel_url)

[Thomas.J.Waldmann, 2013/08/19 21:41:10]

why is that needed?

[ana.balica, 2013/08/21 14:03:26]

What exactly? The whole point of the function? urljoining?

 
     def render_templates(self):
         """ Render both plain text and HTML templates by providing all the
         necessary arguments
 
         :return: tuple consisting of plain text and HTML notification message
          """
-        wiki_name = self.app.cfg.interwikiname
         content_diff = self.get_content_diff()
         meta_diff = self.get_meta_diff()
         meta_diff_txt = list(make_text_diff(meta_diff))
         domain = self.app.cfg.interwiki_map[self.app.cfg.interwikiname]
-        unsubscribe_url = urljoin(domain, url_for('subscribe_item',
-                                                           item_name=self.item_name))
-        change_action = self.change_actions[self.action]
+        unsubscribe_url = urljoin(domain, url_for('frontend.subscribe_item',
+                                                  item_name=self.item_name))
         diff_url = self.generate_diff_url(domain)
-        item_url = urljoin(domain, url_for('show_item', item_name=self.item_name))
+        item_url = urljoin(domain, url_for('frontend.show_item', item_name=self.item_name))
         if self.comment:
             comment = self.meta["comment"]
         else:
             comment = self.revs[0].meta["comment"]
         txt_template = render_template(Notification.txt_template,
-                                       wiki_name=wiki_name,
-                                       page_name=self.item_name,
-                                       change_action=change_action,
-                                       user_name=flaskg.user.name0,
+                                       wiki_name=self.wiki_name,
+                                       notification_sentence=self.notification_sentence[self.action],
                                        diff_url=diff_url,
                                        item_url=item_url,
                                        comment=comment,
                                        content_diff_=content_diff,
                                        meta_diff_=meta_diff_txt,
                                        unsubscribe_url=unsubscribe_url,
                                        )
         html_template = render_template(Notification.html_template,
-                                        wiki_name=wiki_name,
-                                        page_name=self.item_name,
-                                        change_action=change_action,
-                                        user_name=flaskg.user.name0,
+                                        wiki_name=self.wiki_name,
+                                        notification_sentence=self.notification_sentence[self.action],
                                         diff_url=diff_url,
                                         item_url=item_url,
                                         comment=comment,
                                         content_diff_=content_diff,
                                         meta_diff_=meta_diff,
                                         unsubscribe_url=unsubscribe_url,
         )
         return txt_template, html_template
 
 
 def get_item_last_revisions(app, item_name):
     """ Get 2 or less most recent item revisions from the index
 
     :param app: local proxy app
     :param item_name: the name of the item
     :return: a list of revisions
     """
     terms = [Term(WIKINAME, app.cfg.interwikiname), Term(NAME_EXACT, item_name), ]
     query = And(terms)
     return list(
         flaskg.storage.search(query, idx_name=ALL_REVS, sortedby=[MTIME],
                               reverse=True, limit=2))