Observer pattern eingebaut. Zahlreiche Attribute protected gemacht. Logik in caditem verschoben. config aus der gui entfernt

lib/caditem.py

@@ -2,7 +2,27 @@ import json
 import pandas as pd
 import os
 
-class CadItem():
+class DataModel:
+    def __init__(self):
+        self._observers = {}
+        self._counter = 0
+        # self._data_controller = DataController()  # Externer hypothetischer Datencontroller
+        # self._data_controller.subscribe(self)
+
+    def subscribe(self, observer):
+        self._counter += 1
+        self._observers[self._counter] = observer
+        return self._counter
+
+    def unsubscribe(self, observer_id):
+        self._observers.pop(observer_id)
+
+    def notify(self, data):
+        for observer in self._observers.values():
+            observer.notify(data)
+
+
+class CadItem(DataModel):
     """
     This item contains all data for writing all necessary data to the solid edg cad file
 
@@ -138,15 +158,20 @@ class CadItem():
 
     def __init__(self):
         """ is initalized with its unique id"""
-        self.red_ids = {}
-        self.parent_children_mapping = {}
-        self.data = {}
-        self.gui_data = {}
-        self.read_only_items = {}
-        self.controller = None
+        super().__init__()
+        self._red_ids = {}
+        self._parent_children_mapping = {}
+        self._data = {}
+        self._gui_data = {}
+        self._read_only_items = {}
+        self._controller = None
+        self._logic = None
+
+    def add_logic(self, logic):
+        self._logic = logic
 
     def set_controller(self, controller):
-        self.controller = controller
+        self._controller = controller
 
     def set_asm_id(self, asm_id):
         self.set_gui_data("asm_id", asm_id)
@@ -161,47 +186,47 @@ class CadItem():
         """ contains all id relations below, data of subassemblies etc. in
             a dict of the kind parent-children
         """
-        self.parent_children_mapping = parent_children_mapping
+        self._parent_children_mapping = parent_children_mapping
     def get_parent_children(self):
-        return self.parent_children_mapping
+        return self._parent_children_mapping
 
     def set_red_ids(self, red_ids):
         """ these ids are not yet known by the PDM"""
-        self.red_ids = red_ids
+        self._red_ids = red_ids
 
     def get_red_ids(self):
-        return self.red_ids
+        return self._red_ids
 
     # Methoden um die Verwendbarkeit einzelner Schalter auszugrauen
     def set_read_only_dict(self, data:dict):
         for k,v in data:
             self.set_read_only(k,v)
     def set_read_only(self, key, val):
-        if key not in self.gui_data:
+        if key not in self._gui_data:
             raise Exception("this data can not be set "+ key)
         else:
-            self.read_only_items[key] = val
+            self._read_only_items[key] = val
     def get_read_only(self, key):
-        return self.read_only_items[key]
+        return self._read_only_items[key]
     def get_all_read_only_data(self):
-        return self.read_only_items
+        return self._read_only_items
 
     # Daten zum Impfen merken
     def set_data_dict(self, data:dict):
         for k,v in data:
             self.set_data(k,v)
     def set_data(self, key, val):
-        if key not in self.data_keys:
+        if key not in self._data_keys:
             raise Exception("this data can not be set "+ key)
         else:
-            self.data[key] = val
+            self._data[key] = val
 
     def get_data(self, key):
         """ gibt ein Datenstück zurück """
-        return self.data[key]
+        return self._data[key]
     def get_all_data(self):
         """ gibt alle enthaltenen Daten zurück """
-        return self.data
+        return self._data
 
     # Daten die in der GUI gespeichert werden sollen
     def set_gui_dict(self, data:dict):
@@ -213,15 +238,15 @@ class CadItem():
         if key not in self.gui_data_keys:
             raise Exception("this data can not be set "+ key)
         else:
-            self.gui_data[key] = val
+            self._gui_data[key] = val
 
     def get_gui_data(self, key):
-        if key in self.gui_data:
-            return self.gui_data[key]
+        if key in self._gui_data:
+            return self._gui_data[key]
         else:
             return None
     def get_all_gui_data(self):
-        return self.gui_data
+        return self._gui_data
 
     def csv2guidata(self, data):
         translated_data = dict()
@@ -238,7 +263,7 @@ class CadItem():
 
 
     def sivas_data_from_csv(self, cid):
-        path = os.path.join(self.controller.get_env("data"), cid + '.csv')
+        path = os.path.join(self._controller.get_env("data"), cid + '.csv')
         if os.path.exists(path):
             data = self._load_csv(path)
             return data
@@ -321,6 +346,14 @@ class CadItem():
         with open(path, 'w') as f:
            json.dump(self.to_dict(tree), f)
 
+    def callback(self, key, value):
+        if self._logic == None:
+            raise Exception("no logic set")
+        else:
+            self._logic.callback(key, value)
+
+    def set_gui_defaults(self):
+        self._logic.set_gui_defaults()
 class CadItemRepository:
     """
     container class for all CadItems in the local folder
