class ImportMovementPanel(PanelWithTable):

    columnList = ReportMovementPanel.columnList

    def __init__(self):
        super(self.__class__, self).__init__()
        self.layout = QtGui.QGridLayout(self)
        self.importMovementFilter = ImportMovementFilter(self)
        self.layout.addWidget(self.importMovementFilter, 1, 0,
                              QtCore.Qt.AlignTop)
        self.layout.addWidget(self.createTable(), 1, 1, QtCore.Qt.AlignTop)
        self.btnImport = QPushButton("Import", self)
        self.btnImport.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        self.layout.addWidget(self.btnImport)
        self.btnDelete = QPushButton("Delete", self)
        self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        self.layout.addWidget(self.btnDelete)
        self.initListener()

    def initListener(self):
        self.btnImport.clicked.connect(self.doImport)
        self.btnDelete.clicked.connect(self.doDelete)

    def createTable(self):
        self.table = QTableWidget()
        self.table.setRowCount(1000)
        self.table.setColumnCount(len(self.columnList) + 1)
        self.table.setColumnHidden(
            Constant.CONST_COLUMN_IMPORT_MOVEMENT_HIDDEN_ID, True)
        self.table.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
        self.table.setHorizontalHeaderLabels(self.columnList)
        #self.pnLTableWidget.resizeColumnsToContents()
        self.table.sortItems(Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DATE)
        self.table.doubleClicked.connect(self.doImportOrDelete)
        self.table.resizeRowsToContents()
        self.table.setFixedSize(1100, 900)
        return self.table

    def doSubmit(self, filePath, assetName):
        self.imLO = MovementImporter().getMovementList(filePath, assetName)
        self.table.setSortingEnabled(False)
        self.table.clearContents()
        if (self.imLO.movementList is not None):
            countRowTable = len(self.imLO.movementList)
            self.table.setRowCount(countRowTable)
            self.renderTableForObject(self.imLO.movementList)
            imLO2 = Engine.getReportMovementList(self.imLO.fromDate,
                                                 self.imLO.toDate, 'ALL',
                                                 assetName,
                                                 self.imLO.custodyName)
            countRowTable += len(imLO2.movementList)
            self.table.setRowCount(countRowTable)
            self.renderTableForRS(imLO2.movementList)
            self.table.setSortingEnabled(True)
            self.table.resizeRowsToContents()

    def renderTableForObject(self, tableList):
        self.row = 0
        isBold = False
        color = QtGui.QColor(204, 255, 153)
        for movement in tableList:
            self.addItemtoTable2(
                self.table, movement.OID, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_ID, isBold, color)
            self.addItemtoTable2(
                self.table, movement.externalID, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_EXTERNAL_ID, isBold,
                color)
            self.addItemtoTable2(self.table, movement.comment, self.row,
                                 Constant.CONST_COLUMN_IMPORT_MOVEMENT_COMMENT,
                                 isBold, color)
            self.addItemtoTable2(
                self.table, movement.custody.name, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_CUSTODY_NAME, isBold,
                color)
            self.addItemtoTable2(
                self.table, movement.getMovementType(), self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_TYPE, isBold,
                color)
            self.addItemtoTable2(
                self.table, movement.getMovementSubType(), self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_SUB_TYPE, isBold,
                color)
            if (movement.asset is not None):
                self.addItemtoTable2(
                    self.table, movement.asset.name, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_ASSET_NAME, isBold,
                    color)
            if (movement.tax is not None):
                self.addItemtoTable2(
                    self.table, "NEW", self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_TAX_ID, isBold,
                    color)
                self.addItemtoTable2(
                    self.table, movement.tax.taxAmount, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_TAX_AMOUNT, isBold,
                    color)
            if (isinstance(movement, Movement)):
                self.addItemtoTable2(
                    self.table, movement.buySell, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DIRECTION,
                    isBold, color)
                self.addItemtoTable2(
                    self.table, movement.acquisitionDate, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DATE, isBold,
                    color)
                self.addItemtoTable2(
                    self.table, movement.quantity, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_QUANTITY, isBold,
                    color)
                self.addItemtoTable2(
                    self.table, movement.price, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_PRICE, isBold, color)
                self.addItemtoTable2(
                    self.table, movement.rate, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_RATE, isBold, color)
                self.addItemtoTable2(
                    self.table, movement.grossAmount, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_GROSS_AMOUNT, isBold,
                    color)
                self.addItemtoTable2(
                    self.table, movement.netAmount, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_NET_AMOUNT, isBold,
                    color)
                self.addItemtoTable2(
                    self.table, movement.commissionPercentage, self.row,
                    Constant.
                    CONST_COLUMN_IMPORT_MOVEMENT_COMMISSION_PERCENTAGE, isBold,
                    color)
                self.addItemtoTable2(
                    self.table, movement.commissionAmount, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_COMMISSION_AMOUNT,
                    isBold, color)
                self.addItemtoTable2(
                    self.table, movement.commissionVATAmount, self.row,
                    Constant.
                    CONST_COLUMN_IMPORT_MOVEMENT_COMMISSION_IVA_AMOUNT, isBold,
                    color)
                self.addItemtoTable2(
                    self.table, movement.tenor, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_TENOR, isBold, color)
                self.addItemtoTable2(
                    self.table, movement.maturityDate, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_MATURITY_DATE,
                    isBold, color)
            elif (isinstance(movement, CorporateEvent)):
                self.addItemtoTable2(
                    self.table, movement.paymentDate, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DATE, isBold,
                    color)
                self.addItemtoTable2(
                    self.table, movement.grossAmount, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_GROSS_AMOUNT, isBold,
                    color)
                self.addItemtoTable2(
                    self.table, movement.netAmount, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_NET_AMOUNT, isBold,
                    color)
            elif (isinstance(movement, CashMovement)):
                self.addItemtoTable2(
                    self.table, movement.inOut, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DIRECTION,
                    isBold, color)
                self.addItemtoTable2(
                    self.table, movement.movementDate, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DATE, isBold,
                    color)
                self.addItemtoTable2(
                    self.table, movement.amount, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_GROSS_AMOUNT, isBold,
                    color)
                self.addItemtoTable2(
                    self.table, movement.amount, self.row,
                    Constant.CONST_COLUMN_IMPORT_MOVEMENT_NET_AMOUNT, isBold,
                    color)
            #HiddenID
            self.addItemtoTable2(
                self.table, self.row, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_HIDDEN_ID, isBold)
            self.row += 1

    def renderTableForRS(self, tableList):
        isBold = False
        for listItem in tableList:
            self.addItemtoTable(self.table, listItem, self.row,
                                Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_ID,
                                isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_TYPE, isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_SUB_TYPE, isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DIRECTION, isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_ASSET_NAME, isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DATE, isBold)
            self.addItemtoTable(self.table, listItem, self.row,
                                Constant.CONST_COLUMN_IMPORT_MOVEMENT_QUANTITY,
                                isBold)
            self.addItemtoTable(self.table, listItem, self.row,
                                Constant.CONST_COLUMN_IMPORT_MOVEMENT_PRICE,
                                isBold)
            self.addItemtoTable(self.table, listItem, self.row,
                                Constant.CONST_COLUMN_IMPORT_MOVEMENT_RATE,
                                isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_GROSS_AMOUNT, isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_NET_AMOUNT, isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_COMMISSION_PERCENTAGE,
                isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_COMMISSION_AMOUNT,
                isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_COMMISSION_IVA_AMOUNT,
                isBold)
            self.addItemtoTable(self.table, listItem, self.row,
                                Constant.CONST_COLUMN_IMPORT_MOVEMENT_TENOR,
                                isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_MATURITY_DATE, isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_CUSTODY_NAME, isBold)
            self.addItemtoTable(self.table, listItem, self.row,
                                Constant.CONST_COLUMN_IMPORT_MOVEMENT_TAX_ID,
                                isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_TAX_AMOUNT, isBold)
            self.addItemtoTable(self.table, listItem, self.row,
                                Constant.CONST_COLUMN_IMPORT_MOVEMENT_COMMENT,
                                isBold)
            self.addItemtoTable(
                self.table, listItem, self.row,
                Constant.CONST_COLUMN_IMPORT_MOVEMENT_EXTERNAL_ID, isBold)
            self.row += 1

    def doImportOrDelete(self):
        index = self.getCurrentRowValue(
            Constant.CONST_COLUMN_IMPORT_MOVEMENT_HIDDEN_ID)
        if (index is not None):
            self.doImport()
        else:
            self.doDelete()

    def doImport(self):
        index = self.getCurrentRowValue(
            Constant.CONST_COLUMN_IMPORT_MOVEMENT_HIDDEN_ID)
        if (index is not None):
            operation = self.imLO.movementList[int(index)]
            print(operation.externalID)
            newID = None
            taxNewID = None
            if (isinstance(operation, Movement)):
                rs = DaoMovement.getMovementsByExternalID(operation.externalID)
                if len(rs) == 0:
                    if (operation.OID == "NEW"):
                        newID = DaoMovement.insertMovement(operation)
                if (operation.tax is not None and operation.tax.OID == "NEW"):
                    rs = DaoTax.getTaxByExternalID(operation.tax.externalID)
                    if len(rs) == 0:
                        taxNewID = DaoTax.insert(operation.tax)
            elif (isinstance(operation, CorporateEvent)):
                rs = DaoCorporateEvent.getCorporateEventByExternalID(
                    operation.externalID)
                if len(rs) == 0:
                    newID = DaoCorporateEvent.insert(operation)
                    print(newID)
                    if (operation.tax is not None):
                        rs = DaoTax.getTaxByExternalID(
                            operation.tax.externalID)
                        if len(rs) == 0:
                            operation.tax.originOID = newID
                            taxNewID = DaoTax.insert(operation.tax)
            elif (isinstance(operation, CashMovement)):
                rs = DaoCashMovement.getCashMovementsByExternalID(
                    operation.externalID)
                if len(rs) == 0:
                    newID = DaoCashMovement.insert(operation)
            box = QMessageBox()
            box.setWindowTitle('ADD')
            if (newID is None and taxNewID is None):
                box.setText("CANNOT ADD externalID " + operation.externalID)
            else:
                if (newID is not None and taxNewID is not None):
                    box.setText("INSERTED MOVEMENT " + operation.externalID +
                                " NEWID: " + str(newID) + " NEWTAXID: " +
                                str(taxNewID))
                elif (newID is not None and taxNewID is None):
                    box.setText("INSERTED MOVEMENT " + operation.externalID +
                                " NEWID: " + str(newID))
                else:
                    box.setText("INSERTED TAX " + operation.tax.externalID +
                                " NEWTAXID: " + str(taxNewID))
            box.exec_()

    def doDelete(self):
        movementOID = self.getCurrentRowValue(
            Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_ID)
        movementType = self.getCurrentRowValue(
            Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_TYPE)
        movementSubType = self.getCurrentRowValue(
            Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_SUB_TYPE)
        taxOID = self.getCurrentRowValue(
            Constant.CONST_COLUMN_IMPORT_MOVEMENT_TAX_ID)
        result = 0
        if (movementType == Constant.CONST_MOVEMENT_TYPE
                and movementSubType == Constant.CONST_MOVEMENT_SUB_TYPE):
            result = DaoMovement.deleteMovement(movementOID)
            print(result)
        elif (movementType == Constant.CONST_MOVEMENT_TYPE
              and movementSubType == Constant.CONST_CASH_MOVEMENT_SUB_TYPE):
            result = DaoCashMovement.deleteCashMovement(movementOID)
            print(result)
        elif (movementType == Constant.CONST_CORP_EVENT_TYPE
              and movementSubType == Constant.CONST_CORP_EVENT_SUB_TYPE):
            if (taxOID):
                taxResult = DaoTax.deleteTax(taxOID)
            result = DaoCorporateEvent.deleteCorporateEvent(movementOID)
            print(result)
        box = QMessageBox()
        box.setWindowTitle('DELETED')
        if (result == 0):
            box.setText("CANNOT DELETE " + movementType + "-" +
                        movementSubType + "-" + movementOID)
        else:
            if (taxOID is None or taxOID == ""):
                box.setText(movementType + "-" + movementSubType + "-" +
                            movementOID + ": " + str(result) +
                            " record(s) deleted")
            else:
                box.setText(movementType + "-" + movementSubType + "-" +
                            movementOID + ": " + str(result) +
                            " record(s) deleted and taxID: " + taxOID + " " +
                            str(taxResult) + " record(s) deleted")
        box.exec_()
