1561 lines
71 KiB
Python
1561 lines
71 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
import logging
|
|
import json
|
|
|
|
from ast import literal_eval
|
|
from copy import deepcopy
|
|
from lxml import etree
|
|
|
|
import odoo
|
|
from odoo import http, _
|
|
from odoo.http import content_disposition, request
|
|
from odoo.exceptions import UserError, AccessError, ValidationError
|
|
from odoo.addons.web_studio.controllers import export
|
|
from odoo.osv import expression
|
|
from odoo.tools import ustr, sql
|
|
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
# contains all valid operations
|
|
OPERATIONS_WHITELIST = [
|
|
'add',
|
|
'attributes',
|
|
'avatar_image',
|
|
'buttonbox',
|
|
'chatter',
|
|
'enable_approval',
|
|
'kanban_dropdown',
|
|
'kanban_image',
|
|
'kanban_priority',
|
|
'kanban_set_cover',
|
|
'map_popup_fields',
|
|
'pivot_measures_fields',
|
|
'graph_pivot_groupbys_fields',
|
|
'move',
|
|
'remove',
|
|
'statusbar',
|
|
]
|
|
|
|
|
|
class WebStudioController(http.Controller):
|
|
|
|
@http.route('/web_studio/chatter_allowed', type='json', auth='user')
|
|
def is_chatter_allowed(self, model):
|
|
""" Returns True iff a chatter can be activated on the model's form views, i.e. if
|
|
- it is a custom model (since we can make it inherit from mail.thread), or
|
|
- it already inherits from mail.thread.
|
|
"""
|
|
Model = request.env[model]
|
|
return Model._custom or isinstance(Model, type(request.env['mail.thread']))
|
|
|
|
@http.route('/web_studio/activity_allowed', type='json', auth='user')
|
|
def is_activity_allowed(self, model):
|
|
""" Returns True iff an activity view can be activated on the model's action, i.e. if
|
|
- it is a custom model (since we can make it inherit from mail.thread), or
|
|
- it already inherits from mail.thread.
|
|
"""
|
|
Model = request.env[model]
|
|
return Model._custom or isinstance(Model, type(request.env['mail.activity.mixin']))
|
|
|
|
@http.route('/web_studio/get_studio_action', type='json', auth='user')
|
|
def get_studio_action(self, action_name, model, view_id=None, view_type=None):
|
|
view_type = 'tree' if view_type == 'list' else view_type # list is stored as tree in db
|
|
model = request.env['ir.model']._get(model)
|
|
|
|
action = None
|
|
if hasattr(self, '_get_studio_action_' + action_name):
|
|
action = getattr(self, '_get_studio_action_' + action_name)(model, view_id=view_id, view_type=view_type)
|
|
|
|
return action
|
|
|
|
def _get_studio_action_acl(self, model, **kwargs):
|
|
return {
|
|
'name': _('Access Control Lists'),
|
|
'type': 'ir.actions.act_window',
|
|
'res_model': 'ir.model.access',
|
|
'views': [[False, 'list'], [False, 'form']],
|
|
'target': 'current',
|
|
'domain': [],
|
|
'context': {
|
|
'default_model_id': model.id,
|
|
'search_default_model_id': model.id,
|
|
},
|
|
'help': _("""<p class="o_view_nocontent_smiling_face">
|
|
Add a new access control list
|
|
</p>
|
|
"""),
|
|
}
|
|
|
|
def _get_studio_action_automations(self, model, **kwargs):
|
|
return {
|
|
'name': _('Automated Actions'),
|
|
'type': 'ir.actions.act_window',
|
|
'res_model': 'base.automation',
|
|
'views': [[False, 'list'], [False, 'form']],
|
|
'target': 'current',
|
|
'domain': [],
|
|
'context': {
|
|
'default_model_id': model.id,
|
|
'search_default_model_id': model.id,
|
|
},
|
|
'help': _(""" <p class="o_view_nocontent_smiling_face">
|
|
Add a new automated action
|
|
</p>
|
|
"""),
|
|
}
|
|
|
|
def _get_studio_action_filters(self, model, **kwargs):
|
|
return {
|
|
'name': _('Filter Rules'),
|
|
'type': 'ir.actions.act_window',
|
|
'res_model': 'ir.filters',
|
|
'views': [[False, 'list'], [False, 'form']],
|
|
'target': 'current',
|
|
'domain': [],
|
|
'context': { # model_id is a Selection on ir.filters
|
|
'default_model_id': model.model,
|
|
'search_default_model_id': model.model,
|
|
},
|
|
'help': _(""" <p class="o_view_nocontent_smiling_face">
|
|
Add a new filter
|
|
</p>
|
|
"""),
|
|
}
|
|
|
|
def _get_studio_action_reports(self, model, **kwargs):
|
|
return {
|
|
'name': _('Reports'),
|
|
'type': 'ir.actions.act_window',
|
|
'res_model': 'ir.actions.report',
|
|
'views': [[False, 'kanban'], [False, 'form']],
|
|
'target': 'current',
|
|
# One can edit only reports backed by persisting models
|
|
'domain': [
|
|
'&',
|
|
("model_id.transient", "=", False),
|
|
("model_id.abstract", "=", False),
|
|
("report_type", "not in", ['qweb-text'])
|
|
],
|
|
'context': {
|
|
'default_model': model.model,
|
|
'search_default_model': model.model,
|
|
},
|
|
'help': _(""" <p class="o_view_nocontent_empty_report">
|
|
Add a new report
|
|
</p>
|
|
"""),
|
|
}
|
|
|
|
@http.route('/web_studio/create_new_app', type='json', auth='user')
|
|
def create_new_app(self, app_name=False, menu_name=False, model_choice=False, model_id=False, model_options=False, icon=None):
|
|
"""Create a new app @app_name, linked to a new action associated to the model_id or the newlyy created model.
|
|
@param menu_name: name of the first menu (and model if model_choice is 'new') of the app
|
|
@param model_choice: 'new' for a new model, 'existing' for an existing model selected in the wizard
|
|
@param model_id: the model which will be associated to the action if menu_choice is 'existing'
|
|
@param model_options: dictionary of options for the model to be created to include some behaviours OoB
|
|
(e.g. archiving, messaging, etc.)
|
|
@param icon: the icon of the new app.
|
|
It can either be:
|
|
- the ir.attachment id of the uploaded image
|
|
- if the icon has been created, an array containing: [icon_class, color, background_color]
|
|
"""
|
|
_logger.info('creating new app "%s" with main menu "%s"', app_name, menu_name)
|
|
if model_choice == 'existing' and model_id:
|
|
model = request.env['ir.model'].browse(model_id)
|
|
extra_models = request.env['ir.model']
|
|
_logger.info('using existing model %s as main model, all main views duplicated for use in the new app', model.model)
|
|
elif model_choice == 'new' and menu_name:
|
|
# create a new model
|
|
(model, extra_models) = request.env['ir.model'].studio_model_create(menu_name, options=model_options)
|
|
_logger.info('created new model %s as main model with the following options: %s', model.model, ','.join(model_options))
|
|
else:
|
|
_logger.error('inconsistent parameters: model_choice is %s, model_id is %s and menu_name(model) is %s', model_choice, model_id, menu_name)
|
|
raise UserError(_("If you don't want to create a new model, an existing model should be selected."))
|
|
|
|
action = model._create_default_action(menu_name)
|
|
action_ref = 'ir.actions.act_window,' + str(action.id)
|
|
|
|
# create the menus (app menu + first submenu)
|
|
menu_values = {
|
|
'name': app_name,
|
|
}
|
|
child_menu_vals = [(0, 0, {'name': menu_name,'action': action_ref})]
|
|
|
|
# check if a configuration menu is needed
|
|
if extra_models:
|
|
configuration_menu_vals = {'name': _('Configuration'), 'child_id': [], 'is_studio_configuration': True, 'sequence': 100}
|
|
for extra_model in extra_models:
|
|
extra_action = extra_model._create_default_action(extra_model.name)
|
|
configuration_menu_vals['child_id'].append((0, 0, {'name': extra_model.name, 'action': 'ir.actions.act_window,'+ str(extra_action.id)}))
|
|
child_menu_vals.append((0, 0, configuration_menu_vals))
|
|
|
|
menu_values.update(self._get_icon_fields(icon))
|
|
menu_values['child_id'] = child_menu_vals
|
|
|
|
new_menu = request.env['ir.ui.menu'].with_context(**{'ir.ui.menu.full_list': True}).create(menu_values)
|
|
|
|
return {
|
|
'menu_id': new_menu.id,
|
|
'action_id': action.id,
|
|
}
|
|
|
|
@http.route('/web_studio/create_new_menu', type='json', auth='user')
|
|
def create_new_menu(self, menu_name=False, model_choice=False, model_id=False, model_options=False, parent_menu_id=None):
|
|
""" Create a new menu @menu_name, linked to a new action associated to the model_id
|
|
@param model_choice: 'new' for a new model, 'existing' for an existing model selected in the wizard
|
|
@param model_id: the model which will be associated to the action if menu_choice is 'existing'
|
|
@param model_options: dictionary of options for the model to be created to include some behaviours OoB
|
|
(e.g. archiving, messaging, etc.)
|
|
@param parent_menu_id: the parent of the new menu.
|
|
"""
|
|
|
|
sequence = 10
|
|
if parent_menu_id:
|
|
menu = request.env['ir.ui.menu'].search_read([('parent_id', '=', parent_menu_id)], fields=['sequence'], order='sequence desc', limit=1)
|
|
if menu:
|
|
sequence = menu[0]['sequence'] + 1
|
|
|
|
_logger.info('creating new menu "%s"', menu_name)
|
|
if model_choice == 'existing' and model_id:
|
|
model = request.env['ir.model'].browse(model_id)
|
|
extra_models = request.env['ir.model']
|
|
_logger.info('using existing model %s, all main views duplicated for use in the new app', model.model)
|
|
elif model_choice == 'new' and menu_name:
|
|
# create a new model
|
|
(model, extra_models) = request.env['ir.model'].studio_model_create(menu_name, options=model_options)
|
|
_logger.info('created new model %s with the following options: %s', model.model, ','.join(model_options))
|
|
elif model_choice == 'parent':
|
|
(model, extra_models) = (None, None)
|
|
else:
|
|
_logger.error('inconsistent parameters: model_choice is %s, model_id is %s and menu_name(model) is %s', model_choice, model_id, menu_name)
|
|
raise UserError(_("If you don't want to create a new model, an existing model should be selected."))
|
|
|
|
# create the action
|
|
if model:
|
|
action = model._create_default_action(menu_name)
|
|
action_ref = 'ir.actions.act_window,' + str(action.id)
|
|
else:
|
|
action = request.env.ref('base.action_open_website')
|
|
action_ref = 'ir.actions.act_url,' + str(action.id)
|
|
|
|
# create the submenu
|
|
new_menu = request.env['ir.ui.menu'].create({
|
|
'name': menu_name,
|
|
'action': action_ref,
|
|
'parent_id': parent_menu_id,
|
|
'sequence': sequence,
|
|
})
|
|
|
|
# create extra menus for configuration of extra models (tags, stages)
|
|
if extra_models:
|
|
config_menu = new_menu._get_studio_configuration_menu()
|
|
child_menu_vals = list()
|
|
for extra_model in extra_models:
|
|
views = request.env['ir.ui.view'].search([('model', '=', extra_model.model)])
|
|
extra_action = extra_model._create_default_action(extra_model.name)
|
|
child_menu_vals.append((0, 0, {'name': extra_model.name, 'action': 'ir.actions.act_window,'+ str(extra_action.id)}))
|
|
config_menu.write({'child_id': child_menu_vals})
|
|
return {
|
|
'menu_id': new_menu.id,
|
|
'action_id': action.id,
|
|
}
|
|
|
|
@http.route('/web_studio/edit_menu_icon', type='json', auth='user')
|
|
def edit_menu_icon(self, menu_id, icon):
|
|
values = self._get_icon_fields(icon)
|
|
request.env['ir.ui.menu'].browse(menu_id).write(values)
|
|
|
|
def _get_icon_fields(self, icon):
|
|
""" Get icon related fields (depending on the @icon received). """
|
|
if isinstance(icon, int):
|
|
icon_id = request.env['ir.attachment'].browse(icon)
|
|
if not icon_id:
|
|
raise UserError(_('The icon is not linked to an attachment'))
|
|
return {'web_icon_data': icon_id.datas}
|
|
elif isinstance(icon, list) and len(icon) == 3:
|
|
return {'web_icon': ','.join(icon)}
|
|
else:
|
|
raise UserError(_('The icon has not a correct format'))
|
|
|
|
@http.route('/web_studio/set_background_image', type='json', auth='user')
|
|
def set_background_image(self, attachment_id):
|
|
attachment = request.env['ir.attachment'].browse(attachment_id)
|
|
if attachment:
|
|
request.env.company.background_image = attachment.datas
|
|
|
|
@http.route('/web_studio/reset_background_image', type='json', auth='user')
|
|
def reset_background_image(self):
|
|
if request.env.company in request.env.user.with_user(request.uid).company_ids:
|
|
request.env.company.background_image = None
|
|
|
|
def create_new_field(self, values):
|
|
""" Create a new field with given values.
|
|
In some cases we have to convert "id" to "name" or "name" to "id"
|
|
- "model" is the current model we are working on. In js, we only have his name.
|
|
but we need his id to create the field of this model.
|
|
- The relational widget doesn't provide any name, we only have the id of the record.
|
|
This is why we need to search the name depending of the given id.
|
|
"""
|
|
# Get current model
|
|
model_name = values.pop('model_name')
|
|
Model = request.env[model_name]
|
|
# If the model is backed by a sql view
|
|
# it doesn't make sense to add field, and won't work
|
|
table_kind = sql.table_kind(request.env.cr, Model._table)
|
|
if not table_kind or table_kind == 'v':
|
|
raise UserError(_('The model %s doesn\'t support adding fields.', Model._name))
|
|
|
|
values['model_id'] = request.env['ir.model']._get_id(model_name)
|
|
|
|
# Field type is called ttype in the database
|
|
if values.get('type'):
|
|
values['ttype'] = values.pop('type')
|
|
|
|
# For many2one and many2many fields
|
|
if values.get('relation_id'):
|
|
values['relation'] = request.env['ir.model'].browse(values.pop('relation_id')).model
|
|
# For related one2many fields
|
|
if values.get('related') and values.get('ttype') == 'one2many':
|
|
field_name = values.get('related').split('.')[-1]
|
|
field = request.env['ir.model.fields'].search([
|
|
('name', '=', field_name),
|
|
('model', '=', values.pop('relational_model')),
|
|
])
|
|
field.ensure_one()
|
|
values.update(
|
|
relation=field.relation,
|
|
relation_field=field.relation_field,
|
|
)
|
|
# For one2many fields
|
|
if values.get('relation_field_id'):
|
|
field = request.env['ir.model.fields'].browse(values.pop('relation_field_id'))
|
|
values.update(
|
|
relation=field.model_id.model,
|
|
relation_field=field.name,
|
|
)
|
|
# For selection fields
|
|
if values.get('selection'):
|
|
values['selection'] = ustr(values['selection'])
|
|
|
|
if values.get('ttype') == 'many2many':
|
|
# check for existing relation to avoid re-use
|
|
values['relation_table'] = request.env['ir.model.fields']._get_next_relation(model_name, values.get('relation'))
|
|
# Optional default value at creation
|
|
default_value = values.pop('default_value', False)
|
|
|
|
# Filter out invalid field names and create new field
|
|
values = {
|
|
k: v
|
|
for k, v in values.items()
|
|
if k in request.env['ir.model.fields']._fields
|
|
}
|
|
new_field = request.env['ir.model.fields'].create(values)
|
|
|
|
if default_value:
|
|
if new_field.ttype == 'selection':
|
|
if default_value is True:
|
|
# take the first selection value as default one in this case
|
|
default_value = new_field.selection_ids[:1].value
|
|
self.set_default_value(new_field.model, new_field.name, default_value)
|
|
|
|
return new_field
|
|
|
|
@http.route('/web_studio/add_view_type', type='json', auth='user')
|
|
def add_view_type(self, action_type, action_id, res_model, view_type, args):
|
|
view_type = 'tree' if view_type == 'list' else view_type # list is stored as tree in db
|
|
|
|
if view_type == 'activity':
|
|
model = request.env['ir.model']._get(res_model)
|
|
if model.state == 'manual' and not model.is_mail_activity:
|
|
# Activate mail.activity.mixin inheritance on the custom model
|
|
model.write({'is_mail_activity': True})
|
|
|
|
try:
|
|
request.env[res_model].get_view(view_type=view_type)
|
|
except UserError:
|
|
return False
|
|
self.edit_action(action_type, action_id, args)
|
|
return True
|
|
|
|
@http.route('/web_studio/edit_action', type='json', auth='user')
|
|
def edit_action(self, action_type, action_id, args):
|
|
|
|
action_id = request.env[action_type].browse(action_id)
|
|
if action_id:
|
|
if 'groups_id' in args:
|
|
args['groups_id'] = [(6, 0, args['groups_id'])]
|
|
|
|
if 'view_mode' in args:
|
|
args['view_mode'] = args['view_mode'].replace('list', 'tree') # list is stored as tree in db
|
|
|
|
# As view_id and view_ids have precedence on view_mode, we need to correctly set them
|
|
if action_id.view_id or action_id.view_ids:
|
|
view_modes = args['view_mode'].split(',')
|
|
|
|
# add new view_mode
|
|
missing_view_modes = [x for x in view_modes if x not in [y.view_mode for y in action_id.view_ids]]
|
|
for view_mode in missing_view_modes:
|
|
vals = {
|
|
'act_window_id': action_id.id,
|
|
'view_mode': view_mode,
|
|
}
|
|
if action_id.view_id and action_id.view_id.type == view_mode:
|
|
# reuse the same view_id in the corresponding view_ids record
|
|
vals['view_id'] = action_id.view_id.id
|
|
|
|
request.env['ir.actions.act_window.view'].create(vals)
|
|
|
|
for view_id in action_id.view_ids:
|
|
if view_id.view_mode in view_modes:
|
|
# resequence according to new view_modes
|
|
view_id.sequence = view_modes.index(view_id.view_mode)
|
|
else:
|
|
# remove old view_mode
|
|
view_id.unlink()
|
|
|
|
action_id.write(args)
|
|
|
|
return True
|
|
|
|
def _get_studio_view(self, view):
|
|
domain = [('inherit_id', '=', view.id), ('name', '=', self._generate_studio_view_name(view))]
|
|
return view.search(domain, order='priority desc, name desc, id desc', limit=1)
|
|
|
|
def _set_studio_view(self, view, arch):
|
|
studio_view = self._get_studio_view(view)
|
|
if studio_view and len(arch):
|
|
studio_view.arch_db = arch
|
|
elif studio_view:
|
|
studio_view.unlink()
|
|
elif len(arch):
|
|
self._create_studio_view(view, arch)
|
|
|
|
def _generate_studio_view_name(self, view):
|
|
return "Odoo Studio: %s customization" % (view.name)
|
|
|
|
@http.route('/web_studio/get_studio_view_arch', type='json', auth='user')
|
|
def get_studio_view_arch(self, model, view_type, view_id=False):
|
|
view_type = 'tree' if view_type == 'list' else view_type # list is stored as tree in db
|
|
|
|
if not view_id:
|
|
# TOFIX: it's possibly not the used view ; see fields_get_view
|
|
# try to find the lowest priority matching ir.ui.view
|
|
view_id = request.env['ir.ui.view'].default_view(request.env[model]._name, view_type)
|
|
# We have to create a view with the default view if we want to customize it.
|
|
ir_model = request.env['ir.model']._get(model)
|
|
view = ir_model._get_default_view(view_type, view_id)
|
|
studio_view = self._get_studio_view(view)
|
|
|
|
return {
|
|
'studio_view_id': studio_view and studio_view.id or False,
|
|
'studio_view_arch': studio_view and studio_view.arch_db or "<data/>",
|
|
}
|
|
|
|
def _return_view(self, view, studio_view):
|
|
ViewModel = request.env[view.model]
|
|
fields_view = ViewModel.with_context(studio=True).get_view(view.id, view.type)
|
|
view_type = 'list' if view.type == 'tree' else view.type
|
|
models = fields_view['models']
|
|
|
|
return {
|
|
'views': {view_type: fields_view},
|
|
'studio_view_id': studio_view.id,
|
|
'models': {model: request.env[model].fields_get() for model in models}
|
|
}
|
|
|
|
@http.route('/web_studio/restore_default_view', type='json', auth='user')
|
|
def restore_default_view(self, view_id):
|
|
view = request.env['ir.ui.view'].browse(view_id)
|
|
self._set_studio_view(view, "")
|
|
|
|
studio_view = self._get_studio_view(view)
|
|
|
|
return self._return_view(view, studio_view)
|
|
|
|
@http.route('/web_studio/edit_approval', type='json', auth='user')
|
|
def edit_approval(self, model, method, action, operations=None):
|
|
for operation in operations:
|
|
rule_id = operation[1]
|
|
rule = request.env['studio.approval.rule'].browse(rule_id)
|
|
if operation[0] == 'operation_approval_message':
|
|
rule.message = operation[2]
|
|
elif operation[0] == 'operation_different_users':
|
|
rule.exclusive_user = operation[2]
|
|
return True
|
|
|
|
@http.route('/web_studio/edit_view', type='json', auth='user')
|
|
def edit_view(self, view_id, studio_view_arch, operations=None, model=None):
|
|
IrModelFields = request.env['ir.model.fields']
|
|
view = request.env['ir.ui.view'].browse(view_id)
|
|
operations = operations or []
|
|
for op in operations:
|
|
if op['type'] not in OPERATIONS_WHITELIST:
|
|
raise ValidationError(_('The operation type "%s" is not supported', op['type']))
|
|
parser = etree.XMLParser(remove_blank_text=True)
|
|
if studio_view_arch == "":
|
|
studio_view_arch = '<data/>'
|
|
arch = etree.fromstring(studio_view_arch, parser=parser)
|
|
model = model or view.model
|
|
|
|
# Determine whether an operation is associated with
|
|
# the creation of a binary field
|
|
def create_binary_field(op):
|
|
node = op.get('node')
|
|
if node and node.get('tag') == 'field' and node.get('field_description'):
|
|
ttype = node['field_description'].get('type')
|
|
is_related = node['field_description'].get("related")
|
|
is_image = node['attrs'].get('widget') == 'image'
|
|
is_signature = node['attrs'].get('widget') == 'signature'
|
|
return ttype == 'binary' and not is_image and not is_signature and not is_related
|
|
return False
|
|
|
|
# Every time the creation of a binary field is requested,
|
|
# we also create an invisible char field meant to contain the filename.
|
|
# The char field is then associated with the binary field
|
|
# via the 'filename' attribute of the latter.
|
|
# Do it in another list to keep the order of the operations
|
|
# otherwise, the "append" of the filemane binary would be misplaced
|
|
_operations = []
|
|
for op in operations:
|
|
_operations.append(op)
|
|
if not create_binary_field(op):
|
|
continue
|
|
bin_file_field_name = op['node']['field_description']['name']
|
|
filename = bin_file_field_name + '_filename'
|
|
|
|
# Create an operation adding an additional char field
|
|
char_op = deepcopy(op)
|
|
char_op['node']['field_description'].update({
|
|
'name': filename,
|
|
'type': 'char',
|
|
'field_description': _('Filename for %s', op['node']['field_description']['name']),
|
|
})
|
|
char_op['node']['attrs']['invisible'] = '1'
|
|
|
|
# put the filename field after the binary field
|
|
char_op['target']['xpath_info'] = None
|
|
char_op['target']['tag'] = 'field'
|
|
char_op['target']['attrs'] = {'name': bin_file_field_name}
|
|
char_op['target']['position'] = 'after'
|
|
char_op['position'] = 'after'
|
|
|
|
_operations.append(char_op)
|
|
|
|
op['node']['attrs']['filename'] = filename
|
|
|
|
operations = _operations
|
|
for op in operations:
|
|
# create a new field if it does not exist
|
|
if 'node' in op:
|
|
if op['node'].get('tag') == 'field' and op['node'].get('field_description'):
|
|
if op['node']['field_description'].get('special') == 'lines':
|
|
field = request.env['ir.model']._get(model)._setup_one2many_lines()
|
|
else:
|
|
model = op['node']['field_description']['model_name']
|
|
# Check if field exists before creation
|
|
field = IrModelFields.search([
|
|
('name', '=', op['node']['field_description']['name']),
|
|
('model', '=', model),
|
|
], limit=1)
|
|
if not field:
|
|
field = self.create_new_field(op['node']['field_description'])
|
|
op['node']['attrs']['name'] = field.name
|
|
if op['node'].get('tag') == 'filter' and op['target']['tag'] == 'group' and op['node']['attrs'].get('create_group'):
|
|
op['node']['attrs'].pop('create_group')
|
|
create_group_op = {
|
|
'node': {
|
|
'tag': 'group',
|
|
'attrs': {
|
|
'name': 'studio_group_by',
|
|
}
|
|
},
|
|
'empty': True,
|
|
'target': {
|
|
'tag': 'search',
|
|
},
|
|
'position': 'inside',
|
|
}
|
|
self._operation_add(arch, create_group_op, model)
|
|
# set a more specific xpath (with templates//) for the kanban view
|
|
if view.type == 'kanban':
|
|
if op.get('target') and op['target'].get('tag') == 'field':
|
|
op['target']['tag'] = 'templates//field'
|
|
if op['target'].get('extra_nodes'):
|
|
for target in op['target']['extra_nodes']:
|
|
target['tag'] = 'templates//' + target['tag']
|
|
|
|
# call the right operation handler
|
|
getattr(self, '_operation_%s' % (op['type']))(arch, op, model)
|
|
|
|
# Save or create changes into studio view, identifiable by xmlid
|
|
# Example for view id 42 of model crm.lead: web-studio_crm.lead-42
|
|
new_arch = etree.tostring(arch, encoding='unicode', pretty_print=True)
|
|
self._set_studio_view(view, new_arch)
|
|
|
|
# Normalize the view
|
|
studio_view = self._get_studio_view(view)
|
|
try:
|
|
normalized_view = studio_view.normalize()
|
|
self._set_studio_view(view, normalized_view)
|
|
except ValidationError: # Element '<...>' cannot be located in parent view
|
|
# If the studio view is not applicable after normalization, let's
|
|
# just ignore the normalization step, it's better to have a studio
|
|
# view that is not optimized than to prevent the user from making
|
|
# the change he would like to make.
|
|
self._set_studio_view(view, new_arch)
|
|
|
|
return self._return_view(view, studio_view)
|
|
|
|
@http.route('/web_studio/rename_field', type='json', auth='user')
|
|
def rename_field(self, studio_view_id, studio_view_arch, model, old_name, new_name):
|
|
studio_view = request.env['ir.ui.view'].browse(studio_view_id)
|
|
|
|
# a field cannot be renamed if it appears in a view ; we thus reset the
|
|
# studio view before all operations to be able to rename the field
|
|
studio_view.arch_db = studio_view_arch
|
|
|
|
field_id = request.env['ir.model.fields']._get(model, old_name)
|
|
field_id.write({'name': new_name})
|
|
|
|
if field_id.ttype == 'binary' and not field_id.related:
|
|
# during the binary field creation, another char field containing
|
|
# the filename has been created (see @edit_view). To avoid creating
|
|
# the field twice, it is also renamed
|
|
filename_field_id = request.env['ir.model.fields']._get(model, old_name + '_filename')
|
|
if filename_field_id:
|
|
filename_field_id.write({'name': new_name + '_filename'})
|
|
|
|
def _create_studio_view(self, view, arch):
|
|
# We have to play with priorities. Consider the following:
|
|
# View Base: <field name="x"/><field name="y"/>
|
|
# View Standard inherits Base: <field name="x" position="after"><field name="z"/></field>
|
|
# View Custo inherits Base: <field name="x" position="after"><field name="x2"/></field>
|
|
# We want x,x2,z,y, because that's what we did in studio, but the order of xpath
|
|
# resolution is sequence,name, not sequence,id. Because "Custo" < "Standard", it
|
|
# would first resolve in x,x2,y, then resolve "Standard" with x,z,x2,y as result.
|
|
return request.env['ir.ui.view'].create({
|
|
'type': view.type,
|
|
'model': view.model,
|
|
'inherit_id': view.id,
|
|
'mode': 'extension',
|
|
'priority': 99,
|
|
'arch': arch,
|
|
'name': self._generate_studio_view_name(view),
|
|
})
|
|
|
|
@http.route('/web_studio/edit_field', type='json', auth='user')
|
|
def edit_field(self, model_name, field_name, values, force_edit=False):
|
|
field = request.env['ir.model.fields'].search([('model', '=', model_name), ('name', '=', field_name)])
|
|
|
|
if field.ttype == 'selection' and 'selection' in values:
|
|
selection_values = [False] + [x[0] for x in literal_eval(values['selection'])]
|
|
records = request.env[model_name].search([(field_name, 'not in', selection_values)])
|
|
if records and not force_edit:
|
|
message = _("""There are %s records using selection values not listed in those you are trying to save.
|
|
Are you sure you want to remove the selection values of those records?""") % len(records)
|
|
return {'records_linked': len(records), 'message': message}
|
|
records.write({field_name: False})
|
|
|
|
field.write(values)
|
|
|
|
# remove default value if the value is not acceptable anymore
|
|
if field.ttype == 'selection':
|
|
current_default = request.env['ir.default'].get(model_name, field_name, company_id=True)
|
|
if current_default:
|
|
selection_values = literal_eval(field.selection)
|
|
if current_default not in [x[0] for x in selection_values]:
|
|
request.env['ir.default'].discard_values(model_name, field_name, [current_default])
|
|
|
|
@http.route('/web_studio/edit_view_arch', type='json', auth='user')
|
|
def edit_view_arch(self, view_id, view_arch):
|
|
view = request.env['ir.ui.view'].browse(view_id)
|
|
|
|
if view:
|
|
view.write({'arch': view_arch})
|
|
ViewModel = request.env[view.model]
|
|
try:
|
|
fields_view = ViewModel.with_context(studio=True).get_view(view.id, view.type)
|
|
view_type = 'list' if view.type == 'tree' else view.type
|
|
models = fields_view['models']
|
|
return {
|
|
'views': {view_type: fields_view},
|
|
'model_fields': {model: request.env[model].fields_get() for model in models}
|
|
}
|
|
except Exception:
|
|
return False
|
|
|
|
@http.route('/web_studio/export', type='http', auth='user')
|
|
def export(self, **kw):
|
|
""" Exports a zip file containing the 'studio_customization' module
|
|
gathering all customizations done with Studio (customizations of
|
|
existing apps and freshly created apps).
|
|
"""
|
|
studio_module = request.env['ir.module.module'].get_studio_module()
|
|
data = request.env['ir.model.data'].search([('studio', '=', True)])
|
|
content = export.generate_archive(studio_module, data)
|
|
|
|
return request.make_response(content, headers=[
|
|
('Content-Disposition', content_disposition('customizations.zip')),
|
|
('Content-Type', 'application/zip'),
|
|
('Content-Length', len(content)),
|
|
])
|
|
|
|
@http.route('/web_studio/create_default_view', type='json', auth='user')
|
|
def create_default_view(self, model, view_type, attrs):
|
|
attrs['string'] = "Default %s view for %s" % (view_type, model)
|
|
arch = self._get_default_view(view_type, attrs)
|
|
request.env['ir.ui.view'].create({
|
|
'type': view_type,
|
|
'model': model,
|
|
'arch': arch,
|
|
'name': attrs['string'],
|
|
})
|
|
|
|
def _get_default_view(self, view_type, attrs):
|
|
arch = etree.Element(view_type, attrs)
|
|
return etree.tostring(arch, encoding='unicode', pretty_print=True, method='html')
|
|
|
|
def _node_to_expr(self, node):
|
|
if node.get('xpath_info') and not node.get('subview_xpath'):
|
|
# Format of expr is /form/tag1[]/tag2[]/[...]/tag[]
|
|
expr = ''.join(['/%s[%s]' % (parent['tag'], parent['indice']) for parent in node.get('xpath_info')])
|
|
else:
|
|
# Format of expr is //tag[@attr1_name=attr1_value][@attr2_name=attr2_value][...]
|
|
expr = '//' + node['tag']
|
|
for k, v in node.get('attrs', {}).items():
|
|
if k == 'class':
|
|
# Special case for classes which usually contain multiple values
|
|
expr += '[contains(@%s,\'%s\')]' % (k, v)
|
|
else:
|
|
expr += '[@%s=\'%s\']' % (k, v)
|
|
|
|
# Avoid matching nodes in sub views.
|
|
# Example with field as node:
|
|
# A field should be defined only once in a view but in some cases,
|
|
# a view can be composed by some other views where a field with
|
|
# the same name may exist.
|
|
# Here, we want to generate xpath based on the nodes in the parent view only.
|
|
if not node.get('subview_xpath'):
|
|
expr = expr + '[not(ancestor::field)]'
|
|
|
|
# If we receive a more specific xpath because we are editing an inline
|
|
# view, we add it in front of the generated xpath.
|
|
if node.get('subview_xpath'):
|
|
xpath = node.get('subview_xpath')
|
|
if node.get('isSubviewAttr'):
|
|
expr = xpath
|
|
# Hack to check if the last subview xpath element is not the same than expr
|
|
# E.g when we add a field in an empty subview list the expr computed
|
|
# by studio will be only '/tree' but this is useless since the
|
|
# subview xpath already specify this element. So in this case,
|
|
# we don't add the expr computed by studio.
|
|
elif len(xpath) - len(expr) != xpath.find(expr):
|
|
expr = xpath + expr
|
|
return expr
|
|
|
|
# Create a new xpath node based on an operation
|
|
# TODO: rename it in master
|
|
def _get_xpath_node(self, arch, operation):
|
|
expr = self._node_to_expr(operation['target'])
|
|
position = operation['position']
|
|
|
|
return etree.SubElement(arch, 'xpath', {
|
|
'expr': expr,
|
|
'position': position
|
|
})
|
|
|
|
def _operation_remove(self, arch, operation, model=None):
|
|
expr = self._node_to_expr(operation['target'])
|
|
|
|
# We have to create a brand new xpath to remove this node from the view.
|
|
etree.SubElement(arch, 'xpath', {
|
|
'expr': expr,
|
|
'position': 'replace'
|
|
})
|
|
# Sometimes, we have to delete more stuff than just a single tag. Those nodes
|
|
# should be passed as a list in 'extra_nodes' key within the target node.
|
|
if operation['target'].get('extra_nodes'):
|
|
for target in operation['target']['extra_nodes']:
|
|
expr = self._node_to_expr(target)
|
|
etree.SubElement(arch, 'xpath', {
|
|
'expr': expr,
|
|
'position': 'replace'
|
|
})
|
|
|
|
def _operation_replace(self, arch, operation, model):
|
|
"""computes an xpath that will replace operation['target'] by operation['node'] in the arch"""
|
|
target_expr = self._node_to_expr(operation['target'])
|
|
|
|
replace_xpath = etree.SubElement(arch, 'xpath', {
|
|
'expr': target_expr,
|
|
'position': 'replace'
|
|
})
|
|
|
|
replace_with = operation['node']
|
|
etree.SubElement(replace_xpath, replace_with['tag'], replace_with['attrs'])
|
|
|
|
def _operation_add(self, arch, operation, model):
|
|
node = operation['node']
|
|
xpath_node = self._get_xpath_node(arch, operation)
|
|
|
|
# Take a xml_node and put columns on it:
|
|
# If the xml_node is not a group, this function will create a group node
|
|
# to add two columns on it.
|
|
def add_columns(xml_node):
|
|
# Get the random key generated is JS.
|
|
# Expected value: 'studio_<tag_name>_<random_key>
|
|
name = 'studio_group_' + xml_node.get('name').split('_')[2]
|
|
|
|
if xml_node.tag != 'group':
|
|
xml_node_group = etree.SubElement(xml_node, 'group', {'name': name})
|
|
else:
|
|
xml_node_group = xml_node
|
|
|
|
xml_node_page_left = etree.SubElement(xml_node_group, 'group', {'name': name + '_left'})
|
|
xml_node_page_right = etree.SubElement(xml_node_group, 'group', {'name': name + '_right'})
|
|
|
|
# Create the actual node inside the xpath. It needs to be the first
|
|
# child of the xpath to respect the order in which they were added.
|
|
xml_node = etree.Element(node['tag'], node.get('attrs'))
|
|
if node['tag'] == 'notebook':
|
|
name = 'studio_page_' + node['attrs']['name'].split('_')[2]
|
|
xml_node_page = etree.Element('page', {'string': 'New Page', 'name': name})
|
|
add_columns(xml_node_page)
|
|
xml_node.insert(0, xml_node_page)
|
|
elif node['tag'] == 'page':
|
|
add_columns(xml_node)
|
|
elif node['tag'] == 'group':
|
|
if 'empty' not in operation:
|
|
add_columns(xml_node)
|
|
elif node['tag'] == 'button':
|
|
# To create a stat button, we need
|
|
# - a many2one field (1) that points to this model
|
|
# - a field (2) that counts the number of records associated with the current record
|
|
# - an action to jump in (3) with the many2one field (1) as domain/context
|
|
#
|
|
# (1) [button_field] the many2one field
|
|
# (2) [button_count_field] is a non-stored computed field (to always have the good value in the stat button, if access rights)
|
|
# (3) [button_action] an act_window action to jump in the related model
|
|
button_field = request.env['ir.model.fields'].browse(node['field'])
|
|
button_count_field, button_action = self._get_or_create_fields_for_button(model, button_field, node['string'])
|
|
|
|
# the XML looks like <button> <field/> </button : a element `field` needs to be inserted inside the button
|
|
xml_node_field = etree.Element('field', {'widget': 'statinfo', 'name': button_count_field.name, 'string': node['string'] or button_count_field.field_description})
|
|
xml_node.insert(0, xml_node_field)
|
|
|
|
xml_node.attrib['type'] = 'action'
|
|
xml_node.attrib['name'] = str(button_action.id)
|
|
else:
|
|
xml_node.text = node.get('text')
|
|
xpath_node.insert(0, xml_node)
|
|
|
|
def _operation_enable_approval(self, arch, operation, model):
|
|
"""Set 'studio_approval="True"' on all matching buttons in the view."""
|
|
btn_type = operation.get('btn_type')
|
|
btn_name = operation.get('btn_name')
|
|
view_id = operation.get('view_id')
|
|
parser = etree.XMLParser(remove_blank_text=True)
|
|
raw_base_arch = request.env[model].get_view(view_id, 'form')['arch']
|
|
base_arch = etree.fromstring(raw_base_arch, parser=parser)
|
|
|
|
# if no rule is found, create one on the fly
|
|
is_method = btn_type == 'object'
|
|
method = is_method and btn_name
|
|
action = not is_method and int(btn_name)
|
|
rule_domain = request.env['studio.approval.rule']._get_rule_domain(model, method, action)
|
|
has_rules = request.env['studio.approval.rule'].search_count(rule_domain)
|
|
if not has_rules:
|
|
request.env['studio.approval.rule'].create_rule(model, method, action)
|
|
matching_buttons = base_arch.findall(".//button[@type='%s'][@name='%s']" % (btn_type, btn_name))
|
|
for idx, btn in enumerate(matching_buttons):
|
|
# note that these xpath are not the sexiest, but they will be cleaned
|
|
# at view normalization
|
|
xpath_node = etree.SubElement(arch, 'xpath', {
|
|
'expr': "(//button[@type='%s'][@name='%s'])[%s]" % (btn_type, btn_name, idx + 1),
|
|
'position': 'attributes'
|
|
})
|
|
attribute_node = etree.Element('attribute', name='studio_approval')
|
|
attribute_node.text = str(operation.get('enable'))
|
|
# NOTE: this will leave some extended views with `studio_approval=False`
|
|
# which is handled client side to do nothing
|
|
xpath_node.insert(0, attribute_node)
|
|
|
|
def _get_or_create_fields_for_button(self, model, field, button_name):
|
|
""" Returns the button_count_field and the button_action link to a stat button.
|
|
@param field: a many2one field
|
|
"""
|
|
|
|
if (field.ttype != 'many2one' and field.ttype != 'many2many') or field.relation != model:
|
|
raise UserError(_('The related field of a button has to be a many2one to %s.', model))
|
|
|
|
model = request.env['ir.model']._get(model)
|
|
|
|
# There is a counter on the button ; as the related field is a many2one, we need
|
|
# to create a new computed field that counts the number of records in the one2many
|
|
button_count_field_name = 'x_%s_%s_count' % (field.name, field.model.replace('.', '_'))[0:63]
|
|
button_count_field = request.env['ir.model.fields'].search([('name', '=', button_count_field_name), ('model_id', '=', model.id)])
|
|
if not button_count_field:
|
|
compute_function = """
|
|
for record in self: record['%(count_field)s'] = self.env['%(model)s'].search_count([('%(field)s', '=', record.id)])
|
|
""" % {
|
|
'model': field.model,
|
|
'field': field.name,
|
|
'count_field': button_count_field_name,
|
|
}
|
|
button_count_field = request.env['ir.model.fields'].create({
|
|
'name': button_count_field_name,
|
|
'field_description': '%s count' % field.field_description,
|
|
'model': model.model,
|
|
'model_id': model.id,
|
|
'ttype': 'integer',
|
|
'store': False,
|
|
'compute': compute_function.replace(' ', ''), # remove indentation for safe_eval
|
|
})
|
|
|
|
# The action could already exist but we don't want to recreate one each time
|
|
button_action_domain = "[('%s', '=', active_id)]" % (field.name)
|
|
active_id = 'active_id' if field.ttype == 'many2one' else '[active_id]'
|
|
button_action_context = "{'search_default_%s': active_id,'default_%s': %s}" % (field.name, field.name, active_id)
|
|
button_action = request.env['ir.actions.act_window'].search([
|
|
('name', '=', button_name), ('res_model', '=', field.model),
|
|
('domain', '=', button_action_domain), ('context', '=', button_action_context),
|
|
])
|
|
if not button_action:
|
|
# Link the button with an associated act_window
|
|
button_action = request.env['ir.actions.act_window'].create({
|
|
'name': button_name,
|
|
'res_model': field.model,
|
|
'view_mode': 'tree,form',
|
|
'domain': button_action_domain,
|
|
'context': button_action_context,
|
|
})
|
|
|
|
return button_count_field, button_action
|
|
|
|
def _operation_move(self, arch, operation, model=None):
|
|
xpath_node = self._get_xpath_node(arch, operation)
|
|
xml_node = etree.Element('xpath', {
|
|
'expr': self._node_to_expr(operation['node']),
|
|
'position': 'move',
|
|
})
|
|
xpath_node.append(xml_node)
|
|
|
|
# Create or update node for each attribute
|
|
def _operation_attributes(self, arch, operation, model=None):
|
|
ir_model_data = request.env['ir.model.data']
|
|
new_attrs = operation['new_attrs']
|
|
|
|
if 'groups' in new_attrs:
|
|
eval_attr = []
|
|
for many2many_value in new_attrs['groups']:
|
|
group_xmlid = ir_model_data.search([
|
|
('model', '=', 'res.groups'),
|
|
('res_id', '=', many2many_value)])
|
|
if not group_xmlid:
|
|
raise UserError(_(
|
|
"Only groups with an external ID can be used here. Please choose another "
|
|
"group or assign manually an external ID to this group."
|
|
))
|
|
eval_attr.append(group_xmlid.complete_name)
|
|
eval_attr = ",".join(eval_attr)
|
|
new_attrs['groups'] = eval_attr
|
|
|
|
if new_attrs.get('options'):
|
|
options = json.loads(new_attrs['options'])
|
|
if 'color_field' in options:
|
|
field_name = operation['node']['attrs']['name']
|
|
field_id = request.env['ir.model.fields'].search([('model', '=', model), ('name', '=', field_name)])
|
|
related_model_id = request.env['ir.model']._get(field_id.relation)
|
|
|
|
if 'color' in related_model_id.field_id.mapped('name'):
|
|
options['color_field'] = 'color'
|
|
else:
|
|
if 'x_color' not in related_model_id.field_id.mapped('name'):
|
|
request.env['ir.model.fields'].create({
|
|
'model': related_model_id.name,
|
|
'model_id': related_model_id.id,
|
|
'name': 'x_color',
|
|
'field_description': 'Color',
|
|
'ttype': 'integer',
|
|
})
|
|
options['color_field'] = 'x_color'
|
|
new_attrs['options'] = json.dumps(options)
|
|
|
|
|
|
xpath_node = self._get_xpath_node(arch, operation)
|
|
|
|
for key, new_attr in new_attrs.items():
|
|
xml_node = etree.Element('attribute', {'name': key})
|
|
xml_node.text = str(new_attr)
|
|
xpath_node.insert(0, xml_node)
|
|
|
|
# change the field description when changing the field label (for custom fields)
|
|
if key == 'string' and operation.get('node', {}).get('tag') == 'field':
|
|
field_name = operation.get('node', {}).get('attrs', {}).get('name')
|
|
field_id = request.env['ir.model.fields'].search([('model', '=', model), ('name', '=', field_name)])
|
|
if field_name.startswith('x_') and field_id and field_id.field_description != new_attr:
|
|
field_id.write({'field_description': new_attr})
|
|
|
|
def _operation_buttonbox(self, arch, operation, model=None):
|
|
studio_view_arch = arch # The actual arch is the studio view arch
|
|
# Get the arch of the form view with inherited views applied
|
|
arch = request.env[model].get_view(view_type='form')['arch']
|
|
parser = etree.XMLParser(remove_blank_text=True)
|
|
arch = etree.fromstring(arch, parser=parser)
|
|
|
|
# Create xpath to put the buttonbox as the first child of the sheet
|
|
if arch.find('sheet'):
|
|
sheet_node = arch.find('sheet')
|
|
if list(sheet_node):
|
|
# Check if children exists
|
|
xpath_node = etree.SubElement(studio_view_arch, 'xpath', {
|
|
'expr': '//sheet/*[1]',
|
|
'position': 'before'
|
|
})
|
|
else:
|
|
xpath_node = etree.SubElement(studio_view_arch, 'xpath', {
|
|
'expr': '//sheet',
|
|
'position': 'inside'
|
|
})
|
|
# Create and insert the buttonbox node inside the xpath node
|
|
buttonbox_node = etree.Element('div', {'name': 'button_box', 'class': 'oe_button_box'})
|
|
xpath_node.append(buttonbox_node)
|
|
|
|
def _operation_chatter(self, arch, operation, model=None):
|
|
def _get_remove_field_op(arch, field_name):
|
|
return {
|
|
'type': 'remove',
|
|
'target': {
|
|
'tag': 'field',
|
|
'attrs': {
|
|
'name': field_name,
|
|
},
|
|
}
|
|
}
|
|
|
|
if not self.is_chatter_allowed(operation['model']):
|
|
# Chatter can only be activated form models that (can) inherit from mail.thread
|
|
return
|
|
|
|
# From this point, the model is either a custom model or inherits from mail.thread
|
|
model = request.env['ir.model']._get(operation['model'])
|
|
if model.state == 'manual' and not model.is_mail_thread:
|
|
# Activate mail.thread inheritance on the custom model
|
|
model.write({'is_mail_thread': True})
|
|
if model.state == 'manual' and not model.is_mail_activity:
|
|
# Activate mail.activity inheritance on the custom model
|
|
model.write({'is_mail_activity': True})
|
|
|
|
# Remove message_ids, activity_ids and message_follower_ids if already defined in form view
|
|
if operation['remove_message_ids']:
|
|
self._operation_remove(arch, _get_remove_field_op(arch, 'message_ids'))
|
|
if operation['remove_follower_ids']:
|
|
self._operation_remove(arch, _get_remove_field_op(arch, 'message_follower_ids'))
|
|
if operation['remove_activity_ids']:
|
|
self._operation_remove(arch, _get_remove_field_op(arch, 'activity_ids'))
|
|
|
|
xpath_node = etree.SubElement(arch, 'xpath', {
|
|
'expr': '//sheet',
|
|
'position': 'after',
|
|
})
|
|
chatter_node = etree.Element('div', {'class': 'oe_chatter'})
|
|
follower_node = etree.Element('field', {'name': 'message_follower_ids'})
|
|
chatter_node.append(follower_node)
|
|
if model.is_mail_activity:
|
|
activity_node = etree.Element('field', {'name': 'activity_ids'})
|
|
chatter_node.append(activity_node)
|
|
thread_node = etree.Element('field', {'name': 'message_ids'})
|
|
chatter_node.append(thread_node)
|
|
xpath_node.append(chatter_node)
|
|
|
|
def _operation_kanban_dropdown(self, arch, operation, model):
|
|
""" Insert a dropdown and its corresponding needs in an kanban view arch.
|
|
Implied modifications:
|
|
- create an integer field x_color in the model if it doesn't exist
|
|
- add the field x_color in the view
|
|
- add a dropdown section in the view
|
|
- modify the kanban class to use `oe_kanban_color_`
|
|
"""
|
|
model_id = request.env['ir.model']._get_id(model)
|
|
if not model_id:
|
|
return
|
|
|
|
color_field_name = 'x_color'
|
|
if not request.env['ir.model.fields'].search([('model_id', '=', model_id), ('name', '=', color_field_name), ('ttype', '=', 'integer')]):
|
|
# create a field if it doesn't exist in the model
|
|
request.env['ir.model.fields'].create({
|
|
'model': model,
|
|
'model_id': model_id,
|
|
'name': color_field_name,
|
|
'field_description': 'Color',
|
|
'ttype': 'integer',
|
|
})
|
|
|
|
# add the field at the beginning
|
|
etree.SubElement(arch, 'xpath', {
|
|
'expr': 'templates',
|
|
'position': 'before',
|
|
}).append(etree.Element('field', {'name': color_field_name}))
|
|
|
|
# add the dropdown before the rest
|
|
dropdown_node = etree.fromstring("""
|
|
<div class="o_dropdown_kanban dropdown" name="kanban_dropdown">
|
|
<a class="dropdown-toggle o-no-caret btn" data-bs-toggle="dropdown" href="#" aria-label="Dropdown menu" title="Dropdown menu" role="button">
|
|
<span class="fa fa-ellipsis-v"/>
|
|
</a>
|
|
<div class="dropdown-menu" role="menu">
|
|
<t t-if="widget.editable"><a type="edit" class="dropdown-item">Edit</a></t>
|
|
<t t-if="widget.deletable"><a type="delete" class="dropdown-item">Delete</a></t>
|
|
<ul class="oe_kanban_colorpicker" data-field="%(field)s"/>
|
|
</div>
|
|
</div>
|
|
""" % {'field': color_field_name})
|
|
etree.SubElement(arch, 'xpath', {
|
|
'expr': '//div/*[1]',
|
|
'position': 'before',
|
|
}).append(dropdown_node)
|
|
|
|
# set the corresponding color attribute on the kanban record
|
|
xpath_node = etree.SubElement(arch, 'xpath', {
|
|
'expr': '//div',
|
|
'position': 'attributes',
|
|
})
|
|
xml_node = xpath_node.find('attribute[@name="%s"]' % ('color'))
|
|
if xml_node is None:
|
|
xml_node = etree.Element('attribute', {'name': 'color'})
|
|
xml_node.text = color_field_name
|
|
xpath_node.insert(0, xml_node)
|
|
else:
|
|
xml_node.text = color_field_name
|
|
|
|
def _operation_kanban_image(self, arch, operation, model):
|
|
""" Insert a image and its corresponding needs in an kanban view arch
|
|
Implied modifications (if not already done):
|
|
- add the field in the view
|
|
- add a section (kanban_right) in the view
|
|
- add the field with `kanban_image` in this section
|
|
"""
|
|
model_id = request.env['ir.model']._get_id(model)
|
|
if not model_id:
|
|
raise UserError(_('The model %s does not exist.', model))
|
|
|
|
if not operation.get('field'):
|
|
raise UserError(_('Please specify a field.'))
|
|
|
|
field_id = request.env['ir.model.fields'].search([
|
|
('model', '=', model),
|
|
('name', '=', operation['field'])
|
|
])
|
|
if not field_id:
|
|
raise UserError(_('The field %s does not exist.', operation['field']))
|
|
|
|
# add field at the beginning
|
|
etree.SubElement(arch, 'xpath', {
|
|
'expr': 'templates',
|
|
'position': 'before',
|
|
}).append(etree.Element('field', {'name': field_id.name}))
|
|
|
|
# check if there's already a bottom right section
|
|
# boy o boy i sure hope there's only one kanban!
|
|
base_arch = request.env[model].get_view(view_type='kanban')['arch']
|
|
base_tree = etree.fromstring(base_arch)
|
|
has_br_container = base_tree.xpath('//div[hasclass("oe_kanban_bottom_right")]')
|
|
|
|
img_elem = """<img
|
|
t-if="record.{field}.raw_value"
|
|
t-att-src="kanban_image('{model}', 'image_128', record.{field}.raw_value)"
|
|
t-att-title="record.{field}.value" t-att-alt="record.{field}.value"
|
|
class="oe_kanban_avatar o_image_24_cover float-right"
|
|
/>""".format(model=field_id.relation, field=field_id.name)
|
|
# add the image inside the view
|
|
if has_br_container:
|
|
etree.SubElement(arch, 'xpath', {
|
|
'expr': '//div[hasclass("oe_kanban_bottom_right")]',
|
|
'position': 'inside',
|
|
}).append(
|
|
etree.fromstring(img_elem)
|
|
)
|
|
else:
|
|
etree.SubElement(arch, 'xpath', {
|
|
'expr': '//div',
|
|
'position': 'inside',
|
|
}).append(
|
|
etree.fromstring("""
|
|
<div class="oe_kanban_bottom_right">
|
|
%s
|
|
</div>
|
|
""" % img_elem)
|
|
)
|
|
|
|
def _operation_kanban_set_cover(self, arch, operation, model):
|
|
""" Insert a menu in dropdown to set cover image in a kanban view.
|
|
Implied modifications:
|
|
- adds the given m2o field in the view (may create new field
|
|
'x_studio_cover_image_id' if there's no compatible field)
|
|
- adds an option inside dropdown section in the view
|
|
- adds an field having widget `attachment_image` in the view
|
|
"""
|
|
ir_model = request.env['ir.model']._get(model)
|
|
if not ir_model:
|
|
raise UserError(_('The model %s does not exist.', model))
|
|
if operation.get('field'):
|
|
field_id = request.env['ir.model.fields'].search([
|
|
('model', '=', model),
|
|
('name', '=', operation['field'])
|
|
])
|
|
if not field_id:
|
|
raise UserError(_('The field %s does not exist.', operation['field']))
|
|
else:
|
|
field_id = request.env['ir.model.fields'].search([
|
|
('model', '=', ir_model.model),
|
|
('name', '=', 'x_studio_cover_image_id'),
|
|
('ttype', '=', 'many2one')
|
|
])
|
|
# create a field many2one x_studio_cover_image_id if it doesn't exist in the model
|
|
if not field_id:
|
|
field_id = request.env['ir.model.fields'].create({
|
|
'model': ir_model.model,
|
|
'model_id': ir_model.id,
|
|
'relation': 'ir.attachment',
|
|
'name': 'x_studio_cover_image_id',
|
|
'field_description': 'Cover Image',
|
|
'ttype': 'many2one',
|
|
'domain': '[("res_model", "=", "%s"), ("res_id", "=", "%s"), ("mimetype", "ilike", "image")]' % (ir_model.model, ir_model.id)
|
|
})
|
|
|
|
# add link inside the dropdown
|
|
etree.SubElement(arch, 'xpath', {
|
|
'expr': '//div[hasclass("dropdown-menu")]//a',
|
|
'position': 'before',
|
|
}).append(
|
|
etree.fromstring("""
|
|
<a data-type="set_cover" href="#" data-field="%s" class="dropdown-item oe_kanban_action oe_kanban_action_a" >
|
|
Set Cover Image
|
|
</a>
|
|
""" % (field_id.name))
|
|
)
|
|
studio_view_arch = arch
|
|
arch = request.env[model].get_view(view_type='kanban')['arch']
|
|
parser = etree.XMLParser(remove_blank_text=True)
|
|
arch = etree.fromstring(arch, parser=parser)
|
|
|
|
# try to find the best place to put the cover
|
|
possible_hooks = [
|
|
{'expr': '//div[hasclass("o_kanban_record_body")]', 'position' : 'inside'},
|
|
{'expr': '//div[hasclass("o_kanban_record_bottom")]', 'position' : 'before'},
|
|
{'expr': '//div[hasclass("oe_kanban_details")]', 'position' : 'inside'},
|
|
{'expr': '//div', 'position': 'inside'},
|
|
]
|
|
for hook in possible_hooks:
|
|
if len(arch.xpath(hook['expr'])):
|
|
break
|
|
|
|
xpath_node = etree.SubElement(studio_view_arch, 'xpath', hook)
|
|
xpath_node.append(etree.fromstring("""
|
|
<field t-if="record.%s.value" name="%s" widget="attachment_image"/>
|
|
""" % (field_id.name, field_id.name)))
|
|
|
|
def _operation_kanban_priority(self, arch, operation, model):
|
|
""" Insert a priority and its corresponding needs in an kanban view arch
|
|
Implied modifications:
|
|
- create a selection field x_priority in the model if it doesn't exist
|
|
- add a section (kanban_left) in the view
|
|
- add the field x_priority with the widget priority in this section
|
|
"""
|
|
model_id = request.env['ir.model']._get_id(model)
|
|
if not model_id:
|
|
raise UserError(_('The model %s does not exist.', model))
|
|
|
|
if operation.get('field'):
|
|
field_id = request.env['ir.model.fields'].search([
|
|
('model', '=', model),
|
|
('name', '=', operation['field'])
|
|
])
|
|
if not field_id:
|
|
raise UserError(_('The field %s does not exist.', operation['field']))
|
|
|
|
else:
|
|
field_id = request.env['ir.model.fields'].search([
|
|
('model_id', '=', model_id),
|
|
('name', '=', 'x_priority'),
|
|
('ttype', '=', 'selection')
|
|
])
|
|
# create a field selection x_priority if it doesn't exist in the model
|
|
if not field_id:
|
|
field_id = request.env['ir.model.fields'].create({
|
|
'model': model,
|
|
'model_id': model_id,
|
|
'name': 'x_priority',
|
|
'field_description': 'Priority',
|
|
'ttype': 'selection',
|
|
'selection': "[('0', 'Low'), ('1', 'Normal'), ('2', 'High')]",
|
|
})
|
|
|
|
# add priority inside the view
|
|
etree.SubElement(arch, 'xpath', {
|
|
'expr': '//div',
|
|
'position': 'inside',
|
|
}).append(
|
|
etree.fromstring("""
|
|
<div class="oe_kanban_bottom_left">
|
|
<field name="%s" widget="priority"/>
|
|
</div>
|
|
""" % (field_id.name))
|
|
)
|
|
|
|
def _operation_avatar_image(self, arch, operation, model):
|
|
studio_view_arch = arch # The actual arch is the studio view arch
|
|
arch = request.env[model].get_view(view_type='form')['arch']
|
|
parser = etree.XMLParser(remove_blank_text=True)
|
|
arch = etree.fromstring(arch, parser=parser)
|
|
|
|
model_id = request.env['ir.model']._get_id(model)
|
|
IrModelFields = request.env['ir.model.fields']
|
|
|
|
if not model_id:
|
|
raise UserError(_('The model %s does not exist.', model))
|
|
if operation.get('field'):
|
|
field_id = IrModelFields.search([
|
|
('model', '=', model),
|
|
('name', '=', operation['field'])
|
|
])
|
|
if not field_id:
|
|
raise UserError(_('The field %s does not exist.', operation['field']))
|
|
else:
|
|
field_id = IrModelFields.search([
|
|
('model_id', '=', model_id),
|
|
('name', '=', 'x_avatar_image'),
|
|
('ttype', '=', 'binary')
|
|
])
|
|
# create a field selection x_avatar_image if it doesn't exist in the model
|
|
if not field_id:
|
|
field_id = IrModelFields.create({
|
|
'model': model,
|
|
'model_id': model_id,
|
|
'name': 'x_avatar_image',
|
|
'field_description': 'Avatar',
|
|
'ttype': 'binary',
|
|
})
|
|
attrs = {
|
|
'expr': '//div[hasclass("oe_title")]',
|
|
'position': 'before',
|
|
}
|
|
hasFlexH1 = arch.xpath("//div[hasclass('oe_title')]//h1[hasclass('d-flex')]") and True
|
|
if hasFlexH1:
|
|
attrs.update({
|
|
"expr": "//div[hasclass('oe_title')]//h1[hasclass('d-flex')]",
|
|
"position": "inside",
|
|
})
|
|
avatar_class = "oe_avatar ml-3 h4" if hasFlexH1 else "oe_avatar ml-3 mr-3"
|
|
etree.SubElement(studio_view_arch, 'xpath', attrs).append(
|
|
etree.fromstring("""
|
|
<field name="%s" widget="image" class="%s"/>
|
|
""" % (field_id.name, avatar_class))
|
|
)
|
|
|
|
def _operation_statusbar(self, arch, operation, model=None):
|
|
""" Create and insert a header as the first child of the form. """
|
|
xpath_node = etree.SubElement(arch, 'xpath', {
|
|
'expr': '//form/*[1]',
|
|
'position': 'before'
|
|
})
|
|
xpath_node.append(etree.Element('header'))
|
|
|
|
def _operation_map_popup_fields(self, arch, operation, model):
|
|
fields = request.env['ir.model.fields'].browse(operation['target']['field_ids'])
|
|
for field in fields:
|
|
if operation['target']['operation_type'] == 'add':
|
|
op = {
|
|
'node': {
|
|
'tag': 'field',
|
|
'attrs': {
|
|
'name': field.name,
|
|
'string': field.field_description,
|
|
}
|
|
},
|
|
'target': {
|
|
'tag': 'map',
|
|
},
|
|
'position': 'inside',
|
|
}
|
|
self._operation_add(arch, op, model)
|
|
else:
|
|
op = {
|
|
'type': 'remove',
|
|
'target': {
|
|
'tag': 'field',
|
|
'attrs': {
|
|
'name': field.name,
|
|
},
|
|
}
|
|
}
|
|
self._operation_remove(arch, op)
|
|
|
|
def _operation_pivot_measures_fields(self, arch, operation, model):
|
|
fields = request.env['ir.model.fields'].browse(operation['target']['field_ids'])
|
|
for field in fields:
|
|
if operation['target']['operation_type'] == 'add':
|
|
op = {
|
|
'node': {
|
|
'tag': 'field',
|
|
'attrs': {
|
|
'name': field.name,
|
|
'type': 'measure',
|
|
}
|
|
},
|
|
'target': {
|
|
'tag': 'pivot',
|
|
},
|
|
'position': 'inside',
|
|
}
|
|
self._operation_add(arch, op, model)
|
|
else:
|
|
op = {
|
|
'type': 'remove',
|
|
'target': {
|
|
'tag': 'field',
|
|
'attrs': {
|
|
'name': field.name,
|
|
},
|
|
}
|
|
}
|
|
self._operation_remove(arch, op)
|
|
|
|
def _operation_graph_pivot_groupbys_fields(self, arch, operation, model):
|
|
fieldsName = request.env['ir.model.fields'].search([
|
|
('name', 'in', operation['target']['field_names']),
|
|
('model', '=', model),])
|
|
for field in fieldsName:
|
|
if operation['target']['operation_type'] == 'add':
|
|
op = {
|
|
'node': {
|
|
'tag': 'field',
|
|
'attrs': {
|
|
'name': field.name,
|
|
'type': operation['target']['field_type'],
|
|
}
|
|
},
|
|
'target': {
|
|
'tag': operation['target']['view_type'],
|
|
},
|
|
'position': 'inside',
|
|
}
|
|
self._operation_add(arch, op, model)
|
|
elif operation['target']['operation_type'] == 'replace':
|
|
op = {
|
|
'node': {
|
|
'tag': 'field',
|
|
'attrs': {
|
|
'name': field.name,
|
|
'type': operation['target']['field_type'],
|
|
}
|
|
},
|
|
'target': {
|
|
'tag': 'field',
|
|
'attrs': {
|
|
'name': operation['target']['old_field_names'],
|
|
},
|
|
},
|
|
}
|
|
self._operation_replace(arch, op, model)
|
|
else:
|
|
op = {
|
|
'type': 'remove',
|
|
'target': {
|
|
'tag': 'field',
|
|
'attrs': {
|
|
'name': field.name,
|
|
},
|
|
}
|
|
}
|
|
self._operation_remove(arch, op)
|
|
|
|
@http.route('/web_studio/get_email_alias', type='json', auth='user')
|
|
def get_email_alias(self, model_name):
|
|
""" Returns the email alias associated to the model @model_name if both exist
|
|
"""
|
|
result = {'alias_domain': request.env['ir.config_parameter'].get_param('mail.catchall.domain')}
|
|
model = request.env['ir.model']._get(model_name)
|
|
if model:
|
|
email_alias = request.env['mail.alias'].search([('alias_model_id', '=', model.id)], limit=1)
|
|
if email_alias:
|
|
result['email_alias'] = email_alias.alias_name
|
|
return result
|
|
|
|
@http.route('/web_studio/set_email_alias', type='json', auth='user')
|
|
def set_email_alias(self, model_name, value):
|
|
""" Set the email alias associated to the model @model_name
|
|
- if there is no email alias, it will be created
|
|
- if there is one and the value is empty, it will be unlinked
|
|
"""
|
|
model_id = request.env['ir.model']._get_id(model_name)
|
|
if model_id:
|
|
email_alias = request.env['mail.alias'].search([('alias_model_id', '=', model_id)], limit=1)
|
|
if email_alias:
|
|
if value:
|
|
email_alias.alias_name = value
|
|
else:
|
|
email_alias.unlink()
|
|
else:
|
|
request.env['mail.alias'].create({
|
|
'alias_model_id': model_id,
|
|
'alias_name': value,
|
|
})
|
|
|
|
@http.route('/web_studio/get_default_value', type='json', auth='user')
|
|
def get_default_value(self, model_name, field_name):
|
|
""" Return the default value associated to the given field. """
|
|
return {
|
|
'default_value': request.env['ir.default'].get(model_name, field_name, company_id=True)
|
|
}
|
|
|
|
@http.route('/web_studio/set_default_value', type='json', auth='user')
|
|
def set_default_value(self, model_name, field_name, value):
|
|
""" Set the default value associated to the given field. """
|
|
request.env['ir.default'].with_context(studio=True).set(model_name, field_name, value, company_id=True)
|
|
|
|
@http.route('/web_studio/create_inline_view', type='json', auth='user')
|
|
def create_inline_view(self, model, view_id, field_name, subview_type, subview_xpath):
|
|
view = request.env['ir.ui.view'].browse(view_id)
|
|
studio_view = self._get_studio_view(view)
|
|
if not studio_view:
|
|
studio_view = self._create_studio_view(view, '<data/>')
|
|
parser = etree.XMLParser(remove_blank_text=True)
|
|
arch = etree.fromstring(studio_view.arch_db, parser=parser)
|
|
expr = "//field[@name='%s']" % field_name
|
|
if subview_xpath:
|
|
expr = subview_xpath + expr
|
|
position = 'inside'
|
|
xpath_node = arch.find('xpath[@expr="%s"][@position="%s"]' % (expr, position))
|
|
if xpath_node is None: # bool(node) == False if node has no children
|
|
xpath_node = etree.SubElement(arch, 'xpath', {
|
|
'expr': expr,
|
|
'position': position
|
|
})
|
|
inline_view = request.env[model].get_view(view_type=subview_type)
|
|
view_arch = inline_view['arch']
|
|
xml_node = self._inline_view_filter_nodes(etree.fromstring(view_arch))
|
|
xpath_node.insert(0, xml_node)
|
|
studio_view.arch_db = etree.tostring(arch, encoding='utf-8', pretty_print=True)
|
|
return studio_view.arch_db
|
|
|
|
def _inline_view_filter_nodes(self, inline_view_etree):
|
|
"""
|
|
Filters out from a standard view some nodes that are
|
|
irrelevant in an inline view (like the chatter)
|
|
|
|
@param {Etree} inline_view_etree: the arch of the view
|
|
@return {Etree}
|
|
"""
|
|
unwanted_xpath = [
|
|
"*[hasclass('oe_chatter')]",
|
|
"*[hasclass('o_attachment_preview')]",
|
|
]
|
|
for path in unwanted_xpath:
|
|
for node in inline_view_etree.xpath(path):
|
|
inline_view_etree.remove(node)
|
|
|
|
return inline_view_etree
|