ProjectFlask/FlaskMigrateExtension/MigrateProjectExtension.py

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

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

"""
Module implementing the project support for flask-migrate.
"""

import os
import glob

from PyQt5.QtCore import pyqtSlot, QObject, QProcess
from PyQt5.QtWidgets import QMenu, QDialog, QInputDialog, QLineEdit

from E5Gui import E5MessageBox
from E5Gui.E5Application import e5App
from E5Gui.E5Action import E5Action

import Utilities

from ..FlaskCommandDialog import FlaskCommandDialog


# TODO: add a submenu with action for the commands with command options
# TODO: add a submenu to show the created SQL commands (--sql option)
class MigrateProject(QObject):
    """
    Class implementing the flask-migrate project support.
    """
    def __init__(self, plugin, project, parent=None):
        """
        Constructor
        
        @param plugin reference to the plugin object
        @type ProjectFlaskPlugin
        @param project reference to the project object
        @type Project
        @param parent parent
        @type QObject
        """
        super(MigrateProject, self).__init__(parent)
        
        self.__plugin = plugin
        self.__project = project
        
        self.__e5project = e5App().getObject("Project")
    
    def initActions(self):
        """
        Public method to define the flask-migrate actions.
        """
        self.actions = []
        
        self.migrateConfigAct = E5Action(
            self.tr('Configure Migrate'),
            self.tr('&Configure Migrate'),
            0, 0,
            self, 'flask_config_migrate')
        self.migrateConfigAct.setStatusTip(self.tr(
            'Shows a dialog to edit the configuration for flask-migrate'))
        self.migrateConfigAct.setWhatsThis(self.tr(
            """<b>Configure Migrate</b>"""
            """<p>Shows a dialog to edit the configuration for"""
            """ flask-migrate.</p>"""
        ))
        self.migrateConfigAct.triggered.connect(
            self.__configureMigrate)
        self.actions.append(self.migrateConfigAct)
        
        self.migrateInstallAct = E5Action(
            self.tr('Install flask-migrate'),
            self.tr('&Install flask-migrate'),
            0, 0,
            self, 'flask_install_migrate')
        self.migrateInstallAct.setStatusTip(self.tr(
            'Installs the flask-migrate extension into the configured'
            ' environment'))
        self.migrateInstallAct.setWhatsThis(self.tr(
            """<b>Install flask-migrate</b>"""
            """<p>Installs the flask-migrate extension into the configured"""
            """ environment using the pip interface.</p>"""
        ))
        self.migrateInstallAct.triggered.connect(
            self.__installFlaskMigrate)
        self.actions.append(self.migrateInstallAct)
        
        self.migrateAvailabilityAct = E5Action(
            self.tr('Check flask-migrate Availability'),
            self.tr('Check flask-migrate &Availability'),
            0, 0,
            self, 'flask_check_migrate')
        self.migrateAvailabilityAct.setStatusTip(self.tr(
            'Check the availability of the flask-migrate extension'))
        self.migrateAvailabilityAct.setWhatsThis(self.tr(
            """<b>Check flask-migrate Availability</b>"""
            """<p>Check the availability of the flask-migrate extension.</p>"""
        ))
        self.migrateAvailabilityAct.triggered.connect(
            self.__checkAvailability)
        self.actions.append(self.migrateAvailabilityAct)
        
        #########################################################
        ## action to initialize the database migration system
        #########################################################
        
        self.migrateInitAct = E5Action(
            self.tr('Initialize Migrations'),
            self.tr('&Initialize Migrations'),
            0, 0,
            self, 'flask_init_migrations')
        self.migrateInitAct.setStatusTip(self.tr(
            'Initialize support for database migrations'))
        self.migrateInitAct.setWhatsThis(self.tr(
            """<b>Initialize Migrations</b>"""
            """<p>Initializes the support for database migrations to be"""
            """ stored in the configured migrations directory.</p>"""
        ))
        self.migrateInitAct.triggered.connect(
            self.__initMigrations)
        self.actions.append(self.migrateInitAct)
        
        #########################################################
        ## action to create a new database migration
        #########################################################
        
        self.migrateCreateAct = E5Action(
            self.tr('Create Migration'),
            self.tr('&Create Migration'),
            0, 0,
            self, 'flask_create_migration')
        self.migrateCreateAct.setStatusTip(self.tr(
            'Create a new migration for the current database'))
        self.migrateCreateAct.setWhatsThis(self.tr(
            """<b>Create Migration</b>"""
            """<p>Creates a new migration for the current database"""
            """ and stores it  in the configured migrations directory.</p>"""
        ))
        self.migrateCreateAct.triggered.connect(
            self.__createMigration)
        self.actions.append(self.migrateCreateAct)
        
        #########################################################
        ## action to up- and downgrade a databse
        #########################################################
        
        self.upgradeDatabaseAct = E5Action(
            self.tr('Upgrade Database'),
            self.tr('&Upgrade Database'),
            0, 0,
            self, 'flask_upgrade_database')
        self.upgradeDatabaseAct.setStatusTip(self.tr(
            'Upgrade the database to the current migration'))
        self.upgradeDatabaseAct.setWhatsThis(self.tr(
            """<b>Upgrade Database</b>"""
            """<p>Upgrades the database to the current migration.</p>"""
        ))
        self.upgradeDatabaseAct.triggered.connect(
            self.__upgradeDatabase)
        self.actions.append(self.upgradeDatabaseAct)
        
        # TODO: add action for flask db downgrade
        self.downgradeDatabaseAct = E5Action(
            self.tr('Downgrade Database'),
            self.tr('&Downgrade Database'),
            0, 0,
            self, 'flask_downgrade_database')
        self.downgradeDatabaseAct.setStatusTip(self.tr(
            'Downgrade the database to the previous version'))
        self.downgradeDatabaseAct.setWhatsThis(self.tr(
            """<b>Downgrade Database</b>"""
            """<p>Downgrades the database to the previous version.</p>"""
        ))
        self.downgradeDatabaseAct.triggered.connect(
            self.__downgradeDatabase)
        self.actions.append(self.downgradeDatabaseAct)
    
    def initMenu(self):
        """
        Public method to initialize the flask-migrate menu.
        
        @return the menu generated
        @rtype QMenu
        """
        menu = QMenu(self.tr("Database"))
        menu.setTearOffEnabled(True)
        
        menu.addAction(self.migrateConfigAct)
        menu.addSeparator()
        menu.addAction(self.migrateInitAct)
        menu.addSeparator()
        menu.addAction(self.migrateCreateAct)
        menu.addSeparator()
        menu.addAction(self.upgradeDatabaseAct)
        menu.addAction(self.downgradeDatabaseAct)
        menu.addSeparator()
        menu.addAction(self.migrateAvailabilityAct)
        menu.addAction(self.migrateInstallAct)
        
        return menu
    
    def determineCapability(self):
        """
        Public method to determine the availability of flask-migrate.
        """
        available = self.__flaskMigrateAvailable()
        self.__project.setCapability("migrate", available)
        
        self.migrateConfigAct.setEnabled(available)
        self.migrateInstallAct.setEnabled(not available)
        
        self.migrateInitAct.setEnabled(available)
    
    def __flaskMigrateAvailable(self):
        """
        Private method to check, if the 'flask-babel' package is available.
        
        @return flag indicating the availability of 'flask-babel'
        @rtype bool
        """
        interpreter = self.__project.getVirtualenvInterpreter()
        if interpreter and Utilities.isinpath(interpreter):
            detector = os.path.join(
                os.path.dirname(__file__), "FlaskMigrateDetector.py")
            proc = QProcess()
            proc.setProcessChannelMode(QProcess.MergedChannels)
            proc.start(interpreter, [detector])
            finished = proc.waitForFinished(30000)
            if finished and proc.exitCode() == 0:
                return True
        
        return False
    
    def __migrationsDirectory(self, abspath=False):
        """
        Private method to calculate the path of the configured migrations
        directory.
        
        @param abspath flag indicating to return an absolute path
        @type bool
        @return path of the migrations directory
        @rtype str
        """
        migrations = ""
        
        self.__ensureMigrateConfigured()
        
        migrations = self.__project.getData("migrate",
                                            "migrationsDirectory")
        if migrations:
            if abspath:
                migrations = self.__e5project.getAbsoluteUniversalPath(
                    migrations)
            else:
                workdir = self.__project.getApplication()[0]
                migrations = os.path.relpath(
                    self.__e5project.getAbsoluteUniversalPath(migrations),
                    workdir
                )
        else:
            if abspath:
                migrations = self.__e5project.getAbsoluteUniversalPath(
                    "migrations")
        
        return migrations
    
    ########################################################
    ## Menu related slots below
    ########################################################
    
    @pyqtSlot()
    def __configureMigrate(self):
        """
        Private slot to show a dialog to edit the migrate configuration.
        """
        from .MigrateConfigDialog import MigrateConfigDialog
        
        config = self.__project.getData("migrate", "")
        dlg = MigrateConfigDialog(config)
        if dlg.exec() == QDialog.Accepted:
            config = dlg.getConfiguration()
            self.__project.setData("migrate", "", config)
    
    def __ensureMigrateConfigured(self):
        """
        Private method to ensure, that flask-migrate has been configured.
        """
        config = self.__project.getData("migrate", "")
        if not config:
            self.__configureMigrate()
    
    @pyqtSlot()
    def __installFlaskMigrate(self):
        """
        Private slot to install the flask-migrate extension into the configured
        environment.
        """
        language = e5App().getObject("Project").getProjectLanguage()
        if language == "Python3":
            venvName = self.__plugin.getPreferences(
                "VirtualEnvironmentNamePy3")
        else:
            venvName = ""
        if venvName:
            interpreter = self.__project.getFullCommand("python")
            pip = e5App().getObject("Pip")
            pip.installPackages(["flask-migrate"], interpreter=interpreter)
            self.determineCapability()
        else:
            E5MessageBox.critical(
                None,
                self.tr("Install flask-migrate"),
                self.tr("The 'flask-migrate' extension could not be installed"
                        " because no virtual environment has been"
                        " configured."))
    
    @pyqtSlot()
    def __checkAvailability(self):
        """
        Private slot to check the availability of the 'flask-babel' extension.
        """
        self.determineCapability()
        if self.__project.hasCapability("migrate"):
            msg = self.tr("The 'flask-migrate' extension is installed.")
        else:
            msg = self.tr("The 'flask-migrate' extension is not installed.")
        E5MessageBox.information(
            None,
            self.tr("flask-migrate Availability"),
            msg)
    
    #########################################################
    ## slot to initialize the database migration system
    #########################################################
    
    @pyqtSlot()
    def __initMigrations(self):
        """
        Private slot to initialize the database migration system.
        """
        title = self.tr("Initialize Migrations")
        
        self.__ensureMigrateConfigured()
        migrations = self.__migrationsDirectory()
        
        args = ["init"]
        if migrations:
            args += ["--directory", migrations]
        
        multidb = E5MessageBox.yesNo(
            None,
            self.tr("Multiple Databases"),
            self.tr("""Shall the support for multiple databases be"""
                    """ activated?"""))
        if multidb:
            args.append("--multidb")
        
        dlg = FlaskCommandDialog(
            self.__project, title=title,
            msgSuccess=self.tr("\nMigrations initialized successfully.")
        )
        if dlg.startCommand("db", args):
            dlg.exec()
            if dlg.normalExit():
                for root, _dirs, files in os.walk(
                    self.__migrationsDirectory(abspath=True)
                ):
                    for fileName in files:
                        fullName = os.path.join(root, fileName)
                        self.__e5project.appendFile(fullName)
                
                browser = (e5App().getObject("ProjectBrowser")
                           .getProjectBrowser("others"))
                alembic = os.path.join(
                    self.__migrationsDirectory(abspath=True),
                    "alembic.ini"
                )
                browser.sourceFile.emit(alembic)
    
    #########################################################
    ## slot to create a new database migration
    #########################################################
    
    @pyqtSlot()
    def __createMigration(self):
        """
        Private slot to create a new database migration.
        """
        title = self.tr("Create Migration")
        
        self.__ensureMigrateConfigured()
        migrations = self.__migrationsDirectory()
        
        message, ok = QInputDialog.getText(
            None,
            title,
            self.tr("Enter a short message for the migration:"),
            QLineEdit.Normal)
        if ok:
            args = ["migrate"]
            if migrations:
                args += ["--directory", migrations]
            if message:
                args += ["--message", message]
            
            dlg = FlaskCommandDialog(
                self.__project, title=title,
                msgSuccess=self.tr("\nMigration created successfully.")
            )
            if dlg.startCommand("db", args):
                dlg.exec()
                if dlg.normalExit():
                    versionsPattern = os.path.join(
                        self.__migrationsDirectory(abspath=True),
                        "versions", "*.py")
                    for fileName in glob.iglob(versionsPattern):
                        self.__e5project.appendFile(fileName)
    
    #########################################################
    ## slots to up- and downgrade a databse
    #########################################################
    
    @pyqtSlot()
    def __upgradeDatabase(self):
        """
        Private slot to upgrade the database to the current migration.
        """
        title = self.tr("Upgrade Database")
        
        self.__ensureMigrateConfigured()
        migrations = self.__migrationsDirectory()
        
        args = ["upgrade"]
        if migrations:
            args += ["--directory", migrations]
        
        dlg = FlaskCommandDialog(
            self.__project, title=title,
            msgSuccess=self.tr("\nDatabase upgraded successfully.")
        )
        if dlg.startCommand("db", args):
            dlg.exec()
    
    @pyqtSlot()
    def __downgradeDatabase(self):
        """
        Private slot to downgrade the database to the previous version.
        """
        title = self.tr("downgrade Database")
        
        self.__ensureMigrateConfigured()
        migrations = self.__migrationsDirectory()
        
        args = ["downgrade"]
        if migrations:
            args += ["--directory", migrations]
        
        dlg = FlaskCommandDialog(
            self.__project, title=title,
            msgSuccess=self.tr("\nDatabase downgraded successfully.")
        )
        if dlg.startCommand("db", args):
            dlg.exec()