Esempio n. 2
0
class NotificationTab():
    """ui class for new notification tab"""
    global logger

    def __init__(self):
        #####
        logger.info('Inside PurchaseSchedule')
        self.notificationTab_tab_4 = QWidget()
        self.notificationTab_tab_4.setObjectName("notificationTab_tab_4")
        self.gridLayout_19 = QGridLayout(self.notificationTab_tab_4)
        self.gridLayout_19.setObjectName("gridLayout_19")
        ##
        self.horizontalLayout = QHBoxLayout()
        self.horizontalLayout.setObjectName("horizontalLayout")
        self.title_label = QLabel(self.notificationTab_tab_4)
        self.title_label.setObjectName("title_label")
        self.horizontalLayout.addWidget(self.title_label)
        self.gridLayout_19.addLayout(self.horizontalLayout, 0, 0, 1, 1)
        ##
        self.horizontalLayout_6 = QHBoxLayout()
        self.horizontalLayout_6.setObjectName("horizontalLayout_6")
        self.id_label = QLabel(self.notificationTab_tab_4)
        self.id_label.setObjectName("id_label")
        self.horizontalLayout_6.addWidget(self.id_label)
        self.id_line = QLineEdit(self.notificationTab_tab_4)
        self.id_line.setObjectName("id_line")
        self.horizontalLayout_6.addWidget(self.id_line)
        self.notification_schedule_fromdate_label = QLabel(
            self.notificationTab_tab_4)
        self.notification_schedule_fromdate_label.setObjectName(
            "notification_schedule_fromdate_label")
        self.horizontalLayout_6.addWidget(
            self.notification_schedule_fromdate_label)
        self.notification_schedule_fromdate_dateedit = QDateEdit(
            self.notificationTab_tab_4)
        self.notification_schedule_fromdate_dateedit.setMaximumDate(
            QDate.currentDate())
        self.notification_schedule_fromdate_dateedit.setDate(
            QDate.currentDate())
        self.notification_schedule_fromdate_dateedit.setCalendarPopup(True)
        self.notification_schedule_fromdate_dateedit.setObjectName(
            "notification_schedule_fromdate_dateedit")
        self.horizontalLayout_6.addWidget(
            self.notification_schedule_fromdate_dateedit)
        self.notification_schedule_todate_label = QLabel(
            self.notificationTab_tab_4)
        self.notification_schedule_todate_label.setObjectName(
            "notification_schedule_todate_label")
        self.horizontalLayout_6.addWidget(
            self.notification_schedule_todate_label)
        self.notification_schedule_todate_dateedit = QDateEdit(
            self.notificationTab_tab_4)
        self.notification_schedule_todate_dateedit.setMaximumDate(
            QDate.currentDate())
        self.notification_schedule_todate_dateedit.setDate(QDate.currentDate())
        self.notification_schedule_todate_dateedit.setCalendarPopup(True)
        self.notification_schedule_todate_dateedit.setObjectName(
            "notification_schedule_todate_dateedit")
        self.horizontalLayout_6.addWidget(
            self.notification_schedule_todate_dateedit)
        self.type_label = QLabel(self.notificationTab_tab_4)
        self.type_label.setObjectName("type_label")
        self.horizontalLayout_6.addWidget(self.type_label)
        self.notification_states = QComboBox(self.notificationTab_tab_4)
        self.notification_states.setObjectName("notification_states")
        self.horizontalLayout_6.addWidget(self.notification_states)
        self.batch_label = QLabel(self.notificationTab_tab_4)
        self.batch_label.setObjectName("batch_label")
        self.horizontalLayout_6.addWidget(self.batch_label)
        self.notification_results = QComboBox(self.notificationTab_tab_4)
        self.notification_results.setObjectName("notification_results")
        self.horizontalLayout_6.addWidget(self.notification_results)
        self.gridLayout_19.addLayout(self.horizontalLayout_6, 1, 0, 1, 1)
        self.gridLayout_8 = QGridLayout()
        self.gridLayout_8.setObjectName("gridLayout_8")
        self.notification_schedule_table = QTableWidget(
            self.notificationTab_tab_4)
        self.notification_schedule_table.setObjectName(
            "notification_schedule_table")
        self.notification_schedule_table.setColumnCount(5)
        self.notification_schedule_table.setRowCount(0)
        self.notification_schedule_table.setWordWrap(True)
        item = QTableWidgetItem()
        self.notification_schedule_table.setHorizontalHeaderItem(0, item)
        item = QTableWidgetItem()
        self.notification_schedule_table.setHorizontalHeaderItem(1, item)
        item = QTableWidgetItem()
        self.notification_schedule_table.setHorizontalHeaderItem(2, item)
        item = QTableWidgetItem()
        self.notification_schedule_table.setHorizontalHeaderItem(3, item)
        item = QTableWidgetItem()
        self.notification_schedule_table.setHorizontalHeaderItem(4, item)
        self.notification_schedule_table.horizontalHeader(
        ).setCascadingSectionResizes(True)
        self.notification_schedule_table.horizontalHeader(
        ).setStretchLastSection(True)
        self.notification_schedule_table.verticalHeader().setVisible(False)
        self.notification_schedule_table.verticalHeader(
        ).setCascadingSectionResizes(True)
        self.notification_schedule_table.verticalHeader(
        ).setStretchLastSection(False)
        self.gridLayout_8.addWidget(self.notification_schedule_table, 0, 0, 1,
                                    5)
        self.notification_search_button = QPushButton(
            self.notificationTab_tab_4)
        self.notification_search_button.setObjectName(
            "notification_search_button")
        self.gridLayout_8.addWidget(self.notification_search_button, 1, 0, 1,
                                    1)
        spacerItem10 = QSpacerItem(40, 20, QSizePolicy.Expanding,
                                   QSizePolicy.Minimum)
        self.gridLayout_8.addItem(spacerItem10, 1, 2, 1, 1)
        self.notification_reset_button = QPushButton(
            self.notificationTab_tab_4)
        self.notification_reset_button.setObjectName(
            "notification_reset_button")
        self.gridLayout_8.addWidget(self.notification_reset_button, 1, 3, 1, 1)
        self.notification_load_more_button = QPushButton(
            self.notificationTab_tab_4)
        self.notification_load_more_button.setObjectName(
            "notification_load_more_button")
        self.gridLayout_8.addWidget(self.notification_load_more_button, 1, 4,
                                    1, 1)
        self.gridLayout_19.addLayout(self.gridLayout_8, 2, 0, 1, 1)
        ###retranslate
        self.title_label.setText(
            QApplication.translate(
                "MainWindow", "<html><head/><body><p align=\"center\">"
                "<span style=\" font-weight:600;font-size:20px\">"
                "<u>All Notifications</u></span></p></body></html>", None,
                QApplication.UnicodeUTF8))
        self.id_label.setText(
            QApplication.translate("MainWindow", "Message Id", None,
                                   QApplication.UnicodeUTF8))
        self.notification_schedule_fromdate_label.setText(
            QApplication.translate("MainWindow", "From Date", None,
                                   QApplication.UnicodeUTF8))
        self.notification_schedule_fromdate_dateedit.setDisplayFormat(
            QApplication.translate("MainWindow", "dd/MM/yyyy", None,
                                   QApplication.UnicodeUTF8))
        self.notification_schedule_todate_label.setText(
            QApplication.translate("MainWindow", "To Date", None,
                                   QApplication.UnicodeUTF8))
        self.notification_schedule_todate_dateedit.setDisplayFormat(
            QApplication.translate("MainWindow", "dd/MM/yyyy", None,
                                   QApplication.UnicodeUTF8))
        self.type_label.setText(
            QApplication.translate("MainWindow", "Type", None,
                                   QApplication.UnicodeUTF8))
        self.batch_label.setText(
            QApplication.translate("MainWindow", "Number of Notifications",
                                   None, QApplication.UnicodeUTF8))
        self.notification_schedule_table.horizontalHeaderItem(0).setText(
            QApplication.translate("MainWindow", "Message Id", None,
                                   QApplication.UnicodeUTF8))
        self.notification_schedule_table.horizontalHeaderItem(1).setText(
            QApplication.translate("MainWindow", "Date", None,
                                   QApplication.UnicodeUTF8))
        self.notification_schedule_table.horizontalHeaderItem(2).setText(
            QApplication.translate("MainWindow", "From", None,
                                   QApplication.UnicodeUTF8))
        self.notification_schedule_table.horizontalHeaderItem(3).setText(
            QApplication.translate("MainWindow", "Message", None,
                                   QApplication.UnicodeUTF8))
        self.notification_schedule_table.horizontalHeaderItem(4).setText(
            QApplication.translate("MainWindow", "State", None,
                                   QApplication.UnicodeUTF8))
        self.notification_search_button.setText(
            QApplication.translate("MainWindow", "Search", None,
                                   QApplication.UnicodeUTF8))
        self.notification_reset_button.setText(
            QApplication.translate("MainWindow", "Reset All", None,
                                   QApplication.UnicodeUTF8))
        self.notification_load_more_button.setText(
            QApplication.translate("MainWindow", "Load More", None,
                                   QApplication.UnicodeUTF8))
        ##signals and slotts && other stuffs
        self.scheduletable_count = 0
        self.addtable_count = 0
        # self.mainwindow = Ui_MainWindow  # just for the ease of finding the attributes in pycharm
        self.notification_schedule_table.setEditTriggers(
            QAbstractItemView.NoEditTriggers)
        self.batch_number = None
        self.notification_results.addItems([str(i) for i in range(1, 50, 5)])
        self.notification_states.addItems(['All', 'New', 'To Do', 'Done'])
        self.message = Messaging()
        self.notification_load_more_button.clicked.connect(self.load_more)
        self.notification_search_button.clicked.connect(self.search_messages)
        self.notification_reset_button.clicked.connect(self.reset_all)
        self.notificationTab_tab_4.setFocusPolicy(Qt.StrongFocus)
        self.notificationTab_tab_4.focusInEvent = self.load_rows
        # self.assign_shortcuts()

        # def assign_shortcuts(self):
        # QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_search']),
        # self.notificationTab_tab_4, self.search_messages)
        # QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_additem']),
        # self.notificationTab_tab_4, self.add_new_blank_rows)
        # QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_print']),
        # self.notificationTab_tab_4, self.commit_and_print)
        # QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_today']),
        # self.notificationTab_tab_4, lambda: self.load_messages('today'))
        # QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_tommorow']),
        # self.notificationTab_tab_4, lambda: self.load_messages('tomorrow'))
        # QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_thismonth']),
        # self.notificationTab_tab_4, lambda: self.load_messages('month'))
        # QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_thisweek']),
        # self.notificationTab_tab_4, lambda: self.load_messages('week'))
        # QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_clear']),
        # self.notificationTab_tab_4, self.clear_table)

    def add_messages(self, *args):
        """
        Populates the Schedules when we load the tab
        """
        table = self.notification_schedule_table
        if args:
            if args[0] != 'new':
                table.clearContents()
                table.setRowCount(0)
                table.setRowCount(len(args))
                for i, j in enumerate(args):
                    item = QTableWidgetItem(j['msg_id'])
                    table.setItem(i, 0, item)
                    item = QTableWidgetItem(j['date'])
                    table.setItem(i, 1, item)
                    item = QTableWidgetItem(
                        'Name:{}\nDesignation:{}\nAddress:{}'.format(
                            j['name'], j['designation'], j['address']))
                    table.setItem(i, 2, item)
                    item = QTableWidgetItem(
                        'Message Type:{}\nMessage:{}'.format(
                            j['msg_type'].title(), j['msg_body']))
                    table.setItem(i, 3, item)
                    states = QComboBox()
                    self.populate_states(states, j['msg_state'].title())
                    states.currentIndexChanged.connect(
                        lambda index, row=i: self.changed_state(row, index))
                    table.setCellWidget(i, 4, states)
            elif args[0] == 'new':
                initial = table.rowCount()
                row = table.rowCount() + len(args[1])
                table.setRowCount(row)
                forward_range = range(initial, row)
                for i, j in zip(forward_range, args[1]):
                    item = QTableWidgetItem(j['msg_id'])
                    table.setItem(i, 0, item)
                    item = QTableWidgetItem(j['date'])
                    table.setItem(i, 1, item)
                    item = QTableWidgetItem(
                        'Name:{}\nDesignation:{}\nAddress:{}'.format(
                            j['name'], j['designation'], j['address']))
                    table.setItem(i, 2, item)
                    item = QTableWidgetItem(
                        'Message Type:{}\nMessage:{}'.format(
                            j['msg_type'].title(), j['msg_body']))
                    table.setItem(i, 3, item)
                    states = QComboBox()
                    self.populate_states(states, j['msg_state'].title())
                    states.currentIndexChanged.connect(
                        lambda index, row=i: self.changed_state(row, index))
                    table.setCellWidget(i, 4, states)
        table.setColumnWidth(0, (table.width() * 0.5) / 5)
        table.setColumnWidth(1, (table.width() * 0.5) / 5)
        table.setColumnWidth(2, table.width() / 5)
        table.setColumnWidth(3, (table.width() * 2) / 5)
        self.notification_schedule_table.resizeRowsToContents()

    def populate_states(self, combo, state):
        """
        fills the supplier list for each item line
        :param combo: the combo box of suppliers
        :return:none
        """
        combo.setStyleSheet("QAbstractItemView{" "background: #4B77BE;" "}")
        combo.addItems(['New', 'To Do', 'Done'])
        index = combo.findText(state)
        combo.setCurrentIndex(index)

    def changed_state(self, row, index):
        """
        fill the item combo box
        :param combo: the combobox object
        :return: none
        """
        table = self.notification_schedule_table
        data = {}
        data['message_id'] = table.item(row, 0).text()
        data['msg_state'] = table.cellWidget(row, 4).currentText()
        msg = QMessageBox.information(
            QMessageBox(), 'Alert!!',
            'Do you want to change the status of the Message??',
            QMessageBox.Yes | QMessageBox.No)
        if msg == QMessageBox.Yes:
            report = self.message.update_message(data)
            if report:
                _ = QMessageBox.information(QMessageBox(), 'Success!!',
                                            'The Message was updated',
                                            QMessageBox.Yes | QMessageBox.No)
            else:
                _ = QMessageBox.critical(QMessageBox(), 'Error!!',
                                         'The Message was not updated',
                                         QMessageBox.Yes | QMessageBox.No)

    def search_messages(self):
        """
        Searches for messages when search button is pressed
        """
        logger.info('Notifications searching messages initiated')
        from_date = self.notification_schedule_fromdate_dateedit.text()
        to_date = self.notification_schedule_todate_dateedit.text()
        limit = self.notification_results.currentText()
        msg_id = self.id_line.text()
        msg_state = self.notification_states.currentText()
        dataobj = self.message.load_message(limit=limit,
                                            from_date=from_date,
                                            to_date=to_date,
                                            msg_id=msg_id,
                                            msg_state=msg_state)
        if dataobj:
            self.add_messages(*dataobj)
        else:
            self.notification_schedule_table.clearContents()
            self.notification_schedule_table.setRowCount(0)

    def load_more(self):
        """
        Searches for messages when search button is pressed
        """
        logger.info('Notifications searching messages initiated')
        from_date = self.notification_schedule_fromdate_dateedit.text()
        to_date = self.notification_schedule_todate_dateedit.text()
        limit = self.notification_results.currentText()
        msg_id = self.id_line.text()
        msg_state = self.notification_states.currentText()
        offset = self.notification_schedule_table.rowCount()
        dataobj = self.message.load_message(limit=limit,
                                            from_date=from_date,
                                            to_date=to_date,
                                            msg_id=msg_id,
                                            msg_state=msg_state,
                                            offset=offset)
        if dataobj:
            self.add_messages('new', dataobj)
        else:
            self.notification_schedule_table.clearContents()
            self.notification_schedule_table.setRowCount(0)

    def load_single_message(self, msg_id):  # api
        """method to load a single message"""
        self.reset_all()
        dataobj = self.message.load_message(msg_id=msg_id)
        if dataobj:
            self.add_messages('new', dataobj)
            self.id_line.setText(str(msg_id))
        else:
            self.notification_schedule_table.clearContents()
            self.notification_schedule_table.setRowCount(0)

    def load_rows(self, event):
        """
        :return:loads the rows
        """
        self.add_messages()

    def reset_all(self):
        """
        :return: resets the the data in the search text
        """
        try:
            self.id_line.clear()
            self.notification_schedule_table.clearContents()
            self.notification_schedule_table.setRowCount(0)
        except Exception as _:
            if settings.level == 10:
                logger.exception('raised exception')
            return False
Esempio n. 3
0
        self.commitData.emit(editor)
        self.closeEditor.emit(editor)


if __name__ == "__main__":
    """ Run the application. """
    from PySide.QtGui import (QApplication, QTableWidget, QTableWidgetItem,
                              QAbstractItemView)
    import sys

    app = QApplication(sys.argv)

    # Create and populate the tableWidget
    tableWidget = QTableWidget(4, 4)
    tableWidget.setItemDelegate(StarDelegate())
    tableWidget.setEditTriggers(QAbstractItemView.DoubleClicked
                                | QAbstractItemView.SelectedClicked)
    tableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
    tableWidget.setHorizontalHeaderLabels(
        ["Title", "Genre", "Artist", "Rating"])

    data = [["Mass in B-Minor", "Baroque", "J.S. Bach", 5],
            ["Three More Foxes", "Jazz", "Maynard Ferguson", 4],
            ["Sex Bomb", "Pop", "Tom Jones", 3],
            ["Barbie Girl", "Pop", "Aqua", 5]]

    for r in range(len(data)):
        tableWidget.setItem(r, 0, QTableWidgetItem(data[r][0]))
        tableWidget.setItem(r, 1, QTableWidgetItem(data[r][1]))
        tableWidget.setItem(r, 2, QTableWidgetItem(data[r][2]))
        item = QTableWidgetItem()
        item.setData(0, StarRating(data[r][3]).starCount)
Esempio n. 4
0
class ui(QWidget):
    def __init__(self):
        QWidget.__init__(self)
        self.setupUI()
        self.id = 1
        self.lines = []
        self.editable = True
        self.des_sort = True
        self.faker = Factory.create()
        self.btn_add.clicked.connect(self.add_line)
        self.btn_del.clicked.connect(self.del_line)
        self.btn_modify.clicked.connect(self.modify_line)
        self.btn_select_line.clicked.connect(self.select_line)
        self.btn_select_single.clicked.connect(self.deny_muti_line)
        self.btn_sort.clicked.connect(self.sortItem)
        self.btn_set_header.clicked.connect(self.setheader)
        self.btn_set_middle.clicked.connect(self.middle)
        self.table.cellChanged.connect(self.cellchange)
        self.btn_noframe.clicked.connect(self.noframe)


