order-processing/designbox_orders.py

import  os
from    QT.Main_Window      import Main_Window, QtWidgets
from    QT                  import QT
from    Log_View            import Log_View, Log_Handler
from    Order_Display       import Order_Display
from    Login               import Login_Dialog
from    App_State           import App_State
import  designbox_orders_rc
import  pathlib
import  logging
import  threading
import  json

class Order_Processing (Main_Window, App_State) :

    APP_NAME                = "Designbox Orders"
    VERSION                 = "0.5"
    APP_ORGANISATION        = ("designbox-orders", "glaser-co.at")
    APP_DIR                 = os.path.dirname (__file__)

    @classmethod
    def _load_app_settings (cls, settings) :
        settings.beginGroup ("TempSettings")
        result = { "config_file" : settings.value ("config_file")
                 , "user_name"   : settings.value ("user_name")
                 }
        settings.endGroup ()
        return result
    # end def _load_app_settings

    def _setupActions (self, app) :
        super ()._setupActions (app)
        self._add_action \
            ( "add_cnc_orderline",  "CNC Bearbeitung verrechnen"
            , self.add_cnc_orderline
            )
    # end def _setupActions
       
    def _setupGui (self) :
        settings = self.settings
        settings.beginGroup         ("TempSettings")
        config_file  = settings.value    ("config_file")
        settings.endGroup            ()
        self.load_config                     (config_file)
        self.main_menu = QtWidgets.QMenuBar  (self)
        self.setMenuBar                      (self.main_menu)
        file = QtWidgets.QMenu               ("& File")
        self.main_menu.addMenu               (file)
        self.tool_bar_file = self.addToolBar ("File")
        self.tool_bar_file.setObjectName     ("tb_file")
        for a, l in ( ( self.actions.exit
                      , (file, self.tool_bar_file)
                      )
                    , ( (self.actions.add_cnc_orderline), (self.tool_bar_file, ))
                    ) : 
            for x in l :
                x.addAction                 (a)
        sp = QtWidgets.QSplitter            (self)
        self._order_display = Order_Display (self.config, self)
        self.create_log_view                (parent = self)
        sp.addWidget                        (self._order_display)
        sp.addWidget                        (self._log_view)
        sp.setOrientation                   (QT.Vertical)
        self.setCentralWidget               (sp)
        self._setup_topics                  ()
        self.L.info ("User: %s", App_State.User)
        self.client = self.connect_to_db ()
    # end def _setupGui
    
    def _db_connected (self, client) :
        topic = self.mqtt.baskets
        client.subscribe (topic, True)
        self.L.debug     ("Subscribe to %s", topic)
        for k, v in client.get_all_values (topic) :
            self._db_changes (k, v)
    # end def _mqtt_connected
    
    def _db_changes (self, key, value) :
        bst   = self.mqtt.baskets
        if key.startswith (bst) :
            key         = key [len (bst) + 1:]
            parts       = key.split ("/")
            basket_no   = parts.pop (0)
            if not parts :
                if value :
                    data = json.loads (value)
                else :
                    data = None
            else :
                if isinstance (value, bytes) :
                    value = value.decode ("utf-8")
                data = {parts [0] : value}
            self.L.debug ("Change basket %s: %s", basket_no, data)
            self._order_display.update_basket (basket_no, data)
    # end def _mqtt_message
    
    def add_cnc_orderline (self) :
        self._order_display.add_cnc_orderline ()
    # end def add_cnc_orderline
           
    def _restore_settings (self) :
        super ()._restore_settings ()
        sp       = self.centralWidget ()
        settings = self.settings
        settings.beginGroup         ("main-splitter")
        settings.setValue           ("geometry",    sp.saveGeometry ())
        settings.setValue           ("windowState", sp.saveState ())
        settings.endGroup           ()
        self._order_display.restore_settings (settings)
        self._log_view.restore_settings      (settings)
    # end def _restore_settings

    def save_settings (self) :
        settings = self.settings
        sp       = self.centralWidget ()
        super ().save_settings ()
        settings.beginGroup         ("main-splitter")
        sp.restoreGeometry          (settings.value ("geometry"   ))
        sp.restoreState             (settings.value ("windowState"))
        settings.endGroup           ()
        self._order_display.save_settings (settings)
        self._log_view.save_settings      (settings)
        settings.beginGroup         ("TempSettings")

        settings.setValue           ("user_name", App_State.User)
        settings.endGroup           ()
    # end def save_settings
        
    @classmethod
    def pre_main_window_action (cls, settings) :
        settings.beginGroup         ("TempSettings")
        config_file  = settings.value    ("config_file")
        user_name    = settings.value    ("user_name")
        settings.endGroup           ()
        if False :
            login = Login_Dialog (config_file, user_name)
            if login.exec () == 1 :
                settings.beginGroup         ("TempSettings")
                settings.setValue           ("user_name", App_State.User)
                settings.endGroup           ()
                return True
        else :
            cls.L.error ("### Login skipped")
            App_State.User = user_name
            return True
    # end def pre_main_window_action
    
    def create_log_view (self, level = "INFO", parent = None) :
        self.L.debug                ("Log window created")
        self._log_view = Log_View   (parent)
        lh = Log_Handler            (self._log_view)
        #lh.setFormatter \
        #    ( logging.Formatter 
        #         ('<span class="log-time">%(asctime)s</span> '
        #          '<span class="level-%(levelname)s">%(levelname)s</span> - %(message)s'
        #         , datefmt = "%Y-%m-%d %H:%M:%S"
        #         )
        #    )
        lh.setLevel      (level)
        lh.setFormatter \
            ( logging.Formatter 
                ( "%(asctime)s - %(message)s"
                , datefmt   = "%Y-%m-%d %H:%M:%S"
                )
            )
        self.L.addHandler (lh)
        return self._log_view
    # end def create_log_view

# end class Order_Processing
    
if __name__ == "__main__" :
    import argparse
    parser = Order_Processing.Add_Logging_Attributes ()
    parser.add_argument ("-s", "--settings-file",    type = str)
    parser.add_argument ("-c", "--config-file",     type = str)
    cmd    = parser.parse_args ()
    App_State.Setup_Logging (cmd)
    Order_Processing.run (Order_Processing.load_settings (cmd))