views.py

"""Specific views and actions for application using the Comment entity type

:organization: Logilab
:copyright: 2003-2009 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr
"""
__docformat__ = "restructuredtext en"

from itertools import count

from logilab.mtconverter import html_escape
from logilab.common.decorators import monkeypatch

from simplejson import dumps

from cubicweb.selectors import (one_line_rset, but_etype, implements,
                                has_permission, relation_possible, yes)
from cubicweb.view import EntityView
from cubicweb.selectors import match_kwargs, accept
from cubicweb.common.uilib import rql_for_eid, cut, safe_cut, ajax_replace_url
from cubicweb.common.mixins import TreeViewMixIn
from cubicweb.web import stdmsgs
from cubicweb.web.action import (LinkToEntityAction, Action)
from cubicweb.web.views import baseviews, baseforms
from cubicweb.web.views.editforms import AutomaticEntityForm
from cubicweb.web.views.boxes import EditBox
from cubicweb.web.component import EntityVComponent
from cubicweb.web.views.basecontrollers import JSonController

_ = unicode

AutomaticEntityForm.rcategories.set_rtag('generic', 'comments', 'subject')
AutomaticEntityForm.rcategories.set_rtag('generic', 'comments', 'object')
EditBox.rmode.set_rtag('link', 'comments', 'subject')
EditBox.rmode.set_rtag('link', 'comments', 'object')

# comment views ###############################################################

class CommentPrimaryView(baseviews.PrimaryView):
    __select__ = implements('Comment')
    
    def cell_call(self, row, col):
        self.req.add_css('cubes.comment.css')
        entity = self.complete_entity(row, col)
        # display text, author and creation date
        self.w(u'<div class="comment">')
        self.w(u'<div class="commentInfo">')
        # do not try to display creator when you're not allowed to see EUsers
        if entity.creator:
            authorlink = entity.creator.view('oneline')
            self.w(u'%s %s\n' % (self.req._('written by'), authorlink))
        self.w(self.format_date(entity.creation_date))
        # commented object
        if entity.comments:
            self.w(u",  %s " % self.req._('comments'))
            entity.comments[0].view('oneline', w=self.w)
            self.w(u"\n")
        # don't include responses in this view, since the comment section
        # component will display them
        self.w(u'</div>\n')
        self.w(u'<div class="commentBody">%s</div>\n' % entity.printable_value('content'))
        # XXX attribute generated_by added by email component
        if hasattr(self, 'generated_by') and self.generated_by:
            origlink = '<a href="%s">%s</a>' % (self.generated_by[0].absolute_url(),
                                                self.generated_by[0].dc_type().lower())
            txt = self.req._('this comment has been generated from this %s') % origlink
            self.w(u'<div class="commentBottom">%s</div>\n' % txt)
        self.w(u'</div>\n')

    

class CommentSecondaryView(baseviews.SecondaryView):
    __select__ = implements('Comment')
    
    def cell_call(self, row, col, **kwargs):
        entity = self.entity(row, col)
        root = entity.root()
        self.w(u'[<a href="%s">#%s</a>] '
               % (html_escape(root.absolute_url()), root.eid))
        maxsize = self.req.property_value('navigation.short-line-size')
        maxsize = maxsize - len(str(root.eid))
        content = entity.printable_value('content', format='text/plain')
        content = html_escape(cut(content, maxsize))
        self.w(u'<a href="%s">#%s <i>%s</i></a>\n' % (html_escape(entity.absolute_url()),
                                                      entity.eid, content))


class CommentOneLineView(CommentSecondaryView):
    id = 'oneline'


class CommentTreeItemView(baseviews.ListItemView):
    id = 'treeitem'
    __select__ = implements('Comment')
    
    def cell_call(self, row, col, **kwargs):
        _ = self.req._
        self.req.add_js('cubicweb.ajax.js')
        self.req.add_css('cubes.comment.css')
        entity = self.entity(row, col)
        diem = self.format_date(entity.creation_date)
        action = self.vreg.select_action('reply_comment', self.req, self.rset,
                                         row=row)
        editaction = self.vreg.select_action('edit_comment', self.req, self.rset,
                                             row=row)
        if action is None:
            reply = u''
        else:
            url = ajax_replace_url('comment%sHolder' % entity.eid,
                                   rql_for_eid(entity.eid), 'inlinecomment')
            reply = ' | <a href="%s">%s</a>' % (html_escape(url), _(action.title))
        if editaction is None:
            edit = u''
        else:
            url = ajax_replace_url('comment%s' % entity.eid,
                                   rql_for_eid(entity.eid), 'editcomment')
            edit = ' | <a href="%s">%s</a>' % (html_escape(url), _(editaction.title))
        text = entity.printable_value('content')
        if not kwargs.get('full'):
            maxsize = self.req.property_value('navigation.short-line-size')
            text = safe_cut(text, maxsize)	 
        self.w(u'<div class="commentInfo">')
        self.w(self.format_date(entity.creation_date))
        if entity.creator:
            authorlink = entity.creator.view('oneline')
            self.w(u', %s <span class="author">%s</span> \n' % (_('written by'), authorlink,))
        self.w(u'<span class="replyto"> %s </span>' % reply)
        self.w(u'<span class="replyto"> %s </span>' % edit)
        self.w(u'</div>\n')
        self.w(u'<div class="commentBody">%s</div>\n' % text)
        self.w(u'<div id="comment%sHolder"></div>' % entity.eid)


