Techsystech
/
web_techsystech
forked from Techsystech/web
3
0
Fork 0
Code Pull Requests Activity

[MIG] web_domain_field: Migration to 13.0

16.0
laurent.corron 2019-11-11 20:24:52 +01:00 committed by arulbalamurugan
parent ae40850c55
commit d90dbe6d0a
4 changed files with 206 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
web_domain_field/__manifest__.py
View File

@ -1,4 +1,3 @@
# -*- coding: utf-8 -*-
# Copyright 2017 ACSONE SA/NV # Copyright 2017 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
@ -6,11 +5,11 @@
"name": "Web Domain Field", "name": "Web Domain Field",
"summary": """ "summary": """
Use computed field as domain""", Use computed field as domain""",
"version": "10.0.1.0.0", "version": "13.0.1.0.0",
"license": "AGPL-3", "license": "AGPL-3",
"author": "ACSONE SA/NV,Odoo Community Association (OCA)", "author": "ACSONE SA/NV,Odoo Community Association (OCA)",
"website": "https://acsone.eu/", "website": "https://github.com/OCA/web",
"depends": ["web"], "depends": ["web"],
"data": ["views/web_domain_field.xml",], "data": ["views/web_domain_field.xml"],
"demo": [], "installable": True,
} }

9
web_domain_field/i18n/web_domain_field.pot
View File

@ -1,12 +1,12 @@
# Translation of Odoo Server. # Translation of Odoo Server.
# This file contains the translation of the following modules: # This file contains the translation of the following modules:
# * web_domain_field # * web_domain_field
# #
msgid "" msgid ""
msgstr "" msgstr ""
"Project-Id-Version: Odoo Server 10.0\n" "Project-Id-Version: Odoo Server 13.0\n"
"Report-Msgid-Bugs-To: \n" "Report-Msgid-Bugs-To: \n"
"Last-Translator: <>\n" "Last-Translator: \n"
"Language-Team: \n" "Language-Team: \n"
"MIME-Version: 1.0\n" "MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n" "Content-Type: text/plain; charset=UTF-8\n"
@ -15,8 +15,7 @@ msgstr ""
#. module: web_domain_field #. module: web_domain_field
#. openerp-web #. openerp-web
#: code:addons/web_domain_field/static/src/js/pyeval.js:160 #: code:addons/web_domain_field/static/src/js/pyeval.js:0
#, python-format #, python-format
msgid "Unknown nonliteral type " msgid "Unknown nonliteral type "
msgstr "" msgstr ""

413
web_domain_field/static/src/js/pyeval.js
View File

@ -1,233 +1,212 @@
odoo.define('web.domain_field', function (require) { odoo.define('web.domain_field', function (require) {
"use strict"; "use strict";
var pyeval = require('web.pyeval'); var py_utils = require('web.py_utils');
var session = require('web.session'); var session = require('web.session');
var original_pyeval = pyeval.eval; var original_pyeval = py_utils.eval;
var original_ensure_evaluated = pyeval.ensure_evaluated; var py = window.py;
var py = window.py;
/** copied from pyeval and not modified but required since not publicly /** Copied from py_utils and not modified but required since not publicly
exposed by web.pyeval**/ exposed by web.py_utils**/
// recursively wraps JS objects passed into the context to attributedicts // recursively wraps JS objects passed into the context to attributedicts
// which jsonify back to JS objects // which jsonify back to JS objects
function wrap(value) { function wrap(value) {
if (value === null) { return py.None; } if (value === null) { return py.None; }
switch (typeof value) { switch (typeof value) {
case 'undefined': throw new Error("No conversion for undefined"); case 'undefined': throw new Error("No conversion for undefined");
case 'boolean': return py.bool.fromJSON(value); case 'boolean': return py.bool.fromJSON(value);
case 'number': return py.float.fromJSON(value); case 'number': return py.float.fromJSON(value);
case 'string': return py.str.fromJSON(value); case 'string': return py.str.fromJSON(value);
}
switch(value.constructor) {
case Object: return wrapping_dict.fromJSON(value);
case Array: return wrapping_list.fromJSON(value);
}
throw new Error("ValueError: unable to wrap " + value);
} }
switch(value.constructor) { var wrapping_dict = py.type('wrapping_dict', null, {
case Object: return wrapping_dict.fromJSON(value); __init__: function () {
case Array: return wrapping_list.fromJSON(value); this._store = {};
} },
__getitem__: function (key) {
var k = key.toJSON();
if (!(k in this._store)) {
throw new Error("KeyError: '" + k + "'");
}
return wrap(this._store[k]);
},
__getattr__: function (key) {
return this.__getitem__(py.str.fromJSON(key));
},
__len__: function () {
return Object.keys(this._store).length;
},
__nonzero__: function () {
return py.PY_size(this) > 0 ? py.True : py.False;
},
get: function () {
var args = py.PY_parseArgs(arguments, ['k', ['d', py.None]]);
throw new Error("ValueError: unable to wrap " + value); if (!(args.k.toJSON() in this._store)) { return args.d; }
} return this.__getitem__(args.k);
},
var wrapping_dict = py.type('wrapping_dict', null, { fromJSON: function (d) {
__init__: function () { var instance = py.PY_call(wrapping_dict);
this._store = {}; instance._store = d;
}, return instance;
__getitem__: function (key) { },
var k = key.toJSON(); toJSON: function () {
if (!(k in this._store)) { return this._store;
throw new Error("KeyError: '" + k + "'"); },
}
return wrap(this._store[k]);
},
__getattr__: function (key) {
return this.__getitem__(py.str.fromJSON(key));
},
__len__: function () {
return Object.keys(this._store).length
},
__nonzero__: function () {
return py.PY_size(this) > 0 ? py.True : py.False;
},
get: function () {
var args = py.PY_parseArgs(arguments, ['k', ['d', py.None]]);
if (!(args.k.toJSON() in this._store)) { return args.d; }
return this.__getitem__(args.k);
},
fromJSON: function (d) {
var instance = py.PY_call(wrapping_dict);
instance._store = d;
return instance;
},
toJSON: function () {
return this._store;
},
});
var wrapping_list = py.type('wrapping_list', null, {
__init__: function () {
this._store = [];
},
__getitem__: function (index) {
return wrap(this._store[index.toJSON()]);
},
__len__: function () {
return this._store.length;
},
__nonzero__: function () {
return py.PY_size(this) > 0 ? py.True : py.False;
},
fromJSON: function (ar) {
var instance = py.PY_call(wrapping_list);
instance._store = ar;
return instance;
},
toJSON: function () {
return this._store;
},
});
function wrap_context (context) {
for (var k in context) {
if (!context.hasOwnProperty(k)) { continue; }
var val = context[k];
if (val === null) { continue; }
if (val.constructor === Array) {
context[k] = wrapping_list.fromJSON(val);
} else if (val.constructor === Object
&& !py.PY_isInstance(val, py.object)) {
context[k] = wrapping_dict.fromJSON(val);
}
}
return context;
}
function ensure_evaluated (args, kwargs) {
for (var i=0; i<args.length; ++i) {
args[i] = eval_arg(args[i]);
}
for (var k in kwargs) {
if (!kwargs.hasOwnProperty(k)) { continue; }
kwargs[k] = eval_arg(kwargs[k]);
}
}
function eval_contexts (contexts, evaluation_context) {
evaluation_context = _.extend(pyeval.context(), evaluation_context || {});
return _(contexts).reduce(function (result_context, ctx) {
// __eval_context evaluations can lead to some of `contexts`'s
// values being null, skip them as well as empty contexts
if (_.isEmpty(ctx)) { return result_context; }
if (_.isString(ctx)) {
// wrap raw strings in context
ctx = { __ref: 'context', __debug: ctx };
}
var evaluated = ctx;
switch(ctx.__ref) {
case 'context':
evaluation_context.context = evaluation_context;
evaluated = py.eval(ctx.__debug, wrap_context(evaluation_context));
break;
case 'compound_context':
var eval_context = eval_contexts([ctx.__eval_context]);
evaluated = eval_contexts(
ctx.__contexts, _.extend({}, evaluation_context, eval_context));
break;
}
// add newly evaluated context to evaluation context for following
// siblings
_.extend(evaluation_context, evaluated);
return _.extend(result_context, evaluated);
}, {});
}
/** end of unmodified methods copied from pyeval **/
// We need to override the original method to be able to call our
//specialized version of pyeval for domain fields
function eval_arg (arg) {
if (typeof arg !== 'object' || !arg.__ref) { return arg; }
switch(arg.__ref) {
case 'domain': case 'compound_domain':
return domain_field_pyeval('domains', [arg]);
case 'context': case 'compound_context':
return original_pyeval('contexts', [arg]);
default:
throw new Error(_t("Unknown nonliteral type ") + ' ' + arg.__ref);
}
}
// override eval_domains to add 3 lines in order to be able to use a field
//value as domain
function eval_domains (domains, evaluation_context) {
evaluation_context = _.extend(pyeval.context(), evaluation_context ||
{});
var result_domain = [];
_(domains).each(function (domain) {
if (_.isString(domain)) {
// Modified part or the original method
if(domain in evaluation_context) {
result_domain.push.apply(
result_domain, $.parseJSON(evaluation_context[domain]));
return;
}
// end of modifications
// wrap raw strings in domain
domain = { __ref: 'domain', __debug: domain };
}
switch(domain.__ref) {
case 'domain':
evaluation_context.context = evaluation_context;
result_domain.push.apply(
result_domain, py.eval(domain.__debug, wrap_context(evaluation_context)));
break;
case 'compound_domain':
var eval_context = eval_contexts([domain.__eval_context]);
result_domain.push.apply(
result_domain, eval_domains(
domain.__domains, _.extend(
{}, evaluation_context, eval_context)));
break;
default:
result_domain.push.apply(result_domain, domain);
}
}); });
return result_domain;
}
// override pyeval in order to call our specialized implementation of var wrapping_list = py.type('wrapping_list', null, {
// eval_domains __init__: function () {
function domain_field_pyeval (type, object, context, options) { this._store = [];
switch(type) { },
case 'domain': __getitem__: function (index) {
case 'domains': return wrap(this._store[index.toJSON()]);
if (type === 'domain') },
object = [object]; __len__: function () {
return eval_domains(object, context); return this._store.length;
default: },
return original_pyeval(type, object, context, options); __nonzero__: function () {
} return py.PY_size(this) > 0 ? py.True : py.False;
} },
fromJSON: function (ar) {
var instance = py.PY_call(wrapping_list);
instance._store = ar;
return instance;
},
toJSON: function () {
return this._store;
},
});
// override sync_eval in order to call our specialized implementation of function wrap_context(context) {
// eval_domains for (var k in context) {
function sync_eval_domains_and_contexts (source) { if (!context.hasOwnProperty(k)) { continue; }
var contexts = ([session.user_context] || []).concat(source.contexts); var val = context[k];
// see Session.eval_context in Python // Don't add a test case like ``val === undefined``
return { // this is intended to prevent letting crap pass
context: domain_field_pyeval('contexts', contexts), // on the context without even knowing it.
domain: domain_field_pyeval('domains', source.domains), // If you face an issue from here, try to sanitize
group_by: domain_field_pyeval('groupbys', source.group_by_seq || []) // the context upstream instead
}; if (val === null) { continue; }
} if (val.constructor === Array) {
context[k] = wrapping_list.fromJSON(val);
} else if (val.constructor === Object
&& !py.PY_isInstance(val, py.object)) {
context[k] = wrapping_dict.fromJSON(val);
}
}
return context;
}
pyeval.eval = domain_field_pyeval; function ensure_evaluated(args, kwargs) {
pyeval.ensure_evaluated = ensure_evaluated; for (var i=0; i<args.length; ++i) {
pyeval.sync_eval_domains_and_contexts = sync_eval_domains_and_contexts; args[i] = eval_arg(args[i]);
}
for (var k in kwargs) {
if (!kwargs.hasOwnProperty(k)) { continue; }
kwargs[k] = eval_arg(kwargs[k]);
}
}
/** End of unmodified methods copied from pyeval **/
// We need to override the original method to be able to call our
// Specialized version of pyeval for domain fields
function eval_arg (arg) {
if (typeof arg !== 'object' || !arg.__ref) {
return arg;
}
switch (arg.__ref) {
case 'domain': case 'compound_domain':
return domain_field_pyeval('domains', [arg]);
case 'context': case 'compound_context':
return original_pyeval('contexts', [arg]);
default:
throw new Error(_t("Unknown nonliteral type ") + ' ' + arg.__ref);
}
}
// Override eval_domains to add 3 lines in order to be able to use a field
// value as domain
function eval_domains(domains, evaluation_context) {
evaluation_context = _.extend(py_utils.context(), evaluation_context || {});
var result_domain = [];
// Normalize only if the first domain is the array ["|"] or ["!"]
var need_normalization = (
domains &&
domains.length > 0 &&
domains[0].length === 1 &&
(domains[0][0] === "|" || domains[0][0] === "!")
);
_(domains).each(function (domain) {
if (_.isString(domain)) {
// Modified part or the original method
if (domain in evaluation_context) {
result_domain.push.apply(
result_domain, $.parseJSON(evaluation_context[domain]));
return;
}
// End of modifications
// wrap raw strings in domain
domain = { __ref: 'domain', __debug: domain };
}
var domain_array_to_combine;
switch(domain.__ref) {
case 'domain':
evaluation_context.context = evaluation_context;
domain_array_to_combine = py.eval(domain.__debug, wrap_context(evaluation_context));
break;
default:
domain_array_to_combine = domain;
}
if (need_normalization) {
domain_array_to_combine = get_normalized_domain(domain_array_to_combine);
}
result_domain.push.apply(result_domain, domain_array_to_combine);
});
return result_domain;
}
// Override pyeval in order to call our specialized implementation of
// eval_domains
function domain_field_pyeval (type, object, context, options) {
switch (type) {
case 'domain':
case 'domains':
if (type === 'domain') {
object = [object];
}
return eval_domains(object, context);
default:
return original_pyeval(type, object, context, options);
}
}
function eval_domains_and_contexts(source) {
// see Session.eval_context in Python
return {
context: domain_field_pyeval('contexts', source.contexts || [], source.eval_context),
domain: domain_field_pyeval('domains', source.domains, source.eval_context),
group_by: domain_field_pyeval('groupbys', source.group_by_seq || [], source.eval_context),
};
}
py_utils.eval = domain_field_pyeval;
py_utils.ensure_evaluated = ensure_evaluated;
py_utils.eval_domains_and_contexts = eval_domains_and_contexts;
}); });