#     # Sess = sessionmaker(bind = engine)

    def setupUI(self):
        self.setWindowTitle(windowTital)
        self.resize(640, 480)
        self.table = QTableWidget(self)
        self.btn_add = QPushButton(u'增加')
        self.btn_del = QPushButton(u'删除')
        self.btn_modify = QPushButton(u'可以编辑')
        self.btn_select_line = QPushButton(u'选择整行')
        self.btn_select_single = QPushButton(u'禁止选多行')
        self.btn_sort = QPushButton(u'以分数排序')
        self.btn_set_header = QPushButton(u'标头设置')
        self.btn_set_middle = QPushButton(u'文字居中加颜色')
        self.btn_noframe = QPushButton(u'取消边框颜色交替')
        self.spacerItem = QSpacerItem(20, 20, QSizePolicy.Minimum,
                                      QSizePolicy.Expanding)
        self.vbox = QVBoxLayout()
        self.vbox.addWidget(self.btn_add)
        self.vbox.addWidget(self.btn_del)
        self.vbox.addWidget(self.btn_modify)
        self.vbox.addWidget(self.btn_select_line)
        self.vbox.addWidget(self.btn_select_single)
        self.vbox.addWidget(self.btn_sort)
        self.vbox.addWidget(self.btn_set_header)
        self.vbox.addWidget(self.btn_set_middle)
        self.vbox.addWidget(self.btn_noframe)
        self.vbox.addSpacerItem(
            self.spacerItem)  #可以用addItem也可以用addSpacerItem方法添加,没看出哪里不一样
        self.txt = QLabel()
        self.txt.setMinimumHeight(50)
        self.vbox2 = QVBoxLayout()
        self.vbox2.addWidget(self.table)
        self.vbox2.addWidget(self.txt)
        self.hbox = QHBoxLayout()
        self.hbox.addLayout(self.vbox2)
        self.hbox.addLayout(self.vbox)
        self.setLayout(self.hbox)
        self.table.setColumnCount(4)  ##设置列数
        self.headers = [u'id', u'选择', u'姓名', u'成绩', u'住址']
        self.table.setHorizontalHeaderLabels(self.headers)
        self.show()

    def add_line(self):
        self.table.cellChanged.disconnect()
        row = self.table.rowCount()
        self.table.setRowCount(row + 1)
        id = str(self.id)
        ck = QCheckBox()
        h = QHBoxLayout()
        h.setAlignment(Qt.AlignCenter)
        h.addWidget(ck)
        w = QWidget()
        w.setLayout(h)
        name = self.faker.name()
        score = str(random.randint(50, 99))
        add = self.faker.address()
        self.table.setItem(row, 0, QTableWidgetItem(id))
        self.table.setCellWidget(row, 1, w)
        self.table.setItem(row, 2, QTableWidgetItem(name))
        self.table.setItem(row, 3, QTableWidgetItem(score))
        self.table.setItem(row, 4, QTableWidgetItem(add))
        self.id += 1
        self.lines.append([id, ck, name, score, add])
        self.settext(u'自动生成随机一行数据!,checkbox设置为居中显示')
        self.table.cellChanged.connect(self.cellchange)

    def del_line(self):
        removeline = []
        for line in self.lines:
            if line[1].isChecked():
                row = self.table.rowCount()
                for x in range(row, 0, -1):
                    if line[0] == self.table.item(x - 1, 0).text():
                        self.table.removeRow(x - 1)
                        removeline.append(line)
        for line in removeline:
            self.lines.remove(line)
        self.settext(u'删除在左边checkbox中选中的行,使用了一个笨办法取得行号\n,不知道有没有其他可以直接取得行号的方法!')

    def modify_line(self):
        if self.editable == True:
            self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
            self.btn_modify.setText(u'禁止编辑')
            self.editable = False
        else:
            self.table.setEditTriggers(QAbstractItemView.AllEditTriggers)
            self.btn_modify.setText(u'可以编辑')
            self.editable = True
        self.settext(u'设置,是否可以编辑整个表格')

    def select_line(self):
        if self.table.selectionBehavior() == 0:
            self.table.setSelectionBehavior(1)
            self.btn_select_line.setStyleSheet('background-color:lightblue')
        else:
            self.table.setSelectionBehavior(0)
            self.btn_select_line.setStyleSheet('')
        self.settext(u'默认时,点击单元格,只可选择一个格,此处设置为可选择整行')

    def deny_muti_line(self):
        if self.table.selectionMode() in [2, 3]:
            self.table.setSelectionMode(QAbstractItemView.SingleSelection)
            self.btn_select_single.setStyleSheet('background-color:lightblue')
        else:
            self.table.setSelectionMode(QAbstractItemView.ExtendedSelection)
            self.btn_select_single.setStyleSheet('')
        self.settext(u'点击时会轮换以多行或单行选择,默认是可以同时选择多行')

    def sortItem(self):
        if self.des_sort == True:
            self.table.sortItems(3, Qt.DescendingOrder)
            self.des_sort = False
            self.btn_sort.setStyleSheet('background-color:lightblue')
            self.table.setSortingEnabled(True)  # 设置表头可以自动排序
        else:
            self.table.sortItems(3, Qt.AscendingOrder)
            self.des_sort = True
            self.btn_sort.setStyleSheet('background-color:lightblue')
            self.table.setSortingEnabled(False)
        self.settext(u'点击时会轮换以升序降序排列,但排序时,会使自动列宽失效!')

    def setheader(self):
        font = QFont(u'微软雅黑', 12)
        font.setBold(True)
        self.table.horizontalHeader().setFont(font)  # 设置表头字体
        self.table.setColumnWidth(0, 50)
        self.table.setColumnWidth(1, 50)
        self.table.setColumnWidth(3, 100)
        self.table.horizontalHeader().setSectionResizeMode(
            2, QHeaderView.Stretch)
        self.table.horizontalHeader().setStyleSheet(
            'QHeaderView::section{background:gray}')
        self.table.horizontalHeader().setFixedHeight(50)
        self.table.setColumnHidden(0, True)
        self.btn_set_header.setStyleSheet('background-color:lightblue')
        self.settext(
            u'设置标头字体及字号,隐藏ID列,设置标头除姓名外全部为固定宽度\n,设置姓名列自动扩展宽度,设置标头行高,设置标头背景色')

    def middle(self):
        self.btn_set_middle.setStyleSheet('background-color:lightblue')
        self.table.setStyleSheet('color:green;')
        row = self.table.rowCount()
        for x in range(row):
            for y in range(4):
                if y != 1:
                    item = self.table.item(x, y)
                    item.setTextAlignment(Qt.AlignCenter)
                else:
                    pass
        self.btn_set_middle.setStyleSheet('background-color:lightblue')
        self.settext(u'将文字居中显示,设置文字颜色')

    def cellchange(self, row, col):
        item = self.table.item(row, col)
        txt = item.text()
        self.settext(u'第%s行,第%s列 , 数据改变为:%s' % (row, col, txt))

    def noframe(self):
        self.table.setAlternatingRowColors(True)
        self.table.setFrameStyle(QFrame.NoFrame)
        self.table.setStyleSheet('color:green;'
                                 'gridline-color:white;'
                                 'border:0px solid gray')
        self.settext(u'取消表的框线,\n 取消表格内框')

    def settext(self, txt):
        font = QFont(u'微软雅黑', 10)
        self.txt.setFont(font)
        self.txt.setText(txt)
Esempio n. 5
0
class PnLPanel(QtGui.QWidget):

    pnLColumnList = "Custody Name;Initial Position;Final Position;Cash In;Weighted Cash In; Cash Out;Weighted Cash Out;PnL;Weighted PnL;TIR;Weighted TIR".split(
        ";")

    def __init__(self):
        super(self.__class__, self).__init__()
        self.layout = QtGui.QGridLayout(self)
        self.pnlFilter = PnLFilter(self)
        self.layout.addWidget(self.pnlFilter, 1, 0, QtCore.Qt.AlignTop)
        #self.layout.setAlignment(self.pnlFilter, QtCore.Qt.AlignTop)
        #self.layout.setAlignment(self.pnlFilter, QtCore.Qt.AlignLeft)
        self.layout.addWidget(self.createPnLTable(), 1, 1, QtCore.Qt.AlignTop)
        #self.layout.setAlignment(self.pnLTableWidget, QtCore.Qt.AlignTop)
        #self.layout.setAlignment(self.pnLTableWidget, QtCore.Qt.AlignLeft)

    def createPnLTable(self):
        self.pnLTableWidget = QTableWidget()
        self.pnLTableWidget.setRowCount(6)
        self.pnLTableWidget.setColumnCount(len(self.pnLColumnList))
        self.pnLTableWidget.setEditTriggers(
            QtGui.QAbstractItemView.NoEditTriggers)
        self.pnLTableWidget.setHorizontalHeaderLabels(self.pnLColumnList)
        #self.pnLTableWidget.resizeColumnsToContents()
        self.pnLTableWidget.resizeRowsToContents()
        self.pnLTableWidget.setFixedSize(1100, 150)
        return self.pnLTableWidget

    def doSubmit(self, fromDate, toDate):
        pnlLO = Engine.buildPnlLogicObject(fromDate, toDate)
        self.renderPnlTable(pnlLO.pnlVOList)

    def renderPnlTable(self, pnlCalculationList):
        row = 0
        for pnlVO in pnlCalculationList:
            #ItemNameItem
            ItemNameItem = QTableWidgetItemString(pnlVO.itemName, False)
            self.pnLTableWidget.setItem(row,
                                        Constant.CONST_COLUMN_PNL_ITEM_NAME,
                                        ItemNameItem)
            #initialPositionItem
            initialPositionItem = QTableWidgetItemDecimal(
                pnlVO.initialPosition, False)
            self.pnLTableWidget.setItem(
                row, Constant.CONST_COLUMN_PNL_INITIAL_POSITION,
                initialPositionItem)
            #finalPositionItem
            finalPositionItem = QTableWidgetItemDecimal(
                pnlVO.finalPosition, False)
            self.pnLTableWidget.setItem(
                row, Constant.CONST_COLUMN_PNL_FINAL_POSITION,
                finalPositionItem)
            #totalCashIn
            totalCashInItem = QTableWidgetItemDecimal(pnlVO.totalCashIn, False)
            self.pnLTableWidget.setItem(row, Constant.CONST_COLUMN_PNL_CASH_IN,
                                        totalCashInItem)
            #totalWeightedCashIn
            totalWeightedCashInItem = QTableWidgetItemDecimal(
                pnlVO.totalWeightedCashIn, False)
            self.pnLTableWidget.setItem(
                row, Constant.CONST_COLUMN_PNL_WEIGHTED_CASH_IN,
                totalWeightedCashInItem)
            #totalCashOut
            totalCashOutItem = QTableWidgetItemDecimal(pnlVO.totalCashOut,
                                                       False)
            self.pnLTableWidget.setItem(row,
                                        Constant.CONST_COLUMN_PNL_CASH_OUT,
                                        totalCashOutItem)
            #totalWeightedCashOut
            totalWeightedCashOutItem = QTableWidgetItemDecimal(
                pnlVO.totalWeightedCashOut, False)
            self.pnLTableWidget.setItem(
                row, Constant.CONST_COLUMN_PNL_WEIGHTED_CASH_OUT,
                totalWeightedCashOutItem)
            #pnlAmount
            pnlAmountItem = QTableWidgetItemDecimal(pnlVO.pnlAmount, False)
            self.pnLTableWidget.setItem(row,
                                        Constant.CONST_COLUMN_PNL_PNL_AMOUNT,
                                        pnlAmountItem)
            #pnlWeightedAmount
            pnlWeightedAmountItem = QTableWidgetItemDecimal(
                pnlVO.pnlWeightedAmount, False)
            self.pnLTableWidget.setItem(
                row, Constant.CONST_COLUMN_PNL_WEIGHTED_PNL_AMOUNT,
                pnlWeightedAmountItem)
            #tir
            tirItem = QTableWidgetItemDecimal(pnlVO.tir, False)
            self.pnLTableWidget.setItem(row, Constant.CONST_COLUMN_PNL_TIR,
                                        tirItem)
            #weightedtir
            weightedTirItem = QTableWidgetItemDecimal(pnlVO.weightedTir, False)
            self.pnLTableWidget.setItem(row,
                                        Constant.CONST_COLUMN_PNL_WEIGHTED_TIR,
                                        weightedTirItem)
            row += 1
