~txerpa-openerp/openobject-client-web/txerpa

###############################################################################

#

#  Copyright (C) 2007-TODAY OpenERP SA. All Rights Reserved.

#

#  $Id$

#

#  Developed by OpenERP (http://openerp.com) and Axelor (http://axelor.com).

#

#  The OpenERP web client is distributed under the "OpenERP Public License".

#  It's based on Mozilla Public License Version (MPL) 1.1 with following 

#  restrictions:

#

#  -   All names, links and logos of OpenERP must be kept as in original

#      distribution without any changes in all software screens, especially

#      in start-up page and the software header, even if the application

#      source code has been changed or updated or code has been added.

#

#  You can see the MPL licence at: http://www.mozilla.org/MPL/MPL-1.1.html

#

###############################################################################

import base64,os,re

import cherrypy

from openerp import utils, widgets as tw, validators

from openerp.controllers import SecuredController

from openerp.utils import rpc, common, TinyDict, TinyForm, expr_eval

from error_page import _ep

from openobject.tools import expose, redirect, validate, error_handler, exception_handler

import openobject

import openobject.paths

import simplejson

def make_domain(name, value, kind='char'):

    """A helper function to generate domain for the given name, value pair.

    Will be used for search window...

    """

    if isinstance(value, int) and not isinstance(value, bool):

        return [(name, '=', value)]

    if isinstance(value, dict):

        start = value.get('from')

        end = value.get('to')

        if start and end:

            return [(name, '>=', start), (name, '<=', end)]

        elif start:

            return [(name, '>=', start)]

        elif end:

            return [(name, '<=', end)]

        return None

    if kind == "selection" and value:

        return [(name, '=', value)]

    if isinstance(value, basestring) and value:

        return [(name, 'ilike', value)]

    if isinstance(value, bool) and value:

        return [(name, '=', 1)]

    return []

def search(model, offset=0, limit=50, domain=[], context={}, data={}):

    """A helper function to search for data by given criteria.

    @param model: the resource on which to make search

    @param offset: offset from when to start search

    @param limit: limit of the search result

    @param domain: the domain (search criteria)

    @param context: the context

    @param data: the form data

    @returns dict with list of ids count of records etc.

    """

    domain = domain or []

    context = context or {}

    data = data or {}

    proxy = rpc.RPCProxy(model)

    fields = proxy.fields_get([], rpc.session.context)

    search_domain = domain[:]

    search_data = {}

    for k, v in data.items():

        t = fields.get(k, {}).get('type', 'char')

        t = make_domain(k, v, t)

        if t:

            search_domain += t

            search_data[k] = v

    l = limit

    o = offset

    if l < 1: l = 50

    if o < 0: o = 0

    ctx = rpc.session.context.copy()

    ctx.update(context)

    ids = proxy.search(search_domain, o, l, 0, ctx)

    if len(ids) < l:

        count = len(ids)

    else:

        count = proxy.search_count(search_domain, ctx)

    if isinstance(ids, list):

        count = len(ids)

    return dict(model=model, ids=ids, count=count, offset=o, limit=l,

                search_domain=search_domain, search_data=search_data)

def get_validation_schema(self):

    """Generate validation schema for the given Form instance. Should be used

    to validate form inputs with @validate decorator.

    @param self: and instance of Form

    @returns a new instance of Form with validation schema

    """

    kw = cherrypy.request.params

    params, data = TinyDict.split(kw)

    # bypass validations, if saving from button in non-editable view

    if params.button and not params.editable and params.id:

        return None

    cherrypy.request.terp_validators = {}

    cherrypy.request.terp_data = data

    params.nodefault = True

    form = self.create_form(params)

    cherrypy.request.terp_form = form

    vals = cherrypy.request.terp_validators

    keys = vals.keys()

    for k in keys:

        if k not in kw:

            vals.pop(k)

    form.validator = openobject.validators.Schema(**vals)

    return form

def default_error_handler(self, tg_errors=None, **kw):

    """ Error handler for the given Form instance.

    @param self: an instance for Form

    @param tg_errors: errors

    """

    params, data = TinyDict.split(kw)

    return self.create(params, tg_errors=tg_errors)

def default_exception_handler(self, tg_exceptions=None, **kw):

    """ Exception handler for the given Form instance.

    @param self: an instance for Form

    @param tg_exceptions: exception

    """

    # let _cp_on_error handle the exception

    raise tg_exceptions

