1625 lines
64 KiB
Python
1625 lines
64 KiB
Python
import json
|
|
import pandas as pd
|
|
import os
|
|
import glob
|
|
import re
|
|
|
|
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", "bezeichnung2_neu",
|
|
"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_sivas",
|
|
"werkstofftyp_sivas", "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"
|
|
}
|
|
|
|
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):
|
|
self._data = {}
|
|
self._gui_data = {}
|
|
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 _transform_content_from_csv(self, translated_data):
|
|
# Spezial: Abkürzungen .kpl rausschmeissen. Text eventuell kürzen
|
|
if "bezeichnung1_sivas" in translated_data:
|
|
text = translated_data["bezeichnung1_sivas"]
|
|
translated_data["bezeichnung1_sivas"] = 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_sivas"] = "Sägeliste benötigt"
|
|
else:
|
|
translated_data["halbzeugOhneSaege_sivas"] = "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
|
|
if "tosgruppe_sivas" in translated_data:
|
|
text = translated_data["tosgruppe_sivas"]
|
|
if text =="":
|
|
translated_data["tosgruppe_neu"] = "6"
|
|
|
|
|
|
# Spezial Freigabevermerk
|
|
if "freigabevermerk_sivas" in translated_data:
|
|
text = translated_data["freigabevermerk_sivas"]
|
|
translated_data["freigabevermerk_sivas"] = re.sub(r";", " /", 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"]
|
|
translated_data["hersteller_sivas"] = re.sub(r"^.*-\s+", "", text, flags=re.I)
|
|
|
|
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
|
|
if "Indexerfasser" in data:
|
|
author = data["Indexerfasser"]
|
|
if "Aenderungstext" in data:
|
|
if author:
|
|
translated_data["aenderungstext_sivas"] = '{aenderungstext} (von {author})'.format(aenderungstext=data["Aenderungstext"], author=author)
|
|
# Indexerfasser wird nicht in der gui verwaltet. Deshalb Modifikation aus den Rohdate
|
|
else:
|
|
translated_data["aenderungstext_sivas"] = data["Aenderungstext"]
|
|
else:
|
|
default = "Erstanlage"
|
|
if author:
|
|
default = 'Erstanlage (von {author})'.format(author=author)
|
|
translated_data["aenderungstext_sivas"] = default
|
|
|
|
translated_data = self._transform_content_from_csv(translated_data)
|
|
self.set_gui_dict(translated_data)
|
|
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=';')
|
|
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, 'r') as f:
|
|
self.from_json(json.load(f))
|
|
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, questions='ok'):
|
|
return self._controller.message_info(title, key, questions)
|
|
|
|
def message_error(self, title, key):
|
|
return self._controller.message_error(title, key)
|
|
|
|
def check(self):
|
|
self.check_pflichtfelder()
|
|
|
|
def check_key_existence(self, key, missing):
|
|
if not self.get_gui_data(key):
|
|
missing.append(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(key_sivas)
|
|
missing.append(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("oberflaeche_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_neu")
|
|
|
|
# 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_existence("fertigungsart_neu", missing)
|
|
|
|
# Allgemeintoleranz
|
|
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 aus_halbzeug is False:
|
|
self.check_key_both_columns("werkstofftyp_sivas", "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)
|
|
# Automatische Zusatzinformationen
|
|
self.check_key_existence("zusatzinfos_auto_text", missing)
|
|
return missing
|
|
|
|
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()
|
|
|
|
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':
|
|
ret = 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)
|
|
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']
|
|
elif key == 'cb_neuaufbau':
|
|
ret = []
|
|
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']
|
|
elif key == 'cb_fertigungsart_neu':
|
|
ret = ['cb_allgemeintoleranz_neu']
|
|
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 = []
|
|
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 = []
|
|
else:
|
|
raise Exception("this callback does not exist "+key)
|
|
return ret
|
|
|
|
def cb_pdm_kategorie_neu(self, selected):
|
|
"""setzt die Dropdownliste mit
|
|
<undefiniert>, Baugruppe, Einzelteil, Kaufteil, Schweissbaugruppe
|
|
"""
|
|
ret = dict()
|
|
categories = self._config.Allgemein.get_options("Kategorien")
|
|
if selected is None:
|
|
ret['pdm_kategorie_neu'] = categories[0]
|
|
ret['cb_pdm_kategorie_neu'] = categories
|
|
else:
|
|
ret['pdm_kategorie_neu'] = selected
|
|
|
|
# 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', 'normal')
|
|
|
|
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')
|
|
|
|
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:
|
|
ret["halbzeuglaenge_neu"] = 'Länge ? des Kindes der id='+ child_id
|
|
else:
|
|
self.set_state('halbzeuglaenge_neu', 'disabled')
|
|
|
|
|
|
def cb_halbzeugoberflaeche(self, selected):
|
|
ret = dict()
|
|
aus_halbzeug = self._model.get_gui_data("aus_halbzeug_neu")
|
|
if aus_halbzeug == True:
|
|
oarten = self._config.Oberfläche.get_oberflächen_behandlungen()
|
|
if selected is None:
|
|
ret['halbzeugoberflaeche_neu'] = oarten[0]
|
|
ret['cb_halbzeugoberflaeche'] = oarten
|
|
else:
|
|
ret['halbzeugoberflaeche_neu'] = selected
|
|
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', 'normal')
|
|
if halbzeugoberflaeche == "eloxieren":
|
|
farben_elox = self._config.Farben.get_farben_eloxieren()
|
|
if selected is None:
|
|
ret['halbzeugfarbe_neu'] = farben_elox[0] # Default, falls nichts gewählt ist
|
|
ret['cb_halbzeugfarbe'] = farben_elox # Liste in der Combobox
|
|
else:
|
|
ret['halbzeugfarbe_neu'] = selected # vom Nutzer ausgewählter Wert
|
|
elif halbzeugoberflaeche == "lackieren" or halbzeugoberflaeche == "pulverbeschichten":
|
|
farbauswahl = self._config.Farben.get_farbauswahl()
|
|
if selected is None:
|
|
ret['halbzeugfarbe_neu'] = farbauswahl[0]
|
|
ret['cb_halbzeugfarbe'] = farbauswahl
|
|
else:
|
|
ret['halbzeugfarbe_neu'] = selected
|
|
else:
|
|
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 ="<no .par/.asm in path found>"
|
|
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', 'normal')
|
|
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")
|
|
fertigungsart_sivas = self._model.get_gui_data("fertigungsart_sivas")
|
|
|
|
if pdm_kategorie_neu == "Kaufteil" or pdm_kategorie_neu == "Schweissbaugruppe":
|
|
self.set_state('cb_fertigungsart_neu', 'disabled')
|
|
else:
|
|
self.set_state('cb_fertigungsart_neu', 'normal')
|
|
|
|
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'] = ''
|
|
|
|
if selected is None:
|
|
# Default Vorbelegung
|
|
default = ''
|
|
if fertigungsart_sivas == '' or fertigungsart_sivas != "SW - schweißen":
|
|
default = "SW - schweißen"
|
|
else:
|
|
default = ""
|
|
ret['fertigungsart_neu'] = default
|
|
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 == "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"
|
|
else:
|
|
raise Exception("no such fertigungsart "+ fertigungsart)
|
|
cblist = self._config.Fertigung.get_list_in_section(section)
|
|
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 == "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-/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 = ""
|
|
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', 'normal')
|
|
|
|
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', 'normal')
|
|
if pdm_kategorie_neu == "Kaufteil":
|
|
cblist = self._config.Allgemein.get_options("FOS_Gruppe")
|
|
self.set_state('cb_fosGruppe_neu', 'disabled')
|
|
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:
|
|
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', 'normal')
|
|
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 == "":
|
|
default = "Kaufteil"
|
|
else:
|
|
if calc_art == "Kaufteil" or calc_art == "":
|
|
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', 'normal')
|
|
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', 'normal')
|
|
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()
|
|
pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu")
|
|
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', 'normal')
|
|
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', 'normal')
|
|
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', 'normal')
|
|
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', 'normal')
|
|
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")
|
|
# 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', 'normal')
|
|
|
|
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 werkstoff_typ in mlist:
|
|
mat = self._config.Materialien.get_material_of_type(werkstoff_typ)
|
|
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', 'disabled')
|
|
else:
|
|
self.set_state('cb_farbe_neu', 'normal')
|
|
|
|
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
|
|
|
|
if __name__ == "__main__":
|
|
pass
|
|
|
|
|
|
|