Esempio n. 6
0
class PositionPanel(QtGui.QWidget):
    positionTableWidget = None
    summaryTable = None
    movementFilterWidget = None
    row = 0
    summaryRow = 0
    positionColumnList = "Asset Name;Position;Unit Cost;Market Price;Change%;Invested amount;Valuated amount;Tenor;Maturity Date;Gross PNL;Net PNL;Gross%PNL;Net%PNL;Realized Pnl;%Portfolio;WeightedPNL%".split(
        ";")
    summaryColumnList = "Custody;Asset type;Invested Amount;Valuated Amount;Net PnL;Net%PNL;Realized Pnl;RPnL + NPnL;%Portfolio;WeightedPNL%".split(
        ";")

    def __init__(self):
        super(self.__class__, self).__init__()
        self.layout = QtGui.QGridLayout(self)
        self.movementFilterWidget = MovementFilterWidget()
        self.layout.addWidget(self.movementFilterWidget, 1, 0)

    def clearTables(self):
        self.row = 0
        self.summaryRow = 0
        self.createTable()
        self.createSummaryTable()
        self.createGeneralInfoPanel()

    def createSummaryTable(self):
        self.summaryTableWidget = QTableWidget()
        self.summaryTableWidget.setRowCount(7)
        self.summaryTableWidget.setColumnCount(len(self.summaryColumnList))
        self.summaryTableWidget.setEditTriggers(
            QtGui.QAbstractItemView.NoEditTriggers)
        self.summaryTableWidget.setHorizontalHeaderLabels(
            self.summaryColumnList)
        #self.summaryTableWidget.setSortingEnabled(True)
        #self.summaryTableWidget.sortItems(0)
        self.summaryTableWidget.resizeColumnsToContents()
        self.summaryTableWidget.resizeRowsToContents()
        self.summaryTableWidget.setFixedSize(800, 200)
        self.layout.addWidget(self.summaryTableWidget, 1, 1)

    def createGeneralInfoPanel(self):
        self.generalInfoPanel = QWidget()
        self.generalInfoLayout = QtGui.QGridLayout(self.generalInfoPanel)
        self.lblUSDMXN = QLabel("USD/MXN")
        self.lblUSDMXN.font()
        self.lblUSDMXN.setFont(
            QtGui.QFont("MS Shell Dlg", 12, QtGui.QFont.Normal))
        self.generalInfoLayout.addWidget(self.lblUSDMXN, 1, 1)
        self.lblUSDMXNValue = QLabel("0")
        self.lblUSDMXNValue.setFont(
            QtGui.QFont("MS Shell Dlg", 12, QtGui.QFont.Bold))
        self.generalInfoLayout.addWidget(self.lblUSDMXNValue, 1, 2)
        self.generalInfoPanel.setFixedSize(200, 50)
        self.layout.addWidget(self.generalInfoPanel, 1, 2)

    def createTable(self):
        self.positionTableWidget = QTableWidget()
        self.positionTableWidget.setRowCount(27)
        self.positionTableWidget.setColumnCount(
            len(self.positionColumnList) + 1)
        self.positionTableWidget.setColumnHidden(
            Constant.CONST_COLUMN_POSITION_HIDDEN_ID, True)
        self.positionTableWidget.setEditTriggers(
            QtGui.QAbstractItemView.NoEditTriggers)
        self.positionTableWidget.setHorizontalHeaderLabels(
            self.positionColumnList)
        #self.positionTableWidget.setSortingEnabled(True)
        #self.positionTableWidget.sortItems(0)
        self.positionTableWidget.doubleClicked.connect(self.openMovementView)
        self.positionTableWidget.resizeColumnsToContents()
        self.positionTableWidget.resizeRowsToContents()
        self.layout.addWidget(self.positionTableWidget, 2, 0, 3, 3)

    def renderGeneralInfoPanel(self, usdMXNvalue):
        self.lblUSDMXNValue.setText(str(round(usdMXNvalue, 4)))
        #self.generalInfoLayout.addWidget(self.lblUSDMXNValue, 1, 2)

    def renderSummary(self, summaryDict):
        for (key, summaryItem) in sorted(summaryDict.iteritems()):
            if summaryItem.custodyName is None:
                isBold = True
            else:
                isBold = False
            #custodyName
            custodyNameItem = QTableWidgetItemString(summaryItem.custodyName,
                                                     isBold)
            self.summaryTableWidget.setItem(
                self.summaryRow,
                Constant.CONST_COLUMN_SUMMARY_CUST_CUSTODY_NAME,
                custodyNameItem)
            #assetTypeName
            assetTypeNameItem = QTableWidgetItemString(summaryItem.assetType,
                                                       isBold)
            self.summaryTableWidget.setItem(
                self.summaryRow,
                Constant.CONST_COLUMN_SUMMARY_CUST_ASSET_TYPE_NAME,
                assetTypeNameItem)
            #InvestedAmount
            investedAmountItem = QTableWidgetItemDecimal(
                summaryItem.investedAmount, isBold)
            self.summaryTableWidget.setItem(
                self.summaryRow,
                Constant.CONST_COLUMN_SUMMARY_CUST_INVESTED_AMOUNT,
                investedAmountItem)
            #valuatedAmount
            valuatedAmountItem = QTableWidgetItemDecimal(
                summaryItem.valuatedAmount, isBold)
            self.summaryTableWidget.setItem(
                self.summaryRow,
                Constant.CONST_COLUMN_SUMMARY_CUST_VALUATED_AMOUNT,
                valuatedAmountItem)
            #subTotalNetPnL
            netPnLItem = QTableWidgetItemDecimal(summaryItem.netPnL, isBold)
            self.summaryTableWidget.setItem(
                self.summaryRow, Constant.CONST_COLUMN_SUMMARY_CUST_NET_PNL,
                netPnLItem)
            #netPNLPercentage
            netPNLPercentageItem = QTableWidgetItemDecimal(
                summaryItem.getNetPnLPercentage(), isBold)
            self.summaryTableWidget.setItem(
                self.summaryRow,
                Constant.CONST_COLUMN_SUMMARY_CUST_NET_PNL_PERCENTAGE,
                netPNLPercentageItem)
            #realizedPnl
            realizedPnlItem = QTableWidgetItemDecimal(summaryItem.realizedPnl,
                                                      isBold)
            self.summaryTableWidget.setItem(
                self.summaryRow,
                Constant.CONST_COLUMN_SUMMARY_CUST_REALIZED_PNL,
                realizedPnlItem)
            #realizedPnlPlusNetPnL
            realizedPnlPlusNetPnLItem = QTableWidgetItemDecimal(
                summaryItem.realizedPnl + summaryItem.netPnL, isBold)
            self.summaryTableWidget.setItem(
                self.summaryRow,
                Constant.CONST_COLUMN_SUMMARY_CUST_REALIZED_PNL_PLUS_NET_PNL,
                realizedPnlPlusNetPnLItem)
            #positionPercentage
            positionPercentageItem = QTableWidgetItemDecimal(
                summaryItem.positionPercentage, isBold)
            self.summaryTableWidget.setItem(
                self.summaryRow,
                Constant.CONST_COLUMN_SUMMARY_CUST_POSITION_PERCENTAGE,
                positionPercentageItem)
            #weightedPnL
            weightedPnLItem = QTableWidgetItemDecimal(summaryItem.weightedPnL,
                                                      isBold)
            self.summaryTableWidget.setItem(
                self.summaryRow,
                Constant.CONST_COLUMN_SUMMARY_CUST_WEIGHTED_PNL,
                weightedPnLItem)
            self.summaryRow += 1

    def renderSubtotal(self, positionDict, assetType, isSIC):
        accValuatedAmount = Engine.getSubTotalValuatedAmount(
            positionDict, assetType, isSIC)
        accInvestedAmount = Engine.getSubTotalInvestedAmount(
            positionDict, assetType, isSIC)
        accRealizedPnl = Engine.getAccRealizedPnL(positionDict, assetType,
                                                  isSIC)
        accPositionPercentage = Engine.getAccPositionPercentage(
            positionDict, assetType, isSIC)
        accGrossPnlPercentage = Engine.getAccGrossPnlPercentage(
            positionDict, assetType, isSIC)
        accNetPnlPercentage = Engine.getAccNetPnlPercentage(
            positionDict, assetType, isSIC)
        accNetPNL = Engine.getAccNetPNL(positionDict, assetType, isSIC)
        accWeightedPNL = Engine.getAccWeightedPNL(positionDict, assetType,
                                                  isSIC)
        #Invested amount
        investedAmountItem = QTableWidgetItemDecimal(accInvestedAmount, True)
        self.positionTableWidget.setItem(
            self.row, Constant.CONST_COLUMN_POSITION_INVESTED_AMOUNT,
            investedAmountItem)
        #sub total valuated amount
        subTotalValuatedAmountItem = QTableWidgetItemDecimal(
            accValuatedAmount, True)
        self.positionTableWidget.setItem(
            self.row, Constant.CONST_COLUMN_POSITION_VALUATED_AMOUNT,
            subTotalValuatedAmountItem)
        #sub total Gross PNL
        subTotalGrossPNLItem = QTableWidgetItemDecimalColor(
            Engine.getSubtotalGrossPNL(positionDict, assetType, isSIC), True)
        self.positionTableWidget.setItem(
            self.row, Constant.CONST_COLUMN_POSITION_GROSS_PNL,
            subTotalGrossPNLItem)
        #sub total Net PNL
        subTotalNetPNLItem = QTableWidgetItemDecimalColor(accNetPNL, True)
        self.positionTableWidget.setItem(
            self.row, Constant.CONST_COLUMN_POSITION_NET_PNL,
            subTotalNetPNLItem)
        #subTotalGrossPnLPercentage
        subTotalGrossPnLPercentage = QTableWidgetItemDecimalColor(
            accGrossPnlPercentage, True)
        self.positionTableWidget.setItem(
            self.row, Constant.CONST_COLUMN_POSITION_GROSS_PNL_PERCENTAGE,
            subTotalGrossPnLPercentage)
        #pnLNetPercentage
        subTotalNetPnLPercentage = QTableWidgetItemDecimalColor(
            accNetPnlPercentage, True)
        self.positionTableWidget.setItem(
            self.row, Constant.CONST_COLUMN_POSITION_GROSS_NET_PERCENTAGE,
            subTotalNetPnLPercentage)
        #realizedPnL
        realizedPnLItem = QTableWidgetItemDecimalColor(accRealizedPnl, True)
        self.positionTableWidget.setItem(
            self.row, Constant.CONST_COLUMN_POSITION_REALIZED_PNL,
            realizedPnLItem)
        #positionPercentage
        positionPercentageItem = QTableWidgetItemDecimal(
            accPositionPercentage, True)
        self.positionTableWidget.setItem(
            self.row, Constant.CONST_COLUMN_POSITION_POSITION_PERCENTAGE,
            positionPercentageItem)
        #weightedPercentageItem
        weightedPercentageItem = QTableWidgetItemDecimal(accWeightedPNL, True)
        self.positionTableWidget.setItem(
            self.row, Constant.CONST_COLUMN_POSITION_WEIGHTED_PNL,
            weightedPercentageItem)
        #HiddenID
        hiddenIDItem = QTableWidgetItemDecimal(self.row, False)
        self.positionTableWidget.setItem(
            self.row, Constant.CONST_COLUMN_POSITION_HIDDEN_ID, hiddenIDItem)

    def renderPositions(self, positionDict, assetType, isSIC):
        positionList = Engine.getPositionByAssetType(positionDict, assetType,
                                                     isSIC)
        for position in positionList:
            print('rendering ' + position.getAssetName())
            if (position.getTotalQuantity() != 0):
                position.row = self.row
                #assetName
                assetNameItem = QTableWidgetItemString(position.getAssetName(),
                                                       False)
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_ASSET_NAME,
                    assetNameItem)
                #totalQuantity
                totalQuantityItem = QTableWidgetItemInt(
                    position.getTotalQuantity(), False)
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_QUANTITY,
                    totalQuantityItem)
                #UnitCostOrRate
                unitCostItem = QTableWidgetItemDecimal(
                    position.getUnitCostOrRate(), False)
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_PPP, unitCostItem)
                #Market price
                marketPriceItem = QTableWidgetItemDuoDecimal(
                    position.getMarketPrice(), position.getMarketPriceOrig())
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_MARKET_PRICE,
                    marketPriceItem)
                #changePercentage
                changePercentageItem = QTableWidgetItemStringPlusMinus(
                    position.changePercentage, False)
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_CHANGE_PERCENTAGE,
                    changePercentageItem)
                #Invested amount
                investedAmountItem = QTableWidgetItemDecimal(
                    position.getInvestedAmount(), False)
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_INVESTED_AMOUNT,
                    investedAmountItem)
                #Valuated amount
                valuatedAmountItem = QTableWidgetItemDuoDecimal(
                    position.getValuatedAmount(),
                    position.getValuatedAmountOrig())
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_VALUATED_AMOUNT,
                    valuatedAmountItem)
                #Tenor
                tenorItem = QTableWidgetItemDuoInt(position.tenor,
                                                   position.getElapsedDays())
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_TENOR, tenorItem)
                #Maturity Date
                maturityDateItem = QTableWidgetItemString(
                    position.getMaturityDate(), False)
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_MATURITY_DATE,
                    maturityDateItem)
                #GrossPnL
                grossPnlItem = QTableWidgetItemDecimalColor(
                    position.getGrossPnL(), False)
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_GROSS_PNL,
                    grossPnlItem)
                #netPnL
                netPnlItem = QTableWidgetItemDecimalColor(
                    position.getNetPnL(), False)
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_NET_PNL,
                    netPnlItem)
                #pnLGrossPercentage
                pnLGrossPercentageItem = QTableWidgetItemDecimalColor(
                    position.getGrossPnLPercentage(), False)
                self.positionTableWidget.setItem(
                    self.row,
                    Constant.CONST_COLUMN_POSITION_GROSS_PNL_PERCENTAGE,
                    pnLGrossPercentageItem)
                #pnLNetPercentage
                pnLNetPercentageItem = QTableWidgetItemDecimalColor(
                    position.getNetPnLPercentage(), False)
                self.positionTableWidget.setItem(
                    self.row,
                    Constant.CONST_COLUMN_POSITION_GROSS_NET_PERCENTAGE,
                    pnLNetPercentageItem)
                #realizedPnL
                realizedPnLItem = QTableWidgetItemDecimalColor(
                    position.getConsolidatedRealizedPnl(), False)
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_REALIZED_PNL,
                    realizedPnLItem)
                #positionPercentage
                positionPercentageItem = QTableWidgetItemDecimal(
                    position.getPositionPercentage(), False)
                self.positionTableWidget.setItem(
                    self.row,
                    Constant.CONST_COLUMN_POSITION_POSITION_PERCENTAGE,
                    positionPercentageItem)
                #weightedPercentageItem
                weightedPercentageItem = QTableWidgetItemDecimal(
                    position.getWeightedPnl(), False)
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_WEIGHTED_PNL,
                    weightedPercentageItem)
                #HiddenID
                hiddenIDItem = QTableWidgetItemDecimal(self.row, False)
                self.positionTableWidget.setItem(
                    self.row, Constant.CONST_COLUMN_POSITION_HIDDEN_ID,
                    hiddenIDItem)
                self.row += 1
        self.renderSubtotal(positionDict, assetType, isSIC)
        self.row += 1

    def openMovementView(self):
        assetName = self.positionTableWidget.item(
            self.positionTableWidget.currentRow(),
            Constant.CONST_COLUMN_POSITION_ASSET_NAME).text()
        movementList = Engine.getMovementListByAsset(
            assetName, (self.movementFilterWidget.dateFromDate.date()
                        ).toString("yyyy-M-dd"),
            (self.movementFilterWidget.dateToDate.date()
             ).toString("yyyy-M-dd"))
        self.movementView = MovementView(movementList)
        self.movementView.show()
Esempio n. 7
0
        self.commitData.emit(editor)
        self.closeEditor.emit(editor)


if __name__ == "__main__":
    """ Run the application. """
    from PySide.QtGui import (QApplication, QTableWidget, QTableWidgetItem,
                              QAbstractItemView)
    import sys

    app = QApplication(sys.argv)

    # Create and populate the tableWidget
    tableWidget = QTableWidget(4, 4)
    tableWidget.setItemDelegate(StarDelegate())
    tableWidget.setEditTriggers(QAbstractItemView.DoubleClicked | 
                                QAbstractItemView.SelectedClicked)
    tableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
    tableWidget.setHorizontalHeaderLabels(["Title", "Genre", "Artist", "Rating"])

    data = [ ["Mass in B-Minor", "Baroque", "J.S. Bach", 5],
             ["Three More Foxes", "Jazz", "Maynard Ferguson", 4],
             ["Sex Bomb", "Pop", "Tom Jones", 3],
             ["Barbie Girl", "Pop", "Aqua", 5] ]
             

    for r in range(len(data)):
        tableWidget.setItem(r, 0, QTableWidgetItem(data[r][0]))
        tableWidget.setItem(r, 1, QTableWidgetItem(data[r][1]))
        tableWidget.setItem(r, 2, QTableWidgetItem(data[r][2]))
        item = QTableWidgetItem()
        item.setData(0, StarRating(data[r][3]).starCount)
