OvhPs2/GuiManagement.py

from PySide2.QtWidgets import QMainWindow, QApplication, QDialog
from PySide2.QtCore import QAbstractListModel, QAbstractTableModel, Qt, Slot

from MainApplication import Ui_MainWindow
from UserDialog import Ui_userDialog

import ovh_api

# Abstract models
class UserModel(QAbstractListModel):
    def __init__(self, users=[]):
        super().__init__()
        self.users = users
    
    def data(self, index, role):
        if role == Qt.DisplayRole:
            return self.users[index.row()][1]
    
    def rowCount(self, index):
        return len(self.users)

class InstanceModel(QAbstractTableModel):
    def __init__(self, instances=[]):
        super().__init__()
        self.instances = instances
        self.instances.sort(key=lambda e: e[1])

    def data(self, index, role):
        if role == Qt.DisplayRole:
             # we don't show id's, so +1
            return self.instances[index.row()][index.column() + 1]
    
    def rowCount(self, index):
        return len(self.instances)
    
    def columnCount(self, index):
        # we don't show id's, so -1
        if len(self.instances):
            return len(self.instances[0]) - 1
        return 0
    
    def headerData(self, section, orientation, role):
        headers = ['Nom', 'Adresse', 'Région', 'Statut']
        if role == Qt.DisplayRole and orientation == Qt.Horizontal:
            return headers[section]
    
# UI Classes
class UserDialog(QDialog, Ui_userDialog):
    """ A dialog to add and edit users"""
    def __init__(self, user=None):
        super().__init__()
        self.setupUi(self)
        if user:
            self.keyid= user[0]
            self.username = user[1]
            self.publickey = user[2]
            self.name.setText(self.username)
            self.key.setPlainText(self.publickey)
    
    @Slot()
    def accept(self):
        QApplication.setOverrideCursor(Qt.WaitCursor)
        if self.windowTitle() == 'Ajout':
            ovh_api.add_user(self.name.text(), self.key.toPlainText())
        else:
            if self.username != self.name.text() or self.publickey != self.key.toPlainText():
                ovh_api.delete_user(self.keyid)
                ovh_api.add_user(self.name.text(), self.key.toPlainText())
        QApplication.restoreOverrideCursor()
        super().accept()




class MainWindow(QMainWindow, Ui_MainWindow):
    """ The main window"""
    def __init__(self, *args, obj=None, **kwargs):
        super(MainWindow, self).__init__(*args, **kwargs)
        self.setupUi(self)
        
        users = ovh_api.get_users()
        self.user_model = UserModel(users=users)
        self.userView.setModel(self.user_model)
        self.userView.selectionModel().selectionChanged.connect(self.change_user_selection)
        self.addButton.pressed.connect(self.add_user)
        self.deleteButton.pressed.connect(self.delete_user)
        self.editButton.pressed.connect(self.edit_user)
        
        self.instanciateButton.pressed.connect(self.instanciate)
        self.regionCombo.addItems(ovh_api.regions)
        instances = ovh_api.get_instances()
        self.instance_model = InstanceModel(instances=instances)
        self.instanceView.setModel(self.instance_model)
        self.instanceView.selectionModel().selectionChanged.connect(self.change_instance_selection)
        self.instanceView.setSelectionBehavior(self.instanceView.SelectRows)
        self.destroyButton.pressed.connect(self.destroy_instance)
        self.refreshButton.pressed.connect(self.refresh_instances)

        self.show()

    # Instances management methods
    @Slot()
    def instanciate(self):
        region = self.regionCombo.currentText()
        selected_idx = self.userView.selectedIndexes()
        QApplication.setOverrideCursor(Qt.WaitCursor)
        for usr_idx in selected_idx:
            row = usr_idx.row()
            user = self.user_model.users[row]
            user_id = user[0]
            username = user[1]
            ovh_api.create_instance(user_id, username, region)
        self.refresh_instances()
        QApplication.restoreOverrideCursor()

    @Slot()
    def change_instance_selection(self):
        selected_rows = self.instanceView.selectionModel().selectedRows()
        destroy_active = True if selected_rows else False
        self.destroyButton.setEnabled(destroy_active)

    @Slot()
    def destroy_instance(self):
        QApplication.setOverrideCursor(Qt.WaitCursor)
        selected_rows = self.instanceView.selectionModel().selectedRows()
        for idx in selected_rows:
            row = idx.row()
            instance_id = self.instance_model.instances[row][0]
            ovh_api.delete_instance(instance_id)
        self.refresh_instances()
        QApplication.restoreOverrideCursor()
        
    @Slot()
    def refresh_instances(self):
        QApplication.setOverrideCursor(Qt.WaitCursor)
        self.instance_model.instances = ovh_api.get_instances()
        # sorting by name
        self.instance_model.instances.sort(key=lambda e: e[1])
        self.instance_model.layoutChanged.emit()
        QApplication.restoreOverrideCursor()


    # Users management methods
    @Slot()
    def change_user_selection(self):
        del_active = False
        edit_active = False
        instanciate_active = False
        sel_idxes = self.userView.selectedIndexes()
        if sel_idxes:
            del_active = True
            instanciate_active = True
            if len(sel_idxes) == 1:
                edit_active = True

        self.deleteButton.setEnabled(del_active)
        self.editButton.setEnabled(edit_active)
        self.instanciateButton.setEnabled(instanciate_active)

    @Slot()
    def add_user(self):
        dlg = UserDialog()
        dlg.setWindowTitle('Ajout')
        if dlg.exec_():
            self.refresh_users()

    @Slot()
    def edit_user(self):
        usr_idx = self.userView.selectedIndexes()[0]
        row = usr_idx.row()
        user = self.user_model.users[row]
        dlg = UserDialog(user)
        dlg.setWindowTitle('Modification')
        if dlg.exec_():
            self.refresh_users()

    @Slot()
    def delete_user(self):
        # TODO : confirmation
        selected_idx = self.userView.selectedIndexes()
        QApplication.setOverrideCursor(Qt.WaitCursor)
        for usr_idx in selected_idx:
            row = usr_idx.row()
            user_id = self.user_model.users[row][0]
            res = ovh_api.delete_user(user_id)
            print(res)
        self.refresh_users()
        QApplication.restoreOverrideCursor()

    def refresh_users(self):
        self.user_model.users = ovh_api.get_users()
        self.user_model.layoutChanged.emit()
        self.userView.clearSelection()


app = QApplication([])
window = MainWindow()
app.exec_()