459 lines
19 KiB
Python
459 lines
19 KiB
Python
import os
|
|
"""
|
|
Contains the logic for the MVC of CreoMigrate Gui
|
|
"""
|
|
# Infos und Fehlermeldungen die ausgelöst werden können
|
|
messages = {
|
|
"rüstcode_infos": 'Bitte Rüstcode auswählen!',
|
|
"beschaffungsart_infos": ' Komponenten der Schweißbaugruppe müssen eigene Teilenummern erhalten, falls diese aktuell als Underline-Nummern in der Creo-Baugruppe vorliegen, aber keine eigenen Teilenummern in SIVAS besitzen!',
|
|
"mengeneinheit_infos":'Bitte prüfen, ob Mengeneinheit ≠ "M - Meter" korrekt ist!',
|
|
"material_infos":'Werkstoffvorschlag nicht möglich, da das Material nicht in der Mappingdatei "Materialübersetzung.json" enthalten ist.\nBitte Werkstoff in dieser Datei nachfpflegen und prüfen, ob der Werkstoff in den nachfolgenden Systemen vorhanden ist:\n- RuleDesigner\n- SIVAS-Produktiv- und Schulungsdatenbank\n- Solid Edge\nWenn nicht, bitte in diesen Systemen ebenfalls nachpflegen!',
|
|
"unzulaessige_zeichen":'Unzulässige Zeichen identifiziert:\nZeichen: {Zeichentyp} -> Feld: {Feldname}',
|
|
"bezeichnung_zu_gross":'Bezeichnung besitzt mehr als 50 Zeichen. Bitte verkürzen!',
|
|
"konflikt_ruestcode_saegeliste":'In Sivas prüfen, wieso Haken bei "Halbzeug ohne Sägeliste" trotz Rüstcode "SRC Standard Rüstcode" gesetzt ist.',
|
|
"teilenummre_ohne_ruestcode":'Teilenummer darf nicht ohne Rüstcode migriert werden!',
|
|
"fertigungsart":'Fertigungsart falsch. Bitte berichtigen!',
|
|
"fos_gruppe":'FOS-Gruppe falsch. Bitte berichtigen!',
|
|
"kalkulations_art":'Kalkulationsart falsch. Bitte berichtigen!',
|
|
"beschaffungsart":'Beschaffungsart falsch. Bitte berichtigen!',
|
|
"mengeneinheit":'Mengeneinheit falsch. Bitte berichtigen!',
|
|
"teilenummer_halbzeug":'Teilenummer kann kein Halbzeug sein. Bitte berichtigen!',
|
|
"tos_gruppe_not_exist":'TOS-Gruppe exisitert nicht. Bitte eingetragene Gruppennummer korrigieren oder ergänzen!',
|
|
"dispo_not_exist":'Datensatz kann nicht ohne Dispogruppe migriert werden. Bitte nachpflegen!',
|
|
"dispolauf_not_exist":'Datensatz kann nicht ohne Dispolaufgruppe migriert werden. Bitte nachpflegen!',
|
|
"teilenummer_not_exist_infos":'Ersetzte Teilenummer {Ersetzte Teilenummer} exisitert noch nicht in RuleDesigner. Migration trotzdem durchführen?',
|
|
"ersatzteilenummer_not_exist_infos":'Ersatz-Teilenummer {Ersatz-Teilenummer} exisitert noch nicht in RuleDesigner. Migration trotzdem durchführen?',
|
|
"werkstofftyp_not_exist":'Eingetragener Werkstofftyp exisitert nicht. Bitte korrigeren!',
|
|
"werkstoff_not_exist":'Werkstoff falsch. Bitte korrigieren!',
|
|
"color_not_defined":'Teilenummer kann nicht ohne festgelegte Farbe migriert werden!',
|
|
"aenderungstext_too_long":'Änderungstext_weist zu viele Zeichen auf. Bitte auf 400 Zeichen verkürzen!',
|
|
}
|
|
|
|
|
|
class Controller():
|
|
"""
|
|
Class for manipulating the model and returning data for the view
|
|
"""
|
|
def __init__(self, model, view):
|
|
self.set_model(model)
|
|
self.set_view(view)
|
|
self.logic = None
|
|
self.env = None
|
|
|
|
def set_env(self, env):
|
|
self.environment = env
|
|
|
|
def get_env(self, env_path):
|
|
if self.environment == None:
|
|
raise Exception("No environment set")
|
|
if env_path == "lib":
|
|
ret = self.environment.lib_dir
|
|
elif env_path == "data":
|
|
ret = self.environment.data_dir
|
|
elif env_path == "out":
|
|
ret = self.environment.out_dir
|
|
elif env_path == "cfg":
|
|
ret = self.environment.cfg_dir
|
|
else:
|
|
raise Exception("this path is not defined "+env_path)
|
|
return ret
|
|
|
|
def add_logic(self, logic):
|
|
self.logic = logic
|
|
def remove_logic(self):
|
|
self.logic = None
|
|
|
|
def set_model(self, model):
|
|
self.model = model
|
|
def set_view(self, view):
|
|
self.view = view
|
|
|
|
def refresh_gui(self):
|
|
self.view.data_from_model()
|
|
def data_from_model(self):
|
|
self.view.data_from_model()
|
|
|
|
def get_current_asm_id(self):
|
|
self.model.get_current_asm_id()
|
|
def set_current_asm_id(self, asm_id):
|
|
self.model.set_current_asm_id(asm_id)
|
|
|
|
|
|
def set_current_item_id(self, cid):
|
|
"""setze eine neue Item ID """
|
|
# check before. change to given item just in case it is valid, e.g. name is a number of 9 digits
|
|
if not cid.isnumeric():
|
|
return
|
|
|
|
# TODO save current given data. In case, ask whether you should save or drop
|
|
self.set_gui_data('teilenummer', cid)
|
|
|
|
# falls eine .json Datei davon existiert, dann diese zuerst versuchen zu laden
|
|
#self.model.load(demo_data)
|
|
gui_dict = None
|
|
loaded_json = self.model.sivas_data_from_json(cid)
|
|
if loaded_json:
|
|
# falls eine .json Datei dieser ID existiert, dann diese laden
|
|
gui_dict = self.logic.csv2guidata(loaded_csv)
|
|
else:
|
|
# ansonsten die .csv Datei mit den SIVAS Infos holen
|
|
# TODO
|
|
loaded_csv = self.model.sivas_data_from_csv(cid)
|
|
if loaded_csv:
|
|
# und dann diese laden
|
|
gui_dict = self.logic.csv2guidata(loaded_csv)
|
|
if not gui_dict:
|
|
print("no file found "+ cid)
|
|
else:
|
|
self.model.set_gui_dict(gui_dict)
|
|
self.refresh_gui()
|
|
|
|
def get_current_item_id(self):
|
|
return self.get_gui_data('teilenummer')
|
|
|
|
|
|
def set_red_ids(self, red_ids):
|
|
self.model.set_red_ids(red_ids)
|
|
def get_red_ids(self):
|
|
return self.model.get_red_ids()
|
|
|
|
def set_parent_children(self, parent_children_mapping):
|
|
self.model.set_parent_children(parent_children_mapping)
|
|
def get_parent_children(self):
|
|
return self.model.get_parent_children()
|
|
|
|
# merkt sich die reinen Daten zum Impfen
|
|
def set_data_dict(self, data:dict):
|
|
"""merken der Daten zum Impfen"""
|
|
for k,v in data:
|
|
self.set_data(k,v)
|
|
def set_data(self, key, value):
|
|
"""merken der Daten zum Impfen"""
|
|
self.model.set_data(key, value)
|
|
|
|
def get_data(self, key):
|
|
return self.model.get_data(key)
|
|
def get_all_data(self):
|
|
return self.model.get_all_data()
|
|
|
|
# merkt sich die Nutzereingaben, bzw. Daten für die GUI
|
|
def set_gui_dict(self, data:dict):
|
|
"""merken der Eingaben des Nutzers der GUI """
|
|
for k,v in data.items():
|
|
self.set_gui_data(k,v)
|
|
def set_gui_data(self, key, value):
|
|
"""merken der Eingaben des Nutzers der GUI """
|
|
self.model.set_gui_data(key, value)
|
|
|
|
def get_gui_data(self, key):
|
|
return self.model.get_gui_data(key)
|
|
def get_all_gui_data(self):
|
|
return self.model.get_all_gui_data()
|
|
|
|
def callback(self, key, value):
|
|
if not self.logic:
|
|
return
|
|
|
|
# Logik um neue Werte in Oberfläche oder Modell zu füllen
|
|
model_values = self.logic.callback(key, value)
|
|
if model_values:
|
|
self.set_gui_dict(model_values)
|
|
self.refresh_gui()
|
|
|
|
# reine Aktionen
|
|
if key == 'cb_speichern':
|
|
self.save_to_file()
|
|
elif key == 'cb_migrieren':
|
|
pass
|
|
elif key == 'cb_zurücksetzen':
|
|
pass
|
|
elif key == 'cb_suche_asm':
|
|
pass
|
|
|
|
def save_to_file(self):
|
|
"""speichert die bisherigen Eingaben beider Spalten in eine json Datei"""
|
|
path = os.path.join(self.get_env("out"), str(self.get_current_item_id()) + '.json')
|
|
# die Bauminfos und RedIds dazu werden standardmässig nicht mit gemerkt.
|
|
self.model.save(path, False)
|
|
|
|
class GuiLogic():
|
|
"""
|
|
Class for business logic. implementing the dependencies between different user inputs
|
|
"""
|
|
def __init__(self, model, configs):
|
|
# das Modell soll hier nur verwendet werden um aktuell Zustände abzufragen!
|
|
# alles weitere zum Setzen von Daten etc. muss über den Controller laufen, also zurück gegeben werden.
|
|
self.model = model
|
|
# hier holt man die Daten der Configs
|
|
self.config = configs
|
|
# hier sind alle Callbacks bzw. deren Comboboxen
|
|
|
|
# dies sind die Excel Headel der SIVAS csv Export Datei
|
|
# und wie diese in das Datenmodell der Gui integriert werden kann
|
|
self.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":"dispolaufgruppe_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":"werkstofftyp_sivas",
|
|
"Oberfläche":"cb_oberflaeche_neu",
|
|
# "Truemmer":"truemmer",
|
|
# "HzOhneSaegeliste":"",
|
|
"Ruestcode":"ruestcode_sivas",
|
|
"Fertigungsart":"fertigungsart_sivas",
|
|
"FosGruppe":"fosGruppe_sivas",
|
|
"Kalkulationsart":"kalkulationsart_sivas",
|
|
#"Indexerfasser":"",
|
|
"Aenderungstext":"aenderungstext_sivas",
|
|
"Freigabevermerk":"freigabevermerk_sivas",
|
|
# "Indexbearbeiter":"in"
|
|
}
|
|
|
|
def csv2guidata(self, data):
|
|
ret = dict()
|
|
for k,v in data.items():
|
|
if k in self.excel_to_gui and v is not None:
|
|
ret[self.excel_to_gui[k]] = v
|
|
|
|
# Spezial: Befüllung von Änderungstext mit dem Author, falls in der .csv vorhanden
|
|
if "Indexerfasser" in data and "Aenderungstext" in data:
|
|
ret["aenderungstext_sivas"] = '{aenderungstext} (von {author})'.format(aenderungstext=data["Aenderungstext"], author=data["Indexerfasser"])
|
|
# Indexerfasser wird nicht in der gui verwaltet. Deshalb Modifikation aus den Rohdaten
|
|
|
|
# set defaults from given logic
|
|
r1 = self.callback("cb_neuaufbau", None)
|
|
ret.update(r1)
|
|
r2 = self.callback("cb_aus_halbzeug_neu", None)
|
|
ret.update(r2)
|
|
r3 = self.callback("cb_halbzeugoberflaeche", None)
|
|
ret.update(r3)
|
|
|
|
# add entry dependencies
|
|
dep = self.entry_dependencies(ret)
|
|
ret.update(dep)
|
|
return ret
|
|
|
|
def entry_dependencies(self, data):
|
|
return {}
|
|
|
|
|
|
def callback(self, key, value):
|
|
"""gibt ein dict zurück, welches neu im Modell gesetzt wird"""
|
|
|
|
if key == 'cb_pdm_kategorie_neu':
|
|
pass
|
|
elif key == "cb_halbzeug_neu":
|
|
pass
|
|
elif key == "cb_halbzeugoberflaeche":
|
|
return self.halbzeug_oberflaeche_neu(value)
|
|
elif key == "cb_halbzeugfarbe":
|
|
return self.halbzeug_farbe_neu(value)
|
|
elif key == 'cb_neuaufbau':
|
|
return self.neuaufbau(value)
|
|
elif key == 'cb_aus_halbzeug_neu':
|
|
return self.aus_halbzeug_neu(value)
|
|
elif key == 'cb_lebenszyklus_status_neu':
|
|
pass
|
|
elif key == 'cb_3Dmodel_neu':
|
|
pass
|
|
elif key == 'cb_halbzeugOhneSaege_neu':
|
|
pass
|
|
elif key == 'cb_ruestcode_neu':
|
|
pass
|
|
elif key == 'cb_fertigungsart_neu':
|
|
pass
|
|
elif key == 'cb_allgemeintoleranz_neu':
|
|
pass
|
|
elif key == 'cb_fosGruppe_neu':
|
|
pass
|
|
elif key == 'cb_kalkulationsart_neu':
|
|
pass
|
|
elif key == 'cb_beschaffungsart_neu':
|
|
pass
|
|
elif key == 'cb_mengeneinheit_neu':
|
|
pass
|
|
elif key == 'cb_halbzeug_neu':
|
|
pass
|
|
elif key == 'cb_dispogruppe_neu':
|
|
pass
|
|
elif key == 'cb_dispolaufgruppe_neu':
|
|
pass
|
|
elif key == 'cb_hersteller_neu':
|
|
pass
|
|
elif key == 'cb_werkstoffdiskrepanz':
|
|
pass
|
|
elif key == 'cb_werkstofftyp_neu':
|
|
pass
|
|
# return self.werkstofftyp(value)
|
|
elif key == 'cb_material_neu':
|
|
pass
|
|
elif key == 'cb_oberflaeche_neu':
|
|
pass
|
|
elif key == 'cb_farbe_neu':
|
|
return self.farbe(value)
|
|
elif key == 'cb_speichern':
|
|
pass
|
|
elif key == 'cb_migrieren':
|
|
pass
|
|
elif key == 'cb_zurücksetzen':
|
|
pass
|
|
elif key == 'cb_suche_asm':
|
|
pass
|
|
else:
|
|
raise Exception("this callback does not exist "+key)
|
|
|
|
def neuaufbau(self, trueOrfalse):
|
|
ret = dict()
|
|
pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
|
|
if pdm_kat != "Einzelteil" or pdm_kat != "Kaufteil":
|
|
ret["neuaufbau"] = False
|
|
return ret
|
|
|
|
def aus_halbzeug_neu(self, trueOrfalse):
|
|
ret = dict()
|
|
pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
|
|
if pdm_kat == "Einzelteil":
|
|
ret = self.callback("cb_halbzeugoberflaeche", None)
|
|
else:
|
|
ret["aus_halbzeug_neu"] = False
|
|
return ret
|
|
|
|
|
|
def farbe(self, selected):
|
|
farben_alle = self.config.Farben.get_farbauswahl()
|
|
farben_elox = self.config.Farben.get_farben_eloxieren()
|
|
# setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
|
|
ret = {
|
|
# das Feld selbst mit dem Selektierten beschreiben
|
|
'farbe_neu': selected,
|
|
# die neuen Inhalte der comboboxen setzen
|
|
'cb_farben': farben_alle,
|
|
# der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
|
|
'farbe_neu': farben_alle[0],
|
|
}
|
|
return ret
|
|
|
|
|
|
def halbzeug_oberflaeche_neu(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 not selected is None:
|
|
ret['cb_halbzeugoberflaeche'] = selected
|
|
else:
|
|
ret = {
|
|
'halbzeugoberflaeche_neu': oarten[0],
|
|
'cb_halbzeugoberflaeche': oarten,
|
|
}
|
|
else:
|
|
ret = {
|
|
'halbzeugoberflaeche_neu': "",
|
|
'cb_halbzeugoberflaeche': "",
|
|
}
|
|
return ret
|
|
|
|
def halbzeug_farbe_neu(self, selected):
|
|
ret = dict()
|
|
data = self.model.get_gui_data("halbzeug_farbe_neu")
|
|
if "halbzeugoberflaeche_neu" in data:
|
|
halbzeugoberflaeche = data["halbzeugoberflaeche_neu"]
|
|
if data["aus_halbzeug_neu"] == True:
|
|
if halbzeugoberflaeche == "eloxieren" or halbzeugoberflaeche == "lackieren" or halbzeugoberflaeche == "pulverbeschichten":
|
|
if halbzeugoberflaeche == "eloxieren":
|
|
farben_elox = self.config.Farben.get_farben_eloxieren()
|
|
# setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
|
|
ret = {
|
|
# die neuen Inhalte der comboboxen setzen
|
|
'halbzeugfarbe_neu': farben_elox[0],
|
|
'cb_halbzeugfarbe': farben_elox,
|
|
|
|
}
|
|
elif halbzeugoberflaeche == "lackieren" or halbzeugoberflaeche == "pulverbeschichten":
|
|
farbauswahl = self.config.Farben.get_farbauswahl()
|
|
# setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
|
|
ret = {
|
|
'halbzeugfarbe_neu': farbauswahl[0],
|
|
'cb_halbzeugfarbe': farbauswahl,
|
|
}
|
|
|
|
else:
|
|
ret["halbzeugoberflaeche_neu"] = ''
|
|
else:
|
|
ret["halbzeugoberflaeche_neu"] = ''
|
|
return ret
|
|
|
|
|
|
# def werkstofftyp(self, selected_werkstoff):
|
|
# """bekommt Aluminium, Stahl etc. und setzt dann die anderen Felder der Oberfläche"""
|
|
|
|
# # Logik, die steuert, welcher Defaultwert gilt:
|
|
|
|
# # In den nachfolgenden Fällen darf kein Defaultwert eingetragen
|
|
# # werden (selbst wenn in from_siv.csv ein Wert in der Spalte
|
|
# # "Werkstoff" eingetragen sein sollte):
|
|
# # PDM-Kategorie == "Baugruppe"
|
|
# # PDM-Kategorie == "Schweissbaugruppe"
|
|
# # PDM-Kategorie == "Einzelteil" und Aus Halbzeug == True (Haken gesetzt)
|
|
|
|
# # Gilt PDM-Kategorie == "Kaufteil" soll der Defaultwert "siehe
|
|
# # Hersteller" eingetragen werden
|
|
|
|
# # Gilt PDM-Kategorie == "Einzelteil" und Aus Halbzeug == False (kein
|
|
# # Haken), dann wird der Defaultwert wie folgt bestimmt:
|
|
# ret = dict()
|
|
# # das Feld selbst mit dem Selektierten beschreiben
|
|
# ret['werkstofftyp_neu']= selected_werkstoff
|
|
|
|
# pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
|
|
# aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
|
|
|
|
# if pdm_kat == 'Einzelteil' and aus_halbzeug is False:
|
|
# wnamen = self.config.Werkstoffe.get_werkstoffe_of_name(selected_werkstoff)
|
|
# # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
|
|
# ret = {
|
|
# # das Feld selbst mit dem Selektierten beschreiben
|
|
# 'werkstofftyp_neu': selected_werkstoff,
|
|
# # die neuen Inhalte der comboboxen setzen
|
|
# 'cb_material_neu': wnamen,
|
|
# # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
|
|
# 'material_neu': wnamen[0],
|
|
# }
|
|
# return ret
|
|
|
|
# def oberfläche(self, selected):
|
|
|
|
# ret = dict()
|
|
# # das Feld selbst mit dem Selektierten beschreiben
|
|
# ret['oberflaeche_neu']= selected
|
|
|
|
# pdm_kat = self.model.get_gui_data("pdm_kategorie_neu")
|
|
# aus_halbzeug = self.model.get_gui_data("aus_halbzeug_neu")
|
|
|
|
# if pdm_kat == 'Einzelteil' and aus_halbzeug is False:
|
|
# onamen = self.config.Oberfläche.get_oberfläche_of_type(selected)
|
|
# # setze die Inhalte der abhängigen Comboboxen neu und den Wert im Modell
|
|
# ret = {
|
|
# # die neuen Inhalte der comboboxen setzen
|
|
# 'cb_oberflaeche_neu': onamen,
|
|
# # der angezeigte Wert der Combos sollte anfangs dem ersten der Liste entsprechen
|
|
# 'oberflaeche_neu': onamen[0],
|
|
# }
|
|
# return ret
|
|
|
|
|
|
if __name__ == "__main__":
|
|
pass
|