Esempio n. 8
0
class WasteItems():
    """Item waste management tab"""
    global logger

    def __init__(self):
        ###
        logger.info('Inside WasteItems')
        self.wastedetail_tab_1 = QWidget()
        self.wastedetail_tab_1.setObjectName("wastedetail_tab_1")
        self.verticalLayout_9 = QVBoxLayout(self.wastedetail_tab_1)
        self.verticalLayout_9.setObjectName("verticalLayout_9")
        self.verticalLayout_8 = QVBoxLayout()
        self.verticalLayout_8.setObjectName("verticalLayout_8")
        self.horizontalLayout_12 = QHBoxLayout()
        self.horizontalLayout_12.setObjectName("horizontalLayout_12")
        self.waste_fromdate_label = QLabel(self.wastedetail_tab_1)
        self.waste_fromdate_label.setObjectName('waste_fromdate_label')
        self.horizontalLayout_12.addWidget(self.waste_fromdate_label)
        self.waste_fromdate_dateedit = QDateEdit(self.wastedetail_tab_1)
        self.waste_fromdate_dateedit.setCalendarPopup(True)
        self.waste_fromdate_dateedit.setObjectName("waste_fromdate_dateedit")
        self.horizontalLayout_12.addWidget(self.waste_fromdate_dateedit)
        self.waste_todate_label = QLabel(self.wastedetail_tab_1)
        self.waste_todate_label.setObjectName('waste_todate_label')
        self.horizontalLayout_12.addWidget(self.waste_todate_label)
        self.waste_todate_dateedit = QDateEdit(self.wastedetail_tab_1)
        self.waste_todate_dateedit.setCalendarPopup(True)
        self.waste_todate_dateedit.setObjectName("waste_todate_dateedit")
        self.waste_todate_dateedit.setMaximumDate(QDate.currentDate())
        self.horizontalLayout_12.addWidget(self.waste_todate_dateedit)
        spacerItem28 = QSpacerItem(40, 20, QSizePolicy.Expanding,
                                   QSizePolicy.Minimum)
        self.horizontalLayout_12.addItem(spacerItem28)
        self.waste_table_search_button = QPushButton(self.wastedetail_tab_1)
        self.waste_table_search_button.setObjectName(
            "waste_table_search_button")
        self.horizontalLayout_12.addWidget(self.waste_table_search_button)
        self.verticalLayout_8.addLayout(self.horizontalLayout_12)
        self.waste_table = QTableWidget(self.wastedetail_tab_1)
        self.waste_table.setObjectName("waste_table")
        self.waste_table.setColumnCount(6)
        self.waste_table.setRowCount(0)
        item = QTableWidgetItem()
        self.waste_table.setHorizontalHeaderItem(0, item)
        item = QTableWidgetItem()
        self.waste_table.setHorizontalHeaderItem(1, item)
        item = QTableWidgetItem()
        self.waste_table.setHorizontalHeaderItem(2, item)
        item = QTableWidgetItem()
        self.waste_table.setHorizontalHeaderItem(3, item)
        item = QTableWidgetItem()
        self.waste_table.setHorizontalHeaderItem(4, item)
        item = QTableWidgetItem()
        self.waste_table.setHorizontalHeaderItem(5, item)
        self.waste_table.horizontalHeader().setCascadingSectionResizes(False)
        self.waste_table.horizontalHeader().setStretchLastSection(True)
        self.waste_table.verticalHeader().setVisible(False)
        self.waste_table.verticalHeader().setCascadingSectionResizes(False)
        self.waste_table.setSortingEnabled(True)
        self.verticalLayout_8.addWidget(self.waste_table)
        self.verticalLayout_9.addLayout(self.verticalLayout_8)
        ##retranslate
        self.waste_fromdate_label.setText(
            QApplication.translate("MainWindow", "From Date", None,
                                   QApplication.UnicodeUTF8))
        self.waste_fromdate_dateedit.setDisplayFormat(
            QApplication.translate("MainWindow", "dd/MM/yyyy", None,
                                   QApplication.UnicodeUTF8))
        self.waste_todate_label.setText(
            QApplication.translate("MainWindow", "To Date", None,
                                   QApplication.UnicodeUTF8))
        self.waste_todate_dateedit.setDisplayFormat(
            QApplication.translate("MainWindow", "dd/MM/yyyy", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table_search_button.setText(
            QApplication.translate("MainWindow", "Search", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table.horizontalHeaderItem(0).setText(
            QApplication.translate("MainWindow", "Code", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table.horizontalHeaderItem(1).setText(
            QApplication.translate("MainWindow", "Item", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table.horizontalHeaderItem(2).setText(
            QApplication.translate("MainWindow", "Category", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table.horizontalHeaderItem(3).setText(
            QApplication.translate("MainWindow", "Units", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table.horizontalHeaderItem(4).setText(
            QApplication.translate("MainWindow", "Quantity", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table.horizontalHeaderItem(5).setText(
            QApplication.translate("MainWindow", "Reason", None,
                                   QApplication.UnicodeUTF8))

        ###signals and slots && other stuffs
        # self.mainwindow = Ui_MainWindow  # just for the ease of finding the attributes in pycharm
        self.item = WasteIngredients()
        self.waste_fromdate_dateedit.setDate(QDate.currentDate())
        self.waste_todate_dateedit.setDate(QDate.currentDate())
        self.waste_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
        self.waste_table_search_button.clicked.connect(self.search_discard)
        self.wastedetail_tab_1.setFocusPolicy(Qt.StrongFocus)
        self.wastedetail_tab_1.focusInEvent = self.load_rows

    def load_rows(self, event=None):
        """calling add row to restructure the table every time container resizes"""
        self.add_row_to_table()

    def search_discard(self):
        """
        searches the discard from_date and to_date
        :return:none
        """
        f_date = self.waste_fromdate_dateedit.text()
        from_date = datetime.strptime(f_date, '%d/%m/%Y')
        t_date = self.waste_todate_dateedit.text()
        to_date = datetime.strptime(t_date, '%d/%m/%Y')
        to_date = to_date + timedelta(hours=23, minutes=59, seconds=59)
        dataobj = self.item.find_itemdiscard(from_date=from_date,
                                             to_date=to_date)
        self.add_row_to_table(*dataobj)

    def add_row_to_table(self, *args):
        """
        complex stuff of auto complete to be added to each combo box
        :return:
        """
        table = self.waste_table
        if args:
            table.clearContents()
            table.setRowCount(0)
            table.setRowCount(len(args))
            for i, j in enumerate(args):
                code = QTableWidgetItem(j['code'])
                table.setItem(i, 0, code)
                item = QTableWidgetItem(j['item'])
                table.setItem(i, 1, item)
                category = QTableWidgetItem(j['category'])
                table.setItem(i, 2, category)
                unit = QTableWidgetItem(str(j['units']))
                table.setItem(i, 3, unit)
                quantity = QTableWidgetItem(str(j['quantity']))
                table.setItem(i, 4, quantity)
                reason = QTableWidgetItem(j['reason_for_discard'])
                table.setItem(i, 5, reason)
        table.setColumnWidth(0, (table.width() / 6))
        table.setColumnWidth(1, (table.width() / 6))
        table.setColumnWidth(2, (table.width() / 6))
        table.setColumnWidth(3, (table.width() / 6))
        table.setColumnWidth(4, (table.width() / 6))
        table.horizontalHeader().setStretchLastSection(True)
Esempio n. 9
0
class WasteDish():
    """Dish waste management tab"""
    global logger

    def __init__(self):
        ###
        logger.info('Inside WasteDish')
        self.wastedetail_tab_1 = QWidget()
        self.wastedetail_tab_1.setObjectName("wastedetail_tab_1")
        self.verticalLayout_9 = QVBoxLayout(self.wastedetail_tab_1)
        self.verticalLayout_9.setObjectName("verticalLayout_9")
        self.verticalLayout_8 = QVBoxLayout()
        self.verticalLayout_8.setObjectName("verticalLayout_8")
        self.horizontalLayout_12 = QHBoxLayout()
        self.horizontalLayout_12.setObjectName("horizontalLayout_12")
        self.waste_fromdate_label = QLabel(self.wastedetail_tab_1)
        self.waste_fromdate_label.setObjectName('waste_fromdate_label')
        self.horizontalLayout_12.addWidget(self.waste_fromdate_label)
        self.waste_fromdate_dateedit = QDateEdit(self.wastedetail_tab_1)
        self.waste_fromdate_dateedit.setCalendarPopup(True)
        self.waste_fromdate_dateedit.setObjectName("waste_fromdate_dateedit")
        self.horizontalLayout_12.addWidget(self.waste_fromdate_dateedit)
        self.waste_todate_label = QLabel(self.wastedetail_tab_1)
        self.waste_todate_label.setObjectName('waste_todate_label')
        self.horizontalLayout_12.addWidget(self.waste_todate_label)
        self.waste_todate_dateedit = QDateEdit(self.wastedetail_tab_1)
        self.waste_todate_dateedit.setCalendarPopup(True)
        self.waste_todate_dateedit.setObjectName("waste_todate_dateedit")
        self.waste_todate_dateedit.setMaximumDate(QDate.currentDate())
        self.horizontalLayout_12.addWidget(self.waste_todate_dateedit)
        spacerItem28 = QSpacerItem(40, 20, QSizePolicy.Expanding,
                                   QSizePolicy.Minimum)
        self.horizontalLayout_12.addItem(spacerItem28)
        self.waste_table_search_button = QPushButton(self.wastedetail_tab_1)
        self.waste_table_search_button.setObjectName(
            "waste_table_search_button")
        self.horizontalLayout_12.addWidget(self.waste_table_search_button)
        self.verticalLayout_8.addLayout(self.horizontalLayout_12)
        self.waste_table = QTableWidget(self.wastedetail_tab_1)
        self.waste_table.setObjectName("waste_table")
        self.waste_table.setColumnCount(5)
        self.waste_table.setRowCount(0)
        item = QTableWidgetItem()
        self.waste_table.setHorizontalHeaderItem(0, item)
        item = QTableWidgetItem()
        self.waste_table.setHorizontalHeaderItem(1, item)
        item = QTableWidgetItem()
        self.waste_table.setHorizontalHeaderItem(2, item)
        item = QTableWidgetItem()
        self.waste_table.setHorizontalHeaderItem(3, item)
        item = QTableWidgetItem()
        self.waste_table.setHorizontalHeaderItem(4, item)
        self.waste_table.horizontalHeader().setCascadingSectionResizes(False)
        self.waste_table.horizontalHeader().setStretchLastSection(True)
        self.waste_table.verticalHeader().setVisible(False)
        self.waste_table.verticalHeader().setCascadingSectionResizes(False)
        self.waste_table.setSortingEnabled(True)
        self.verticalLayout_8.addWidget(self.waste_table)
        self.horizontalLayout_13 = QHBoxLayout()
        self.horizontalLayout_13.setObjectName("horizontalLayout_13")
        self.waste_table_newrow_button = QPushButton(self.wastedetail_tab_1)
        self.waste_table_newrow_button.setObjectName(
            "waste_table_newrow_button")
        self.horizontalLayout_13.addWidget(self.waste_table_newrow_button)
        spacerItem29 = QSpacerItem(612, 20, QSizePolicy.Expanding,
                                   QSizePolicy.Minimum)
        self.horizontalLayout_13.addItem(spacerItem29)
        self.waste_table_discard_button = QPushButton(self.wastedetail_tab_1)
        self.waste_table_discard_button.setObjectName(
            "waste_table_discard_button")
        self.horizontalLayout_13.addWidget(self.waste_table_discard_button)
        self.verticalLayout_8.addLayout(self.horizontalLayout_13)
        self.verticalLayout_9.addLayout(self.verticalLayout_8)
        ##retranslate
        self.waste_fromdate_label.setText(
            QApplication.translate("MainWindow", "From Date", None,
                                   QApplication.UnicodeUTF8))
        self.waste_fromdate_dateedit.setDisplayFormat(
            QApplication.translate("MainWindow", "dd/MM/yyyy", None,
                                   QApplication.UnicodeUTF8))
        self.waste_todate_label.setText(
            QApplication.translate("MainWindow", "To Date", None,
                                   QApplication.UnicodeUTF8))
        self.waste_todate_dateedit.setDisplayFormat(
            QApplication.translate("MainWindow", "dd/MM/yyyy", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table_search_button.setText(
            QApplication.translate("MainWindow", "Search", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table.horizontalHeaderItem(0).setText(
            QApplication.translate("MainWindow", "Code", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table.horizontalHeaderItem(1).setText(
            QApplication.translate("MainWindow", "Item", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table.horizontalHeaderItem(2).setText(
            QApplication.translate("MainWindow", "Category", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table.horizontalHeaderItem(3).setText(
            QApplication.translate("MainWindow", "Quantity", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table.horizontalHeaderItem(4).setText(
            QApplication.translate("MainWindow", "Reason", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table_newrow_button.setText(
            QApplication.translate("MainWindow", "New Row", None,
                                   QApplication.UnicodeUTF8))
        self.waste_table_discard_button.setText(
            QApplication.translate("MainWindow", "Discard Item", None,
                                   QApplication.UnicodeUTF8))
        self.wastedetail_tab_1.setTabOrder(self.waste_fromdate_dateedit,
                                           self.waste_todate_dateedit)
        self.wastedetail_tab_1.setTabOrder(self.waste_todate_dateedit,
                                           self.waste_table_search_button)
        ###signals and slots && other stuffs
        # self.mainwindow = Ui_MainWindow  # just for the ease of finding the attributes in pycharm
        self.schedule = SchedulePurchase()
        self.suplier = BusinessParty(category='Supplier')
        self.add = AddStockInventory()
        self.item = WasteMenu()
        self.waste_fromdate_dateedit.setDate(QDate.currentDate())
        self.waste_todate_dateedit.setDate(QDate.currentDate())
        self.waste_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
        self.waste_table_newrow_button.clicked.connect(self.add_new_blank_rows)
        self.waste_table_discard_button.clicked.connect(self.discard)
        self.waste_table_search_button.clicked.connect(self.search_discard)
        self.wastedetail_tab_1.setFocusPolicy(Qt.StrongFocus)
        self.wastedetail_tab_1.focusInEvent = self.load_rows

    def load_rows(self, event=None):
        pass

    def add_new_blank_rows(self):
        """
        deletes the schedules in the database
        """
        table = self.waste_table
        item = table.item(0, 0)
        if item:
            message = QMessageBox.critical(QMessageBox(), 'Warning!',
                                           'This will remove all the entries',
                                           QMessageBox.Ok | QMessageBox.Cancel)
            if message == QMessageBox.Ok:
                table.setRowCount(0)
                table.clearContents()
                self.add_row_to_table('new')
                self.waste_table_discard_button.setVisible(True)
        elif not item:
            self.waste_table_discard_button.setVisible(True)
            self.add_row_to_table('new')

    def add_row_to_table(self, *args):
        """
        complex stuff of auto complete to be added to each combo box
        :return:
        """
        table = self.waste_table
        if args:
            if args[0] != 'new':
                table.clearContents()
                table.setRowCount(0)
                table.setRowCount(len(args))
                for i, j in enumerate(args):
                    code = QTableWidgetItem(j['code'])
                    table.setItem(i, 0, code)
                    item = QTableWidgetItem(j['item'])
                    table.setItem(i, 1, item)
                    category = QTableWidgetItem(j['category'])
                    table.setItem(i, 2, category)
                    quantity = QTableWidgetItem(str(j['quantity']))
                    table.setItem(i, 3, quantity)
                    reason = QTableWidgetItem(j['reason_for_discard'])
                    table.setItem(i, 4, reason)
            if args[0] == 'new':
                row = table.rowCount() + 1
                table.setRowCount(row)
                codeline = QLineEdit()
                codeline.editingFinished.connect(
                    lambda: self.get_details_of_code(row))
                table.setCellWidget(row - 1, 0, codeline)
                itemcombo = QComboBox()
                self.fill_item_list(itemcombo)
                itemcombo.currentIndexChanged.connect(
                    lambda: self.get_details_of_item(row))
                table.setCellWidget(row - 1, 1, itemcombo)
                category = QTableWidgetItem()
                table.setItem(row - 1, 2, category)
                quantity = QLineEdit()
                table.setCellWidget(row - 1, 3, quantity)
                combo = QComboBox()
                combo.addItem("Cancelled")
                combo.addItem("Mishandling")
                combo.addItem("Excess")
                table.setCellWidget(row - 1, 4, combo)
        table.setColumnWidth(0, (table.width() / 5))
        table.setColumnWidth(1, (table.width() / 5))
        table.setColumnWidth(2, (table.width() / 5))
        table.setColumnWidth(3, (table.width() / 5))
        table.horizontalHeader().setStretchLastSection(
            True
        )  # important to resize last section else blank space after last column

    def fill_item_list(self, combo):
        """
        fill the item combo box
        :param combo: the combobox object
        :return: none
        """
        itemfield = combo
        itemfield.setStyleSheet("QAbstractItemView{"
                                "background: #4B77BE;"
                                "}")
        self.item.populate_item(itemfield)

    def get_details_of_code(self, rowcount):
        """
        fills the item, category and units based on the code
        :param rowcount: the row count
        :return: none
        """
        row = rowcount - 1
        table = self.waste_table
        codeline = table.cellWidget(row, 0)
        data = self.item.get_details_of_code(codeline.text())
        item = table.cellWidget(row, 1)
        index = item.findText(data['item'])
        item.setCurrentIndex(index)
        category = table.item(row, 2)
        category.setText(data['category'])

    def get_details_of_item(self, rowcount):
        """
        fills the code, category and units based on the item
        :param rowcount: the row count
        :return: none
        """
        row = rowcount - 1
        table = self.waste_table
        itemcombo = table.cellWidget(row, 1)
        data = self.item.get_details_of_item(itemcombo.currentText())
        code = table.cellWidget(row, 0)
        code.setText(data['code'])
        category = table.item(row, 2)
        category.setText(data['category'])

    def discard(self):
        """
        saves the details in db before printing
        """
        logger.info('WasteDish discard initiated')
        table = self.waste_table
        data = self.get_data()
        if data:
            for i in data:
                status = self.item.discard(i)
                if status:
                    model_index = table.indexFromItem(i['model_item'])
                    row = model_index.row()
                    table.removeRow(row)
                else:
                    msg = QMessageBox.critical(QMessageBox(), "Error!!",
                                               "The item cannot be discarded",
                                               QMessageBox.Ok)
                    if msg == QMessageBox.Ok:
                        return False

    def search_discard(self):
        """
        searches the discard from_date and to_date
        :return:none
        """
        table = self.waste_table
        item = table.cellWidget(0, 0)
        if item:
            msg = QMessageBox.critical(QMessageBox(), 'Warning!',
                                       'This will delete all the rows added',
                                       QMessageBox.Ok | QMessageBox.Cancel)
            if msg == QMessageBox.Cancel:
                return False
        f_date = self.waste_fromdate_dateedit.text()
        from_date = datetime.strptime(f_date, '%d/%m/%Y')
        t_date = self.waste_todate_dateedit.text()
        to_date = datetime.strptime(t_date, '%d/%m/%Y')
        to_date = to_date + timedelta(hours=23, minutes=59, seconds=59)
        dataobj = self.item.find_itemdiscard(from_date=from_date,
                                             to_date=to_date)
        self.add_row_to_table(*dataobj)
        self.waste_table_discard_button.setVisible(False)

    def get_data(self):
        """
        :return: fetches all the data for printing
        """
        table = self.waste_table
        rows = table.rowCount()
        dataobj = []
        for i in range(rows):
            dictionary = {}
            item = table.cellWidget(i, 0) if table.cellWidget(
                i, 0) is not None else table.item(i, 0)
            dictionary['code'] = item.text()
            if dictionary['code'] == '':
                break
            item = table.cellWidget(i, 1).currentText() if table.cellWidget(
                i, 1) is not None else table.item(i, 1).text()
            dictionary['item'] = item
            item = table.cellWidget(i, 2) if table.cellWidget(
                i, 2) is not None else table.item(i, 2)
            dictionary['category'] = item.text()
            item = table.cellWidget(i, 3) if table.cellWidget(
                i, 3) is not None else table.item(i, 3)
            dictionary['quantity'] = item.text()
            if dictionary['quantity'] == '':
                self.show_error('Quantity')
                return False
            item = table.cellWidget(i, 4).currentText() if table.cellWidget(
                i, 4) is not None else table.item(i, 4).text()
            dictionary['reason_for_discard'] = item
            dictionary['model_item'] = table.item(i, 2)
            dataobj.append(dictionary)
        return dataobj

    def show_error(self, text):
        """
        :return: pops up an error
        """
        QMessageBox.critical(QMessageBox(), "Fail!!",
                             "Please Enter %s properly" % text, QMessageBox.Ok)
Esempio n. 10
0
class ReportMovementPanel(PanelWithTable):

    columnList = "EVENT_ID;EVENT_TYPE; EVENT_SUB_TYPE; EVENT_DIRECTION; ASSET_NAME; EVENT_DATE; QUANTITY; PRICE; RATE; GROSS_AMOUNT; NET_AMOUNT; COMMISSION_PERCENTAGE; COMMISSION_AMOUNT; COMMISSION_IVA_AMOUNT; TENOR; MATURITY_DATE; CUSTODY_NAME; TAX_ID; TAX_AMOUNT; COMMENT; EXTERNAL_ID".split(
        ";")

    def __init__(self):
        super(self.__class__, self).__init__()
        self.layout = QtGui.QGridLayout(self)
        self.reportMovementFilter = ReportMovementFilter(self)
        self.layout.addWidget(self.reportMovementFilter, 1, 0,
                              QtCore.Qt.AlignTop)
        self.layout.addWidget(self.createTable(), 1, 1, QtCore.Qt.AlignTop)

    def createTable(self):
        self.table = QTableWidget()
        self.table.setRowCount(1000)
        self.table.setColumnCount(len(self.columnList))
        self.table.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
        self.table.setHorizontalHeaderLabels(self.columnList)
        #self.pnLTableWidget.resizeColumnsToContents()
        self.table.sortItems(Constant.CONST_COLUMN_REPORT_MOVEMENT_EVENT_DATE)
        self.table.resizeRowsToContents()
        self.table.setFixedSize(1100, 900)
        return self.table

    def doSubmit(self, fromDate, toDate, movementType, assetName, custodyName):
        reportMovementLO = Engine.getReportMovementList(
            fromDate, toDate, movementType, assetName, custodyName)
        self.table.setSortingEnabled(False)
        self.table.clearContents()
        self.table.setRowCount(len(reportMovementLO.movementList))
        self.renderTable(reportMovementLO.movementList)
        self.table.setSortingEnabled(True)
        self.table.resizeRowsToContents()

    def renderTable(self, tableList):
        row = 0
        isBold = False
        for listItem in tableList:
            self.addItemtoTable(self.table, listItem, row,
                                Constant.CONST_COLUMN_REPORT_MOVEMENT_EVENT_ID,
                                isBold)
            self.addItemtoTable(
                self.table, listItem, row,
                Constant.CONST_COLUMN_REPORT_MOVEMENT_EVENT_TYPE, isBold)
            self.addItemtoTable(
                self.table, listItem, row,
                Constant.CONST_COLUMN_REPORT_MOVEMENT_EVENT_SUB_TYPE, isBold)
            self.addItemtoTable(
                self.table, listItem, row,
                Constant.CONST_COLUMN_REPORT_MOVEMENT_EVENT_DIRECTION, isBold)
            self.addItemtoTable(
                self.table, listItem, row,
                Constant.CONST_COLUMN_REPORT_MOVEMENT_ASSET_NAME, isBold)
            self.addItemtoTable(
                self.table, listItem, row,
                Constant.CONST_COLUMN_REPORT_MOVEMENT_EVENT_DATE, isBold)
            self.addItemtoTable(self.table, listItem, row,
                                Constant.CONST_COLUMN_REPORT_MOVEMENT_QUANTITY,
                                isBold)
            self.addItemtoTable(self.table, listItem, row,
                                Constant.CONST_COLUMN_REPORT_MOVEMENT_PRICE,
                                isBold)
            self.addItemtoTable(self.table, listItem, row,
                                Constant.CONST_COLUMN_REPORT_MOVEMENT_RATE,
                                isBold)
            self.addItemtoTable(
                self.table, listItem, row,
                Constant.CONST_COLUMN_REPORT_MOVEMENT_GROSS_AMOUNT, isBold)
            self.addItemtoTable(
                self.table, listItem, row,
                Constant.CONST_COLUMN_REPORT_MOVEMENT_NET_AMOUNT, isBold)
            self.addItemtoTable(
                self.table, listItem, row,
                Constant.CONST_COLUMN_REPORT_MOVEMENT_COMMISSION_PERCENTAGE,
                isBold)
            self.addItemtoTable(
                self.table, listItem, row,
                Constant.CONST_COLUMN_REPORT_MOVEMENT_COMMISSION_AMOUNT,
                isBold)
            self.addItemtoTable(
                self.table, listItem, row,
                Constant.CONST_COLUMN_REPORT_MOVEMENT_COMMISSION_IVA_AMOUNT,
                isBold)
            self.addItemtoTable(self.table, listItem, row,
                                Constant.CONST_COLUMN_REPORT_MOVEMENT_TENOR,
                                isBold)
            self.addItemtoTable(
                self.table, listItem, row,
                Constant.CONST_COLUMN_REPORT_MOVEMENT_CUSTODY_NAME, isBold)
            self.addItemtoTable(self.table, listItem, row,
                                Constant.CONST_COLUMN_REPORT_MOVEMENT_TAX_ID,
                                isBold)
            self.addItemtoTable(
                self.table, listItem, row,
                Constant.CONST_COLUMN_REPORT_MOVEMENT_TAX_AMOUNT, isBold)
            self.addItemtoTable(self.table, listItem, row,
                                Constant.CONST_COLUMN_REPORT_MOVEMENT_COMMENT,
                                isBold)
            self.addItemtoTable(
                self.table, listItem, row,
                Constant.CONST_COLUMN_REPORT_MOVEMENT_EXTERNAL_ID, isBold)
            row += 1
Esempio n. 11
0
class Ui_MainWindow(QMainWindow):
    """Cette classe contient tous les widgets de notre application."""
    
    defaultPalette = QPalette()
    defaultPalette.setColor(QPalette.Base, QColor("#151515"))
    defaultPalette.setColor(QPalette.Text, Qt.white)

    def __init__(self):
        super(Ui_MainWindow, self).__init__()
        # initialise la GUI avec un exemple
        self.text = "Ceci est un petit texte d'exemple."
        # les variables sont en place, initialise la GUI
        self.initUI()
        # exécute l'exemple
        self.orgText.setText(self.text)
        self.encode_text(False)
        self.logLab.setText(
            u"Saisir du texte ou importer un fichier, puis pousser \n"
            u"le bouton correspondant à l'opération souhaitée.")

    def initUI(self):
        """Met en place les éléments de l'interface."""
        # -+++++++------------------- main window -------------------+++++++- #
        self.setWindowTitle(u"Encodage / Décodage de Huffman")
        self.centerAndResize()
        centralwidget = QWidget(self)
        mainGrid = QGridLayout(centralwidget)
        mainGrid.setColumnMinimumWidth(0, 450)
        # -+++++++------------------ groupe analyse -----------------+++++++- #
        analysGroup = QGroupBox(u"Analyse", centralwidget)
        self.analysGrid = QGridLayout(analysGroup)
        #         ----------- groupe de la table des codes ----------         #
        codeTableGroup = QGroupBox(u"Table des codes", analysGroup)
        codeTableGrid = QGridLayout(codeTableGroup)
        # un tableau pour les codes
        self.codesTableModel = MyTableModel()
        self.codesTable = QTableView(codeTableGroup)
        self.codesTable.setModel(self.codesTableModel)
        self.codesTable.setFont(QFont("Mono", 8))
        self.codesTable.resizeColumnsToContents()
        self.codesTable.setSortingEnabled(True)
        codeTableGrid.addWidget(self.codesTable, 0, 0, 1, 1)
        self.analysGrid.addWidget(codeTableGroup, 1, 0, 1, 1)
        #        ----------- label du ratio de compression ----------         #
        self.ratioLab = QLabel(u"Ratio de compression: ", analysGroup)
        font = QFont()
        font.setBold(True)
        font.setWeight(75)
        font.setKerning(True)
        self.ratioLab.setFont(font)
        self.analysGrid.addWidget(self.ratioLab, 2, 0, 1, 1)
        # -+++++++-------- groupe de la table de comparaison --------+++++++- #
        self.compGroup = QGroupBox(analysGroup)
        self.compGroup.setTitle(u"Comparaisons")
        compGrid = QGridLayout(self.compGroup)
        # un tableau pour le ratio
        self.compTable = QTableWidget(self.compGroup)
        sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(
            self.compTable.sizePolicy().hasHeightForWidth())
        self.compTable.setSizePolicy(sizePolicy)
        self.compTable.setBaseSize(QSize(0, 0))
        font = QFont()
        font.setWeight(50)
        self.compTable.setFont(font)
        self.compTable.setEditTriggers(QAbstractItemView.NoEditTriggers)
        self.compTable.setShowGrid(True)
        self.compTable.setGridStyle(Qt.SolidLine)
        # lignes / colonnes
        self.compTable.setColumnCount(2)
        self.compTable.setRowCount(3)
        self.compTable.setVerticalHeaderItem(0, QTableWidgetItem("Taille (bits)"))
        self.compTable.setVerticalHeaderItem(1, QTableWidgetItem("Entropie"))
        self.compTable.setVerticalHeaderItem(2, QTableWidgetItem("Taille moy. (bits)"))
        for i in range(2):
            self.compTable.verticalHeaderItem(i).setTextAlignment(
                Qt.AlignRight)
        self.compTable.setHorizontalHeaderItem(0, QTableWidgetItem("ASCII"))
        self.compTable.setHorizontalHeaderItem(1, QTableWidgetItem("Huffman"))
        
        # nom des items
        self.compTabASCIIMem = QTableWidgetItem()
        self.compTable.setItem(0, 0, self.compTabASCIIMem)
        self.compTabASCIIEnt = QTableWidgetItem()
        self.compTable.setItem(1, 0, self.compTabASCIIEnt)
        self.compTabASCIIAvg = QTableWidgetItem()
        self.compTable.setItem(2, 0, self.compTabASCIIAvg)
        self.compTabHuffMem = QTableWidgetItem()
        self.compTable.setItem(0, 1, self.compTabHuffMem)
        self.compTabHuffEnt = QTableWidgetItem()
        self.compTable.setItem(1, 1, self.compTabHuffEnt)
        self.compTabHuffAvg = QTableWidgetItem()
        self.compTable.setItem(2, 1, self.compTabHuffAvg)
        # parem du tableau
        self.compTable.horizontalHeader().setCascadingSectionResizes(False)
        self.compTable.verticalHeader().setVisible(True)
        font = QFont("Mono", 8)
        self.compTable.setFont(font)
        compGrid.addWidget(self.compTable, 1, 0, 1, 1)
        self.analysGrid.addWidget(self.compGroup, 0, 0, 1, 1)
        mainGrid.addWidget(analysGroup, 0, 1, 1, 1)
        # -+++++++----------------- groupe du texte -----------------+++++++- #
        groupBox = QGroupBox(u"Texte", centralwidget)
        textGrid = QGridLayout(groupBox)
        # -+++++++------------- groupe du texte original ------------+++++++- #
        orgTextGroup = QGroupBox(u"Texte original (Ctrl+T)", groupBox)
        orgTextGrid = QGridLayout(orgTextGroup)
        self.orgText = QTextEdit(orgTextGroup)
        self.orgText.setPalette(self.defaultPalette)
        orgTextGrid.addWidget(self.orgText, 0, 0, 1, 1)
        textGrid.addWidget(orgTextGroup, 0, 0, 1, 2)
        # -+++++++------------ groupe du texte compressé ------------+++++++- #
        compressedTextGroup = QGroupBox(u"Texte compressé (Ctrl+H)", groupBox)
        compressedTextGrid = QGridLayout(compressedTextGroup)
        self.compressedText = QTextEdit(compressedTextGroup)
        self.compressedText.setPalette(self.defaultPalette)
        compressedTextGrid.addWidget(self.compressedText, 0, 0, 1, 1)
        textGrid.addWidget(compressedTextGroup, 1, 0, 1, 2)
        # -+++++++------------ groupe pour le texte ascii -----------+++++++- #
        asciiTextGroup = QGroupBox(u"Texte ASCII", groupBox)
        asciiTextGrid = QGridLayout(asciiTextGroup)
        self.asciiText = QTextBrowser(asciiTextGroup)
        self.asciiText.setPalette(self.defaultPalette)
        asciiTextGrid.addWidget(self.asciiText, 0, 0, 1, 1)
        textGrid.addWidget(asciiTextGroup, 2, 0, 1, 2)
        # -+++++++-------------------- label de log -----------------+++++++- #
        self.logLab = QLabel(analysGroup)
        textGrid.addWidget(self.logLab, 3, 0, 1, 2)
        # -+++++++----------- bouton pour encoder le texte ----------+++++++- #
        self.encodeBut = QPushButton(groupBox)
        self.encodeBut.setStatusTip(
            u"Cliquez sur ce bouton pour encoder le texte original.")
        self.encodeBut.setText(u"ENCODER")
        self.encodeBut.clicked.connect(self.encode_text)
        textGrid.addWidget(self.encodeBut, 4, 0, 1, 1)
        # -+++++++----------- bouton pour décoder le texte ----------+++++++- #
        self.decodeBut = QPushButton(groupBox)
        self.decodeBut.setStatusTip(
            u"Cliquez sur ce bouton pour décoder le texte compressé.")
        self.decodeBut.setText(u"DÉCODER")
        self.decodeBut.clicked.connect(self.decode_text)
        textGrid.addWidget(self.decodeBut, 4, 1, 1, 1)
        mainGrid.addWidget(groupBox, 0, 0, 1, 1)
        self.setCentralWidget(centralwidget)
        # -+++++++--------------- une barre de statut ---------------+++++++- #
        self.setStatusBar(QStatusBar(self))
        # -+++++++--------------------- le menu ---------------------+++++++- #
        self.fileMenu = QMenu(u"Fichier")
        self.fileMenu.addAction(u"Importer un texte...", self.open_text)
        self.fileMenu.addAction(
            u"Importer un texte encodé...", lambda: self.open_text(True))
        self.fileMenu.addAction(u"Importer un dictionnaire...", self.open_dict)
        self.fileMenu.addAction(u"Enregistrer le dictionnaire...", self.save_dict)
        self.fileMenu.addAction(u"Quitter", self.close)
        self.menuBar().addMenu(self.fileMenu)
        QMetaObject.connectSlotsByName(self)

    def open_text(self, compressed=False):
        """Ouvrir un fichier contenant un texte compressé ou non."""
        fname, _ = QFileDialog.getOpenFileName(self, u'Ouvrir')
        f = open(fname, 'r')
        with f:
            data = f.read()
            if compressed:
                self.compressedText.setText(data)
            else:
                self.orgText.setText(data)

    def open_dict(self):
        """Ouvrir un dictionnaire de codes Huffman."""
        fname, _ = QFileDialog.getOpenFileName(self, u'Ouvrir')
        self.occ = {}
        self.hCodes = {}
        self.aCodes = {}
        self.hCost = {}
        self.aCost = {}
        self.hCodes = create_dict_from_file(fname)
        self.update_codes_table()
        self.logLab.setText(u"Dictionnaire de Huffman importé.")
        return self.hCodes

    def save_dict(self):
        """Enregistrer le dictionnaire de codes Huffman."""
        fname, _ = QFileDialog.getSaveFileName(self, "Enregistrer sous")
        save_dict_to_file(fname, self.hCodes)

    def make_tab_rows(self):
        """Génère le remplissage des lignes du tableau des codes."""
        dictList = [self.occ, self.aCodes, self.hCodes, self.aCost, self.hCost]
        tabList = []
        charList = self.hCodes.keys() if self.hCodes else self.occ.keys()
        for char in charList:
            l = ["'" + char + "'"]
            for dic in dictList:
                try:
                    l.append(dic[char])
                except KeyError:
                    l.append('')
            tabList.append(l)
        return tabList

    def encode_text(self, wizard=True):
        """Encode le texte original."""
        self.text = self.orgText.toPlainText().encode('utf-8')
        if not self.text:
            self.compressedText.setText(u"")
            self.asciiText.setText(u"")
            self.logLab.setText(
                u"<font color=#A52A2A>Rien à compresser.</font>")
            return
        self.occ = {}
        self.tree = ()
        self.hCodes = {}
        self.aCodes = {}
        self.hCost = {}
        self.aCost = {}
        self.hSqueezed = []
        self.aSqueezed = []
        self.stringHSqueezed = ''
        self.stringASqueezed = ''
        if wizard:
            self.launch_wizard(
                EncodeWizard(self),
                u"<font color=#008000>Compression achevée.</font>")
        else:
            self.make_occ()
            self.make_tree()
            self.make_codes()
            self.make_cost()
            self.make_encoded_text()
            self.make_comp()

    def decode_text(self, wizard=True):
        """Décode le texte compressé."""
        self.codeString = str(
            self.compressedText.toPlainText().replace(' ', ''))
        if not self.codeString or not self.hCodes:
            self.orgText.setText(u"")
            self.asciiText.setText(u"")
            if not self.codeString:
                self.logLab.setText(
                    u"<font color=#A52A2A>Rien à décompresser.</font>")
            if not self.hCodes:
                self.logLab.setText(
                    u"<font color=#A52A2A>Dictionnaire indisponible pour la décompression.</font>")
            return
        self.text = ''
        self.stringASqueezed = ''
        if wizard:
            self.launch_wizard(
                DecodeWizard(self),
                u"<font color=#008000>Texte décompressé.</font>")
        else:
            self.make_code_map()
            self.make_decoded_text()

    def launch_wizard(self, wizard, finishString):
        """Lance l'assistant d'en/décodage pour guider l'utilisateur.
        Cache les options inaccessibles pendant l'assistant.
        """
        self.logLab.setText(
            u"<font color=#9E6A00>Opération en cours. "
            u"Suivre les indications.</font>")
        disItems = [self.orgText, self.compressedText, self.encodeBut,
                    self.decodeBut, self.fileMenu.actions()[1],
                    self.fileMenu.actions()[2], self.fileMenu.actions()[3]]
        for item in disItems:
            item.setEnabled(False)
        self.compGroup.setVisible(False)
        self.analysGrid.addWidget(wizard, 0, 0, 1, 1)
        res = wizard.exec_()
        if res:
            self.logLab.setText(finishString)
        else:
            self.logLab.setText(
                u"<font color=#A52A2A>Opération interrompue.</font>")
        for item in disItems:
            item.setEnabled(True)
        self.compGroup.setVisible(True)

    def update_ratio_lab(self):
        """Replace la valeur du label du ratio de compression."""
        if not self.stringASqueezed:
            val = '/'
        else:
            val = (len(self.stringHSqueezed.replace(' ', '')) /
                   float(len(self.stringASqueezed.replace(' ', ''))))
        self.ratioLab.setText(unicode('Taux de compression:  ' + str(val)))

    def update_comp_table(self):
        """Met à jour le tableau de comparaison ASCII VS Huffman."""
        self.compTabASCIIMem.setText(unicode(len(''.join(self.aSqueezed))))
        self.compTabHuffMem.setText(unicode(len(''.join(self.hSqueezed))))
        # entropie ?
        self.compTabASCIIEnt.setText('0')
        self.compTabHuffEnt.setText('0')
        self.compTabASCIIAvg.setText(unicode(8))
        self.compTabHuffAvg.setText(unicode(
            average_code_length(self.hSqueezed)))
        self.compTable.resizeColumnsToContents()

    def update_codes_table(self, hlRow=[]):
        """Met à jour le tableau des codes et surligne les lignes de hlRow."""
        self.codesTableModel.hlRow = hlRow
        self.codesTableModel.emptyTable()
        self.codesTableModel.fillTable(self.make_tab_rows())
        self.codesTable.resizeColumnsToContents()

    def centerAndResize(self):
        """Centre et redimmensionne le widget.""" 
        screen = QDesktopWidget().screenGeometry()
        self.resize(screen.width() / 1.6, screen.height() / 1.4)
        size = self.geometry()
        self.move(
            (screen.width() - size.width()) / 2,
            (screen.height() - size.height()) / 2)

    #===================== METHODS FOR EN/DECODE WIZARDS =====================#
    def make_encode_init(self):
        self.compressedText.setText(unicode(self.stringHSqueezed))
        self.asciiText.setText(unicode(self.stringASqueezed))
        self.orgText.setTextColor(QColor(Qt.darkGreen))
        self.orgText.setText(unicode(self.text.decode('utf-8')))
        self.update_codes_table()

    def make_occ(self):
        self.orgText.setTextColor(QColor(Qt.white))
        self.orgText.setText(unicode(self.text.decode('utf-8')))
        self.occ = occurences(self.text)
        self.update_codes_table([0, 1])

    def make_tree(self):
        self.tree = make_trie(self.occ)
        self.update_codes_table()

    def make_codes(self):
        self.hCodes = make_codes(self.tree, {})
        self.aCodes = make_ascii_codes(self.occ.keys(), {})
        self.update_codes_table([2, 3])

    def make_cost(self):
        self.hCost = tree_cost(self.hCodes, self.occ)
        self.aCost = tree_cost(self.aCodes, self.occ)
        self.update_codes_table([4, 5])

    def make_encoded_text(self):
        self.hSqueezed = squeeze(self.text, self.hCodes)
        self.aSqueezed = squeeze(self.text, self.aCodes)
        self.stringHSqueezed = ' '.join(self.hSqueezed)
        self.stringASqueezed = ' '.join(self.aSqueezed)
        self.compressedText.setTextColor(QColor(Qt.darkGreen))
        self.asciiText.setTextColor(QColor(Qt.darkYellow))
        self.compressedText.setText(unicode(self.stringHSqueezed))
        self.asciiText.setText(unicode(self.stringASqueezed))
        self.update_codes_table()

    def make_comp(self):
        self.compressedText.setTextColor(QColor(Qt.white))
        self.asciiText.setTextColor(QColor(Qt.white))
        self.compressedText.setText(unicode(self.stringHSqueezed))
        self.asciiText.setText(unicode(self.stringASqueezed))
        self.update_codes_table()
        self.update_comp_table()
        self.update_ratio_lab()

    def make_decode_init(self):
        self.orgText.setText(unicode(self.text))
        self.asciiText.setText(unicode(self.stringASqueezed))
        self.compressedText.setTextColor(QColor(Qt.darkGreen))
        self.compressedText.setText(self.compressedText.toPlainText())

    def make_code_map(self):
        self.compressedText.setTextColor(QColor(Qt.white))
        self.compressedText.setText(self.compressedText.toPlainText())
        self.orgText.setText(unicode(self.text))
        self.asciiText.setText(unicode(self.stringASqueezed))
        self.codeMap = dict(zip(self.hCodes.values(), self.hCodes.keys()))
        self.update_codes_table([0, 3])

    def make_decoded_text(self):
        self.unSqueezed = unsqueeze(self.codeString, self.codeMap)
        self.text = ''.join(self.unSqueezed)
        self.orgText.setTextColor(QColor(Qt.darkGreen))
        self.orgText.setText(unicode(self.text.decode('utf-8')))
        self.asciiText.setText(unicode(self.stringASqueezed))
        self.update_codes_table()

    def make_ascii_decode(self):
        self.orgText.setTextColor(QColor(Qt.white))
        self.orgText.setText(unicode(self.text.decode('utf-8')))
        self.aCodes = make_ascii_codes(self.codeMap.values(), {})
        self.aSqueezed = squeeze(self.text, self.aCodes)
        self.stringASqueezed = ' '.join(self.aSqueezed)
        self.occ = occurences(self.text)
        self.hCost = tree_cost(self.hCodes, self.occ)
        self.aCost = tree_cost(self.aCodes, self.occ)
        self.asciiText.setTextColor(QColor(Qt.darkGreen))
        self.asciiText.setText(unicode(self.stringASqueezed))
        self.update_codes_table([1, 2, 4, 5])
Esempio n. 12
0
class MenuWeekday():
    """Tab to manage menu entry for each day"""
    global logger

    def __init__(self, day):
        ####
        logger.info('Inside MenuWeekday')
        self.menudetail_tab_1 = QWidget()
        self.menudetail_tab_1.setObjectName("menudetail_tab_1")
        self.gridLayout_20 = QGridLayout(self.menudetail_tab_1)
        self.gridLayout_20.setObjectName("gridLayout_20")
        self.menu_table = QTableWidget(self.menudetail_tab_1)
        self.menu_table.setSortingEnabled(True)
        self.menu_table.setObjectName("menu_table")
        self.menu_table.setColumnCount(6)
        self.menu_table.setRowCount(0)
        item = QTableWidgetItem()
        self.menu_table.setHorizontalHeaderItem(0, item)
        item = QTableWidgetItem()
        self.menu_table.setHorizontalHeaderItem(1, item)
        item = QTableWidgetItem()
        self.menu_table.setHorizontalHeaderItem(2, item)
        item = QTableWidgetItem()
        self.menu_table.setHorizontalHeaderItem(3, item)
        item = QTableWidgetItem()
        self.menu_table.setHorizontalHeaderItem(4, item)
        item = QTableWidgetItem()
        self.menu_table.setHorizontalHeaderItem(5, item)
        self.menu_table.horizontalHeader().setCascadingSectionResizes(False)
        self.menu_table.horizontalHeader().setStretchLastSection(True)
        self.menu_table.verticalHeader().setVisible(True)
        self.menu_table.verticalHeader().setCascadingSectionResizes(True)
        self.gridLayout_20.addWidget(self.menu_table, 0, 0, 1, 3)
        spacerItem22 = QSpacerItem(612, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
        self.gridLayout_20.addItem(spacerItem22, 1, 0, 1, 1)
        self.menu_table_refresh_button = QPushButton(self.menudetail_tab_1)
        self.menu_table_refresh_button.setObjectName("menu_table_refresh_button")
        self.gridLayout_20.addWidget(self.menu_table_refresh_button, 1, 1, 1, 1)
        self.menu_table_add_button = QPushButton(self.menudetail_tab_1)
        self.menu_table_add_button.setObjectName("menu_table_add_button")
        self.gridLayout_20.addWidget(self.menu_table_add_button, 1, 2, 1, 1)
        ####retranslate
        self.menu_table.horizontalHeaderItem(0).setText(
            QApplication.translate("MainWindow", "Code", None, QApplication.UnicodeUTF8))
        self.menu_table.horizontalHeaderItem(1).setText(
            QApplication.translate("MainWindow", "Item", None, QApplication.UnicodeUTF8))
        self.menu_table.horizontalHeaderItem(2).setText(
            QApplication.translate("MainWindow", "Category", None, QApplication.UnicodeUTF8))
        self.menu_table.horizontalHeaderItem(3).setText(
            QApplication.translate("MainWindow", "Rate", None, QApplication.UnicodeUTF8))
        self.menu_table.horizontalHeaderItem(4).setText(
            QApplication.translate("MainWindow", "Per Day", None, QApplication.UnicodeUTF8))
        self.menu_table.horizontalHeaderItem(5).setText(
            QApplication.translate("MainWindow", "Available", None, QApplication.UnicodeUTF8))
        self.menu_table_refresh_button.setText(
            QApplication.translate("MainWindow", "Refresh", None, QApplication.UnicodeUTF8))
        self.menu_table_add_button.setText(
            QApplication.translate("MainWindow", "Add Dish", None, QApplication.UnicodeUTF8))
        ###signals and slots && other stuffs
        # self.mainwindow = Ui_MainWindow  # just for the ease of finding the attributes in pycharm
        self.day = day
        self.menu_table_add_button.clicked.connect(self.add_menu)
        self.menu_table.itemDoubleClicked.connect(self.popup_edit)
        self.menu_table_refresh_button.clicked.connect(self.update_menu)
        self.menu_table.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.menu_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
        self.menu_table.setShowGrid(False)
        self.menu_table.setAlternatingRowColors(True)
        self.update_menu()
        self.popup = object
        self.menudetail_tab_1.setFocusPolicy(Qt.StrongFocus)
        self.menudetail_tab_1.focusInEvent = self.load_rows
        self.assign_shortcuts()

    def assign_shortcuts(self):
        """assign shortcuts"""
        QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_menumgtmonsun_view']),
                  self.menudetail_tab_1, self.row_selected)
        QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_menumgtmonsun_refresh']),
                  self.menudetail_tab_1, self.update_menu)
        QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_menumgtmonsun_add']),
                  self.menudetail_tab_1, self.add_menu)

    def row_selected(self):
        """selets a row entry"""
        rows = sorted(set(index.row() for index in
                          self.menu_table.selectedIndexes()))
        if rows:
            code = self.menu_table.item(rows[0], 0).text()
            name = self.menu_table.item(rows[0], 1).text()
            quantity = self.menu_table.item(rows[0], 4).text()
            self.add_menu(code, name, quantity)

    def add_menu(self, *args):
        """
        :return: Pops up a new dialogue to add the menus
        """
        if not args:
            self.popup = AddMenuFromList(parent=self, day=self.day)
            self.popup.exec_()
        else:
            self.popup = MenuQuantityEditPopup(parent=self, day=self.day, code=args[0], name=args[1], quantity=args[2])
            self.popup.exec_()

    def update_menu(self):
        """
        :return:Populates the menu table
        """
        menu = WeeklyMenu(day=self.day)
        menulist = menu.load_dish_per_Day()
        if not menulist == []:
            self.add_row(*menulist)
        else:
            self.menu_table.clearContents()
            self.menu_table.setRowCount(0)

    def popup_edit(self, item):
        """
        Pops up the menu to be edited
        :param item: item clicked
        :return:none
        """
        model_index = self.menu_table.indexFromItem(item)
        row = model_index.row()
        code = self.menu_table.item(row, 0).text()
        name = self.menu_table.item(row, 1).text()
        quantity = self.menu_table.item(row, 4).text()
        self.add_menu(code, name, quantity)

    def add_row(self, *args):
        """creates a new row entry"""
        table = self.menu_table
        if args:
            table.setRowCount(len(args))
            for i, j in enumerate(args):
                item = QTableWidgetItem(j['item_no'])
                table.setItem(i, 0, item)
                item = QTableWidgetItem(j['item'])
                table.setItem(i, 1, item)
                item = QTableWidgetItem(j['category'])
                table.setItem(i, 2, item)
                item = QTableWidgetItem(j['rate'])
                table.setItem(i, 3, item)
                item = QTableWidgetItem(j['per_day'])
                table.setItem(i, 4, item)
                item = QTableWidgetItem(j['available'])
                table.setItem(i, 5, item)
        table.setColumnWidth(0, table.width() / 6)
        table.setColumnWidth(1, table.width() / 6)
        table.setColumnWidth(2, table.width() / 6)
        table.setColumnWidth(3, table.width() / 6)
        table.setColumnWidth(4, table.width() / 6)

    def load_rows(self, event):
        """
        :return:checks and adds new rows
        """
        self.add_row()
Esempio n. 13
0
class ReportEmployeeTestDialogue(QDialog):
    """
    Employee Report Popup Manager
    """
    global logger

    def __init__(self, code=None, parent=None):
        logger.info('Inside ReportEmployeeTestDialogue')
        super(ReportEmployeeTestDialogue, self).__init__(parent)
        self.resize(500, 500)
        self.vertical_23 = QVBoxLayout(self)
        self.vertical_23.setObjectName("vertical_23")
        self.label_1 = QLabel(self)
        self.vertical_23.addWidget(self.label_1)
        self.report_health_table = QTableWidget(self)
        self.report_health_table.setObjectName("report_health_table")
        self.report_health_table.setColumnCount(5)
        self.report_health_table.setRowCount(0)
        self.report_health_table.setSelectionBehavior(
            QAbstractItemView.SelectRows)
        item = QTableWidgetItem()
        self.report_health_table.setHorizontalHeaderItem(0, item)
        item = QTableWidgetItem()
        self.report_health_table.setHorizontalHeaderItem(1, item)
        item = QTableWidgetItem()
        self.report_health_table.setHorizontalHeaderItem(2, item)
        item = QTableWidgetItem()
        self.report_health_table.setHorizontalHeaderItem(3, item)
        item = QTableWidgetItem()
        self.report_health_table.setHorizontalHeaderItem(4, item)
        self.report_health_table.horizontalHeader().setCascadingSectionResizes(
            True)
        self.report_health_table.horizontalHeader().setStretchLastSection(True)
        self.report_health_table.verticalHeader().setCascadingSectionResizes(
            True)
        self.vertical_23.addWidget(self.report_health_table)
        self.horizontal_21 = QHBoxLayout()
        self.report_health_newrow_buttuon = QPushButton(self)
        self.report_health_newrow_buttuon.setObjectName(
            "report_health_newrow_buttuon")
        self.horizontal_21.addWidget(self.report_health_newrow_buttuon)
        spacerItem23 = QSpacerItem(40, 20, QSizePolicy.Expanding,
                                   QSizePolicy.Minimum)
        self.horizontal_21.addItem(spacerItem23)
        self.vertical_23.addLayout(self.horizontal_21)
        ### retanslate
        self.setWindowTitle(
            QApplication.translate("MainWindow", "Health Report", None,
                                   QApplication.UnicodeUTF8))
        self.label_1.setText(
            QApplication.translate("MainWindow", "Health Report", None,
                                   QApplication.UnicodeUTF8))
        self.report_health_table.horizontalHeaderItem(0).setText(
            QApplication.translate("MainWindow", "Code", None,
                                   QApplication.UnicodeUTF8))
        self.report_health_table.horizontalHeaderItem(1).setText(
            QApplication.translate("MainWindow", "Date", None,
                                   QApplication.UnicodeUTF8))
        self.report_health_table.horizontalHeaderItem(2).setText(
            QApplication.translate("MainWindow", "Organization Name", None,
                                   QApplication.UnicodeUTF8))
        self.report_health_table.horizontalHeaderItem(3).setText(
            QApplication.translate("MainWindow", "Test", None,
                                   QApplication.UnicodeUTF8))
        self.report_health_table.horizontalHeaderItem(4).setText(
            QApplication.translate("MainWindow", "Description", None,
                                   QApplication.UnicodeUTF8))
        self.report_health_newrow_buttuon.setText(
            QApplication.translate("MainWindow", "New Row", None,
                                   QApplication.UnicodeUTF8))
        ###signals and slots && other stuffs
        self.health = Health(emp_id=code)
        self.report_health_table.setEditTriggers(
            QAbstractItemView.NoEditTriggers)
        self.load_table_rows()
        self.report_health_table.itemDoubleClicked.connect(
            self.popup_health_edit)
        self.report_health_newrow_buttuon.clicked.connect(self.new_healthTest)
        self.focusInEvent = self.load_rows

    def new_healthTest(self, code=None):
        """
        pops up a dialog to add a new report or edit the existing report
        :param code:the code of the report
        """
        try:
            pop = HygieneReportPop(parent=self,
                                   table='health_table',
                                   code=code)
            pop.setWindowFlags(Qt.WindowTitleHint)
            pop.exec_()
            self.load_table_rows()
        except Exception:
            if settings.level == 10:
                logger.exception('raised exception')
            return False, 'Some Internal Error'

    def load_table_rows(self):
        """
        loads the table of reports
        """
        try:
            data = self.health.load_report()
            if data[0]:
                self.add_table_rows(*data[1])
                if not data[1]:
                    self.report_health_table.clearContents()
                    self.report_health_table.setRowCount(0)
        except Exception:
            if settings.level == 10:
                logger.exception('raised exception')
            return False, 'Some Internal Error'

    def popup_health_edit(self, item):
        """
        Pops up the menu to be edited
        :param item: item clicked
        """
        try:
            table = self.report_health_table
            model_index = table.indexFromItem(item)
            row = model_index.row()
            self.new_healthTest(table.item(row, 0).text())
        except Exception:
            if settings.level == 10:
                logger.exception('raised exception')
            return False, 'Some Internal Error'

    def add_table_rows(self, *args):
        """
        adds a new row to the pes table
        """
        try:
            table = self.report_health_table
            if args:
                table.setRowCount(len(args))
                for row, data in enumerate(args):
                    table.setItem(row, 0, QTableWidgetItem(data['code']))
                    table.setItem(row, 1, QTableWidgetItem(data['date']))
                    table.setItem(row, 2,
                                  QTableWidgetItem(data['organization']))
                    table.setItem(row, 3, QTableWidgetItem(data['test']))
                    table.setItem(row, 4,
                                  QTableWidgetItem(data['description']))
            table.setColumnWidth(0, (table.width() / 5) * 0.5)
            table.setColumnWidth(1, (table.width() / 5) * 0.5)
            table.setColumnWidth(2, table.width() / 5)
            table.setColumnWidth(3, table.width() / 5)
        except Exception:
            if settings.level == 10:
                logger.exception('raised exception')
            return False, 'Some Internal Error'

    def load_rows(self, event):
        """
        loads the rows of the tables
        """
        self.add_table_rows()
Esempio n. 14
0
class Hygiene():
    """ The Hygiene Tab
    """
    global logger

    def __init__(self):
        ####
        logger.info('Inside Hygiene')
        self.reporthygiene_tab_2 = QWidget()
        self.reporthygiene_tab_2.setObjectName("reporthygiene_tab_2")
        self.vertical_23 = QVBoxLayout(self.reporthygiene_tab_2)
        self.vertical_23.setObjectName("vertical_23")
        self.label_1 = QLabel(self.reporthygiene_tab_2)
        self.vertical_23.addWidget(self.label_1)
        self.report_hyginepest_table = QTableWidget(self.reporthygiene_tab_2)
        self.report_hyginepest_table.setObjectName("report_hyginepest_table")
        self.report_hyginepest_table.setColumnCount(5)
        self.report_hyginepest_table.setRowCount(0)
        self.report_hyginepest_table.setSelectionBehavior(
            QAbstractItemView.SelectRows)
        item = QTableWidgetItem()
        self.report_hyginepest_table.setHorizontalHeaderItem(0, item)
        item = QTableWidgetItem()
        self.report_hyginepest_table.setHorizontalHeaderItem(1, item)
        item = QTableWidgetItem()
        self.report_hyginepest_table.setHorizontalHeaderItem(2, item)
        item = QTableWidgetItem()
        self.report_hyginepest_table.setHorizontalHeaderItem(3, item)
        item = QTableWidgetItem()
        self.report_hyginepest_table.setHorizontalHeaderItem(4, item)
        self.report_hyginepest_table.horizontalHeader(
        ).setCascadingSectionResizes(True)
        self.report_hyginepest_table.horizontalHeader().setStretchLastSection(
            True)
        self.report_hyginepest_table.verticalHeader(
        ).setCascadingSectionResizes(True)
        self.vertical_23.addWidget(self.report_hyginepest_table)
        self.horizontal_21 = QHBoxLayout()
        self.report_hyginepest_newrow_buttuon = QPushButton(
            self.reporthygiene_tab_2)
        self.report_hyginepest_newrow_buttuon.setObjectName(
            "report_hyginepest_newrow_buttuon")
        self.horizontal_21.addWidget(self.report_hyginepest_newrow_buttuon)
        spacerItem23 = QSpacerItem(40, 20, QSizePolicy.Expanding,
                                   QSizePolicy.Minimum)
        self.horizontal_21.addItem(spacerItem23)
        # self.report_hyginepest_save_button = QPushButton(self.reporthygiene_tab_2)
        # self.report_hyginepest_save_button.setObjectName("report_hyginepest_save_button")
        # self.horizontal_21.addWidget(self.report_hyginepest_save_button)
        self.vertical_23.addLayout(self.horizontal_21)
        self.label_2 = QLabel(self.reporthygiene_tab_2)
        self.vertical_23.addWidget(self.label_2)
        self.report_hyginewater_table = QTableWidget(self.reporthygiene_tab_2)
        self.report_hyginewater_table.setObjectName("report_hyginewater_table")
        self.report_hyginewater_table.setColumnCount(5)
        self.report_hyginewater_table.setRowCount(0)
        self.report_hyginewater_table.setSelectionBehavior(
            QAbstractItemView.SelectRows)
        item = QTableWidgetItem()
        self.report_hyginewater_table.setHorizontalHeaderItem(0, item)
        item = QTableWidgetItem()
        self.report_hyginewater_table.setHorizontalHeaderItem(1, item)
        item = QTableWidgetItem()
        self.report_hyginewater_table.setHorizontalHeaderItem(2, item)
        item = QTableWidgetItem()
        self.report_hyginewater_table.setHorizontalHeaderItem(3, item)
        item = QTableWidgetItem()
        self.report_hyginewater_table.setHorizontalHeaderItem(4, item)
        self.report_hyginewater_table.horizontalHeader(
        ).setCascadingSectionResizes(True)
        self.report_hyginewater_table.horizontalHeader().setStretchLastSection(
            True)
        self.report_hyginewater_table.verticalHeader(
        ).setCascadingSectionResizes(True)
        self.vertical_23.addWidget(self.report_hyginewater_table)
        self.horizontal_22 = QHBoxLayout()
        self.report_hyginewater_newrow_buttuon = QPushButton(
            self.reporthygiene_tab_2)
        self.report_hyginewater_newrow_buttuon.setObjectName(
            "report_hyginewater_newrow_buttuon")
        self.horizontal_22.addWidget(self.report_hyginewater_newrow_buttuon)
        spacerItem24 = QSpacerItem(40, 20, QSizePolicy.Expanding,
                                   QSizePolicy.Minimum)
        self.horizontal_22.addItem(spacerItem24)
        # self.report_hyginewater_save_button = QPushButton(self.reporthygiene_tab_2)
        # self.report_hyginewater_save_button.setObjectName("report_hyginewater_save_button")
        # self.horizontal_22.addWidget(self.report_hyginewater_save_button)
        self.vertical_23.addLayout(self.horizontal_22)
        ### retanslate
        self.label_1.setText(
            QApplication.translate("MainWindow", "Pest Test Report", None,
                                   QApplication.UnicodeUTF8))
        self.report_hyginepest_table.horizontalHeaderItem(0).setText(
            QApplication.translate("MainWindow", "Code", None,
                                   QApplication.UnicodeUTF8))
        self.report_hyginepest_table.horizontalHeaderItem(1).setText(
            QApplication.translate("MainWindow", "Date", None,
                                   QApplication.UnicodeUTF8))
        self.report_hyginepest_table.horizontalHeaderItem(2).setText(
            QApplication.translate("MainWindow", "Organization Name", None,
                                   QApplication.UnicodeUTF8))
        self.report_hyginepest_table.horizontalHeaderItem(3).setText(
            QApplication.translate("MainWindow", "Test", None,
                                   QApplication.UnicodeUTF8))
        self.report_hyginepest_table.horizontalHeaderItem(4).setText(
            QApplication.translate("MainWindow", "Description", None,
                                   QApplication.UnicodeUTF8))
        self.report_hyginepest_newrow_buttuon.setText(
            QApplication.translate("MainWindow", "New Row", None,
                                   QApplication.UnicodeUTF8))
        # self.report_hyginepest_save_button.setText(
        # QApplication.translate("MainWindow", "Save", None, QApplication.UnicodeUTF8))
        self.label_2.setText(
            QApplication.translate("MainWindow", "Water Test Report", None,
                                   QApplication.UnicodeUTF8))
        self.report_hyginewater_table.horizontalHeaderItem(0).setText(
            QApplication.translate("MainWindow", "Code", None,
                                   QApplication.UnicodeUTF8))
        self.report_hyginewater_table.horizontalHeaderItem(1).setText(
            QApplication.translate("MainWindow", "Date", None,
                                   QApplication.UnicodeUTF8))
        self.report_hyginewater_table.horizontalHeaderItem(2).setText(
            QApplication.translate("MainWindow", "Organization Name", None,
                                   QApplication.UnicodeUTF8))
        self.report_hyginewater_table.horizontalHeaderItem(3).setText(
            QApplication.translate("MainWindow", "Test", None,
                                   QApplication.UnicodeUTF8))
        self.report_hyginewater_table.horizontalHeaderItem(4).setText(
            QApplication.translate("MainWindow", "Description", None,
                                   QApplication.UnicodeUTF8))
        self.report_hyginewater_newrow_buttuon.setText(
            QApplication.translate("MainWindow", "New Row", None,
                                   QApplication.UnicodeUTF8))
        # self.report_hyginewater_save_button.setText(
        #     QApplication.translate("MainWindow", "Save", None, QApplication.UnicodeUTF8))
        ###signals and slots && other stuffs
        self.pest = Pest()
        self.water = Water()
        self.report_hyginepest_table.setEditTriggers(
            QAbstractItemView.NoEditTriggers)
        self.report_hyginewater_table.setEditTriggers(
            QAbstractItemView.NoEditTriggers)
        self.load_table_rows()
        self.report_hyginepest_table.itemDoubleClicked.connect(
            self.popup_pest_edit)
        self.report_hyginewater_table.itemDoubleClicked.connect(
            self.popup_water_edit)
        self.reporthygiene_tab_2.focusInEvent = self.load_rows  # very important for focus
        self.report_hyginepest_newrow_buttuon.clicked.connect(
            self.new_pestTest)  # if no focus available then we need lambda
        self.report_hyginewater_newrow_buttuon.clicked.connect(
            self.new_waterTest)

    def new_pestTest(self, code=None):
        """
        The pest report popup generator
        :param code: The code of the pest report
        """
        pop = HygieneReportPop(parent=self, table='pest_table', code=code)
        pop.setWindowFlags(Qt.WindowTitleHint)
        pop.exec_()
        self.load_table_rows()

    def new_waterTest(self, code=None):
        """
        The water report popup generator
        :param code: The code of the water report
        """
        pop = HygieneReportPop(parent=self, table='water_table', code=code)
        pop.setWindowFlags(Qt.WindowTitleHint)
        pop.exec_()
        self.load_table_rows()

    def load_table_rows(self):
        """
        Populates the rows for both the table
        """
        logger.info('Hygiene save table initiated')
        try:
            data = self.pest.load_report()
            if data[0]:
                self.add_table_rows('pest_table', *data[1])
                if not data[1]:
                    self.report_hyginepest_table.clearContents()
                    self.report_hyginepest_table.setRowCount(0)
            data = self.water.load_report()
            if data[0]:
                self.add_table_rows('water_table', *data[1])
                if not data[1]:
                    self.report_hyginewater_table.clearContents()
                    self.report_hyginewater_table.setRowCount(0)
        except Exception:
            if settings.level == 10:
                logger.exception('raised exception')
            return False, 'Some Internal Error'

    def popup_pest_edit(self, item):
        """
        Pops up the menu to be edited
        :param item: item clicked
        """
        table = self.report_hyginepest_table
        model_index = table.indexFromItem(item)
        row = model_index.row()
        self.new_pestTest(table.item(row, 0).text())

    def popup_water_edit(self, item):
        """
        Pops up the menu to be edited
        :param item: item clicked
        """
        table = self.report_hyginewater_table
        model_index = table.indexFromItem(item)
        row = model_index.row()
        self.new_waterTest(table.item(row, 0).text())

    def add_table_rows(self, tablename, *args):
        """
        adds a new row to the pes table
        """
        if tablename == 'pest_table':
            table = self.report_hyginepest_table
        else:
            table = self.report_hyginewater_table
        if args:
            table.setRowCount(len(args))
            for row, data in enumerate(args):
                table.setItem(row, 0, QTableWidgetItem(data['code']))
                table.setItem(row, 1, QTableWidgetItem(data['date']))
                table.setItem(row, 2, QTableWidgetItem(data['organization']))
                table.setItem(row, 3, QTableWidgetItem(data['test']))
                table.setItem(row, 4, QTableWidgetItem(data['description']))
        table.setColumnWidth(0, (table.width() / 5) * 0.5)
        table.setColumnWidth(1, (table.width() / 5) * 0.5)
        table.setColumnWidth(2, table.width() / 5)
        table.setColumnWidth(3, table.width() / 5)

    def load_rows(self, event):
        """
        loads the rows of the tables
        """
        self.add_table_rows(tablename='pest_table')
        self.add_table_rows(tablename='water_table')