class CommentThreadView(TreeViewMixIn, baseviews.ListView):
    """a recursive tree view"""
    __select__ = implements('Comment')
    title = _('thread view')
        
    def open_item(self, entity):
        self.w(u'<li id="comment%s" class="comment">\n' % entity.eid)


# comment edition views #######################################################

class InlineCommentView(EntityView):
    id = 'inlinecomment'
    __select__ = yes() # explicit call when it makes sense

    def cell_call(self, row, col):
        entity = self.entity(row, col)
        self.wview('inlinecommentform', None, commented=entity)
        

class InlineCommentForm(baseforms.CreationForm):
    id = 'inlinecommentform'
    __select__ = match_kwargs('commented') # explicit call when it makes sense
    
    title = None # hidden
    
    EDITION_BODY = u"""
    
 <div id="comment%(eid)sSlot">%(attrform)s
 <div id="comment%(eid)sbbar"><button onclick="%(onclick)s" tabindex="%(tabindex1)s">%(validate)s</button>
  <button onclick="%(oncancelclick)s" tabindex="%(tabindex2)s">%(cancel)s</button>
 
 </div>
</div>
"""
    def call(self, commented):
        self.req.add_js('cubicweb.ajax.js','cubes.comment.js')
        newcomment = self.vreg.etype_class('Comment')(self.req, None, None)
        newcomment.eid = 'INLINE'
        # hack to avoid tabindex conflicts caused by Ajax requests
        self.req.next_tabindex = count(20).next
        self._hiddens = []
        attrform = self.attributes_form(newcomment, {})
        onclick = html_escape("processComment(%s, 'add_comment')" % dumps(commented.eid))
        oncancelclick = html_escape("processComment(%s, '')" % dumps(commented.eid))
        self.w(self.EDITION_BODY % dict(attrform=attrform, onclick=onclick, oncancelclick=oncancelclick,
                                        eid=commented.eid,
                                        tabindex1=self.req.next_tabindex(),
                                        tabindex2=self.req.next_tabindex(),
                                        validate=self.req._(stdmsgs.BUTTON_OK),
                                        cancel=self.req._(stdmsgs.BUTTON_CANCEL)))

    def editable_attributes(self, entity):
        return [(rschema, x) for rschema, _, x in entity.relations_by_category(('primary'), 'add')
                if rschema.is_final() and rschema != 'eid']

 # don't show comments relation in edition forms
try:
    baseforms.EditionForm.skip_relations.add('comments')
except AttributeError:
    pass # XXX bw compat cubicweb < 2.49

class InlineEditCommentForm(baseforms.EditionForm):
    id = 'editcomment'
    __select__ = implements('Comment')
    
    EDITION_BODY = u"""
 <div id="comment%(eid)sSlot">%(attrform)s
  <div>
   <button onclick="%(onclick)s" tabindex="%(tabindex1)s">%(validate)s</button>
   <button onclick="%(oncancelclick)s" tabindex="%(tabindex2)s">%(cancel)s</button>
  </div>
</div>
"""
    def cell_call(self, row, col):
        self.req.add_js( ('cubicweb.ajax.js', 'cubes.comment.js') )
        # hack to avoid tabindex conflicts caused by Ajax request
        self.req.next_tabindex = count(20).next
        comment = self.entity(row, col)
        self._hiddens = []
        attrform = self.attributes_form(comment, {'tab_class': ''})
        onclick = html_escape("processComment(%s, 'edit_comment')" % dumps(comment.eid))
        oncancelclick = html_escape("processComment(%s, '')" % dumps(comment.eid))
        self.w(self.EDITION_BODY % dict(attrform=attrform, onclick=onclick, oncancelclick=oncancelclick,
                                        eid=comment.eid,
                                        tabindex1=self.req.next_tabindex(),
                                        tabindex2=self.req.next_tabindex(),
                                        validate=self.req._(stdmsgs.BUTTON_OK),
                                        cancel=self.req._(stdmsgs.BUTTON_CANCEL)))
                                        
    def editable_attributes(self, entity):
        return [(rschema, x) for rschema, _, x in entity.relations_by_category(('primary'), 'add')
                  if rschema.is_final() and rschema != 'eid']

    
