openerp/addons/base/ir/ir_actions.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2014 OpenERP S.A. <http://www.openerp.com>
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21
  22 from functools import partial
  23 import logging
  24 import operator
  25 import os
  26 import time
  27 import datetime
  28 import dateutil
  29
  30 import openerp
  31 from openerp import SUPERUSER_ID
  32 from openerp import tools
  33 from openerp import workflow
  34 from openerp.osv import fields, osv
  35 from openerp.osv.orm import browse_record
  36 import openerp.report.interface
  37 from openerp.report.report_sxw import report_sxw, report_rml
  38 from openerp.tools.safe_eval import safe_eval as eval
  39 from openerp.tools.translate import _
  40 import openerp.workflow
  41
  42 _logger = logging.getLogger(__name__)
  43
  44 class actions(osv.osv):
  45     _name = 'ir.actions.actions'
  46     _table = 'ir_actions'
  47     _order = 'name'
  48     _columns = {
  49         'name': fields.char('Name', size=64, required=True),
  50         'type': fields.char('Action Type', required=True, size=32),
  51         'usage': fields.char('Action Usage', size=32),
  52         'help': fields.text('Action description',
  53             help='Optional help text for the users with a description of the target view, such as its usage and purpose.',
  54             translate=True),
  55     }
  56     _defaults = {
  57         'usage': lambda *a: False,
  58     }
  59
  60
  61 class ir_actions_report_xml(osv.osv):
  62
  63     def _report_content(self, cursor, user, ids, name, arg, context=None):
  64         res = {}
  65         for report in self.browse(cursor, user, ids, context=context):
  66             data = report[name + '_data']
  67             if not data and report[name[:-8]]:
  68                 fp = None
  69                 try:
  70                     fp = tools.file_open(report[name[:-8]], mode='rb')
  71                     data = fp.read()
  72                 except:
  73                     data = False
  74                 finally:
  75                     if fp:
  76                         fp.close()
  77             res[report.id] = data
  78         return res
  79
  80     def _report_content_inv(self, cursor, user, id, name, value, arg, context=None):
  81         self.write(cursor, user, id, {name+'_data': value}, context=context)
  82
  83     def _report_sxw(self, cursor, user, ids, name, arg, context=None):
  84         res = {}
  85         for report in self.browse(cursor, user, ids, context=context):
  86             if report.report_rml:
  87                 res[report.id] = report.report_rml.replace('.rml', '.sxw')
  88             else:
  89                 res[report.id] = False
  90         return res
  91
  92     def _lookup_report(self, cr, name):
  93         """
  94         Look up a report definition.
  95         """
  96         opj = os.path.join
  97
  98         # First lookup in the deprecated place, because if the report definition
  99         # has not been updated, it is more likely the correct definition is there.
 100         # Only reports with custom parser sepcified in Python are still there.
 101         if 'report.' + name in openerp.report.interface.report_int._reports:
 102             new_report = openerp.report.interface.report_int._reports['report.' + name]
 103         else:
 104             cr.execute("SELECT * FROM ir_act_report_xml WHERE report_name=%s", (name,))
 105             r = cr.dictfetchone()
 106             if r:
 107                 if r['report_rml'] or r['report_rml_content_data']:
 108                     if r['parser']:
 109                         kwargs = { 'parser': operator.attrgetter(r['parser'])(openerp.addons) }
 110                     else:
 111                         kwargs = {}
 112                     new_report = report_sxw('report.'+r['report_name'], r['model'],
 113                             opj('addons',r['report_rml'] or '/'), header=r['header'], register=False, **kwargs)
 114                 elif r['report_xsl'] and r['report_xml']:
 115                     new_report = report_rml('report.'+r['report_name'], r['model'],
 116                             opj('addons',r['report_xml']),
 117                             r['report_xsl'] and opj('addons',r['report_xsl']), register=False)
 118                 else:
 119                     raise Exception, "Unhandled report type: %s" % r
 120             else:
 121                 raise Exception, "Required report does not exist: %s" % r
 122
 123         return new_report
 124
 125     def render_report(self, cr, uid, res_ids, name, data, context=None):
 126         """
 127         Look up a report definition and render the report for the provided IDs.
 128         """
 129         new_report = self._lookup_report(cr, name)
 130         return new_report.create(cr, uid, res_ids, data, context)
 131
 132     _name = 'ir.actions.report.xml'
 133     _inherit = 'ir.actions.actions'
 134     _table = 'ir_act_report_xml'
 135     _sequence = 'ir_actions_id_seq'
 136     _order = 'name'
 137     _columns = {
 138         'type': fields.char('Action Type', size=32, required=True),
 139         'name': fields.char('Name', size=64, required=True, translate=True),
 140
 141         'model': fields.char('Model', required=True),
 142         'report_type': fields.char('Report Type', required=True, help="Report Type: qweb-html, qweb-pdf, custom"),
 143         'report_name': fields.char('Service Name', required=True, help="URL of the report is /report/<service name>/<ids>"),
 144         'groups_id': fields.many2many('res.groups', 'res_groups_report_rel', 'uid', 'gid', 'Groups'),
 145
 146         # options
 147         'multi': fields.boolean('On Multiple Doc.', help="If set to true, the action will not be displayed on the right toolbar of a form view."),
 148         'attachment_use': fields.boolean('Reload from Attachment', help='If you check this, then the second time the user prints with same attachment name, it returns the previous report.'),
 149         'attachment': fields.char('Save as Attachment Prefix', size=128, help='This is the filename of the attachment used to store the printing result. Keep empty to not save the printed reports. You can use a python expression with the object and time variables.'),
 150
 151         # Deprecated rml stuff
 152         'usage': fields.char('Action Usage', size=32),
 153         'header': fields.boolean('Add RML Header', help="Add or not the corporate RML header"),
 154         'parser': fields.char('Parser Class'),
 155         'auto': fields.boolean('Custom Python Parser'),
 156
 157         'report_xsl': fields.char('XSL Path'),
 158         'report_xml': fields.char('XML Path'),
 159
 160         'report_rml': fields.char('Main Report File Path', help="The path to the main report file (depending on Report Type) or NULL if the content is in another data field"),
 161         'report_file': fields.related('report_rml', type="char", required=False, readonly=False, string='Report File', help="The path to the main report file (depending on Report Type) or NULL if the content is in another field", store=True),
 162
 163         'report_sxw': fields.function(_report_sxw, type='char', string='SXW Path'),
 164         'report_sxw_content_data': fields.binary('SXW Content'),
 165         'report_rml_content_data': fields.binary('RML Content'),
 166         'report_sxw_content': fields.function(_report_content, fnct_inv=_report_content_inv, type='binary', string='SXW Content',),
 167         'report_rml_content': fields.function(_report_content, fnct_inv=_report_content_inv, type='binary', string='RML Content'),
 168     }
 169     _defaults = {
 170         'type': 'ir.actions.report.xml',
 171         'multi': False,
 172         'auto': True,
 173         'header': True,
 174         'report_sxw_content': False,
 175         'report_type': 'qweb-pdf',
 176         'attachment': False,
 177     }
 178
 179
 180 class ir_actions_act_window(osv.osv):
 181     _name = 'ir.actions.act_window'
 182     _table = 'ir_act_window'
 183     _inherit = 'ir.actions.actions'
 184     _sequence = 'ir_actions_id_seq'
 185     _order = 'name'
 186
 187     def _check_model(self, cr, uid, ids, context=None):
 188         for action in self.browse(cr, uid, ids, context):
 189             if action.res_model not in self.pool:
 190                 return False
 191             if action.src_model and action.src_model not in self.pool:
 192                 return False
 193         return True
 194
 195     def _invalid_model_msg(self, cr, uid, ids, context=None):
 196         return _('Invalid model name in the action definition.')
 197
 198     _constraints = [
 199         (_check_model, _invalid_model_msg, ['res_model','src_model'])
 200     ]
 201
 202     def _views_get_fnc(self, cr, uid, ids, name, arg, context=None):
 203         """Returns an ordered list of the specific view modes that should be
 204            enabled when displaying the result of this action, along with the
 205            ID of the specific view to use for each mode, if any were required.
 206
 207            This function hides the logic of determining the precedence between
 208            the view_modes string, the view_ids o2m, and the view_id m2o that can
 209            be set on the action.
 210
 211            :rtype: dict in the form { action_id: list of pairs (tuples) }
 212            :return: { action_id: [(view_id, view_mode), ...], ... }, where view_mode
 213                     is one of the possible values for ir.ui.view.type and view_id
 214                     is the ID of a specific view to use for this mode, or False for
 215                     the default one.
 216         """
 217         res = {}
 218         for act in self.browse(cr, uid, ids):
 219             res[act.id] = [(view.view_id.id, view.view_mode) for view in act.view_ids]
 220             view_ids_modes = [view.view_mode for view in act.view_ids]
 221             modes = act.view_mode.split(',')
 222             missing_modes = [mode for mode in modes if mode not in view_ids_modes]
 223             if missing_modes:
 224                 if act.view_id and act.view_id.type in missing_modes:
 225                     # reorder missing modes to put view_id first if present
 226                     missing_modes.remove(act.view_id.type)
 227                     res[act.id].append((act.view_id.id, act.view_id.type))
 228                 res[act.id].extend([(False, mode) for mode in missing_modes])
 229         return res
 230
 231     def _search_view(self, cr, uid, ids, name, arg, context=None):
 232         res = {}
 233         for act in self.browse(cr, uid, ids, context=context):
 234             field_get = self.pool[act.res_model].fields_view_get(cr, uid,
 235                 act.search_view_id and act.search_view_id.id or False,
 236                 'search', context=context)
 237             res[act.id] = str(field_get)
 238         return res
 239
 240     _columns = {
 241         'name': fields.char('Action Name', size=64, translate=True),
 242         'type': fields.char('Action Type', size=32, required=True),
 243         'view_id': fields.many2one('ir.ui.view', 'View Ref.', ondelete='cascade'),
 244         'domain': fields.char('Domain Value',
 245             help="Optional domain filtering of the destination data, as a Python expression"),
 246         'context': fields.char('Context Value', required=True,
 247             help="Context dictionary as Python expression, empty by default (Default: {})"),
 248         'res_id': fields.integer('Record ID', help="Database ID of record to open in form view, when ``view_mode`` is set to 'form' only"),
 249         'res_model': fields.char('Destination Model', size=64, required=True,
 250             help="Model name of the object to open in the view window"),
 251         'src_model': fields.char('Source Model', size=64,
 252             help="Optional model name of the objects on which this action should be visible"),
 253         'target': fields.selection([('current','Current Window'),('new','New Window'),('inline','Inline Edit'),('inlineview','Inline View')], 'Target Window'),
 254         'view_mode': fields.char('View Mode', size=250, required=True,
 255             help="Comma-separated list of allowed view modes, such as 'form', 'tree', 'calendar', etc. (Default: tree,form)"),
 256         'view_type': fields.selection((('tree','Tree'),('form','Form')), string='View Type', required=True,
 257             help="View type: Tree type to use for the tree view, set to 'tree' for a hierarchical tree view, or 'form' for a regular list view"),
 258         'usage': fields.char('Action Usage', size=32,
 259             help="Used to filter menu and home actions from the user form."),
 260         'view_ids': fields.one2many('ir.actions.act_window.view', 'act_window_id', 'Views'),
 261         'views': fields.function(_views_get_fnc, type='binary', string='Views',
 262                help="This function field computes the ordered list of views that should be enabled " \
 263                     "when displaying the result of an action, federating view mode, views and " \
 264                     "reference view. The result is returned as an ordered list of pairs (view_id,view_mode)."),
 265         'limit': fields.integer('Limit', help='Default limit for the list view'),
 266         'auto_refresh': fields.integer('Auto-Refresh',
 267             help='Add an auto-refresh on the view'),
 268         'groups_id': fields.many2many('res.groups', 'ir_act_window_group_rel',
 269             'act_id', 'gid', 'Groups'),
 270         'search_view_id': fields.many2one('ir.ui.view', 'Search View Ref.'),
 271         'filter': fields.boolean('Filter'),
 272         'auto_search':fields.boolean('Auto Search'),
 273         'search_view' : fields.function(_search_view, type='text', string='Search View'),
 274         'multi': fields.boolean('Restrict to lists', help="If checked and the action is bound to a model, it will only appear in the More menu on list views"),
 275     }
 276
 277     _defaults = {
 278         'type': 'ir.actions.act_window',
 279         'view_type': 'form',
 280         'view_mode': 'tree,form',
 281         'context': '{}',
 282         'limit': 80,
 283         'target': 'current',
 284         'auto_refresh': 0,
 285         'auto_search':True,
 286         'multi': False,
 287     }
 288
 289     def read(self, cr, uid, ids, fields=None, context=None, load='_classic_read'):
 290         """ call the method get_empty_list_help of the model and set the window action help message
 291         """
 292         ids_int = isinstance(ids, (int, long))
 293         if ids_int:
 294             ids = [ids]
 295         results = super(ir_actions_act_window, self).read(cr, uid, ids, fields=fields, context=context, load=load)
 296
 297         if not fields or 'help' in fields:
 298             context = dict(context or {})
 299             eval_dict = {
 300                 'active_model': context.get('active_model'),
 301                 'active_id': context.get('active_id'),
 302                 'active_ids': context.get('active_ids'),
 303                 'uid': uid,
 304             }
 305             for res in results:
 306                 model = res.get('res_model')
 307                 if model and self.pool.get(model):
 308                     try:
 309                         with tools.mute_logger("openerp.tools.safe_eval"):
 310                             eval_context = eval(res['context'] or "{}", eval_dict) or {}
 311                     except Exception:
 312                         continue
 313                     custom_context = dict(context, **eval_context)
 314                     res['help'] = self.pool.get(model).get_empty_list_help(cr, uid, res.get('help', ""), context=custom_context)
 315         if ids_int:
 316             return results[0]
 317         return results
 318
 319     def for_xml_id(self, cr, uid, module, xml_id, context=None):
 320         """ Returns the act_window object created for the provided xml_id
 321
 322         :param module: the module the act_window originates in
 323         :param xml_id: the namespace-less id of the action (the @id
 324                        attribute from the XML file)
 325         :return: A read() view of the ir.actions.act_window
 326         """
 327         dataobj = self.pool.get('ir.model.data')
 328         data_id = dataobj._get_id (cr, SUPERUSER_ID, module, xml_id)
 329         res_id = dataobj.browse(cr, uid, data_id, context).res_id
 330         return self.read(cr, uid, res_id, [], context)
 331
 332 VIEW_TYPES = [
 333     ('tree', 'Tree'),
 334     ('form', 'Form'),
 335     ('graph', 'Graph'),
 336     ('calendar', 'Calendar'),
 337     ('gantt', 'Gantt'),
 338     ('kanban', 'Kanban')]
 339 class ir_actions_act_window_view(osv.osv):
 340     _name = 'ir.actions.act_window.view'
 341     _table = 'ir_act_window_view'
 342     _rec_name = 'view_id'
 343     _order = 'sequence'
 344     _columns = {
 345         'sequence': fields.integer('Sequence'),
 346         'view_id': fields.many2one('ir.ui.view', 'View'),
 347         'view_mode': fields.selection(VIEW_TYPES, string='View Type', required=True),
 348         'act_window_id': fields.many2one('ir.actions.act_window', 'Action', ondelete='cascade'),
 349         'multi': fields.boolean('On Multiple Doc.',
 350             help="If set to true, the action will not be displayed on the right toolbar of a form view."),
 351     }
 352     _defaults = {
 353         'multi': False,
 354     }
 355     def _auto_init(self, cr, context=None):
 356         super(ir_actions_act_window_view, self)._auto_init(cr, context)
 357         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'act_window_view_unique_mode_per_action\'')
 358         if not cr.fetchone():
 359             cr.execute('CREATE UNIQUE INDEX act_window_view_unique_mode_per_action ON ir_act_window_view (act_window_id, view_mode)')
 360
 361
 362 class ir_actions_act_window_close(osv.osv):
 363     _name = 'ir.actions.act_window_close'
 364     _inherit = 'ir.actions.actions'
 365     _table = 'ir_actions'
 366     _defaults = {
 367         'type': 'ir.actions.act_window_close',
 368     }
 369
 370
 371 class ir_actions_act_url(osv.osv):
 372     _name = 'ir.actions.act_url'
 373     _table = 'ir_act_url'
 374     _inherit = 'ir.actions.actions'
 375     _sequence = 'ir_actions_id_seq'
 376     _order = 'name'
 377     _columns = {
 378         'name': fields.char('Action Name', size=64, translate=True),
 379         'type': fields.char('Action Type', size=32, required=True),
 380         'url': fields.text('Action URL',required=True),
 381         'target': fields.selection((
 382             ('new', 'New Window'),
 383             ('self', 'This Window')),
 384             'Action Target', required=True
 385         )
 386     }
 387     _defaults = {
 388         'type': 'ir.actions.act_url',
 389         'target': 'new'
 390     }
 391
 392
 393 class ir_actions_server(osv.osv):
 394     """ Server actions model. Server action work on a base model and offer various
 395     type of actions that can be executed automatically, for example using base
 396     action rules, of manually, by adding the action in the 'More' contextual
 397     menu.
 398
 399     Since OpenERP 8.0 a button 'Create Menu Action' button is available on the
 400     action form view. It creates an entry in the More menu of the base model.
 401     This allows to create server actions and run them in mass mode easily through
 402     the interface.
 403
 404     The available actions are :
 405
 406     - 'Execute Python Code': a block of python code that will be executed
 407     - 'Trigger a Workflow Signal': send a signal to a workflow
 408     - 'Run a Client Action': choose a client action to launch
 409     - 'Create or Copy a new Record': create a new record with new values, or
 410       copy an existing record in your database
 411     - 'Write on a Record': update the values of a record
 412     - 'Execute several actions': define an action that triggers several other
 413       server actions
 414     """
 415     _name = 'ir.actions.server'
 416     _table = 'ir_act_server'
 417     _inherit = 'ir.actions.actions'
 418     _sequence = 'ir_actions_id_seq'
 419     _order = 'sequence,name'
 420
 421     def _select_objects(self, cr, uid, context=None):
 422         model_pool = self.pool.get('ir.model')
 423         ids = model_pool.search(cr, uid, [], limit=None)
 424         res = model_pool.read(cr, uid, ids, ['model', 'name'])
 425         return [(r['model'], r['name']) for r in res] + [('', '')]
 426
 427     def _get_states(self, cr, uid, context=None):
 428         """ Override me in order to add new states in the server action. Please
 429         note that the added key length should not be higher than already-existing
 430         ones. """
 431         return [('code', 'Execute Python Code'),
 432                 ('trigger', 'Trigger a Workflow Signal'),
 433                 ('client_action', 'Run a Client Action'),
 434                 ('object_create', 'Create or Copy a new Record'),
 435                 ('object_write', 'Write on a Record'),
 436                 ('multi', 'Execute several actions')]
 437
 438     def _get_states_wrapper(self, cr, uid, context=None):
 439         return self._get_states(cr, uid, context)
 440
 441     _columns = {
 442         'name': fields.char('Action Name', required=True, size=64, translate=True),
 443         'condition': fields.char('Condition',
 444                                  help="Condition verified before executing the server action. If it "
 445                                  "is not verified, the action will not be executed. The condition is "
 446                                  "a Python expression, like 'object.list_price > 5000'. A void "
 447                                  "condition is considered as always True. Help about python expression "
 448                                  "is given in the help tab."),
 449         'state': fields.selection(_get_states_wrapper, 'Action To Do', required=True,
 450                                   help="Type of server action. The following values are available:\n"
 451                                   "- 'Execute Python Code': a block of python code that will be executed\n"
 452                                   "- 'Trigger a Workflow Signal': send a signal to a workflow\n"
 453                                   "- 'Run a Client Action': choose a client action to launch\n"
 454                                   "- 'Create or Copy a new Record': create a new record with new values, or copy an existing record in your database\n"
 455                                   "- 'Write on a Record': update the values of a record\n"
 456                                   "- 'Execute several actions': define an action that triggers several other server actions\n"
 457                                   "- 'Send Email': automatically send an email (available in email_template)"),
 458         'usage': fields.char('Action Usage', size=32),
 459         'type': fields.char('Action Type', size=32, required=True),
 460         # Generic
 461         'sequence': fields.integer('Sequence',
 462                                    help="When dealing with multiple actions, the execution order is "
 463                                    "based on the sequence. Low number means high priority."),
 464         'model_id': fields.many2one('ir.model', 'Base Model', required=True, ondelete='cascade',
 465                                     help="Base model on which the server action runs."),
 466         'menu_ir_values_id': fields.many2one('ir.values', 'More Menu entry', readonly=True,
 467                                              help='More menu entry.'),
 468         # Client Action
 469         'action_id': fields.many2one('ir.actions.actions', 'Client Action',
 470                                      help="Select the client action that has to be executed."),
 471         # Python code
 472         'code': fields.text('Python Code',
 473                             help="Write Python code that the action will execute. Some variables are "
 474                             "available for use; help about pyhon expression is given in the help tab."),
 475         # Workflow signal
 476         'use_relational_model': fields.selection([('base', 'Use the base model of the action'),
 477                                                   ('relational', 'Use a relation field on the base model')],
 478                                                  string='Target Model', required=True),
 479         'wkf_transition_id': fields.many2one('workflow.transition', string='Signal to Trigger',
 480                                              help="Select the workflow signal to trigger."),
 481         'wkf_model_id': fields.many2one('ir.model', 'Target Model',
 482                                         help="The model that will receive the workflow signal. Note that it should have a workflow associated with it."),
 483         'wkf_model_name': fields.related('wkf_model_id', 'model', type='char', string='Target Model Name', store=True, readonly=True),
 484         'wkf_field_id': fields.many2one('ir.model.fields', string='Relation Field',
 485                                         oldname='trigger_obj_id',
 486                                         help="The field on the current object that links to the target object record (must be a many2one, or an integer field with the record ID)"),
 487         # Multi
 488         'child_ids': fields.many2many('ir.actions.server', 'rel_server_actions',
 489                                       'server_id', 'action_id',
 490                                       string='Child Actions',
 491                                       help='Child server actions that will be executed. Note that the last return returned action value will be used as global return value.'),
 492         # Create/Copy/Write
 493         'use_create': fields.selection([('new', 'Create a new record in the Base Model'),
 494                                         ('new_other', 'Create a new record in another model'),
 495                                         ('copy_current', 'Copy the current record'),
 496                                         ('copy_other', 'Choose and copy a record in the database')],
 497                                        string="Creation Policy", required=True,
 498                                        help=""),
 499         'crud_model_id': fields.many2one('ir.model', 'Target Model',
 500                                          oldname='srcmodel_id',
 501                                          help="Model for record creation / update. Set this field only to specify a different model than the base model."),
 502         'crud_model_name': fields.related('crud_model_id', 'model', type='char',
 503                                           string='Create/Write Target Model Name',
 504                                           store=True, readonly=True),
 505         'ref_object': fields.reference('Reference record', selection=_select_objects, size=128,
 506                                        oldname='copy_object'),
 507         'link_new_record': fields.boolean('Attach the new record',
 508                                           help="Check this if you want to link the newly-created record "
 509                                           "to the current record on which the server action runs."),
 510         'link_field_id': fields.many2one('ir.model.fields', 'Link using field',
 511                                          oldname='record_id',
 512                                          help="Provide the field where the record id is stored after the operations."),
 513         'use_write': fields.selection([('current', 'Update the current record'),
 514                                        ('expression', 'Update a record linked to the current record using python'),
 515                                        ('other', 'Choose and Update a record in the database')],
 516                                       string='Update Policy', required=True,
 517                                       help=""),
 518         'write_expression': fields.char('Expression',
 519                                         oldname='write_id',
 520                                         help="Provide an expression that, applied on the current record, gives the field to update."),
 521         'fields_lines': fields.one2many('ir.server.object.lines', 'server_id',
 522                                         string='Value Mapping',
 523                                         help=""),
 524
 525         # Fake fields used to implement the placeholder assistant
 526         'model_object_field': fields.many2one('ir.model.fields', string="Field",
 527                                               help="Select target field from the related document model.\n"
 528                                                    "If it is a relationship field you will be able to select "
 529                                                    "a target field at the destination of the relationship."),
 530         'sub_object': fields.many2one('ir.model', 'Sub-model', readonly=True,
 531                                       help="When a relationship field is selected as first field, "
 532                                            "this field shows the document model the relationship goes to."),
 533         'sub_model_object_field': fields.many2one('ir.model.fields', 'Sub-field',
 534                                                   help="When a relationship field is selected as first field, "
 535                                                        "this field lets you select the target field within the "
 536                                                        "destination document model (sub-model)."),
 537         'copyvalue': fields.char('Placeholder Expression', help="Final placeholder expression, to be copy-pasted in the desired template field."),
 538         # Fake fields used to implement the ID finding assistant
 539         'id_object': fields.reference('Record', selection=_select_objects, size=128),
 540         'id_value': fields.char('Record ID'),
 541     }
 542
 543     _defaults = {
 544         'state': 'code',
 545         'condition': 'True',
 546         'type': 'ir.actions.server',
 547         'sequence': 5,
 548         'code': """# You can use the following variables:
 549 #  - self: ORM model of the record on which the action is triggered
 550 #  - object: browse_record of the record on which the action is triggered if there is one, otherwise None
 551 #  - pool: ORM model pool (i.e. self.pool)
 552 #  - cr: database cursor
 553 #  - uid: current user id
 554 #  - context: current context
 555 #  - time: Python time module
 556 #  - workflow: Workflow engine
 557 # If you plan to return an action, assign: action = {...}""",
 558         'use_relational_model': 'base',
 559         'use_create': 'new',
 560         'use_write': 'current',
 561     }
 562
 563     def _check_expression(self, cr, uid, expression, model_id, context):
 564         """ Check python expression (condition, write_expression). Each step of
 565         the path must be a valid many2one field, or an integer field for the last
 566         step.
 567
 568         :param str expression: a python expression, beginning by 'obj' or 'object'
 569         :param int model_id: the base model of the server action
 570         :returns tuple: (is_valid, target_model_name, error_msg)
 571         """
 572         if not model_id:
 573             return (False, None, 'Your expression cannot be validated because the Base Model is not set.')
 574         # fetch current model
 575         current_model_name = self.pool.get('ir.model').browse(cr, uid, model_id, context).model
 576         # transform expression into a path that should look like 'object.many2onefield.many2onefield'
 577         path = expression.split('.')
 578         initial = path.pop(0)
 579         if initial not in ['obj', 'object']:
 580             return (False, None, 'Your expression should begin with obj or object.\nAn expression builder is available in the help tab.')
 581         # analyze path
 582         while path:
 583             step = path.pop(0)
 584             column_info = self.pool[current_model_name]._all_columns.get(step)
 585             if not column_info:
 586                 return (False, None, 'Part of the expression (%s) is not recognized as a column in the model %s.' % (step, current_model_name))
 587             column_type = column_info.column._type
 588             if column_type not in ['many2one', 'int']:
 589                 return (False, None, 'Part of the expression (%s) is not a valid column type (is %s, should be a many2one or an int)' % (step, column_type))
 590             if column_type == 'int' and path:
 591                 return (False, None, 'Part of the expression (%s) is an integer field that is only allowed at the end of an expression' % (step))
 592             if column_type == 'many2one':
 593                 current_model_name = column_info.column._obj
 594         return (True, current_model_name, None)
 595
 596     def _check_write_expression(self, cr, uid, ids, context=None):
 597         for record in self.browse(cr, uid, ids, context=context):
 598             if record.write_expression and record.model_id:
 599                 correct, model_name, message = self._check_expression(cr, uid, record.write_expression, record.model_id.id, context=context)
 600                 if not correct:
 601                     _logger.warning('Invalid expression: %s' % message)
 602                     return False
 603         return True
 604
 605     _constraints = [
 606         (_check_write_expression,
 607             'Incorrect Write Record Expression',
 608             ['write_expression']),
 609         (partial(osv.Model._check_m2m_recursion, field_name='child_ids'),
 610             'Recursion found in child server actions',
 611             ['child_ids']),
 612     ]
 613
 614     def on_change_model_id(self, cr, uid, ids, model_id, wkf_model_id, crud_model_id, context=None):
 615         """ When changing the action base model, reset workflow and crud config
 616         to ease value coherence. """
 617         values = {
 618             'use_create': 'new',
 619             'use_write': 'current',
 620             'use_relational_model': 'base',
 621             'wkf_model_id': model_id,
 622             'wkf_field_id': False,
 623             'crud_model_id': model_id,
 624         }
 625         return {'value': values}
 626
 627     def on_change_wkf_wonfig(self, cr, uid, ids, use_relational_model, wkf_field_id, wkf_model_id, model_id, context=None):
 628         """ Update workflow type configuration
 629
 630          - update the workflow model (for base (model_id) /relational (field.relation))
 631          - update wkf_transition_id to False if workflow model changes, to force
 632            the user to choose a new one
 633         """
 634         values = {}
 635         if use_relational_model == 'relational' and wkf_field_id:
 636             field = self.pool['ir.model.fields'].browse(cr, uid, wkf_field_id, context=context)
 637             new_wkf_model_id = self.pool.get('ir.model').search(cr, uid, [('model', '=', field.relation)], context=context)[0]
 638             values['wkf_model_id'] = new_wkf_model_id
 639         else:
 640             values['wkf_model_id'] = model_id
 641         return {'value': values}
 642
 643     def on_change_wkf_model_id(self, cr, uid, ids, wkf_model_id, context=None):
 644         """ When changing the workflow model, update its stored name also """
 645         wkf_model_name = False
 646         if wkf_model_id:
 647             wkf_model_name = self.pool.get('ir.model').browse(cr, uid, wkf_model_id, context).model
 648         values = {'wkf_transition_id': False, 'wkf_model_name': wkf_model_name}
 649         return {'value': values}
 650
 651     def on_change_crud_config(self, cr, uid, ids, state, use_create, use_write, ref_object, crud_model_id, model_id, context=None):
 652         """ Wrapper on CRUD-type (create or write) on_change """
 653         if state == 'object_create':
 654             return self.on_change_create_config(cr, uid, ids, use_create, ref_object, crud_model_id, model_id, context=context)
 655         elif state == 'object_write':
 656             return self.on_change_write_config(cr, uid, ids, use_write, ref_object, crud_model_id, model_id, context=context)
 657         else:
 658             return {}
 659
 660     def on_change_create_config(self, cr, uid, ids, use_create, ref_object, crud_model_id, model_id, context=None):
 661         """ When changing the object_create type configuration:
 662
 663          - `new` and `copy_current`: crud_model_id is the same as base model
 664          - `new_other`: user choose crud_model_id
 665          - `copy_other`: disassemble the reference object to have its model
 666          - if the target model has changed, then reset the link field that is
 667            probably not correct anymore
 668         """
 669         values = {}
 670         if use_create == 'new':
 671             values['crud_model_id'] = model_id
 672         elif use_create == 'new_other':
 673             pass
 674         elif use_create == 'copy_current':
 675             values['crud_model_id'] = model_id
 676         elif use_create == 'copy_other' and ref_object:
 677             ref_model, ref_id = ref_object.split(',')
 678             ref_model_id = self.pool['ir.model'].search(cr, uid, [('model', '=', ref_model)], context=context)[0]
 679             values['crud_model_id'] = ref_model_id
 680
 681         if values.get('crud_model_id') != crud_model_id:
 682             values['link_field_id'] = False
 683         return {'value': values}
 684
 685     def on_change_write_config(self, cr, uid, ids, use_write, ref_object, crud_model_id, model_id, context=None):
 686         """ When changing the object_write type configuration:
 687
 688          - `current`: crud_model_id is the same as base model
 689          - `other`: disassemble the reference object to have its model
 690          - `expression`: has its own on_change, nothing special here
 691         """
 692         values = {}
 693         if use_write == 'current':
 694             values['crud_model_id'] = model_id
 695         elif use_write == 'other' and ref_object:
 696             ref_model, ref_id = ref_object.split(',')
 697             ref_model_id = self.pool['ir.model'].search(cr, uid, [('model', '=', ref_model)], context=context)[0]
 698             values['crud_model_id'] = ref_model_id
 699         elif use_write == 'expression':
 700             pass
 701
 702         if values.get('crud_model_id') != crud_model_id:
 703             values['link_field_id'] = False
 704         return {'value': values}
 705
 706     def on_change_write_expression(self, cr, uid, ids, write_expression, model_id, context=None):
 707         """ Check the write_expression and update crud_model_id accordingly """
 708         values = {}
 709         valid, model_name, message = self._check_expression(cr, uid, write_expression, model_id, context=context)
 710         if valid:
 711             ref_model_id = self.pool['ir.model'].search(cr, uid, [('model', '=', model_name)], context=context)[0]
 712             values['crud_model_id'] = ref_model_id
 713             return {'value': values}
 714         if not message:
 715             message = 'Invalid expression'
 716         return {
 717             'warning': {
 718                 'title': 'Incorrect expression',
 719                 'message': message,
 720             }
 721         }
 722
 723     def on_change_crud_model_id(self, cr, uid, ids, crud_model_id, context=None):
 724         """ When changing the CRUD model, update its stored name also """
 725         crud_model_name = False
 726         if crud_model_id:
 727             crud_model_name = self.pool.get('ir.model').browse(cr, uid, crud_model_id, context).model
 728         values = {'link_field_id': False, 'crud_model_name': crud_model_name}
 729         return {'value': values}
 730
 731     def _build_expression(self, field_name, sub_field_name):
 732         """ Returns a placeholder expression for use in a template field,
 733         based on the values provided in the placeholder assistant.
 734
 735         :param field_name: main field name
 736         :param sub_field_name: sub field name (M2O)
 737         :return: final placeholder expression
 738         """
 739         expression = ''
 740         if field_name:
 741             expression = "object." + field_name
 742             if sub_field_name:
 743                 expression += "." + sub_field_name
 744         return expression
 745
 746     def onchange_sub_model_object_value_field(self, cr, uid, ids, model_object_field, sub_model_object_field=False, context=None):
 747         result = {
 748             'sub_object': False,
 749             'copyvalue': False,
 750             'sub_model_object_field': False,
 751         }
 752         if model_object_field:
 753             fields_obj = self.pool.get('ir.model.fields')
 754             field_value = fields_obj.browse(cr, uid, model_object_field, context)
 755             if field_value.ttype in ['many2one', 'one2many', 'many2many']:
 756                 res_ids = self.pool.get('ir.model').search(cr, uid, [('model', '=', field_value.relation)], context=context)
 757                 sub_field_value = False
 758                 if sub_model_object_field:
 759                     sub_field_value = fields_obj.browse(cr, uid, sub_model_object_field, context)
 760                 if res_ids:
 761                     result.update({
 762                         'sub_object': res_ids[0],
 763                         'copyvalue': self._build_expression(field_value.name, sub_field_value and sub_field_value.name or False),
 764                         'sub_model_object_field': sub_model_object_field or False,
 765                     })
 766             else:
 767                 result.update({
 768                     'copyvalue': self._build_expression(field_value.name, False),
 769                 })
 770         return {'value': result}
 771
 772     def onchange_id_object(self, cr, uid, ids, id_object, context=None):
 773         if id_object:
 774             ref_model, ref_id = id_object.split(',')
 775             return {'value': {'id_value': ref_id}}
 776         return {'value': {'id_value': False}}
 777
 778     def create_action(self, cr, uid, ids, context=None):
 779         """ Create a contextual action for each of the server actions. """
 780         for action in self.browse(cr, uid, ids, context=context):
 781             ir_values_id = self.pool.get('ir.values').create(cr, SUPERUSER_ID, {
 782                 'name': _('Run %s') % action.name,
 783                 'model': action.model_id.model,
 784                 'key2': 'client_action_multi',
 785                 'value': "ir.actions.server,%s" % action.id,
 786             }, context)
 787             action.write({
 788                 'menu_ir_values_id': ir_values_id,
 789             })
 790
 791         return True
 792
 793     def unlink_action(self, cr, uid, ids, context=None):
 794         """ Remove the contextual actions created for the server actions. """
 795         for action in self.browse(cr, uid, ids, context=context):
 796             if action.menu_ir_values_id:
 797                 try:
 798                     self.pool.get('ir.values').unlink(cr, SUPERUSER_ID, action.menu_ir_values_id.id, context)
 799                 except Exception:
 800                     raise osv.except_osv(_('Warning'), _('Deletion of the action record failed.'))
 801         return True
 802
 803     def run_action_client_action(self, cr, uid, action, eval_context=None, context=None):
 804         if not action.action_id:
 805             raise osv.except_osv(_('Error'), _("Please specify an action to launch!"))
 806         return self.pool[action.action_id.type].read(cr, uid, action.action_id.id, context=context)
 807
 808     def run_action_code_multi(self, cr, uid, action, eval_context=None, context=None):
 809         eval(action.code.strip(), eval_context, mode="exec", nocopy=True)  # nocopy allows to return 'action'
 810         if 'action' in eval_context:
 811             return eval_context['action']
 812
 813     def run_action_trigger(self, cr, uid, action, eval_context=None, context=None):
 814         """ Trigger a workflow signal, depending on the use_relational_model:
 815
 816          - `base`: base_model_pool.signal_<TRIGGER_NAME>(cr, uid, context.get('active_id'))
 817          - `relational`: find the related model and object, using the relational
 818            field, then target_model_pool.signal_<TRIGGER_NAME>(cr, uid, target_id)
 819         """
 820         obj_pool = self.pool[action.model_id.model]
 821         if action.use_relational_model == 'base':
 822             target_id = context.get('active_id')
 823             target_pool = obj_pool
 824         else:
 825             value = getattr(obj_pool.browse(cr, uid, context.get('active_id'), context=context), action.wkf_field_id.name)
 826             if action.wkf_field_id.ttype == 'many2one':
 827                 target_id = value.id
 828             else:
 829                 target_id = value
 830             target_pool = self.pool[action.wkf_model_id.model]
 831
 832         trigger_name = action.wkf_transition_id.signal
 833
 834         workflow.trg_validate(uid, target_pool._name, target_id, trigger_name, cr)
 835
 836     def run_action_multi(self, cr, uid, action, eval_context=None, context=None):
 837         res = []
 838         for act in action.child_ids:
 839             result = self.run(cr, uid, [act.id], context)
 840             if result:
 841                 res.append(result)
 842         return res and res[0] or False
 843
 844     def run_action_object_write(self, cr, uid, action, eval_context=None, context=None):
 845         """ Write server action.
 846
 847          - 1. evaluate the value mapping
 848          - 2. depending on the write configuration:
 849
 850           - `current`: id = active_id
 851           - `other`: id = from reference object
 852           - `expression`: id = from expression evaluation
 853         """
 854         res = {}
 855         for exp in action.fields_lines:
 856             if exp.type == 'equation':
 857                 expr = eval(exp.value, eval_context)
 858             else:
 859                 expr = exp.value
 860             res[exp.col1.name] = expr
 861
 862         if action.use_write == 'current':
 863             model = action.model_id.model
 864             ref_id = context.get('active_id')
 865         elif action.use_write == 'other':
 866             model = action.crud_model_id.model
 867             ref_id = action.ref_object.id
 868         elif action.use_write == 'expression':
 869             model = action.crud_model_id.model
 870             ref = eval(action.write_expression, eval_context)
 871             if isinstance(ref, browse_record):
 872                 ref_id = getattr(ref, 'id')
 873             else:
 874                 ref_id = int(ref)
 875
 876         obj_pool = self.pool[model]
 877         obj_pool.write(cr, uid, [ref_id], res, context=context)
 878
 879     def run_action_object_create(self, cr, uid, action, eval_context=None, context=None):
 880         """ Create and Copy server action.
 881
 882          - 1. evaluate the value mapping
 883          - 2. depending on the write configuration:
 884
 885           - `new`: new record in the base model
 886           - `copy_current`: copy the current record (id = active_id) + gives custom values
 887           - `new_other`: new record in target model
 888           - `copy_other`: copy the current record (id from reference object)
 889             + gives custom values
 890         """
 891         res = {}
 892         for exp in action.fields_lines:
 893             if exp.type == 'equation':
 894                 expr = eval(exp.value, eval_context)
 895             else:
 896                 expr = exp.value
 897             res[exp.col1.name] = expr
 898
 899         if action.use_create in ['new', 'copy_current']:
 900             model = action.model_id.model
 901         elif action.use_create in ['new_other', 'copy_other']:
 902             model = action.crud_model_id.model
 903
 904         obj_pool = self.pool[model]
 905         if action.use_create == 'copy_current':
 906             ref_id = context.get('active_id')
 907             res_id = obj_pool.copy(cr, uid, ref_id, res, context=context)
 908         elif action.use_create == 'copy_other':
 909             ref_id = action.ref_object.id
 910             res_id = obj_pool.copy(cr, uid, ref_id, res, context=context)
 911         else:
 912             res_id = obj_pool.create(cr, uid, res, context=context)
 913
 914         if action.link_new_record and action.link_field_id:
 915             self.pool[action.model_id.model].write(cr, uid, [context.get('active_id')], {action.link_field_id.name: res_id})
 916
 917     def _get_eval_context(self, cr, uid, action, context=None):
 918         """ Prepare the context used when evaluating python code, like the
 919         condition or code server actions.
 920
 921         :param action: the current server action
 922         :type action: browse record
 923         :returns: dict -- evaluation context given to (safe_)eval """
 924         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
 925         obj_pool = self.pool[action.model_id.model]
 926         obj = None
 927         if context.get('active_model') == action.model_id.model and context.get('active_id'):
 928             obj = obj_pool.browse(cr, uid, context['active_id'], context=context)
 929         return {
 930             'self': obj_pool,
 931             'object': obj,
 932             'obj': obj,
 933             'pool': self.pool,
 934             'time': time,
 935             'datetime': datetime,
 936             'dateutil': dateutil,
 937             'cr': cr,
 938             'uid': uid,
 939             'user': user,
 940             'context': context,
 941             'workflow': workflow
 942         }
 943
 944     def run(self, cr, uid, ids, context=None):
 945         """ Runs the server action. For each server action, the condition is
 946         checked. Note that a void (``False``) condition is considered as always
 947         valid. If it is verified, the run_action_<STATE> method is called. This
 948         allows easy overriding of the server actions.
 949
 950         :param dict context: context should contain following keys
 951
 952                              - active_id: id of the current object (single mode)
 953                              - active_model: current model that should equal the action's model
 954
 955                              The following keys are optional:
 956
 957                              - active_ids: ids of the current records (mass mode). If active_ids
 958                                and active_id are present, active_ids is given precedence.
 959
 960         :return: an action_id to be executed, or False is finished correctly without
 961                  return action
 962         """
 963         if context is None:
 964             context = {}
 965         res = False
 966         for action in self.browse(cr, uid, ids, context):
 967             eval_context = self._get_eval_context(cr, uid, action, context=context)
 968             condition = action.condition
 969             if condition is False:
 970                 # Void (aka False) conditions are considered as True
 971                 condition = True
 972             if hasattr(self, 'run_action_%s_multi' % action.state):
 973                 run_context = eval_context['context']
 974                 expr = eval(str(condition), eval_context)
 975                 if not expr:
 976                     continue
 977                 # call the multi method
 978                 func = getattr(self, 'run_action_%s_multi' % action.state)
 979                 res = func(cr, uid, action, eval_context=eval_context, context=run_context)
 980
 981             elif hasattr(self, 'run_action_%s' % action.state):
 982                 func = getattr(self, 'run_action_%s' % action.state)
 983                 active_id = context.get('active_id')
 984                 active_ids = context.get('active_ids', [active_id] if active_id else [])
 985                 for active_id in active_ids:
 986                     # run context dedicated to a particular active_id
 987                     run_context = dict(context, active_ids=[active_id], active_id=active_id)
 988                     eval_context["context"] = run_context
 989                     expr = eval(str(condition), eval_context)
 990                     if not expr:
 991                         continue
 992                     # call the single method related to the action: run_action_<STATE>
 993                     res = func(cr, uid, action, eval_context=eval_context, context=run_context)
 994         return res
 995
 996
 997 class ir_server_object_lines(osv.osv):
 998     _name = 'ir.server.object.lines'
 999     _sequence = 'ir_actions_id_seq'
