removed DatabaseManager.py as it's unused
This commit is contained in:
steffen123
parent
7042f11954
commit
d27d6a310c
|
|
@ -1,827 +0,0 @@
|
|||
#!/usr/bin/python2
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
#Copyright 2008-2010 J. Urner
|
||||
#This program is free software: you can redistribute it and/or modify
|
||||
#it under the terms of the GNU Affero General Public License as published by
|
||||
#the Free Software Foundation, version 3 of the License.
|
||||
#
|
||||
#This program is distributed in the hope that it will be useful,
|
||||
#but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
#GNU General Public License for more details.
|
||||
#
|
||||
#You should have received a copy of the GNU Affero General Public License
|
||||
#along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#In the "official" distribution you can find the license in agpl-3.0.txt.
|
||||
|
||||
"""Database manager
|
||||
|
||||
@todo: (gtk) how to validate user input in gtk.Dialog? as soon as the user clicks ok the dialog is dead. we use a while loop as workaround. not nice
|
||||
@todo: (fpdb) we need the application name 'fpdb' from somewhere to put it in dialog titles
|
||||
@todo: (fpdb) config object should be initialized globally and accessible from all modules via Configuration.py
|
||||
|
||||
@todo: (all dialogs) save/restore size and pos
|
||||
|
||||
@todo: (WidgetDatabaseManager) give database status meaningful colors
|
||||
@todo: (WidgetDatabaseManager) implement database purging
|
||||
@todo: (WidgetDatabaseManager) implement database export
|
||||
@todo: (WidgetDatabaseManager) what to do on database doubleclick?
|
||||
@todo: (WidgetDatabaseManager) context menu for database tree
|
||||
@todo: (WidgetDatabaseManager) initializing/validating databases may take a while. how to give feedback?
|
||||
|
||||
"""
|
||||
|
||||
import os
|
||||
import pygtk
|
||||
pygtk.require('2.0')
|
||||
import gtk
|
||||
import gobject
|
||||
|
||||
#*******************************************************************************************************
|
||||
class DatabaseManager(gobject.GObject):
|
||||
DatabaseTypes = {}
|
||||
|
||||
@classmethod
|
||||
def from_fpdb(klass, data, defaultDatabaseType=None):
|
||||
|
||||
#NOTE: if no databases are present in config fpdb fails with
|
||||
# Traceback (most recent call last):
|
||||
# File "/home/me2/Scr/Repos/fpdb-mme/pyfpdb/DatabaseManager.py", line 783, in <module>
|
||||
# databaseManager = DatabaseManager.from_fpdb('', defaultDatabaseType=DatabaseTypeSqLite)
|
||||
# File "/home/me2/Scr/Repos/fpdb-mme/pyfpdb/DatabaseManager.py", line 36, in from_fpdb
|
||||
# config = Configuration.Config(file=options.config, dbname=options.dbname)
|
||||
# File "/home/me2/Scr/Repos/fpdb-mme/pyfpdb/Configuration.py", line 436, in __init__
|
||||
# db = self.get_db_parameters()
|
||||
# File "/home/me2/Scr/Repos/fpdb-mme/pyfpdb/Configuration.py", line 583, in get_db_parameters
|
||||
# name = self.db_selected
|
||||
# AttributeError: Config instance has no attribute 'db_selected'
|
||||
import sys
|
||||
import Options
|
||||
import Configuration
|
||||
#NOTE: fpdb should perform this globally
|
||||
(options, argv) = Options.fpdb_options()
|
||||
config = Configuration.Config(file=options.config, dbname=options.dbname)
|
||||
#TODO: handle no database present
|
||||
defaultDatabaseName = config.get_db_parameters().get('db-databaseName', None)
|
||||
#TODO: fpdb stores databases in no particular order. this has to be fixed somehow
|
||||
databases = []
|
||||
for name, fpdbDatabase in config.supported_databases.items():
|
||||
databaseKlass = klass.DatabaseTypes.get(fpdbDatabase.db_server, None)
|
||||
#NOTE: Config does not seem to validate user input, so anything may end up here
|
||||
if databaseKlass is None:
|
||||
raise ValueError('Unknown databasetype: %s' % fpdbDatabase.db_server)
|
||||
|
||||
database = databaseKlass()
|
||||
if database.Type == 'sqlite':
|
||||
database.name = fpdbDatabase.db_name
|
||||
database.file = fpdbDatabase.db_server
|
||||
else:
|
||||
database.name = fpdbDatabase.db_name
|
||||
database.host = fpdbDatabase.db_server
|
||||
#NOTE: fpdbDatabase.db_ip is no is a string
|
||||
database.port = int(fpdbDatabase.db_ip)
|
||||
database.user = fpdbDatabase.db_user
|
||||
database.password = fpdbDatabase.db_pass
|
||||
databases.append(database)
|
||||
|
||||
return klass(databases=databases, defaultDatabaseType=defaultDatabaseType)
|
||||
|
||||
def to_fpdb(self):
|
||||
pass
|
||||
|
||||
|
||||
def __init__(self, databases=None, defaultDatabaseType=None):
|
||||
gobject.GObject.__init__(self)
|
||||
|
||||
self._defaultDatabaseType = defaultDatabaseType
|
||||
self._databases = [] if databases is None else list(databases)
|
||||
self._activeDatabase = None
|
||||
def __iter__(self):
|
||||
return iter(self._databases)
|
||||
def set_default_database_type(self, databaseType):
|
||||
self._defaultDatabaseType = defaultDatabaseType
|
||||
def get_default_database_type(self):
|
||||
return self._defaultDatabaseType
|
||||
def database_from_id(self, idDatabase):
|
||||
for database in self._databases:
|
||||
if idDatabase == self.database_id(database):
|
||||
return database
|
||||
def database_id(self, database):
|
||||
return id(database)
|
||||
def add_database(self, database):
|
||||
if database in self._databases:
|
||||
raise ValueError('database already registered')
|
||||
self._databases.append(database)
|
||||
def remove_database(self, database):
|
||||
self._databases.remove(database)
|
||||
|
||||
def activate_database(self, database):
|
||||
if self._activeDatabase is not None:
|
||||
self._activeDatabase.status = self._activeDatabase.StatusInactive
|
||||
#TODO: finalize database
|
||||
self.emit('database-deactivated', self.database_id(self._activeDatabase) )
|
||||
|
||||
database.status = database.StatusActive
|
||||
#TODO: activate database
|
||||
self._activeDatabase = database
|
||||
self.emit('database-activated', self.database_id(database) )
|
||||
|
||||
def active_database(self):
|
||||
return self._activeDatabase
|
||||
|
||||
# register DatabaseManager signals
|
||||
gobject.type_register(DatabaseManager)
|
||||
gobject.signal_new('database-activated', DatabaseManager, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (int, ))
|
||||
gobject.signal_new('database-deactivated', DatabaseManager, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (int, ))
|
||||
gobject.signal_new('database-error', DatabaseManager, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, (int, ))
|
||||
|
||||
class DatabaseTypeMeta(type):
|
||||
def __new__(klass, name, bases, kws):
|
||||
newKlass = type.__new__(klass, name, bases, kws)
|
||||
if newKlass.Type is not None:
|
||||
if newKlass.Type in DatabaseManager.DatabaseTypes:
|
||||
raise ValueError('data base type already registered for: %s' % newKlass.Type)
|
||||
DatabaseManager.DatabaseTypes[newKlass.Type] = newKlass
|
||||
return newKlass
|
||||
|
||||
class DatabaseTypeBase(object):
|
||||
__metaclass__ = DatabaseTypeMeta
|
||||
Type = None
|
||||
StatusActive = 'active'
|
||||
StatusInactive = 'inactive'
|
||||
StatusError = 'error' #TODO: not implemented
|
||||
|
||||
#TODO: not happy with returning error string. just being too lazy to impl dozens of error codes for later translation
|
||||
def init_new_database(self):
|
||||
"""initializes a new empty database
|
||||
@return: (str) error if something goes wrong, None otherwise
|
||||
"""
|
||||
raise NotImplementedError()
|
||||
|
||||
def validate_database(self):
|
||||
"""checks if the database is valid
|
||||
@return: (str) error if something goes wrong, None otherwise
|
||||
"""
|
||||
raise NotImplementedError()
|
||||
|
||||
class DatabaseTypePostgres(DatabaseTypeBase):
|
||||
Type = 'postgresql'
|
||||
@classmethod
|
||||
def display_name(klass):
|
||||
return 'Postgres'
|
||||
def __init__(self, name='', host='localhost', port=5432, user='postgres', password='', database='fpdb'):
|
||||
self.name = name
|
||||
self.host = host
|
||||
self.port = port
|
||||
self.user = user
|
||||
self.password = password
|
||||
self.database = database
|
||||
self.status = self.StatusInactive
|
||||
|
||||
#TODO: implement
|
||||
def init_new_database(self):
|
||||
pass
|
||||
|
||||
#TODO: implement
|
||||
def validate_database(self):
|
||||
pass
|
||||
|
||||
class DatabaseTypeMysql(DatabaseTypeBase):
|
||||
Type = 'mysql'
|
||||
@classmethod
|
||||
def display_name(klass):
|
||||
return 'MySql'
|
||||
def __init__(self, name='', host='localhost', port=3306, user='root', password='', database='fpdb'):
|
||||
self.name = name
|
||||
self.host = host
|
||||
self.port = port
|
||||
self.user = user
|
||||
self.password = password
|
||||
self.database = database
|
||||
self.status = self.StatusInactive
|
||||
|
||||
#TODO: implement
|
||||
def init_new_database(self):
|
||||
pass
|
||||
|
||||
#TODO: implement
|
||||
def validate_database(self):
|
||||
pass
|
||||
|
||||
|
||||
class DatabaseTypeSqLite(DatabaseTypeBase):
|
||||
Type = 'sqlite'
|
||||
@classmethod
|
||||
def display_name(klass):
|
||||
return 'SqLite'
|
||||
def __init__(self, name='', host='', file='', database='fpdb'):
|
||||
self.name = name
|
||||
self.file = file
|
||||
self.status = self.StatusInactive
|
||||
|
||||
def init_new_database(self):
|
||||
# make shure all attrs are specified
|
||||
if not self.file:
|
||||
return 'no database file specified'
|
||||
# create file if necessary (this will truncate file if it exists)
|
||||
try:
|
||||
open(self.file, 'w').close()
|
||||
except IOError:
|
||||
return 'can not write file'
|
||||
|
||||
#TODO: init tables (...)
|
||||
|
||||
|
||||
def validate_database(self):
|
||||
pass
|
||||
#TODO: check if tables (...) exist
|
||||
|
||||
|
||||
|
||||
#TODO: how do we want to handle unsupported database types?
|
||||
# ..uncomment to remove unsupported database types
|
||||
#try: import psycopg2
|
||||
#except ImportError: del DatabaseManager.DatabaseTypes['postgres']
|
||||
#try: import MySQLdb
|
||||
#except ImportError: del DatabaseManager.DatabaseTypes['mysql']
|
||||
#try: import sqlite3
|
||||
#except ImportError: del DatabaseManager.DatabaseTypes['sqlite']
|
||||
|
||||
#***************************************************************************************************************************
|
||||
#TODO: there is no title (on linux), wtf?
|
||||
def DialogError(parent=None, msg=''):
|
||||
dlg = gtk.MessageDialog(
|
||||
parent=parent,
|
||||
flags=gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT,
|
||||
type=gtk.MESSAGE_ERROR,
|
||||
buttons=gtk.BUTTONS_OK,
|
||||
message_format=msg,
|
||||
)
|
||||
dlg.run()
|
||||
dlg.destroy()
|
||||
return None
|
||||
|
||||
|
||||
#TODO: derrive from gtk.VBox?
|
||||
class WidgetDatabaseProperties(gtk.VBox):
|
||||
|
||||
ModeNew = 0
|
||||
ModeEdit = 1
|
||||
ModeAdd = 2
|
||||
|
||||
class SqLiteFileChooserButton(gtk.HBox):
|
||||
#NOTE: for some weird reason it is impossible to let the user choose a non exiting filename with gtk.FileChooserButton, so impl our own on the fly
|
||||
def __init__(self, widgetDatabaseProperties, parentWidget):
|
||||
gtk.HBox.__init__(self)
|
||||
self.set_homogeneous(False)
|
||||
|
||||
self.parentWidget = parentWidget
|
||||
self.widgetDatabaseProperties = widgetDatabaseProperties
|
||||
self.entry = gtk.Entry()
|
||||
self.button = gtk.Button('...')
|
||||
self.button.connect('clicked', self.on_button_clicked)
|
||||
|
||||
# layout widgets
|
||||
self.pack_start(self.entry, True, True)
|
||||
self.pack_start(self.button, False, False)
|
||||
|
||||
def get_filename(self):
|
||||
return self.entry.get_text()
|
||||
|
||||
def set_filename(self, name):
|
||||
self.entry.set_text(name)
|
||||
|
||||
def on_button_clicked(self, button):
|
||||
if self.widgetDatabaseProperties.mode == WidgetDatabaseProperties.ModeAdd:
|
||||
action = gtk.FILE_CHOOSER_ACTION_OPEN
|
||||
elif self.widgetDatabaseProperties.mode == WidgetDatabaseProperties.ModeNew:
|
||||
action = gtk.FILE_CHOOSER_ACTION_SAVE
|
||||
else:
|
||||
raise ValueError('unsupported dialog mode')
|
||||
dlg = gtk.FileChooserDialog(
|
||||
title='Choose an exiting database file or type in name of a new one',
|
||||
parent=self.parentWidget,
|
||||
action=action,
|
||||
buttons=(
|
||||
gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
|
||||
gtk.STOCK_OK, gtk.RESPONSE_OK,
|
||||
),
|
||||
backend=None
|
||||
)
|
||||
dlg.set_default_response(gtk.RESPONSE_OK)
|
||||
dlg.set_do_overwrite_confirmation(True)
|
||||
if dlg.run() == gtk.RESPONSE_OK:
|
||||
fileName = dlg.get_filename()
|
||||
self.set_filename(fileName)
|
||||
dlg.destroy()
|
||||
|
||||
|
||||
#TODO: bit ugly this thingy. try to find a better way to map database attrs to gtk widgets
|
||||
class FieldWidget(object):
|
||||
def __init__(self, text='', attrDatabase='', widget=None, attrGet=None, attrSet=None, defaultValue=None, canEdit=False, tooltip=''):
|
||||
"""
|
||||
@param canEdit: True if the user can edit the attr in edit mode, False otherwise
|
||||
"""
|
||||
self._label = gtk.Label(text)
|
||||
self._attrDatabase = attrDatabase
|
||||
self._widget = widget
|
||||
self._defaultValue = defaultValue
|
||||
self._attrGetter=None,
|
||||
self._attrGet = attrGet
|
||||
self._attrSet = attrSet
|
||||
self._canEdit = canEdit
|
||||
|
||||
self._label.set_tooltip_text(tooltip)
|
||||
self._widget.set_tooltip_text(tooltip)
|
||||
|
||||
def widget(self):
|
||||
return self._widget
|
||||
def label(self):
|
||||
return self._label
|
||||
def is_sensitive(self, database):
|
||||
return hasattr(database, self._attrDatabase)
|
||||
def can_edit(self):
|
||||
return self._canEdit
|
||||
def set_sensitive(self, flag):
|
||||
self._label.set_sensitive(flag)
|
||||
self._widget.set_sensitive(flag)
|
||||
def value_from_database(self, database):
|
||||
getattr(self._widget, self._attrSet)( getattr(database, self._attrDatabase) )
|
||||
def value_to_database(self, database):
|
||||
setattr(database, self._attrDatabase, getattr(self._widget, self._attrGet)() )
|
||||
def reset_value(self):
|
||||
getattr(self._widget, self._attrSet)(self._defaultValue)
|
||||
|
||||
def __init__(self, databaseManager, database, mode=ModeEdit, parentWidget=None):
|
||||
gtk.VBox.__init__(self)
|
||||
|
||||
self.databaseManager = databaseManager
|
||||
self.database = database
|
||||
self.mode = mode
|
||||
self.parentWidget = parentWidget
|
||||
self.fieldWidgets = (
|
||||
self.FieldWidget(
|
||||
text='Name:',
|
||||
attrDatabase='name',
|
||||
widget=gtk.Entry(),
|
||||
defaultValue='',
|
||||
attrGet='get_text',
|
||||
attrSet='set_text',
|
||||
canEdit=True,
|
||||
tooltip='Any name you like to name the database '
|
||||
),
|
||||
self.FieldWidget(
|
||||
text='File:',
|
||||
attrDatabase='file',
|
||||
widget=self.SqLiteFileChooserButton(self, self.parentWidget),
|
||||
defaultValue='',
|
||||
attrGet='get_filename',
|
||||
attrSet='set_filename',
|
||||
canEdit=False,
|
||||
tooltip='Fully qualified path of the file to hold the database '
|
||||
),
|
||||
self.FieldWidget(
|
||||
text='Host:',
|
||||
attrDatabase='host',
|
||||
widget=gtk.Entry(),
|
||||
defaultValue='',
|
||||
attrGet='get_text',
|
||||
attrSet='set_text',
|
||||
canEdit=False,
|
||||
tooltip='Host the database is located at'
|
||||
),
|
||||
self.FieldWidget(
|
||||
text='Port:',
|
||||
attrDatabase='port',
|
||||
widget=gtk.SpinButton(adjustment=gtk.Adjustment(value=0, lower=0, upper=999999, step_incr=1, page_incr=10) ),
|
||||
defaultValue=0,
|
||||
attrGet='get_value',
|
||||
attrSet='set_value',
|
||||
canEdit=False,
|
||||
tooltip='Port to use to connect to the host'
|
||||
),
|
||||
self.FieldWidget(
|
||||
text='User:',
|
||||
attrDatabase='user',
|
||||
widget=gtk.Entry(),
|
||||
defaultValue='',
|
||||
attrGet='get_text',
|
||||
attrSet='set_text',
|
||||
canEdit=False,
|
||||
tooltip='User name used to login to the host'
|
||||
),
|
||||
self.FieldWidget(
|
||||
text='Pwd:',
|
||||
attrDatabase='password',
|
||||
widget=gtk.Entry(),
|
||||
defaultValue='',
|
||||
attrGet='get_text',
|
||||
attrSet='set_text',
|
||||
canEdit=False,
|
||||
tooltip='Password used to login to the host'
|
||||
),
|
||||
self.FieldWidget(
|
||||
text='Db:',
|
||||
attrDatabase='database',
|
||||
widget=gtk.Entry(),
|
||||
defaultValue='',
|
||||
attrGet='get_text',
|
||||
attrSet='set_text',
|
||||
canEdit=False,
|
||||
tooltip='Name of the database'
|
||||
),
|
||||
)
|
||||
|
||||
# setup database type combo
|
||||
self.comboType = gtk.ComboBox()
|
||||
listStore= gtk.ListStore(str, str)
|
||||
self.comboType.set_model(listStore)
|
||||
cell = gtk.CellRendererText()
|
||||
self.comboType.pack_start(cell, True)
|
||||
self.comboType.add_attribute(cell, 'text', 0)
|
||||
self.comboType.connect('changed', self.on_combo_type_changed)
|
||||
|
||||
# fill database type combo with available database klasses. we store (databaseDisplayName, databaseType) in our model for later lookup
|
||||
iCurrentDatabase = 0
|
||||
databaseTypes = [(klass.display_name(), klass.Type) for klass in databaseManager.DatabaseTypes.values()]
|
||||
databaseTypes.sort()
|
||||
for i, (databaseDisplayName, databaseType) in enumerate(databaseTypes):
|
||||
listStore.append( (databaseDisplayName, databaseType) )
|
||||
if databaseType == self.database.Type:
|
||||
iCurrentDatabase = i
|
||||
if self.mode == self.ModeEdit or len(databaseTypes) < 2:
|
||||
self.comboType.set_button_sensitivity(gtk.SENSITIVITY_OFF)
|
||||
|
||||
# init and layout field widgets
|
||||
self.pack_start(self.comboType, False, False, 2)
|
||||
table = gtk.Table(rows=len(self.fieldWidgets) +1, columns=2, homogeneous=False)
|
||||
self.pack_start(table, False, False, 2)
|
||||
for i,fieldWidget in enumerate(self.fieldWidgets):
|
||||
table.attach(fieldWidget.label(), 0, 1, i, i+1, xoptions=gtk.FILL)
|
||||
table.attach(fieldWidget.widget(), 1, 2, i, i+1)
|
||||
|
||||
# init widget
|
||||
self.comboType.set_active(iCurrentDatabase)
|
||||
self._adjust_widgets(self.database)
|
||||
|
||||
def _adjust_widgets(self, database):
|
||||
for fieldWidget in self.fieldWidgets:
|
||||
isSensitive = fieldWidget.is_sensitive(database)
|
||||
if isSensitive:
|
||||
fieldWidget.value_from_database(database)
|
||||
else:
|
||||
fieldWidget.reset_value()
|
||||
if self.mode == self.ModeEdit:
|
||||
isSensitive = isSensitive and fieldWidget.can_edit()
|
||||
fieldWidget.set_sensitive(isSensitive)
|
||||
|
||||
|
||||
def on_combo_type_changed(self, combo):
|
||||
i = self.comboType.get_active()
|
||||
if i < 0:
|
||||
return
|
||||
|
||||
# check if we need to init a new database
|
||||
currentDatabaseType = self.comboType.get_model()[i][1]
|
||||
if currentDatabaseType == self.database.Type:
|
||||
return
|
||||
|
||||
# create new empty database
|
||||
#NOTE: we dont register it in DatabaseManager
|
||||
self.database = self.databaseManager.DatabaseTypes[currentDatabaseType]()
|
||||
self._adjust_widgets(self.database)
|
||||
|
||||
|
||||
def get_database(self):
|
||||
for fieldWidget in self.fieldWidgets:
|
||||
if fieldWidget.is_sensitive(self.database):
|
||||
fieldWidget.value_to_database(self.database)
|
||||
return self.database
|
||||
|
||||
|
||||
class DialogDatabaseProperties(gtk.Dialog):
|
||||
def __init__(self, databaseManager, database, parent=None, mode=WidgetDatabaseProperties.ModeEdit, title=''):
|
||||
gtk.Dialog.__init__(self,
|
||||
title=title,
|
||||
parent=parent,
|
||||
flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
|
||||
buttons=(
|
||||
gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
|
||||
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT,
|
||||
)
|
||||
)
|
||||
self.connect('response', self.on_dialog_response)
|
||||
|
||||
# setup widget
|
||||
self.widgetDatabaseProperties = WidgetDatabaseProperties(databaseManager,database, mode=mode, parentWidget=self)
|
||||
self.vbox.pack_start(self.widgetDatabaseProperties, True, True)
|
||||
self.show_all()
|
||||
|
||||
def get_widget_database_properties(self):
|
||||
return self.widgetDatabaseProperties
|
||||
|
||||
def on_dialog_response(self, dlg, responseId):
|
||||
if responseId == gtk.RESPONSE_REJECT:
|
||||
pass
|
||||
elif responseId == gtk.RESPONSE_ACCEPT:
|
||||
pass
|
||||
|
||||
|
||||
#TODO: derrive from gtk.VBox?
|
||||
# ..is there a way to derrive from gtk.Widget or similar? this would make parentWidget kw obsolete
|
||||
class WidgetDatabaseManager(gtk.VBox):
|
||||
"""
|
||||
"""
|
||||
|
||||
def __init__(self, databaseManager, parentWidget=None):
|
||||
gtk.VBox.__init__(self)
|
||||
|
||||
self.parentWidget = parentWidget
|
||||
self.databaseManager = databaseManager
|
||||
self.databaseManager.connect('database-activated', self.on_database_manager_database_activated)
|
||||
self.databaseManager.connect('database-deactivated', self.on_database_manager_database_deactivated)
|
||||
self.databaseStatusNames = {
|
||||
DatabaseTypeBase.StatusActive: 'Active',
|
||||
DatabaseTypeBase.StatusInactive: 'Inactive',
|
||||
DatabaseTypeBase.StatusError: 'Error',
|
||||
}
|
||||
|
||||
|
||||
#TODO: dono how to make word wrap work as expected
|
||||
self.labelInfo = gtk.Label('database management')
|
||||
self.labelInfo.set_line_wrap(True)
|
||||
self.labelInfo.set_selectable(True)
|
||||
self.labelInfo.set_single_line_mode(False)
|
||||
self.labelInfo.set_alignment(0, 0)
|
||||
|
||||
# database management buttons
|
||||
|
||||
#TODO: bit messy the distinction New/Add/Edit. we'd have to pass three flags to DialogDatabaseProperties
|
||||
# to handle this. maybe drop Edit (is just a Remove + Add), to keep things simple
|
||||
self.buttonDatabaseActivate = gtk.Button("Activate")
|
||||
self.buttonDatabaseActivate.set_tooltip_text('activates the database')
|
||||
self.buttonDatabaseActivate.connect('clicked', self.on_button_database_activate_clicked)
|
||||
self.buttonDatabaseActivate.set_sensitive(False)
|
||||
self.buttonDatabaseNew = gtk.Button("New..")
|
||||
self.buttonDatabaseNew.set_tooltip_text('creates a new database')
|
||||
self.buttonDatabaseNew.connect('clicked', self.on_button_database_new_clicked)
|
||||
self.buttonDatabaseAdd = gtk.Button("Add..")
|
||||
self.buttonDatabaseAdd.set_tooltip_text('adds an existing database')
|
||||
self.buttonDatabaseAdd.connect('clicked', self.on_button_database_add_clicked)
|
||||
self.buttonDatabaseEdit = gtk.Button("Edit..")
|
||||
self.buttonDatabaseEdit.set_tooltip_text('edit database settings')
|
||||
self.buttonDatabaseEdit.connect('clicked', self.on_button_database_edit_clicked)
|
||||
self.buttonDatabaseEdit.set_sensitive(False)
|
||||
self.buttonDatabaseRemove = gtk.Button("Remove")
|
||||
self.buttonDatabaseRemove.set_tooltip_text('removes the database from the list')
|
||||
self.buttonDatabaseRemove.set_sensitive(False)
|
||||
self.buttonDatabaseRemove.connect('clicked', self.on_button_database_remove_clicked)
|
||||
|
||||
#TODO: i dont think we should do any real database management here. maybe drop it
|
||||
#self.buttonDatabaseDelete = gtk.Button("Delete")
|
||||
#self.buttonDatabaseDelete.set_tooltip_text('removes the database from the list and deletes it')
|
||||
#self.buttonDatabaseDelete.set_sensitive(False)
|
||||
|
||||
# init database tree
|
||||
self.treeDatabases = gtk.TreeView()
|
||||
treeDatabaseColumns = ( # name, displayName, dataType
|
||||
('name', 'Name', str),
|
||||
('status', 'Status', str),
|
||||
('type', 'Type', str),
|
||||
('_id', '', int),
|
||||
)
|
||||
self.treeDatabaseColumns = {} # name --> index
|
||||
store = gtk.ListStore( *[i[2] for i in treeDatabaseColumns] )
|
||||
self.treeDatabases.set_model(store)
|
||||
for i, (name, displayName, dataType) in enumerate(treeDatabaseColumns):
|
||||
col = gtk.TreeViewColumn(displayName, gtk.CellRendererText(), text=i)
|
||||
self.treeDatabases.append_column(col)
|
||||
if name.startswith('_'):
|
||||
col.set_visible(False)
|
||||
self.treeDatabaseColumns[name] = i
|
||||
self.treeDatabases.get_selection().connect('changed', self.on_tree_databases_selection_changed)
|
||||
|
||||
# layout widgets
|
||||
vbox = gtk.VBox(self)
|
||||
vbox.pack_start(self.labelInfo, False, False, 2)
|
||||
vbox.pack_start(gtk.HSeparator(), False, False, 2)
|
||||
hbox = gtk.HBox()
|
||||
self.add(hbox)
|
||||
hbox.set_homogeneous(False)
|
||||
vbox = gtk.VBox()
|
||||
hbox.pack_start(vbox, False, False, 2)
|
||||
vbox.pack_start(self.buttonDatabaseActivate, False, False, 2)
|
||||
vbox.pack_start(self.buttonDatabaseNew, False, False, 2)
|
||||
vbox.pack_start(self.buttonDatabaseAdd, False, False, 2)
|
||||
vbox.pack_start(self.buttonDatabaseEdit, False, False, 2)
|
||||
vbox.pack_start(self.buttonDatabaseRemove, False, False, 2)
|
||||
#vbox.pack_start(self.buttonDatabaseDelete, False, False, 2)
|
||||
box = gtk.VBox()
|
||||
vbox.pack_start(box, True, True, 0)
|
||||
|
||||
hbox.pack_start(gtk.VSeparator(), False, False, 2)
|
||||
hbox.pack_end(self.treeDatabases, True, True, 2)
|
||||
|
||||
self.show_all()
|
||||
|
||||
# init widget
|
||||
model = self.treeDatabases.get_model()
|
||||
for database in self.databaseManager:
|
||||
it = model.append()
|
||||
model.set_value(it, self.treeDatabaseColumns['name'], database.name)
|
||||
model.set_value(it, self.treeDatabaseColumns['status'], self.databaseStatusNames[database.status] )
|
||||
model.set_value(it, self.treeDatabaseColumns['type'], database.display_name() )
|
||||
model.set_value(it, self.treeDatabaseColumns['_id'], self.databaseManager.database_id(database))
|
||||
|
||||
|
||||
def on_database_manager_database_activated(self, databaseManager, idDatabase):
|
||||
database = self.databaseManager.database_from_id(idDatabase)
|
||||
model = self.treeDatabases.get_model()
|
||||
for row in iter(model):
|
||||
if row[self.treeDatabaseColumns['_id']] == idDatabase:
|
||||
row[self.treeDatabaseColumns['status']] = self.databaseStatusNames[database.StatusActive]
|
||||
break
|
||||
else:
|
||||
raise ValueError('database not found')
|
||||
|
||||
|
||||
def on_database_manager_database_deactivated(self, databaseManager, idDatabase):
|
||||
database = self.databaseManager.database_from_id(idDatabase)
|
||||
model = self.treeDatabases.get_model()
|
||||
for row in iter(model):
|
||||
if row[self.treeDatabaseColumns['_id']] == idDatabase:
|
||||
row[self.treeDatabaseColumns['status']] = self.databaseStatusNames[database.StatusInactive]
|
||||
break
|
||||
else:
|
||||
raise ValueError('database not found')
|
||||
|
||||
|
||||
def on_button_database_activate_clicked(self, button):
|
||||
selection = self.treeDatabases.get_selection()
|
||||
if selection is None:
|
||||
return
|
||||
|
||||
model, it = selection.get_selected()
|
||||
idDatabase = model.get_value(it, self.treeDatabaseColumns['_id'])
|
||||
database = self.databaseManager.database_from_id(idDatabase)
|
||||
self.databaseManager.activate_database(database)
|
||||
|
||||
|
||||
#TODO: for some reason i have to click OK/Cancel twice to close the dialog
|
||||
def on_button_database_new_clicked(self, button):
|
||||
databaseKlass = self.databaseManager.get_default_database_type()
|
||||
if databaseKlass is None:
|
||||
raise ValueError('no default database type set')
|
||||
database = databaseKlass()
|
||||
|
||||
while True:
|
||||
dlg = DialogDatabaseProperties(
|
||||
self.databaseManager,
|
||||
database,
|
||||
parent=self.parentWidget,
|
||||
mode=WidgetDatabaseProperties.ModeNew,
|
||||
title='New database'
|
||||
)
|
||||
response = dlg.run()
|
||||
if response == gtk.RESPONSE_ACCEPT:
|
||||
database = dlg.get_widget_database_properties().get_database()
|
||||
#TODO: initing may or may not take a while. how to handle?
|
||||
error = database.init_new_database()
|
||||
if error:
|
||||
DialogError(parent=dlg, msg=error)
|
||||
dlg.destroy()
|
||||
continue
|
||||
else:
|
||||
database = None
|
||||
dlg.destroy()
|
||||
break
|
||||
|
||||
|
||||
if database is None:
|
||||
return
|
||||
|
||||
self.databaseManager.add_database(database)
|
||||
model = self.treeDatabases.get_model()
|
||||
it = model.append()
|
||||
model.set_value(it, self.treeDatabaseColumns['name'], database.name)
|
||||
model.set_value(it, self.treeDatabaseColumns['status'], self.databaseStatusNames[database.status] )
|
||||
model.set_value(it, self.treeDatabaseColumns['type'], database.display_name() )
|
||||
model.set_value(it, self.treeDatabaseColumns['_id'], self.databaseManager.database_id(database))
|
||||
|
||||
|
||||
def on_button_database_add_clicked(self, button):
|
||||
databaseKlass = self.databaseManager.get_default_database_type()
|
||||
if databaseKlass is None:
|
||||
raise ValueError('no defult database type set')
|
||||
database = databaseKlass()
|
||||
|
||||
while True:
|
||||
dlg = DialogDatabaseProperties(
|
||||
self.databaseManager,
|
||||
database,
|
||||
parent=self.parentWidget,
|
||||
mode=WidgetDatabaseProperties.ModeAdd,
|
||||
title='Add database'
|
||||
)
|
||||
response = dlg.run()
|
||||
if response == gtk.RESPONSE_ACCEPT:
|
||||
database = dlg.get_widget_database_properties().get_database()
|
||||
#TODO: validating may or may not take a while. how to handle?
|
||||
error = database.validate_database()
|
||||
if error:
|
||||
DialogError(parent=self.parentWidget, msg=error)
|
||||
dlg.destroy()
|
||||
continue
|
||||
else:
|
||||
database = None
|
||||
dlg.destroy()
|
||||
break
|
||||
|
||||
if database is None:
|
||||
return
|
||||
|
||||
self.databaseManager.add_database(database)
|
||||
model = self.treeDatabases.get_model()
|
||||
it = model.append()
|
||||
model.set_value(it, self.treeDatabaseColumns['name'], database.name)
|
||||
model.set_value(it, self.treeDatabaseColumns['status'], self.databaseStatusNames[database.status] )
|
||||
model.set_value(it, self.treeDatabaseColumns['type'], database.display_name() )
|
||||
model.set_value(it, self.treeDatabaseColumns['_id'], self.databaseManager.database_id(database))
|
||||
dlg.destroy()
|
||||
|
||||
def on_button_database_edit_clicked(self, button):
|
||||
selection = self.treeDatabases.get_selection()
|
||||
if selection is None:
|
||||
return
|
||||
|
||||
model, it = selection.get_selected()
|
||||
idDatabase = model.get_value(it, self.treeDatabaseColumns['_id'])
|
||||
database = self.databaseManager.database_from_id(idDatabase)
|
||||
dlg = DialogDatabaseProperties(
|
||||
self.databaseManager,
|
||||
database,
|
||||
parent=self.parentWidget,
|
||||
mode=WidgetDatabaseProperties.ModeEdit,
|
||||
title='Edit database'
|
||||
)
|
||||
response = dlg.run()
|
||||
if response == gtk.RESPONSE_REJECT:
|
||||
pass
|
||||
elif response == gtk.RESPONSE_ACCEPT:
|
||||
database = dlg.get_database()
|
||||
selection = self.treeDatabases.get_selection()
|
||||
if selection is not None:
|
||||
model, it = selection.get_selected()
|
||||
model.set_value(it, self.treeDatabaseColumns['name'], database.name)
|
||||
dlg.destroy()
|
||||
|
||||
|
||||
def on_button_database_remove_clicked(self, button):
|
||||
selection = self.treeDatabases.get_selection()
|
||||
if selection is None:
|
||||
return
|
||||
|
||||
model, it = selection.get_selected()
|
||||
#TODO: finalize database
|
||||
model.remove(it)
|
||||
|
||||
|
||||
def on_tree_databases_selection_changed(self, treeSelection):
|
||||
hasSelection = bool(treeSelection.count_selected_rows())
|
||||
|
||||
# enable/disable selection dependend widgets
|
||||
self.buttonDatabaseActivate.set_sensitive(hasSelection)
|
||||
self.buttonDatabaseEdit.set_sensitive(hasSelection)
|
||||
self.buttonDatabaseRemove.set_sensitive(hasSelection)
|
||||
#self.buttonDatabaseDelete.set_sensitive(hasSelection)
|
||||
|
||||
|
||||
class DialogDatabaseManager(gtk.Dialog):
|
||||
def __init__(self, databaseManager, parent=None):
|
||||
gtk.Dialog.__init__(self,
|
||||
title="Databases",
|
||||
parent=parent,
|
||||
flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
|
||||
buttons=(
|
||||
gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
|
||||
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT,
|
||||
))
|
||||
#self.set_size_request(260, 250)
|
||||
self.widgetDatabaseManager = WidgetDatabaseManager(databaseManager, parentWidget=self)
|
||||
self.vbox.pack_start(self.widgetDatabaseManager, True, True)
|
||||
self.show_all()
|
||||
|
||||
#**************************************************************************************************
|
||||
if __name__ == '__main__':
|
||||
databaseManager = DatabaseManager.from_fpdb('', defaultDatabaseType=DatabaseTypeSqLite)
|
||||
|
||||
#d = DialogDatabaseProperties(
|
||||
# DatabaseManager(defaultDatabaseType=DatabaseTypeSqLite),
|
||||
#database=DatabaseTypePostgres(),
|
||||
# database=None,
|
||||
# )
|
||||
d = DialogDatabaseManager(databaseManager)
|
||||
d.connect("destroy", gtk.main_quit)
|
||||
d.run()
|
||||
#gtk.main()
|
||||
Loading…
Reference in New Issue
Block a user