MqttMonitor/MqttConnectionOptionsDialog.py

# -*- coding: utf-8 -*-

# Copyright (c) 2018 Detlev Offenbach <detlev@die-offenbachs.de>
#

"""
Module implementing a dialog to enter MQTT connection options.
"""

from __future__ import unicode_literals

from PyQt5.QtCore import pyqtSlot, QUuid
from PyQt5.QtWidgets import QDialog, QDialogButtonBox, QAbstractButton

from E5Gui import E5MessageBox

from .Ui_MqttConnectionOptionsDialog import Ui_MqttConnectionOptionsDialog


class MqttConnectionOptionsDialog(QDialog, Ui_MqttConnectionOptionsDialog):
    """
    Class implementing a dialog to enter MQTT connection options.
    """
    def __init__(self, client, options=None, parent=None):
        """
        Constructor
        
        @param client reference to the MQTT client object
        @type MqttClient
        @param options dictionary containing the connection options to
            populate the dialog with. It must have the keys "ClientId",
            "Keepalive", "CleanSession", "Username", "Password", "WillTopic",
            "WillMessage", "WillQos", "WillRetain".
        @type dict
        @param parent reference to the parent widget
        @type QWidget
        """
        super(MqttConnectionOptionsDialog, self).__init__(parent)
        self.setupUi(self)
        
        self.__client = client
        
        self.__populateDefaults(options=options)
        
        self.__updateOkButton()
    
    def __updateOkButton(self):
        """
        Private method to update the enabled state of the OK button.
        """
        if self.clientIdEdit.text() == "" and \
                not self.cleanSessionCheckBox.isChecked():
            enable = False
            E5MessageBox.critical(
                self,
                self.tr("Invalid Connection Parameters"),
                self.tr("""An empty Client ID requires a clean session."""))
        else:
            enable = True
        
        self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(enable)
    
    @pyqtSlot()
    def on_generateIdButton_clicked(self):
        """
        Private slot to generate a client ID.
        """
        uuid = QUuid.createUuid()
        self.clientIdEdit.setText(uuid.toString(QUuid.WithoutBraces))
    
    @pyqtSlot(QAbstractButton)
    def on_buttonBox_clicked(self, button):
        """
        Private slot to handle the press of a button box button.
        
        @param button button that has been pressed
        @type QAbstractButton
        """
        if button == self.buttonBox.button(QDialogButtonBox.RestoreDefaults):
            self.__populateDefaults(options=None)
    
    def __populateDefaults(self, options=None):
        """
        Private method to populate the dialog.
        
        If no options dictionary is given, the dialog will be populated with
        default values.
        
        @param options dictionary containing the connection options to populate
            the dialog with. It must have the keys "ClientId", "Keepalive",
            "CleanSession", "Username", "Password", "WillTopic", "WillMessage",
            "WillQos", "WillRetain".
        @type dict
        """
        if options is None:
            options = self.__client.defaultConnectionOptions()
        
        # general
        self.clientIdEdit.setText(options["ClientId"])
        self.keepaliveSpinBox.setValue(options["Keepalive"])
        self.cleanSessionCheckBox.setChecked(options["CleanSession"])
        
        # user credentials
        self.usernameEdit.setText(options["Username"])
        self.passwordEdit.setText(options["Password"])
        
        # last will and testament
        self.willQosSpinBox.setValue(options["WillQos"])
        self.willRetainCheckBox.setChecked(options["WillRetain"])
        self.willTopicEdit.setText(options["WillTopic"])
        self.willMessageEdit.setPlainText(options["WillMessage"])
    
    def getConnectionOptions(self):
        """
        Public method get the entered connection options.
        
        @return dictionary containing the connection options. It has the keys
            "ClientId", "Keepalive", "CleanSession", "Username", "Password",
            "WillTopic", "WillMessage", "WillQos", "WillRetain".
        @rtype tuple of (int, dict)
        """
        return {
            "ClientId": self.clientIdEdit.text(),
            "Keepalive": self.keepaliveSpinBox.value(),
            "CleanSession": self.cleanSessionCheckBox.isChecked(),
            "Username": self.usernameEdit.text(),
            "Password": self.passwordEdit.text(),
            "WillTopic": self.willTopicEdit.text(),
            "WillMessage": self.willMessageEdit.toPlainText(),
            "WillQos": self.willQosSpinBox.value(),
            "WillRetain": self.willRetainCheckBox.isChecked(),
        }
    
    @pyqtSlot(str)
    def on_clientIdEdit_textChanged(self, clientId):
        """
        Private slot handling a change of the client ID string.
        
        @param clientId client ID
        @type str
        """
        self.__updateOkButton()
    
    @pyqtSlot(bool)
    def on_cleanSessionCheckBox_clicked(self, checked):
        """
        Private slot to handle a change of the clean session selection.
        
        @param checked current state of the clean session selection
        @type bool
        """
        self.__updateOkButton()