import json import pandas as pd import os import glob import re import subprocess import shutil 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 """ # diese Daten bilden dann die Impfdaten data_keys = [ "Author", "Teilenummer", "StartRevision", "Bezeichnung1", "Bezeichnung2", "Bezeichnung4", "KategorieNE", "BeschaffungsartNE", "TOS-Gruppe_ERP", "Dispogruppe", "Dispolaufgruppe", "WerkstofftypNE", "WerkstoffNE", "Oberflaechenbehandlung", "Farbe", "KalkulationsartNE", "RuestcodeAusw", "Fertigungsart", "Allgemeintoleranz", "HalbzeugInternAngabe", "Halbzeug", "HalbzeugOhneSaegeliste", "EinheitNE", "FOS-GruppeNE", "Hersteller", "HerstellerTeilenummer", "Serien-Status", "Kantennorm", "Oberflaechennorm", "Massnorm", "Tolerierungsnorm", "TOS-Gruppe", "TOS_Schoenenberger_Produkt", "TOS_Automation", "TOS_Maschinenelement", "TOS_Schoenenberger_Komponenten", "TOS_Pneumatik", "TOS_Konfig", "TOS_ILS", "TOS_MAS", "TOS_Spinnereikomponente", "TOS_Betriebsmittel", "TOS_Geruest", "TOS_FremdTransport", "TOS_MAS_Konfig", "TOS_Schaltschrank", "TOS_Schalt_Einbau", "TOS_Dezentral", "TOS_Automation_Sensorik", "TOS_Kabel", "TOS_Installation", "TOS_Automation_Sonstiges", "TOS_Verbindungselement", "TOS_Lager", "TOS_Kraft_Drehmoment", "TOS_Sicherungselement", "TOS_Bedienungselement", "TOS_ILS_2", "TOS_ILS_Foerderer", "TOS_MAS_Fahrstecke", "TOS_Trolley", "TOS_Trolley_Projekte", "TOS_Trolley_Omniflo", "TOS_Trolley_Spinnerei", "TOS_Trolley_ILS", "Änderungsbeschreibung", "Freigabevermerk", "ZusaetzlicheInformationen"] gui_data_keys = [ # Felder der Oberfläche um etwas einzugeben oberflaeche_neu "asm_id", "teilenummer", "datenbank", "pdm_kategorie_neu", "neuaufbau", "aus_halbzeug_neu", "halbzeugnummer_neu", "halbzeug_extern_neu", "halbzeuglaenge_neu", "halbzeugoberflaeche_neu", "halbzeugfarbe_neu", "lebenszyklus_status_neu", "model3d_neu", "bezeichnung1_sivas", "bezeichnung1_neu", "bezeichnung2_sivas", "halbzeugOhneSaege_sivas", "halbzeugOhneSaege_neu", "ruestcode_sivas", "ruestcode_neu", "fertigungsart_sivas", "fertigungsart_neu", "allgemeintoleranz_sivas", "allgemeintoleranz_neu", "fosGruppe_sivas", "fosGruppe_neu", "kalkulationsart_sivas", "kalkulationsart_neu", "beschaffungsart_sivas", "beschaffungsart_neu", "mengeneinheit_sivas", "mengeneinheit_neu", "halbzeug_sivas", "halbzeug_neu", "tosgruppe_sivas", "tosgruppe_neu", "dispogruppe_sivas", "dispogruppe_neu", "dispolaufgruppe_sivas","dispolaufgruppe_neu", "hersteller_sivas", "hersteller_neu", "ersatzfuer_sivas", "ersatzfuer_neu", "ersetztdurch_sivas", "ersetztdurch_neu", "herstteilenr_sivas", "herstteilenr_neu", "werkstoffdiskr_neu", "werkstofftyp_neu", "material_sivas", "material_neu", "oberflaeche_neu", "farbe_neu", "version_sivas", "aenderungsindex_sivas", "aenderungsindex_neu", "aenderungstext_sivas", "aenderungstext_neu", "freigabevermerk_sivas", "freigabevermerk_neu", "zusatzinfos_auto_text", "zusatzinfos_bendef_text", # das wird nur zur Datenübergabe aus der csv verwendet, # ist also eigentlich kein Teil der gui "truemmer", # Felder der Comboboxen. benannt wie deren callbacks "cb_datenbank_neu", "cb_pdm_kategorie_neu", "cb_halbzeug_neu", "cb_halbzeugoberflaeche", "cb_halbzeugfarbe", "cb_lebenszyklus_status_neu", "cb_3Dmodel_neu", "cb_halbzeugOhneSaege_neu", "cb_ruestcode_neu", "cb_fertigungsart_neu", "cb_allgemeintoleranz_neu", "cb_fosGruppe_neu", "cb_kalkulationsart_neu", "cb_beschaffungsart_neu", "cb_mengeneinheit_neu", "cb_dispogruppe_neu", "cb_dispolaufgruppe_neu", "cb_hersteller_neu", "cb_herstteilenr_neu", "cb_werkstofftyp_neu", "cb_werkstoffdiskrepanz", "cb_material_neu", "cb_oberflaeche_neu", "cb_farbe_neu", # buttons "cb_speichern", "cb_migrieren", "cb_suche_asm", "cb_zurücksetzen", "cb_ladelokal_asm", "cb_3dsuchen", ] # dies sind die Excel Headel der SIVAS csv Export Datei # und wie diese in das Datenmodell der Gui integriert werden kann excel_to_gui = { "Teilenummer":"teilenummer", "Bezeichnung1":"bezeichnung1_sivas", "Bezeichnung2":"bezeichnung2_sivas", "Beschaffungsart":"beschaffungsart_sivas", "Mengeneinheit":"mengeneinheit_sivas", "Halbzeug":"halbzeug_sivas", "TOS_Gruppe":"tosgruppe_sivas", "Dispogruppe":"dispogruppe_sivas", "Dispolaufgruppe":"dispolaufgruppe_sivas", "ErsatzFuer":"ersatzfuer_neu", "ErsetztDurch":"ersetztdurch_neu", "AktuellerIndex":"aenderungsindex_sivas", "Hersteller":"hersteller_sivas", "HerstellerTeilenummer":"herstteilenr_sivas", "Version":"version_sivas", "HalbzeugExtern":"halbzeug_extern_neu", "Werkstoff":"material_sivas", "Oberfläche":"cb_oberflaeche_neu", "Truemmer":"truemmer", "HzOhneSaegeliste":"halbzeugOhneSaege_sivas", "Ruestcode":"ruestcode_sivas", "Fertigungsart":"fertigungsart_sivas", "FosGruppe":"fosGruppe_sivas", "Kalkulationsart":"kalkulationsart_sivas", #"Indexerfasser":"", "Aenderungstext":"aenderungstext_sivas", "Freigabevermerk":"freigabevermerk_sivas", # "Indexbearbeiter":"in" } key2label = { "asm_id": "Baugruppennummer", "teilenummer": "Teilenummer", "pdm_kategorie_neu": "PDM-Kategorie", "halbzeugnummer_neu": "Halbzeugnummer", "halbzeuglaenge_neu": "Halbzeuglänge", "halbzeugoberflaeche_neu": "Halbzeugoberfläche", "halbzeugfarbe_neu": "Halbzeugfarbe", "lebenszyklus_status_neu": "Lebenzyklusstatus", "model3d_neu": "3D-Modell", "bezeichnung1_sivas": "Bezeichnung 1", "bezeichnung1_neu": "Bezeichnung 1", "bezeichnung2_sivas": "Bezeichnung 2", "halbzeugOhneSaege_sivas": "Halbzeug ohne Sägeliste", "halbzeugOhneSaege_neu": "Halbzeug ohne Sägeliste", "ruestcode_sivas": "Rüstcode", "ruestcode_neu": "Rüstcode", "fertigungsart_sivas": "Fertigungsart", "fertigungsart_neu": "Fertigungsart", "allgemeintoleranz_sivas": "Allgemeintoleranz", "allgemeintoleranz_neu": "Allgemeintoleranz", "fosGruppe_sivas": "FOS-Gruppe", "fosGruppe_neu": "FOS-Gruppe", "kalkulationsart_sivas": "Kalkulationsart", "kalkulationsart_neu": "Kalkulationsart", "beschaffungsart_sivas": "Beschaffungsart", "beschaffungsart_neu": "Beschaffungsart", "mengeneinheit_sivas": "Mengeneinheit", "mengeneinheit_neu": "Mengeneinheit", "halbzeug_sivas": "Halbzeug", "halbzeug_neu": "Halbzeug", "tosgruppe_sivas": "TOS-Gruppe", "tosgruppe_neu": "TOS-Gruppe", "dispogruppe_sivas": "Dispogruppe", "dispogruppe_neu": "Dispogruppe", "dispolaufgruppe_sivas": "Dispolaufgruppe", "dispolaufgruppe_neu": "Dispolaufgruppe", "hersteller_sivas": "Hersteller", "hersteller_neu": "Hersteller", "ersatzfuer_sivas": "Ersatz für", "ersatzfuer_neu": "Ersatz für", "ersetztdurch_sivas": "Ersetzt durch", "ersetztdurch_neu": "Ersetzt durch", "herstteilenr_sivas": "Hersteller Teilenummer", "herstteilenr_neu": "Hersteller Teilenummer", "werkstofftyp_neu": "Werkstofftyp", "material_sivas": "Material", "material_neu": "Material", "oberflaeche_neu": "Oberfläche", "farbe_neu": "Farbe", "version_sivas": "Version", "aenderungsindex_sivas": "Änderungsindex", "aenderungsindex_neu": "Änderungsindex", "aenderungstext_sivas": "Änderungstext", "aenderungstext_neu": "Änderungstext", "freigabevermerk_sivas": "Freigabevermerk", "freigabevermerk_neu": "Freigabevermerk", "zusatzinfos_auto_text": "Zusatzinformationen automatisch", "zusatzinfos_bendef_text": "Zusatzinformationen Benutzerdefiniert", } def __init__(self): """ is initalized with its unique id""" super().__init__() self._red_ids = {} self._parent_children_mapping = {} self._bom_properties = {} self._data = {} self._gui_data = {} self._gui_states = {} self._read_only_items = {} self._controller = None self._logic = None self._has_bom = None def clear(self): asm_id = self.get_asm_id() # das einzige was beim Löschen des Modells bleiben sollte, ist die übergeordnete Baugruppennummer self._data = {} self._gui_data = {} self.set_asm_id(asm_id) self._gui_states = {} self._read_only_items = {} if self._logic: self._logic.clear_states() def add_logic(self, logic): self._logic = logic def set_controller(self, controller): self._controller = controller def set_asm_id(self, asm_id): self.set_gui_data("asm_id", asm_id) def get_asm_id(self): return self.get_gui_data("asm_id") def set_current_item_id(self, tid): self.set_gui_data('teilenummer', tid) def get_current_item_id(self): return self.get_gui_data('teilenummer') def set_parent_children(self, parent_children_mapping): """ contains all id relations below, data of subassemblies etc. in a dict of the kind parent-children """ self._parent_children_mapping = parent_children_mapping def get_parent_children(self): 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 def get_red_ids(self): return self._red_ids def set_bom_properties(self, properties) -> dict: """" Contains the properties of the BOM-positions(e.g. description, material etc.) """ self._bom_properties = properties def get_bom_properties(self, property_name) -> dict: if property_name not in self._bom_properties: raise ValueError(f"Property '{property_name}' doesn't exist in BOM! Check property spelling!") else: return self._bom_properties[property_name] def set_bom_existence(self, bom_status: bool) -> bool: self._has_bom = bom_status def has_bom(self) -> bool: return self._has_bom # 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: raise Exception("this data can not be set "+ key) else: self._read_only_items[key] = val def get_read_only(self, key): return self._read_only_items[key] def get_all_read_only_data(self): 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: # raise Exception("this data can not be set "+ key) # else: # self._data[key] = val # def get_data(self, key): # """ gibt ein Datenstück zurück """ # return self._data[key] # def get_all_data(self): # """ gibt alle enthaltenen Daten zurück """ # return self._data # Daten die in der GUI gespeichert werden sollen def set_gui_dict(self, data:dict): """ setzt die Daten der GUI """ for k,v in data.items(): self.set_gui_data(k,v) def set_gui_data(self, key, val): """ merkt sich ein Datenatom für die GUI """ if key not in self.gui_data_keys: raise Exception("this data can not be set "+ key) else: self._gui_data[key] = val def set_state_dict(self, data:dict): """ setzt die Zustände der GUI wie readonly etc.""" for k,v in data.items(): self.set_state(k,v) def set_state(self, key, val): """ merkt sich den status wie 'readonly' etc für die GUI """ if key not in self.gui_data_keys: raise Exception("this data can not be set "+ key) else: self._gui_states[key] = val def get_states(self): return self._gui_states def get_gui_data(self, 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 def get_halbzeug_laenge_of_asm_id(self, halbzeugid): asm_id = self.get_asm_id() current_id = self.get_current_item_id() data_dir = self._controller.get_env('data') path = os.path.join(data_dir, asm_id + '.json') jsonobjs = None try: with open(path, encoding='utf-8') as json_file: jsonobjs = json.load(json_file) except Exception: raise Exception("guid_data, data, parent_children_mapping or red_ids not found") laenge = 0 if jsonobjs: for jo in jsonobjs[halbzeugid]: if jo['Parent'] == str(current_id): laenge = jo['Länge'] return laenge def _transform_content_from_csv(self, translated_data, author=None): """"baut die Texte aus der csv Datei nach dem Einladen um""" # default setzen if 'datenbank' not in translated_data: translated_data["datenbank"] = 'Produktiv' # Änderungstext sollte Author enthalten wenn einer gegeben ist if 'aenderungstext_sivas' in translated_data: text= translated_data["aenderungstext_sivas"] text_neu = None # semikolon müssen rausfliegen if re.search(';', text): text_neu = re.sub(r"\s*;\s*", " / ", text, flags=re.I) if author: if text_neu: text_neu = '{aenderungstext} (von {author})'.format(aenderungstext=text_neu, author=author) else: text_neu = '{aenderungstext} (von {author})'.format(aenderungstext=text, author=author) if text_neu: translated_data["aenderungstext_neu"] = text_neu else: pass else: default = "Erstanlage" if author: default = 'Erstanlage (von {author})'.format(author=author) translated_data["aenderungstext_neu"] = default # Spezial: Abkürzungen .kpl rausschmeissen. Text eventuell kürzen if "bezeichnung1_sivas" in translated_data: text = translated_data["bezeichnung1_sivas"] substituted_text = re.sub(r"\s+(?:-\s*bg|kpl)[.|\s]*", "", text, flags=re.I) if substituted_text != text: translated_data["bezeichnung1_neu"] = substituted_text # Spezial Halbzeug ohne Sägeliste if "halbzeugOhneSaege_sivas" in translated_data: text = translated_data["halbzeugOhneSaege_sivas"] if text =="N": translated_data["halbzeugOhneSaege_neu"] = "Sägeliste benötigt" else: translated_data["halbzeugOhneSaege_neu"] = "Sägeliste nicht benötigt" # Spezial Beschaffungsart if "beschaffungsart_sivas" in translated_data: text = translated_data["beschaffungsart_sivas"] if text =="Eigenbaugruppe": translated_data["beschaffungsart_sivas"] = "Eigenbau" # Spezial TOS Gruppe default = '6' if "tosgruppe_sivas" in translated_data: text = translated_data["tosgruppe_sivas"] if text =="": translated_data["tosgruppe_neu"] = default else: translated_data["tosgruppe_neu"] = default # Spezial Allgemeintoleranz if "fertigungsart_sivas" in translated_data: fertigungsart = translated_data["fertigungsart_sivas"] if fertigungsart == "3D - 3D-drucken": default = "ISO 2768:1991-mK" elif fertigungsart == "3D - 3D drucken": default = "ISO 2768:1991-mK" elif fertigungsart == "BI - biegen": default = "ISO 2768:1991-mK" elif fertigungsart == "DR - drehen": default = "ISO 2768:1991-mK" elif fertigungsart == "EX - extrudieren": default = "DIN 16941 - 3A" elif fertigungsart == "FR - fräsen": default = "ISO 2768:1991-mK" elif fertigungsart == "GI - gießen": default = "ISO 8062-3 - DCTG 10" elif fertigungsart == "LW - laser- und wasserstrahlschneiden": default = "ISO 2768:1991-mK" elif fertigungsart == "PR - verpressen": default = "ISO 2768:1991-mK" elif fertigungsart == "SA - sägen": default = "ISO 2768:1991-mK" elif fertigungsart == "SN - strangpressen": default = "EN 12020-2" elif fertigungsart == "SP - spritzgießen": default = "DIN ISO 20457-TG5" elif fertigungsart == "ST - stanzen": default = "DIN 6930-2 - m" elif fertigungsart == "SW - schweißen": default = "EN ISO 13920-BF" else: pass translated_data["allgemeintoleranz_sivas"] = default # Spezial Freigabevermerk if "freigabevermerk_sivas" in translated_data: text = translated_data["freigabevermerk_sivas"] if re.search(';', text): translated_data["freigabevermerk_neu"] = re.sub(r"\s*;\s*", " / ", text, flags=re.I) # Spezial Hersteller: aus "80312 - Rehau AG & Co." wird "Rehau AG & Co." if "hersteller_sivas" in translated_data: text = translated_data["hersteller_sivas"] if re.search(r"^\d+\s+-\s+", text): translated_data["hersteller_sivas"] = re.sub(r"^\d+\s+-\s+", "", text, flags=re.I) # Spezial Änderungsindex if "aenderungsindex_sivas" not in translated_data: translated_data["aenderungsindex_neu"] = 'A' elif "aenderungsindex_sivas" in translated_data: text = translated_data["aenderungsindex_sivas"] if text.islower(): translated_data["aenderungsindex_neu"] = text.upper() return translated_data def csv2guidata(self, data): translated_data = dict() for k,v in data.items(): if k in self.excel_to_gui and v is not None: translated_data[self.excel_to_gui[k]] = v # Spezial: Befüllung von Änderungstext mit dem Author, falls in der .csv vorhanden # Indexerfasser wird nicht in der gui verwaltet. Deshalb Modifikation aus den Rohdaten author = None if "Indexerfasser" in data: author = data["Indexerfasser"] translated_data = self._transform_content_from_csv(translated_data, author) return translated_data def get_child_of_id(self, sivasId): parent_children = self.get_parent_children() if str(sivasId) in parent_children: return parent_children[str(sivasId)][0] else: return None def get_all_children_of_id(self, sivasId): parent_children = self.get_parent_children() if str(sivasId) in parent_children: return parent_children[str(sivasId)] else: return None def sivas_data_from_csv(self, cid): path = os.path.join(self._controller.get_env("data"), cid + '.csv') if os.path.exists(path): data = self._load_csv(path) return data return None def _load_csv(self, path): """lädt die SIVAS csv Datei in die Felder für die Oberfläche """ if not os.path.exists(path): return None df = pd.read_csv(path, sep=';', converters={"Version":str, "Werkstoff": str}) ret = dict() # baue aus der gegebenen Zeile ein dict d = df.to_dict() for k,v in d.items(): value = v[0] # schmeisse alle NaN raus if pd.isna(value): value = None ret[k] = value return ret def from_json_file(self, subpath, cid): path = os.path.join(subpath, cid + '.json') if os.path.exists(path): self.load(path) return True return False def from_json(self, jsonobj): if "gui_data" in jsonobj: gui_data = jsonobj["gui_data"] self.set_gui_dict(gui_data) else: raise Exception("no gui_data given in string") if "parent_children_mapping" in jsonobj: parent_children_mapping = jsonobj["parent_children_mapping"] self.set_parent_children(parent_children_mapping) if "red_ids" in jsonobj: red_ids = jsonobj["red_ids"] self.set_red_ids(red_ids) def to_dict(self, tree=False ): jsonobj = dict() # die Oberflächendaten gui_data = self.get_all_gui_data() jsonobj["gui_data"] = gui_data # der Baum if tree: parent_children_mapping = self.get_parent_children() jsonobj["parent_children_mapping"] = parent_children_mapping # die ids der nicht migrierten Dateien red_ids = self.get_red_ids() jsonobj["red_ids"] = red_ids return jsonobj def to_json(self, tree=False): obj = self.to_dict(tree) return json.dumps(obj) def load(self, path): """loads all data of a model from a json string""" try: with open(path, encoding='utf-8') as json_file: self.from_json(json.load(json_file)) except Exception: raise Exception("guid_data, data, parent_children_mapping or red_ids not found") def save_to_file(self): """speichert die bisherigen Eingaben beider Spalten in eine json Datei""" path = os.path.join(self._controller.get_env("out"), str(self.get_current_item_id()) + '.json') if str(self.get_current_item_id()) == str(self.get_asm_id()): savePath = True else: savePath = False # die Bauminfos und RedIds dazu werden standardmässig nicht mit gemerkt. Nur im obersten Assemblyfile self.save(path, savePath) def save(self, path, tree=False): """saves all data of model to a json string""" with open(path, 'w') as f: json.dump(self.to_dict(tree), f, indent=4, sort_keys=True) def callback(self, key, value): if self._logic == None: raise Exception("no logic set") else: new_content = self._logic.callback(key, value) states = self._logic.get_states() self.set_state_dict(states) return new_content def get_dependent(self, key): if self._logic == None: raise Exception("no logic set") else: return self._logic.get_dependent(key) def set_gui_defaults(self): self._logic.set_gui_defaults() def message_info(self, title, key, values={}): return self._controller.message_info(title, key, values) def message_error(self, title, key, values={}): return self._controller.message_error(title, key, values) def message_question(self, title, key, values={}): return self._controller.message_question(title, key, values) def check_key_existence(self, key, missing): if not self.get_gui_data(key): missing.append(self.key2label[key]) def check_key_both_columns(self, key_sivas, key_neu, missing): if not self.get_gui_data(key_sivas): if not self.get_gui_data(key_neu): missing.append(self.key2label[key_neu]) def get_key_with_data(self, key_sivas: str, key_neu: str, key_list: list = []): ''' Vergleicht Inhalt von SIVAS-Feld und überschriebenem Feld: - Sind nur das überschriebene oder das überschriebe und das SIVAS-Feld befüllt, wird das überschriebene zurückgegeben - Ist nur das SIVAS-Feld befüllt, wird das SIVAS-Feld zurückgegeben - Ist keines von beiden Feldern befüllt, wird None zurückgegeben ''' if not self.get_gui_data(key_neu): if not self.get_gui_data(key_sivas): return key_list.append(key_sivas) else: key_list.append(key_neu) return key_list def check_pflichtfelder(self): """Allgemeine Prüfungen: Solange nicht alle Pflichtfelder einen Wert aufweisen, muss beim Klick auf den Button "Migrieren" eine ERROR-Messagebox erscheinen, in der alle Pflichtfelder aufgelistet sind, die keinen Wert aufweisen """ missing = list() # Teilenummer self.check_key_existence("teilenummer", missing) # Datenbank self.check_key_existence("datenbank", missing) # PDM-Kategorie self.check_key_existence("pdm_kategorie_neu", missing) # Halbzeugfarbe hblzeug_oberfläche = self.get_gui_data("halbzeugoberflaeche_neu") if hblzeug_oberfläche == "eloxieren" or hblzeug_oberfläche == "lackieren" or hblzeug_oberfläche == "pulverbeschichten": if not self.get_gui_data("halbzeugfarbe_neu"): missing.append("Halbzeugfarbe") # Lebenszyklusstatus self.check_key_existence("lebenszyklus_status_neu", missing) # 3D-Modell self.check_key_existence("model3d_neu", missing) # Bezeichnung 1 self.check_key_both_columns("bezeichnung1_sivas", "bezeichnung1_neu", missing) # Halbzeug ohne Sägeliste self.check_key_both_columns("halbzeugOhneSaege_sivas", "halbzeugOhneSaege_neu", missing) # Rüstcode self.check_key_both_columns("ruestcode_sivas", "ruestcode_neu", missing) pdm_kategorie_neu = self.get_gui_data("pdm_kategorie_neu") # Fertigungsart if pdm_kategorie_neu == "Einzelteil" or pdm_kategorie_neu == "Schweissbaugruppe": self.check_key_both_columns("fertigungsart_sivas", "fertigungsart_neu", missing) # Allgemeintoleranz if pdm_kategorie_neu == "Einzelteil" or pdm_kategorie_neu == "Schweissbaugruppe": self.check_key_both_columns("allgemeintoleranz_sivas", "allgemeintoleranz_neu", missing) # FOS-Gruppe self.check_key_both_columns("fosGruppe_sivas", "fosGruppe_neu", missing) # Kalkulationsart self.check_key_both_columns("kalkulationsart_sivas", "kalkulationsart_neu", missing) # Beschaffungsart self.check_key_both_columns("beschaffungsart_sivas", "beschaffungsart_neu", missing) # Mengeneinheit self.check_key_both_columns("mengeneinheit_sivas", "mengeneinheit_neu", missing) # Halbzeug self.check_key_both_columns("halbzeug_sivas", "halbzeug_neu", missing) # TOS-Gruppe self.check_key_both_columns("tosgruppe_sivas", "tosgruppe_neu", missing) # Dispogruppe self.check_key_both_columns("dispogruppe_sivas", "dispogruppe_neu", missing) # Dispolaufgruppe self.check_key_both_columns("dispolaufgruppe_sivas", "dispolaufgruppe_neu", missing) # Werkstofftyp aus_halbzeug = self.get_gui_data("aus_halbzeug_neu") if pdm_kategorie_neu == "Einzelteil" and aus_halbzeug is False: self.check_key_existence("werkstofftyp_neu", missing) # Änderungstext self.check_key_both_columns("aenderungstext_sivas", "aenderungstext_neu", missing) # Freigabevermerk self.check_key_both_columns("freigabevermerk_sivas", "freigabevermerk_neu", missing) if len(missing) > 0: return (False, missing) else: return (True, []) def check_blacklist_completeness(self): """ Prüft, ob Baugruppen-id in Blacklist fehlt -> zutreffend, wenn in Stückliste beigestellte oder dispo-inaktive Stücklistenpositionen existieren """ teilenummer = self.get_gui_data("teilenummer") child_id = self.get_child_of_id(teilenummer) if child_id is None: # Prüfung nur bei Teilenummern mit Stückliste sinnvoll return (True, {}) config = self._controller.get_config() blacklist_ids = set(config.get_blacklist()) children_ids = self.get_all_children_of_id(teilenummer) # In der Prüfung dürfen nur die Kinder der aktuellen BG-Ebene, aber keine Kinder aus tieferen BG-Ebenen berücksichtigt werden dispoaktiv_statuses = {} beistellung_statuses = {} for child_id in children_ids: dispoaktiv_statuses[child_id] = self.get_bom_properties("Dispoaktiv")[child_id] beistellung_statuses[child_id] = self.get_bom_properties("Lieferantenbeistellung")[child_id] if "False" not in dispoaktiv_statuses.values() and "True" not in beistellung_statuses.values(): return (True, {}) if teilenummer not in blacklist_ids: return (False, {teilenummer}) else: return (True, {}) def check_improper_chars(self, invalid_chars): """ Überprüft, ob in den Eingabefeldern der GUI unzulässige Zeichen eingetragen wurden. Die unzulässigen Zeichen sind in cfg/InvalidCharacters.txt aufgelistet. Ursprung dieser Liste ist //ruledesigner/RDF_Daten/Konfigurator/CustomVaulting/ERP_Item.ini -> Option "InvalidCharacters" """ wrongchars = {} keys_to_check = [] # Bei diesen Feldern soll geprüft werden, ob sie einen Inhalt aufweisen. Wenn nicht, muss auch nicht geprüft werden, ob sich darin unzulässige Zeichen befinden. check_key_for_data = ["halbzeugnummer_neu", "halbzeuglaenge_neu", "zusatzinfos_auto_text", "zusatzinfos_bendef_text"] keys_with_data = list(filter(lambda key: self.get_gui_data(key) != "", check_key_for_data)) keys_to_check + keys_with_data # Mapping SIVAS-Felder und Überschriebene Felder. Hier soll jeweils geprüft werden, welches der beiden einen Wert enthält. # Wenn beide Felder einen Wert enthalten soll nur das überschriebene Feld nach unzulässigen Zeichen durchsucht werden, ansonsten das SIVAS-Feld compare_keys_for_data = { "bezeichnung1_sivas": "bezeichnung1_neu", "tosgruppe_sivas": "tosgruppe_neu", "hersteller_sivas": "hersteller_neu", "ersatzfuer_sivas": "ersatzfuer_neu", "ersetztdurch_sivas": "ersetztdurch_neu", "herstteilenr_sivas": "herstteilenr_neu", "material_sivas": "material_neu", "aenderungsindex_sivas": "aenderungsindex_neu", "aenderungstext_sivas": "aenderungstext_neu", "freigabevermerk_sivas": "freigabevermerk_neu", } for sivas_key, neu_key in compare_keys_for_data.items(): self.get_key_with_data(sivas_key, neu_key, keys_to_check) for key in keys_to_check: content = self.get_gui_data(key) for c in invalid_chars: if c in content: Label = self.key2label[key] if Label in wrongchars: wrongchars[Label].append(c) else: wrongchars[Label] = [c] if len(wrongchars.keys()) > 0: return (False, wrongchars) else: return (True, {}) def get_content(self, key_sivas, key_neu): if self.get_gui_data(key_neu): return self.get_gui_data(key_neu) else: if self.get_gui_data(key_sivas): return self.get_gui_data(key_sivas) return None def check_content(self): """Überprüfe die Inhalte nach Längen, Zeichenketten und korrekten Kombinationen der Eingaben""" # Prüfung Bezeichnungslänge (darf max. 50 Zeichen betragen) pdm_kategorie_neu = self.get_gui_data("pdm_kategorie_neu") content = self.get_content('bezeichnung1_sivas', 'bezeichnung1_neu') if len(content) > 50: self.message_error('Bezeichnung1 zu gross', 'bezeichnung_zu_gross_50') return False # Rüstcode und Sägeliste ruestcode = self.get_gui_data("ruestcode_sivas") halbzeugOhneSaege_neu = self.get_gui_data("halbzeugOhneSaege_neu") if ruestcode == "SRC Standard Rüstcode" and halbzeugOhneSaege_neu == "Sägeliste nicht benötigt": self.message_error('Konflikt Rüstcode und Sägeliste', 'konflikt_ruestcode_saegeliste') return False # Rüstcode und Kategorie ruestcode = self.get_content('ruestcode_sivas', 'ruestcode_neu') if pdm_kategorie_neu != "Baugruppe" and ruestcode == "": self.message_error('Teilenummer ohne Rüstcode', 'teilenummer_ohne_ruestcode') return False if pdm_kategorie_neu == "": self.message_error('Kategorie nicht definiert', 'pdm_kategorie_definiert') return False # Fertigungsart fertigungsart = self.get_content('fertigungsart_sivas', 'fertigungsart_neu') arten = ["3D - 3D-drucken", "EX - extrudieren", "GI - gießen", "PR - verpressen", "SN - strangpressen", "SP - spritzgießen", "SW - schweißen"] if pdm_kategorie_neu == "Baugruppe" and fertigungsart == arten: self.message_error('Fertigunsart falsch', 'fertigungsart') return False farten = self._controller.get_config().Fertigung.get_list_in_section("Fertigungsarten") if pdm_kategorie_neu == "Kauteil" and fertigungsart == farten: self.message_error('Fertigunsart falsch', 'fertigungsart') return False if pdm_kategorie_neu == "Schweissbaugruppe" and fertigungsart != "SW - schweißen": self.message_error('Fertigunsart falsch', 'fertigungsart') return False # FOS - Gruppe fos_gruppe = self.get_content('fosGruppe_sivas', 'fosGruppe_neu') if pdm_kategorie_neu == "Baugruppe" and fos_gruppe == "0 - Einzelteil": self.message_error('FOS Gruppe falsch', 'fos_gruppe') return False if pdm_kategorie_neu == "Einzelteil" and fos_gruppe == "1 - Baugruppe": self.message_error('FOS Gruppe falsch', 'fos_gruppe') return False if pdm_kategorie_neu == "Schweissbaugruppe" and fos_gruppe == "1 - Baugruppe": self.message_error('FOS Gruppe falsch', 'fos_gruppe') return False # Kalkulationsart kalkulationsart = self.get_content('kalkulationsart_sivas', 'kalkulationsart_neu') if pdm_kategorie_neu == "Kaufteil" and kalkulationsart == "Eigenbau": self.message_error('Kalkulationsart falsch', 'kalkulations_art') return False if pdm_kategorie_neu == "Einzelteil" and kalkulationsart == "Kaufteil": self.message_error('Kalkulationsart falsch', 'kalkulations_art') return False if pdm_kategorie_neu == "Schweissbaugruppe" and kalkulationsart == "Kaufteil": self.message_error('Kalkulationsart falsch', 'kalkulations_art') return False # Beschaffungsart beschaffungsart = self.get_content('beschaffungsart_sivas', 'beschaffungsart_neu') if pdm_kategorie_neu == "Baugruppe" and beschaffungsart == "Kaufteil": self.message_error('beschaffungsart falsch', 'beschaffungsart') return False if pdm_kategorie_neu == "Schweissbaugruppe" and beschaffungsart == "Kaufteil": self.message_error('beschaffungsart falsch', 'beschaffungsart') return False if pdm_kategorie_neu == "Kaufteil" and beschaffungsart == "Eigenbau": self.message_error('beschaffungsart falsch', 'beschaffungsart') return False # Mengeneinheit mengeneinheit = self.get_content('mengeneinheit_sivas', 'mengeneinheit_neu') ruestcode = self.get_content('ruestcode_sivas', 'ruestcode_neu') if ruestcode == "SRC - Standard Rüstcode" and mengeneinheit != "Stck - Stück": self.message_error('Mengeneinheit falsch', 'mengeneinheit') return False # Halbzeug halbzeug = self.get_content('halbzeug_sivas', 'halbzeug_neu') if ruestcode == "SRC - Standard Rüstcode" and halbzeug == 'WAHR': self.message_error('Halbzeug falsch', 'teilenummer_halbzeug') return False if ruestcode == "Trümmerbaugruppe" and halbzeug == 'WAHR': self.message_error('Halbzeug falsch', 'teilenummer_halbzeug') return False # TOS-Gruppe tosgruppe = self.get_content('tosgruppe_sivas', 'tosgruppe_neu') (num2refId, num2child) = self._controller.get_config().TOSGruppen.get_Id2TosGroup() # TODO wirklich als refernce-id oder als Gruppe? if tosgruppe not in num2child.keys(): self.message_error('TOS Gruppe nicht vorhanden', 'tos_gruppe_not_exist') return False # Dispogruppe dispogruppe = self.get_content('dispogruppe_sivas', 'dispogruppe_neu') if dispogruppe == '': self.message_error('Dispogruppe nicht angegeben', 'dispo_not_exist') return False # Dispolaufgruppe dispolaufgruppe = self.get_content('dispolaufgruppe_sivas', 'dispolaufgruppe_neu') if dispolaufgruppe == '' or dispolaufgruppe == " - ": self.message_error('Dispolaufgruppe nicht angegeben', 'dispolauf_not_exist') return False # Ersatz für ersatzfuer = self.get_content('ersatzfuer_sivas', 'ersatzfuer_neu') Teilenummern = self._controller.get_config().get_ruledesigner_ids() if ersatzfuer and ersatzfuer not in Teilenummern: ret = self.message_question('Ersatz nicht in Teilenummer ', 'teilenummer_not_exist_infos', {'teilenummer':ersatzfuer, 'default':'no' } ) if ret == "no": return False # Ersetzt durch ersatzdurch = self.get_content('ersetztdurch_sivas', 'ersetztdurch_neu') Teilenummern = self._controller.get_config().get_ruledesigner_ids() if ersatzdurch and ersatzdurch not in Teilenummern: ret = self.message_question('Ersatz nicht in Teilenummer ', 'ersatzteilenummer_not_exist_infos', {'teilenummer':ersatzdurch, 'default':'no' } ) if ret == "no": return False # Hersteller hersteller = self.get_content('hersteller_sivas', 'hersteller_neu') alleHersteller = self._controller.get_config().Hersteller.get_all() if hersteller and hersteller not in alleHersteller: ret = self.message_error('Ersatz nicht in Teilenummer ', 'hersteller', {'hersteller':hersteller } ) if ret == "no": return False # # Werkstofftyp TODO # werkstofftyp = self.get_content('werkstofftyp_neu', 'werkstofftyp_neu') # if werkstofftyp == '': # self.message_error('Werkstofftyp nicht eingetragen', 'werkstofftyp_not_exist') # return # # Material TODO # werkstofftyp = self.get_content('werkstofftyp_neu', 'werkstofftyp_neu') # if werkstofftyp == '': # self.message_error('Werkstofftyp nicht eingetragen', 'werkstofftyp_not_exist') # return # Farbe farbe = self.get_gui_data("farbe_neu") oberflaeche = self.get_gui_data("oberflaeche_neu") if farbe == '' and (oberflaeche == "Masterbatch (Grundfarbe)" or \ oberflaeche == "eloxieren" or\ oberflaeche == "pulverbeschichten" or\ oberflaeche == "lackieren"): self.message_error('Farbe nicht festgelegt', 'color_not_defined') return False # Überprüfung ob eine Ergänzung der Angaben zu Material in der Config Datei nötig wäre aus_halbzeug = self.get_gui_data("aus_halbzeug_neu") if pdm_kategorie_neu == "Einzelteil" and aus_halbzeug == False: mlist = self._controller.get_config().Materialien.get_all_materials() material_sivas = self.get_gui_data("material_sivas") if material_sivas not in mlist: self.message_info('Materialinformation', 'material_infos') return True def call_prep_tool(self, impf_pfad): data_prep_tool = os.environ.get(r'SIEMENS_DATA_PREP_TOOL') if not os.path.isfile(data_prep_tool): self.message_error('Impftool not found', 'wrong_impftool_path') return False out_dir = self._controller.get_env('out') subprocess.run(f"{data_prep_tool} /file {impf_pfad} /ModifyProperties") all_logs = glob.glob(os.path.join(out_dir, "*.log")) if len(all_logs) > 1: self.message_error('too many logfiles found', 'too_many_logfiles') return False else: path = all_logs[0] content = '' try: with open(path, 'r', encoding='utf-16le') as f: content = f.read() f.close() except Exception: raise Exception("log file could not be opened") ret = False if re.findall(r'1 out of 1', content): os.remove(path) self.message_info('Preparation sucessful', 'preparation_sucessful', {'path':impf_pfad}) ret = True elif re.findall(r'Error', content): self.message_error('Something went wrong', 'some_error_in_log') else: self.message_error('Something went wrong', 'some_error_in_log') if not ret: log_editor = os.environ.get(r'LOG_EDITOR') subprocess.run(f"{log_editor} {path}") if os.path.exists(path): shutil.move(path, self._controller.get_env('log')) return ret def create_migration_file(self, data): """erzeugt Verzeichnis und Datei""" datenbank = self.get_gui_data("datenbank") # IF Datenbank == "Produktiv": # New_path = \\ssg.local\freigaben\SIVAS_CAD_EDM\Migration\02_Bedarfspool\ # ELSE: # New_path = \\ssg.local\freigaben\SIVAS_CAD_EDM\Schulung\Migration\02_Bedarfspool zielpfad = self._controller.get_config().Pfade.get('Zielpfade', datenbank ) if os.path.exists(zielpfad): # nur den Usernamen dazu bauen, wenn auch der konfigurierte Pfad existiert. username = os.environ.get("USERNAME") userpfad = os.path.join(zielpfad, username) # Wenn User, der migriert, noch keinen Ordner im Ziel besitzt, # soll dieser automatisch beim Klick auf "Migrieren" angelegt werden. if not os.path.exists(userpfad): os.mkdir(userpfad) current_id = self.get_current_item_id() target_path = os.path.join(self._controller.get_env('out'), str(current_id) + '.xlsx') infos = dict() infos['path'] = target_path df = pd.DataFrame.from_dict(data, orient='index') df = (df.T) df.to_excel(target_path, header=True, index=False) if not os.path.exists(target_path): raise FileExistsError("Pfad wurde nicht erzeugt", target_path) return infos def tos_to_dict(self, tosgruppe, num2refId, num2child): tosstr = str(tosgruppe) ret = dict() keybefore = '' for n in range(1, len(tosstr)+1): if n == 1: spaltenName = "TOS-Gruppe" else: spaltenName = keybefore key = tosstr[0:n] if key in num2refId: parentKey = num2refId[key] content = num2child[key] ret[spaltenName] = content else: spaltenName = keybefore ret[spaltenName] = num2child[key] keybefore = parentKey return ret def create_migration_data(self): data = { # Die hier aufgelistete Reihenfolge der Spalten legt die Reihenfolge in der abgeleiteten Excel fest, sollte hier eine anndere Sorierung benötigt werden die Reihenfolge der Spalten ändern # vorgegebene Keys 'Path':'', 'Filename':'', 'New Path':'', 'New Filename':'', 'Delete':'' , 'Document Number':'-', 'Revision': '-', 'Project Name': '-', 'Teamcenter Item Type': '-', 'Part Type': '-', 'TC_ImportTime': '-', 'Last Saved Version': '-', 'Subject': '-', 'Category': '-', 'Keywords': '-', 'Title':'', # Default Inhalte 'Änderungsbeschreibung':'', 'Allgemeintoleranz':'', 'HalbzeugInternAngabe':'', 'Author':'', 'BeschaffungsartNE':'', 'Bezeichnung2':'', 'Bezeichnung4':'', 'Dispogruppe':'', 'Dispolaufgruppe':'', 'Farbe':'', 'Farbe':'', 'Fertigungsart':'', 'FOS-GruppeNE':'', 'Freigabevermerk':'', 'Halbzeug':'', 'HalbzeugIntern':'', 'HalbzeugOhneSaegeliste':'', 'Hersteller':'', 'HerstellerTeilenummer':'', 'KalkulationsartNE':'', 'KategorieNE':'', 'Kopiertes_Teil_1_y_Skalierung':'', 'EinheitNE':'', 'Oberflaechenbehandlung':'', 'RuestcodeAusw':'', 'Serien-Status':'', 'StartRevision':'', 'Teilenummer':'', 'WerkstoffNE':'', 'WerkstofftypNE':'', 'ZusaetzlicheInformationen':'', 'Kantennorm':'', 'Oberflaechennorm':'', 'Massnorm':'', 'Tolerierungsnorm':'', 'TOS-Gruppe':'' } all_data = self.get_all_gui_data() model3d_neu = self.get_gui_data("model3d_neu") path = os.path.dirname(model3d_neu) data["Path"] = path filename = os.path.basename(model3d_neu) data["Filename"] = filename (fn, ending) = filename.split('.') teilenummer = self.get_gui_data("teilenummer") datenbank = self.get_gui_data("datenbank") # IF Datenbank == "Produktiv": # New_path = \\ssg.local\freigaben\SIVAS_CAD_EDM\Migration\02_Bedarfspool\ # ELSE: # New_path = \\ssg.local\freigaben\SIVAS_CAD_EDM\Schulung\Migration\02_Bedarfspool zpfad = self._controller.get_config().Pfade.get('Zielpfade', datenbank ) username = os.environ.get("USERNAME") zielpfad = os.path.join(zpfad, username) data["New Path"] = zielpfad data["New Filename"] = teilenummer + "." +ending data["Teilenummer"] = teilenummer pdm_kategorie_neu = self.get_gui_data("pdm_kategorie_neu") bezeichnung1 = self.get_content('bezeichnung1_sivas', 'bezeichnung1_neu') title = bezeichnung1 data["KategorieNE"] = pdm_kategorie_neu data["Title"] = title # Aus Halbzeug aus_halbzeug = self.get_gui_data("aus_halbzeug_neu") if aus_halbzeug: data["HalbzeugInternAngabe"] = "Ja" else: data["HalbzeugInternAngabe"] = "Nein" # Halbzeugnummer halbzeugnummer = self.get_gui_data("halbzeugnummer_neu") if halbzeugnummer: data["HalbzeugIntern"] = halbzeugnummer # Halbzeuglänge halbzeuglaenge = self.get_gui_data("halbzeuglaenge_neu") if halbzeuglaenge: data["Kopiertes_Teil_1_y_Skalierung"] = halbzeuglaenge # Halbzeugoberfläche halbzeugoberflaeche = self.get_gui_data("halbzeugoberflaeche_neu") if halbzeugoberflaeche: data["Oberflaechenbehandlung"] = halbzeugoberflaeche # Halbzeugfarbe farbe = self.get_gui_data("halbzeugoberflaeche_neu") if farbe: data["Farbe"] = farbe # Lebenszyklussstatus serienstatus = self.get_gui_data("lebenszyklus_status_neu") if serienstatus: data["Serien-Status"] = serienstatus # 3D-Modell - None # Bezeichnung 1 if bezeichnung1: data["Bezeichnung2"] = bezeichnung1 bezeichnung4 = "" if pdm_kategorie_neu == "Baugruppe" or pdm_kategorie_neu == "Schweissbaugruppe": bezeichnung4 = "- BG" data["Bezeichnung4"] = bezeichnung4 # Author username = os.environ.get("USERNAME") data["Author"] = username halbzeugOhneSaege = self.get_content('halbzeugOhneSaege_sivas', 'halbzeugOhneSaege_sivas') trans_halbzeugOhneSaege = { "N": "Sägeliste benötigt", "J": "Sägeliste nicht benötigt" } if halbzeugOhneSaege: data["HalbzeugOhneSaegeliste"] = trans_halbzeugOhneSaege[halbzeugOhneSaege] ruestcode = self.get_content('ruestcode_sivas', 'ruestcode_neu') trans_ruestcode = { "Trümmerbaugruppe": "Trümmerbaugruppe", "HZS - Halbzeuge Sägeteile": "HZS Halbzeuge Sägeteile", "HZS Halbzeuge Sägeteile": "HZS Halbzeuge Sägeteile", # Erforderlich, wenn Ruestcode in Spalte 'Ueberschriebene Werte' ausgewählt wird, sonst Aenderung von 'Allgemein.cfg' erforderlich "SRC - Standard Rüstcode": "SRC Standard Rüstcode", "SRC Standard Rüstcode": "SRC Standard Rüstcode" # Erforderlich, wenn Ruestcode in Spalte 'Ueberschriebene Werte' ausgewählt wird, sonst Aenderung von 'Allgemein.cfg' erforderlich } if ruestcode: data["RuestcodeAusw"] = trans_ruestcode[ruestcode] # Fertigungsart fertigungsart = self.get_content('fertigungsart_sivas', 'fertigungsart_neu') trans = { "3D - 3D-drucken":"3D-drucken", "3D - 3D drucken":"3D-drucken", "BI - biegen":"biegen", "DR - drehen":"drehen", "EX - extrudieren":"extrudieren", "FR - fräsen":"fräsen", "GI - gießen":"gießen", "LW - laser- und wasserstrahlschneiden":"laser-/wasserstrahlschneiden", "PR - verpressen":"verpressen", "SA - sägen":"sägen", "SN - strangpressen":"strangpressen", "SP - spritzgießen":"spritzgießen", "ST - stanzen":"stanzen", "SW - schweißen":"schweißen", } if fertigungsart is not None: data["Fertigungsart"] = trans[fertigungsart] # Allgemeintoleranz toleranz = self.get_content('allgemeintoleranz_sivas', 'allgemeintoleranz_neu') if toleranz is not None: data["Allgemeintoleranz"] = toleranz # Kantennorm normen = self._controller.get_config().Normen norm = normen.get_section_options("Kantennorm") if norm is not None: data["Kantennorm"] = norm[0] # Massnorm norm = normen.get_section_options("Massnorm") if norm is not None: data["Massnorm"] = norm[0] # Oberflaechennorm norm = normen.get_section_options("Oberflaechennorm") if norm is not None: data["Oberflaechennorm"] = norm[0] # Tolerierungsnorm norm = normen.get_section_options("Tolerierungsnorm") if norm is not None: data["Tolerierungsnorm"] = norm[0] # FOS Gruppe fos_gruppe = self.get_content('fosGruppe_sivas', 'fosGruppe_neu') trans = { "0 - Einzelteil":"Einzelteil", "1 - Baugruppe":"Baugruppe", } data["FOS-GruppeNE"] = trans[fos_gruppe] # Kalkulationsart kalkart = self.get_content('kalkulationsart_sivas', 'kalkulationsart_neu') if kalkart is not None: data["KalkulationsartNE"] = kalkart # Beschaffungsart beschaffungsart = self.get_content('beschaffungsart_sivas', 'beschaffungsart_neu') if beschaffungsart is not None: data["BeschaffungsartNE"] = beschaffungsart # Mengeneinheit mengeneinheit = self.get_content('mengeneinheit_sivas', 'mengeneinheit_neu') trans = { "L - Liter":"L", "mm - Millimeter":"mm", "Stck - Stück":"Stck", "M - Meter":"m", "m2 - Quadratmeter":"m²", "dm³ - Kubikdezimeter":"dm³", "m³ - Kubikmeter":"m³", } data["EinheitNE"] = trans[mengeneinheit] # Halbzeug halbzeug = self.get_content('halbzeug_sivas', 'halbzeug_neu') trans = { "WAHR":"Ja", "FALSCH":"", } data["Halbzeug"] = trans[halbzeug] # TOS-Gruppe # Nr. Spaltenname in Impfdatei Wert in Impfdatei # 3 TOS-Gruppe Schönenberger Produkt # 33 TOS_Schoenenberger_Produkt ILS IntraLogistikSystem # 330 TOS_ILS ILS 2.0 # 3303 TOS_ILS_2 Laufprofil 2.0 (num2refId, num2child) = self._controller.get_config().TOSGruppen.get_Id2TosGroup() tosgruppe = self.get_content('tosgruppe_sivas', 'tosgruppe_neu') newcolumns = self.tos_to_dict(tosgruppe, num2refId, num2child) data.update(newcolumns) # Dispogruppe dispogruppe = self.get_content('dispogruppe_sivas', 'dispogruppe_neu') trans = { "10 - Fahrstrecke":"Fahrstrecke", "20 - Förderer":"Förderer", "30 - Gerüst":"Gerüst", "40 - Betriebsmittel":"Betriebsmittel", "50 - Automation":"Automation", "60 - Kleinteile":"Kleinteil", "70 - Rohmaterial":"Rohmaterial", "80 - Sonstiges Intern":"Sonstiges Intern", "90 - Baustelleneinrichtung":"Baustelleneinrichtung", "100 - Sonderkonstruktionen":"Sonderkonstruktionen", } data["Dispogruppe"] = trans[dispogruppe] # Dispolaufgruppe dispolaufgruppe = self.get_content('dispolaufgruppe_sivas', 'dispolaufgruppe_neu') trans = { "10 - Omniflo":"Omniflo", "20 - Intra Logistic System + Alt-HFS":"Intra Logistic System + alt-HFS", "30 - Fremd-Transportsysteme + SSG-Anbauten":"Fremd-Transportsysteme + SSG-Anbauten", "40 - Spinnereikomponenten":"Spinnereikomponente", "45 - Automotiv":"Automotiv", "50 - Nicht eindeutig, Sonder":"Nicht eindeutig, Sonder", } data["Dispolaufgruppe"] = trans[dispolaufgruppe] # Hersteller hersteller = self.get_content('hersteller_sivas', 'hersteller_neu') if hersteller: data['Hersteller'] = hersteller # HerstellerTeilenummer herstellertnr = self.get_content('herstteilenr_sivas', 'herstteilenr_neu') if herstellertnr: data['HerstellerTeilenummer'] = herstellertnr # Ersatz für - None # Ersatz durch - None # Wirkstoffdiskrepanz - None # Werkstofftyp werkstofftyp = self.get_gui_data('werkstofftyp_neu') if werkstofftyp: data["WerkstofftypNE"] = werkstofftyp # Material material = self.get_content('material_sivas', 'material_neu') if material: if not aus_halbzeug: data["WerkstoffNE"] = material else: data["WerkstoffNE"] = "" # Oberfläche oberflaeche = self.get_gui_data('oberflaeche_neu') if oberflaeche: data["Oberflaechenbehandlung"] = oberflaeche # Farbe farbe = self.get_gui_data('farbe_neu') if farbe: data["Farbe"] = farbe # Version - None # Startrevision startrevision = self.get_content('aenderungsindex_sivas', 'aenderungsindex_neu') if startrevision: data["StartRevision"] = startrevision # Änderungstext aenderungstext = self.get_content('aenderungstext_sivas', 'aenderungstext_neu' ) if aenderungstext: data["Änderungsbeschreibung"] = aenderungstext # Freigabevermerk freigabe = self.get_content('freigabevermerk_sivas', 'freigabevermerk_neu') if freigabe: data["Freigabevermerk"] = freigabe # ZusaetzlicheInformationen # Die Werte aus den Feldern Automatische Zusatzinformationen und # Benutzerdefinierte Zusatzinformationen müssen vor dem Eintragen in # die Impfdatei zusammengesetzt werden zusatzinfos_auto_text = self.get_gui_data("zusatzinfos_auto_text") zusatzinfos_bendef_text = self.get_gui_data("zusatzinfos_bendef_text") data["ZusaetzlicheInformationen"] = zusatzinfos_auto_text + zusatzinfos_bendef_text return data class CadItemRepository: """ container class for all CadItems in the local folder also just managed by the controller """ def __init__(self): self.caditems = [] def add(self, caditem): self.caditems.append(caditem) def get(self, id): for caditem in self.caditems: if caditem.id == id: return caditem return None def get_all(self): return self.caditems def update(self, old_item, new_item): self.delete(old_item.id) self.add(new_item) def delete(self, id): for p in self.caditems: if p.id == id: self.caditems.remove(p) return raise Exception("CadItem not found") class GuiLogic(): """ Class for business logic. implementing the dependencies between different user inputs die neuen Inhalte nach jedem Callback werden als dict zurückgegeben. Manche Callbacks verursachen weitere abhängige Callbacks. Am Ende geht das gesamte Dictionary der neuen Inhalte von Comboboxen und Entries zurück und werden im Modell gesetzt """ 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 werden die Zustände gespeichert self._states = dict() # comboboxen disabled/enabled def clear_states(self): self._states = dict() def get_states(self): return self._states def set_state(self, key, val): """ merkt sich den status wie 'readonly' etc für dieses item in der GUI""" self._states[key] = val 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_aus_halbzeug_neu') self.call_and_set_data('cb_ruestcode_neu') self.call_and_set_data('cb_lebenszyklus_status_neu') self.call_and_set_data('cb_fosGruppe_neu') # self.call_and_set_data('cb_3Dmodel_neu') 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_datenbank_neu': ret = self.cb_datenbank_neu(value) elif 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': set = self.cb_halbzeugOhneSaege_neu(value) elif key == 'cb_ruestcode_neu': ret = self.cb_ruestcode_neu(value) ### elif key == 'cb_fertigungsart_neu': ret = self.cb_fertigungsart_neu(value) elif key == 'cb_allgemeintoleranz_neu': ret = self.cb_allgemeintoleranz_neu(value) elif key == 'cb_fosGruppe_neu': ret = self.cb_fosGruppe_neu(value) elif key == 'cb_kalkulationsart_neu': ret = self.cb_kalkulationsart_neu(value) elif key == 'cb_beschaffungsart_neu': ret = self.cb_beschaffungsart_neu(value) elif key == 'cb_mengeneinheit_neu': ret = self.cb_mengeneinheit_neu(value) elif key == 'cb_halbzeug_neu': ret = self.cb_halbzeug_neu(value) elif key == 'cb_dispogruppe_neu': ret = self.cb_dispogruppe_neu(value) elif key == 'cb_dispolaufgruppe_neu': ret = self.cb_dispolaufgruppe_neu(value) elif key == 'cb_hersteller_neu': ret = self.cb_hersteller_neu(value) elif key == 'cb_herstteilenr_neu': ret = self.cb_herstteilenr_neu(value) elif key == 'cb_werkstoffdiskrepanz': ret = self.cb_werkstoffdiskrepanz(value) elif key == 'cb_werkstofftyp_neu': ret = self.cb_werkstofftyp_neu(value) elif key == 'cb_material_neu': ret = self.cb_material_neu(value) elif key == 'cb_oberflaeche_neu': ret = self.cb_oberflaeche_neu(value) elif key == 'cb_farbe_neu': ret = self.cb_farbe_neu(value) elif key == 'cb_halbzeugnummer': ret = self.cb_halbzeugnummer(value) elif key == 'cb_halbzeuglaenge': ret = self.cb_halbzeuglaenge(value) elif key == 'cb_freigabevermerk': ret = self.cb_freigabevermerk(value) elif key == 'cb_zusatzinfos_auto_text': ret = self.cb_zusatzinfos_auto_text(value) else: raise Exception("this callback does not exist "+key) return ret def get_dependent(self, key): """ gibt die Namen der Callbacks zurück, welche nach dem Aufruf der ursprünglichen Methode wegen der Abhängigkeiten der Comboboxen anschliessend folgen sollen """ ret = list() if key == 'cb_datenbank_neu': ret = [] elif key == 'cb_pdm_kategorie_neu': ret = ['cb_neuaufbau', 'cb_aus_halbzeug_neu', 'cb_3Dmodel_neu', 'cb_halbzeugOhneSaege_neu', 'cb_ruestcode_neu', 'cb_fertigungsart_neu', 'cb_allgemeintoleranz_neu', 'cb_fosGruppe_neu', 'cb_kalkulationsart_neu', 'cb_beschaffungsart_neu', 'cb_mengeneinheit_neu', 'cb_halbzeug_neu', 'cb_dispogruppe_neu', 'cb_dispolaufgruppe_neu', 'cb_hersteller_neu', 'cb_werkstoffdiskrepanz', 'cb_werkstofftyp_neu', 'cb_material_neu', 'cb_oberflaeche_neu', 'cb_farbe_neu', 'cb_herstteilenr_neu', 'cb_freigabevermerk', 'cb_halbzeugoberflaeche', 'cb_halbzeugfarbe', 'cb_halbzeugnummer', 'cb_halbzeuglaenge','cb_zusatzinfos_auto_text'] elif key == 'cb_neuaufbau': ret = ['cb_3Dmodel_neu'] elif key == 'cb_aus_halbzeug_neu': ret = ['cb_halbzeugoberflaeche', 'cb_halbzeugfarbe', 'cb_werkstoffdiskrepanz', 'cb_werkstofftyp_neu', 'cb_material_neu', 'cb_oberflaeche_neu', 'cb_farbe_neu', 'cb_halbzeugnummer', 'cb_halbzeuglaenge', 'cb_3Dmodel_neu', 'cb_zusatzinfos_auto_text'] elif key == 'cb_halbzeugoberflaeche': ret = ['cb_halbzeugfarbe'] elif key == 'cb_halbzeugfarbe': ret = [] elif key == 'cb_lebenszyklus_status_neu': ret = [] elif key == 'cb_3Dmodel_neu': ret = [] elif key == 'cb_halbzeugOhneSaege_neu': ret = [] elif key == 'cb_ruestcode_neu': ret = [ 'cb_halbzeugOhneSaege_neu', 'cb_mengeneinheit_neu', 'cb_halbzeug_neu', 'cb_zusatzinfos_auto_text'] elif key == 'cb_fertigungsart_neu': ret = ['cb_allgemeintoleranz_neu'] elif key == 'cb_allgemeintoleranz_neu': ret = [] elif key == 'cb_fosGruppe_neu': ret = [] elif key == 'cb_kalkulationsart_neu': ret = [] elif key == 'cb_beschaffungsart_neu': ret = [] elif key == 'cb_mengeneinheit_neu': ret = [] elif key == 'cb_halbzeug_neu': ret = [] elif key == 'cb_dispogruppe_neu': ret = [] elif key == 'cb_dispolaufgruppe_neu': ret = [] elif key == 'cb_hersteller_neu': ret = [] elif key == 'cb_werkstoffdiskrepanz': ret = ['cb_zusatzinfos_auto_text'] elif key == 'cb_werkstofftyp_neu': ret = ['cb_material_neu'] elif key == 'cb_material_neu': ret = ['cb_oberflaeche_neu'] elif key == 'cb_oberflaeche_neu': ret = ['cb_farbe_neu'] elif key == 'cb_farbe_neu': ret = [] # Aktionen der Knöpfe werden vom Controller verarbeitet elif key == 'cb_speichern': ret = [] elif key == 'cb_migrieren': ret = [] elif key == 'cb_zurücksetzen': ret = [] elif key == 'cb_suche_asm': ret = [] elif key == 'cb_ladelokal_asm': ret = [] elif key == 'cb_3dsuchen': ret = [] elif key == 'cb_freigabevermerk': ret = [] elif key == 'cb_zusatzinfos_auto_text': ret = [] else: raise Exception("this callback does not exist "+key) return ret def cb_datenbank_neu(self, selected): ret = dict() if selected is None: ret['datenbank'] = "Produktiv" # Default else: ret['datenbank'] = selected return ret def cb_pdm_kategorie_neu(self, selected): """setzt die Dropdownliste mit , 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, selected): ret = dict() pdm_kat = self._model.get_gui_data("pdm_kategorie_neu") if pdm_kat == "Einzelteil": self.set_state('neuaufbau', 'readonly') else: self.set_state('neuaufbau', 'disabled') if selected is None: # Default Vorbelegung if pdm_kat != "Einzelteil" and pdm_kat != "Kaufteil": ret['neuaufbau'] = False else: ret['neuaufbau'] = selected return ret def cb_aus_halbzeug_neu(self, trueOrfalse): ret = dict() pdm_kat = self._model.get_gui_data("pdm_kategorie_neu") # normalerweise ist der Haken nicht gesetzt ret["aus_halbzeug_neu"] = False if pdm_kat == "Einzelteil": # nur beim Einzelteil darf der Nutzer überhaupt anwählen ob ein Halbzeug enthalten ist oder nicht if not trueOrfalse is None: ret["aus_halbzeug_neu"] = trueOrfalse self.set_state('aus_halbzeug_neu', 'readonly') else: self.set_state('aus_halbzeug_neu', 'disabled') return ret def cb_halbzeugnummer(self, selected): # Abfrage zur Feld "Halbzeugnummer". Dieses ist nicht gesteuert durch eine eigene Combobox o.ä. ret = dict() aus_halbzeug = self._model.get_gui_data("aus_halbzeug_neu") ret["halbzeugnummer_neu"] = '' if aus_halbzeug == True: self.set_state('halbzeugnummer_neu', 'normal') # wenn Kind der aktuellen Teilenummer in RD_Teilenummern.csv ist, dann anzeigen current_id = self._model.get_current_item_id() child_id = self._model.get_child_of_id(current_id) if child_id is not None: Teilenummern = self._config.get_ruledesigner_ids() if child_id in Teilenummern: ret["halbzeugnummer_neu"] = child_id else: env = self._model._controller._environment rd_ids_filepath = os.path.join(env.data_dir, env.ruledesigner_csv_filename) self._model.message_info('Fehlendes Halbzeug', 'halbzeug_not_in_RDids', {'halbzeug_id': child_id, 'rdids_path': rd_ids_filepath}) else: self.set_state('halbzeugnummer_neu', 'disabled') return ret def cb_halbzeuglaenge(self, selected): # Abfrage zur Feld "Halbzeuglänge". Dieses ist nicht gesteuert durch eine eigene Combobox o.ä. ret = dict() aus_halbzeug = self._model.get_gui_data("aus_halbzeug_neu") ret["halbzeuglaenge_neu"] = '' if aus_halbzeug == True: self.set_state('halbzeuglaenge_neu', 'normal') # wenn Kind der aktuellen Teilenummer in RD_Teilenummern.csv ist, dann anzeigen current_id = self._model.get_current_item_id() child_id = self._model.get_child_of_id(current_id) if child_id is not None: Teilenummern = self._config.get_ruledesigner_ids() if child_id in Teilenummern: laenge = self._model.get_halbzeug_laenge_of_asm_id(child_id) ret["halbzeuglaenge_neu"] = laenge else: self.set_state('halbzeuglaenge_neu', 'disabled') 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'] = '' ret['cb_halbzeugoberflaeche'] = oarten else: ret['halbzeugoberflaeche_neu'] = selected self.set_state('cb_halbzeugoberflaeche', 'normal') else: ret = { 'halbzeugoberflaeche_neu': "", 'cb_halbzeugoberflaeche': "", } self.set_state('cb_halbzeugoberflaeche', 'disabled') 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['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 if aus_halbzeug == True: self.set_state('cb_halbzeugfarbe', 'readonly') if halbzeugoberflaeche == "eloxieren": farben_elox = self._config.Farben.get_farben_eloxieren() if selected is None: ret['halbzeugfarbe_neu'] = '' # 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'] = '' ret['cb_halbzeugfarbe'] = farbauswahl else: ret['halbzeugfarbe_neu'] = selected else: ret = { 'halbzeugfarbe_neu': '', 'cb_halbzeugfarbe': '', } self.set_state('cb_halbzeugfarbe', 'disabled') else: ret = { 'halbzeugfarbe_neu': '', 'cb_halbzeugfarbe': '', } self.set_state('cb_halbzeugfarbe', 'disabled') return ret def cb_3Dmodel_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") pfad = self._config.Pfade.get('3D-Modelle', 'BaugruppeSchweissbaugruppe') pfad = '' if pdm_kategorie_neu == "Baugruppe" or pdm_kategorie_neu == "Schweissbaugruppe": pfad = self._config.Pfade.get('3D-Modelle', 'BaugruppeSchweissbaugruppe') ret['cb_3Dmodel_neu'] = [pfad] # Dropdownwerte = keine # state_ComboBox = disabled # state_Button = disabled self.set_state('cb_3Dmodel_neu', 'disabled') self.set_state('cb_3dsuchen', 'disabled') elif pdm_kategorie_neu == "Kaufteil": pfad = self._config.Pfade.get('3D-Modelle', 'Kaufteil') ret['cb_3Dmodel_neu'] = [pfad] # Dropdownwerte = keine # state_ComboBox = disabled # state_Button = disabled self.set_state('cb_3Dmodel_neu', 'disabled') self.set_state('cb_3dsuchen', 'disabled') 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: pfad = self._config.Pfade.get('3D-Modelle', 'Einzelteil') ret['cb_3Dmodel_neu'] = [pfad] # Dropdownwerte = keine # state_ComboBox = disabled # state_Button = disabled self.set_state('cb_3Dmodel_neu', 'disabled') self.set_state('cb_3dsuchen', 'disabled') else: search_path = self._config.Pfade.get('3D-Modelle', 'EinzelteilDefault') itemid = str(self._model.get_current_item_id()) pfade = [] for root, dirnames, filenames in os.walk(search_path): pfade.extend(glob.glob(os.path.join(root, itemid+".par"))) for root, dirnames, filenames in os.walk(search_path): pfade.extend(glob.glob(os.path.join(root, itemid+".asm"))) # 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. self.set_state('cb_3Dmodel_neu', 'readonly') self.set_state('cb_3dsuchen', 'normal') # state_ComboBox = readonly # state_Button = keiner ret['cb_3Dmodel_neu'] = pfade if len(pfade) == 0: pfad ="" else: pfad = pfade[0] if selected is None: ret['model3d_neu'] = pfad else: ret['model3d_neu'] = selected return ret def cb_halbzeugOhneSaege_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") ruestcode = self._model.get_gui_data("ruestcode_sivas") cblist = [] if pdm_kategorie_neu == "Baugruppe": # Dropdownwerte = None (keine Werte) self.set_state('cb_halbzeugOhneSaege_neu', 'disabled') else: if ruestcode == "HZS Halbzeuge Sägeteile": cblist = self._config.Allgemein.get_options("HalbzeugOhneSaegeliste") self.set_state('cb_halbzeugOhneSaege_neu', 'disabled') self.set_state('cb_halbzeugOhneSaege_neu', 'readonly') ret['cb_halbzeugOhneSaege_neu'] = cblist if selected is None: default = '' if len(cblist) > 0: default = cblist[0] ret['halbzeugOhneSaege_neu'] = default else: ret['halbzeugOhneSaege_neu'] = selected return ret def cb_ruestcode_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") ruestcode_sivas = self._model.get_gui_data("ruestcode_sivas") truemmer = self._model.get_gui_data("truemmer") if pdm_kategorie_neu == "Baugruppe": lrstcodes = self._config.Allgemein.get_options("RuestcodeBaugruppe") else: lrstcodes = self._config.Allgemein.get_options("RuestcodeStandard") ret['cb_ruestcode_neu'] = lrstcodes ret['ruestcode_neu'] = '' if selected is None: # Default Vorbelegung if ruestcode_sivas is None or truemmer == "J": if pdm_kategorie_neu == "Baugruppe": default = lrstcodes[0] else: self._model.message_info('Rüstcodeinformationen', 'rüstcode_infos') default = '' else: default = '' ret['ruestcode_neu'] = default else: ret['ruestcode_neu'] = selected return ret def cb_fertigungsart_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") # status setzen if pdm_kategorie_neu == "Kaufteil" or pdm_kategorie_neu == "Schweissbaugruppe": self.set_state('cb_fertigungsart_neu', 'disabled') else: self.set_state('cb_fertigungsart_neu', 'readonly') # Werte der Combobox setzen if pdm_kategorie_neu == "Baugruppe": cblist = self._config.Fertigung.get_list_in_section("FertigungsartenBaugruppe") cblist.insert(0, '') ret['cb_fertigungsart_neu'] = cblist elif pdm_kategorie_neu == "Einzelteil": cblist = self._config.Fertigung.get_list_in_section("Fertigungsarten") cblist.insert(0, '') ret['cb_fertigungsart_neu'] = cblist else: ret['cb_fertigungsart_neu'] = '' # default setzen if selected is None: ret['fertigungsart_neu'] = '' fertigung_sivas = self._model.get_gui_data("fertigungsart_sivas") if pdm_kategorie_neu == "Schweissbaugruppe": if fertigung_sivas == "": ret['fertigungsart_neu'] = 'SW - schweißen' elif fertigung_sivas != "schweißen": ret['fertigungsart_neu'] = 'SW - schweißen' else: ret['fertigungsart_neu'] = selected return ret def cb_allgemeintoleranz_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") fertigungsart = self._model.get_gui_data("fertigungsart_neu") ret['allgemeintoleranz_neu'] = '' if pdm_kategorie_neu == "Baugruppe": cblist = self._config.Fertigung.get_list_in_section("AllgemeintoleranzBaugruppe") elif pdm_kategorie_neu == "Kaufteil" or pdm_kategorie_neu == "Schweissbaugruppe": cblist = None if pdm_kategorie_neu == "Einzelteil": if fertigungsart == "3D - 3D-drucken": section = "Allgemeintoleranz3DDruck" elif fertigungsart == "3D - 3D drucken": section = "Allgemeintoleranz3DDruck" elif fertigungsart == "BI - biegen": section = "AllgemeintoleranzBiegen" elif fertigungsart == "DR - drehen": section = "AllgemeintoleranzSpanen" elif fertigungsart == "EX - extrudieren": section = "AllgemeintoleranzExtrudieren" elif fertigungsart == "FR - fräsen": section = "AllgemeintoleranzSpanen" elif fertigungsart == "GI - gießen": section = "AllgemeintoleranzGiessen" elif fertigungsart == "LW - laser- und wasserstrahlschneiden": section = "AllgemeintoleranzSpanen" elif fertigungsart == "PR - verpressen": section = "AllgemeintoleranzVerpressen" elif fertigungsart == "SA - sägen": section = "AllgemeintoleranzSpanen" elif fertigungsart == "SN - strangpressen": section = "AllgemeintoleranzStrangpressen" elif fertigungsart == "SP - spritzgießen": section = "AllgemeintoleranzSpritzgiessen" elif fertigungsart == "ST - stanzen": section = "AllgemeintoleranzStanzen" elif fertigungsart == "SW - schweißen": section = "AllgemeintoleranzSchweissen" elif fertigungsart == "": section = None else: raise Exception("no such fertigungsart "+ fertigungsart) if section: cblist = self._config.Fertigung.get_list_in_section(section) else: cblist = None else: cblist = None ret['cb_allgemeintoleranz_neu'] = cblist if selected is None: # Default Vorbelegung if pdm_kategorie_neu == "Kaufteil": default = '' elif pdm_kategorie_neu == "Baugruppe": default = "ISO 2768:1991-mK" elif pdm_kategorie_neu == "Schweissbaugruppe": default = "EN ISO 13920-BF" else: if fertigungsart == "3D - 3D-drucken": default = "ISO 2768:1991-mK" elif fertigungsart == "3D - 3D drucken": default = "ISO 2768:1991-mK" elif fertigungsart == "BI - biegen": default = "ISO 2768:1991-mK" elif fertigungsart == "DR - drehen": default = "ISO 2768:1991-mK" elif fertigungsart == "EX - extrudieren": default = "DIN 16941 - 3A" elif fertigungsart == "FR - fräsen": default = "ISO 2768:1991-mK" elif fertigungsart == "GI - gießen": default = "ISO 8062-3 - DCTG 10" elif fertigungsart == "LW - laser- und wasserstrahlschneiden": default = "ISO 2768:1991-mK" elif fertigungsart == "PR - verpressen": default = "ISO 2768:1991-mK" elif fertigungsart == "SA - sägen": default = "ISO 2768:1991-mK" elif fertigungsart == "SN - strangpressen": default = "EN 12020-2" elif fertigungsart == "SP - spritzgießen": default = "DIN ISO 20457-TG5" elif fertigungsart == "ST - stanzen": default = "DIN 6930-2 - m" elif fertigungsart == "SW - schweißen": # TODO default = "" elif fertigungsart == "": default = "" else: raise Exception("no such fertigungsart "+ fertigungsart) ret['allgemeintoleranz_neu'] = default else: ret['allgemeintoleranz_neu'] = selected if pdm_kategorie_neu == "Kaufteil" or pdm_kategorie_neu == "Schweissbaugruppe": self.set_state('cb_allgemeintoleranz_neu', 'disabled') else: self.set_state('cb_allgemeintoleranz_neu', 'readonly') return ret def cb_fosGruppe_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") fos_gruppe_sivas = self._model.get_gui_data("fosGruppe_sivas") ret['fosGruppe_neu'] = '' self.set_state('cb_fosGruppe_neu', 'disabled') if pdm_kategorie_neu == "Kaufteil": cblist = self._config.Allgemein.get_options("FOS_Gruppe") self.set_state('cb_fosGruppe_neu', 'readonly') elif pdm_kategorie_neu == "Baugruppe": cblist = ['1 - Baugruppe'] elif pdm_kategorie_neu == "Einzelteil" or pdm_kategorie_neu == "Schweissbaugruppe": cblist = ['0 - Einzelteil'] else: cblist = None ret['cb_fosGruppe_neu'] = cblist if selected is None: # Default Vorbelegung default = '' if fos_gruppe_sivas == None or fos_gruppe_sivas == '': if pdm_kategorie_neu == "Baugruppe": default = "1 - Baugruppe" elif pdm_kategorie_neu == "Einzelteil" or pdm_kategorie_neu == "Schweissbaugruppe": default = "0 - Einzelteil" elif pdm_kategorie_neu == "Kaufteil": default = cblist[0] elif fos_gruppe_sivas == "0 - Einzelteil": if pdm_kategorie_neu == "Baugruppe": default = "1 - Baugruppe" elif fos_gruppe_sivas == "1 - Baugruppe": if pdm_kategorie_neu == "Einzelteil" or pdm_kategorie_neu == "Schweissbaugruppe": default = "0 - Einzelteil" ret['fosGruppe_neu'] = default else: ret['fosGruppe_neu'] = selected # if selected is None: # # Default Vorbelegung # default = '' # if pdm_kategorie_neu == "Baugruppe": # if fos_gruppe == "0 - Einzelteil" or fos_gruppe == None: # default = "1 - Baugruppe" # else: # if fos_gruppe == "1 - Baugruppe" or fos_gruppe == None: # default = "0 - Einzelteil" # ret['fosGruppe_neu'] = default # else: # ret['fosGruppe_neu'] = selected return ret def cb_kalkulationsart_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") calc_art = self._model.get_gui_data("kalkulationsart_sivas") ret['cb_kalkulationsart_neu'] = '' if pdm_kategorie_neu == "Baugruppe": cblist = self._config.Allgemein.get_options("Kalkulationsart") self.set_state('cb_kalkulationsart_neu', 'readonly') else: cblist = None self.set_state('cb_kalkulationsart_neu', 'disabled') ret['cb_kalkulationsart_neu'] = cblist ret['kalkulationsart_neu'] = '' if selected is None: # Default Vorbelegung default = '' if pdm_kategorie_neu == "Kaufteil": if calc_art == "Eigenbau" or calc_art == "" or calc_art == None: default = "Kaufteil" else: if calc_art == "Kaufteil" or calc_art == "" or calc_art == None: default = "Eigenbau" ret['kalkulationsart_neu'] = default else: ret['kalkulationsart_neu'] = selected return ret def cb_beschaffungsart_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") bart = self._model.get_gui_data("beschaffungsart_sivas") if pdm_kategorie_neu == "Einzelteil": cblist = self._config.Allgemein.get_options("Beschaffungsart") self.set_state('cb_beschaffungsart_neu', 'readonly') else: cblist = None self.set_state('cb_beschaffungsart_neu', 'disabled') ret['cb_beschaffungsart_neu'] = cblist ret['beschaffungsart_neu'] = '' if selected is None: # Default Vorbelegung default = '' if bart == "Eigenbau": if pdm_kategorie_neu == "Kaufteil": default = "Kaufteil" else: default = "" elif bart == "Kaufteil": if pdm_kategorie_neu == "Baugruppe": default = "Eigenbau" elif pdm_kategorie_neu == "Einzelteil" or pdm_kategorie_neu == "Kaufteil": default = "" elif pdm_kategorie_neu == "Schweissbaugruppe": default = "Eigenbau" self._model.message_info('Beschaffungsart', 'beschaffungsart_infos') ret['beschaffungsart_neu'] = default else: ret['beschaffungsart_neu'] = selected return ret def cb_mengeneinheit_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") rcode_sivas = self._model.get_gui_data("ruestcode_sivas") rcode_neu = self._model.get_gui_data("ruestcode_neu") # TODO oder ruestcode_neu? mengeneinheit_sivas = self._model.get_gui_data("mengeneinheit_sivas") cblist = None if rcode_sivas == "SRC - Standard Rüstcode" or rcode_neu == "Trümmerbaugruppe": self.set_state('cb_mengeneinheit_neu', 'disabled') elif rcode_sivas == "HZS - Halbzeuge Sägeteile": if pdm_kategorie_neu == "Einzelteil" or pdm_kategorie_neu == "Kaufteil": cblist = self._config.Allgemein.get_options("EinheitAusw") self.set_state('cb_mengeneinheit_neu', 'readonly') else: self.set_state('cb_mengeneinheit_neu', 'disabled') ret['cb_mengeneinheit_neu'] = cblist if selected is None: # Default Vorbelegung default = '' if rcode_sivas == "SRC - Standard Rüstcode" or rcode_neu == "SRC Standard Rüstcode": if mengeneinheit_sivas != "Stck - Stück": default = "Stck - Stück" else: default = "" elif rcode_sivas == "HZS - Halbzeuge Sägeteile" or rcode_neu == "HZS Halbzeuge Sägeteile": if mengeneinheit_sivas != "M - Meter": if pdm_kategorie_neu == "Schweissbaugruppe": default = "M - Meter" elif pdm_kategorie_neu == "Einzelteil" or pdm_kategorie_neu == "Kaufteil": default = "M - Meter" self._model.message_info('Mengeneinheit', 'mengeneinheit_infos') ret['mengeneinheit_neu'] = default else: ret['mengeneinheit_neu'] = selected return ret def cb_halbzeug_neu(self, selected): ret = dict() rcode_sivas = self._model.get_gui_data("ruestcode_sivas") rcode_neu = self._model.get_gui_data("ruestcode_neu") halbzeug_sivas = self._model.get_gui_data("halbzeug_sivas") cblist = '' if rcode_sivas == "SRC - Standard Rüstcode" or rcode_neu == "SRC Standard Rüstcode" or rcode_neu == "Trümmerbaugruppe": cblist = "FALSCH" self.set_state('cb_halbzeug_neu', 'disabled') elif rcode_sivas == "HZS - Halbzeuge Sägeteile": cblist = self._config.Allgemein.get_options("Halbzeug") self.set_state('cb_halbzeug_neu', 'readonly') else: self.set_state('cb_halbzeug_neu', 'disabled') ret['cb_halbzeug_neu'] = cblist if selected is None: # Default Vorbelegung default = '' if halbzeug_sivas == "WAHR": if rcode_sivas == "SRC - Standard Rüstcode" or rcode_neu == "SRC Standard Rüstcode" or rcode_neu == "Trümmerbaugruppe": default = "FALSCH" # elif rcode == "HZS - Halbzeuge Sägeteile": # default = "" ret['halbzeug_neu'] = default else: ret['halbzeug_neu'] = selected return ret def cb_dispogruppe_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") cblist = self._config.Allgemein.get_options("Dispogruppe") ret['cb_dispogruppe_neu'] = cblist if selected is None: # Default Vorbelegung ret['dispogruppe_neu'] = '' else: ret['dispogruppe_neu'] = selected return ret def cb_dispolaufgruppe_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") cblist = self._config.Allgemein.get_options("Dispolaufgruppe") ret['cb_dispolaufgruppe_neu'] = cblist if selected is None: # Default Vorbelegung ret['dispolaufgruppe_neu'] = '' else: ret['dispolaufgruppe_neu'] = selected return ret def cb_hersteller_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") cblist = self._config.Hersteller.get_all() ret['cb_hersteller_neu'] = cblist if pdm_kategorie_neu == "Kaufteil": self.set_state('cb_hersteller_neu', 'readonly') else: self.set_state('cb_hersteller_neu', 'disabled') if selected is None: # Default Vorbelegung ret['hersteller_neu'] = "" else: ret['hersteller_neu'] = selected return ret def cb_herstteilenr_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") if pdm_kategorie_neu == "Kaufteil": self.set_state('herstteilenr_neu', 'normal') else: self.set_state('herstteilenr_neu', 'disabled') return ret def cb_werkstoffdiskrepanz(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") aus_halbzeug = self._model.get_gui_data("aus_halbzeug_neu") if pdm_kategorie_neu == "Einzelteil": if aus_halbzeug == True: ret['cb_werkstoffdiskrepanz'] = True self.set_state('werkstoffdiskr_neu', 'disabled') else: self.set_state('werkstoffdiskr_neu', 'normal') else: self.set_state('werkstoffdiskr_neu', 'disabled') return ret def cb_werkstofftyp_neu(self, selected): """bekommt Aluminium, Stahl etc. und setzt dann die anderen Felder der Oberfläche""" ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") aus_halbzeug = self._model.get_gui_data("aus_halbzeug_neu") material_sivas = self._model.get_gui_data("material_sivas") # Combobox: if pdm_kategorie_neu == "Einzelteil": if aus_halbzeug == True: cblist = None self.set_state('cb_werkstofftyp_neu', 'disabled') else: cblist = self._config.Werkstoffe.get_werkstoff_namen() self.set_state('cb_werkstofftyp_neu', 'readonly') else: cblist = None self.set_state('cb_werkstofftyp_neu', 'disabled') ret['cb_werkstofftyp_neu'] = cblist # Logik, die steuert, welcher Defaultwert gilt: if selected is None: # Default Vorbelegung default = '' if pdm_kategorie_neu != "Einzelteil": pass elif pdm_kategorie_neu == "Einzelteil" and aus_halbzeug == True: pass elif material_sivas == "": pass elif pdm_kategorie_neu == "Einzelteil" and aus_halbzeug == False: mlist = self._config.Materialien.get_all_materials() if material_sivas in mlist: mat = self._config.Materialien.get_material_of_type(material_sivas) if 'Werkstofftyp' in mat: default = mat['Werkstofftyp'] else: default = mat['Message'] else: # TODO beim migrieren die Meldung bringen self._model.message_info('Materialinformation', 'material_infos') pass else: pass ret['werkstofftyp_neu'] = default else: ret['werkstofftyp_neu'] = selected return ret def cb_material_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") aus_halbzeug = self._model.get_gui_data("aus_halbzeug_neu") material_sivas = self._model.get_gui_data("material_sivas") werkstoff_typ = self._model.get_gui_data("werkstofftyp_neu") # dropdown if werkstoff_typ == "Stahl": cblist = self._config.Werkstoffe.get_werkstoffe_of_name("Stahl") elif werkstoff_typ == "Aluminium": cblist = self._config.Werkstoffe.get_werkstoffe_of_name("Aluminium") elif werkstoff_typ == "Kunst-/ Verbundstoff": cblist = self._config.Werkstoffe.get_werkstoffe_of_name("Kunst-/ Verbundstoff") elif werkstoff_typ == "Schwermetall": cblist = self._config.Werkstoffe.get_werkstoffe_of_name("Schwermetall") else: cblist = '' ret['cb_material_neu'] = cblist if pdm_kategorie_neu == "Einzelteil": if aus_halbzeug == True: self.set_state('cb_material_neu', 'disabled') else: self.set_state('cb_material_neu', 'readonly') else: self.set_state('cb_material_neu', 'disabled') if selected is None: # Default Vorbelegung default = '' if pdm_kategorie_neu == "Baugruppe": pass elif pdm_kategorie_neu == "Schweissbaugruppe": pass elif pdm_kategorie_neu == "Einzelteil" and aus_halbzeug == True: pass elif material_sivas == "": pass elif pdm_kategorie_neu == "Kaufteil": default = "siehe Hersteller" elif pdm_kategorie_neu == "Einzelteil" and aus_halbzeug == False: mlist = self._config.Materialien.get_all_materials() if material_sivas in mlist: mat = self._config.Materialien.get_material_of_type(material_sivas) if 'Werkstofftyp' in mat: default = mat['Werkstoff'] else: default = mat['Message'] # TODO Prüfung ob Message vorhanden ret['material_neu'] = default else: ret['material_neu'] = selected return ret def cb_oberflaeche_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") aus_halbzeug = self._model.get_gui_data("aus_halbzeug_neu") werkstoff_typ = self._model.get_gui_data("werkstofftyp_neu") material_sivas = self._model.get_gui_data("material_sivas") # pflicht = False # if pdm_kategorie_neu == "Einzelteil": # if werkstoff_typ == "Kunst-/ Verbundstoff": # pflicht = True # else: # pass if pdm_kategorie_neu == "Einzelteil": if werkstoff_typ == "Stahl": cblist = self._config.Oberfläche.get_oberfläche_of_type("Stahl") elif werkstoff_typ == "Aluminium": cblist = self._config.Oberfläche.get_oberfläche_of_type("Aluminium") elif werkstoff_typ == "Kunst-/ Verbundstoff": cblist = self._config.Oberfläche.get_oberfläche_of_type("Kunst-/ Verbundstoff") elif werkstoff_typ == "Schwermetall": cblist = self._config.Oberfläche.get_oberfläche_of_type("Schwermetall") elif werkstoff_typ == "Festigkeitsklasse": cblist = self._config.Oberfläche.get_oberfläche_of_type("Normteil") else: cblist = '' elif pdm_kategorie_neu == "Schweissbaugruppe": cblist = self._config.Oberfläche.get_oberfläche_of_type("Schweissbaugruppe") else: cblist = '' ret['cb_oberflaeche_neu'] = cblist if pdm_kategorie_neu == "Einzelteil": if aus_halbzeug == True: self.set_state('cb_oberflaeche_neu', 'disabled') else: self.set_state('cb_oberflaeche_neu', 'readonly') elif pdm_kategorie_neu == "Schweissbaugruppe": self.set_state('cb_oberflaeche_neu', 'readonly') else: self.set_state('cb_oberflaeche_neu', 'disabled') ret['oberflaeche_neu'] = '' if selected is None: # Default Vorbelegung default = '' if pdm_kategorie_neu == 'Einzelteil' and aus_halbzeug is False: mlist = self._config.Materialien.get_all_materials() if material_sivas in mlist: mat = self._config.Materialien.get_material_of_type(material_sivas) if 'Werkstofftyp' in mat and 'Oberfläche' in mat: default = mat['Oberfläche'] else: default = '' ret['oberflaeche_neu'] = default else: ret['oberflaeche_neu'] = selected return ret def cb_farbe_neu(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") aus_halbzeug = self._model.get_gui_data("aus_halbzeug_neu") material_sivas = self._model.get_gui_data("material_sivas") oberflaeche_neu = self._model.get_gui_data("oberflaeche_neu") # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell ret['cb_farbe_neu'] = '' if oberflaeche_neu == "eloxieren": cblist = self._config.Farben.get_farben_eloxieren() elif oberflaeche_neu == "lackieren": cblist = self._config.Farben.get_farbauswahl() elif oberflaeche_neu == "Masterbatch (Grundfarbe)": cblist = self._config.Farben.get_farbauswahl() elif oberflaeche_neu == "pulverbeschichten": cblist = self._config.Farben.get_farbauswahl() else: cblist = '' ret['cb_farbe_neu'] = cblist if oberflaeche_neu == "eloxieren" or \ oberflaeche_neu == "lackieren" or \ oberflaeche_neu == "Masterbatch (Grundfarbe)" or \ oberflaeche_neu == "pulverbeschichten": self.set_state('cb_farbe_neu', 'readonly') else: self.set_state('cb_farbe_neu', 'disabled') if selected is None: # Default Vorbelegung default = '' if pdm_kategorie_neu != "Einzelteil": pass elif pdm_kategorie_neu == "Einzelteil" and aus_halbzeug == True: self.set_state('cb_farbe_neu', 'disabled') elif material_sivas == "": pass elif pdm_kategorie_neu == "Einzelteil" and aus_halbzeug == False: mlist = self._config.Materialien.get_all_materials() if material_sivas in mlist: mat = self._config.Materialien.get_material_of_type(material_sivas) if 'Werkstofftyp' in mat and 'Farbe' in mat: default = mat['Farbe'] else: default = '' ret['farbe_neu'] = default else: ret['farbe_neu'] = selected return ret def cb_freigabevermerk(self, selected): ret = dict() pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu") version_sivas = str(self._model.get_gui_data("version_sivas")) freigabe_sivas = self._model.get_gui_data("freigabevermerk_sivas") freigabe_neu = self._model.get_gui_data("freigabevermerk_neu") # Brauchen wir für den Fall, dass der SIVAS-Freigabevermerk beim Einlesen bereits transformiert wurden, da er ein Semikolon enthielt. if selected is None: # Default Vorbelegung default = '' if freigabe_sivas is None: if pdm_kategorie_neu == "Kaufteil": pass else: if re.findall(r'(\d{6})', version_sivas): default = 'Anpassung an neues Indexsystem, Zeichnung mit Versionsnummer {version} weiterhin gültig'.format(version=version_sivas) else: default = '-' else: if freigabe_neu is not None: default = freigabe_neu ret['freigabevermerk_neu'] = default else: ret['freigabevermerk_neu'] = selected return ret def cb_zusatzinfos_auto_text(self, selected): ret = dict() aenderungsindex_sivas = self._model.get_gui_data("aenderungsindex_sivas") truemmer = self._model.get_gui_data("truemmer") ruestcode = self._model.get_gui_data("ruestcode_sivas") werkstoffdiskr_neu = self._model.get_gui_data("werkstoffdiskr_neu") aus_halbzeug = self._model.get_gui_data("aus_halbzeug_neu") # Ermittlung, ob sich in der Stückliste der ausgewählten Teilenummer Beistellungsteile oder nicht-dispoaktive Teile befinden beistellungen = False dispoinaktiv = False if self._model.has_bom(): all_beistellungen = self._model.get_bom_properties("Lieferantenbeistellung") all_dispoaktiv = self._model.get_bom_properties("Dispoaktiv") active_id = self._model.get_current_item_id() children_of_active_id = self._model.get_all_children_of_id(active_id) for child in children_of_active_id: if all_beistellungen[child] == "True": beistellungen = True if all_dispoaktiv[child] == "False": dispoinaktiv = True # Liest Optionsnamen aus 'Zusatzinformationen.cfg' cfg_single_options = dict.fromkeys(self._config.Zusatz.get_section_options("EinzelTextblöcke"), "EinzelTextblöcke") cfg_combo_options = dict.fromkeys(self._config.Zusatz.get_section_options("ComboTextblöcke"), "ComboTextblöcke") all_cfg_options = cfg_single_options | cfg_combo_options if selected is None: text = '' try: self._config.get_blacklist() except: self._model.message_error('Blacklist nicht vorhanden', 'blacklist_not_exist') return {} # Prüft, ob einer der nachfolgenden Fälle auf die Teilenummer zutrifft, die im Moment migriert wird matches = [] if aenderungsindex_sivas and aenderungsindex_sivas.islower(): matches.append("Kleinbuchstabe") if truemmer == 'J' or ruestcode is None: matches.append("Truemmer") if werkstoffdiskr_neu: matches.append("Werkstoffdiskrepanz") if dispoinaktiv: matches.append("Dispoinaktiv") if beistellungen: if aus_halbzeug: matches.append("BlacklistHZ") else: matches.append("BlacklistBG") # Sucht sich die zutreffende Option aus der "Zusatzinformationen.cfg", die mit den gefundenen Fällen übereinstimmen # heraus und gibt den Optionstext zurück. Bei fehlender Übereinstimmung wird kein Text geschrieben if len(matches) > 0: match_len = len("".join(matches)) for option in all_cfg_options: if all(match in option for match in matches) and len(option) == match_len: text = self._config.Zusatz.get(all_cfg_options[option], option) break ret['zusatzinfos_auto_text'] = text else: ret['zusatzinfos_auto_text'] = selected return ret if __name__ == "__main__": pass