@@ -352,6 +385,293 @@ class CadItemRepository:
                 return
         raise Exception("CadItem not found")
 
+
+
+class GuiLogic():
+    """
+    Class for business logic. implementing the dependencies between different user inputs
+    """
+    def __init__(self, model, configs):
+        # das Modell soll hier nur verwendet werden um aktuell Zustände abzufragen!
+        # alles weitere zum Setzen von Daten etc. muss über den Controller laufen, also zurück gegeben werden. 
+        self.model = model 
+        # hier holt man die Daten der Configs
+        self.config = configs
+        # hier sind alle Callbacks bzw. deren Comboboxen 
+
+    def set_gui_defaults(self):
+        # set defaults from given logic
+        self.call_and_set_data('cb_pdm_kategorie_neu')
+        self.call_and_set_data('cb_neuaufbau')
+        self.call_and_set_data('cb_aus_halbzeug_neu')
+        self.call_and_set_data('cb_halbzeugoberflaeche')
+
+    def call_and_set_data(self, callbackfunc):
+        eval('self.model.set_gui_dict(self.'+callbackfunc+'(None))')
+
+    def callback(self, key, value):
+        """gibt ein dict zurück, welches neu im Modell gesetzt wird"""
+
+        ret = dict()
+        if key == 'cb_pdm_kategorie_neu':
+            ret = self.cb_pdm_kategorie_neu(value)
+        elif key == 'cb_neuaufbau':
+            ret = self.cb_neuaufbau(value)
+        elif key == 'cb_aus_halbzeug_neu':
+            ret = self.cb_aus_halbzeug_neu(value)
+        elif key == "cb_halbzeugoberflaeche":
+            ret = self.cb_halbzeugoberflaeche(value)
+        elif key == "cb_halbzeugfarbe":
+            ret = self.cb_halbzeugfarbe(value)
+        elif key == 'cb_lebenszyklus_status_neu':
+            ret = self.cb_lebenszyklus_status_neu(value)
+        elif key == 'cb_3Dmodel_neu':
+            ret = self.cb_3Dmodel_neu(value)
+        elif key == 'cb_halbzeugOhneSaege_neu':
+            pass
+        elif key == 'cb_ruestcode_neu':
+            pass
+        elif key == 'cb_fertigungsart_neu':
+            pass
+        elif key == 'cb_allgemeintoleranz_neu':
+            pass
+        elif key == 'cb_fosGruppe_neu':
+            pass
+        elif key == 'cb_kalkulationsart_neu':
+            pass
+        elif key == 'cb_beschaffungsart_neu':
+            pass
+        elif key == 'cb_mengeneinheit_neu':
+            pass
+        elif key == 'cb_halbzeug_neu':
+            pass
+        elif key == 'cb_dispogruppe_neu':
+            pass
+        elif key == 'cb_dispolaufgruppe_neu':
+            pass
+        elif key == 'cb_hersteller_neu':
+            pass
+        elif key == 'cb_werkstoffdiskrepanz':
+            pass
+        elif key == 'cb_werkstofftyp_neu':
+            pass
+            # ret = self.cb_werkstofftyp_neu(value)
+        elif key == 'cb_material_neu':
+            pass
+        elif key == 'cb_oberflaeche_neu':
+            pass
+        elif key == 'cb_farbe_neu':
+            ret = self.cb_farbe_neu(value)
+        elif key == 'cb_speichern':
+            pass
+        elif key == 'cb_migrieren':
+            pass
+        elif key == 'cb_zurücksetzen':
+            pass
+        elif key == 'cb_suche_asm':
+            pass
+        else:
+            raise Exception("this callback does not exist "+key)
+        return ret
+        
+    def cb_pdm_kategorie_neu(self, selected):
+        """setzt die Dropdownliste mit
+            <undefiniert>, Baugruppe, Einzelteil, Kaufteil, Schweissbaugruppe
+        """
+        ret = dict()
+        categories = self.config.Allgemein.get_options("Kategorien")
+        if selected is None:
+            ret['pdm_kategorie_neu'] = categories[0] 
+            ret['cb_pdm_kategorie_neu'] = categories
+        else:
+            ret['pdm_kategorie_neu'] = selected 
+        return ret
+
+    def cb_neuaufbau(self, trueOrfalse):
+        ret = dict()
+        pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
+        if pdm_kat != "Einzelteil" or pdm_kat != "Kaufteil":
+            ret["neuaufbau"] = False
+        return ret
+    
+    def cb_aus_halbzeug_neu(self, trueOrfalse):
+        ret = dict()
+        pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
+        if pdm_kat == "Einzelteil":
+            pass
+        else:
+            ret["aus_halbzeug_neu"] = False
+        return ret
+    
+
+    def cb_halbzeugoberflaeche(self, selected):
+        ret = dict()
+        aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
+        if aus_halbzeug == "True":
+            oarten = self.config.Oberfläche.get_oberflächen_behandlungen()
+            if selected is None:
+                ret['halbzeugoberflaeche_neu'] = oarten[0] 
+                ret['cb_halbzeugoberflaeche'] = oarten
+            else:
+                ret['halbzeugoberflaeche_neu'] = selected 
+        else:
+            ret = { 
+                'halbzeugoberflaeche_neu': "",
+                'cb_halbzeugoberflaeche': "",
+            }
+        return ret
+
+    def cb_lebenszyklus_status_neu(self, selected):
+        ret = dict()
+        lstatus = self.config.Allgemein.get_options("Lebenszyklus") # Serie, Prototyp
+        if selected is None:
+            ret['lebenszyklus_status_neu'] = lstatus[0]
+            ret['cb_lebenszyklus_status_neu'] = lstatus
+        else:
+            ret['cb_lebenszyklus_status_neu'] = selected 
+        return ret
+    
+    def cb_halbzeugfarbe(self, selected):
+        ret = dict()
+        halbzeugoberflaeche = self.model.get_gui_data("halbzeugoberflaeche_neu")
+        aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
+
+        # setze die Inhalte der abhängigen Comboboxen neu 
+        ret = { 
+            'halbzeugfarbe_neu': '', 
+            'cb_halbzeugfarbe': '',
+        }
+        if aus_halbzeug == "True":
+            if halbzeugoberflaeche == "eloxieren":
+                farben_elox = self.config.Farben.get_farben_eloxieren()
+                if selected is None:
+                    ret['halbzeugfarbe_neu'] = farben_elox[0]     # Default, falls nichts gewählt ist
+                    ret['cb_halbzeugfarbe'] = farben_elox         # Liste in der Combobox
+                else:
+                    ret['halbzeugfarbe_neu'] = selected           # vom Nutzer ausgewählter Wert
+            elif halbzeugoberflaeche == "lackieren" or halbzeugoberflaeche == "pulverbeschichten":
+                farbauswahl = self.config.Farben.get_farbauswahl()
+                if selected is None:
+                    ret['halbzeugfarbe_neu'] = farbauswahl[0]
+                    ret['cb_halbzeugfarbe'] = farbauswahl
+                else:
+                    ret['halbzeugfarbe_neu'] = selected
+        else:
+            pass
+        return ret
+
+    def cb_3Dmodel_neu(self, selected):
+        ret = dict()
+        pdm_kategorie_neu = self.model.get_gui_data("pdm_kategorie_neu")
+        if pdm_kategorie_neu == "Baugruppe" or pdm_kategorie_neu == "Schweissbaugruppe":
+            # Defaultwert = \\ssg.local\freigaben\Abteilungen\Entwicklung\CAD\Standards\SolidEdge\Template\DIN Metric\baugruppe.asm
+            # Dropdownwerte = keine
+            # state_ComboBox = disabled
+            # state_Button = disabled
+            # ret = { 
+                # '': '', 
+                # '': '',
+            # }
+            pass
+        elif pdm_kategorie_neu == "Kaufteil":
+            # Defaultwert = \\ssg.local\freigaben\SIVAS_CAD_EDM\Migration\06_3D_Vorlagen\ET_mit_Volumen.par
+            # Dropdownwerte = keine
+            # state_ComboBox = disabled
+            # state_Button = disabled
+            pass
+        elif pdm_kategorie_neu == "Einzelteil":
+            aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
+            neuaufbau = self.model.get_gui_data("neuaufbau")
+            if aus_halbzeug == "True" or neuaufbau == "True":
+                # Defaultwert = \\ssg.local\freigaben\SIVAS_CAD_EDM\Migration\06_3D_Vorlagen\ET_mit_Volumen.par
+                # Dropdownwerte = keine
+                # state_ComboBox = disabled
+                # state_Button = disabled
+                pass
+            else:
+                # Defaultwert = ""
+                # Dropdownwerte = Dateipfade von allen .par-Dateien, die die aktuelle Teilenummer im Dateinamen aufweisen und sich gleichzeitig in einem der rekursiv durchsuchten Pfade aus der Sektion "3D-Modelle" in "Zielpfade.cfg" befinden.
+                # state_ComboBox = readonly
+                # state_Button = keiner
+
+                # IF Button "Durchsuchen" geklickt und benutzerdefinierte Solid Edge-Datei gewählt:
+                    # Defaultwert = Dateipfad der gewählten Solid Edge-Datei
+                pass
+        return ret
+
+
+
+    # def cb_werkstofftyp_neu(self, selected_werkstoff):
+        # """bekommt Aluminium, Stahl etc. und setzt dann die anderen Felder der Oberfläche"""
+
+        # # Logik, die steuert, welcher Defaultwert gilt:
+
+        # #    In den nachfolgenden Fällen darf kein Defaultwert eingetragen
+        # #    werden (selbst wenn in from_siv.csv ein Wert in der Spalte
+        # #    "Werkstoff" eingetragen sein sollte):
+        # #        PDM-Kategorie == "Baugruppe"
+        # #        PDM-Kategorie == "Schweissbaugruppe"
+        # #        PDM-Kategorie == "Einzelteil" und Aus Halbzeug == True (Haken gesetzt)
+
+        # #    Gilt PDM-Kategorie == "Kaufteil" soll der Defaultwert "siehe
+        # #    Hersteller" eingetragen werden
+
+        # #    Gilt PDM-Kategorie == "Einzelteil" und Aus Halbzeug == False (kein
+        # #    Haken), dann wird der Defaultwert wie folgt bestimmt:
+        # ret = dict()
+        # # das Feld selbst mit dem Selektierten beschreiben
+        # ret['werkstofftyp_neu']= selected_werkstoff
+
+        # pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
+        # aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
+
+        # if pdm_kat == 'Einzelteil' and aus_halbzeug is False:
+            # wnamen = self.config.Werkstoffe.get_werkstoffe_of_name(selected_werkstoff)
+            # # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
+            # ret = { 
+                    # # das Feld selbst mit dem Selektierten beschreiben
+                   # 'werkstofftyp_neu': selected_werkstoff,  
+                    # # die neuen Inhalte der comboboxen setzen
+                   # 'cb_material_neu': wnamen, 
+                    # # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
+                   # 'material_neu': wnamen[0],  
+            # }
+        # return ret
+
+    # def oberfläche(self, selected):
+
+        # ret = dict()
+        # # das Feld selbst mit dem Selektierten beschreiben
+        # ret['oberflaeche_neu']= selected
+
+        # pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
+        # aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
+
+        # if pdm_kat == 'Einzelteil' and aus_halbzeug is False:
+            # onamen = self.config.Oberfläche.get_oberfläche_of_type(selected)
+            # # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
+            # ret = { 
+                    # # die neuen Inhalte der comboboxen setzen
+                   # 'cb_oberflaeche_neu': onamen, 
+                    # # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
+                   # 'oberflaeche_neu': onamen[0],  
+            # }
+        # return ret
+
+    def cb_farbe_neu(self, selected):
+        farben_alle = self.config.Farben.get_farbauswahl()
+        farben_elox = self.config.Farben.get_farben_eloxieren()
+        # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
+        ret = { 
+                # das Feld selbst mit dem Selektierten beschreiben
+               'farbe_neu': selected,  
+                # die neuen Inhalte der comboboxen setzen
+               'cb_farben': farben_alle, 
+                # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
+               'farbe_neu': farben_alle[0],  
+        }
+        return ret
+
 if __name__ == "__main__":
     pass