tryton 6.6.8__py3-none-any.whl → 6.8.1__py3-none-any.whl

tryton/gui/window/form.py

@@ -2,7 +2,6 @@
 # this repository contains the full copyright notices and license terms.
 "Form"
 import csv
-import datetime
 import gettext
 import locale
 import os
@@ -14,8 +13,7 @@ from gi.repository import Gdk, GLib, Gtk
 import tryton.common as common
 from tryton import plugins
 from tryton.action import Action
-from tryton.common import (
-    RPCException, RPCExecute, message, sur, sur_3b, timezoned_date)
+from tryton.common import RPCException, RPCExecute, sur, sur_3b
 from tryton.common.common import selection as selection_
 from tryton.common.popup_menu import popup
 from tryton.common.underline import set_underline
@@ -23,6 +21,7 @@ from tryton.gui import Main
 from tryton.gui.window import Window
 from tryton.gui.window.attachment import Attachment
 from tryton.gui.window.email_ import Email
+from tryton.gui.window.log import Log
 from tryton.gui.window.note import Note
 from tryton.gui.window.revision import Revision
 from tryton.gui.window.view_form.screen import Screen
@@ -75,7 +74,7 @@ class Form(TabContent):
                 self.screen.search_filter()
 
         self.update_revision()
-        self.activate_save()
+        self.set_buttons_sensitive()
 
     def get_toolbars(self):
         try:
@@ -295,37 +294,8 @@ class Form(TabContent):
         if not current_record or current_record.id < 0:
             self.info_bar_add(
                 _('You have to select one record.'), Gtk.MessageType.INFO)
-            return False
-
-        fields = [
-            ('id', _('ID:')),
-            ('create_uid.rec_name', _('Created by:')),
-            ('create_date', _('Created at:')),
-            ('write_uid.rec_name', _('Edited by:')),
-            ('write_date', _('Edited at:')),
-        ]
-
-        try:
-            data = RPCExecute('model', self.model, 'read', [current_record.id],
-                [x[0] for x in fields], context=self.screen.context)[0]
-        except RPCException:
             return
-        date_format = self.screen.context.get('date_format', '%x')
-        datetime_format = date_format + ' %H:%M:%S.%f'
-        message_str = ''
-        for (key, label) in fields:
-            value = data
-            keys = key.split('.')
-            name = keys.pop(-1)
-            for key in keys:
-                value = value.get(key + '.', {})
-            value = (value or {}).get(name, '/')
-            if isinstance(value, datetime.datetime):
-                value = timezoned_date(value).strftime(datetime_format)
-            message_str += '%s %s\n' % (label, value)
-        message_str += _('Model:') + ' ' + self.model
-        message(message_str)
-        return True
+        Log(current_record)
 
     def sig_revision(self, widget=None):
         if not self.modified_save():
@@ -374,24 +344,29 @@ class Form(TabContent):
             tooltip = self.name
         self.title.set_text(label)
         tooltips.set_tip(self.title, tooltip)
-        self.set_buttons_sensitive(revision)
+        self.set_buttons_sensitive()
 
-    def set_buttons_sensitive(self, revision=None):
+    def set_buttons_sensitive(self):
+        revision = self.screen.context.get('_datetime')
         if not revision:
             access = common.MODELACCESS[self.model]
+            modified = self.screen.modified()
             for name, sensitive in [
-                    ('new', access['create']),
-                    ('save', access['create'] or access['write']),
+                    ('new', access['create'] and not modified),
+                    ('save',
+                        (access['create'] or access['write'])
+                        and modified and not self.screen.readonly),
                     ('remove', access['delete']),
                     ('copy', access['create']),
                     ('import', access['create']),
+                    ('action', access['write'] and not self.screen.readonly),
                     ]:
                 if name in self.buttons:
                     self.buttons[name].props.sensitive = sensitive
                 if name in self.menu_buttons:
                     self.menu_buttons[name].props.sensitive = sensitive
         else:
-            for name in ['new', 'save', 'remove', 'copy', 'import']:
+            for name in ['new', 'save', 'remove', 'copy', 'import', 'action']:
                 if name in self.buttons:
                     self.buttons[name].props.sensitive = False
                 if name in self.menu_buttons:
@@ -467,7 +442,7 @@ class Form(TabContent):
                 return
         self.screen.new()
         self.info_bar_clear()
-        self.activate_save()
+        self.set_buttons_sensitive()
 
     def sig_copy(self, widget=None):
         if not common.MODELACCESS[self.model]['create']:
@@ -502,14 +477,14 @@ class Form(TabContent):
             return
         self.screen.display_prev()
         self.info_bar_clear()
-        self.activate_save()
+        self.set_buttons_sensitive()
 
     def sig_next(self, widget=None):
         if not self.modified_save():
             return
         self.screen.display_next()
         self.info_bar_clear()
-        self.activate_save()
+        self.set_buttons_sensitive()
 
     def sig_reload(self, test_modified=True):
         if test_modified:
@@ -531,7 +506,6 @@ class Form(TabContent):
         self.screen.display(set_cursor=set_cursor)
         self.info_bar_clear()
         self.set_buttons_sensitive()
-        self.activate_save()
         self.screen.count_tab_domain()
         return True
 
@@ -601,8 +575,7 @@ class Form(TabContent):
         selected = len(self.screen.selected_records)
         if selected > 1:
             name += '#%i' % selected
-        for button_id in ('print', 'relate', 'email', 'open', 'save',
-                'attach'):
+        for button_id in ['print', 'relate', 'email', 'open', 'attach']:
             button = self.buttons[button_id]
             can_be_sensitive = getattr(button, '_can_be_sensitive', True)
             if button_id in {'print', 'relate', 'email', 'open'}:
@@ -612,8 +585,6 @@ class Form(TabContent):
                 can_be_sensitive |= any(
                     b.attrs.get('keyword', 'action') == action_type
                     for b in self.screen.get_buttons())
-            elif button_id == 'save':
-                can_be_sensitive &= not self.screen.readonly
             set_sensitive(button_id, bool(position) and can_be_sensitive)
         set_sensitive('switch', self.screen.number_of_views > 1)
         set_sensitive('remove', self.screen.deletable)
@@ -629,7 +600,7 @@ class Form(TabContent):
             msg = "%s/%s" % (name, common.humanize(size))
         self.status_label.set_text(msg)
         self.info_bar_clear()
-        self.activate_save()
+        self.set_buttons_sensitive()
         self.refresh_attachment_preview()
 
     def record_modified(self):
@@ -637,12 +608,12 @@ class Form(TabContent):
             # As it is called via idle_add, the form could have been destroyed
             # in the meantime.
             if self.widget_get().props.window:
-                self.activate_save()
+                self.set_buttons_sensitive()
         GLib.idle_add(_record_modified)
         self.info_bar_refresh()
 
     def record_saved(self):
-        self.activate_save()
+        self.set_buttons_sensitive()
         self.refresh_resources()
 
     def modified_save(self):
@@ -693,9 +664,6 @@ class Form(TabContent):
         }
         Action.execute(action, data, context=self.screen.local_context)
 
-    def activate_save(self):
-        self.buttons['save'].props.sensitive = self.screen.modified()
-
     def sig_win_close(self, widget):
         Main().sig_win_close(widget)
 

tryton/gui/window/infobar.py

@@ -12,9 +12,10 @@ class InfoBar(object):
         self.__box = Gtk.VBox()
         self.__box.show()
         self.__messages = set()
+        self.__kinds = {}
         return self.__box
 
-    def info_bar_add(self, message, type_=Gtk.MessageType.ERROR):
+    def info_bar_add(self, message, type_=Gtk.MessageType.ERROR, kind=None):
         if not message:
             return
         key = (message, type_)
@@ -27,15 +28,19 @@ class InfoBar(object):
             info_bar.connect('response', self.__response, key)
             info_bar.set_message_type(type_)
             info_bar.show_all()
+            self.__kinds[info_bar] = kind
 
     def __response(self, widget, response, key):
         self.__messages.add(key)
         self.__box.remove(widget)
 
-    def info_bar_refresh(self):
+    def info_bar_refresh(self, kind=None):
         for child in self.__box.get_children():
-            self.__box.remove(child)
+            if self.__kinds[child] == kind:
+                self.__box.remove(child)
+                del self.__kinds[child]
 
     def info_bar_clear(self):
-        self.info_bar_refresh()
+        for kind in set(self.__kinds.values()):
+            self.info_bar_refresh(kind=kind)
         self.__messages.clear()

tryton/gui/window/log.py

@@ -0,0 +1,95 @@
+# This file is part of Tryton.  The COPYRIGHT file at the top level of
+# this repository contains the full copyright notices and license terms.
+
+import gettext
+
+from gi.repository import Gtk
+
+from tryton.common import RPCException, RPCExecute, timezoned_date
+from tryton.common.underline import set_underline
+from tryton.gui.window.view_form.screen import Screen
+from tryton.gui.window.win_form import WinForm
+
+_ = gettext.gettext
+
+
+class Log(WinForm):
+
+    def __init__(self, record):
+        self.resource = '%s,%s' % (record.model_name, record.id)
+        title = _("Logs (%s)") % record.rec_name()
+
+        context = record.get_context()
+        try:
+            log, = RPCExecute(
+                'model', record.model_name, 'read', [record.id],
+                ['create_uid.rec_name', 'create_date',
+                    'write_uid.rec_name', 'write_date'], context=context)
+        except RPCException:
+            return
+
+        date_format = context.get('date_format', '%x')
+        datetime_format = date_format + ' %H:%M:%S.%f'
+
+        grid = Gtk.Grid(
+            column_spacing=3, row_spacing=3, border_width=3)
+
+        entry_model = Gtk.Entry(editable=False)
+        entry_model.set_text(record.model_name)
+        grid.attach(entry_model, 1, 1, 1, 1)
+        label_model = Gtk.Label(
+            label=set_underline(_("Model:")),
+            use_underline=True, halign=Gtk.Align.END)
+        label_model.set_mnemonic_widget(entry_model)
+        grid.attach(label_model, 0, 1, 1, 1)
+
+        entry_id = Gtk.Entry(editable=False)
+        entry_id.set_alignment(1)
+        entry_id.set_text(str(record.id))
+        grid.attach(entry_id, 3, 1, 1, 1)
+        label_id = Gtk.Label(
+            label=set_underline(_("ID:")),
+            use_underline=True, halign=Gtk.Align.END)
+        label_id.set_mnemonic_widget(entry_id)
+        grid.attach(label_id, 2, 1, 1, 1)
+
+        for i, (user, user_label, date, date_label) in enumerate([
+                    ('create_uid.', _("Created by:"),
+                        'create_date', _("Created at:")),
+                    ('write_uid.', _("Last Modified by:"),
+                        'write_date', _("Last Modified at:"))], 2):
+            entry_user = Gtk.Entry(editable=False, width_chars=50)
+            user = log.get(user)
+            if user:
+                user = user.get('rec_name', '')
+            entry_user.set_text(user or '')
+            grid.attach(entry_user, 1, i, 1, 1)
+            label_user = Gtk.Label(
+                label=set_underline(user_label),
+                use_underline=True, halign=Gtk.Align.END)
+            label_user.set_mnemonic_widget(entry_user)
+            grid.attach(label_user, 0, i, 1, 1)
+
+            entry_date = Gtk.Entry(editable=False)
+            date = log.get(date)
+            if date:
+                date = timezoned_date(date).strftime(datetime_format)
+            entry_date.set_width_chars(len(date or ''))
+            entry_date.set_text(date or '')
+            grid.attach(entry_date, 3, i, 1, 1)
+            label_date = Gtk.Label(
+                label=set_underline(date_label),
+                use_underline=True, halign=Gtk.Align.END)
+            label_date.set_mnemonic_widget(entry_date)
+            grid.attach(label_date, 2, i, 1, 1)
+
+        grid.show_all()
+
+        screen = Screen('ir.model.log', domain=[
+                ('resource', '=', self.resource),
+                ], mode=['tree', 'form'])
+        super().__init__(screen, view_type='tree', title=title)
+        screen.search_filter()
+
+        self.win.vbox.pack_start(grid, expand=False, fill=True, padding=0)
+        self.win.vbox.reorder_child(grid, 2)

