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