src/eric7/UI/InstallInfoDialog.py

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

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

"""
Module implementing a dialog to show information about the installation.
"""

import json
import os

from PyQt6.QtCore import pyqtSlot
from PyQt6.QtWidgets import QDialog, QDialogButtonBox

from eric7.EricWidgets import EricMessageBox

from .Ui_InstallInfoDialog import Ui_InstallInfoDialog

from eric7 import Globals
from eric7.EricGui import EricPixmapCache


class InstallInfoDialog(QDialog, Ui_InstallInfoDialog):
    """
    Class implementing a dialog to show information about the installation.
    """

    def __init__(self, parent=None):
        """
        Constructor

        @param parent reference to the parent widget
        @type QWidget
        """
        super().__init__(parent)
        self.setupUi(self)

        self.__deleteButton = self.buttonBox.addButton(
            self.tr("Delete Info"), QDialogButtonBox.ButtonRole.ActionRole
        )
        self.__deleteButton.clicked.connect(self.on_deleteButton_clicked)
        self.__updateButton = self.buttonBox.addButton(
            self.tr("Upgrade Instructions"), QDialogButtonBox.ButtonRole.ActionRole
        )
        self.__updateButton.clicked.connect(self.on_updateButton_clicked)

        self.__edited = False
        self.__loaded = True

        self.editButton.setIcon(EricPixmapCache.getIcon("infoEdit"))
        self.saveButton.setIcon(EricPixmapCache.getIcon("fileSave"))

        infoFileName = Globals.getInstallInfoFilePath()

        self.__deleteButton.setEnabled(os.path.exists(infoFileName))

        try:
            with open(infoFileName, "r") as infoFile:
                self.__info = json.load(infoFile)

            if Globals.isWindowsPlatform():
                self.sudoLabel1.setText(self.tr("Installed as Administrator:"))
            else:
                self.sudoLabel1.setText(self.tr("Installed with sudo:"))
            self.sudoLabel2.setText(
                self.tr("Yes") if self.__info["sudo"] else self.tr("No")
            )
            self.userLabel.setText(self.__info["user"])
            self.installedFromEdit.setText(self.__info["install_cwd"])
            self.interpreteEdit.setText(self.__info["exe"])
            self.commandEdit.setText(self.__info["argv"])
            self.installPathEdit.setText(self.__info["eric"])
            self.virtenvLabel.setText(
                self.tr("Yes") if self.__info["virtualenv"] else self.tr("No")
            )
            self.remarksEdit.setPlainText(self.__info["remarks"])
            if self.__info["pip"]:
                self.pipLabel.setText(
                    self.tr(
                        "'eric-ide' was installed from PyPI using the pip" " command."
                    )
                )
            else:
                self.pipLabel.hide()
            if self.__info["guessed"]:
                self.guessLabel.setText(
                    self.tr(
                        "The information shown in this dialog was guessed at"
                        " the first start of eric."
                    )
                )
            else:
                self.guessLabel.hide()
            if self.__info["edited"]:
                self.userProvidedLabel.setText(
                    self.tr("The installation information was provided by the user.")
                )
            else:
                self.userProvidedLabel.hide()
            if self.__info["installed_on"]:
                self.installDateTimeLabel.setText(
                    self.__info["installed_on"]
                    if self.__info["installed_on"]
                    else self.tr("unknown")
                )

            self.__updateButton.setEnabled(bool(self.__info["exe"]))
        except OSError as err:
            EricMessageBox.critical(
                self,
                self.tr("Load Install Information"),
                self.tr(
                    "<p>The file containing the install information could"
                    " not be read.</p><p>Reason: {0}</p>"
                    ""
                ).format(str(err)),
            )
            self.__loaded = False
            self.__info = {}

            self.__updateButton.setEnabled(False)

    def wasLoaded(self):
        """
        Public method to check, if the install data was loaded.

        @return flag indicating the data was loaded
        @rtype bool
        """
        return self.__loaded

    @pyqtSlot(bool)
    def on_editButton_toggled(self, checked):
        """
        Private slot to switch the dialog into edit mode.

        @param checked flag giving the button check state
        @type bool
        """
        self.installedFromEdit.setReadOnly(not checked)
        self.interpreteEdit.setReadOnly(not checked)
        self.commandEdit.setReadOnly(not checked)
        self.installPathEdit.setReadOnly(not checked)
        self.remarksEdit.setReadOnly(not checked)

        if checked:
            self.__edited = True

    @pyqtSlot()
    def on_saveButton_clicked(self):
        """
        Private slot handling the save button press.
        """
        if self.__edited:
            self.__saveData()

    @pyqtSlot()
    def reject(self):
        """
        Public slot handling the closing of the dialog.
        """
        if self.__edited:
            yes = EricMessageBox.yesNo(
                self,
                self.tr("Install Information"),
                self.tr(
                    """The install information was edited. Unsaved"""
                    """ changes will be lost. Save first?"""
                ),
                yesDefault=True,
            )
            if yes:
                self.__saveData()

        super().reject()

    def __saveData(self):
        """
        Private method to save the data.
        """
        if self.installedFromEdit.text() != self.__info["install_cwd"]:
            self.__info["install_cwd"] = self.installedFromEdit.text()
            self.__info["install_cwd_edited"] = True
        if self.interpreteEdit.text() != self.__info["exe"]:
            self.__info["exe"] = self.interpreteEdit.text()
            self.__info["exe_edited"] = True
        if self.commandEdit.text() != self.__info["argv"]:
            self.__info["argv"] = self.commandEdit.text()
            self.__info["argv_edited"] = True
        if self.installPathEdit.text() != self.__info["eric"]:
            self.__info["eric"] = self.installPathEdit.text()
            self.__info["eric_edited"] = True
        self.__info["remarks"] = self.remarksEdit.toPlainText()
        self.__info["edited"] = True

        infoFileName = Globals.getInstallInfoFilePath()
        try:
            with open(infoFileName, "w") as infoFile:
                json.dump(self.__info, infoFile, indent=2)
            self.__edited = False
            self.editButton.setChecked(False)
        except OSError as err:
            EricMessageBox.critical(
                self,
                self.tr("Save Install Information"),
                self.tr(
                    "<p>The file containing the install information could"
                    " not be written.</p><p>Reason: {0}</p>"
                    ""
                ).format(str(err)),
            )

    @pyqtSlot()
    def on_deleteButton_clicked(self):
        """
        Private slot deleting the install information file.
        """
        res = EricMessageBox.yesNo(
            self,
            self.tr("Delete Installation Information"),
            self.tr(
                """Do you really want to delete the installation"""
                """ information? It will be recreated at the next"""
                """ start."""
            ),
        )
        if not res:
            return

        infoFileName = Globals.getInstallInfoFilePath()
        os.remove(infoFileName)

        # local data will be deleted automatically
        self.__edited = False

        self.close()

    @pyqtSlot()
    def on_updateButton_clicked(self):
        """
        Private slot to show some upgrade instructions.
        """
        updateTextList = []
        cmdPrefix = ""

        if self.__info["sudo"]:
            if Globals.isWindowsPlatform():
                updateTextList.append(
                    self.tr(
                        "Perform the following step(s) with Administrator"
                        " privileges.\n"
                    )
                )
            else:
                cmdPrefix = "sudo "

        if self.__info["pip"]:
            updateTextList.append(
                "{0}{1} -m pip install --upgrade eric-ide".format(
                    cmdPrefix,
                    self.__info["exe"],
                )
            )
        else:
            if "install_cwd" in self.__info and bool(self.__info["install_cwd"]):
                updateTextList.append("cd {0}".format(self.__info["install_cwd"]))
            updateTextList.append(
                "{0}{1} {2}".format(
                    cmdPrefix,
                    self.__info["exe"],
                    self.__info["argv"],
                )
            )

        from eric7.EricWidgets.EricPlainTextDialog import EricPlainTextDialog

        dlg = EricPlainTextDialog(
            title=self.tr("Upgrade Instructions"), text="\n".join(updateTextList)
        )
        dlg.exec()