387 lines
17 KiB
Python
387 lines
17 KiB
Python
import os
|
|
from tkinter import messagebox
|
|
import update_database
|
|
|
|
from manage_configs import SivasAssemblyData
|
|
from get_teilestamm import FetchSivasTeilestamm
|
|
|
|
"""
|
|
Contains the logic for the MVC of CreoMigrate Gui
|
|
"""
|
|
# Infos und Fehlermeldungen die ausgelöst werden können
|
|
messages = {
|
|
"pdm_kategorie_definiert": "PDM-Kategorie nicht definiert",
|
|
"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_50":'Bezeichnung besitzt mehr als 50 Zeichen. Bitte verkürzen!',
|
|
"bezeichnung_zu_gross_45":'Bezeichnung besitzt mehr als 45 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.',
|
|
"teilenummer_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 '{teilenummer}' exisitert noch nicht in RuleDesigner. Migration trotzdem durchführen?",
|
|
"ersatzteilenummer_not_exist_infos":"Ersatz-Teilenummer '{teilenummer}' exisitert noch nicht in RuleDesigner. Migration trotzdem durchführen?",
|
|
"hersteller": "Hersteller nicht in RuleDesigner enthalten. Bitte nachpflegen!",
|
|
"werkstofftyp_not_exist":'Eingetragener Werkstofftyp existiert 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!',
|
|
"missing_data":'Fehlende Angaben in der Oberfläche: {Labels}',
|
|
"sivas_db_error":'Diese Assembly existiert nicht. Eventuell ist es nur ein Teil?',
|
|
"export_sucessful":'Export der Migrationsdatei erfolgreich. Siehe {path}',
|
|
"export_not_sucessful":'Export der Migrationsdatei fehlgeschlagen. Überprüfe Schreibrechte für {path}.',
|
|
"export_not_sucessful_file_open":'Export fehlgeschlagen. Datei offen?',
|
|
"blacklist_not_exist": 'Bitte Blacklist vom Server holen',
|
|
"wrong_impftool_path": 'Pfad zur DataPrepUtility.exe nicht gefunden. Bitte setenv.bat prüfen.' ,
|
|
"too_many_logfiles":'Keine eindeutige Logdatei zum aktuellen DataPrep Prozess gefunden. Bitte löschen Sie die überflüssigen .log files',
|
|
"some_error_in_log":'Log Datei enthält einen Fehler. Bitte prüfen.',
|
|
"preparation_sucessful":'Preparation mit der Datei {path} erfolgreich',
|
|
"missing_in_blacklist":"{teilenummer} fehlt in der Blacklist, da sich in dessen Stückliste beigestellte oder dispo-inaktive Positionen befinden.\n\nBitte {teilenummer} in die Blacklist aufnehmen!",
|
|
"halbzeug_not_in_RDids":"Halbzeug-Teilenummer '{halbzeug_id}' fehlt in '{rdids_path}'.\n\nEntweder wurde das Halbzeug noch nicht migriert, oder der aktuelle Stand von RD_Teilenummern.csv muss geladen werden.\n\nZum Laden des aktuellen Standes von RD_Teilenummern.csv auf 'Suche' unter dem Eingabefeld der Baugruppennummer klicken und dieses Programm neu starten"
|
|
}
|
|
|
|
|
|
# Der Beobachter
|
|
class Observer:
|
|
def __init__(self):
|
|
pass
|
|
|
|
def attach(self, observable):
|
|
observable.subscribe(self)
|
|
|
|
def notify(self, observable, *args, **kwargs):
|
|
#print(f"Got {args} {kwargs} from {observable}")
|
|
dependent_cbs = self._model.get_dependent(args[0])
|
|
for cb in dependent_cbs:
|
|
model_values = self._model.callback(cb, None)
|
|
if model_values:
|
|
self.set_gui_dict(model_values)
|
|
self.refresh_gui()
|
|
|
|
|
|
|
|
class Controller(Observer):
|
|
"""
|
|
Class for manipulating the model and returning data for the view
|
|
"""
|
|
def __init__(self, model, view):
|
|
self._environment = None
|
|
self._config = None
|
|
self.set_model(model)
|
|
self.set_view(view)
|
|
|
|
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
|
|
elif env_path == "log":
|
|
ret = self._environment.log_dir
|
|
else:
|
|
raise Exception("this path is not defined "+env_path)
|
|
return ret
|
|
|
|
def set_config(self, config):
|
|
self._config = config
|
|
def get_config(self):
|
|
return self._config
|
|
|
|
def get_orange_ids(self, red_ids):
|
|
"""just check which files have already been worked with, so data has been added"""
|
|
orange = dict()
|
|
work = self.get_env('out')
|
|
for red in red_ids:
|
|
if os.path.exists(os.path.join(work, red +'.json')):
|
|
orange[red] = True
|
|
return orange
|
|
|
|
def get_csv_files_of_asm(self, asmid, uselocal):
|
|
""" sich die Einzelteile als .csv und den Aufbau des Assemblies als .json holen """
|
|
data_dir = self.get_env("data")
|
|
sivas_teilestamm = FetchSivasTeilestamm(asmid, data_dir)
|
|
|
|
# falls uselocal True, dann keine Serverabfrage, sondern mit den lokalen Daten arbeiten
|
|
sivas_teilestamm.fetch_from_db(uselocal)
|
|
if not uselocal:
|
|
try:
|
|
sivas_teilestamm.get_unmigrated_teilstamm_csvs()
|
|
except:
|
|
self.message_error('Abfrage hat nicht funktioniert', 'sivas_db_error')
|
|
return
|
|
|
|
redids = sivas_teilestamm.get_red_ids()
|
|
|
|
sad = SivasAssemblyData(data_dir, asmid + '.json')
|
|
parent_children = sad.get_parent_children()
|
|
|
|
self._model.set_red_ids(redids)
|
|
self._model.set_parent_children(parent_children)
|
|
self._model.set_asm_id(asmid)
|
|
|
|
def get_bom_properties(self, asmid):
|
|
""" Holt sich aus Stückliste alle Eigenschaften der Stücklistenpositionen (z.B. Bezeichnung)"""
|
|
data_dir = self.get_env("data")
|
|
assembly_data = SivasAssemblyData(data_dir, asmid + '.json')
|
|
|
|
bom_properties = assembly_data.get_all_bom_properties()
|
|
self._model.set_bom_properties(bom_properties)
|
|
|
|
def set_model(self, model):
|
|
self._model = model
|
|
self.attach(model)
|
|
|
|
def set_view(self, view):
|
|
self._view = view
|
|
|
|
def refresh_gui(self):
|
|
self._view.data_from_model()
|
|
self._view.set_states()
|
|
# def data_from_model(self):
|
|
# self._view.data_from_model()
|
|
def data_from_view(self, key=None):
|
|
return self._view.data_from_view(key)
|
|
|
|
def get_current_asm_id(self):
|
|
self._model.get_asm_id()
|
|
def set_current_asm_id(self, asm_id, loadlocal=False):
|
|
if not asm_id.isnumeric():
|
|
return
|
|
# TODO save current given data. In case, ask whether you should save or drop
|
|
self._model.set_asm_id(asm_id)
|
|
# hole alle Daten vom Server
|
|
self.get_csv_files_of_asm(asm_id, loadlocal)
|
|
self.get_bom_properties(asm_id)
|
|
#self._load_cid_data2model(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
|
|
# nur die red-id Daten können geladen werden.
|
|
# red_ids = self._model.get_red_ids()
|
|
# if not cid in red_ids:
|
|
# return
|
|
|
|
# TODO save current given data. In case, ask whether you should save or drop
|
|
self._model.set_current_item_id(cid)
|
|
self._load_cid_data2model(cid)
|
|
|
|
def get_current_item_id(self):
|
|
return self._model.get_current_item_id()
|
|
|
|
def _load_cid_data2model(self, cid):
|
|
"""lädt alle nötigen Daten für diese ID """
|
|
# falls eine .json Datei davon im Work Ordner existiert, dann diese zuerst versuchen ins Modell zu laden
|
|
self._view.clear_rightframes()
|
|
self._model.clear()
|
|
isok = self._model.from_json_file(self.get_env("out"), cid)
|
|
if isok == False:
|
|
# ansonsten die .csv Datei mit den SIVAS Infos aus data holen
|
|
loaded = self._model.sivas_data_from_csv(cid)
|
|
if loaded == None:
|
|
print("no file found "+ cid)
|
|
else:
|
|
# und diese in der Gui setzen
|
|
set_data = self._model.csv2guidata(loaded)
|
|
self.set_gui_dict(set_data)
|
|
self._model.set_gui_defaults()
|
|
self.refresh_gui()
|
|
|
|
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 get_gui_states(self):
|
|
return self._model.get_states()
|
|
def get_configuration(self):
|
|
return self._model.get_configuration()
|
|
|
|
def message_info(self, title, key, values):
|
|
text = messages[key]
|
|
if 'halbzeug_id' in values:
|
|
text = text.format(halbzeug_id=values['halbzeug_id'], rdids_path=values['rdids_path'])
|
|
if 'path' in values:
|
|
text = text.format(path=values['path'])
|
|
return messagebox.showinfo(title, text)
|
|
def message_question(self, title, key, values={}):
|
|
text = messages[key]
|
|
if 'teilenummer' in values:
|
|
text = text.format(teilenummer=values['teilenummer'])
|
|
default = messagebox.NO
|
|
if 'default' in values and values['default'] == 'yes':
|
|
default = messagebox.YES
|
|
return messagebox.askquestion(title, text, type=messagebox.YESNO, default=default)
|
|
def message_error(self, title, key, values={}):
|
|
text = messages[key]
|
|
if 'Labels' in values:
|
|
text = text.format(Labels=values['Labels'])
|
|
if 'Zeichentyp' in values:
|
|
text = text.format(Zeichentyp=values['Zeichentyp'], Feldname=values['Feldname'] )
|
|
if 'path' in values:
|
|
text = text.format(path=values['path'])
|
|
if 'teilenummer' in values:
|
|
text = text.format(teilenummer=values['teilenummer'])
|
|
return messagebox.showerror(title, text)
|
|
|
|
def callback(self, key, value):
|
|
if not self._model:
|
|
raise Exception("no model yet added")
|
|
|
|
# Aktionen der Knöpfe
|
|
if key == 'cb_speichern':
|
|
data = self.data_from_view()
|
|
self._model.set_gui_dict(data)
|
|
self._model.save_to_file()
|
|
elif key == 'cb_migrieren':
|
|
data = self.data_from_view()
|
|
self._model.set_gui_dict(data)
|
|
self.migrieren()
|
|
elif key == 'cb_zurücksetzen':
|
|
self.zuruecksetzen()
|
|
elif key == 'cb_suche_asm':
|
|
# kopiere Blacklist von Server
|
|
update_database.get_blacklist(self.get_env("data"))
|
|
# hole dir den in die gui eingetragene Nummer
|
|
current_asmid = self.data_from_view('asm_id')
|
|
self.set_current_asm_id(current_asmid)
|
|
elif key == 'cb_ladelokal_asm':
|
|
current_asmid = self.data_from_view('asm_id')
|
|
# hole dir nur die lokalen Daten. Keine Datenbankabfrage
|
|
self.set_current_asm_id(current_asmid, True)
|
|
elif key == 'cb_3dsuchen':
|
|
self.suche_3d()
|
|
|
|
# callbacks der gui zur
|
|
else:
|
|
# Logik um neue Werte in Oberfläche oder Modell zu füllen
|
|
model_values = self._model.callback(key, value)
|
|
if model_values:
|
|
self.set_gui_dict(model_values)
|
|
|
|
# gib dem observer Bescheid, was aufgerufen wurde
|
|
self.notify(self._model, key,value)
|
|
self.refresh_gui()
|
|
|
|
def migrieren(self):
|
|
self._view.reset_labels()
|
|
|
|
# Pruefung ob Pflichtfelder befuellt
|
|
(ok, missing) = self._model.check_pflichtfelder()
|
|
if ok == False:
|
|
labels = ', '.join(missing)
|
|
self.message_error('Fehlende Angaben', 'missing_data', {'Labels':labels})
|
|
self._view.highlight_labels(missing)
|
|
return
|
|
|
|
# Pruefung ob assembly-id in Blacklist fehlt
|
|
(ok, missing_blacklist_id) = self._model.check_blacklist_completeness()
|
|
if ok == False:
|
|
id = ''.join(missing_blacklist_id)
|
|
self.message_error('Fehlend in Blacklist', 'missing_in_blacklist', {'teilenummer': id})
|
|
return
|
|
|
|
# Pruefung, ob unzulaessige Zeichen vorhanden
|
|
invalid_chars = self._config.InvalidChars.get()
|
|
(ok, wrongchars) = self._model.check_improper_chars(invalid_chars)
|
|
if ok == False:
|
|
for label,achars in wrongchars.items():
|
|
chars = ''.join(achars)
|
|
self.message_error('Unzulässige Zeichen', 'unzulaessige_zeichen', {'Zeichentyp': chars, 'Feldname':label})
|
|
self._view.highlight_labels(wrongchars)
|
|
return
|
|
|
|
# Pruefung Feldinhalte
|
|
ok = self._model.check_content()
|
|
if ok == True:
|
|
data = self._model.create_migration_data()
|
|
try:
|
|
infos = self._model.create_migration_file(data)
|
|
except PermissionError:
|
|
self.message_error('export of excel', 'export_not_sucessful_file_open')
|
|
except FileExistsError:
|
|
self.message_error('export of excel', 'export_not_sucessful')
|
|
else:
|
|
self.message_info('export of excel', 'export_sucessful', {'path': infos['path']})
|
|
self._model.call_prep_tool(infos['path'])
|
|
|
|
|
|
def zuruecksetzen(self):
|
|
cid = self.get_current_item_id()
|
|
self._model.clear()
|
|
self._view.clear_rightframes()
|
|
csv_data = self._model.sivas_data_from_csv(str(cid))
|
|
# transform the csv keys into keys used behind the gui
|
|
gui_data = self._model.csv2guidata(csv_data)
|
|
self.set_gui_dict(gui_data)
|
|
# create dropdown and other defaults
|
|
self._model.set_gui_defaults()
|
|
|
|
def suche_3d(self):
|
|
pdm_kategorie_neu = self._model.get_gui_data("pdm_kategorie_neu")
|
|
aus_halbzeug = self._model.get_gui_data("aus_halbzeug_neu")
|
|
neuaufbau = self._model.get_gui_data("neuaufbau")
|
|
# Suche Knopf darf nur bei Einzelteilen funktionieren und wenn Halbzeug/NEuaufbau nicht angehakt sind
|
|
if pdm_kategorie_neu == "Einzelteil" and not (aus_halbzeug == True or neuaufbau == True):
|
|
newpath = self._view.suche_3d()
|
|
if newpath:
|
|
self._model.set_gui_data('model3d_neu', newpath)
|
|
self._model.set_gui_data('cb_3Dmodel_neu', '')
|
|
|
|
|
|
if __name__ == "__main__":
|
|
pass
|