1 # -*- coding: utf-8 -*-
2 ##############################################################################
4 # OpenERP, Open Source Management Solution
5 # Copyright (C) 2004-2014 OpenERP S.A. <http://www.openerp.com>
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.
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.
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/>.
20 ##############################################################################
22 from functools import partial
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
42 _logger = logging.getLogger(__name__)
45 class actions(osv.osv):
46 _name = 'ir.actions.actions'
50 'name': fields.char('Name', size=64, required=True),
51 'type': fields.char('Action Type', required=True, size=32),
52 'usage': fields.char('Action Usage', size=32),
53 'help': fields.text('Action description',
54 help='Optional help text for the users with a description of the target view, such as its usage and purpose.',
58 'usage': lambda *a: False,
62 class ir_actions_report_xml(osv.osv):
64 def _report_content(self, cursor, user, ids, name, arg, context=None):
66 for report in self.browse(cursor, user, ids, context=context):
67 data = report[name + '_data']
68 if not data and report[name[:-8]]:
71 fp = tools.file_open(report[name[:-8]], mode='rb')
81 def _report_content_inv(self, cursor, user, id, name, value, arg, context=None):
82 self.write(cursor, user, id, {name+'_data': value}, context=context)
84 def _report_sxw(self, cursor, user, ids, name, arg, context=None):
86 for report in self.browse(cursor, user, ids, context=context):
88 res[report.id] = report.report_rml.replace('.rml', '.sxw')
90 res[report.id] = False
93 def _lookup_report(self, cr, name):
95 Look up a report definition.
99 # First lookup in the deprecated place, because if the report definition
100 # has not been updated, it is more likely the correct definition is there.
101 # Only reports with custom parser sepcified in Python are still there.
102 if 'report.' + name in openerp.report.interface.report_int._reports:
103 new_report = openerp.report.interface.report_int._reports['report.' + name]
105 cr.execute("SELECT * FROM ir_act_report_xml WHERE report_name=%s", (name,))
106 r = cr.dictfetchone()
108 if r['report_type'] in ['qweb-pdf', 'qweb-html']:
109 return r['report_name']
110 elif r['report_rml'] or r['report_rml_content_data']:
112 kwargs = { 'parser': operator.attrgetter(r['parser'])(openerp.addons) }
115 new_report = report_sxw('report.'+r['report_name'], r['model'],
116 opj('addons',r['report_rml'] or '/'), header=r['header'], register=False, **kwargs)
117 elif r['report_xsl'] and r['report_xml']:
118 new_report = report_rml('report.'+r['report_name'], r['model'],
119 opj('addons',r['report_xml']),
120 r['report_xsl'] and opj('addons',r['report_xsl']), register=False)
122 raise Exception, "Unhandled report type: %s" % r
124 raise Exception, "Required report does not exist: %s" % r
128 def render_report(self, cr, uid, res_ids, name, data, context=None):
130 Look up a report definition and render the report for the provided IDs.
132 new_report = self._lookup_report(cr, name)
134 if isinstance(new_report, (str, unicode)): # Qweb report
135 # The only case where a QWeb report is rendered with this method occurs when running
136 # yml tests originally written for RML reports.
137 if openerp.tools.config['test_enable'] and not tools.config['test_report_directory']:
138 # Only generate the pdf when a destination folder has been provided.
139 return self.pool['report'].get_html(cr, uid, res_ids, new_report, data=data, context=context), 'html'
141 return self.pool['report'].get_pdf(cr, uid, res_ids, new_report, data=data, context=context), 'pdf'
143 return new_report.create(cr, uid, res_ids, data, context)
145 _name = 'ir.actions.report.xml'
146 _inherit = 'ir.actions.actions'
147 _table = 'ir_act_report_xml'
148 _sequence = 'ir_actions_id_seq'
151 'type': fields.char('Action Type', size=32, required=True),
152 'name': fields.char('Name', size=64, required=True, translate=True),
154 'model': fields.char('Model', required=True),
155 'report_type': fields.selection([('qweb-pdf', 'PDF'),
156 ('qweb-html', 'HTML'),
157 ('controller', 'Controller'),
158 ('pdf', 'RML pdf (deprecated)'),
159 ('sxw', 'RML sxw (deprecated)'),
160 ('webkit', 'Webkit (deprecated)'),
161 ], 'Report Type', required=True, help="HTML will open the report directly in your browser, PDF will use wkhtmltopdf to render the HTML into a PDF file and let you download it, Controller allows you to define the url of a custom controller outputting any kind of report."),
162 'report_name': fields.char('Template Name', required=True, help="For QWeb reports, name of the template used in the rendering. The method 'render_html' of the model 'report.template_name' will be called (if any) to give the html. For RML reports, this is the LocalService name."),
163 'groups_id': fields.many2many('res.groups', 'res_groups_report_rel', 'uid', 'gid', 'Groups'),
166 '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."),
167 '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.'),
168 '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.'),
170 # Deprecated rml stuff
171 'usage': fields.char('Action Usage', size=32),
172 'header': fields.boolean('Add RML Header', help="Add or not the corporate RML header"),
173 'parser': fields.char('Parser Class'),
174 'auto': fields.boolean('Custom Python Parser'),
176 'report_xsl': fields.char('XSL Path'),
177 'report_xml': fields.char('XML Path'),
179 'report_rml': fields.char('Main Report File Path/controller', help="The path to the main report file/controller (depending on Report Type) or NULL if the content is in another data field"),
180 '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),
182 'report_sxw': fields.function(_report_sxw, type='char', string='SXW Path'),
183 'report_sxw_content_data': fields.binary('SXW Content'),
184 'report_rml_content_data': fields.binary('RML Content'),
185 'report_sxw_content': fields.function(_report_content, fnct_inv=_report_content_inv, type='binary', string='SXW Content',),
186 'report_rml_content': fields.function(_report_content, fnct_inv=_report_content_inv, type='binary', string='RML Content'),
189 'type': 'ir.actions.report.xml',
193 'report_sxw_content': False,
194 'report_type': 'pdf',
199 class ir_actions_act_window(osv.osv):
200 _name = 'ir.actions.act_window'
201 _table = 'ir_act_window'
202 _inherit = 'ir.actions.actions'
203 _sequence = 'ir_actions_id_seq'
206 def _check_model(self, cr, uid, ids, context=None):
207 for action in self.browse(cr, uid, ids, context):
208 if action.res_model not in self.pool:
210 if action.src_model and action.src_model not in self.pool:
214 def _invalid_model_msg(self, cr, uid, ids, context=None):
215 return _('Invalid model name in the action definition.')
218 (_check_model, _invalid_model_msg, ['res_model','src_model'])
221 def _views_get_fnc(self, cr, uid, ids, name, arg, context=None):
222 """Returns an ordered list of the specific view modes that should be
223 enabled when displaying the result of this action, along with the
224 ID of the specific view to use for each mode, if any were required.
226 This function hides the logic of determining the precedence between
227 the view_modes string, the view_ids o2m, and the view_id m2o that can
228 be set on the action.
230 :rtype: dict in the form { action_id: list of pairs (tuples) }
231 :return: { action_id: [(view_id, view_mode), ...], ... }, where view_mode
232 is one of the possible values for ir.ui.view.type and view_id
233 is the ID of a specific view to use for this mode, or False for
237 for act in self.browse(cr, uid, ids):
238 res[act.id] = [(view.view_id.id, view.view_mode) for view in act.view_ids]
239 view_ids_modes = [view.view_mode for view in act.view_ids]
240 modes = act.view_mode.split(',')
241 missing_modes = [mode for mode in modes if mode not in view_ids_modes]
243 if act.view_id and act.view_id.type in missing_modes:
244 # reorder missing modes to put view_id first if present
245 missing_modes.remove(act.view_id.type)
246 res[act.id].append((act.view_id.id, act.view_id.type))
247 res[act.id].extend([(False, mode) for mode in missing_modes])
250 def _search_view(self, cr, uid, ids, name, arg, context=None):
252 for act in self.browse(cr, uid, ids, context=context):
253 field_get = self.pool[act.res_model].fields_view_get(cr, uid,
254 act.search_view_id and act.search_view_id.id or False,
255 'search', context=context)
256 res[act.id] = str(field_get)
260 'name': fields.char('Action Name', size=64, translate=True),
261 'type': fields.char('Action Type', size=32, required=True),
262 'view_id': fields.many2one('ir.ui.view', 'View Ref.', ondelete='cascade'),
263 'domain': fields.char('Domain Value',
264 help="Optional domain filtering of the destination data, as a Python expression"),
265 'context': fields.char('Context Value', required=True,
266 help="Context dictionary as Python expression, empty by default (Default: {})"),
267 'res_id': fields.integer('Record ID', help="Database ID of record to open in form view, when ``view_mode`` is set to 'form' only"),
268 'res_model': fields.char('Destination Model', size=64, required=True,
269 help="Model name of the object to open in the view window"),
270 'src_model': fields.char('Source Model', size=64,
271 help="Optional model name of the objects on which this action should be visible"),
272 'target': fields.selection([('current','Current Window'),('new','New Window'),('inline','Inline Edit'),('inlineview','Inline View')], 'Target Window'),
273 'view_mode': fields.char('View Mode', size=250, required=True,
274 help="Comma-separated list of allowed view modes, such as 'form', 'tree', 'calendar', etc. (Default: tree,form)"),
275 'view_type': fields.selection((('tree','Tree'),('form','Form')), string='View Type', required=True,
276 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"),
277 'usage': fields.char('Action Usage', size=32,
278 help="Used to filter menu and home actions from the user form."),
279 'view_ids': fields.one2many('ir.actions.act_window.view', 'act_window_id', 'Views'),
280 'views': fields.function(_views_get_fnc, type='binary', string='Views',
281 help="This function field computes the ordered list of views that should be enabled " \
282 "when displaying the result of an action, federating view mode, views and " \
283 "reference view. The result is returned as an ordered list of pairs (view_id,view_mode)."),
284 'limit': fields.integer('Limit', help='Default limit for the list view'),
285 'auto_refresh': fields.integer('Auto-Refresh',
286 help='Add an auto-refresh on the view'),
287 'groups_id': fields.many2many('res.groups', 'ir_act_window_group_rel',
288 'act_id', 'gid', 'Groups'),
289 'search_view_id': fields.many2one('ir.ui.view', 'Search View Ref.'),
290 'filter': fields.boolean('Filter'),
291 'auto_search':fields.boolean('Auto Search'),
292 'search_view' : fields.function(_search_view, type='text', string='Search View'),
293 '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"),
297 'type': 'ir.actions.act_window',
299 'view_mode': 'tree,form',
308 def read(self, cr, uid, ids, fields=None, context=None, load='_classic_read'):
309 """ call the method get_empty_list_help of the model and set the window action help message
311 ids_int = isinstance(ids, (int, long))
314 results = super(ir_actions_act_window, self).read(cr, uid, ids, fields=fields, context=context, load=load)
316 if not fields or 'help' in fields:
317 context = dict(context or {})
319 'active_model': context.get('active_model'),
320 'active_id': context.get('active_id'),
321 'active_ids': context.get('active_ids'),
325 model = res.get('res_model')
326 if model and self.pool.get(model):
328 with tools.mute_logger("openerp.tools.safe_eval"):
329 eval_context = eval(res['context'] or "{}", eval_dict) or {}
332 custom_context = dict(context, **eval_context)
333 res['help'] = self.pool.get(model).get_empty_list_help(cr, uid, res.get('help', ""), context=custom_context)
338 def for_xml_id(self, cr, uid, module, xml_id, context=None):
339 """ Returns the act_window object created for the provided xml_id
341 :param module: the module the act_window originates in
342 :param xml_id: the namespace-less id of the action (the @id
343 attribute from the XML file)
344 :return: A read() view of the ir.actions.act_window
346 dataobj = self.pool.get('ir.model.data')
347 data_id = dataobj._get_id (cr, SUPERUSER_ID, module, xml_id)
348 res_id = dataobj.browse(cr, uid, data_id, context).res_id
349 return self.read(cr, uid, res_id, [], context)
355 ('calendar', 'Calendar'),
357 ('kanban', 'Kanban')]
358 class ir_actions_act_window_view(osv.osv):
359 _name = 'ir.actions.act_window.view'
360 _table = 'ir_act_window_view'
361 _rec_name = 'view_id'
364 'sequence': fields.integer('Sequence'),
365 'view_id': fields.many2one('ir.ui.view', 'View'),
366 'view_mode': fields.selection(VIEW_TYPES, string='View Type', required=True),
367 'act_window_id': fields.many2one('ir.actions.act_window', 'Action', ondelete='cascade'),
368 'multi': fields.boolean('On Multiple Doc.',
369 help="If set to true, the action will not be displayed on the right toolbar of a form view."),
374 def _auto_init(self, cr, context=None):
375 super(ir_actions_act_window_view, self)._auto_init(cr, context)
376 cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'act_window_view_unique_mode_per_action\'')
377 if not cr.fetchone():
378 cr.execute('CREATE UNIQUE INDEX act_window_view_unique_mode_per_action ON ir_act_window_view (act_window_id, view_mode)')
381 class ir_actions_act_window_close(osv.osv):
382 _name = 'ir.actions.act_window_close'
383 _inherit = 'ir.actions.actions'
384 _table = 'ir_actions'
386 'type': 'ir.actions.act_window_close',
390 class ir_actions_act_url(osv.osv):
391 _name = 'ir.actions.act_url'
392 _table = 'ir_act_url'
393 _inherit = 'ir.actions.actions'
394 _sequence = 'ir_actions_id_seq'
397 'name': fields.char('Action Name', size=64, translate=True),
398 'type': fields.char('Action Type', size=32, required=True),
399 'url': fields.text('Action URL',required=True),
400 'target': fields.selection((
401 ('new', 'New Window'),
402 ('self', 'This Window')),
403 'Action Target', required=True
407 'type': 'ir.actions.act_url',
412 class ir_actions_server(osv.osv):
413 """ Server actions model. Server action work on a base model and offer various
414 type of actions that can be executed automatically, for example using base
415 action rules, of manually, by adding the action in the 'More' contextual
418 Since OpenERP 8.0 a button 'Create Menu Action' button is available on the
419 action form view. It creates an entry in the More menu of the base model.
420 This allows to create server actions and run them in mass mode easily through
423 The available actions are :
425 - 'Execute Python Code': a block of python code that will be executed
426 - 'Trigger a Workflow Signal': send a signal to a workflow
427 - 'Run a Client Action': choose a client action to launch
428 - 'Create or Copy a new Record': create a new record with new values, or
429 copy an existing record in your database
430 - 'Write on a Record': update the values of a record
431 - 'Execute several actions': define an action that triggers several other
434 _name = 'ir.actions.server'
435 _table = 'ir_act_server'
436 _inherit = 'ir.actions.actions'
437 _sequence = 'ir_actions_id_seq'
438 _order = 'sequence,name'
440 def _select_objects(self, cr, uid, context=None):
441 model_pool = self.pool.get('ir.model')
442 ids = model_pool.search(cr, uid, [], limit=None)
443 res = model_pool.read(cr, uid, ids, ['model', 'name'])
444 return [(r['model'], r['name']) for r in res] + [('', '')]
446 def _get_states(self, cr, uid, context=None):
447 """ Override me in order to add new states in the server action. Please
448 note that the added key length should not be higher than already-existing
450 return [('code', 'Execute Python Code'),
451 ('trigger', 'Trigger a Workflow Signal'),
452 ('client_action', 'Run a Client Action'),
453 ('object_create', 'Create or Copy a new Record'),
454 ('object_write', 'Write on a Record'),
455 ('multi', 'Execute several actions')]
457 def _get_states_wrapper(self, cr, uid, context=None):
458 return self._get_states(cr, uid, context)
461 'name': fields.char('Action Name', required=True, size=64, translate=True),
462 'condition': fields.char('Condition',
463 help="Condition verified before executing the server action. If it "
464 "is not verified, the action will not be executed. The condition is "
465 "a Python expression, like 'object.list_price > 5000'. A void "
466 "condition is considered as always True. Help about python expression "
467 "is given in the help tab."),
468 'state': fields.selection(_get_states_wrapper, 'Action To Do', required=True,
469 help="Type of server action. The following values are available:\n"
470 "- 'Execute Python Code': a block of python code that will be executed\n"
471 "- 'Trigger a Workflow Signal': send a signal to a workflow\n"
472 "- 'Run a Client Action': choose a client action to launch\n"
473 "- 'Create or Copy a new Record': create a new record with new values, or copy an existing record in your database\n"
474 "- 'Write on a Record': update the values of a record\n"
475 "- 'Execute several actions': define an action that triggers several other server actions\n"
476 "- 'Send Email': automatically send an email (available in email_template)"),
477 'usage': fields.char('Action Usage', size=32),
478 'type': fields.char('Action Type', size=32, required=True),
480 'sequence': fields.integer('Sequence',
481 help="When dealing with multiple actions, the execution order is "
482 "based on the sequence. Low number means high priority."),
483 'model_id': fields.many2one('ir.model', 'Base Model', required=True, ondelete='cascade',
484 help="Base model on which the server action runs."),
485 'model_name': fields.related('model_id', 'model', type='char',
486 string='Model Name', readonly=True),
487 'menu_ir_values_id': fields.many2one('ir.values', 'More Menu entry', readonly=True,
488 help='More menu entry.'),
490 'action_id': fields.many2one('ir.actions.actions', 'Client Action',
491 help="Select the client action that has to be executed."),
493 'code': fields.text('Python Code',
494 help="Write Python code that the action will execute. Some variables are "
495 "available for use; help about pyhon expression is given in the help tab."),
497 'use_relational_model': fields.selection([('base', 'Use the base model of the action'),
498 ('relational', 'Use a relation field on the base model')],
499 string='Target Model', required=True),
500 'wkf_transition_id': fields.many2one('workflow.transition', string='Signal to Trigger',
501 help="Select the workflow signal to trigger."),
502 'wkf_model_id': fields.many2one('ir.model', 'Target Model',
503 help="The model that will receive the workflow signal. Note that it should have a workflow associated with it."),
504 'wkf_model_name': fields.related('wkf_model_id', 'model', type='char', string='Target Model Name', store=True, readonly=True),
505 'wkf_field_id': fields.many2one('ir.model.fields', string='Relation Field',
506 oldname='trigger_obj_id',
507 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)"),
509 'child_ids': fields.many2many('ir.actions.server', 'rel_server_actions',
510 'server_id', 'action_id',
511 string='Child Actions',
512 help='Child server actions that will be executed. Note that the last return returned action value will be used as global return value.'),
514 'use_create': fields.selection([('new', 'Create a new record in the Base Model'),
515 ('new_other', 'Create a new record in another model'),
516 ('copy_current', 'Copy the current record'),
517 ('copy_other', 'Choose and copy a record in the database')],
518 string="Creation Policy", required=True,
520 'crud_model_id': fields.many2one('ir.model', 'Target Model',
521 oldname='srcmodel_id',
522 help="Model for record creation / update. Set this field only to specify a different model than the base model."),
523 'crud_model_name': fields.related('crud_model_id', 'model', type='char',
524 string='Create/Write Target Model Name',
525 store=True, readonly=True),
526 'ref_object': fields.reference('Reference record', selection=_select_objects, size=128,
527 oldname='copy_object'),
528 'link_new_record': fields.boolean('Attach the new record',
529 help="Check this if you want to link the newly-created record "
530 "to the current record on which the server action runs."),
531 'link_field_id': fields.many2one('ir.model.fields', 'Link using field',
533 help="Provide the field where the record id is stored after the operations."),
534 'use_write': fields.selection([('current', 'Update the current record'),
535 ('expression', 'Update a record linked to the current record using python'),
536 ('other', 'Choose and Update a record in the database')],
537 string='Update Policy', required=True,
539 'write_expression': fields.char('Expression',
541 help="Provide an expression that, applied on the current record, gives the field to update."),
542 'fields_lines': fields.one2many('ir.server.object.lines', 'server_id',
543 string='Value Mapping',
546 # Fake fields used to implement the placeholder assistant
547 'model_object_field': fields.many2one('ir.model.fields', string="Field",
548 help="Select target field from the related document model.\n"
549 "If it is a relationship field you will be able to select "
550 "a target field at the destination of the relationship."),
551 'sub_object': fields.many2one('ir.model', 'Sub-model', readonly=True,
552 help="When a relationship field is selected as first field, "
553 "this field shows the document model the relationship goes to."),
554 'sub_model_object_field': fields.many2one('ir.model.fields', 'Sub-field',
555 help="When a relationship field is selected as first field, "
556 "this field lets you select the target field within the "
557 "destination document model (sub-model)."),
558 'copyvalue': fields.char('Placeholder Expression', help="Final placeholder expression, to be copy-pasted in the desired template field."),
559 # Fake fields used to implement the ID finding assistant
560 'id_object': fields.reference('Record', selection=_select_objects, size=128),
561 'id_value': fields.char('Record ID'),
567 'type': 'ir.actions.server',
569 'code': """# You can use the following variables:
570 # - self: ORM model of the record on which the action is triggered
571 # - object: browse_record of the record on which the action is triggered if there is one, otherwise None
572 # - pool: ORM model pool (i.e. self.pool)
573 # - cr: database cursor
574 # - uid: current user id
575 # - context: current context
576 # - time: Python time module
577 # - workflow: Workflow engine
578 # If you plan to return an action, assign: action = {...}""",
579 'use_relational_model': 'base',
581 'use_write': 'current',
584 def _check_expression(self, cr, uid, expression, model_id, context):
585 """ Check python expression (condition, write_expression). Each step of
586 the path must be a valid many2one field, or an integer field for the last
589 :param str expression: a python expression, beginning by 'obj' or 'object'
590 :param int model_id: the base model of the server action
591 :returns tuple: (is_valid, target_model_name, error_msg)
594 return (False, None, 'Your expression cannot be validated because the Base Model is not set.')
595 # fetch current model
596 current_model_name = self.pool.get('ir.model').browse(cr, uid, model_id, context).model
597 # transform expression into a path that should look like 'object.many2onefield.many2onefield'
598 path = expression.split('.')
599 initial = path.pop(0)
600 if initial not in ['obj', 'object']:
601 return (False, None, 'Your expression should begin with obj or object.\nAn expression builder is available in the help tab.')
605 column_info = self.pool[current_model_name]._all_columns.get(step)
607 return (False, None, 'Part of the expression (%s) is not recognized as a column in the model %s.' % (step, current_model_name))
608 column_type = column_info.column._type
609 if column_type not in ['many2one', 'int']:
610 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))
611 if column_type == 'int' and path:
612 return (False, None, 'Part of the expression (%s) is an integer field that is only allowed at the end of an expression' % (step))
613 if column_type == 'many2one':
614 current_model_name = column_info.column._obj
615 return (True, current_model_name, None)
617 def _check_write_expression(self, cr, uid, ids, context=None):
618 for record in self.browse(cr, uid, ids, context=context):
619 if record.write_expression and record.model_id:
620 correct, model_name, message = self._check_expression(cr, uid, record.write_expression, record.model_id.id, context=context)
622 _logger.warning('Invalid expression: %s' % message)
627 (_check_write_expression,
628 'Incorrect Write Record Expression',
629 ['write_expression']),
630 (partial(osv.Model._check_m2m_recursion, field_name='child_ids'),
631 'Recursion found in child server actions',
635 def on_change_model_id(self, cr, uid, ids, model_id, wkf_model_id, crud_model_id, context=None):
636 """ When changing the action base model, reset workflow and crud config
637 to ease value coherence. """
640 'use_write': 'current',
641 'use_relational_model': 'base',
642 'wkf_model_id': model_id,
643 'wkf_field_id': False,
644 'crud_model_id': model_id,
648 values['model_name'] = self.pool.get('ir.model').browse(cr, uid, model_id, context).model
650 return {'value': values}
652 def on_change_wkf_wonfig(self, cr, uid, ids, use_relational_model, wkf_field_id, wkf_model_id, model_id, context=None):
653 """ Update workflow type configuration
655 - update the workflow model (for base (model_id) /relational (field.relation))
656 - update wkf_transition_id to False if workflow model changes, to force
657 the user to choose a new one
660 if use_relational_model == 'relational' and wkf_field_id:
661 field = self.pool['ir.model.fields'].browse(cr, uid, wkf_field_id, context=context)
662 new_wkf_model_id = self.pool.get('ir.model').search(cr, uid, [('model', '=', field.relation)], context=context)[0]
663 values['wkf_model_id'] = new_wkf_model_id
665 values['wkf_model_id'] = model_id
666 return {'value': values}
668 def on_change_wkf_model_id(self, cr, uid, ids, wkf_model_id, context=None):
669 """ When changing the workflow model, update its stored name also """
670 wkf_model_name = False
672 wkf_model_name = self.pool.get('ir.model').browse(cr, uid, wkf_model_id, context).model
673 values = {'wkf_transition_id': False, 'wkf_model_name': wkf_model_name}
674 return {'value': values}
676 def on_change_crud_config(self, cr, uid, ids, state, use_create, use_write, ref_object, crud_model_id, model_id, context=None):
677 """ Wrapper on CRUD-type (create or write) on_change """
678 if state == 'object_create':
679 return self.on_change_create_config(cr, uid, ids, use_create, ref_object, crud_model_id, model_id, context=context)
680 elif state == 'object_write':
681 return self.on_change_write_config(cr, uid, ids, use_write, ref_object, crud_model_id, model_id, context=context)
685 def on_change_create_config(self, cr, uid, ids, use_create, ref_object, crud_model_id, model_id, context=None):
686 """ When changing the object_create type configuration:
688 - `new` and `copy_current`: crud_model_id is the same as base model
689 - `new_other`: user choose crud_model_id
690 - `copy_other`: disassemble the reference object to have its model
691 - if the target model has changed, then reset the link field that is
692 probably not correct anymore
695 if use_create == 'new':
696 values['crud_model_id'] = model_id
697 elif use_create == 'new_other':
699 elif use_create == 'copy_current':
700 values['crud_model_id'] = model_id
701 elif use_create == 'copy_other' and ref_object:
702 ref_model, ref_id = ref_object.split(',')
703 ref_model_id = self.pool['ir.model'].search(cr, uid, [('model', '=', ref_model)], context=context)[0]
704 values['crud_model_id'] = ref_model_id
706 if values.get('crud_model_id') != crud_model_id:
707 values['link_field_id'] = False
708 return {'value': values}
710 def on_change_write_config(self, cr, uid, ids, use_write, ref_object, crud_model_id, model_id, context=None):
711 """ When changing the object_write type configuration:
713 - `current`: crud_model_id is the same as base model
714 - `other`: disassemble the reference object to have its model
715 - `expression`: has its own on_change, nothing special here
718 if use_write == 'current':
719 values['crud_model_id'] = model_id
720 elif use_write == 'other' and ref_object:
721 ref_model, ref_id = ref_object.split(',')
722 ref_model_id = self.pool['ir.model'].search(cr, uid, [('model', '=', ref_model)], context=context)[0]
723 values['crud_model_id'] = ref_model_id
724 elif use_write == 'expression':
727 if values.get('crud_model_id') != crud_model_id:
728 values['link_field_id'] = False
729 return {'value': values}
731 def on_change_write_expression(self, cr, uid, ids, write_expression, model_id, context=None):
732 """ Check the write_expression and update crud_model_id accordingly """
734 valid, model_name, message = self._check_expression(cr, uid, write_expression, model_id, context=context)
736 ref_model_id = self.pool['ir.model'].search(cr, uid, [('model', '=', model_name)], context=context)[0]
737 values['crud_model_id'] = ref_model_id
738 return {'value': values}
740 message = 'Invalid expression'
743 'title': 'Incorrect expression',
748 def on_change_crud_model_id(self, cr, uid, ids, crud_model_id, context=None):
749 """ When changing the CRUD model, update its stored name also """
750 crud_model_name = False
752 crud_model_name = self.pool.get('ir.model').browse(cr, uid, crud_model_id, context).model
754 values = {'link_field_id': False, 'crud_model_name': crud_model_name}
755 return {'value': values}
757 def _build_expression(self, field_name, sub_field_name):
758 """ Returns a placeholder expression for use in a template field,
759 based on the values provided in the placeholder assistant.
761 :param field_name: main field name
762 :param sub_field_name: sub field name (M2O)
763 :return: final placeholder expression
767 expression = "object." + field_name
769 expression += "." + sub_field_name
772 def onchange_sub_model_object_value_field(self, cr, uid, ids, model_object_field, sub_model_object_field=False, context=None):
776 'sub_model_object_field': False,
778 if model_object_field:
779 fields_obj = self.pool.get('ir.model.fields')
780 field_value = fields_obj.browse(cr, uid, model_object_field, context)
781 if field_value.ttype in ['many2one', 'one2many', 'many2many']:
782 res_ids = self.pool.get('ir.model').search(cr, uid, [('model', '=', field_value.relation)], context=context)
783 sub_field_value = False
784 if sub_model_object_field:
785 sub_field_value = fields_obj.browse(cr, uid, sub_model_object_field, context)
788 'sub_object': res_ids[0],
789 'copyvalue': self._build_expression(field_value.name, sub_field_value and sub_field_value.name or False),
790 'sub_model_object_field': sub_model_object_field or False,
794 'copyvalue': self._build_expression(field_value.name, False),
796 return {'value': result}
798 def onchange_id_object(self, cr, uid, ids, id_object, context=None):
800 ref_model, ref_id = id_object.split(',')
801 return {'value': {'id_value': ref_id}}
802 return {'value': {'id_value': False}}
804 def create_action(self, cr, uid, ids, context=None):
805 """ Create a contextual action for each of the server actions. """
806 for action in self.browse(cr, uid, ids, context=context):
807 ir_values_id = self.pool.get('ir.values').create(cr, SUPERUSER_ID, {
808 'name': _('Run %s') % action.name,
809 'model': action.model_id.model,
810 'key2': 'client_action_multi',
811 'value': "ir.actions.server,%s" % action.id,
814 'menu_ir_values_id': ir_values_id,
819 def unlink_action(self, cr, uid, ids, context=None):
820 """ Remove the contextual actions created for the server actions. """
821 for action in self.browse(cr, uid, ids, context=context):
822 if action.menu_ir_values_id:
824 self.pool.get('ir.values').unlink(cr, SUPERUSER_ID, action.menu_ir_values_id.id, context)
826 raise osv.except_osv(_('Warning'), _('Deletion of the action record failed.'))
829 def run_action_client_action(self, cr, uid, action, eval_context=None, context=None):
830 if not action.action_id:
831 raise osv.except_osv(_('Error'), _("Please specify an action to launch!"))
832 return self.pool[action.action_id.type].read(cr, uid, action.action_id.id, context=context)
834 def run_action_code_multi(self, cr, uid, action, eval_context=None, context=None):
835 eval(action.code.strip(), eval_context, mode="exec", nocopy=True) # nocopy allows to return 'action'
836 if 'action' in eval_context:
837 return eval_context['action']
839 def run_action_trigger(self, cr, uid, action, eval_context=None, context=None):
840 """ Trigger a workflow signal, depending on the use_relational_model:
842 - `base`: base_model_pool.signal_<TRIGGER_NAME>(cr, uid, context.get('active_id'))
843 - `relational`: find the related model and object, using the relational
844 field, then target_model_pool.signal_<TRIGGER_NAME>(cr, uid, target_id)
846 obj_pool = self.pool[action.model_id.model]
847 if action.use_relational_model == 'base':
848 target_id = context.get('active_id')
849 target_pool = obj_pool
851 value = getattr(obj_pool.browse(cr, uid, context.get('active_id'), context=context), action.wkf_field_id.name)
852 if action.wkf_field_id.ttype == 'many2one':
856 target_pool = self.pool[action.wkf_model_id.model]
858 trigger_name = action.wkf_transition_id.signal
860 workflow.trg_validate(uid, target_pool._name, target_id, trigger_name, cr)
862 def run_action_multi(self, cr, uid, action, eval_context=None, context=None):
864 for act in action.child_ids:
865 result = self.run(cr, uid, [act.id], context)
868 return res and res[0] or False
870 def run_action_object_write(self, cr, uid, action, eval_context=None, context=None):
871 """ Write server action.
873 - 1. evaluate the value mapping
874 - 2. depending on the write configuration:
876 - `current`: id = active_id
877 - `other`: id = from reference object
878 - `expression`: id = from expression evaluation
881 for exp in action.fields_lines:
882 if exp.type == 'equation':
883 expr = eval(exp.value, eval_context)
886 res[exp.col1.name] = expr
888 if action.use_write == 'current':
889 model = action.model_id.model
890 ref_id = context.get('active_id')
891 elif action.use_write == 'other':
892 model = action.crud_model_id.model
893 ref_id = action.ref_object.id
894 elif action.use_write == 'expression':
895 model = action.crud_model_id.model
896 ref = eval(action.write_expression, eval_context)
897 if isinstance(ref, browse_record):
898 ref_id = getattr(ref, 'id')
902 obj_pool = self.pool[model]
903 obj_pool.write(cr, uid, [ref_id], res, context=context)
905 def run_action_object_create(self, cr, uid, action, eval_context=None, context=None):
906 """ Create and Copy server action.
908 - 1. evaluate the value mapping
909 - 2. depending on the write configuration:
911 - `new`: new record in the base model
912 - `copy_current`: copy the current record (id = active_id) + gives custom values
913 - `new_other`: new record in target model
914 - `copy_other`: copy the current record (id from reference object)
915 + gives custom values
918 for exp in action.fields_lines:
919 if exp.type == 'equation':
920 expr = eval(exp.value, eval_context)
923 res[exp.col1.name] = expr
925 if action.use_create in ['new', 'copy_current']:
926 model = action.model_id.model
927 elif action.use_create in ['new_other', 'copy_other']:
928 model = action.crud_model_id.model
930 obj_pool = self.pool[model]
931 if action.use_create == 'copy_current':
932 ref_id = context.get('active_id')
933 res_id = obj_pool.copy(cr, uid, ref_id, res, context=context)
934 elif action.use_create == 'copy_other':
935 ref_id = action.ref_object.id
936 res_id = obj_pool.copy(cr, uid, ref_id, res, context=context)
938 res_id = obj_pool.create(cr, uid, res, context=context)
940 if action.link_new_record and action.link_field_id:
941 self.pool[action.model_id.model].write(cr, uid, [context.get('active_id')], {action.link_field_id.name: res_id})
943 def _get_eval_context(self, cr, uid, action, context=None):
944 """ Prepare the context used when evaluating python code, like the
945 condition or code server actions.
947 :param action: the current server action
948 :type action: browse record
949 :returns: dict -- evaluation context given to (safe_)eval """
950 user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
951 obj_pool = self.pool[action.model_id.model]
953 if context.get('active_model') == action.model_id.model and context.get('active_id'):
954 obj = obj_pool.browse(cr, uid, context['active_id'], context=context)
961 'datetime': datetime,
962 'dateutil': dateutil,
967 'workflow': workflow,
968 'Warning': openerp.exceptions.Warning,
971 def run(self, cr, uid, ids, context=None):
972 """ Runs the server action. For each server action, the condition is
973 checked. Note that a void (``False``) condition is considered as always
974 valid. If it is verified, the run_action_<STATE> method is called. This
975 allows easy overriding of the server actions.
977 :param dict context: context should contain following keys
979 - active_id: id of the current object (single mode)
980 - active_model: current model that should equal the action's model
982 The following keys are optional:
984 - active_ids: ids of the current records (mass mode). If active_ids
985 and active_id are present, active_ids is given precedence.
987 :return: an action_id to be executed, or False is finished correctly without
993 for action in self.browse(cr, uid, ids, context):
994 eval_context = self._get_eval_context(cr, uid, action, context=context)
995 condition = action.condition
996 if condition is False:
997 # Void (aka False) conditions are considered as True
999 if hasattr(self, 'run_action_%s_multi' % action.state):
1000 run_context = eval_context['context']
1001 expr = eval(str(condition), eval_context)
1004 # call the multi method
1005 func = getattr(self, 'run_action_%s_multi' % action.state)
1006 res = func(cr, uid, action, eval_context=eval_context, context=run_context)
1008 elif hasattr(self, 'run_action_%s' % action.state):
1009 func = getattr(self, 'run_action_%s' % action.state)
1010 active_id = context.get('active_id')
1011 active_ids = context.get('active_ids', [active_id] if active_id else [])
1012 for active_id in active_ids:
1013 # run context dedicated to a particular active_id
1014 run_context = dict(context, active_ids=[active_id], active_id=active_id)
1015 eval_context["context"] = run_context
1016 expr = eval(str(condition), eval_context)
1019 # call the single method related to the action: run_action_<STATE>
1020 res = func(cr, uid, action, eval_context=eval_context, context=run_context)
1024 class ir_server_object_lines(osv.osv):
1025 _name = 'ir.server.object.lines'
1026 _sequence = 'ir_actions_id_seq'
1028 'server_id': fields.many2one('ir.actions.server', 'Related Server Action'),
1029 'col1': fields.many2one('ir.model.fields', 'Field', required=True),
1030 'value': fields.text('Value', required=True, help="Expression containing a value specification. \n"
1031 "When Formula type is selected, this field may be a Python expression "
1032 " that can use the same values as for the condition field on the server action.\n"
1033 "If Value type is selected, the value will be used directly without evaluation."),
1034 'type': fields.selection([
1036 ('equation', 'Python expression')
1037 ], 'Evaluation Type', required=True, change_default=True),
1044 TODO_STATES = [('open', 'To Do'),
1046 TODO_TYPES = [('manual', 'Launch Manually'),('once', 'Launch Manually Once'),
1047 ('automatic', 'Launch Automatically')]
1048 class ir_actions_todo(osv.osv):
1050 Configuration Wizards
1052 _name = 'ir.actions.todo'
1053 _description = "Configuration Wizards"
1055 'action_id': fields.many2one(
1056 'ir.actions.actions', 'Action', select=True, required=True),
1057 'sequence': fields.integer('Sequence'),
1058 'state': fields.selection(TODO_STATES, string='Status', required=True),
1059 'name': fields.char('Name', size=64),
1060 'type': fields.selection(TODO_TYPES, 'Type', required=True,
1061 help="""Manual: Launched manually.
1062 Automatic: Runs whenever the system is reconfigured.
1063 Launch Manually Once: after having been launched manually, it sets automatically to Done."""),
1064 'groups_id': fields.many2many('res.groups', 'res_groups_action_rel', 'uid', 'gid', 'Groups'),
1065 'note': fields.text('Text', translate=True),
1072 _order="sequence,id"
1074 def name_get(self, cr, uid, ids, context=None):
1075 return [(rec.id, rec.action_id.name) for rec in self.browse(cr, uid, ids, context=context)]
1077 def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=100):
1081 ids = self.search(cr, user, [('action_id', operator, name)] + args, limit=limit)
1082 return self.name_get(cr, user, ids, context=context)
1083 return super(ir_actions_todo, self).name_search(cr, user, name, args=args, operator=operator, context=context, limit=limit)
1086 def action_launch(self, cr, uid, ids, context=None):
1087 """ Launch Action of Wizard"""
1088 wizard_id = ids and ids[0] or False
1089 wizard = self.browse(cr, uid, wizard_id, context=context)
1090 if wizard.type in ('automatic', 'once'):
1091 wizard.write({'state': 'done'})
1094 act_type = self.pool.get('ir.actions.actions').read(cr, uid, wizard.action_id.id, ['type'], context=context)
1096 res = self.pool[act_type['type']].read(cr, uid, wizard.action_id.id, [], context=context)
1097 if act_type['type'] != 'ir.actions.act_window':
1099 res.setdefault('context','{}')
1100 res['nodestroy'] = True
1102 # Open a specific record when res_id is provided in the context
1103 user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
1104 ctx = eval(res['context'], {'user': user})
1105 if ctx.get('res_id'):
1106 res.update({'res_id': ctx.pop('res_id')})
1108 # disable log for automatic wizards
1109 if wizard.type == 'automatic':
1110 ctx.update({'disable_log': True})
1111 res.update({'context': ctx})
1115 def action_open(self, cr, uid, ids, context=None):
1116 """ Sets configuration wizard in TODO state"""
1117 return self.write(cr, uid, ids, {'state': 'open'}, context=context)
1119 def progress(self, cr, uid, context=None):
1120 """ Returns a dict with 3 keys {todo, done, total}.
1122 These keys all map to integers and provide the number of todos
1123 marked as open, the total number of todos and the number of
1124 todos not open (which is basically a shortcut to total-todo)
1128 user_groups = set(map(
1130 self.pool['res.users'].browse(cr, uid, [uid], context=context)[0].groups_id))
1131 def groups_match(todo):
1132 """ Checks if the todo's groups match those of the current user
1134 return not todo.groups_id \
1135 or bool(user_groups.intersection((
1136 group.id for group in todo.groups_id)))
1140 self.browse(cr, uid,
1141 self.search(cr, uid, [('state', '!=', 'open')], context=context),
1146 self.browse(cr, uid,
1147 self.search(cr, uid, [], context=context),
1152 'total': len(total),
1153 'todo': len(total) - len(done)
1157 class ir_actions_act_client(osv.osv):
1158 _name = 'ir.actions.client'
1159 _inherit = 'ir.actions.actions'
1160 _table = 'ir_act_client'
1161 _sequence = 'ir_actions_id_seq'
1164 def _get_params(self, cr, uid, ids, field_name, arg, context):
1166 for record in self.browse(cr, uid, ids, context=context):
1167 result[record.id] = record.params_store and eval(record.params_store, {'uid': uid}) or False
1170 def _set_params(self, cr, uid, id, field_name, field_value, arg, context):
1171 if isinstance(field_value, dict):
1172 self.write(cr, uid, id, {'params_store': repr(field_value)}, context=context)
1174 self.write(cr, uid, id, {'params_store': field_value}, context=context)
1177 'name': fields.char('Action Name', required=True, size=64, translate=True),
1178 'tag': fields.char('Client action tag', size=64, required=True,
1179 help="An arbitrary string, interpreted by the client"
1180 " according to its own needs and wishes. There "
1181 "is no central tag repository across clients."),
1182 'res_model': fields.char('Destination Model', size=64,
1183 help="Optional model, mostly used for needactions."),
1184 'context': fields.char('Context Value', size=250, required=True,
1185 help="Context dictionary as Python expression, empty by default (Default: {})"),
1186 'params': fields.function(_get_params, fnct_inv=_set_params,
1188 string="Supplementary arguments",
1189 help="Arguments sent to the client along with"
1191 'params_store': fields.binary("Params storage", readonly=True)
1194 'type': 'ir.actions.client',
1199 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: