', {
+ 'class': 'col-sm-10 col-sm-offset-2'
+ }).appendTo(jQuery('
', {
+ 'class': 'form-group'
+ }).appendTo(body)));
+ this.wid_text = jQuery('
', {
+ 'type': 'text',
+ 'class': 'form-control input-sm',
+ 'placeholder': Sao.i18n.gettext('Search'),
+ 'name': attributes.name,
+ }).appendTo(group);
+
+ if (!attributes.completion || attributes.completion == '1') {
+ this.wid_completion = Sao.common.get_completion(
+ group,
+ this._update_completion.bind(this),
+ this._completion_match_selected.bind(this));
+ this.wid_text.completion = this.wid_completion;
+ }
+
+ this.but_add = jQuery('
', {
+ 'class': 'btn btn-default btn-sm',
+ 'type': 'button',
+ 'aria-label': Sao.i18n.gettext("Add"),
+ 'title': Sao.i18n.gettext("Add"),
+ }).append(Sao.common.ICONFACTORY.get_icon_img('tryton-add')
+ ).appendTo(jQuery('
', {
+ 'class': 'input-group-btn'
+ }).appendTo(group));
+ this.but_add.click(this.add.bind(this));
+
+ this._readonly = false;
+ this._record_id = null;
+ this._popup = false;
+ },
+ _required_el: function() {
+ return this.wid_text;
+ },
+ _invalid_el: function() {
+ return this.wid_text;
+ },
+ add: function() {
+ var context = this.field.get_context(this.record);
+ var value = this.wid_text.val();
+ var domain = this.field.get_domain(this.record);
+
+ if (this._popup) {
+ return;
+ } else {
+ this._popup = true;
+ }
+
+ const callback = result => {
+ if (!jQuery.isEmptyObject(result)) {
+ var ids = result.map(function(e) {
+ return e[0];
+ });
+ this.add_new_keys(ids);
+ }
+ this.wid_text.val('');
+ this._popup = false;
+ };
+
+ var parser = new Sao.common.DomainParser();
+ new Sao.Window.Search(this.schema_model,
+ callback, {
+ sel_multi: true,
+ context: context,
+ domain: domain,
+ new_: false,
+ search_filter: parser.quote(value),
+ title: this.attributes.string
+ });
+ },
+ add_new_keys: function(ids) {
+ var field = this.field;
+ field.add_new_keys(ids, this.record)
+ .then(new_names => {
+ this.send_modified();
+ var value = this.field.get_client(this.record);
+ for (const key of new_names) {
+ value[key] = null;
+ }
+ this.field.set_client(this.record, value);
+ this._display().then(() => {
+ this.fields[new_names[0]].input.focus();
+ });
+ });
+ },
+ remove: function(key, modified=true) {
+ delete this.fields[key];
+ this.rows[key].remove();
+ delete this.rows[key];
+ if (modified) {
+ this.send_modified();
+ this.set_value(this.record, this.field);
+ }
+ },
+ set_value: function() {
+ this.field.set_client(this.record, this.get_value());
+ },
+ get_value: function() {
+ var value = {};
+ for (var key in this.fields) {
+ var widget = this.fields[key];
+ value[key] = widget.get_value();
+ }
+ return value;
+ },
+ get modified() {
+ if (this.record && this.field) {
+ var value = this.field.get_client(this.record);
+ for (var key in this.fields) {
+ var widget = this.fields[key];
+ if (widget.modified(value)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ },
+ set_readonly: function(readonly) {
+ Sao.View.Form.Dict._super.set_readonly.call(this, readonly);
+ this._set_button_sensitive();
+ for (var key in this.fields) {
+ var widget = this.fields[key];
+ widget.set_readonly(readonly);
+ }
+ this.wid_text.prop('disabled', readonly);
+ },
+ _set_button_sensitive: function() {
+ var create = this.attributes.create;
+ if (create === undefined) {
+ create = 1;
+ } else if (typeof create == 'string') {
+ create = Boolean(parseInt(create, 10));
+ }
+ var delete_ = this.attributes['delete'];
+ if (delete_ === undefined) {
+ delete_ = 1;
+ } else if (typeof delete_ == 'string') {
+ delete_ = Boolean(parseInt(delete_, 10));
+ }
+ this.but_add.prop('disabled', this._readonly || !create);
+ for (var key in this.fields) {
+ var button = this.fields[key].button;
+ button.prop('disabled', this._readonly || !delete_);
+ }
+ },
+ add_line: function(key, position) {
+ var field, row;
+ var key_schema = this.field.keys[key];
+ this.fields[key] = field = new (
+ this.get_entries(key_schema.type))(key, this);
+ this.rows[key] = row = jQuery('
', {
+ 'class': 'form-group'
+ });
+ var text = key_schema.string + Sao.i18n.gettext(':');
+ var label = jQuery('
', {
+ 'text': text
+ }).appendTo(jQuery('
', {
+ 'class': 'dict-label col-sm-2 control-label'
+ }).appendTo(row));
+
+ field.el.addClass('col-sm-10').appendTo(row);
+
+ label.uniqueId();
+ field.labelled.uniqueId();
+ field.labelled.attr('aria-labelledby', label.attr('id'));
+ label.attr('for', field.labelled.attr('id'));
+
+ field.button.click(() => {
+ this.remove(key, true);
+ });
+
+ var previous = null;
+ if (position > 0) {
+ previous = this.container.children().eq(position - 1);
+ }
+ if (previous) {
+ previous.after(row);
+ } else {
+ this.container.prepend(row);
+ }
+ },
+ display: function() {
+ this._display();
+ },
+ _display: function() {
+ Sao.View.Form.Dict._super.display.call(this);
+
+ var record = this.record;
+ var field = this.field;
+ if (!field) {
+ return;
+ }
+
+ var record_id = record ? record.id : null;
+ var key;
+
+ if (record_id != this._record_id) {
+ for (key in this.fields) {
+ this.remove(key, false);
+ }
+ this._record_id = record_id;
+ }
+
+ var value = field.get_client(record);
+ var new_key_names = Object.keys(value).filter(
+ e => !this.fields[e]);
+
+ var prm;
+ if (!jQuery.isEmptyObject(new_key_names)) {
+ prm = field.add_keys(new_key_names, record);
+ } else {
+ prm = jQuery.when();
+ }
+ prm.then(() => {
+ var i, len, key;
+ var keys = Object.keys(value)
+ .filter(function(key) {
+ return field.keys[key];
+ })
+ .sort(function(key1, key2) {
+ var seq1 = field.keys[key1].sequence;
+ var seq2 = field.keys[key2].sequence;
+ if (seq1 < seq2) {
+ return -1;
+ } else if (seq1 > seq2) {
+ return 1;
+ } else {
+ return 0;
+ }
+ });
+ // We remove first the old keys in order to keep the order
+ // inserting the new ones
+ var removed_key_names = Object.keys(this.fields).filter(
+ function(e) {
+ return !(e in value);
+ });
+ for (i = 0, len = removed_key_names.length; i < len; i++) {
+ key = removed_key_names[i];
+ this.remove(key, false);
+ }
+ var decoder = new Sao.PYSON.Decoder();
+ var inversion = new Sao.common.DomainInversion();
+ for (i = 0, len = keys.length; i < len; i++) {
+ key = keys[i];
+ var val = value[key];
+ if (!this.fields[key]) {
+ this.add_line(key, i);
+ }
+ var widget = this.fields[key];
+ widget.set_value(val);
+ widget.set_readonly(this._readonly);
+ var key_domain = (decoder.decode(field.keys[key].domain ||
+ 'null'));
+ if (key_domain !== null) {
+ if (!inversion.eval_domain(key_domain, value)) {
+ widget.el.addClass('has-error');
+ } else {
+ widget.el.removeClass('has-error');
+ }
+ }
+ }
+ });
+ this._set_button_sensitive();
+ return prm;
+ },
+ _update_completion: function(text) {
+ if (this.wid_text.prop('disabled')) {
+ return jQuery.when();
+ }
+ if (!this.record) {
+ return jQuery.when();
+ }
+ return Sao.common.update_completion(
+ this.wid_text, this.record, this.field, this.schema_model);
+ },
+ _completion_match_selected: function(value) {
+ this.add_new_keys([value.id]);
+ this.wid_text.val('');
+ },
+ get_entries: function(type) {
+ switch (type) {
+ case 'char':
+ return Sao.View.Form.Dict.Entry;
+ case 'boolean':
+ return Sao.View.Form.Dict.Boolean;
+ case 'selection':
+ return Sao.View.Form.Dict.Selection;
+ case 'multiselection':
+ return Sao.View.Form.Dict.MultiSelection;
+ case 'integer':
+ return Sao.View.Form.Dict.Integer;
+ case 'float':
+ return Sao.View.Form.Dict.Float;
+ case 'numeric':
+ return Sao.View.Form.Dict.Numeric;
+ case 'date':
+ return Sao.View.Form.Dict.Date;
+ case 'datetime':
+ return Sao.View.Form.Dict.DateTime;
+ }
+ }
+ });
+
+ Sao.View.Form.Dict.Entry = Sao.class_(Object, {
+ init: function(name, parent_widget) {
+ this.name = name;
+ this.definition = parent_widget.field.keys[name];
+ this.parent_widget = parent_widget;
+ this.create_widget();
+ if (this.definition.help) {
+ this.el.attr('title', this.definition.help);
+ }
+ },
+ create_widget: function() {
+ this.el = jQuery('
', {
+ 'class': this.class_
+ });
+ var group = jQuery('
', {
+ 'class': 'input-group input-group-sm'
+ }).appendTo(this.el);
+ this.input = this.labelled = jQuery('
', {
+ 'type': 'text',
+ 'class': 'form-control input-sm mousetrap',
+ 'name': this.name,
+ }).appendTo(group);
+ this.button = jQuery('
', {
+ 'class': 'btn btn-default',
+ 'type': 'button',
+ 'arial-label': Sao.i18n.gettext("Remove"),
+ 'title': Sao.i18n.gettext("Remove"),
+ }).append(Sao.common.ICONFACTORY.get_icon_img('tryton-remove')
+ ).appendTo(jQuery('
', {
+ 'class': 'input-group-btn'
+ }).appendTo(group));
+
+ this.el.on('keydown',
+ this.parent_widget.send_modified.bind(this.parent_widget));
+ this.el.change(
+ this.parent_widget.focus_out.bind(this.parent_widget));
+ },
+ modified: function(value) {
+ return (JSON.stringify(this.get_value()) !=
+ JSON.stringify(value[this.name]));
+ },
+ get_value: function() {
+ return this.input.val();
+ },
+ set_value: function(value) {
+ this.input.val(value || '');
+ },
+ set_readonly: function(readonly) {
+ this._readonly = readonly;
+ this.input.prop('readonly', readonly);
+ }
+ });
+
+ Sao.View.Form.Dict.Char = Sao.class_(Sao.View.Form.Dict.Entry, {
+ class_: 'dict-char',
+ modified: function(value) {
+ return (JSON.stringify(this.get_value()) !=
+ JSON.stringify(value[this.name] || ""));
+ }
+ });
+
+ Sao.View.Form.Dict.Boolean = Sao.class_(Sao.View.Form.Dict.Entry, {
+ class_: 'dict-boolean',
+ create_widget: function() {
+ Sao.View.Form.Dict.Boolean._super.create_widget.call(this);
+ this.input.attr('type', 'checkbox');
+ this.input.change(
+ this.parent_widget.focus_out.bind(this.parent_widget));
+ },
+ get_value: function() {
+ return this.input.prop('checked');
+ },
+ set_readonly: function(readonly) {
+ this._readonly = readonly;
+ this.input.prop('disabled', readonly);
+ },
+ set_value: function(value) {
+ this.input.prop('checked', value);
+ }
+ });
+
+ Sao.View.Form.Dict.SelectionEntry = Sao.class_(Sao.View.Form.Dict.Entry, {
+ create_widget: function() {
+ Sao.View.Form.Dict.SelectionEntry._super.create_widget.call(this);
+ var select = jQuery('
', {
+ 'class': 'form-control input-sm mousetrap',
+ 'name': this.name,
+ });
+ select.change(
+ this.parent_widget.focus_out.bind(this.parent_widget));
+ this.input.replaceWith(select);
+ this.input = this.labelled = select;
+ var selection = jQuery.extend([], this.definition.selection);
+ if (this.definition.sort === undefined || this.definition.sort) {
+ selection.sort(function(a, b) {
+ return a[1].localeCompare(b[1]);
+ });
+ }
+ for (const e of selection) {
+ select.append(jQuery('
', {
+ 'value': JSON.stringify(e[0]),
+ 'text': e[1],
+ 'title': this.definition.help_selection[e[0]],
+ }));
+ }
+ },
+ set_readonly: function(readonly) {
+ this._readonly = readonly;
+ this.input.prop('disabled', readonly);
+ }
+ });
+
+ Sao.View.Form.Dict.Selection = Sao.class_(
+ Sao.View.Form.Dict.SelectionEntry, {
+ class_: 'dict-selection',
+ create_widget: function() {
+ Sao.View.Form.Dict.Selection._super.create_widget.call(this);
+ this.input.prepend(jQuery('
', {
+ 'value': JSON.stringify(null),
+ 'text': '',
+ }));
+ },
+ get_value: function() {
+ return JSON.parse(this.input.val());
+ },
+ set_value: function(value) {
+ this.input.val(JSON.stringify(value));
+ var title = this.definition.help_selection[value] || null;
+ if (this.definition.help && title) {
+ title = this.definition.help + '\n' + title;
+ }
+ this.input.attr('title', title);
+ },
+ });
+
+ Sao.View.Form.Dict.MultiSelection = Sao.class_(
+ Sao.View.Form.Dict.SelectionEntry, {
+ class_: 'dict-multiselection',
+ create_widget: function() {
+ Sao.View.Form.Dict.MultiSelection._super
+ .create_widget.call(this);
+ this.input.prop('multiple', true);
+ var widget_help = this.definition.help;
+ if (widget_help) {
+ this.input.children().each(function() {
+ var option = jQuery(this);
+ var help = option.attr('title');
+ if (help) {
+ help = widget_help + '\n' + help;
+ option.attr('title', help);
+ }
+ });
+ }
+ },
+ get_value: function() {
+ var value = this.input.val();
+ return value.map(function(e) { return JSON.parse(e); });
+ },
+ set_value: function(value) {
+ if (value) {
+ value = value.map(function(e) { return JSON.stringify(e); });
+ }
+ this.input.val(value);
+ }
+ });
+
+ Sao.View.Form.Dict.Integer = Sao.class_(Sao.View.Form.Dict.Entry, {
+ class_: 'dict-integer',
+ create_widget: function() {
+ Sao.View.Form.Dict.Integer._super.create_widget.call(this);
+ this.input_text = this.labelled = integer_input(this.input);
+ },
+ get_value: function() {
+ var value = parseInt(this.input.val(), 10);
+ if (isNaN(value)) {
+ return null;
+ }
+ return value;
+ },
+ set_value: function(value, options) {
+ if (value !== null) {
+ this.input.val(value);
+ this.input_text.val(value.toLocaleString(
+ Sao.i18n.BC47(Sao.i18n.getlang()), options));
+ } else {
+ this.input.val('');
+ this.input_text.val('');
+ }
+ },
+ set_readonly: function(readonly) {
+ Sao.View.Form.Dict.Integer._super.set_readonly.call(this, readonly);
+ this.input_text.prop('readonly', readonly);
+ },
+ });
+
+ Sao.View.Form.Dict.Float = Sao.class_(Sao.View.Form.Dict.Integer, {
+ class_: 'dict-float',
+ get digits() {
+ var record = this.parent_widget.record;
+ if (record) {
+ var digits = record.expr_eval(this.definition.digits);
+ if (!digits || !digits.every(function(e) {
+ return e !== null;
+ })) {
+ return null;
+ }
+ return digits;
+ } else {
+ return null;
+ }
+ },
+ get_value: function() {
+ var value = this.input.val();
+ if (!value && (value !== 0)) {
+ return null;
+ }
+ value = Number(value);
+ if (isNaN(value)) {
+ return null;
+ }
+ return value;
+ },
+ set_value: function(value) {
+ var step = 'any',
+ options = {};
+ var digits = this.digits;
+ if (digits) {
+ step = Math.pow(10, -digits[1]).toFixed(digits[1]);
+ options.minimumFractionDigits = digits[1];
+ options.maximumFractionDigits = digits[1];
+ }
+ this.input.attr('step', step);
+ Sao.View.Form.Dict.Float._super.set_value.call(this, value, options);
+ },
+ });
+
+ Sao.View.Form.Dict.Numeric = Sao.class_(Sao.View.Form.Dict.Float, {
+ class_: 'dict-numeric',
+ get_value: function() {
+ var value = this.input.val();
+ if (!value && (value !== 0)) {
+ return null;
+ }
+ value = new Sao.Decimal(value);
+ if (isNaN(value.valueOf())) {
+ return null;
+ }
+ return value;
+ }
+ });
+
+ Sao.View.Form.Dict.Date = Sao.class_(Sao.View.Form.Dict.Entry, {
+ class_: 'dict-date',
+ format: '%x',
+ _input: 'date',
+ _input_format: '%Y-%m-%d',
+ _format: Sao.common.format_date,
+ _parse: Sao.common.parse_date,
+ create_widget: function() {
+ Sao.View.Form.Dict.Date._super.create_widget.call(this);
+ var group = this.input.parent().find('.input-group-btn');
+ this.input_date = jQuery('
', {
+ 'type': this._input,
+ 'role': 'button',
+ 'tabindex': -1,
+ });
+ this.input_date.click(() => {
+ var value = this.get_value();
+ value = this._format(this._input_format, value);
+ this.input_date.val(value);
+ });
+ this.input_date.change(() => {
+ var value = this.input_date.val();
+ if (value) {
+ value = this._parse(this._input_format, value);
+ value = this._format(this.format, value);
+ this.input.val(value).change();
+ this.input.focus();
+ }
+ });
+ if (this.input_date[0].type == this._input) {
+ var icon = jQuery('
', {
+ 'class': 'btn btn-default',
+ 'aria-label': Sao.i18n.gettext("Open the calendar"),
+ 'title': Sao.i18n.gettext("Open the calendar"),
+ }).prependTo(group);
+ this.input_date.appendTo(icon);
+ Sao.common.ICONFACTORY.get_icon_img('tryton-date')
+ .appendTo(icon);
+ }
+ var mousetrap = new Mousetrap(this.el[0]);
+
+ mousetrap.bind('enter', (e, combo) => {
+ var value = this._parse(this.format, this.input.val());
+ value = this._format(this.format, value);
+ this.input.val(value).change();
+ });
+ mousetrap.bind('=', (e, combo) => {
+ e.preventDefault();
+ this.input.val(this._format(this.format, moment())).change();
+ });
+
+ Sao.common.DATE_OPERATORS.forEach(operator => {
+ mousetrap.bind(operator[0], (e, combo) => {
+ e.preventDefault();
+ var date = this.get_value() || Sao.DateTime();
+ date.add(operator[1]);
+ this.input.val(this._format(this.format, date)).change();
+ });
+ });
+ },
+ get_value: function() {
+ return this._parse(this.format, this.input.val());
+ },
+ set_value: function(value) {
+ this.input.val(this._format(this.format, value));
+ },
+ });
+
+ Sao.View.Form.Dict.DateTime = Sao.class_(Sao.View.Form.Dict.Date, {
+ class_: 'dict-datetime',
+ format: '%x %X',
+ _input: 'datetime-local',
+ _input_format: '%Y-%m-%dT%H:%M:%S',
+ _format: Sao.common.format_datetime,
+ _parse: Sao.common.parse_datetime,
+ });
+
+ Sao.View.Form.PYSON = Sao.class_(Sao.View.Form.Char, {
+ class_: 'form-pyson',
+ init: function(view, attributes) {
+ Sao.View.Form.PYSON._super.init.call(this, view, attributes);
+ this.encoder = new Sao.PYSON.Encoder({});
+ this.decoder = new Sao.PYSON.Decoder({}, true);
+ this.el.keyup(this.validate_pyson.bind(this));
+ this.icon = jQuery('
![]()
', {
+ 'class': 'icon form-control-feedback',
+ }).appendTo(this.group);
+ this.group.addClass('has-feedback');
+ },
+ display: function() {
+ Sao.View.Form.PYSON._super.display.call(this);
+ this.validate_pyson();
+ },
+ get_encoded_value: function() {
+ var value = this.input.val();
+ if (!value) {
+ return value;
+ }
+ try {
+ return this.encoder.encode(eval_pyson(value));
+ }
+ catch (err) {
+ return null;
+ }
+ },
+ set_value: function() {
+ // avoid modification because different encoding
+ var value = this.get_encoded_value();
+ var record = this.record;
+ var field = this.field;
+ var previous = field.get_client(record);
+ if (value && previous && Sao.common.compare(
+ value, this.encoder.encode(this.decoder.decode(previous)))) {
+ value = previous;
+ }
+ field.set_client(record, value);
+ },
+ get_client_value: function() {
+ var value = Sao.View.Form.PYSON._super.get_client_value.call(this);
+ if (value) {
+ value = Sao.PYSON.toString(this.decoder.decode(value));
+ }
+ return value;
+ },
+ validate_pyson: function() {
+ var icon = 'ok';
+ if (this.get_encoded_value() === null) {
+ icon = 'error';
+ }
+ Sao.common.ICONFACTORY.get_icon_url('tryton-' + icon)
+ .then(url => {
+ this.icon.attr('src', url);
+ });
+ },
+ focus_out: function() {
+ this.validate_pyson();
+ Sao.View.Form.PYSON._super.focus_out.call(this);
+ }
+ });
+
+ let botuiInstance = null;
+ let previousValue = null;
+ Sao.View.Form.HTMLViewer = Sao.class_(Sao.View.Form.Widget, {
+ class_: 'form-htmlviewer',
+ expand: true,
+
+ init: function(view, attributes) {
+ Sao.View.Form.HTMLViewer._super.init.call(this, view, attributes);
+ this.el = jQuery('
', {
+ 'class': this.class_ + ' panel panel-default',
+ });
+
+ this.container = jQuery('
', {
+ 'class': 'panel-body htmlviewer-content',
+ }).appendTo(this.el);
+ },
+
+ display: function() {
+ Sao.View.Form.HTMLViewer._super.display.call(this);
+ var value = '';
+ var record = this.record;
+
+ if (record) {
+ value = record.field_get_client(this.field_name);
+ }
+ console.log("HTMLViewer",this.field_name)
+ console.log("Value from display",value)
+ console.log("Last Value from display",this._last_value)
+ // Si la valeur n'a pas changé, ne rien faire
+ if (this._last_value === value) {
+ return;
+ }
+
+ this._last_value = value;
+ this.container.empty();
+
+ // if (!value) {
+ // return;
+ // }
+
+ let height = 300
+ let width = 400
+ if (this.attributes.height) {
+ height = parseInt(this.attributes.height);
+ }
+ if (this.attributes.width) {
+ width = parseInt(this.attributes.width);
+ }
+ Sao.renderHTMLViewerContent(this.container, value, height, width, this.record);
+
+ },
+
+ focus: function() {
+ // No input element to focus
+ return false;
+ },
+
+ get_value: function() {
+ // Read-only, no value
+ return null;
+ },
+
+ set_value: function() {
+ // No-op — viewer only
+ },
+
+ set_readonly: function(readonly) {
+ // Viewer is always read-only — nothing to do
+ },
+
+ get modified() {
+ return false;
+ },
+ });
+
+ Sao.View.VisGraph = Sao.class_(Sao.View, {
+ editable: false,
+ view_type: 'graph',
+ xml_parser: Sao.View.GraphXMLViewParser,
+ init: function(view_id, screen, xml, children_field) {
+ this.el = jQuery('
', {
+ 'class': 'graph'
+ });
+ this.container = this.el;
+ Sao.View.VisGraph._super.init.call(this, view_id, screen, xml);
+ },
+
+ display: function() {
+ const loads = [];
+
+ for (const record of this.screen.group) {
+ loads.push(record.load('vis_data'));
+ }
+
+ jQuery.when.apply(jQuery, loads).done(() => {
+ for (const record of this.screen.group) {
+ const visData = record.field_get_client('vis_data');
+ try {
+ let height = 300
+ let width = 400
+ if (this.attributes.height) {
+ height = parseInt(this.attributes.height);
+ }
+ if (this.attributes.width) {
+ width = parseInt(this.attributes.width);
+ }
+ Sao.renderHTMLViewerContent(this.container, visData,height,width, record);
+ } catch (e) {
+ console.warn('Erreur de parsing JSON pour vis_data', e);
+ }
+ }
+ });
+ },
+
+ reload: function() {
+ this.display();
+ },
+
+ get deletable() {
+ return false;
+ },
+
+ set_value: function() {
+ // No-op — viewer only
+ },
+
+ });
+
+ window.addEventListener("message", function (event) {
+ if (event.data?.type === "open_tab") {
+ const { model, res_id, view_mode, domain, context } = event.data.payload || {};
+
+ Sao.Tab.create({
+ model: model,
+ res_id: res_id,
+ mode: view_mode,
+ domain: domain,
+ target: "new",
+ context: context
+ });
+ }
+ if (event.data?.type === "exec_window"){
+ const { model, res_id, view_mode, domain, context } = event.data.payload || {};
+ var action = {
+ type: 'ir.action.act_window',
+ res_model: model,
+
+ pyson_domain: domain,
+
+ pyson_context: JSON.stringify(context),
+ pyson_order: 'null',
+ pyson_search_value: '[]',
+
+ views: [],
+ domains: []
+ };
+
+ Sao.Action.exec_action(action, { ids: [] }, {});
+ }
+ });
+ // window.addEventListener("message", function (event) {
+ // // ⚠️ Sécurité : vérifier l'origine
+ // // if (event.origin !== "https://ton-react.example.com") return;
+
+ // if (event.data?.type === "open_tab") {
+ // const { model, res_id, view_mode, domain } = event.data.payload || {};
+
+ // Sao.Tab.create({
+ // model: model,
+ // res_id: res_id,
+ // mode: [view_mode],
+ // domain: domain,
+ // target: "new",
+ // });
+ // }
+ // });
+
+ Sao.renderHTMLViewerContent = function(container, value, height, width, record) {
+ function decodeHtmlEntities(str) {
+ const txt = document.createElement('textarea');
+ txt.innerHTML = str;
+ return txt.value;
+ }
+ console.log("Value",value)
+ container.empty();
+
+ if (!value) return;
+
+ if (/^imo:\d+$/.test(value)) {
+ // Case 1: VesselFinder ship by IMO
+ var imo = value.split(':')[1];
+
+ var iframe = document.createElement('iframe');
+ iframe.style.width = '100%';
+ iframe.style.height = height.toString()+'px';
+ iframe.style.border = '0';
+ iframe.src = `https://www.vesselfinder.com/aismap?width=100%25&height=${height-10}&names=true&imo=${imo}&track=true`;
+ container[0].appendChild(iframe);
+
+ } else if (/^https?:\/\//i.test(value)) {
+ // Case 2: Generic URL (not VesselFinder)
+ console.log("InFrame",value)
+ var iframe = jQuery('
', {
+ src: value,
+ width: '100%',
+ height: height.toString()+'px',
+ frameborder: 0,
+ scrolling: 'auto',
+ // sandbox: 'allow-same-origin allow-scripts allow-popups allow-forms', // optional: adjust based on your security needs
+ });
+ container.append(iframe);
+ } else if (value.startsWith("metabase:")) {
+ const url = value.replace(/^metabase:/, '');
+ const iframe = jQuery('
', {
+ src: url,
+ width: '100%',
+ height: height.toString()+'px',
+ frameborder: 0,
+ allowtransparency: 'true',
+ sandbox: 'allow-same-origin allow-scripts allow-popups allow-forms',
+ });
+ container.append(iframe);
+ } else if (value.startsWith("chatbot:")) {
+ let chatData = JSON.parse(value.replace(/^chatbot:/, '')) || [];
+ let lastMessage = chatData[chatData.length - 1];
+ container.empty();
+ const chatHeight = height - 60;
+
+ // 1. Ajouter le conteneur HTML
+ $('
', {
+ id: 'chat-wrapper',
+ html: `
+
+
+
+
+
+
+
+ `,
+ css: {
+ width: '100%',
+ height: height.toString()+'px',
+ boxSizing: 'border-box'
+ }
+ }).appendTo(container);
+
+ $('#chat-container').css({
+ height: chatHeight.toString() + 'px',
+ overflowY: 'auto',
+ borderRadius: '16px',
+ border: '1px solid #ccc',
+ padding: '10px',
+ boxSizing: 'border-box',
+ background: '#fff'
+ });
+
+ // 2. Ajout des messages de l'historique
+ const chatContainer = document.getElementById('chat-container');
+
+ const addMessage = (type, content) => {
+ if ((type === 'bot') || (type === 'user')){
+ const bubble = document.createElement('div');
+ bubble.className = `chat-bubble ${type}`;
+ bubble.innerHTML = decodeHtmlEntities(content);
+ chatContainer.appendChild(bubble);
+ bubble.querySelectorAll('a.tryton-link').forEach(link => {
+ link.addEventListener('click', (event) => {
+ event.preventDefault();
+ const target = event.currentTarget;
+ const model = target.getAttribute('data-model');
+ const res_id = parseInt(target.getAttribute('data-id'), 10);
+ const view_mode = target.getAttribute('data-view') || 'form';
+
+ if (!model || isNaN(res_id)) return;
+
+ Sao.Tab.create({
+ model: model,
+ res_id: res_id,
+ mode: [view_mode],
+ target: "new",
+ });
+ });
+ });
+ chatContainer.scrollTop = chatContainer.scrollHeight;
+ }
+ };
+ for (let msg of chatData) {
+ addMessage(msg.type, msg.content);
+ }
+
+ // 3. Gérer la saisie utilisateur
+ const input = document.getElementById('user-input');
+ const button = document.getElementById('send-btn');
+
+ button.addEventListener('click', () => {
+ const question = input.value.trim();
+ if (question) {
+ addMessage('user', question);
+ let currentUserId = Sao.Session.current_session.user_id;
+ // charger les inputs via RPC
+ let fields = ['id','user_id']; // les champs dont on a besoin
+ let domain = [['user_id', '=', currentUserId]]; // filtrer sur ce dashboard
+
+ Sao.rpc({
+ 'method': 'model.purchase.dashboard.search_read',
+ 'params': [domain, 0, null, null, fields, Sao.Session.current_session.context]
+ }, Sao.Session.current_session, true, false).then(inputs => {
+ console.log("RPC results",inputs);
+ let userInput = inputs.find(r => r.user_id === currentUserId);
+ Sao.Action.execute(479, {
+ model: 'purchase.dashboard',
+ id: userInput.id,
+ ids: [userInput.id]
+ }, {user_request: question}, Sao.Session.current_session.context, true)
+ .then(() => {
+ chatData.push({ type: 'user', content: question });
+ input.value = '';
+ record.field_set_client('input', JSON.stringify(chatData));
+ })
+ });
+ }
+ });
+
+ // 4. Permettre la touche "Entrée"
+ input.addEventListener('keydown', (e) => {
+ if (e.key === 'Enter') {
+ button.click();
+ }
+ });
+ } else {
+ if (value.startsWith('d3:')) {
+ const json = value.slice(3);
+ const config = JSON.parse(json); // doit contenir { highlightedCountry: '250' }
+
+ // Réutilise le conteneur si déjà présent
+ let d3Div = container.find('.d3-map-container');
+ if (d3Div.length === 0) {
+ d3Div = $('
', {
+ class: 'd3-map-container',
+ css: {
+ width: '100%',
+ minWidth: '800px',
+ height: (height - 25*height/1000).toString() + 'px',
+ overflow: 'visible',
+ background: 'transparent'
+ }
+ }).appendTo(container);
+ } else {
+ d3Div.empty(); // vide sans supprimer le conteneur
+ }
+
+ const loadD3Map = () => {
+ const svg = d3.select(d3Div[0])
+ .append("svg")
+ .attr("width", width)
+ .attr("height", (height - 25*height/1000));
+
+ const scale = Math.min(width, height) * 0.3;
+
+ const projection = d3.geoNaturalEarth1()
+ .scale(scale)
+ .translate([width / 2, (height - 10) / 2]);
+
+ const path = d3.geoPath().projection(projection);
+
+ function showTooltip(data, type) {
+ // Supprime les anciens tooltips
+ svg.selectAll(".boat-tooltip-container").remove();
+
+ const svgHeight = +svg.attr("height");
+ const tooltipHeight = 400;
+
+ const tooltipGroup = svg.append("g")
+ .attr("class", "boat-tooltip-container")
+ .attr("transform", `translate(10, ${svgHeight - tooltipHeight - 100})`);
+
+ let html = `
+
+
+
${data.name || data.properties?.name || 'Objet'}
+
+
+ `;
+
+ if (type === 'boat') {
+ html += `
+
+
IMO: ${data.imo || 'N/A'}
+
Position: ${data.lat.toFixed(2)}, ${data.lon.toFixed(2)}
+
Statut: ${data.status || 'En route'}
+
+ ${data.links ? `
+
+
+ ${data.links.map(link => `
+ -
+ ${link.text}
+
+ `).join('')}
+
+
+ ` : ''}
+
+ ${data.actions ? `
+
+ ${data.actions.map(action => `
+
+ `).join('')}
+
+ ` : ''}
+
+
+
+ `;
+ } else if (type === 'country') {
+ html += `
+
Country: ${data.properties.name}
+ `;
+ }
+
+ html += `