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", "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_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_sivas", "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._data = {} self._gui_data = {} self._gui_states = {} self._read_only_items = {} self._controller = None self._logic = 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 # 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"] translated_data["bezeichnung1_neu"] = re.sub(r"\s+kpl[.|\s]", "", text, flags=re.I) # 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 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 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}) 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 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_improper_chars(self, invalid_chars): """ überprüft ob inder Oberfläche nicht erlaubte Zeichen eingetragen wurden""" wrongchars = dict() for key in self.key2label: if key == "model3d_neu": # 3D Teil Pfad ausnehmen continue 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""" content = self.get_content('bezeichnung1_sivas', 'bezeichnung1_neu') if len(content) > 50: self.message_error('Bezeichnung1 zu gross', 'bezeichnung_zu_gross') 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 content = self.get_content('ruestcode_sivas', 'ruestcode_neu') pdm_kategorie_neu = self.get_gui_data("pdm_kategorie_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_sivas') if 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':'', 'Oberflaechenbehandlung':'', 'RuestcodeAusw':'', 'Serien-Status':'', 'StartRevision':'', 'Teilenummer':'', 'WerkstoffNE':'', 'WerkstofftypNE':'', 'ZusaetzlicheInformationen':'', '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 # Bezeichnung um "- BG" ergänzen if pdm_kategorie_neu == "Baugruppe" or pdm_kategorie_neu == "Schweissbaugruppe": title = bezeichnung1 + " - BG" data["Title"] = title aus_halbzeug = self.get_gui_data("aus_halbzeug_neu") if aus_halbzeug: data["HalbzeugInternAngabe"] = "Ja" # 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 halbzeuglaenge: data["HalbzeugOhneSaegeliste"] = trans_halbzeugOhneSaege[halbzeugOhneSaege] ruestcode = self.get_content('ruestcode_sivas', 'ruestcode_neu') trans_ruestcode = { "HZS - Halbzeuge Sägeteile": "HZS Halbzeuge Sägeteile", "SRC - Standard Rüstcode": "SRC Standard Rüstcode" } 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 # 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_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_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'] 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_halbzeugnummer', 'cb_halbzeuglaenge' ] 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_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 # Entry-Abhängigkeit der Bezeichnung 1. keine eigene Callback. Abhängig von der Kategorie pdm_kat = ret["pdm_kategorie_neu"] if pdm_kat == "Baugruppe" or pdm_kat == "Schweissbaugruppe": maxlen = 45 # Längenbeschränkung = 45 Zeichen else: maxlen = 50 # Längenbeschränkung = 50 Zeichen text = self._model.get_gui_data("bezeichnung1_sivas") if len(text) > maxlen: ret["bezeichnung1_neu"] = text[0:maxlen] return ret def cb_neuaufbau(self, selected): ret = dict() pdm_kat = self._model.get_gui_data("pdm_kategorie_neu") if pdm_kat != "Einzelteil" and pdm_kat != "Kaufteil": self.set_state('neuaufbau', 'disabled') else: self.set_state('neuaufbau', 'readonly') 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 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: 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('halbzeugoberflaeche_neu', 'normal') else: ret = { 'halbzeugoberflaeche_neu': "", 'cb_halbzeugoberflaeche': "", } self.set_state('halbzeugoberflaeche_neu', '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 == "" 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") ret['cb_fertigungsart_neu'] = cblist elif pdm_kategorie_neu == "Einzelteil": cblist = self._config.Fertigung.get_list_in_section("Fertigungsarten") 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 = "AllgemeintoleranzSpanen" 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 == "Bauteil" or pdm_kategorie_neu == "Kaufteil": default = '' 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 = "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 = 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" or pdm_kategorie_neu == "Schweissbaugruppe": cblist = ['1 - Baugruppe'] elif pdm_kategorie_neu == "Einzelteil": cblist = ['0 - Einzelteil'] else: cblist = None ret['cb_fosGruppe_neu'] = cblist if selected is None: # Default Vorbelegung default = '' if fos_gruppe == None or fos_gruppe == '': if pdm_kategorie_neu == "Baugruppe" or pdm_kategorie_neu == "Schweissbaugruppe": default = "1 - Baugruppe" elif pdm_kategorie_neu == "Einzelteil": default = "0 - Einzelteil" elif pdm_kategorie_neu == "Kaufteil": default = cblist[0] 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 = self._model.get_gui_data("ruestcode_sivas") # TODO oder ruestcode_neu? mengeneinheit = self._model.get_gui_data("mengeneinheit_sivas") cblist = None if rcode == "SRC Standard Rüstcode" or rcode == "Trümmerbaugruppe": self.set_state('cb_mengeneinheit_neu', 'disabled') elif rcode == "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') elif pdm_kategorie_neu == "Schweissbaugruppe": self.set_state('cb_mengeneinheit_neu', 'disabled') else: self.set_state('cb_mengeneinheit_neu', 'disabled') ret['cb_mengeneinheit_neu'] = cblist if selected is None: # Default Vorbelegung default = '' if rcode == "SRC Standard Rüstcode": if mengeneinheit != "Stck - Stück": default = "Stck - Stück" else: default = "" elif rcode == "HZS Halbzeuge Sägeteile": if mengeneinheit != "M - Meter": if pdm_kategorie_neu == "Schweissbaugruppe": default = "M - Meter" elif pdm_kategorie_neu == "Einzelteil" or pdm_kategorie_neu == "Kaufteil": default = "" 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 = self._model.get_gui_data("ruestcode_sivas") halbzeug = self._model.get_gui_data("halbzeug_sivas") cblist = '' if rcode == "SRC Standard Rüstcode" or rcode == "Trümmerbaugruppe": cblist = "FALSCH" elif rcode == "HZS Halbzeuge Sägeteile": cblist = self._config.Allgemein.get_options("Halbzeug") ret['cb_halbzeug_neu'] = cblist if rcode == "SRC Standard Rüstcode" or rcode == "Trümmerbaugruppe": self.set_state('cb_halbzeug_neu', 'disabled') elif rcode == "HZS Halbzeuge Sägeteile": self.set_state('cb_halbzeug_neu', 'readonly') else: self.set_state('cb_halbzeug_neu', 'disabled') if selected is None: # Default Vorbelegung default = '' if halbzeug == "WAHR": if rcode == "SRC Standard Rüstcode" or rcode == "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() aus_halbzeug = self._model.get_gui_data("aus_halbzeug_neu") if aus_halbzeug == True: ret['cb_werkstoffdiskrepanz'] = True self.set_state('cb_werkstoffdiskrepanz', 'disabled') else: self.set_state('cb_werkstoffdiskrepanz', 'normal') 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', 'disbled') 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_neu = self._model.get_gui_data("material_neu") # pflicht = False # if pdm_kategorie_neu == "Einzelteil": # if werkstoff_typ == "Kunst-/ Verbundstoff": # pflicht = True # else: # pass 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 = '' ret['cb_oberflaeche_neu'] = cblist if aus_halbzeug == True: self.set_state('cb_oberflaeche_neu', 'disabled') else: self.set_state('cb_oberflaeche_neu', 'readonly') 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_neu in mlist: mat = self._config.Materialien.get_material_of_type(material_neu) 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: 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 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") 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: pass 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") teilenummer = str(self._model.get_gui_data("teilenummer")) werkstoffdiskr_neu = self._model.get_gui_data("werkstoffdiskr_neu") if selected is None: text = '' try: blacklist = self._config.get_blacklist() except: self._model.message_error('Blacklist nicht vorhanden', 'blacklist_not_exist') return {} if aenderungsindex_sivas.islower(): if truemmer == 'J' or ruestcode == '': text = self._config.Zusatz.get('ComboTextblöcke', 'KleinbuchstabeTruemmer') if teilenummer in blacklist: text = self._config.Zusatz.get('ComboTextblöcke', 'KleinbuchstabeTruemmerBlacklist') elif teilenummer in blacklist: text = self._config.Zusatz.get('ComboTextblöcke', 'KleinbuchstabeBlacklist') elif werkstoffdiskr_neu == True: text = self._config.Zusatz.get('ComboTextblöcke', 'KleinbuchstabeWerkstoffdiskrepanz') else: text = self._config.Zusatz.get('EinzelTextblöcke', 'Kleinbuchstabe') text = text.format(aenderungsindex=aenderungsindex_sivas) elif truemmer == 'J' or ruestcode == '': if teilenummer in blacklist: text = self._config.Zusatz.get('ComboTextblöcke', 'TruemmerBlacklist') elif werkstoffdiskr_neu == True: text = self._config.Zusatz.get('ComboTextblöcke', 'TruemmerWerkstoffdiskrepanz') else: text = self._config.Zusatz.get('EinzelTextblöcke', 'Truemmer') ret['zusatzinfos_auto_text'] = text else: ret['zusatzinfos_auto_text'] = selected return ret if __name__ == "__main__": pass