def saveSlot(self): """ Saves the currently displayed data type. """ self._dataTypeModel.myPropertyList = self._dataTypeView.myPropertyList try: self._dataTypeModel.saveDataType() except ConfigurationError, error: getDefaultLogger().error(error.message)
def saveSlot(self): """ Saves the currently displayed relation type. """ self._relationTypeView.close() try: self._relationTypeModel.saveRelationType() except ConfigurationError, error: getDefaultLogger().error(error.message)
def saveSlot(self): """ Saves the currently displayed data type. """ self._dataTypeModel.myPropertyList = self._dataTypeView.myPropertyList try: self._dataTypeModel.saveDataType() except ConfigurationError, error: getDefaultLogger().error(error.message)
class CreateConfigurationController(object): """ Controller component of the create configuration dialog. """ _logger = logger.getDefaultLogger() def __init__(self, repositoryManager): """ Constructor. """ self.__errorMessage = None self.__view = CreateConfigurationView(self) self.__model = CreateConfigurationModel(repositoryManager) self.__view.show() def createConfiguration(self, hostUri, username, password, configurationPath, dataPath): """ Delegates the call to the model. """ self.__errorMessage = None self.__view.createPushButton.setEnabled(False) thread = threading.Thread(target=self.__prepare, args=(hostUri, configurationPath, dataPath, username, password)) thread.start() while thread.isAlive(): qApp.processEvents() self.__view.createPushButton.setEnabled(True) if not self.__errorMessage is None: self._logger.error(self.__errorMessage) self.__view.showErrorMessage(self.__errorMessage) else: createConfiguration = True if self.__model.exists: createConfiguration = self.__view.showQuestion( "The configuration path does already exist. Overwrite it?") self.__view.createPushButton.setEnabled(False) thread = threading.Thread( target=self.__performConfigurationCreation, args=(createConfiguration, )) thread.start() while thread.isAlive(): qApp.processEvents() if not self.__errorMessage is None: self._logger.error(self.__errorMessage) self.__view.showErrorMessage(self.__errorMessage) self.__view.createPushButton.setEnabled(True) def __prepare(self, hostUri, configurationPath, dataPath, username, password): """ Performs basic checks in thread. """ try: self.__model.prepareConfiguration(hostUri, configurationPath, dataPath, username, password) except ConfigurationError, error: self.__errorMessage = error.message
class IconHandler(object): """ Implements icon management for a specific repository. """ __logger = getDefaultLogger() def __init__(self, iconRegistry, sourceFileStorer, targetFileStorer): """ Constructor. @param iconRegistry: Global registry for icons. @type iconRegistry: L{IconRegistry<datafinder.core.configuration.icons.registry.IconRegistry>} @param sourceFileStorer: Represents the source directory containing icon files. @type sourceFileStorer: L{FileStorer<datafinder.persistence.factory.FileStorer>} @param targetFileStorer: Represents the target directory for the icon files. @type targetFileStorer: L{FileStorer<datafinder.persistence.factory.FileStorer>} """ self._iconRegistry = iconRegistry self._location = targetFileStorer.identifier self._sourceFileStorer = sourceFileStorer self._targetFileStorer = targetFileStorer @property def allIcons(self): """ Getter for all defined icons. """ return self._iconRegistry.icons @property def icons(self): """ Getter for handler-specific icons. """ return self._iconRegistry.getIcons(self._location) @property def localIconFilePath(self): """ Getter for the local icon file path. """ return self._location def load(self): """ Stores the icons in the target directory and register corresponding icons. @raise ConfigurationError: Indicating problems. """ self.__logger.info("Loading icons...") try: if not self._targetFileStorer.exists(): self._targetFileStorer.createCollection(True) except PersistenceError, error: raise ConfigurationError("Cannot prepare target icon location.\nReason: '%s'" % error.message) else:
class ScriptHandler(object): """ Handles scripts of a specific repository. """ __logger = getDefaultLogger() def __init__(self, scriptRegistry, sourceFileStorer, targetFileStorer): """ Constructor. @param scriptRegistry: Global registry for scripts. @type scriptRegistry: L{ScriptRegistry<datafinder.core.configuration.scripts.registry.ScriptRegistry>} @param sourceFileStorer: Represents the source directory containing scripts. @type sourceFileStorer: L{FileStorer<datafinder.persistence.factory.FileStorer>} @param targetFileStorer: Represents the target directory of the scripts. @type targetFileStorer: L{FileStorer<datafinder.persistence.factory.FileStorer>} """ self._scriptRegistry = scriptRegistry self._location = targetFileStorer.identifier self._sourceFileStorer = sourceFileStorer self._targetFileStorer = targetFileStorer @property def allScripts(self): """ Getter for all defined scripts. """ return self._scriptRegistry.scripts @property def scripts(self): """ Getter for handler-specific scripts. """ return self._scriptRegistry.getScripts(self._location) def load(self): """ Loads the scripts in the target directory and registers corresponding scripts. @raise ConfigurationError: Indicating problems. """ self.__logger.info("Loading scripts...") try: if not self._targetFileStorer.exists(): self._targetFileStorer.createCollection(True) except PersistenceError, error: raise ConfigurationError("Cannot access target location of repository-specific " \ + "script extensions.\nReason: '%s'" % error.message) else:
class ScriptRegistry(object): """ Global registry for script extensions. """ _logger = getDefaultLogger() def __init__(self, preferences): """ Constructor. @param preferences: Global preferences object. @type preferences: L{PreferencesHandler<datafinder.core.configuration.preferences.PreferencesHandler>} """ self._preferences = preferences self._registeredScripts = dict() @property def scripts(self): """ Getter for all existing scripts. """ result = list() for locationScripts in self._registeredScripts.values(): for script in locationScripts.values(): result.append(copy(script)) return result def load(self): """ Loads local script extensions. @raise ConfigurationError: Indicating problems on initialization. """ scripts = list() for scriptUri in self._preferences.scriptUris: try: fileStorer = createFileStorer(scriptUri) except PersistenceError, error: self._logger.debug("Cannot access script '%s'. Reason '%s'" % (scriptUri, error.message)) else: try: script = createScript(fileStorer) except ConfigurationError, error: self._logger.debug(error.message) else:
def __init__(self, parameter, startUrl, debug): """ Constructor. @param parameter: Parameter of the application. @type parameter: C{list} @param startUrl: The URL used for connection. @type startUrl: C{unicode} @param debug: Activates debug messages when set to C{True}. @type debug: C{bool} """ QtGui.QApplication.__init__(self, parameter) pixmap = QtGui.QPixmap(":/images/images/splash_datafinder_user.png") splash = QtGui.QSplashScreen(pixmap, QtCore.Qt.WindowStaysOnTopHint) splash.show() self.processEvents() #Initializing of the translator. self.__translator = Translator() self.installTranslator(self.__translator) #Initializing of the logging mechanism. rootLoggerHandler = LoggerHandler(constants.LOGGER_ROOT) rootLoggingModel = LoggingModel(rootLoggerHandler, parent=self) rootLogger = logging.getLogger(constants.LOGGER_ROOT) if debug: rootLogger.setLevel(logging.DEBUG) rootLogger.addHandler(rootLoggerHandler) logger.getDefaultLogger().addHandler(rootLoggerHandler) scriptLoggerHandler = LoggerHandler(constants.LOGGER_SCRIPT) scriptLoggingModel = LoggingModel(scriptLoggerHandler, parent=self) scriptLogger = logging.getLogger(constants.LOGGER_SCRIPT) scriptLogger.setLevel(logging.DEBUG) scriptLogger.addHandler(scriptLoggerHandler) #Model initialization. repositoryManager = repositoryManagerInstance repositoryManager.load() if repositoryManager.preferences.getConnection(startUrl) is None: repositoryManager.preferences.addConnection(startUrl) #controller initialization. self.__mainWindow = MainWindow() self.__unmanagedRepositoryController = UnmanagedRepositoryController( self.__mainWindow, repositoryManager) self.__managedRepositoryController = ManagedRepositoryController( self.__mainWindow, repositoryManager) self.__scriptController = ScriptController( repositoryManager.scriptRegistry, self.__unmanagedRepositoryController.model, self.__mainWindow) self.__unmanagedRepositoryController.load( self.__managedRepositoryController, self.__scriptController) self.__managedRepositoryController.load( self.__unmanagedRepositoryController, self.__scriptController) self.__outputView = OutputFacadeController( self.__mainWindow, SearchFilter(self.__managedRepositoryController.model), self.__managedRepositoryController.itemActionController) self.__outputView.myRootLogView.model = LoggingSortFilterModel( rootLoggingModel) self.__outputView.myScriptLogView.model = LoggingSortFilterModel( scriptLoggingModel) # Display the GUI self.__mainWindow.show() splash.finish(self.__mainWindow) # initialize script API and scripts scriptApiContext = _ScriptApiContext() scriptApiContext.mainWidget = self.__mainWindow scriptApiContext.repositoryManager = repositoryManager scriptApiContext.managedRepositoryController = self.__managedRepositoryController scriptApiContext.unmanagedRepositoryController = self.__unmanagedRepositoryController scriptApiContext.scriptController = self.__scriptController script_api._context = scriptApiContext self.__scriptController.load() # Register clean up stuff atexit.register(repositoryManager.savePreferences) #Log message that everything is fine... rootLogger.info("DataFinder successful started.")
#OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ Implements the model component of the create configuration dialog. """ __version__ = "$Revision-Id:$" from datafinder.common import logger from datafinder.core.error import ConfigurationError _logger = logger.getDefaultLogger() class CreateConfigurationModel(object): """ Implements the model component of the create configuration dialog. """ def __init__(self, repositoryManager): """ Constructor. """ self._repositoryManager = repositoryManager self._preferences = repositoryManager.preferences self._configurationUri = None self._dataPath = None self._repositoryConfiguration = None self._exists = None self._username = None
class ScriptCollection(object): """ Class representing a script collection. """ _logger = getDefaultLogger() def __init__(self, fileStorer): """ Constructor. @param fileStorer: Allowing access to the script data. @type fileStorer: L{FileStorer<datafinder.persistence.factory.FileStorer>} """ self._fileStorer = fileStorer self.uri = self._fileStorer.uri self.name = self._fileStorer.name self._tmpdir = tempfile.mkdtemp() sys.path.append(self._tmpdir) self.title = self._fileStorer.name[:-4] sys.path.append(self._tmpdir) self._baseDirFileStorer = createFileStorer("file:///" + self._tmpdir + "/" + self.title) atexit.register(self._cleanup) self.scripts = list() self.hasPreferences = False self.location = None self._extract() self._parse() def _extract(self): """ Extract the script collection. """ dataStream = self._fileStorer.readData() tar = tarfile.open(fileobj=dataStream) for member in tar.getmembers(): tar.extract(member, self._tmpdir) tar.close() dataStream.close() def _parse(self): """ Parse all scripts. """ configFileStorer = self._baseDirFileStorer.getChild( constants.SCRIPT_DEFINITION_FILE_NAME) data = configFileStorer.readData() for line in data.readlines(): fileStorer = self._baseDirFileStorer.getChild(line.strip()) self.scripts.append(Script(fileStorer)) data.close() if self._baseDirFileStorer.getChild( constants.PREFERENCES_PAGE_MODULE_NAME).exists(): self.hasPreferences = True def _cleanup(self): """ Cleanup the temporary directory. """ if self._tmpdir in sys.path: sys.path.remove(self._tmpdir) try: fileStorer = createFileStorer("file:///" + self._tmpdir) if fileStorer.exists(): fileStorer.delete() except PersistenceError, error: self._logger.debug(error.message)
class SelectScriptDialog(SelectScriptDialogForm): """ Dialog to select a "script". (see L{datafinder.application.ScriptingHandler.ScriptingHandler}) """ __logger = getDefaultLogger() def __init__(self, *args): """ Constructor. """ SelectScriptDialogForm.__init__(self, *args) self.connect(self, PYSIGNAL("quit"), SLOT("reject()")) self.okay = 0 def setScripts(self, scripts): """ Set items of script-listview. Invoke this method before using getScript(). @param scripts: list of scripts @type scripts: C{list} of C{dictionaries} (keys: name, description, file, version, datatypes, icon) """ self.scriptListView.clear() for script in scripts: if isinstance(script, Script): item = QListViewItem(self.scriptListView, script.title or "", script.description or "", script.version or "", ",".join(script.datatypes), script.iconName or "") else: item = QListViewItem(self.scriptListView, script.title or "", "", "", "", "") item.script = script self.scriptListView.clearSelection() self.adjustSize() def getScriptToRemove(self): """ Show and handle dialog, returns name of selected script. @return: name of selected script (OK) or None (Cancel) @rtype: C{unicode} (or C{None}) """ self.setCaption(self.tr("Select Script")) self.taskTextLabel.setText(self.tr("Select Script to Remove:")) self.okButton.setText(self.tr("Remove")) self.cancelButton.setDefault(True) self.exec_loop() result = list() if self.okay: item = self.scriptListView.firstChild() while not item is None: if item.isSelected(): result.append(item.script) item = item.nextSibling() return result def cancelPushButtonSlot(self): """ Slot for Cancel-button. """ self.okay = 0 # false self.emit(PYSIGNAL("quit"), ()) def okPushButtonSlot(self): """ Slot for OK-button. """ self.okay = 1 # true self.emit(PYSIGNAL("quit"), ())
class Importer( ItemTreeWalkerBase, object ): # inherit from object to make pylint happy, but this is a pylint issue """ This class uses the L{ItemTreeWalkerBase<datafinder.core.item.visitor.base.ItemTreeWalkerBase>} protocol to implement a recursive copy algorithm between two repositories. It is assumed (but NOT checked) that the repository configurations are compatible. """ _log = logger.getDefaultLogger() def __init__(self, stopTraversalStates=None, stopProcessStates=None): """ @param stopTraversalStates: List of states that are used to prevent traversal of specific collections. Default: C{None} @type stopTraversalStates: C{list} of C{unicode} @param stopProcessStates: List of states that are used to prevent processing a specific items. Default: C{None} @type stopProcessStates: C{list} of C{unicode} """ super(Importer, self).__init__(-1, stopTraversalStates, stopProcessStates) self._pwd = None self._deferredLinks = None self._destinationRootPath = None self._itemFactory = None self._newSourceName = None self._defaultProperties = None self._source = None self._copyData = True self._ignoreLinks = False self._determinePropertiesCallback = None self.importedLeafs = None def performImport(self, source, targetCollection, newSourceName=None, defaultProperties=None, copyData=True, ignoreLinks=False, determinePropertiesCallback=None): """ This method initiates the copy process and starts walking the source creating a new node in the destination tree for each item it passes. @param source: The item that should be imported. @type source: L{ItemBase<datafinder.core.item.base.ItemBase>} @param targetCollection: The collection that should afterwards contain the copy. @type targetCollection: L{ItemCollection<datafinder.core.item.collection.ItemCollection>} @param newSourceName: Optional new name of the source item. Default: C{None} @type newSourceName: C{unicode} @param defaultProperties: Optional list of properties which are set for every item. Default: C{None} @type defaultProperties: C{list} of L{Property<datafinder.core.item.property.Property>} @param copyData: Flag indicating whether data has to be copied or not. @type copyData: C{bool} @param ignoreLinks: Flag indicating the links are ignored during import. Default: C{False} @type ignoreLinks: C{bool} @param determinePropertiesCallback: Function determining properties used when importing a specific item. @type: determinePropertiesCallback: C{callable} using an item description as input and returns a dictionary describing the properties. @raise ItemError: Indicating errors during import. """ self._pwd = targetCollection self._deferredLinks = list() self._destinationRootPath = targetCollection.path self._itemFactory = targetCollection.itemFactory self._newSourceName = newSourceName self._defaultProperties = defaultProperties self._source = source self._copyData = copyData self.importedLeafs = list() self._ignoreLinks = ignoreLinks self._determinePropertiesCallback = determinePropertiesCallback self.walk(source) missingDefferedLinkPaths = list() for source, importName, destinationParent in self._deferredLinks: try: self._copyLink(source, importName, destinationParent) except ItemError: missingDefferedLinkPaths.append(source.path) if len(missingDefferedLinkPaths) > 0: errorMessage = "The following links could not be imported:" for linkPath in missingDefferedLinkPaths: errorMessage += "\n" + linkPath raise ItemError(errorMessage) def walk(self, node): """ @see: L{walk<datafinder.core.item.visitor.base.ItemTreeWalkerBase.walk>} method to add further post-processing. """ super(Importer, self).walk(node) if node.isCollection: if not node.state in self._stopTraversalStates: self._pwd = self._pwd.parent def _copyLink(self, source, importName, destinationParent): """ Copies a link item. """ baseDestinationPath = self._destinationRootPath if not baseDestinationPath.endswith("/"): baseDestinationPath += "/" baseDestinationPath += (self._newSourceName or self._source.name) destinationLinkTargetPath = baseDestinationPath + source.linkTarget.path[ len(self._source.path):] destinationLinkTarget = self._itemFactory.create( destinationLinkTargetPath) link = self._itemFactory.createLink(importName, destinationLinkTarget, destinationParent) properties = source.properties.values()[:] if not self._determinePropertiesCallback is None: properties.extend(self._determinePropertiesCallback(source)) if not self._defaultProperties is None: properties.extend(self._defaultProperties) try: link.create(properties) except CoreError, error: link.invalidate() raise error
class SearchDialog(QtGui.QDialog, Ui_searchDialog): """ This class implements the search dialog. """ _logger = getDefaultLogger() def __init__(self, repositoryModel, parentWidget, itemActionController): """ Constructor. @param repositoryModel: Reference on the repository model. @type repositoryModel: L{RepositoryModel<datafinder.gui.user.models.repository.repository.RepositoryModel>} @param parentWidget: Parent widget of this dialog. @type parentWidget: L{QWidget<PyQt4.QtGui.QWidget>} """ QtGui.QDialog.__init__(self, parentWidget) Ui_searchDialog.__init__(self) self.setupUi(self) self._collectionSearchDialog = None self._parser = search_restriction.SearchRestrictionParser() self.__model = repositoryModel self._worker = None self._initialSearchQuery = "" self.__searchQueryAnalyzer = SearchQueryAnalyzer(self._parser, self._preparePropertyDefinitionToolTips()) self._initSearchQueryEditor() self.__highlighter = SearchSyntaxHighlighter(self.__searchQueryAnalyzer, self.restrictionTextEdit) self.__searchResultController = SearchResultController(self.resultsTableView, parentWidget, self, itemActionController) self.__searchResultController.model = SearchFilter(self.__model) self.__storedSearchesController = _SearchStorerController(self.searchesListView, self) self.__storedSearchesController.model = _ServerSearchStoreModel(repositoryModel.preferences) self._keywordSearchQueryConverter = KeywordSearchQueryConverter(self.__model.repository.configuration.registeredPropertyDefinitions) self.storedSearchesPushButton.setChecked(True) self._activateExpertMode() self.expertModePushButton.setEnabled(False) self._connectSlots() def show(self): """ @see: L{QDialog<PyQt4.QtGui.QDialog>}""" self.startLineEdit.setText(self.__model.activePath or "/") QtGui.QDialog.show(self) def _initSearchQueryEditor(self): """ Initializes the search query editor. """ self.restrictionTextEdit.searchQueryAnalyzer = self.__searchQueryAnalyzer propertyNameCompleter = Completer(self._preparePropertyDefinitionToolTips(), True) self.restrictionTextEdit.registerCompleter(propertyNameCompleter, SearchQueryAnalyzer.PROPERTY_TYPE) comparisionOperatorCompleter = QtGui.QCompleter(self._parser.comparisonTokens) comparisionOperatorCompleter.setCaseSensitivity(QtCore.Qt.CaseInsensitive) self.restrictionTextEdit.registerCompleter(comparisionOperatorCompleter, SearchQueryAnalyzer.COMPARISON_TYPE) conjunctionOperatorCompleter = QtGui.QCompleter(self._parser.conjunctionTokens) conjunctionOperatorCompleter.setCaseSensitivity(QtCore.Qt.CaseInsensitive) self.restrictionTextEdit.registerCompleter(conjunctionOperatorCompleter, SearchQueryAnalyzer.CONJUNCTION_TYPE) completions = {u"''": u"Empty Value.", u"'DD.MM.YYYY'": u"Date Format Value.", u"'DD.MM.YYYY HH:MM:SS'": u"Date Time Format Value."} valueStateCompleter = Completer(completions) self.restrictionTextEdit.registerCompleter(valueStateCompleter, SearchQueryAnalyzer.LITERAL_TYPE) self.restrictionTextEdit.state = SearchQueryAnalyzer.PROPERTY_TYPE def _preparePropertyDefinitionToolTips(self): """ Prepares a dictionary containing the tool tips of existing property definitions. """ result = dict() for propDef in self.__model.repository.configuration.registeredPropertyDefinitions.values(): result[propDef.identifier] = util.determinePropertyDefinitionToolTip(propDef) return result def _connectSlots(self): """ Connects signals and slots. """ self.connect(self.startSelectionButton, QtCore.SIGNAL("clicked()"), self._showSelectionClickedSlot) self.connect(self.closeButton, QtCore.SIGNAL("clicked()"), self._closeClickedSlot) self.connect(self.searchesListView, QtCore.SIGNAL("doubleClicked(QModelIndex)"), self._storedSearchClickedSlot) self.connect(self.expertModePushButton, QtCore.SIGNAL("clicked(bool)"), self._searchModeChanged) self.connect(self.storedSearchesPushButton, QtCore.SIGNAL("clicked(bool)"), self._storedSearchesModeChanged) self.connect(self.saveSearchButton, QtCore.SIGNAL("clicked()"), self._handleSearchStored) def _handleSearchStored(self): """ Reacts on when saving a search. """ self._initialSearchQuery = self.restrictionTextEdit.toPlainText() def _showSelectionClickedSlot(self): """ Slot is called when the start selection button was clicked. """ leafFilterModel = LeafFilter(self.__model) self._collectionSearchDialog = ItemSelectionDialog(leafFilterModel, self) self._collectionSearchDialog.selectedIndex = self.__model.indexFromPath(unicode(self.startLineEdit.text())) if self._collectionSearchDialog.exec_() == QtGui.QDialog.Accepted: item = self.__model.nodeFromIndex(self._collectionSearchDialog.selectedIndex) self.startLineEdit.setText(item.path or "/") def _closeClickedSlot(self): """ Slot is called when the close button was clicked. """ if self._proceedWithUnsavedChanges(): self.__storedSearchesController.model.save() self.close() def _expertSearchClickedSlot(self): """ Slot is called when the search button was clicked and the dialog is in the expert mode. """ self.resultsGroupBox.show() self.setEnabled(False) path = unicode(self.startLineEdit.text()) query = unicode(self.restrictionTextEdit.toPlainText()) self._worker = util.startNewQtThread(self.__model.search, self._searchFinishedSlot, self.__model.indexFromPath(path), query) def _searchFinishedSlot(self): """ Slot is called when the search thread finished its work and the dialog is in expert mode. """ if not self._worker.error is None: QtGui.QMessageBox.critical(self, "Search Error", self._worker.error.message) self.setEnabled(True) def _simpleSearchClickedSlot(self): """ Slot is called when the search button was clicked and the dialog is in the simple search mode. """ self.splitter_2.show() self.resultsGroupBox.show() self.setEnabled(False) text = unicode(self.keywordLineEdit.text()) path = unicode(self.startLineEdit.text()) query = self._keywordSearchQueryConverter.convert(text) self._worker = util.startNewQtThread(self.__model.search, self._searchFinishedSlot, self.__model.indexFromPath(path), query) def _storedSearchClickedSlot(self, index): """ Slot is called when a search was selected from the stored searches. """ if self._proceedWithUnsavedChanges(): self.__storedSearchesController.searchSelectedSlot(index) restriction = self.__storedSearchesController.model.restrictionFromIndex(index) self._initialSearchQuery = restriction self.restrictionTextEdit.setText(restriction) else: self.searchesListView.clearSelection() def _searchModeChanged(self, expertMode): """ Slot is called when the state of the expertModePushButton changed. """ if expertMode: self._activateExpertMode() else: if self._proceedWithUnsavedChanges(): self._activateSimpleMode() else: self.expertModePushButton.setChecked(True) def _proceedWithUnsavedChanges(self): """ Checks for unsaved changes of the search restrictions and asks the user how to proceed. """ continue_ = True if self._initialSearchQuery != self.restrictionTextEdit.toPlainText(): answer = QtGui.QMessageBox.question(self, "Unsaved Changes", "Some changes of the search restrictions "\ + "have not yet been saved and may be lost when you proceed."\ + "\nDo you want to continue?", QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, QtGui.QMessageBox.No) if answer == QtGui.QMessageBox.No: continue_ = False return continue_ def _storedSearchesModeChanged(self, storedSearches): """ Slot is called when the state of the storedSearchesPushButton changed. """ self.storedSearchGroupBox.setVisible(bool(storedSearches)) def _activateSimpleMode(self): """ Activates the simple mode. It hides all expert mode's widgets and sets all simple mode's widgets visible. It also manages the signal slot connections. """ self.disconnect(self.__searchQueryAnalyzer, QtCore.SIGNAL(SearchQueryAnalyzer.VALIDATION_SIGNAL), self.searchButton.setEnabled) self.disconnect(self.__searchQueryAnalyzer, QtCore.SIGNAL(SearchQueryAnalyzer.VALIDATION_SIGNAL), self.__storedSearchesController.validationSlot) self.disconnect(self.searchButton, QtCore.SIGNAL("clicked()"), self._expertSearchClickedSlot) self.connect(self.keywordLineEdit, QtCore.SIGNAL("textChanged(const QString &)"), self._handleKeywordLineEditTextChanged) self.connect(self.searchButton, QtCore.SIGNAL("clicked()"), self._simpleSearchClickedSlot) self.splitter_2.hide() self.resultsGroupBox.hide() self.optionsGroupBox.hide() self.storedSearchGroupBox.hide() self.simpleSearchGroupBox.show() self.searchButton.show() self.storedSearchesPushButton.hide() self.resize(self.minimumSize().width(), self.sizeHint().height()) self._handleKeywordLineEditTextChanged(self.keywordLineEdit.text()) def _handleKeywordLineEditTextChanged(self, newText): """ Handles changes of the keyword line editor. """ isEmpty = len(unicode(newText).strip()) == 0 self.searchButton.setEnabled(not isEmpty) def _activateExpertMode(self): """ Activates the expert mode. It hides all simple mode's widgets and sets all expert mode's widgets visible. It also manages the signal slot connections. """ self.disconnect(self.searchButton, QtCore.SIGNAL("clicked()"), self._simpleSearchClickedSlot) self.disconnect(self.keywordLineEdit, QtCore.SIGNAL("textChanged(const QString &)"), self._handleKeywordLineEditTextChanged) self.optionsGroupBox.show() self.storedSearchGroupBox.setVisible(self.storedSearchesPushButton.isChecked()) self.connect(self.searchButton, QtCore.SIGNAL("clicked()"), self._expertSearchClickedSlot) self.connect(self.__searchQueryAnalyzer, QtCore.SIGNAL(SearchQueryAnalyzer.VALIDATION_SIGNAL), self.searchButton.setEnabled) self.connect(self.__searchQueryAnalyzer, QtCore.SIGNAL(SearchQueryAnalyzer.VALIDATION_SIGNAL), self.__storedSearchesController.validationSlot) self.startLabel.hide() self.startSelectionButton.hide() self.splitter_2.show() self.simpleSearchGroupBox.hide() self.storedSearchesPushButton.show() query = self._keywordSearchQueryConverter.convert(unicode(self.keywordLineEdit.text())) self._initialSearchQuery = query self.restrictionTextEdit.setText(query)
class AdminMain(AdminWindow): """ Implements the administration client functionality. """ __tabDataTypesTitle = "Data Types" __tabRelationTypesTitle = "Relation Types" __tabDataStoresTitle = "Data Stores" __baseCaption = "DataFinder Administration Client - Server: " __errorMessageCaption = "DataFinder Administration Client: Error" __informationMessageCaption = "DataFinder Administration Client: Information" __logger = getDefaultLogger() def __init__(self, repositoryManager): """ Constructor. """ # Init GUI AdminWindow.__init__(self) # set icon in window-title: self.setIcon(QPixmap.fromMimeSource("DF_Logo_24x24.png")) iconSet = QIconSet(QPixmap.fromMimeSource("dataType16.png")) self.dataNavigator.setTabIconSet(self.dataTypes, iconSet) iconSet = QIconSet(QPixmap.fromMimeSource("relationType16.png")) self.dataNavigator.setTabIconSet(self.relationTypes, iconSet) iconSet = QIconSet(QPixmap.fromMimeSource("dataStore16.png")) self.dataNavigator.setTabIconSet(self.dataStores, iconSet) logger_handler.installGuiLoggingHandler(self.__logger, self.logList) self.myStatusBar = self.statusBar() self.statusLabel1 = QLabel("DataFinder", self.myStatusBar) self.statusLabel2 = QLabel("OK", self.myStatusBar) self.myStatusBar.addWidget(self.statusLabel1, 80) self.myStatusBar.addWidget(self.statusLabel2, 20) self.statusLabel1.show() self.statusLabel2.show() self.myStatusBar.show() # prepare "About"-dialog: self.dfAboutDialog = about_dialog.AboutDialog() self.dfAboutDialog.setPixmap( QPixmap.fromMimeSource("about_datafinder_admin.png")) # Login-dialog: self.dfLoginDialog = login_dialog.LoginDialog( repositoryManager.preferences, parent=self, showurl=True) # IconView: propertyPanelLayout = QGridLayout(self.propertyPanel, 1, 1, 2, 6, "propertyPanelLayout") self.iconView = canvas_view.CanvasView(self.propertyPanel, self, "iconView", 0) propertyPanelLayout.addWidget(self.iconView, 0, 0) self.iconViewCanvas = self.iconView.canvas() self.connect(self.dfLoginDialog.okPushButton, PYSIGNAL("updateWebdavServerView"), self.updateWebdavServerSlot) self.connect(self.dataTypeBrowser, SIGNAL("doubleClicked(QListViewItem*)"), self.__addDataTypeIconSlot) self.connect(self.relationTypeBrowser, SIGNAL("doubleClicked(QListViewItem*)"), self.__addRelationTypeIconSlot) self.connect(self.dataStoreBrowser, SIGNAL("clicked(QListViewItem*)"), self.iconView.updateCanvasView) self.connect(self.dataStoreBrowser, SIGNAL("doubleClicked(QListViewItem*)"), self.editSlot) # Init model self._repositoryManager = repositoryManager self.repositoryConfiguration = None self._preferences = self._repositoryManager.preferences self._lastUploadDirectory = os.path.expanduser("~") self._dataTypes = list() self._relationTypes = list() self._dataStores = list() self.__setConnectionState(False) def __setConnectionState(self, isConnected): """ Sets the enabled state of the actions in accordance to successful or unsuccessful connection. """ self.iconView.clear() self.__setActionEnabledState(isConnected) if isConnected: self.setCaption(self.__baseCaption + unicode( self.repositoryConfiguration.repositoryConfigurationUri)) iconPath = self.repositoryConfiguration.localIconFilePath if sys.platform == "win32" and iconPath.startswith("/"): iconPath = iconPath[1:] utils.addQtImagePath(iconPath) else: self.repositoryConfiguration = None enableActions = [ self.fileConnectAction, self.fileExitAction, self.fileCreateConfigurationAction, self.editPreferencesAction, self.helpAboutAction ] for action in enableActions: action.setEnabled(True) self.setCaption(self.__baseCaption + "<not connected>") self.updateDataTypes() self.updateRelationTypes() self.updateDataStores() def __setActionEnabledState(self, isEnabled): """ Sets the enabled state of all actions. """ self.datamodelExportAction.setEnabled(isEnabled) self.datamodelImportAction.setEnabled(isEnabled) self.datamodelNewDataTypeAction.setEnabled(isEnabled) self.datamodelNewRelationTypeAction.setEnabled(isEnabled) self.deleteAction.setEnabled(isEnabled) self.editAction.setEnabled(isEnabled) self.editPreferencesAction.setEnabled(isEnabled) self.fileConnectAction.setEnabled(isEnabled) self.fileCreateConfigurationAction.setEnabled(isEnabled) self.fileDeleteConfigurationAction.setEnabled(isEnabled) self.fileExitAction.setEnabled(isEnabled) self.helpAboutAction.setEnabled(isEnabled) self.reloadConfigurationAction.setEnabled(isEnabled) self.storeExportAction.setEnabled(isEnabled) self.storeImportAction.setEnabled(isEnabled) self.storeNewAction.setEnabled(isEnabled) self.utilDeleteIconAction.setEnabled(isEnabled) self.utilDeleteScriptAction.setEnabled(isEnabled) self.utilUploadIconAction.setEnabled(isEnabled) self.utilUploadScriptAction.setEnabled(isEnabled) def __configureDatastore(self, datastore=None): """ Shows the Data Store configuration wizard to add a new Data Store. """ DataStoreConfigurationWizardController( self, self.repositoryConfiguration.dataStoreHandler, self.repositoryConfiguration.iconHandler, datastore) def changeIconPixmap(self, icon, oldLabel, newLabel): """ Changes the icon (node) pixmap. """ changedTitle = oldLabel if not oldLabel == newLabel and not self._getIconFromLabel( newLabel) == None: result = self.__showQuestion("DataFinder: Confirm Overwrite", "A Node of the same name \"" + unicode(newLabel) + \ "\" already exists.\nBefore renaming, please close that node.") return changedTitle if not oldLabel == newLabel and self._isTypeExisting(newLabel): result = self.__showQuestion( "DataFinder: Confirm Overwrite", "Overwrite existing \"" + unicode(newLabel) + "\"?") if result: return changedTitle iconItem = self._getIconFromLabel(oldLabel) if not iconItem is None: if icon is None: iconItem.setIconLabel(newLabel) else: iconItem.setIconLabel(newLabel) iconItem.setIconPixmap(icon.pixmap()) changedTitle = newLabel self.iconView.updateCanvasView() def _isNodeExisting(self, title): """ Check if the node with title does already exist. @param title: Title of the node. @type title: C{string} """ returnValue = True if self._getIconFromLabel(title) is None: returnValue = False return returnValue def _isTypeExisting(self, newName): """ Checks if the type exists. """ returnValue = False if not self.repositoryConfiguration.getDataType(newName) is None: returnValue = True elif not self.repositoryConfiguration.getRelation(newName) is None: returnValue = True return returnValue def _getIconFromLabel(self, searchLabel): """ Returns the icon specified by searchLabel. @param searchLabel: the label of the icon. @type searchLabel: C{String} @rtype: L{PrototypeIcon} """ return self.iconView.getIcon(searchLabel) def updateWebdavServerSlot(self, url, username, password): """ Reconnect to WebDAV server. """ # update preferences if self.dfLoginDialog.savePasswordCheckBox.isChecked(): self._preferences.addConnection(url, username, password) else: self._preferences.addConnection(url, username, None) self._preferences.store() try: if not self.repositoryConfiguration is None: self.repositoryConfiguration.release() repositoryConfiguration = None repositoryConfiguration = self._repositoryManager.getRepositoryConfiguration( url, username, password) repositoryConfiguration.load() except ConfigurationError, error: if not repositoryConfiguration is None: repositoryConfiguration.release() self.__showErrorMessage("Cannot connect to specified server. Reason: '%s'" % error.message \ + "Please try again or create a new configuration.") self.__setConnectionState(False) else:
self._setNodeIcon() self._dataTypeView.setButtonsState(False) def saveSlot(self): """ Saves the currently displayed data type. """ self._dataTypeModel.myPropertyList = self._dataTypeView.myPropertyList try: self._dataTypeModel.saveDataType() except ConfigurationError, error: getDefaultLogger().error(error.message) else: self._dataTypeView.close() self._parentFrame.updateDataTypes() getDefaultLogger().info("Data Type " + self._dataTypeModel.myTitle + " was successfully saved.") def __getattr__(self, name): """ Delegates calls to the generated PyQt class. """ return getattr(self._dataTypeView, name) class DataTypeModel(QObject): """ This is the data model of the add/edit data type dialog that contains the current data type or none and the list of available data types. """ def __init__(self, title, dataModelHandler, propertyDefinitionFactory, iconHandler):
self._dataTypeView.updateDataType(self._dataTypeModel.myTitle, self._dataTypeModel.myIconName, self._dataTypeModel.myPropertyList) self._setNodeIcon() self._dataTypeView.setButtonsState(False) def saveSlot(self): """ Saves the currently displayed data type. """ self._dataTypeModel.myPropertyList = self._dataTypeView.myPropertyList try: self._dataTypeModel.saveDataType() except ConfigurationError, error: getDefaultLogger().error(error.message) else: self._dataTypeView.close() self._parentFrame.updateDataTypes() getDefaultLogger().info("Data Type " + self._dataTypeModel.myTitle + " was successfully saved.") def __getattr__(self, name): """ Delegates calls to the generated PyQt class. """ return getattr(self._dataTypeView, name) class DataTypeModel(QObject): """ This is the data model of the add/edit data type dialog that contains the current data type or none and the list of available data types. """ def __init__(self, title, dataModelHandler, propertyDefinitionFactory, iconHandler): """
def __init__(self, repositoryModel): """ Constructor. """ self._repositoryModel = repositoryModel self._workerThreads = dict() self._logger = getDefaultLogger()
class DataStoreConfigurationWizardController(object): """ Controls the DataStoreWizardView. Delegates the control of the specific from to the according subclass of AbstractoptionComntroller. """ _logger = getDefaultLogger() def __init__(self, parentFrame, dataStoreHandler, iconHandler, datastore=None): """ Constructor. """ self.parent = parentFrame self._dataStoreHandler = dataStoreHandler # create main view self.wizardView = view.DataStoreConfigurationWizardView(parentFrame) # init model if not datastore is None: self.datastore = datastore else: self.datastore = self._dataStoreHandler.createDataStore() # add control logic of the displayed forms self.lastPageTitle = standardOptionsPage self.currentFormHandler = default.base_option_controller.BaseOptionController( self.wizardView, self, standardOptionsPage, dataStoreHandler, iconHandler) self.formControllerDict = { standardOptionsPage: { _defaultForAllDataStores: self.currentFormHandler }, storageOptionsPage: { datastores.OFFLINE_STORE: offline.storage_option_controller.StorageOptionController( self.wizardView, self, storageOptionsPage), datastores.TSM_CONNECTOR_STORE: tsm.storage_option_controller.StorageOptionController( self.wizardView, self, storageOptionsPage), _defaultForAllDataStores: default.storage_option_controller.StorageOptionController( self.wizardView, self, storageOptionsPage) }, securityOptionsPage: { datastores.GRIDFTP_STORE: gridftp.security_option_controller.SecurityOptionController( self.wizardView, self, securityOptionsPage), }, authenticationOptionsPage: { datastores.FTP_STORE: ftp.authentication_option_controller. AuthenticationOptionController(self.wizardView, self, authenticationOptionsPage), datastores.WEBDAV_STORE: webdav.authentication_option_controller. AuthenticationOptionController(self.wizardView, self, authenticationOptionsPage), datastores.TSM_CONNECTOR_STORE: tsm.authentication_option_controller. AuthenticationOptionController(self.wizardView, self, authenticationOptionsPage), datastores.S3_STORE: s3.authentication_option_controller. AuthenticationOptionController(self.wizardView, self, authenticationOptionsPage), datastores.SUBVERSION_STORE: webdav.authentication_option_controller. AuthenticationOptionController(self.wizardView, self, authenticationOptionsPage), _defaultForAllDataStores: default.authentication_option_controller. AuthenticationOptionController(self.wizardView, self, authenticationOptionsPage) }, performanceOptionsPage: { datastores.GRIDFTP_STORE: gridftp.performance_option_controller. PerformanceOptionController(self.wizardView, self, performanceOptionsPage) } } # show wizard self.wizardView.setCaption( wizardCaptionTemplate % (self.datastore.storeType, self.datastore.name)) self.wizardView.show() self.wizardView.adjustSize() self.currentFormHandler.showModelPart() self.setPageSequence() # connect slots self.wizardView.connect(self.wizardView, SIGNAL("selected(const QString&)"), self._wizardPageChangedSlot) self.wizardView.connect(self.wizardView.finishButton(), SIGNAL("clicked()"), self._finishedSlot) def _finishedSlot(self): """ Method to overwrite standard behavior of the QWizard class if the button "finished" is used. This method validates the user input, saves the DataStore object and continues closes the wizard. """ self._dataStoreHandler.addDataStore(self.datastore) try: self._dataStoreHandler.store() except ConfigurationError, error: self._logger.error(error.message) else:
def __init__(self, parameter, startUrl, debug): """ Constructor. @param parameter: Parameter of the application. @type parameter: C{list} @param startUrl: The URL used for connection. @type startUrl: C{unicode} @param debug: Activates debug messages when set to C{True}. @type debug: C{bool} """ QtGui.QApplication.__init__(self, parameter) pixmap = QtGui.QPixmap(":/images/images/splash_datafinder_user.png") splash = QtGui.QSplashScreen(pixmap, QtCore.Qt.WindowStaysOnTopHint) splash.show() self.processEvents() #Initializing of the translator. self.__translator = Translator() self.installTranslator(self.__translator) #Initializing of the logging mechanism. rootLoggerHandler = LoggerHandler(constants.LOGGER_ROOT) rootLoggingModel = LoggingModel(rootLoggerHandler, parent=self) rootLogger = logging.getLogger(constants.LOGGER_ROOT) if debug: rootLogger.setLevel(logging.DEBUG) rootLogger.addHandler(rootLoggerHandler) logger.getDefaultLogger().addHandler(rootLoggerHandler) scriptLoggerHandler = LoggerHandler(constants.LOGGER_SCRIPT) scriptLoggingModel = LoggingModel(scriptLoggerHandler, parent=self) scriptLogger = logging.getLogger(constants.LOGGER_SCRIPT) scriptLogger.setLevel(logging.DEBUG) scriptLogger.addHandler(scriptLoggerHandler) #Model initialization. repositoryManager = repositoryManagerInstance repositoryManager.load() if repositoryManager.preferences.getConnection(startUrl) is None: repositoryManager.preferences.addConnection(startUrl) #controller initialization. self.__mainWindow = MainWindow() self.__unmanagedRepositoryController = UnmanagedRepositoryController(self.__mainWindow, repositoryManager) self.__managedRepositoryController = ManagedRepositoryController(self.__mainWindow, repositoryManager) self.__scriptController = ScriptController(repositoryManager.scriptRegistry, self.__unmanagedRepositoryController.model, self.__mainWindow) self.__unmanagedRepositoryController.load(self.__managedRepositoryController, self.__scriptController) self.__managedRepositoryController.load(self.__unmanagedRepositoryController, self.__scriptController) self.__outputView = OutputFacadeController(self.__mainWindow, SearchFilter(self.__managedRepositoryController.model), self.__managedRepositoryController.itemActionController) self.__outputView.myRootLogView.model = LoggingSortFilterModel(rootLoggingModel) self.__outputView.myScriptLogView.model = LoggingSortFilterModel(scriptLoggingModel) # Display the GUI self.__mainWindow.show() splash.finish(self.__mainWindow) # initialize script API and scripts scriptApiContext = _ScriptApiContext() scriptApiContext.mainWidget = self.__mainWindow scriptApiContext.repositoryManager = repositoryManager scriptApiContext.managedRepositoryController = self.__managedRepositoryController scriptApiContext.unmanagedRepositoryController = self.__unmanagedRepositoryController scriptApiContext.scriptController = self.__scriptController script_api._context = scriptApiContext self.__scriptController.load() # Register clean up stuff atexit.register(repositoryManager.savePreferences) #Log message that everything is fine... rootLogger.info("DataFinder successful started.")
self._relationTypeModel.initRelationType() self._setNodeIcon() self._relationTypeView.setButtonsState(False) def saveSlot(self): """ Saves the currently displayed relation type. """ self._relationTypeView.close() try: self._relationTypeModel.saveRelationType() except ConfigurationError, error: getDefaultLogger().error(error.message) else: self._parentFrame.updateRelationTypes() getDefaultLogger().info("Relation Type " + self._relationTypeModel.myTitle + " was successfully saved.") def __getattr__(self, name): """ Delegates calls to the generated PyQt class. """ return getattr(self._relationTypeView, name) class RelationTypeModel(QObject): """ This is the data model of the add/edit relation type dialog that contains the current relation type or none and the list of available data types """ def __init__(self, title, dataModelHandler, iconHandler): """
class Script(object): """ Represents a single script extension. """ _logger = getDefaultLogger() def __init__(self, fileStorer): """ Initialize a new script. @param fileStorer: Allowing access to the script data. @type fileStorer: L{FileStorer<datafinder.persistence.factory.FileStorer>} """ self._fileStorer = fileStorer self.uri = self._fileStorer.uri self.name = self._fileStorer.name self.location = None # Script options self.title = None self.description = None self.datatypes = list() self.dataformats = list() self.iconName = None self.version = None self.automatic = False self._parseScript() if self.iconName is None: self.iconName = "lightning_bolt" if self.title is None: self.title = fileStorer.name def _parseScript(self): """ Parse the script and extract the meta data. """ dataStream = self._fileStorer.readData() try: try: line = dataStream.readline() while line: line = line.strip() self._parse(line) line = dataStream.readline() finally: dataStream.close() except IOError: raise ConfigurationError("Cannot read script data.") def _parse(self, line): """ Evaluates the line and sets the corresponding script attribute. """ if line.startswith(_COMMENT_CHARACTER): if constants.TITLE_KEYWORD in line: self.title = line.split(constants.TITLE_KEYWORD)[1].strip() elif constants.DATATYPES_KEYWORD in line: datatypes = line.split( constants.DATATYPES_KEYWORD)[1].split(_LIST_SEPARATOR) for datatype in datatypes: datatype = datatype.strip() if len(datatype) > 0: self.datatypes.append(datatype) elif constants.DATAFORMATS_KEYWORD in line: dataformats = line.split( constants.DATAFORMATS_KEYWORD)[1].split(_LIST_SEPARATOR) for dataformat in dataformats: dataformat = dataformat.strip() if len(dataformat) > 0: self.dataformats.append(dataformat) elif constants.ICON_KEYWORD in line: self.iconName = line.split(constants.ICON_KEYWORD)[1].strip() elif constants.VERSION_KEYWORD in line: self.version = line.split(constants.VERSION_KEYWORD)[1].strip() elif constants.DESCRIPTION_KEYWORD in line: self.description = line.split( constants.DESCRIPTION_KEYWORD)[1].strip() elif constants.AUTOMATIC_EXECUTE_KEYWORD in line: self.automatic = True def execute(self): """ Execute the script. @param scriptOut: Object to write the script output to. @type scriptOut: Object with write() method. @raise ConfigurationError: Raised if execution of script caused an exception or script terminated with a negative return code. """ try: fileObject = self._fileStorer.readData() except PersistenceError, error: raise ConfigurationError("Cannot access script.\nReason: '%s'" % error.message) else:
#SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT #LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, #DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY #THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT #(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE #OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ Implements the model component of the create configuration dialog. """ __version__ = "$Revision-Id:$" from datafinder.common import logger from datafinder.core.error import ConfigurationError _logger = logger.getDefaultLogger() class CreateConfigurationModel(object): """ Implements the model component of the create configuration dialog. """ def __init__(self, repositoryManager): """ Constructor. """ self._repositoryManager = repositoryManager self._preferences = repositoryManager.preferences self._configurationUri = None self._dataPath = None self._repositoryConfiguration = None self._exists = None self._username = None self._password = None