# comment component ###########################################################

class CommentSectionVComponent(EntityVComponent):
    """a component to display a <div> html section including comments
    related to an object
    """
    id = 'commentsection'
    __select__ = EntityVComponent.__select__ & relation_possible('comments', 'object', 'Comment')

    context = 'navcontentbottom'

    def cell_call(self, row, col, view=None, orderby='diem'):
        req = self.req
        req.add_js( ('cubicweb.ajax.js', 'cubes.comment.js') )
        eid = self.rset[row][col]
        self.w(u'<div id="%s" class="%s" cubicweb:rooteid="%s">' % (
            self.div_id(), self.div_class(), eid))
        action = self.vreg.select_action('reply_comment', req, self.rset, row=0)
        if action is not None:
            url = ajax_replace_url('comment%sHolder' % eid, rql_for_eid(eid), 'inlinecomment')
            reply = u' (<a href="%s">%s</a>)' % (url, req._(action.title))
            if req.use_fckeditor() and req.property_value('ui.default-text-format') == 'text/html':
                req.fckeditor_config()
        else:
            reply = u''        
        if orderby == 'author':
            rql = u'Any C,CD,CC,CCF,U,UL,US,UF ORDERBY UL WHERE C is Comment, '\
                  'C comments X, C creation_date CD, C content CC, C content_format CCF, ' \
                  'C created_by U?, U login UL, U firstname UF, U surname US, X eid %(x)s'
        else: # orderby == 'diem'
            rql = u'Any C,CD,CC,CCF,U,UL,US,UF ORDERBY CD WHERE C is Comment, '\
                  'C comments X, C creation_date CD, C content CC, C content_format CCF, ' \
                  'C created_by U?, U login UL, U firstname UF, U surname US, X eid %(x)s'
        rset = req.execute(rql, {'x': eid}, 'x')
        if rset.rowcount:
            self.w(u'<h4>%s</h4>%s' % (req._('Comment_plural'), reply))
            self.w(u'<div id="comment%sHolder"></div>' % eid)
            self.w(u'<ul class="comment">')
            for i in xrange(rset.rowcount):
                self.wview('tree', rset, row=i, full=True)
            self.w(u'</ul>')
        elif reply:
            self.w(reply)
            self.w(u'<div id="comment%sHolder"></div>' % eid)
        self.w(u'</div>')

baseviews.PRIMARY_SKIP_RELS.add('comments') # displayed by the above component


# comment actions #############################################################

class ReplyCommentAction(LinkToEntityAction):
    id = 'reply_comment'
    __select__ = LinkToEntityAction.__select__ & implements('Comment')

    etype = 'Comment'
    rtype = 'comments'
    target = 'subject'
    
    title = _('reply to this comment')
    category = 'hidden'
    order = 111

    def url(self):
        rset = self.rset
        comment = rset.get_entity(self.row or 0, self.col or 0)
        linkto = '%s:%s:%s' % (self.rtype, comment.eid, self.target)
        return self.build_url(vid='creation', etype=self.etype,
                              __linkto=linkto,
                              __redirectpath=comment.root().rest_path(),
                              __redirectvid=self.req.form.get('vid', ''))


class AddCommentAction(LinkToEntityAction):
    """add comment is like reply for everything but Comment"""
    id = 'reply_comment'
    __select__ = LinkToEntityAction.__select__ & but_etype('Comment')

    etype = 'Comment'
    rtype = 'comments'
    role = 'object'
    
    title = _('add comment')
    category = 'hidden'
    order = 111


class EditCommentAction(Action):
    id = 'edit_comment'
    __select__ = one_line_rset() & implements('Comment') & has_permission('update')
    
    title = _('edit comment')
    category = 'hidden'
    order = 110

    def url(self):
        return self.build_url(rql=self.rset.printable_rql(), vid='edition')


# add some comments related methods to the Jsoncontroller #####################

@monkeypatch(JSonController)
def js_add_comment(self, commented, text, format):
    rql = 'INSERT Comment C: C content %(text)s, C content_format %(format)s, C comments X WHERE X eid %(x)s'
    rset = self.req.execute(rql, {'format' : format, 'text' : text, 'x' : commented}, 'x')
    return u''

@monkeypatch(JSonController)
def js_edit_comment(self, comment, text, format):
    rql = 'SET C content %(text)s, C content_format %(format)s WHERE C eid %(x)s'
    rset = self.req.execute(rql, {'format' : format, 'text' : text, 'x' : comment}, 'x')
    return u''