1000     _columns = {
1001         'server_id': fields.many2one('ir.actions.server', 'Related Server Action'),
1002         'col1': fields.many2one('ir.model.fields', 'Field', required=True),
1003         'value': fields.text('Value', required=True, help="Expression containing a value specification. \n"
1004                                                           "When Formula type is selected, this field may be a Python expression "
1005                                                           " that can use the same values as for the condition field on the server action.\n"
1006                                                           "If Value type is selected, the value will be used directly without evaluation."),
1007         'type': fields.selection([
1008             ('value', 'Value'),
1009             ('equation', 'Python expression')
1010         ], 'Evaluation Type', required=True, change_default=True),
1011     }
1012     _defaults = {
1013         'type': 'value',
1014     }
1015
1016
1017 TODO_STATES = [('open', 'To Do'),
1018                ('done', 'Done')]
1019 TODO_TYPES = [('manual', 'Launch Manually'),('once', 'Launch Manually Once'),
1020               ('automatic', 'Launch Automatically')]
1021 class ir_actions_todo(osv.osv):
1022     """
1023     Configuration Wizards
1024     """
1025     _name = 'ir.actions.todo'
1026     _description = "Configuration Wizards"
1027     _columns={
1028         'action_id': fields.many2one(
1029             'ir.actions.actions', 'Action', select=True, required=True),
1030         'sequence': fields.integer('Sequence'),
1031         'state': fields.selection(TODO_STATES, string='Status', required=True),
1032         'name': fields.char('Name', size=64),
1033         'type': fields.selection(TODO_TYPES, 'Type', required=True,
1034             help="""Manual: Launched manually.
1035 Automatic: Runs whenever the system is reconfigured.
1036 Launch Manually Once: after having been launched manually, it sets automatically to Done."""),
1037         'groups_id': fields.many2many('res.groups', 'res_groups_action_rel', 'uid', 'gid', 'Groups'),
1038         'note': fields.text('Text', translate=True),
1039     }
1040     _defaults={
1041         'state': 'open',
1042         'sequence': 10,
1043         'type': 'manual',
1044     }
1045     _order="sequence,id"
1046
1047     def action_launch(self, cr, uid, ids, context=None):
1048         """ Launch Action of Wizard"""
1049         wizard_id = ids and ids[0] or False
1050         wizard = self.browse(cr, uid, wizard_id, context=context)
1051         if wizard.type in ('automatic', 'once'):
1052             wizard.write({'state': 'done'})
1053
1054         # Load action
1055         act_type = self.pool.get('ir.actions.actions').read(cr, uid, wizard.action_id.id, ['type'], context=context)
1056
1057         res = self.pool[act_type['type']].read(cr, uid, wizard.action_id.id, [], context=context)
1058         if act_type['type'] != 'ir.actions.act_window':
1059             return res
1060         res.setdefault('context','{}')
1061         res['nodestroy'] = True
1062
1063         # Open a specific record when res_id is provided in the context
1064         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
1065         ctx = eval(res['context'], {'user': user})
1066         if ctx.get('res_id'):
1067             res.update({'res_id': ctx.pop('res_id')})
1068
1069         # disable log for automatic wizards
1070         if wizard.type == 'automatic':
1071             ctx.update({'disable_log': True})
1072         res.update({'context': ctx})
1073
1074         return res
1075
1076     def action_open(self, cr, uid, ids, context=None):
1077         """ Sets configuration wizard in TODO state"""
1078         return self.write(cr, uid, ids, {'state': 'open'}, context=context)
1079
1080     def progress(self, cr, uid, context=None):
1081         """ Returns a dict with 3 keys {todo, done, total}.
1082
1083         These keys all map to integers and provide the number of todos
1084         marked as open, the total number of todos and the number of
1085         todos not open (which is basically a shortcut to total-todo)
1086
1087         :rtype: dict
1088         """
1089         user_groups = set(map(
1090             lambda x: x.id,
1091             self.pool['res.users'].browse(cr, uid, [uid], context=context)[0].groups_id))
1092         def groups_match(todo):
1093             """ Checks if the todo's groups match those of the current user
1094             """
1095             return not todo.groups_id \
1096                    or bool(user_groups.intersection((
1097                         group.id for group in todo.groups_id)))
1098
1099         done = filter(
1100             groups_match,
1101             self.browse(cr, uid,
1102                 self.search(cr, uid, [('state', '!=', 'open')], context=context),
1103                         context=context))
1104
1105         total = filter(
1106             groups_match,
1107             self.browse(cr, uid,
1108                 self.search(cr, uid, [], context=context),
1109                         context=context))
1110
1111         return {
1112             'done': len(done),
1113             'total': len(total),
1114             'todo': len(total) - len(done)
1115         }
1116
1117
1118 class ir_actions_act_client(osv.osv):
1119     _name = 'ir.actions.client'
1120     _inherit = 'ir.actions.actions'
1121     _table = 'ir_act_client'
1122     _sequence = 'ir_actions_id_seq'
1123     _order = 'name'
1124
1125     def _get_params(self, cr, uid, ids, field_name, arg, context):
1126         result = {}
1127         for record in self.browse(cr, uid, ids, context=context):
1128             result[record.id] = record.params_store and eval(record.params_store, {'uid': uid}) or False
1129         return result
1130
1131     def _set_params(self, cr, uid, id, field_name, field_value, arg, context):
1132         if isinstance(field_value, dict):
1133             self.write(cr, uid, id, {'params_store': repr(field_value)}, context=context)
1134         else:
1135             self.write(cr, uid, id, {'params_store': field_value}, context=context)
1136
1137     _columns = {
1138         'name': fields.char('Action Name', required=True, size=64, translate=True),
1139         'tag': fields.char('Client action tag', size=64, required=True,
1140                            help="An arbitrary string, interpreted by the client"
1141                                 " according to its own needs and wishes. There "
1142                                 "is no central tag repository across clients."),
1143         'res_model': fields.char('Destination Model', size=64,
1144             help="Optional model, mostly used for needactions."),
1145         'context': fields.char('Context Value', size=250, required=True,
1146             help="Context dictionary as Python expression, empty by default (Default: {})"),
1147         'params': fields.function(_get_params, fnct_inv=_set_params,
1148                                   type='binary',
1149                                   string="Supplementary arguments",
1150                                   help="Arguments sent to the client along with"
1151                                        "the view tag"),
1152         'params_store': fields.binary("Params storage", readonly=True)
1153     }
1154     _defaults = {
1155         'type': 'ir.actions.client',
1156         'context': '{}',
1157
1158     }
1159
1160
1161
1162 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
1163