1 # copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

     2 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr

     3 #

     4 # This file is part of CubicWeb.

     5 #

     6 # CubicWeb is free software: you can redistribute it and/or modify it under the

     7 # terms of the GNU Lesser General Public License as published by the Free

     8 # Software Foundation, either version 2.1 of the License, or (at your option)

     9 # any later version.

    10 #

    11 # CubicWeb is distributed in the hope that it will be useful, but WITHOUT

    12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

    13 # FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more

    14 # details.

    15 #

    16 # You should have received a copy of the GNU Lesser General Public License along

    17 # with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

    18 #

    19 # (disable pylint msg for client obj access to protected member as in obj._cw)

    20 # pylint: disable=W0212

    21 """The ``ajaxcontroller`` module defines the :class:`AjaxController`

    22 controller and the ``ajax-funcs`` cubicweb registry.

    23 

    24 .. autoclass:: cubicweb.web.views.ajaxcontroller.AjaxController

    25    :members:

    26 

    27 ``ajax-funcs`` registry hosts exposed remote functions, that is

    28 functions that can be called from the javascript world.

    29 

    30 To register a new remote function, either decorate your function

    31 with the :ref:`cubicweb.web.views.ajaxcontroller.ajaxfunc` decorator:

    32 

    33 .. sourcecode:: python

    34 

    35     from cubicweb.selectors import mactch_user_groups

    36     from cubicweb.web.views.ajaxcontroller import ajaxfunc

    37 

    38     @ajaxfunc(output_type='json', selector=match_user_groups('managers'))

    39     def list_users(self):

    40         return [u for (u,) in self._cw.execute('Any L WHERE U login L')]

    41 

    42 or inherit from :class:`cubicwbe.web.views.ajaxcontroller.AjaxFunction` and

    43 implement the ``__call__`` method:

    44 

    45 .. sourcecode:: python

    46 

    47     from cubicweb.web.views.ajaxcontroller import AjaxFunction

    48     class ListUser(AjaxFunction):

    49         __regid__ = 'list_users' # __regid__ is the name of the exposed function

    50         __select__ = match_user_groups('managers')

    51         output_type = 'json'

    52 

    53         def __call__(self):

    54             return [u for (u, ) in self._cw.execute('Any L WHERE U login L')]

    55 

    56 

    57 .. autoclass:: cubicweb.web.views.ajaxcontroller.AjaxFunction

    58    :members:

    59 

    60 .. autofunction:: cubicweb.web.views.ajaxcontroller.ajaxfunc

    61 

    62 """

    63 

    64 __docformat__ = "restructuredtext en"

    65 

    66 from functools import partial

    67 

    68 from logilab.common.date import strptime

    69 from logilab.common.deprecation import deprecated

    70 

    71 from cubicweb import ObjectNotFound, NoSelectableObject

    72 from cubicweb.appobject import AppObject

    73 from cubicweb.selectors import yes

    74 from cubicweb.utils import json, json_dumps, UStringIO

    75 from cubicweb.uilib import exc_message

    76 from cubicweb.web import RemoteCallFailed, DirectResponse

    77 from cubicweb.web.controller import Controller

    78 from cubicweb.web.views import vid_from_rset

    79 from cubicweb.web.views import basecontrollers

    80 

    81 

    82 def optional_kwargs(extraargs):

    83     if extraargs is None:

    84         return {}

    85     # we receive unicode keys which is not supported by the **syntax

    86     return dict((str(key), value) for key, value in extraargs.iteritems())

    87 

    88 

    89 class AjaxController(Controller):

    90     """AjaxController handles ajax remote calls from javascript

    91 

    92     The following javascript function call:

    93 

    94     .. sourcecode:: javascript

    95 

    96       var d = asyncRemoteExec('foo', 12, "hello");

    97       d.addCallback(function(result) {

    98           alert('server response is: ' + result);

    99       });

   100 

   101     will generate an ajax HTTP GET on the following url::

   102 

   103         BASE_URL/ajax?fname=foo&arg=12&arg="hello"

   104 

   105     The AjaxController controller will therefore be selected to handle those URLs

   106     and will itself select the :class:`cubicweb.web.views.ajaxcontroller.AjaxFunction`

   107     matching the *fname* parameter.

   108     """

   109     __regid__ = 'ajax'

   110 

   111     def publish(self, rset=None):

   112         self._cw.ajax_request = True

   113         try:

   114             fname = self._cw.form['fname']

   115         except KeyError:

   116             raise RemoteCallFailed('no method specified')

   117         try:

   118             func = self._cw.vreg['ajax-func'].select(fname, self._cw)

   119         except ObjectNotFound:

   120             # function not found in the registry, inspect JSonController for

   121             # backward compatibility

   122             try:

   123                 func = getattr(basecontrollers.JSonController, 'js_%s' % fname).im_func

   124                 func = partial(func, self)

   125             except AttributeError:

   126                 raise RemoteCallFailed('no %s method' % fname)

   127             else:

   128                 self.warning('remote function %s found on JSonController, '

   129                              'use AjaxFunction / @ajaxfunc instead', fname)

   130         except NoSelectableObject:

   131             raise RemoteCallFailed('method %s not available in this context'

   132                                    % fname)

   133         # no <arg> attribute means the callback takes no argument

   134         args = self._cw.form.get('arg', ())

   135         if not isinstance(args, (list, tuple)):

   136             args = (args,)

   137         try:

   138             args = [json.loads(arg) for arg in args]

   139         except ValueError, exc:

   140             self.exception('error while decoding json arguments for '

   141                            'js_%s: %s (err: %s)', fname, args, exc)

   142             raise RemoteCallFailed(exc_message(exc, self._cw.encoding))

   143         try:

   144             result = func(*args)

   145         except (RemoteCallFailed, DirectResponse):

   146             raise

   147         except Exception, exc:

   148             self.exception('an exception occurred while calling js_%s(%s): %s',

   149                            fname, args, exc)

   150             raise RemoteCallFailed(exc_message(exc, self._cw.encoding))

   151         if result is None:

   152             return ''

   153         # get unicode on @htmlize methods, encoded string on @jsonize methods

   154         elif isinstance(result, unicode):

   155             return result.encode(self._cw.encoding)

   156         return result

   157 

   158 class AjaxFunction(AppObject):

   159     """

   160     Attributes on this base class are:

   161 

   162     :attr: `check_pageid`: make sure the pageid received is valid before proceeding

   163     :attr: `output_type`:

   164 

   165            - *None*: no processing, no change on content-type

   166 

   167            - *json*: serialize with `json_dumps` and set *application/json*

   168                      content-type

   169 

   170            - *xhtml*: wrap result in an XML node and forces HTML / XHTML

   171                       content-type (use ``_cw.html_content_type()``)

   172 

   173     """

   174     __registry__ = 'ajax-func'

   175     __select__ = yes()

   176     __abstract__ = True

   177 

   178     check_pageid = False

   179     output_type = None

   180 

   181     @staticmethod

   182     def _rebuild_posted_form(names, values, action=None):

   183         form = {}

   184         for name, value in zip(names, values):

   185             # remove possible __action_xxx inputs

   186             if name.startswith('__action'):

   187                 if action is None:

   188                     # strip '__action_' to get the actual action name

   189                     action = name[9:]

   190                 continue

   191             # form.setdefault(name, []).append(value)

   192             if name in form:

   193                 curvalue = form[name]

   194                 if isinstance(curvalue, list):

   195                     curvalue.append(value)

   196                 else:

   197                     form[name] = [curvalue, value]

   198             else:

   199                 form[name] = value

   200         # simulate click on __action_%s button to help the controller

   201         if action:

   202             form['__action_%s' % action] = u'whatever'

   203         return form

   204 

   205     def validate_form(self, action, names, values):

   206         self._cw.form = self._rebuild_posted_form(names, values, action)

   207         return basecontrollers._validate_form(self._cw, self._cw.vreg)

   208 

   209     def _exec(self, rql, args=None, rocheck=True):

   210         """json mode: execute RQL and return resultset as json"""

   211         rql = rql.strip()

   212         if rql.startswith('rql:'):

   213             rql = rql[4:]

   214         if rocheck:

   215             self._cw.ensure_ro_rql(rql)

   216         try:

   217             return self._cw.execute(rql, args)

   218         except Exception, ex:

   219             self.exception("error in _exec(rql=%s): %s", rql, ex)

   220             return None

   221         return None

   222 

   223     def _call_view(self, view, paginate=False, **kwargs):

   224         divid = self._cw.form.get('divid')

   225         # we need to call pagination before with the stream set

   226         try:

   227             stream = view.set_stream()

   228         except AttributeError:

   229             stream = UStringIO()

   230             kwargs['w'] = stream.write

   231             assert not paginate

   232         if divid == 'pageContent':

   233             # ensure divid isn't reused by the view (e.g. table view)

   234             del self._cw.form['divid']

   235             # mimick main template behaviour

   236             stream.write(u'<div id="pageContent">')

   237             vtitle = self._cw.form.get('vtitle')

   238             if vtitle:

   239                 stream.write(u'<h1 class="vtitle">%s</h1>\n' % vtitle)

   240             paginate = True

   241         nav_html = UStringIO()

   242         if paginate and not view.handle_pagination:

   243             view.paginate(w=nav_html.write)

   244         stream.write(nav_html.getvalue())

   245         if divid == 'pageContent':

   246             stream.write(u'<div id="contentmain">')

   247         view.render(**kwargs)

   248         extresources = self._cw.html_headers.getvalue(skiphead=True)

   249         if extresources:

   250             stream.write(u'<div class="ajaxHtmlHead">\n') # XXX use a widget ?

   251             stream.write(extresources)

   252             stream.write(u'</div>\n')

   253         if divid == 'pageContent':

   254             stream.write(u'</div>%s</div>' % nav_html.getvalue())

   255         return stream.getvalue()

   256 

   257 

   258 def _ajaxfunc_factory(implementation, selector=yes(), _output_type=None,

   259                       _check_pageid=False, regid=None):

   260     """converts a standard python function into an AjaxFunction appobject"""

   261     class AnAjaxFunc(AjaxFunction):

   262         __regid__ = regid or implementation.__name__

   263         __select__ = selector

   264         output_type = _output_type

   265         check_pageid = _check_pageid

   266 

   267         def serialize(self, content):

   268             if self.output_type is None:

   269                 return content

   270             elif self.output_type == 'xhtml':

   271                 self._cw.set_content_type(self._cw.html_content_type())

   272                 return ''.join((self._cw.document_surrounding_div(),

   273                                 content.strip(), u'</div>'))

   274             elif self.output_type == 'json':

   275                 self._cw.set_content_type('application/json')

   276                 return json_dumps(content)

   277             raise RemoteCallFailed('no serializer found for output type %s'

   278                                    % self.output_type)

   279 

   280         def __call__(self, *args, **kwargs):

   281             if self.check_pageid:

   282                 data = self._cw.session.data.get(self._cw.pageid)

   283                 if data is None:

   284                     raise RemoteCallFailed(self._cw._('pageid-not-found'))

   285             return self.serialize(implementation(self, *args, **kwargs))

   286     AnAjaxFunc.__name__ = implementation.__name__

   287     # make sure __module__ refers to the original module otherwise

   288     # vreg.register(obj) will ignore ``obj``.

   289     AnAjaxFunc.__module__ = implementation.__module__

   290     return AnAjaxFunc

   291 

   292 

   293 def ajaxfunc(implementation=None, selector=yes(), output_type=None,

   294              check_pageid=False, regid=None):

   295     """promote a standard function to an ``AjaxFunction`` appobject.

   296 

   297     All parameters are optional:

   298 

   299     :param selector: a custom selector object if needed, default is ``yes()``

   300 

   301     :param output_type: either None, 'json' or 'xhtml' to customize output

   302                         content-type. Default is None

   303 

   304     :param check_pageid: whether the function requires a valid `pageid` or not

   305                          to proceed. Default is False.

   306 

   307     :param regid: a custom __regid__ for the created ``AjaxFunction`` object. Default

   308                   is to keep the wrapped function name.

   309 

   310     ``ajaxfunc`` can be used both as a standalone decorator:

   311 

   312     .. sourcecode:: python

   313 

   314         @ajaxfunc

   315         def my_function(self):

   316             return 42

   317 

   318     or as a parametrizable decorator:

   319 

   320     .. sourcecode:: python

   321 

   322         @ajaxfunc(output_type='json')

   323         def my_function(self):

   324             return 42

   325 

   326     """

   327     # if used as a parametrized decorator (e.g. @ajaxfunc(output_type='json'))

   328     if implementation is None:

   329         def _decorator(func):

   330             return _ajaxfunc_factory(func, selector=selector,

   331                                      _output_type=output_type,

   332                                      _check_pageid=check_pageid,

   333                                      regid=regid)

   334         return _decorator

   335     # else, used as a standalone decorator (i.e. @ajaxfunc)

   336     return _ajaxfunc_factory(implementation, selector=selector,

   337                              _output_type=output_type,

   338                              _check_pageid=check_pageid, regid=regid)

   339 

   340 

   341 

   342 ###############################################################################

   343 #  Cubicweb remote functions for :                                            #

   344 #  - appobject rendering                                                      #

   345 #  - user / page session data management                                      #

   346 ###############################################################################

   347 @ajaxfunc(output_type='xhtml')

   348 def view(self):

   349     # XXX try to use the page-content template

   350     req = self._cw

   351     rql = req.form.get('rql')

   352     if rql:

   353         rset = self._exec(rql)

   354     elif 'eid' in req.form:

   355         rset = self._cw.eid_rset(req.form['eid'])

   356     else:

   357         rset = None

   358     vid = req.form.get('vid') or vid_from_rset(req, rset, self._cw.vreg.schema)

   359     try:

   360         viewobj = self._cw.vreg['views'].select(vid, req, rset=rset)

   361     except NoSelectableObject:

   362         vid = req.form.get('fallbackvid', 'noresult')

   363         viewobj = self._cw.vreg['views'].select(vid, req, rset=rset)

   364     viewobj.set_http_cache_headers()

   365     req.validate_cache()

   366     return self._call_view(viewobj, paginate=req.form.pop('paginate', False))

   367 

   368 

   369 @ajaxfunc(output_type='xhtml')

   370 def component(self, compid, rql, registry='components', extraargs=None):

   371     if rql:

   372         rset = self._exec(rql)

   373     else:

   374         rset = None

   375     # XXX while it sounds good, addition of the try/except below cause pb:

   376     # when filtering using facets return an empty rset, the edition box

   377     # isn't anymore selectable, as expected. The pb is that with the

   378     # try/except below, we see a "an error occurred" message in the ui, while

   379     # we don't see it without it. Proper fix would probably be to deal with

   380     # this by allowing facet handling code to tell to js_component that such

   381     # error is expected and should'nt be reported.

   382     #try:

   383     comp = self._cw.vreg[registry].select(compid, self._cw, rset=rset,

   384                                           **optional_kwargs(extraargs))

   385     #except NoSelectableObject:

   386     #    raise RemoteCallFailed('unselectable')

   387     return self._call_view(comp, **optional_kwargs(extraargs))

   388 

   389 @ajaxfunc(output_type='xhtml')

   390 def render(self, registry, oid, eid=None,

   391               selectargs=None, renderargs=None):

   392     if eid is not None:

   393         rset = self._cw.eid_rset(eid)

   394         # XXX set row=0

   395     elif self._cw.form.get('rql'):

   396         rset = self._cw.execute(self._cw.form['rql'])

   397     else:

   398         rset = None

   399     viewobj = self._cw.vreg[registry].select(oid, self._cw, rset=rset,

   400                                              **optional_kwargs(selectargs))

   401     return self._call_view(viewobj, **optional_kwargs(renderargs))

   402 

   403 

   404 @ajaxfunc(output_type='json')

   405 def i18n(self, msgids):

   406     """returns the translation of `msgid`"""

   407     return [self._cw._(msgid) for msgid in msgids]

   408 

   409 @ajaxfunc(output_type='json')

   410 def format_date(self, strdate):

   411     """returns the formatted date for `msgid`"""

   412     date = strptime(strdate, '%Y-%m-%d %H:%M:%S')

   413     return self._cw.format_date(date)

   414 

   415 @ajaxfunc(output_type='json')

   416 def external_resource(self, resource):

   417     """returns the URL of the external resource named `resource`"""

   418     return self._cw.uiprops[resource]

   419 

   420 @ajaxfunc(output_type='json', check_pageid=True)

   421 def user_callback(self, cbname):

   422     """execute the previously registered user callback `cbname`.

   423 

   424     If matching callback is not found, return None

   425     """

   426     page_data = self._cw.session.data.get(self._cw.pageid, {})

   427     try:

   428         cb = page_data[cbname]

   429     except KeyError:

   430         self.warning('unable to find user callback %s', cbname)

   431         return None

   432     return cb(self._cw)

   433 

   434 

   435 @ajaxfunc

   436 def unregister_user_callback(self, cbname):

   437     """unregister user callback `cbname`"""

   438     self._cw.unregister_callback(self._cw.pageid, cbname)

   439 

   440 @ajaxfunc

   441 def unload_page_data(self):

   442     """remove user's session data associated to current pageid"""

   443     self._cw.session.data.pop(self._cw.pageid, None)

   444 

   445 @ajaxfunc(output_type='json')

   446 @deprecated("[3.13] use jQuery.cookie(cookiename, cookievalue, {path: '/'}) in js land instead")

   447 def set_cookie(self, cookiename, cookievalue):

   448     """generates the Set-Cookie HTTP reponse header corresponding

   449     to `cookiename` / `cookievalue`.

   450     """

   451     cookiename, cookievalue = str(cookiename), str(cookievalue)

   452     self._cw.set_cookie(cookiename, cookievalue)