tryton/gui/window/view_board/action.py

@@ -122,10 +122,6 @@ class Action:
                     self.screen.current_record.cancel()
             WinForm(self.screen, callback, title=self.title.get_text())
 
-    def set_value(self, mode, model_field):
-        self.screen.current_view.set_value()
-        return True
-
     def display(self):
         self.screen.search_filter(self.screen.screen_container.get_text())
 

tryton/gui/window/view_form/model/field.py

@@ -95,8 +95,11 @@ class Field(object):
     def validate(self, record, softvalidation=False, pre_validate=None):
         if self.attrs.get('readonly'):
             return True
+        state_attrs = self.get_state_attrs(record)
+        is_required = bool(int(state_attrs.get('required') or 0))
+        is_invisible = bool(int(state_attrs.get('invisible') or 0))
         invalid = False
-        self.get_state_attrs(record)['domain_readonly'] = False
+        state_attrs['domain_readonly'] = False
         domain = simplify(self.validation_domains(record, pre_validate))
         if not softvalidation:
             if not self.check_required(record):
@@ -107,8 +110,15 @@ class Field(object):
         elif domain == [('id', '=', None)]:
             invalid = 'domain'
         else:
+            screen_domain, _ = self.domains_get(record, pre_validate)
             unique, leftpart, value = unique_value(domain)
-            if unique:
+            unique_from_screen, _, _ = unique_value(screen_domain)
+            if (self._is_empty(record)
+                    and not is_required
+                    and not is_invisible
+                    and not unique_from_screen):
+                pass
+            elif unique:
                 # If the inverted domain is so constraint that only one value
                 # is possible we should use it. But we must also pay attention
                 # to the fact that the original domain might be a 'OR' domain
@@ -132,11 +142,10 @@ class Field(object):
                         setdefault = False
                 if setdefault and not pre_validate:
                     self.set_client(record, value)
-                    self.get_state_attrs(record)['domain_readonly'] = (
-                        domain_readonly)
+                    state_attrs['domain_readonly'] = domain_readonly
             if not eval_domain(domain, EvalEnvironment(record)):
                 invalid = domain
-        self.get_state_attrs(record)['invalid'] = invalid
+        state_attrs['invalid'] = invalid
         return not invalid
 
     def set(self, record, value):
@@ -354,6 +363,11 @@ class TimeDeltaField(Field):
 class FloatField(Field):
     _default = None
 
+    def __init__(self, attrs):
+        super().__init__(attrs)
+        self._digits = {}
+        self._symbol = {}
+
     def _is_empty(self, record):
         return self.get(record) is None
 
@@ -369,14 +383,18 @@ class FloatField(Field):
             digits_name = digits_field.attrs.get('relation')
             digits_id = digits_field.get(record)
             if digits_name and digits_id is not None and digits_id >= 0:
-                try:
-                    digits = RPCExecute(
-                        'model', digits_name, 'get_digits', digits_id)
-                except RPCException:
-                    logger.warn(
-                        "Fail to fetch digits for %s,%s",
-                        digits_name, digits_id)
-                    return
+                if digits_id in self._digits:
+                    digits = self._digits[digits_id]
+                else:
+                    try:
+                        digits = RPCExecute(
+                            'model', digits_name, 'get_digits', digits_id)
+                    except RPCException:
+                        logger.warn(
+                            "Fail to fetch digits for %s,%s",
+                            digits_name, digits_id)
+                        return
+                    self._digits[digits_id] = digits
             else:
                 return
         if not digits or any(d is None for d in digits):
@@ -396,10 +414,14 @@ class FloatField(Field):
             symbol_name = symbol_field.attrs.get('relation')
             symbol_id = symbol_field.get(record)
             if symbol_name and symbol_id is not None and symbol_id >= 0:
+                if symbol_id in self._symbol:
+                    return self._symbol[symbol_id]
                 try:
-                    return RPCExecute(
+                    result = RPCExecute(
                         'model', symbol_name, 'get_symbol', symbol_id, sign,
                         context=record.get_context())
+                    self._symbol[symbol_id] = result
+                    return result
                 except RPCException:
                     logger.warn(
                         "Fail to fetch symbol for %s,%s",

tryton/gui/window/view_form/model/record.py

@@ -44,6 +44,11 @@ class Record:
         self.destroyed = False
 
     def __getitem__(self, name):
+        self.load(name)
+        if name != '*':
+            return self.group.fields[name]
+
+    def load(self, name, process_exception=True):
         if not self.destroyed and self.id >= 0 and name not in self._loaded:
             id2record = {
                 self.id: self,
@@ -74,9 +79,13 @@ class Record:
             fnames = [fname for fname, field in fields
                 if fname not in self._loaded
                 and (not views or (views & field.views))]
-            fnames.extend(('%s.rec_name' % fname for fname in fnames[:]
-                    if self.group.fields[fname].attrs['type']
-                    in ('many2one', 'one2one', 'reference')))
+            for fname in list(fnames):
+                f_attrs = self.group.fields[fname].attrs
+                if f_attrs['type'] in {'many2one', 'one2one', 'reference'}:
+                    fnames.append('%s.rec_name' % fname)
+                elif (f_attrs['type'] == 'selection'
+                        and f_attrs.get('loading', 'lazy') == 'eager'):
+                    fnames.append('%s:string' % fname)
             if 'rec_name' not in fnames:
                 fnames.append('rec_name')
             fnames.extend(['_timestamp', '_write', '_delete'])
@@ -126,7 +135,8 @@ class Record:
             exception = False
             try:
                 values = RPCExecute('model', self.model_name, 'read',
-                    list(id2record.keys()), fnames, context=ctx)
+                    list(id2record.keys()), fnames, context=ctx,
+                    process_exception=process_exception)
             except RPCException:
                 values = [{'id': x} for x in id2record]
                 default_values = dict((f, None) for f in fnames)
@@ -142,8 +152,6 @@ class Record:
                     for key in record.modified_fields:
                         value.pop(key, None)
                     record.set(value, modified=False)
-        if name != '*':
-            return self.group.fields[name]
 
     def __repr__(self):
         return '<Record %s@%s at %s>' % (self.id, self.model_name, id(self))
@@ -240,6 +248,7 @@ class Record:
         return (self.deleted
             or self.removed
             or self.exception
+            or self.group.readonly
             or not self._write)
 
     readonly = property(get_readonly)
@@ -464,13 +473,17 @@ class Record:
                 if fieldname == 'rec_name':
                     self.value['rec_name'] = value
                 continue
-            if isinstance(self.group.fields[fieldname], fields.O2MField):
+            field = self.group.fields[fieldname]
+            if isinstance(field, fields.O2MField):
                 later[fieldname] = value
                 continue
-            if isinstance(self.group.fields[fieldname], (fields.M2OField,
-                        fields.ReferenceField)):
+            if isinstance(field, (fields.M2OField, fields.ReferenceField)):
                 related = fieldname + '.'
                 self.value[related] = val.get(related) or {}
+            elif (isinstance(field, fields.SelectionField)
+                    and fieldname + ':string' in val):
+                related = fieldname + ':string'
+                self.value[related] = val[related]
             self.group.fields[fieldname].set(self, value)
             self._loaded.add(fieldname)
             fieldnames.append(fieldname)