def format_datetime():
if not value:
return ''
format_ = date_format() + ' ' + HM_FORMAT
if (not isinstance(value, datetime.datetime)
or value.time() == datetime.time.min):
format_ = date_format()
return datetime_strftime(value, format_)
def updateDatas(self, group):
self.datas = {}
self.labels = {}
self.ids = {}
self.group = group
minx = None
maxx = None
for model in group:
x = model[self.xfield['name']].get(model)
if not minx:
minx = x
if not maxx:
maxx = x
minx = min(minx, x)
maxx = max(maxx, x)
self.labels[x] = model[self.xfield['name']].get_client(model)
self.ids.setdefault(x, [])
self.ids[x].append(model.id)
self.datas.setdefault(x, {})
for yfield in self.yfields:
key = yfield.get('key', yfield['name'])
self.datas[x].setdefault(key, 0.0)
if yfield.get('domain'):
context = rpc.CONTEXT.copy()
context['context'] = context.copy()
context['_user'] = rpc._USER
for field in model.group.fields:
context[field] = model[field].get(model,
check_load=False)
if not PYSONDecoder(context).decode(yfield['domain']):
continue
if yfield['name'] == '#':
self.datas[x][key] += 1
else:
self.datas[x][key] += \
float(model[yfield['name']].get(model) or 0)
if isinstance(minx, datetime.datetime):
date = minx
while date <= maxx:
self.labels[date] = datetime_strftime(date, date_format())
self.datas.setdefault(date, {})
for yfield in self.yfields:
self.datas[date].setdefault(
yfield.get('key', yfield['name']), 0.0)
date += relativedelta(days=1)
elif isinstance(minx, datetime.date):
date = minx
while date <= maxx:
self.labels[date] = datetime_strftime(date, date_format())
self.datas.setdefault(date, {})
for yfield in self.yfields:
self.datas[date].setdefault(
yfield.get('key', yfield['name']), 0.0)
date += relativedelta(days=1)
def format_datetime():
if not value:
return ''
format_ = date_format() + ' ' + time_format(field)
if (not isinstance(value, datetime.datetime)
or value.time() == datetime.time.min):
format_ = date_format()
time = value
else:
time = timezoned_date(value)
return datetime_strftime(time, format_)
def convert_datetime():
try:
return untimezoned_date(datetime.datetime(*time.strptime(value,
date_format() + ' ' + HM_FORMAT)[:6]))
except ValueError:
try:
return untimezoned_date(datetime.datetime(*time.strptime(value,
date_format())[:6]))
except ValueError:
return
except TypeError:
return
def convert_datetime():
try:
return untimezoned_date(
datetime.datetime(
*time.strptime(value,
date_format() + ' ' +
time_format(field))[:6]))
except ValueError:
try:
return datetime.datetime(
*time.strptime(value, date_format())[:6])
except ValueError:
return
except TypeError:
return
def sig_logs(self, widget=None):
obj_id = self.id_get()
if obj_id < 0 or obj_id is False:
self.message_info(_('You have to select one record!'))
return False
fields = [
('id', _('ID:')),
('create_uid.rec_name', _('Creation User:'******'create_date', _('Creation Date:')),
('write_uid.rec_name', _('Latest Modification by:')),
('write_date', _('Latest Modification Date:')),
]
try:
res = RPCExecute('model', self.model, 'read', [obj_id],
[x[0] for x in fields], context=self.context)
except RPCException:
return
message_str = ''
for line in res:
for (key, val) in fields:
value = str(line.get(key, False) or '/')
if line.get(key, False) \
and key in ('create_date', 'write_date'):
display_format = date_format() + ' %H:%M:%S'
date = timezoned_date(line[key])
value = common.datetime_strftime(date, display_format)
message_str += val + ' ' + value + '\n'
message_str += _('Model:') + ' ' + self.model
message(message_str)
return True
def __init__(self, field_name, model_name, attrs=None, format=None):
super(Calendar, self).__init__(field_name, model_name, attrs=attrs)
if format is None:
format = date_format()
self.widget = date_widget.ComplexEntry(format, spacing=0)
self.entry = self.widget.widget
self.entry.set_property('activates_default', True)
self.entry.connect('key_press_event', self.sig_key_press)
self.entry.connect('activate', self.sig_activate)
self.entry.connect('focus-in-event', lambda x, y: self._focus_in())
self.entry.connect('focus-out-event', lambda x, y: self._focus_out())
self.but_open = gtk.Button()
img_find = gtk.Image()
img_find.set_from_stock('tryton-find', gtk.ICON_SIZE_SMALL_TOOLBAR)
self.but_open.set_image(img_find)
self.but_open.set_relief(gtk.RELIEF_NONE)
self.but_open.connect('clicked', self.cal_open)
self.but_open.set_alignment(0.5, 0.5)
self.widget.pack_start(self.but_open, expand=False, fill=False)
self.widget.set_focus_chain([self.entry])
tooltips = Tooltips()
tooltips.set_tip(self.but_open, _('Open the calendar'))
tooltips.enable()
def sig_logs(self, widget=None):
obj_id = self.id_get()
if obj_id < 0 or obj_id is False:
self.message_info(_('You have to select one record!'))
return False
fields = [
('id', _('ID:')),
('create_uid.rec_name', _('Creation User:'******'create_date', _('Creation Date:')),
('write_uid.rec_name', _('Latest Modification by:')),
('write_date', _('Latest Modification Date:')),
]
try:
res = RPCExecute('model', self.model, 'read', [obj_id],
[x[0] for x in fields], context=self.context)
except RPCException:
return
message_str = ''
for line in res:
for (key, val) in fields:
value = str(line.get(key, False) or '/')
if line.get(key, False) \
and key in ('create_date', 'write_date'):
display_format = date_format() + ' %H:%M:%S'
date = timezoned_date(line[key])
value = common.datetime_strftime(date, display_format)
message_str += val + ' ' + value + '\n'
message_str += _('Model:') + ' ' + self.model
message(message_str)
return True
def get_client(self, record):
value = super(DateTimeField, self).get_client(record)
if value:
value = common.timezoned_date(value)
return datetime_strftime(value, date_format() + ' ' +
self.time_format(record))
return ''
def __init__(self, field_name, model_name, treeview, attrs=None,
renderer=None):
if renderer is None:
renderer = partial(CellRendererDate, date_format())
super(Date, self).__init__(field_name, model_name, treeview,
attrs=attrs, renderer=renderer)
self.renderer.connect('editing-started', self.editing_started)
def get_client(self, record):
value = super(DateTimeField, self).get_client(record)
if value:
value = common.timezoned_date(value)
return datetime_strftime(
value,
date_format() + ' ' + self.time_format(record))
return ''
def set_client(self, record, value, force_change=False):
if not isinstance(value, datetime.date):
try:
value = datetime.date(*time.strptime(value,
date_format())[:3])
except ValueError:
value = self._default
super(DateField, self).set_client(record, value,
force_change=force_change)
def set_client(self, record, value, force_change=False):
if not isinstance(value, datetime.datetime):
try:
value = datetime.datetime(*time.strptime(value,
date_format() + ' ' + self.time_format(record))[:6])
value = common.untimezoned_date(value)
except ValueError:
value = self._default
super(DateTimeField, self).set_client(record, value,
force_change=force_change)
def set_client(self, record, value, force_change=False):
if isinstance(value, basestring):
try:
value = datetime.date(*time.strptime(value, date_format())[:3])
except ValueError:
value = self._default
elif isinstance(value, datetime.datetime):
assert (value.time() == datetime.time())
value = value.date()
super(DateField, self).set_client(record,
value,
force_change=force_change)
def set_client(self, record, value, force_change=False):
if isinstance(value, basestring):
try:
value = datetime.datetime(*time.strptime(
value,
date_format() + ' ' + self.time_format(record))[:6])
except ValueError:
value = self._default
if value:
value = common.untimezoned_date(value)
super(DateTimeField, self).set_client(record,
value,
force_change=force_change)
def get_client(self, record):
value = super(DateField, self).get_client(record)
if value:
return datetime_strftime(value, date_format())
return ''
def get_format(self, record, field):
return date_format() + ' ' + field.time_format(record)
def get_format(self, record, field):
return date_format()
def get_format(self):
return date_format()
def __init__(self, field_name, model_name, attrs=None):
super(DateTime, self).__init__(field_name, model_name, attrs=attrs,
format=date_format() + ' ' + HM_FORMAT)
def convert_date():
try:
return datetime.date(*time.strptime(value, date_format())[:3])
except (ValueError, TypeError):
return
def format_date():
if not value:
return ''
return datetime_strftime(value, date_format())
def convert_date():
try:
return datetime.date(*time.strptime(value, date_format())[:3])
except (ValueError, TypeError):
return
def updateDatas(self, group):
self.datas = {}
self.labels = {}
self.ids = {}
self.group = group
minx = None
maxx = None
for model in group:
x = model[self.xfield['name']].get(model)
if not minx:
minx = x
if not maxx:
maxx = x
if minx is None and maxx is None:
if isinstance(x, datetime.datetime):
minx, maxx = datetime.datetime.min, datetime.datetime.max
elif isinstance(x, datetime.date):
minx, maxx = datetime.date.min, datetime.date.max
elif isinstance(x, datetime.timedelta):
minx, maxx = datetime.timedelta.min, datetime.timedelta.max
try:
minx = min(minx, x)
maxx = max(maxx, x)
except TypeError:
continue
self.labels[x] = model[self.xfield['name']].get_client(model)
self.ids.setdefault(x, [])
self.ids[x].append(model.id)
self.datas.setdefault(x, {})
for yfield in self.yfields:
key = yfield.get('key', yfield['name'])
self.datas[x].setdefault(key, 0.0)
if yfield.get('domain'):
context = rpc.CONTEXT.copy()
context['context'] = context.copy()
context['_user'] = rpc._USER
for field in model.group.fields:
context[field] = model[field].get(model)
if not PYSONDecoder(context).decode(yfield['domain']):
continue
if yfield['name'] == '#':
self.datas[x][key] += 1
else:
self.datas[x][key] += \
float(model[yfield['name']].get(model) or 0)
if isinstance(minx, datetime.datetime):
date = minx
while date <= maxx:
self.labels[date] = datetime_strftime(date, date_format())
self.datas.setdefault(date, {})
for yfield in self.yfields:
self.datas[date].setdefault(
yfield.get('key', yfield['name']), 0.0)
date += relativedelta(days=1)
elif isinstance(minx, datetime.date):
date = minx
while date <= maxx:
self.labels[date] = datetime_strftime(date, date_format())
self.datas.setdefault(date, {})
for yfield in self.yfields:
self.datas[date].setdefault(
yfield.get('key', yfield['name']), 0.0)
date += relativedelta(days=1)
def search_box(self, button):
def key_press(window, event):
if event.keyval == gtk.keysyms.Escape:
button.set_active(False)
window.hide()
def search():
button.set_active(False)
self.search_window.hide()
text = ''
for label, entry in self.search_table.fields:
if isinstance(entry, gtk.ComboBox):
value = entry.get_active_text()
else:
value = entry.get_text()
if value:
text += label + ' ' + quote(value) + ' '
self.set_text(text)
self.do_search()
def date_activate(entry):
entry._focus_out(entry, None)
search()
if not self.search_window:
self.search_window = gtk.Window()
self.search_window.set_transient_for(button.get_toplevel())
self.search_window.set_type_hint(
gtk.gdk.WINDOW_TYPE_HINT_POPUP_MENU)
self.search_window.set_destroy_with_parent(True)
self.search_window.set_title('Tryton')
self.search_window.set_icon(TRYTON_ICON)
self.search_window.set_decorated(False)
if hasattr(self.search_window, 'set_deletable'):
self.search_window.set_deletable(False)
self.search_window.connect('key-press-event', key_press)
vbox = gtk.VBox()
fields = [f for f in self.screen.domain_parser.fields.itervalues()
if f.get('searchable', True)]
fields.sort(key=operator.itemgetter('string'))
self.search_table = gtk.Table(rows=len(fields), columns=2)
self.search_table.set_border_width(5)
self.search_table.set_row_spacings(2)
self.search_table.set_col_spacings(2)
# Fill table with fields
self.search_table.fields = []
for i, field in enumerate(fields):
label = gtk.Label(field['string'])
label.set_alignment(0.0, 0.5)
self.search_table.attach(label, 0, 1, i, i + 1)
if field['type'] in ('boolean', 'selection'):
if hasattr(gtk, 'ComboBoxText'):
entry = gtk.ComboBoxText()
else:
entry = gtk.combo_box_new_text()
entry.append_text('')
if field['type'] == 'boolean':
selections = (_('True'), _('False'))
else:
selections = tuple(x[1] for x in field['selection'])
for selection in selections:
entry.append_text(selection)
widget = entry
elif field['type'] in ('date', 'datetime', 'time'):
if field['type'] == 'date':
format_ = date_format()
elif field['type'] == 'datetime':
format_ = date_format() + ' ' + common.HM_FORMAT
elif field['type'] == 'time':
format_ = common.HM_FORMAT
widget = common.date_widget.ComplexEntry(format_,
spacing=0)
entry = widget.widget
entry.connect('activate', date_activate)
else:
entry = gtk.Entry()
widget = entry
entry.connect('activate', lambda *a: search())
self.search_table.attach(widget, 1, 2, i, i + 1)
self.search_table.fields.append((field['string'] + ':', entry))
scrolled = gtk.ScrolledWindow()
scrolled.add_with_viewport(self.search_table)
scrolled.set_shadow_type(gtk.SHADOW_NONE)
vbox.pack_start(scrolled, expand=True, fill=True)
find_button = gtk.Button(_('Find'))
find_button.connect('clicked', lambda *a: search())
find_img = gtk.Image()
find_img.set_from_stock('tryton-find', gtk.ICON_SIZE_SMALL_TOOLBAR)
find_button.set_image(find_img)
hbuttonbox = gtk.HButtonBox()
hbuttonbox.set_spacing(5)
hbuttonbox.pack_start(find_button)
hbuttonbox.set_layout(gtk.BUTTONBOX_END)
vbox.pack_start(hbuttonbox, expand=False, fill=True)
self.search_window.add(vbox)
vbox.show_all()
# Disable scrolling:
scrolled.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER)
# See what changed:
new_size = self.search_window.size_request()
# Reenable scrolling:
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.search_window.set_default_size(*new_size)
parent = button.get_toplevel()
button_x, button_y = button.translate_coordinates(parent,
*parent.window.get_origin())
button_allocation = button.get_allocation()
# Resize the window to not be out of the screen
width, height = self.search_window.get_default_size()
screen = self.search_window.get_screen()
screen_width = screen.get_width()
screen_height = screen.get_height()
delta_width = screen_width - (button_x + width)
delta_height = screen_height - (button_y + button_allocation.height
+ height)
if delta_width < 0:
width += delta_width
if delta_height < 0:
height += delta_height
self.search_window.resize(width, height)
# Move the window under the button
self.search_window.move(button_x,
button_y + button_allocation.height)
from tryton.gui.main import Main
page = Main.get_main().get_page()
if button.get_active():
if self.search_window not in page.dialogs:
page.dialogs.append(self.search_window)
self.search_window.show()
else:
self.search_window.hide()
if self.search_window in page.dialogs:
page.dialogs.remove(self.search_window)
def __init__(self, field_name, model_name, treeview, attrs=None):
super(Datetime, self).__init__(field_name, model_name, treeview,
attrs=attrs)
self.renderer.format = date_format() + ' ' + HM_FORMAT
def get_format(self):
return date_format()
def get_format(self):
return date_format() + ' %H:%M:%S' # got to find a way
def get_client(self, record):
value = super(DateField, self).get_client(record)
if value:
return datetime_strftime(value, date_format())
return ''
def setter(self, column, cell, store, iter):
super(Datetime, self).setter(column, cell, store, iter)
record = store.get_value(iter, 0)
field = record[self.field_name]
time_format = field.time_format(record)
self.renderer.format = date_format() + ' ' + time_format
def get_format(self):
return date_format() + ' %H:%M:%S' # got to find a way
def __init__(self, field_name, model_name, treeview, attrs=None):
super(Date, self).__init__(field_name, model_name, treeview,
attrs=attrs)
self.renderer = CellRendererDate(date_format())
self.renderer.connect('editing-started', self.editing_started)
