Files
YMS/yms/view/base.py
T

802 lines
33 KiB
Python

# SPDX-License-Identifier: WTFPL
"""
Special:
Notebook with Vessel, User, Lists, Settings
"""
import os
import pyudev
from gi.repository import GLib, Gtk, Gdk, Rsvg
from datetime import datetime
import subprocess
import locale
import xml.etree.ElementTree as ET
import json
from .view import View
from yms import gtkutils, combobox, treeview
from yms.lookup import Dropdown, DDNAME
from yms.model import user
class BaseView(View):
def __init__(self, context):
super().__init__(context, _("Base Data"), "base.ui")
self.context = context
self.user = user.User(context.db) # current user record
self.newuser = False
self.backupdevice = None # USB-Stick detected only on demand
# Settings
self.sys_currency = context.db.load_setting(4)[0] or '€'
self.entry['sys_currency'].set_text(self.sys_currency)
self.sys_max_width = context.db.load_setting(20)[1] or 1024
self.spin['sys_max_width'].set_value(self.sys_max_width)
self.sys_max_height = context.db.load_setting(21)[1] or 768
self.spin['sys_max_height'].set_value(self.sys_max_height)
# combos
roles = {'captain': 'Captain', 'helmsman': 'Helmsman', 'sailor': 'Sailor'}
combobox.load_from_dict(self.combo['user_role'], roles)
langs = {'de': 'Deutsch', 'en': 'English'}
combobox.load_from_dict(self.combo['user_lang'], langs)
today = datetime.now()
datedict = {
key: f"{prefix} - {today.strftime(fmt)}"
for key, (fmt, prefix) in context.datefmt_map.items()
}
self.datefmt = context.db.load_setting(2, False)[0] or 'Y-m-d'
combobox.load_from_dict(self.combo['datefmt'], datedict, self.datefmt)
# shipyard
self.db.cur.execute("SELECT compid, compname FROM company WHERE comptype=3 ORDER BY compname")
shipyards = dict(self.db.cur.fetchall())
combobox.load_from_dict(self.combo['shipyard'], {-1: _("─── none ───")} | shipyards)
# get current vessel data
self.db.cur.execute("SELECT valint FROM settings WHERE userid=0 AND sno=1")
row = self.db.cur.fetchone()
if not row:
self.context.vessel.vid = 0
self.context.vessel.vesselname = "Ghost"
self.db.cur.execute("INSERT INTO settings (userid, sno, valint) VALUES (0, 1, 0)")
self.db.conn.commit()
else:
# check if vessel from settings exist
self.db.cur.execute("SELECT count(*) FROM vessel WHERE vid=%s", (row[0],))
res = self.db.cur.fetchone()[0]
if res > 0:
self.context.vessel.vid = row[0]
else:
# TODO set vessel to first in list
self.context.vessel.vid = 0
self.context.vessel.vesselname = "Ghost"
# default storage for current vessel
self.dd_storage = self.context.lookup.storage(self.context.vessel.vid)
combobox.load_from_dict(self.combo['storage'], {-1: _("─── none ───")} | self.dd_storage)
self.context.subscribe("storage_modified", self.storage_modified)
# Vessel types
self.dd_vtype = self.context.lookup.dropdown(Dropdown.VESSEL_TYPE)
combobox.load_from_dict(self.combo['vtype'], {-1: _("─── none ───")} | self.dd_vtype, -1)
self.context.subscribe("dd_vtype_modified", self.vtype_modified)
# Hull types
self.dd_htype = self.context.lookup.enum('vessel.htype')
combobox.load_from_dict(self.combo['htype'], self.dd_htype, 'mono')
# List of available shapes for combobox selection
shapes = self.load_shapes()
combobox.load_from_dict(self.combo['hull_shape'], {"-1": _("─── none ───")} | shapes)
# get list of vessels
vessellist = self.context.lookup.vessel()
if len(vessellist) > 0:
combobox.load_from_dict(self.combo['vessel'], vessellist, self.context.vessel.vid)
# TODO ? vessel load triggered from combobox init
# self.context.publish("vessel_modified", self.context.EVENT_UPD, None)
# prepare lists
self.lst_user = Gtk.ListStore(int, str)
self.load_list_user()
treeview.add_column(self.tree['user'], 'ID', 0)
treeview.add_column(self.tree['user'], 'Login', 1)
self.tree['user'].set_model(self.lst_user)
# list of dropdown lists (static!)
self.lst_lists = Gtk.ListStore(int, str, int)
sql = (
"SELECT dd.ddval, dd.ddtext, FIND_IN_SET('locked', dd.flags) AS locked, "
"COUNT(n.ddval) AS records "
"FROM dropdown AS dd LEFT JOIN dropdown AS n ON dd.ddval=n.ddid "
"WHERE dd.ddid=0 "
"GROUP BY dd.ddval, dd.ddtext "
"ORDER BY dd.ddval"
)
self.db.dcur.execute(sql)
for row in self.db.dcur.fetchall():
data = []
data.append(row['ddval'])
if row['locked']:
# Unicode Lock-Symbol
data.append("{} \U0001F512".format(row['ddtext']))
else:
data.append(row['ddtext'])
data.append(row['records'])
self.lst_lists.append(data)
treeview.create_columns(
self.tree['ddlists'],
(_('ID'), _('List'), _('Records'))
)
self.tree['ddlists'].set_model(self.lst_lists)
self.lst_list = Gtk.ListStore(int, str, str, int, str, str)
treeview.create_columns(
self.tree['ddlist'],
(_('ID'), _('Text'), _('Short'), _('Sort'), _('Color'), _('Flags'))
)
self.tree['ddlist'].set_model(self.lst_list)
# Select first list
selection = self.tree['ddlists'].get_selection()
path = Gtk.TreePath.new_from_indices([1])
selection.select_path(path)
self.ddid_cur = None # Current selected dropdown entry
self.ddval_cur = None
self.ddid_iter = None # to easy update selected item
self.ddval_iter = None # to easy update selected item
self.dd_newrecord = False
# Settings date format selection list
# self.context.datefmt_map
# load shape of vessel if available
if self.context.vessel.vid > 0:
self.db.cur.execute("SELECT shapefile FROM vessel WHERE vid=%s", (self.context.vessel.vid, ))
filename = self.db.cur.fetchone()[0] or ''
shapefilepath = os.path.join(context.cfg['shapedir'], filename)
if os.path.isfile(shapefilepath):
handle = Rsvg.Handle()
self._svg = handle.new_from_file(shapefilepath)
#self._svg = handle.new_from_file(os.path.join(sys.path[0], cfg['shapedir'], "elizabethan29.svg"))
#viewport = Rsvg.Rectangle()
#viewport.x = 0
#viewport.y = 0
#viewport.width = 320
#viewport.height = 240
#self._svg.render_document(ctx, viewport)
# WIP generic remarks handling
self.text['vessel_remarks'].set_size_request(200, 70)
def load_list(self):
# placeholder
pass
def load_list_user(self):
selected_id = treeview.get_value(self.tree['user'])
self.lst_user.clear()
self.db.cur.execute("SELECT userid, login FROM user WHERE userid>0 ORDER BY login")
selection = self.tree['user'].get_selection()
for row in self.db.cur.fetchall():
treeiter = self.lst_user.append(row)
if row[0] == selected_id:
# restore previous selected row
selection.select_iter(treeiter)
def load_list_dropdown(self, listid):
self.lst_list.clear()
sql = (
"SELECT ddval, ddtext, ddshort, sort, color, flags "
"FROM dropdown "
"WHERE ddid=%s "
"ORDER BY ddval"
)
self.db.cur.execute(sql, (listid,))
for row in self.db.cur.fetchall():
self.lst_list.append(row)
def load_dropdowns(self):
# non static dropdown (re-)load feature
# default storage for current vessel
sql = "SELECT sid, sname FROM storage WHERE stype=0 AND vid=%s ORDER BY sname"
self.db.cur.execute(sql, (self.context.vessel.vid,))
self.dd_storage = dict(self.db.cur.fetchall())
combobox.refresh_dict(self.combo['storage'], {-1: _("─── none ───")} | self.dd_storage)
def vtype_modified(self, eventtype, data):
self.dd_vtype[data[0]] = data[1]
lst = self.combo['vtype'].get_model()
if eventtype == self.context.EVENT_UPD:
for row in lst:
if row[0] == data[0]:
row[1] = data[1]
return
elif eventtype == self.context.EVENT_ADD:
lst.append(data)
else:
# not implemented
pass
def storage_modified(self, eventtype, data):
self.dd_storage[data[0]] = data[1]
lst = self.combo['storage'].get_model()
if eventtype == self.context.EVENT_UPD:
for row in lst:
if row[0] == data[0]:
row[1] = data[1]
return
elif eventtype == self.context.EVENT_ADD:
lst.append(data)
else:
# not implemented
pass
def load_shapes(self):
# TODO / WIP process shapeindex
# returns dict of filename: title
indexfile = os.path.join(self.context.cfg['docpath'], "shapeindex.json")
if os.path.isfile(indexfile):
# load json
with open(indexfile, "r", encoding="utf-8") as fh:
sflist = json.load(fh)
print("Shapeindex file found and loaded")
else:
# create shapeindex (first simple version)
sflist = {}
for fname in os.listdir(self.context.cfg['shapedir']):
if fname.lower().endswith(".svg"):
shapefile = os.path.join(self.context.cfg['shapedir'], fname)
try:
root = ET.parse(shapefile).getroot()
title_element = root.find("{http://www.w3.org/2000/svg}title")
if title_element is not None and title_element.text:
title = title_element.text.strip()
else:
title = os.path.splitext(fname)[0]
except ET.ParseError:
title = os.path.splitext(fname)[0]
sflist[fname] = title
with open(indexfile, "w", encoding="utf-8") as fh:
json.dump(sflist, fh, ensure_ascii=False, indent=4)
print("Created new shapeindex file")
return sflist
def find_usb_sticks(self):
result = []
for name in os.listdir("/sys/block"):
device = "/sys/block/" + name
removable = device + "/removable"
if not os.path.exists(removable):
continue
with open(removable) as f:
if f.read().strip() != "1":
continue
device_path = os.path.realpath(device + "/device")
if "/usb" in device_path.lower():
result.append(name)
return result
def is_mounted(self, device):
with open("/proc/mounts") as f:
for line in f:
mounted_device = line.split()[0]
if mounted_device == device:
return True
return False
def on_but_usbdevice_clicked(self, widget):
self.backupdevice = None
devlist = self.find_usb_sticks()
if len(devlist) == 0:
self.label['usb_device'].set_text('n/a')
return
if len(devlist) != 1:
print(devlist)
print("Multiple devices not supported yet")
self.label['usb_device'].set_text('multiple')
return
usbdev = devlist[0]
self.label['usb_device'].set_text(f"/dev/{usbdev}")
"""
serial number via python3-pyudev:
import pyudev
Settings
7 - usb backup device serial
8 - usb backup partition uuid
9 - last backup timestamp
"""
# first get stick hardware data
udevctx = pyudev.Context()
device = pyudev.Devices.from_sys_path(udevctx, os.path.join("/sys/class/block", usbdev))
serial = device.get("ID_SERIAL_SHORT")
vendor = device.get("ID_VENDOR")
model = device.get("ID_MODEL")
self.label['usb_serial'].set_text(serial or 'n/a')
self.label['usb_vendor'].set_text(vendor or 'n/a')
self.label['usb_model'].set_text(model or 'n/a')
# TODO second get partition, filesystem type and label
# there must be only one ext4 partition on disk
partitions = [
child for child in device.children
if child.device_type == "partition"
]
partition = partitions[0]
print(f"Partition={partition}")
if len(partitions) != 1:
print("error: more than one partition!")
return
partuuid = partition.properties.get("ID_PART_ENTRY_UUID")
fstype = partition.get("ID_FS_TYPE")
plabel = partition.get("ID_FS_LABEL")
self.label['usb_partition'].set_text(plabel)
self.label['usb_uuid'].set_text(partuuid)
self.label['usb_fstype'].set_text(fstype)
if fstype != "ext4":
print(f"error: invalid fileystem type {fstype}, ext4 expected")
return
self.backupdevice = f"/dev/{usbdev}1" # partition!
# check if device is mounted
if not self.is_mounted(self.backupdevice):
print("device is not mounted. trying to mount now")
pass
# For backup there must be an directory names ymsbackup which contains
# backup description and backup sets
# Desription and identification file backup.json?
# if plabel != 'BACKUP' or not os.path.isdir('ymsbackup')
mountpoint = os.path.join("/media", os.getlogin(), "BACKUP")
if not os.path.isdir(mountpoint):
print(f"Device is not mounted at {mountpoint}")
def on_but_usbinit_clicked(self, widget):
if self.backupdevice is None:
return
# UUID of devive -> settings
# check if backups already exist
answer = gtkutils.questionbox(
_("Initialize USB-Stick\n"
"All data on that device will be lost!\n"
"Are you really sure?"
), title="YMS")
if answer == False:
return
if self.label['usb_fstype'].get_text() != 'ext4':
print("formatting {self.backupdevice} with ext4")
#try:
# subprocess.run(["sudo", "mkfs.ext4", "-L", "BACKUP", self.backupdevice], check=True)
#except subprocess.CalledProcessError as e:
# print("formatting failed: ", e)
myself = os.getlogin()
mountpoint = os.path.join("/media", myself, "backup")
basedir = os.path.join(mountpoint, 'ymsbackup')
print(basedir)
# mkdir basedir
# chown (os.getlogin(), 'yms')
# chmod 770
else:
#
pass
def on_cmb_vessel_changed(self, widget):
self.context.vessel.load(combobox.get_list_value(widget))
sql = ("UPDATE settings SET valint=%s WHERE userid=0 AND sno=1")
self.db.cur.execute(sql, (self.context.vessel.vid,))
self.db.conn.commit()
# Refresh dependent data
self.load_dropdowns()
self.context.publish("vessel_modified", self.context.EVENT_UPD, (self.context.vessel.pk_value, ))
# Show data
self.display_vessel(self.context.vessel)
def on_but_vessel_add_clicked(self, widget):
answer = gtkutils.questionbox(
_("Add new vessel.\n"
"Are you sure?"
), title="YMS")
if answer == False:
return
self.context.vessel.create()
print(self.context.vessel)
model = self.combo['vessel'].get_model()
if model is None:
combobox.load_from_dict(self.combo['vessel'], {self.context.vessel.vid: self.context.vessel.vesselname}, self.context.vessel.vid)
else:
model.append((self.context.vessel.vid, self.context.vessel.vesselname))
combobox.activate_row(self.combo['vessel'], self.context.vessel.vid)
self.edit_vessel(self.context.vessel)
self.stack['vessel'].set_visible_child(self.box['vessel_edit'])
def on_but_vessel_edit_clicked(self, widget):
self.edit_vessel(self.context.vessel)
self.stack['vessel'].set_visible_child(self.box['vessel_edit'])
def on_but_vessel_save_clicked(self, widget):
vessel = self.context.vessel
vessel.vesselname = self.entry['vesselname'].get_text()
vessel.model = self.entry['model'].get_text()
vessel.vtype = combobox.get_list_value(self.combo['vtype'])
if vessel.vtype == -1:
vessel.vtype = None
vessel.year_built = self.spin['year_built'].get_value_as_int()
vessel.hull_number = self.entry['hull_number'].get_text()
vessel.shipyard = combobox.get_list_value(self.combo['shipyard'])
if vessel.shipyard == -1:
vessel.shipyard = None
vessel.loa = self.spin['loa'].get_value()
vessel.lwl = self.spin['lwl'].get_value()
vessel.beam = self.spin['beam'].get_value()
vessel.draught = self.spin['draught'].get_value()
vessel.draught_min = self.spin['draught_min'].get_value()
vessel.displacement = self.spin['displacement'].get_value_as_int()
vessel.ballast = self.spin['ballast'].get_value_as_int()
vessel.beltpos_bow = self.spin['belt_bow'].get_value()
vessel.beltpos_aft = self.spin['belt_aft'].get_value()
vessel.htype = combobox.get_list_value(self.combo['htype'])
vessel.shapefile = combobox.get_list_value(self.combo['hull_shape'])
if vessel.shapefile == '-1':
vessel.shapefile = None
vessel.remarks = gtkutils.get_text_contents(self.text['vessel_remarks'])
vessel.save()
self.context.publish("vessel_modified", self.context.EVENT_UPD, (vessel.vid, ))
self.stack['vessel'].set_visible_child(self.box['vessel'])
self.display_vessel(self.context.vessel)
def on_but_vessel_cancel_clicked(self, widget):
self.stack['vessel'].set_visible_child(self.box['vessel'])
def on_but_vessel_delete_clicked(self, widget):
# TODO check if there are no associated data with vessel
answer = gtkutils.questionbox(
_("Delete vessel!\n"
"Are you sure?"
), title="YMS")
if answer == False:
return
# TODO
def on_but_settings_save_clicked(self, widget):
# System settings
new_currency = self.entry['sys_currency'].get_text()
if self.sys_currency != new_currency:
self.db.save_setting(4, new_currency, None)
self.sys_currency = new_currency
new_max_width = self.spin['sys_max_width'].get_value_as_int()
if self.sys_max_width != new_max_width:
self.db.save_setting(20, None, new_max_width)
self.sys_max_width = new_max_width
new_max_height = self.spin['sys_max_height'].get_value_as_int()
if self.sys_max_height != new_max_height:
self.db.save_setting(21, None, new_max_height)
self.sys_max_height = new_max_height
# User settings
new_datefmt = combobox.get_list_value(self.combo['datefmt'])
if self.datefmt != new_datefmt:
self.db.save_setting(2, new_datefmt, None)
self.context.datefmt = new_datefmt
self.db.conn.commit()
def display_vessel(self, vessel):
self.label['vesselname'].set_text(vessel.vesselname)
self.label['model'].set_text(vessel.model or '')
self.label['shipyard'].set_text(str(vessel.shipyard))
self.label['year_built'].set_text(self.format_int(vessel.year_built, False, default='n/a'))
self.label['hull_number'].set_text(vessel.hull_number or '')
self.label['loa'].set_text(self.format_float(vessel.loa, 2, suffix="m"))
self.label['lwl'].set_text(self.format_float(vessel.lwl, 2, suffix="m"))
self.label['beam'].set_text(self.format_float(vessel.beam, 2, suffix="m"))
self.label['draught'].set_text(self.format_float(vessel.draught, 2, suffix="m"))
self.label['draught_min'].set_text(self.format_float(vessel.draught_min, 2, suffix="m"))
self.label['displacement'].set_text(self.format_int(vessel.displacement, 2, suffix="kg"))
self.label['ballast'].set_text(self.format_int(vessel.ballast, 2, suffix="kg"))
self.label['belt_bow'].set_text(self.format_float(vessel.beltpos_bow, 2, suffix="m"))
self.label['belt_aft'].set_text(self.format_float(vessel.beltpos_aft, 2, suffix="m"))
self.label['hull_shape'].set_text(vessel.shapefile or '')
self.label['storage_def'].set_text(str(vessel.sid_default))
self.label['remarks'].set_text(vessel.remarks or '')
def edit_vessel(self, vessel):
self.entry['vesselname'].set_text(vessel.vesselname)
self.entry['model'].set_text(vessel.model or '')
combobox.activate_row(self.combo['vtype'], vessel.vtype or -1)
self.spin['year_built'].set_value(vessel.year_built or 0)
self.entry['hull_number'].set_text(vessel.hull_number or '')
combobox.activate_row(self.combo['shipyard'], vessel.shipyard or -1)
self.spin['loa'].set_value(vessel.loa or 0)
self.spin['lwl'].set_value(vessel.lwl or 0)
self.spin['beam'].set_value(vessel.beam or 0)
self.spin['draught'].set_value(vessel.draught or 0)
self.spin['draught_min'].set_value(vessel.draught_min or 0)
self.spin['displacement'].set_value(vessel.displacement or 0)
self.spin['ballast'].set_value(vessel.ballast or 0)
self.spin['belt_bow'].set_value(vessel.beltpos_bow or 0)
self.spin['belt_aft'].set_value(vessel.beltpos_aft or 0)
combobox.activate_row(self.combo['htype'], vessel.htype)
combobox.activate_row(self.combo['hull_shape'], vessel.shapefile or "-1")
combobox.activate_row(self.combo['storage'], vessel.sid_default or -1)
self.text['vessel_remarks'].get_buffer().set_text(vessel.remarks or '')
self.entry['vesselname'].grab_focus()
def display_user(self, user):
self.entry['user_login'].set_text(user.login)
self.entry['user_displayname'].set_text(user.displayname)
combobox.activate_row(self.combo['user_role'], user.role)
combobox.activate_row(self.combo['user_lang'], user.language)
self.check['user_locked'].set_active('locked' in user.flags)
self.check['user_deleted'].set_active('deleted' in user.flags)
self.entry['user_pass'].set_text('')
def on_tvw_user_row_activated(self, widget, path, column):
# load selected user
self.context.user.user_id = treeview.get_value(widget, 0)
self.context.user.load()
self.display_user(self.context.user)
def on_but_user_new_clicked(self, widget):
# get first free user id and create a new record with name "user<nnn>"
self.context.user.create()
self.lst_user.append((self.context.user.user_id, self.context.user.login))
def on_but_user_del_clicked(self, widget):
answer = gtkutils.questionbox(
_("Delete user!\n"
"Are you sure?"
), title="YMS")
if answer == False:
return
self.context.user.delete()
selection = self.tree['user'].get_selection()
model, tree_iter = selection.get_selected()
model.remove(tree_iter)
# TODO Select some other user from new list selection
self.context.user.user_id = treeview.get_value(self.tree['user'])
self.context.user.load()
self.display_user(self.context.user)
def on_but_user_newpass_clicked(self, widget):
self.entry['user_pass'].set_text(self.context.user.genpass())
def on_but_user_save_clicked(self, widget):
newlogin = self.entry['user_login'].get_text()
# check if changed login exists and throw error in that case
if newlogin != self.context.user.login:
sql = "SELECT COUNT(login) FROM user WHERE login=%s"
self.db.cur.execute(sql, (newlogin, ))
if self.db.cur.fetchone()[0] > 0:
# TODO set error indicator
print("Error: Login already exists!")
return
sql = "UPDATE user SET login=%s WHERE userid=%s"
self.db.cur.execute(sql, (newlogin, self.context.user.user_id))
treeview.set_value(self.tree['user'], 1, newlogin)
self.context.user.displayname = self.entry['user_displayname'].get_text()
self.context.user.role = combobox.get_list_value(self.combo['user_role'])
self.context.user.language = combobox.get_list_value(self.combo['user_lang'])
self.context.user.flags = []
if self.check['user_locked'].get_active(): self.context.user.flags.append('locked')
if self.check['user_deleted'].get_active(): self.context.user.flags.append('deleted')
self.context.user.save()
# password field is different. if filled set new password
newpass = self.entry['user_pass'].get_text()
if len(newpass) >= 8:
try:
self.context.user.setpass(newpass)
finally:
newpass = None
self.entry['user_pass'].set_text('')
else:
# Password to short
pass
def clear_dd_entry(self):
# Clear list entry editor
self.spin['dd_val'].set_text('')
self.entry['dd_text'].set_text('')
self.entry['dd_short'].set_text('')
self.spin['dd_sort'].set_text('')
self.entry['dd_color'].set_text('')
# TODO set color button to undef shown as 100% transparent
# self.button['dd_color']
self.check['dd_fixed'].set_active(False)
self.check['dd_locked'].set_active(False)
def on_but_dd_color_set(self, button):
rgba = button.get_rgba()
r = round(rgba.red * 255)
g = round(rgba.green * 255)
b = round(rgba.blue * 255)
a = round(rgba.alpha * 255)
if a > 0:
self.entry['dd_color'].set_text(f"#{r:02X}{g:02X}{b:02X}")
else:
self.entry['dd_color'].set_text('')
def on_ent_dd_color_activate(self, entry):
self.set_color_from_entry(entry, self.button['dd_color'])
def on_ent_dd_color_focus_out_event(self, entry, event):
self.set_color_from_entry(entry, self.button['dd_color'])
return False
def on_but_list_new_clicked(self, widget):
self.dd_newrecord = True
self.ddval_cur = None
self.clear_dd_entry()
# get next free value for ddid, ddval
sql = (
"SELECT MIN(n.ddval) AS nextval "
"FROM ("
"SELECT 1 AS ddval "
"UNION ALL "
"SELECT DISTINCT ddval+1 "
"FROM dropdown "
"WHERE ddid=%(ddid)s AND ddval>0"
") AS n "
"LEFT JOIN dropdown AS m ON m.ddval=n.ddval AND m.ddid=%(ddid)s "
"WHERE m.ddval IS NULL"
)
self.db.cur.execute(sql, {'ddid': self.ddid_cur})
self.ddval_cur = self.db.cur.fetchone()[0] or 1
if not self.ddval_cur:
# TODO message internal error to user
print("internal error while creating new value")
return
self.spin['dd_val'].set_value(self.ddval_cur)
self.button['list_save'].set_sensitive(True)
self.entry['dd_text'].grab_focus()
def on_but_list_save_clicked(self, widget):
if self.dd_newrecord:
sql = (
"INSERT INTO dropdown (ddid, ddval, ddtext, ddshort, sort, color, flags) "
"VALUES (%s, %s, %s, %s, %s, %s, %s)"
)
values = (
self.ddid_cur,
self.spin['dd_val'].get_value_as_int(), # autogenerated by new button
self.entry['dd_text'].get_text(),
self.entry['dd_short'].get_text(),
self.spin['dd_sort'].get_value_as_int(),
self.entry['dd_color'].get_text().lstrip('#'),
self.get_checks(('dd_locked', 'dd_fixed'), prefix='dd_')
)
if self.db.execute_write(sql, values, 1):
self.db.conn.commit()
else:
# TODO message sql error to user
print(self.db.last_error())
print(sql, values)
return
# TODO
# message success to user
# refresh list
data = (
self.spin['dd_val'].get_value_as_int(),
self.entry['dd_text'].get_text(),
self.entry['dd_short'].get_text(),
self.spin['dd_sort'].get_value_as_int(),
self.entry['dd_color'].get_text().lstrip('#'),
'' # TODO flags
)
treeiter = self.lst_list.append(data)
selection = self.tree['ddlist'].get_selection()
selection.select_iter(treeiter)
# increase entry in main list
count = treeview.get_value(self.tree['ddlists'], 2)
treeview.set_value(self.tree['ddlists'], 2, count+1)
# send event
eventname = "dd_{}_modified".format(DDNAME[self.ddid_cur])
self.context.publish(eventname, self.context.EVENT_ADD, (data[0], data[1]))
else:
if self.ddid_cur is None or self.ddval_cur is None:
print("internal error: ids not set")
return
sql = (
"UPDATE dropdown SET ddtext=%s, ddshort=%s, sort=%s, color=%s, flags=%s "
"WHERE ddid=%s AND ddval=%s"
)
values = (
self.entry['dd_text'].get_text(),
self.entry['dd_short'].get_text(),
self.spin['dd_sort'].get_value_as_int(),
self.entry['dd_color'].get_text().lstrip('#'),
self.get_checks(('dd_locked', 'dd_fixed'), prefix='dd_'),
self.ddid_cur,
self.ddval_cur
)
if self.db.execute_write(sql, values):
self.db.conn.commit()
else:
# TODO message sql error to user
print(self.db.last_error())
print(sql, values)
return
# refresh list
data = (
self.spin['dd_val'].get_value_as_int(),
self.entry['dd_text'].get_text(),
self.entry['dd_short'].get_text(),
self.spin['dd_sort'].get_value_as_int(),
self.entry['dd_color'].get_text().lstrip('#'),
'' # TODO flags
)
treeview.set_row_values(self.tree['ddlist'], data)
# send event
eventname = "dd_{}_modified".format(DDNAME[self.ddid_cur])
self.context.publish(eventname, self.context.EVENT_UPD, (data[0], data[1]))
self.dd_newrecord = False
# TODO
# message success to user
# refresh list
def on_but_list_delete_clicked(self, widget):
answer = gtkutils.questionbox(
_("Delete list entry!\n"
"Are you sure?"
), title="YMS")
if answer == False:
return
def on_tvw_ddlists_row_activated(self, widget, path, column):
# load single list
self.ddid_iter = widget.get_selection().get_selected()[1]
self.ddid_cur = treeview.get_value(widget, 0)
self.ddval_cur = None
self.load_list_dropdown(self.ddid_cur)
self.clear_dd_entry()
self.button['list_save'].set_sensitive(False)
def on_tvw_ddlist_row_activated(self, widget, path, column):
# load list entry details
self.ddval_iter = widget.get_selection().get_selected()[1]
self.ddval_cur = treeview.get_value(widget, 0)
sql = (
"SELECT ddtext, ddshort, sort, color, flags "
"FROM dropdown "
"WHERE ddid=%s AND ddval=%s "
"ORDER BY ddval"
)
self.db.dcur.execute(sql, (self.ddid_cur, self.ddval_cur))
row = self.db.dcur.fetchone()
if not row:
# internal error
print(f"internal error ddval #{self.ddval_cur} not found")
self.ddval_cur = None
return
# fill edit fields
self.spin['dd_val'].set_value(self.ddval_cur)
self.entry['dd_text'].set_text(row['ddtext'] or '')
self.entry['dd_short'].set_text(row['ddshort'] or '')
if row['sort']:
self.spin['dd_sort'].set_value(row['sort'])
else:
self.spin['dd_sort'].set_text('')
self.entry['dd_color'].set_text(row['color'] or '')
flags = (row['flags'] or '').split(',')
self.check['dd_fixed'].set_active('fixed' in flags)
self.check['dd_locked'].set_active('locked' in flags)
self.button['list_save'].set_sensitive(True)
self.dd_newrecord = False