class Form(SecuredController):

    _cp_path = "/openerp/form"

    def create_form(self, params, tg_errors=None):

        if tg_errors:

            return cherrypy.request.terp_form

        cherrypy.session['params'] = params

        params.offset = params.offset or 0

        params.limit = params.limit or 50

        params.count = params.count or 0

        params.view_type = params.view_type or params.view_mode[0]

        return tw.form_view.ViewForm(params, name="view_form", action="/openerp/form/save")

    @expose(template="/openerp/controllers/templates/form.mako")

    def create(self, params, tg_errors=None):

        params.view_type = params.view_type or params.view_mode[0]

        if params.view_type == 'tree':

            params.editable = True

        target = getattr(cherrypy.request, '_terp_view_target', None)

        if target == 'new':

            # for target='new' keep orignal value as '_terp_view_target' hidden field,

            # that's necessary to keep wizard without toolbar button (new, save, pager, etc...)

            hidden_fields = params.hidden_fields or []

            hidden_fields.append(tw.form.Hidden(name='_terp_view_target', default=ustr(target)))

            params.hidden_fields = hidden_fields

        form = self.create_form(params, tg_errors)

        if not tg_errors:

            try:

                cherrypy.session.pop('remember_notebooks')

            except:

                self.reset_notebooks()

        editable = form.screen.editable

        mode = form.screen.view_type

        id = form.screen.id

        buttons = TinyDict()    # toolbar

        buttons.new = (not editable or mode == 'tree') and mode != 'diagram'

        buttons.edit = not editable and (mode == 'form' or mode == 'diagram')

        buttons.save = editable and mode == 'form'

        buttons.cancel = editable and mode == 'form'

        buttons.delete = not editable and mode == 'form'

        buttons.pager =  mode == 'form' or mode == 'diagram'# Pager will visible in edit and non-edit mode in form view.

        buttons.can_attach = id and mode == 'form'

        buttons.i18n = not editable and mode == 'form'

        buttons.show_grid = mode == 'diagram'

        buttons.create_node = mode == 'diagram' and editable

        from openerp.widgets import get_registered_views

        buttons.views = []

        for kind, view in get_registered_views():

            buttons.views.append(dict(kind=kind, name=view.name, desc=view.desc))

        buttons.toolbar = (target != 'new' and not form.is_dashboard) or mode == 'diagram'

        pager = None

        if buttons.pager:

            pager = tw.pager.Pager(id=form.screen.id, ids=form.screen.ids, offset=form.screen.offset,

                                   limit=form.screen.limit, count=form.screen.count, view_type=params.view_type)

        can_shortcut = self.can_shortcut_create()

        shortcut_ids = []

        if cherrypy.session.get('terp_shortcuts'):

            for sc in cherrypy.session['terp_shortcuts']:

                if isinstance(sc['res_id'], tuple):

                    shortcut_ids.append(sc['res_id'][0])

                else:

                    shortcut_ids.append(sc['res_id'])        

        title = form.screen.string or ''

        display_name = {}

        if params.view_type == 'form':

            if params.id:

                if form.screen.view.get('fields') and form.screen.view['fields'].get('name'):

                    display_name = {'field': form.screen.view['fields']['name']['string'], 'value': ustr(form.screen.view['fields']['name']['value'])}

                    title= ustr(display_name['field']) + ':' + ustr(display_name['value'])

        elif params.view_type == 'diagram':

            display_name = {'field': form.screen.view['fields']['name']['string'], 'value': rpc.RPCProxy(params.model).name_get(form.screen.id, rpc.session.context)[0][1]}

        # For Corporate Intelligence visibility.

        obj_process = rpc.RPCProxy('ir.model').search([('model', '=', 'process.process')]) or None

        tips = params.display_menu_tip

        if params.view_type == params.view_mode[0] and tips:

            tips = tips

        is_dashboard = form.screen.is_dashboard or False

        return dict(form=form, pager=pager, buttons=buttons, path=self.path, can_shortcut=can_shortcut, shortcut_ids=shortcut_ids, display_name=display_name, title=title, tips=tips, obj_process=obj_process, is_dashboard=is_dashboard)

    @expose('json', methods=('POST',))

    def close_or_disable_tips(self):

        rpc.RPCProxy('res.users').write(rpc.session.uid,{'menu_tips':False}, rpc.session.context)

    def _read_form(self, context, count, domain, filter_domain, id, ids, kw,

                   limit, model, offset, search_data, search_domain, source,

                   view_ids, view_mode, view_type, notebook_tab, o2m_edit=False,

                   editable=False):

        """ Extract parameters for form reading/creation common to both

        self.edit and self.view

        """

        params, data = TinyDict.split({'_terp_model': model,

                                       '_terp_id' : id,

                                       '_terp_ids' : ids,

                                       '_terp_view_ids' : view_ids,

                                       '_terp_view_mode' : view_mode,

                                       '_terp_view_type' : view_type,

                                       '_terp_source' : source,

                                       '_terp_domain' : domain,

                                       '_terp_context' : context,

                                       '_terp_offset': offset,

                                       '_terp_limit': limit,

                                       '_terp_count': count,

                                       '_terp_search_domain': search_domain,

                                       '_terp_search_data': search_data,

                                       '_terp_filter_domain': filter_domain,

                                       '_terp_notebook_tab': notebook_tab})

        params.o2m_edit = o2m_edit

        params.editable = editable

        params.action_id = kw.get('action_id')

        if kw.get('default_date'):

            params.context.update({'default_date' : kw['default_date']})

        cherrypy.request._terp_view_target = kw.get('target')

        if params.view_mode and 'form' not in params.view_mode:

            params.view_type = params.view_mode[-1]

        if params.view_type == 'tree':

            params.view_type = 'form'

        if not params.ids:

            params.offset = 0

        return params

    @expose()

    def edit(self, model, id=False, ids=None, view_ids=None,

             view_mode=['form', 'tree'], view_type='form', source=None, domain=[], context={},

             offset=0, limit=50, count=0, search_domain=None,

             search_data=None, filter_domain=None, o2m_edit=False, **kw):

        notebook_tab = kw.get('notebook_tab') or 0

        params = self._read_form(context, count, domain, filter_domain, id,

                                 ids, kw, limit, model, offset, search_data,

                                 search_domain, source, view_ids, view_mode,

                                 view_type, notebook_tab, o2m_edit=o2m_edit, editable=True)

        if not params.ids:

            params.count = 0

        # On New O2M

        if params.source:

            current = TinyDict()

            current.id = False

            params[params.source] = current

        return self.create(params)

    @expose()

    def view(self, model, id, ids=None, view_ids=None,

             view_mode=['form', 'tree'], view_type='form', source=None, domain=[], context={},

             offset=0, limit=50, count=0, search_domain=None,

             search_data=None, filter_domain=None, **kw):

        notebook_tab = kw.get('notebook_tab') or 0

        params = self._read_form(context, count, domain, filter_domain, id,

                                 ids, kw, limit, model, offset, search_data,

                                 search_domain, source, view_ids, view_mode,

                                 view_type, notebook_tab)

        if not params.ids:

            params.count = 1

        return self.create(params)

    @expose()

    def cancel(self, **kw):

        params, data = TinyDict.split(kw)

        if params.button:

            res = self.button_action(params)

            if res:

                return res

            raise redirect('/')

        if not params.id and params.ids:

            params.id = params.ids[0]

        if params.id and params.editable:

            raise redirect(self.path + "/view", model=params.model,

                                               id=params.id,

                                               ids=ustr(params.ids),

                                               view_ids=ustr(params.view_ids),

                                               view_mode=ustr(params.view_mode),

                                               domain=ustr(params.domain),

                                               context=ustr(params.context),

                                               offset=params.offset,

                                               limit=params.limit,

                                               count=params.count,

                                               search_domain=ustr(params.search_domain),

                                               search_data = ustr(params.search_data),

                                               filter_domain= ustr(params.filter_domain))

        params.view_type = 'tree'

        return self.create(params)

    @expose(methods=('POST',))

    @validate(form=get_validation_schema)

    @error_handler(default_error_handler)

    @exception_handler(default_exception_handler)

    def save(self, terp_save_only=False, **kw):

        """Controller method to save/button actions...

        @param tg_errors: TG special arg, used durring validation

        @param kw: keyword arguments

        @return: form view

        """

        params, data = TinyDict.split(kw)

        # remember the current page (tab) of notebooks

        cherrypy.session['remember_notebooks'] = True

        Model = rpc.RPCProxy(params.model)

        # bypass save, for button action in non-editable view

        if params.editable:

            if not params.id:

                if params.default_o2m:

                    data.update(params.default_o2m)

                ctx = dict((params.context or {}), **rpc.session.context)

                params.id = int(Model.create(data, ctx))

                params.ids = (params.ids or []) + [params.id]

                params.count += 1

            else:

                ctx = dict((params.context or {}), **rpc.session.context)

                original_data = Model.read(params.id, data.keys(), ctx)

                modified = {}

                if original_data and isinstance(original_data, dict):

                    for field, original_value in original_data.iteritems():

                        if isinstance(original_value, tuple):

                            original_data[field] = original_value[0]

                        if field in data and data[field] != original_data[field]:

                            #When field is many2many at that time following code will be applied

                            if isinstance(data[field], list) and isinstance(data[field][0][2], list):

                                if sorted(data[field][0][2]) != sorted(original_data[field]):

                                    modified[field] = data[field]

                            else:

                                modified[field] = data[field]

                    ctx = utils.context_with_concurrency_info(params.context, params.concurrency_info)

                    if modified:

                        Model.write([params.id], modified, ctx)

                else:

                    ctx = utils.context_with_concurrency_info(params.context, params.concurrency_info)

                    if data:

                        Model.write([params.id], data, ctx)

            tw.ConcurrencyInfo.update(

                params.model, Model.read([params.id], ['__last_update'], ctx)

            )

        cherrypy.request.params = params

        button = params.button

        # perform button action

        if params.button:

            res = self.button_action(params)

            if res:

                return res

        current = params.chain_get(params.source or '')

        if current:

            current.id = None

        elif not button:

            params.editable = False

        if terp_save_only:

            return dict(params=params, data=data)

        def get_params(p, f):

            pp = p.chain_get(f)

            px = rpc.RPCProxy(p.model)

            _ids = pp.ids

            _all = px.read([p.id], [f])[0][f]

            _new = [i for i in _all if i not in _ids]

            pp.ids = _all

            if _new:

                pp.id = _new[0]

            return pp

        if params.source and len(params.source.split("/")) > 1:

            path = params.source.split("/")

            p = params

            for f in path:

                p = get_params(p, f)

            return self.create(params)

        args = {'model': params.model,

                'id': params.id,

                'ids': ustr(params.ids),

                'view_ids': ustr(params.view_ids),

                'view_mode': ustr(params.view_mode),

                'domain': ustr(params.domain),

                'context': ustr(params.context),

                'offset': params.offset,

                'limit': params.limit,

                'count': params.count,

                'search_domain': ustr(params.search_domain),

                'search_data': ustr(params.search_data),

                'filter_domain': ustr(params.filter_domain),

                'notebook_tab': params.notebook_tab}

        if params.view_target and params.view_target == 'new':

            # within a wizard popup dialog - keep the orignal target mode

            # (here target='new' will hide toolbar buttons (new, save, pager, etc..)

            args['target'] = 'new'

        if params.o2m_edit:

            # hack to avoid creating new record line when editing o2m inline:

            # by default one2many.mako is going to fetch a new line (.create)

            # on /edit

            args['o2m_edit'] = "1"

        if params.editable or params.source or params.return_edit:

            raise redirect(self.path + '/edit', source=params.source, **args)

        raise redirect(self.path + '/view', **args)

    def button_action_cancel(self, name, params):

        if name:

            params.button.btype = "object"

            params.id = False

            res = self.button_action(params)

            if res:

                return res

        import actions

        return actions.close_popup(reload=False)

    def button_action_save(self, _, params):

        params.id = False

        params.button = None

    def button_action_workflow(self, name, params):

        model, id, _, _ = self._get_button_infos(params)

        res = rpc.session.execute('object', 'exec_workflow', model, name, id)

        if isinstance(res, dict):

            import actions

            return actions.execute(res, ids=[id])

        params.button = None

    def button_action_object(self, name, params):

        model, id, ids, ctx = self._get_button_infos(params)

        res = rpc.session.execute('object', 'execute', model, name, ids, ctx)

        # after installation of modules (esp. initial) we may

        # need values from the global context for some contexts & domains (e.g.

        # leads) => installer wizards are generally postfixed by '.installer'

        # so use this characteristic to setup context reloads

        if model.endswith('.installer'):

            rpc.session.context_reload()

        if isinstance(res, dict):

            import actions

            return actions.execute(res, ids=[id], context=ctx)

        params.button = None

    def button_action_action(self, name, params):

        model, id, ids, ctx = self._get_button_infos(params)

        import actions

        action_id = int(name)

        action_type = actions.get_action_type(action_id)

        if action_type == 'ir.actions.wizard':

            cherrypy.session['wizard_parent_form'] = self.path

            cherrypy.session['wizard_parent_params'] = params.parent_params or params

        res = actions.execute_by_id(

                action_id, type=action_type,

                model=model, id=id, ids=ids,

                context=ctx or {})

        if res:

            return res

        params.button = None

    BUTTON_ACTIONS_BY_BTYPE = {

        'action': button_action_action,