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__)
44 class actions(osv.osv):
45 _name = 'ir.actions.actions'
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.',
57 'usage': lambda *a: False,
61 class ir_actions_report_xml(osv.osv):
63 def _report_content(self, cursor, user, ids, name, arg, context=None):
65 for report in self.browse(cursor, user, ids, context=context):
66 data = report[name + '_data']
67 if not data and report[name[:-8]]:
70 fp = tools.file_open(report[name[:-8]], mode='rb')
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)
83 def _report_sxw(self, cursor, user, ids, name, arg, context=None):
85 for report in self.browse(cursor, user, ids, context=context):
87 res[report.id] = report.report_rml.replace('.rml', '.sxw')
89 res[report.id] = False
92 def _lookup_report(self, cr, name):
94 Look up a report definition.
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]
104 cr.execute("SELECT * FROM ir_act_report_xml WHERE report_name=%s", (name,))
105 r = cr.dictfetchone()
107 if r['report_rml'] or r['report_rml_content_data']:
109 kwargs = { 'parser': operator.attrgetter(r['parser'])(openerp.addons) }
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)
119 raise Exception, "Unhandled report type: %s" % r
121 raise Exception, "Required report does not exist: %s" % r
125 def render_report(self, cr, uid, res_ids, name, data, context=None):
127 Look up a report definition and render the report for the provided IDs.
129 new_report = self._lookup_report(cr, name)
130 return new_report.create(cr, uid, res_ids, data, context)
132 _name = 'ir.actions.report.xml'
133 _inherit = 'ir.actions.actions'
134 _table = 'ir_act_report_xml'
135 _sequence = 'ir_actions_id_seq'
138 'name': fields.char('Name', size=64, required=True, translate=True),
139 'model': fields.char('Object', size=64, required=True),
140 'type': fields.char('Action Type', size=32, required=True),
141 'report_name': fields.char('Service Name', size=64, required=True),
142 'usage': fields.char('Action Usage', size=32),
143 'report_type': fields.char('Report Type', size=32, required=True, help="Report Type, e.g. pdf, html, raw, sxw, odt, html2html, mako2html, ..."),
144 'groups_id': fields.many2many('res.groups', 'res_groups_report_rel', 'uid', 'gid', 'Groups'),
145 '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."),
146 '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.'),
147 '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.'),
148 'auto': fields.boolean('Custom Python Parser'),
150 'header': fields.boolean('Add RML Header', help="Add or not the corporate RML header"),
152 'report_xsl': fields.char('XSL Path', size=256),
153 'report_xml': fields.char('XML Path', size=256, help=''),
155 # Pending deprecation... to be replaced by report_file as this object will become the default report object (not so specific to RML anymore)
156 'report_rml': fields.char('Main Report File Path', size=256, help="The path to the main report file (depending on Report Type) or NULL if the content is in another data field"),
157 # temporary related field as report_rml is pending deprecation - this field will replace report_rml after v6.0
158 'report_file': fields.related('report_rml', type="char", size=256, 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),
160 'report_sxw': fields.function(_report_sxw, type='char', string='SXW Path'),
161 'report_sxw_content_data': fields.binary('SXW Content'),
162 'report_rml_content_data': fields.binary('RML Content'),
163 'report_sxw_content': fields.function(_report_content, fnct_inv=_report_content_inv, type='binary', string='SXW Content',),
164 'report_rml_content': fields.function(_report_content, fnct_inv=_report_content_inv, type='binary', string='RML Content'),
166 'parser': fields.char('Parser Class'),
169 'type': 'ir.actions.report.xml',
173 'report_sxw_content': False,
174 'report_type': 'pdf',
179 class ir_actions_act_window(osv.osv):
180 _name = 'ir.actions.act_window'
181 _table = 'ir_act_window'
182 _inherit = 'ir.actions.actions'
183 _sequence = 'ir_actions_id_seq'
186 def _check_model(self, cr, uid, ids, context=None):
187 for action in self.browse(cr, uid, ids, context):
188 if action.res_model not in self.pool:
190 if action.src_model and action.src_model not in self.pool:
194 def _invalid_model_msg(self, cr, uid, ids, context=None):
195 return _('Invalid model name in the action definition.')
198 (_check_model, _invalid_model_msg, ['res_model','src_model'])
201 def _views_get_fnc(self, cr, uid, ids, name, arg, context=None):
202 """Returns an ordered list of the specific view modes that should be
203 enabled when displaying the result of this action, along with the
204 ID of the specific view to use for each mode, if any were required.
206 This function hides the logic of determining the precedence between
207 the view_modes string, the view_ids o2m, and the view_id m2o that can
208 be set on the action.
210 :rtype: dict in the form { action_id: list of pairs (tuples) }
211 :return: { action_id: [(view_id, view_mode), ...], ... }, where view_mode
212 is one of the possible values for ir.ui.view.type and view_id
213 is the ID of a specific view to use for this mode, or False for
217 for act in self.browse(cr, uid, ids):
218 res[act.id] = [(view.view_id.id, view.view_mode) for view in act.view_ids]
219 view_ids_modes = [view.view_mode for view in act.view_ids]
220 modes = act.view_mode.split(',')
221 missing_modes = [mode for mode in modes if mode not in view_ids_modes]
223 if act.view_id and act.view_id.type in missing_modes:
224 # reorder missing modes to put view_id first if present
225 missing_modes.remove(act.view_id.type)
226 res[act.id].append((act.view_id.id, act.view_id.type))
227 res[act.id].extend([(False, mode) for mode in missing_modes])
230 def _search_view(self, cr, uid, ids, name, arg, context=None):
232 for act in self.browse(cr, uid, ids, context=context):
233 field_get = self.pool[act.res_model].fields_view_get(cr, uid,
234 act.search_view_id and act.search_view_id.id or False,
235 'search', context=context)
236 res[act.id] = str(field_get)
240 'name': fields.char('Action Name', size=64, translate=True),
241 'type': fields.char('Action Type', size=32, required=True),
242 'view_id': fields.many2one('ir.ui.view', 'View Ref.', ondelete='cascade'),
243 'domain': fields.char('Domain Value',
244 help="Optional domain filtering of the destination data, as a Python expression"),
245 'context': fields.char('Context Value', required=True,
246 help="Context dictionary as Python expression, empty by default (Default: {})"),
247 'res_id': fields.integer('Record ID', help="Database ID of record to open in form view, when ``view_mode`` is set to 'form' only"),
248 'res_model': fields.char('Destination Model', size=64, required=True,
249 help="Model name of the object to open in the view window"),
250 'src_model': fields.char('Source Model', size=64,
251 help="Optional model name of the objects on which this action should be visible"),
252 'target': fields.selection([('current','Current Window'),('new','New Window'),('inline','Inline Edit'),('inlineview','Inline View')], 'Target Window'),
253 'view_mode': fields.char('View Mode', size=250, required=True,
254 help="Comma-separated list of allowed view modes, such as 'form', 'tree', 'calendar', etc. (Default: tree,form)"),
255 'view_type': fields.selection((('tree','Tree'),('form','Form')), string='View Type', required=True,
256 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"),
257 'usage': fields.char('Action Usage', size=32,
258 help="Used to filter menu and home actions from the user form."),
259 'view_ids': fields.one2many('ir.actions.act_window.view', 'act_window_id', 'Views'),
260 'views': fields.function(_views_get_fnc, type='binary', string='Views',
261 help="This function field computes the ordered list of views that should be enabled " \
262 "when displaying the result of an action, federating view mode, views and " \
263 "reference view. The result is returned as an ordered list of pairs (view_id,view_mode)."),
264 'limit': fields.integer('Limit', help='Default limit for the list view'),
265 'auto_refresh': fields.integer('Auto-Refresh',
266 help='Add an auto-refresh on the view'),
267 'groups_id': fields.many2many('res.groups', 'ir_act_window_group_rel',
268 'act_id', 'gid', 'Groups'),
269 'search_view_id': fields.many2one('ir.ui.view', 'Search View Ref.'),
270 'filter': fields.boolean('Filter'),
271 'auto_search':fields.boolean('Auto Search'),
272 'search_view' : fields.function(_search_view, type='text', string='Search View'),
273 'multi': fields.boolean('Action on Multiple Doc.', help="If set to true, the action will not be displayed on the right toolbar of a form view"),
277 'type': 'ir.actions.act_window',
279 'view_mode': 'tree,form',
288 def read(self, cr, uid, ids, fields=None, context=None, load='_classic_read'):
289 """ call the method get_empty_list_help of the model and set the window action help message
291 ids_int = isinstance(ids, (int, long))
294 results = super(ir_actions_act_window, self).read(cr, uid, ids, fields=fields, context=context, load=load)
296 if not fields or 'help' in fields:
297 context = dict(context or {})
299 'active_model': context.get('active_model'),
300 'active_id': context.get('active_id'),
301 'active_ids': context.get('active_ids'),
305 model = res.get('res_model')
306 if model and self.pool.get(model):
308 with tools.mute_logger("openerp.tools.safe_eval"):
309 eval_context = eval(res['context'] or "{}", eval_dict) or {}
312 custom_context = dict(context, **eval_context)
313 res['help'] = self.pool.get(model).get_empty_list_help(cr, uid, res.get('help', ""), context=custom_context)
318 def for_xml_id(self, cr, uid, module, xml_id, context=None):
319 """ Returns the act_window object created for the provided xml_id
321 :param module: the module the act_window originates in
322 :param xml_id: the namespace-less id of the action (the @id
323 attribute from the XML file)
324 :return: A read() view of the ir.actions.act_window
326 dataobj = self.pool.get('ir.model.data')
327 data_id = dataobj._get_id (cr, SUPERUSER_ID, module, xml_id)
328 res_id = dataobj.browse(cr, uid, data_id, context).res_id
329 return self.read(cr, uid, res_id, [], context)
335 ('calendar', 'Calendar'),
337 ('kanban', 'Kanban')]
338 class ir_actions_act_window_view(osv.osv):
339 _name = 'ir.actions.act_window.view'
340 _table = 'ir_act_window_view'
341 _rec_name = 'view_id'
344 'sequence': fields.integer('Sequence'),
345 'view_id': fields.many2one('ir.ui.view', 'View'),
346 'view_mode': fields.selection(VIEW_TYPES, string='View Type', required=True),
347 'act_window_id': fields.many2one('ir.actions.act_window', 'Action', ondelete='cascade'),
348 'multi': fields.boolean('On Multiple Doc.',
349 help="If set to true, the action will not be displayed on the right toolbar of a form view."),
354 def _auto_init(self, cr, context=None):
355 super(ir_actions_act_window_view, self)._auto_init(cr, context)
356 cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'act_window_view_unique_mode_per_action\'')
357 if not cr.fetchone():
358 cr.execute('CREATE UNIQUE INDEX act_window_view_unique_mode_per_action ON ir_act_window_view (act_window_id, view_mode)')
361 class ir_actions_act_window_close(osv.osv):
362 _name = 'ir.actions.act_window_close'
363 _inherit = 'ir.actions.actions'
364 _table = 'ir_actions'
366 'type': 'ir.actions.act_window_close',
370 class ir_actions_act_url(osv.osv):
371 _name = 'ir.actions.act_url'
372 _table = 'ir_act_url'
373 _inherit = 'ir.actions.actions'
374 _sequence = 'ir_actions_id_seq'
377 'name': fields.char('Action Name', size=64, translate=True),
378 'type': fields.char('Action Type', size=32, required=True),
379 'url': fields.text('Action URL',required=True),
380 'target': fields.selection((
381 ('new', 'New Window'),
382 ('self', 'This Window')),
383 'Action Target', required=True
387 'type': 'ir.actions.act_url',
392 class ir_actions_server(osv.osv):
393 """ Server actions model. Server action work on a base model and offer various
394 type of actions that can be executed automatically, for example using base
395 action rules, of manually, by adding the action in the 'More' contextual
398 Since OpenERP 8.0 a button 'Create Menu Action' button is available on the
399 action form view. It creates an entry in the More menu of the base model.
400 This allows to create server actions and run them in mass mode easily through
403 The available actions are :
405 - 'Execute Python Code': a block of python code that will be executed
406 - 'Trigger a Workflow Signal': send a signal to a workflow
407 - 'Run a Client Action': choose a client action to launch
408 - 'Create or Copy a new Record': create a new record with new values, or
409 copy an existing record in your database
410 - 'Write on a Record': update the values of a record
411 - 'Execute several actions': define an action that triggers several other
414 _name = 'ir.actions.server'
415 _table = 'ir_act_server'
416 _inherit = 'ir.actions.actions'
417 _sequence = 'ir_actions_id_seq'
418 _order = 'sequence,name'
420 def _select_objects(self, cr, uid, context=None):
421 model_pool = self.pool.get('ir.model')
422 ids = model_pool.search(cr, uid, [], limit=None)
423 res = model_pool.read(cr, uid, ids, ['model', 'name'])
424 return [(r['model'], r['name']) for r in res] + [('', '')]
426 def _get_states(self, cr, uid, context=None):
427 """ Override me in order to add new states in the server action. Please
428 note that the added key length should not be higher than already-existing
430 return [('code', 'Execute Python Code'),
431 ('trigger', 'Trigger a Workflow Signal'),
432 ('client_action', 'Run a Client Action'),
433 ('object_create', 'Create or Copy a new Record'),
434 ('object_write', 'Write on a Record'),
435 ('multi', 'Execute several actions')]
437 def _get_states_wrapper(self, cr, uid, context=None):
438 return self._get_states(cr, uid, context)
441 'name': fields.char('Action Name', required=True, size=64, translate=True),
442 'condition': fields.char('Condition',
443 help="Condition verified before executing the server action. If it "
444 "is not verified, the action will not be executed. The condition is "
445 "a Python expression, like 'object.list_price > 5000'. A void "
446 "condition is considered as always True. Help about python expression "
447 "is given in the help tab."),
448 'state': fields.selection(_get_states_wrapper, 'Action To Do', required=True,
449 help="Type of server action. The following values are available:\n"
450 "- 'Execute Python Code': a block of python code that will be executed\n"
451 "- 'Trigger a Workflow Signal': send a signal to a workflow\n"
452 "- 'Run a Client Action': choose a client action to launch\n"
453 "- 'Create or Copy a new Record': create a new record with new values, or copy an existing record in your database\n"
454 "- 'Write on a Record': update the values of a record\n"
455 "- 'Execute several actions': define an action that triggers several other server actions\n"
456 "- 'Send Email': automatically send an email (available in email_template)"),
457 'usage': fields.char('Action Usage', size=32),
458 'type': fields.char('Action Type', size=32, required=True),
460 'sequence': fields.integer('Sequence',
461 help="When dealing with multiple actions, the execution order is "
462 "based on the sequence. Low number means high priority."),
463 'model_id': fields.many2one('ir.model', 'Base Model', required=True, ondelete='cascade',
464 help="Base model on which the server action runs."),
465 'menu_ir_values_id': fields.many2one('ir.values', 'More Menu entry', readonly=True,
466 help='More menu entry.'),
468 'action_id': fields.many2one('ir.actions.actions', 'Client Action',
469 help="Select the client action that has to be executed."),
471 'code': fields.text('Python Code',
472 help="Write Python code that the action will execute. Some variables are "
473 "available for use; help about pyhon expression is given in the help tab."),
475 'use_relational_model': fields.selection([('base', 'Use the base model of the action'),
476 ('relational', 'Use a relation field on the base model')],
477 string='Target Model', required=True),
478 'wkf_transition_id': fields.many2one('workflow.transition', string='Signal to Trigger',
479 help="Select the workflow signal to trigger."),
480 'wkf_model_id': fields.many2one('ir.model', 'Target Model',
481 help="The model that will receive the workflow signal. Note that it should have a workflow associated with it."),
482 'wkf_model_name': fields.related('wkf_model_id', 'model', type='char', string='Target Model Name', store=True, readonly=True),
483 'wkf_field_id': fields.many2one('ir.model.fields', string='Relation Field',
484 oldname='trigger_obj_id',
485 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 'child_ids': fields.many2many('ir.actions.server', 'rel_server_actions',
488 'server_id', 'action_id',
489 string='Child Actions',
490 help='Child server actions that will be executed. Note that the last return returned action value will be used as global return value.'),
492 'use_create': fields.selection([('new', 'Create a new record in the Base Model'),
493 ('new_other', 'Create a new record in another model'),
494 ('copy_current', 'Copy the current record'),
495 ('copy_other', 'Choose and copy a record in the database')],
496 string="Creation Policy", required=True,
498 'crud_model_id': fields.many2one('ir.model', 'Target Model',
499 oldname='srcmodel_id',
500 help="Model for record creation / update. Set this field only to specify a different model than the base model."),
501 'crud_model_name': fields.related('crud_model_id', 'model', type='char',
502 string='Create/Write Target Model Name',
503 store=True, readonly=True),
504 'ref_object': fields.reference('Reference record', selection=_select_objects, size=128,
505 oldname='copy_object'),
506 'link_new_record': fields.boolean('Attach the new record',
507 help="Check this if you want to link the newly-created record "
508 "to the current record on which the server action runs."),
509 'link_field_id': fields.many2one('ir.model.fields', 'Link using field',
511 help="Provide the field where the record id is stored after the operations."),
512 'use_write': fields.selection([('current', 'Update the current record'),
513 ('expression', 'Update a record linked to the current record using python'),
514 ('other', 'Choose and Update a record in the database')],
515 string='Update Policy', required=True,
517 'write_expression': fields.char('Expression',
519 help="Provide an expression that, applied on the current record, gives the field to update."),
520 'fields_lines': fields.one2many('ir.server.object.lines', 'server_id',
521 string='Value Mapping',
524 # Fake fields used to implement the placeholder assistant
525 'model_object_field': fields.many2one('ir.model.fields', string="Field",
526 help="Select target field from the related document model.\n"
527 "If it is a relationship field you will be able to select "
528 "a target field at the destination of the relationship."),
529 'sub_object': fields.many2one('ir.model', 'Sub-model', readonly=True,
530 help="When a relationship field is selected as first field, "
531 "this field shows the document model the relationship goes to."),
532 'sub_model_object_field': fields.many2one('ir.model.fields', 'Sub-field',
533 help="When a relationship field is selected as first field, "
534 "this field lets you select the target field within the "
535 "destination document model (sub-model)."),
536 'copyvalue': fields.char('Placeholder Expression', help="Final placeholder expression, to be copy-pasted in the desired template field."),
537 # Fake fields used to implement the ID finding assistant
538 'id_object': fields.reference('Record', selection=_select_objects, size=128),
539 'id_value': fields.char('Record ID'),
545 'type': 'ir.actions.server',
547 'code': """# You can use the following variables:
548 # - self: ORM model of the record on which the action is triggered
549 # - object: browse_record of the record on which the action is triggered if there is one, otherwise None
550 # - pool: ORM model pool (i.e. self.pool)
551 # - cr: database cursor
552 # - uid: current user id
553 # - context: current context
554 # - time: Python time module
555 # If you plan to return an action, assign: action = {...}""",
556 'use_relational_model': 'base',
558 'use_write': 'current',
561 def _check_expression(self, cr, uid, expression, model_id, context):
562 """ Check python expression (condition, write_expression). Each step of
563 the path must be a valid many2one field, or an integer field for the last
566 :param str expression: a python expression, beginning by 'obj' or 'object'
567 :param int model_id: the base model of the server action
568 :returns tuple: (is_valid, target_model_name, error_msg)
571 return (False, None, 'Your expression cannot be validated because the Base Model is not set.')
572 # fetch current model
573 current_model_name = self.pool.get('ir.model').browse(cr, uid, model_id, context).model
574 # transform expression into a path that should look like 'object.many2onefield.many2onefield'
575 path = expression.split('.')
576 initial = path.pop(0)
577 if initial not in ['obj', 'object']:
578 return (False, None, 'Your expression should begin with obj or object.\nAn expression builder is available in the help tab.')
582 column_info = self.pool[current_model_name]._all_columns.get(step)
584 return (False, None, 'Part of the expression (%s) is not recognized as a column in the model %s.' % (step, current_model_name))
585 column_type = column_info.column._type
586 if column_type not in ['many2one', 'int']:
587 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))
588 if column_type == 'int' and path:
589 return (False, None, 'Part of the expression (%s) is an integer field that is only allowed at the end of an expression' % (step))
590 if column_type == 'many2one':
591 current_model_name = column_info.column._obj
592 return (True, current_model_name, None)
594 def _check_write_expression(self, cr, uid, ids, context=None):
595 for record in self.browse(cr, uid, ids, context=context):
596 if record.write_expression and record.model_id:
597 correct, model_name, message = self._check_expression(cr, uid, record.write_expression, record.model_id.id, context=context)
599 _logger.warning('Invalid expression: %s' % message)
604 (_check_write_expression,
605 'Incorrect Write Record Expression',
606 ['write_expression']),
607 (partial(osv.Model._check_m2m_recursion, field_name='child_ids'),
608 'Recursion found in child server actions',
612 def on_change_model_id(self, cr, uid, ids, model_id, wkf_model_id, crud_model_id, context=None):
613 """ When changing the action base model, reset workflow and crud config
614 to ease value coherence. """
617 'use_write': 'current',
618 'use_relational_model': 'base',
619 'wkf_model_id': model_id,
620 'wkf_field_id': False,
621 'crud_model_id': model_id,
623 return {'value': values}
625 def on_change_wkf_wonfig(self, cr, uid, ids, use_relational_model, wkf_field_id, wkf_model_id, model_id, context=None):
626 """ Update workflow type configuration
628 - update the workflow model (for base (model_id) /relational (field.relation))
629 - update wkf_transition_id to False if workflow model changes, to force
630 the user to choose a new one
633 if use_relational_model == 'relational' and wkf_field_id:
634 field = self.pool['ir.model.fields'].browse(cr, uid, wkf_field_id, context=context)
635 new_wkf_model_id = self.pool.get('ir.model').search(cr, uid, [('model', '=', field.relation)], context=context)[0]
636 values['wkf_model_id'] = new_wkf_model_id
638 values['wkf_model_id'] = model_id
639 return {'value': values}
641 def on_change_wkf_model_id(self, cr, uid, ids, wkf_model_id, context=None):
642 """ When changing the workflow model, update its stored name also """
643 wkf_model_name = False
645 wkf_model_name = self.pool.get('ir.model').browse(cr, uid, wkf_model_id, context).model
646 values = {'wkf_transition_id': False, 'wkf_model_name': wkf_model_name}
647 return {'value': values}
649 def on_change_crud_config(self, cr, uid, ids, state, use_create, use_write, ref_object, crud_model_id, model_id, context=None):
650 """ Wrapper on CRUD-type (create or write) on_change """
651 if state == 'object_create':
652 return self.on_change_create_config(cr, uid, ids, use_create, ref_object, crud_model_id, model_id, context=context)
653 elif state == 'object_write':
654 return self.on_change_write_config(cr, uid, ids, use_write, ref_object, crud_model_id, model_id, context=context)
658 def on_change_create_config(self, cr, uid, ids, use_create, ref_object, crud_model_id, model_id, context=None):
659 """ When changing the object_create type configuration:
661 - `new` and `copy_current`: crud_model_id is the same as base model
662 - `new_other`: user choose crud_model_id
663 - `copy_other`: disassemble the reference object to have its model
664 - if the target model has changed, then reset the link field that is
665 probably not correct anymore
668 if use_create == 'new':
669 values['crud_model_id'] = model_id
670 elif use_create == 'new_other':
672 elif use_create == 'copy_current':
673 values['crud_model_id'] = model_id
674 elif use_create == 'copy_other' and ref_object:
675 ref_model, ref_id = ref_object.split(',')
676 ref_model_id = self.pool['ir.model'].search(cr, uid, [('model', '=', ref_model)], context=context)[0]
677 values['crud_model_id'] = ref_model_id
679 if values.get('crud_model_id') != crud_model_id:
680 values['link_field_id'] = False
681 return {'value': values}
683 def on_change_write_config(self, cr, uid, ids, use_write, ref_object, crud_model_id, model_id, context=None):
684 """ When changing the object_write type configuration:
686 - `current`: crud_model_id is the same as base model
687 - `other`: disassemble the reference object to have its model
688 - `expression`: has its own on_change, nothing special here
691 if use_write == 'current':
692 values['crud_model_id'] = model_id
693 elif use_write == 'other' and ref_object:
694 ref_model, ref_id = ref_object.split(',')
695 ref_model_id = self.pool['ir.model'].search(cr, uid, [('model', '=', ref_model)], context=context)[0]
696 values['crud_model_id'] = ref_model_id
697 elif use_write == 'expression':
700 if values.get('crud_model_id') != crud_model_id:
701 values['link_field_id'] = False
702 return {'value': values}
704 def on_change_write_expression(self, cr, uid, ids, write_expression, model_id, context=None):
705 """ Check the write_expression and update crud_model_id accordingly """
707 valid, model_name, message = self._check_expression(cr, uid, write_expression, model_id, context=context)
709 ref_model_id = self.pool['ir.model'].search(cr, uid, [('model', '=', model_name)], context=context)[0]
710 values['crud_model_id'] = ref_model_id
711 return {'value': values}
713 message = 'Invalid expression'
716 'title': 'Incorrect expression',
721 def on_change_crud_model_id(self, cr, uid, ids, crud_model_id, context=None):
722 """ When changing the CRUD model, update its stored name also """
723 crud_model_name = False
725 crud_model_name = self.pool.get('ir.model').browse(cr, uid, crud_model_id, context).model
726 values = {'link_field_id': False, 'crud_model_name': crud_model_name}
727 return {'value': values}
729 def _build_expression(self, field_name, sub_field_name):
730 """ Returns a placeholder expression for use in a template field,
731 based on the values provided in the placeholder assistant.
733 :param field_name: main field name
734 :param sub_field_name: sub field name (M2O)
735 :return: final placeholder expression
739 expression = "object." + field_name
741 expression += "." + sub_field_name
744 def onchange_sub_model_object_value_field(self, cr, uid, ids, model_object_field, sub_model_object_field=False, context=None):
748 'sub_model_object_field': False,
750 if model_object_field:
751 fields_obj = self.pool.get('ir.model.fields')
752 field_value = fields_obj.browse(cr, uid, model_object_field, context)
753 if field_value.ttype in ['many2one', 'one2many', 'many2many']:
754 res_ids = self.pool.get('ir.model').search(cr, uid, [('model', '=', field_value.relation)], context=context)
755 sub_field_value = False
756 if sub_model_object_field:
757 sub_field_value = fields_obj.browse(cr, uid, sub_model_object_field, context)
760 'sub_object': res_ids[0],
761 'copyvalue': self._build_expression(field_value.name, sub_field_value and sub_field_value.name or False),
762 'sub_model_object_field': sub_model_object_field or False,
766 'copyvalue': self._build_expression(field_value.name, False),
768 return {'value': result}
770 def onchange_id_object(self, cr, uid, ids, id_object, context=None):
772 ref_model, ref_id = id_object.split(',')
773 return {'value': {'id_value': ref_id}}
774 return {'value': {'id_value': False}}
776 def create_action(self, cr, uid, ids, context=None):
777 """ Create a contextual action for each of the server actions. """
778 for action in self.browse(cr, uid, ids, context=context):
779 ir_values_id = self.pool.get('ir.values').create(cr, SUPERUSER_ID, {
780 'name': _('Run %s') % action.name,
781 'model': action.model_id.model,
782 'key2': 'client_action_multi',
783 'value': "ir.actions.server,%s" % action.id,
786 'menu_ir_values_id': ir_values_id,
791 def unlink_action(self, cr, uid, ids, context=None):
792 """ Remove the contextual actions created for the server actions. """
793 for action in self.browse(cr, uid, ids, context=context):
794 if action.menu_ir_values_id:
796 self.pool.get('ir.values').unlink(cr, SUPERUSER_ID, action.menu_ir_values_id.id, context)
798 raise osv.except_osv(_('Warning'), _('Deletion of the action record failed.'))
801 def run_action_client_action(self, cr, uid, action, eval_context=None, context=None):
802 if not action.action_id:
803 raise osv.except_osv(_('Error'), _("Please specify an action to launch!"))
804 return self.pool[action.action_id.type].read(cr, uid, action.action_id.id, context=context)
806 def run_action_code_multi(self, cr, uid, action, eval_context=None, context=None):
807 eval(action.code.strip(), eval_context, mode="exec", nocopy=True) # nocopy allows to return 'action'
808 if 'action' in eval_context:
809 return eval_context['action']
811 def run_action_trigger(self, cr, uid, action, eval_context=None, context=None):
812 """ Trigger a workflow signal, depending on the use_relational_model:
814 - `base`: base_model_pool.signal_<TRIGGER_NAME>(cr, uid, context.get('active_id'))
815 - `relational`: find the related model and object, using the relational
816 field, then target_model_pool.signal_<TRIGGER_NAME>(cr, uid, target_id)
818 obj_pool = self.pool[action.model_id.model]
819 if action.use_relational_model == 'base':
820 target_id = context.get('active_id')
821 target_pool = obj_pool
823 value = getattr(obj_pool.browse(cr, uid, context.get('active_id'), context=context), action.wkf_field_id.name)
824 if action.wkf_field_id.ttype == 'many2one':
828 target_pool = self.pool[action.wkf_model_id.model]
830 trigger_name = action.wkf_transition_id.signal
832 workflow.trg_validate(uid, target_pool._name, target_id, trigger_name, cr)
834 def run_action_multi(self, cr, uid, action, eval_context=None, context=None):
836 for act in action.child_ids:
837 result = self.run(cr, uid, [act.id], context)
840 return res and res[0] or False
842 def run_action_object_write(self, cr, uid, action, eval_context=None, context=None):
843 """ Write server action.
845 - 1. evaluate the value mapping
846 - 2. depending on the write configuration:
848 - `current`: id = active_id
849 - `other`: id = from reference object
850 - `expression`: id = from expression evaluation
853 for exp in action.fields_lines:
854 if exp.type == 'equation':
855 expr = eval(exp.value, eval_context)
858 res[exp.col1.name] = expr
860 if action.use_write == 'current':
861 model = action.model_id.model
862 ref_id = context.get('active_id')
863 elif action.use_write == 'other':
864 model = action.crud_model_id.model
865 ref_id = action.ref_object.id
866 elif action.use_write == 'expression':
867 model = action.crud_model_id.model
868 ref = eval(action.write_expression, eval_context)
869 if isinstance(ref, browse_record):
870 ref_id = getattr(ref, 'id')
874 obj_pool = self.pool[model]
875 obj_pool.write(cr, uid, [ref_id], res, context=context)
877 def run_action_object_create(self, cr, uid, action, eval_context=None, context=None):
878 """ Create and Copy server action.
880 - 1. evaluate the value mapping
881 - 2. depending on the write configuration:
883 - `new`: new record in the base model
884 - `copy_current`: copy the current record (id = active_id) + gives custom values
885 - `new_other`: new record in target model
886 - `copy_other`: copy the current record (id from reference object)
887 + gives custom values
890 for exp in action.fields_lines:
891 if exp.type == 'equation':
892 expr = eval(exp.value, eval_context)
895 res[exp.col1.name] = expr
897 if action.use_create in ['new', 'copy_current']:
898 model = action.model_id.model
899 elif action.use_create in ['new_other', 'copy_other']:
900 model = action.crud_model_id.model
902 obj_pool = self.pool[model]
903 if action.use_create == 'copy_current':
904 ref_id = context.get('active_id')
905 res_id = obj_pool.copy(cr, uid, ref_id, res, context=context)
906 elif action.use_create == 'copy_other':
907 ref_id = action.ref_object.id
908 res_id = obj_pool.copy(cr, uid, ref_id, res, context=context)
910 res_id = obj_pool.create(cr, uid, res, context=context)
912 if action.link_new_record and action.link_field_id:
913 self.pool[action.model_id.model].write(cr, uid, [context.get('active_id')], {action.link_field_id.name: res_id})
915 def _eval_context_for_action(self, cr, uid, action, context=None):
918 model = self.pool[action.model_id.model]
919 active_id = context.get('active_id')
920 active_ids = context.get('active_ids', [active_id] if active_id else [])
922 if context.get('active_model') == action.model_id.model and active_id:
923 context = dict(context, active_ids=active_ids, active_id=active_id)
924 target_record = model.browse(cr, uid, active_id, context=context) if active_id else None
925 user = self.pool['res.users'].browse(cr, uid, uid)
928 'object': target_record,
929 'obj': target_record,
932 'datetime': datetime,
933 'dateutil': dateutil,
942 def run(self, cr, uid, ids, context=None):
943 """ Runs the server action. For each server action, the condition is
944 checked. Note that a void (``False``) condition is considered as always
945 valid. If it is verified, the run_action_<STATE> method is called. This
946 allows easy overriding of the server actions.
948 :param dict context: context should contain following keys
950 - active_id: id of the current object (single mode)
951 - active_model: current model that should equal the action's model
953 The following keys are optional:
955 - active_ids: ids of the current records (mass mode). If active_ids
956 and active_id are present, active_ids is given precedence.
958 :return: an action_id to be executed, or False is finished correctly without
964 for action in self.browse(cr, uid, ids, context):
965 eval_context = self._eval_context_for_action(cr, uid, action, context)
966 condition = action.condition
967 if condition is False:
968 # Void (aka False) conditions are considered as True
970 if hasattr(self, 'run_action_%s_multi' % action.state):
971 run_context = eval_context['context']
972 expr = eval(str(condition), eval_context)
975 # call the multi method
976 func = getattr(self, 'run_action_%s_multi' % action.state)
977 res = func(cr, uid, action, eval_context=eval_context, context=run_context)
979 elif hasattr(self, 'run_action_%s' % action.state):
980 func = getattr(self, 'run_action_%s' % action.state)
981 active_id = context.get('active_id')
982 active_ids = context.get('active_ids', [active_id] if active_id else [])
983 for active_id in active_ids:
984 # run context dedicated to a particular active_id
985 run_context = dict(context, active_ids=[active_id], active_id=active_id)
986 eval_context["context"] = run_context
987 expr = eval(str(condition), eval_context)
990 # call the single method related to the action: run_action_<STATE>
991 res = func(cr, uid, action, eval_context=eval_context, context=run_context)
995 class ir_server_object_lines(osv.osv):
996 _name = 'ir.server.object.lines'
997 _sequence = 'ir_actions_id_seq'
999 'server_id': fields.many2one('ir.actions.server', 'Related Server Action'),
1000 'col1': fields.many2one('ir.model.fields', 'Field', required=True),
1001 'value': fields.text('Value', required=True, help="Expression containing a value specification. \n"
1002 "When Formula type is selected, this field may be a Python expression "
1003 " that can use the same values as for the condition field on the server action.\n"
1004 "If Value type is selected, the value will be used directly without evaluation."),
1005 'type': fields.selection([
1007 ('equation', 'Python expression')
1008 ], 'Evaluation Type', required=True, change_default=True),
1015 TODO_STATES = [('open', 'To Do'),
1017 TODO_TYPES = [('manual', 'Launch Manually'),('once', 'Launch Manually Once'),
1018 ('automatic', 'Launch Automatically')]
1019 class ir_actions_todo(osv.osv):
1021 Configuration Wizards
1023 _name = 'ir.actions.todo'
1024 _description = "Configuration Wizards"
1026 'action_id': fields.many2one(
1027 'ir.actions.actions', 'Action', select=True, required=True),
1028 'sequence': fields.integer('Sequence'),
1029 'state': fields.selection(TODO_STATES, string='Status', required=True),
1030 'name': fields.char('Name', size=64),
1031 'type': fields.selection(TODO_TYPES, 'Type', required=True,
1032 help="""Manual: Launched manually.
1033 Automatic: Runs whenever the system is reconfigured.
1034 Launch Manually Once: after having been launched manually, it sets automatically to Done."""),
1035 'groups_id': fields.many2many('res.groups', 'res_groups_action_rel', 'uid', 'gid', 'Groups'),
1036 'note': fields.text('Text', translate=True),
1043 _order="sequence,id"
1045 def action_launch(self, cr, uid, ids, context=None):
1046 """ Launch Action of Wizard"""
1047 wizard_id = ids and ids[0] or False
1048 wizard = self.browse(cr, uid, wizard_id, context=context)
1049 if wizard.type in ('automatic', 'once'):
1050 wizard.write({'state': 'done'})
1053 act_type = self.pool.get('ir.actions.actions').read(cr, uid, wizard.action_id.id, ['type'], context=context)
1055 res = self.pool[act_type['type']].read(cr, uid, wizard.action_id.id, [], context=context)
1056 if act_type['type'] != 'ir.actions.act_window':
1058 res.setdefault('context','{}')
1059 res['nodestroy'] = True
1061 # Open a specific record when res_id is provided in the context
1062 user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
1063 ctx = eval(res['context'], {'user': user})
1064 if ctx.get('res_id'):
1065 res.update({'res_id': ctx.pop('res_id')})
1067 # disable log for automatic wizards
1068 if wizard.type == 'automatic':
1069 ctx.update({'disable_log': True})
1070 res.update({'context': ctx})
1074 def action_open(self, cr, uid, ids, context=None):
1075 """ Sets configuration wizard in TODO state"""
1076 return self.write(cr, uid, ids, {'state': 'open'}, context=context)
1078 def progress(self, cr, uid, context=None):
1079 """ Returns a dict with 3 keys {todo, done, total}.
1081 These keys all map to integers and provide the number of todos
1082 marked as open, the total number of todos and the number of
1083 todos not open (which is basically a shortcut to total-todo)
1087 user_groups = set(map(
1089 self.pool['res.users'].browse(cr, uid, [uid], context=context)[0].groups_id))
1090 def groups_match(todo):
1091 """ Checks if the todo's groups match those of the current user
1093 return not todo.groups_id \
1094 or bool(user_groups.intersection((
1095 group.id for group in todo.groups_id)))
1099 self.browse(cr, uid,
1100 self.search(cr, uid, [('state', '!=', 'open')], context=context),
1105 self.browse(cr, uid,
1106 self.search(cr, uid, [], context=context),
1111 'total': len(total),
1112 'todo': len(total) - len(done)
1116 class ir_actions_act_client(osv.osv):
1117 _name = 'ir.actions.client'
1118 _inherit = 'ir.actions.actions'
1119 _table = 'ir_act_client'
1120 _sequence = 'ir_actions_id_seq'
1123 def _get_params(self, cr, uid, ids, field_name, arg, context):
1125 for record in self.browse(cr, uid, ids, context=context):
1126 result[record.id] = record.params_store and eval(record.params_store, {'uid': uid}) or False
1129 def _set_params(self, cr, uid, id, field_name, field_value, arg, context):
1130 if isinstance(field_value, dict):
1131 self.write(cr, uid, id, {'params_store': repr(field_value)}, context=context)
1133 self.write(cr, uid, id, {'params_store': field_value}, context=context)
1136 'name': fields.char('Action Name', required=True, size=64, translate=True),
1137 'tag': fields.char('Client action tag', size=64, required=True,
1138 help="An arbitrary string, interpreted by the client"
1139 " according to its own needs and wishes. There "
1140 "is no central tag repository across clients."),
1141 'res_model': fields.char('Destination Model', size=64,
1142 help="Optional model, mostly used for needactions."),
1143 'context': fields.char('Context Value', size=250, required=True,
1144 help="Context dictionary as Python expression, empty by default (Default: {})"),
1145 'params': fields.function(_get_params, fnct_inv=_set_params,
1147 string="Supplementary arguments",
1148 help="Arguments sent to the client along with"
1150 'params_store': fields.binary("Params storage", readonly=True)
1153 'type': 'ir.actions.client',
1160 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: