815 lines
34 KiB
Python
815 lines
34 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, bool)
|
|
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'])
|
|
data.append(row['locked'])
|
|
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.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, ))
|
|
# refresh vessel selection list
|
|
model = self.combo['vessel'].get_model()
|
|
active = self.combo['vessel'].get_active()
|
|
model[active][1] = f"{vessel.vesselname} - {vessel.model}" if vessel.model else vessel.vesselname
|
|
# switch to display mode
|
|
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 or '')
|
|
self.label['model'].set_text(vessel.model or '')
|
|
self.label['shipyard'].set_text(self.dd_storage.get(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(self.dd_storage.get(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):
|
|
"""
|
|
Flags locked and fixed should not be overwritten!
|
|
"""
|
|
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: fixed must not be overwritten!
|
|
)
|
|
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.button['list_save'].set_sensitive(False)
|
|
if treeview.get_value(widget, 3) == True:
|
|
# List is locked!
|
|
self.lst_list.clear()
|
|
self.clear_dd_entry()
|
|
self.button['list_new'].set_sensitive(False)
|
|
return
|
|
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_new'].set_sensitive(True)
|
|
|
|
def on_tvw_ddlist_row_activated(self, widget, path, column):
|
|
# load list entry details
|
|
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_delete'].set_sensitive(not 'fixed' in flags)
|
|
self.button['list_save'].set_sensitive(True)
|
|
self.dd_newrecord = False
|