Logik an die geänderten Tabellen (siehe Commit d745436) angepasst. Beim Update der TOS-Regeln und -Bedingungen wird zudem in VAR_TEIL_BEDINGUNG_2 und STKL_REGEL nur noch die Positionsnummer aktualisiert, aber nicht mehr die Bedingung oder Regel selbst. Das ist nicht nötig, weil ja eine Verschiebung erfolgt, also abgesehen von einer etwaigen Anpassung der Positionsnummer keine Änderungen erfolgen
This commit is contained in:
+256
-192
@@ -232,32 +232,36 @@ class RD_COMP:
|
||||
|
||||
def get_verbose_data(self) -> list[dict[str]]:
|
||||
res = self.db.con.execute("""
|
||||
SELECT C.*, R.REGEL, B.BEDINGUNG
|
||||
SELECT C.*, R.LFD_NR, B.UEB_LEISTEN_NR
|
||||
FROM COMP C
|
||||
|
||||
LEFT JOIN VAR_TEIL_BEDINGUNG_2 B
|
||||
ON C.ID = B.COMP_ID
|
||||
ON C.UEBTEILENR = B.UEBTEILENR
|
||||
AND C.POSNR = B.POSNR
|
||||
|
||||
LEFT JOIN STKL_REGEL R
|
||||
ON C.ID = R.COMP_ID
|
||||
ON C.UEBTEILENR = R.UEBTEILENR
|
||||
AND C.POSNR = R.POSNR
|
||||
|
||||
WHERE C.PARENT = :parent_code
|
||||
WHERE C.UEBTEILENR = :parent_code
|
||||
ORDER BY C.POSNR
|
||||
""", {"parent_code": self.parent_code}).fetchall()
|
||||
return res
|
||||
|
||||
def get_compact_data(self) -> list[dict[str]]:
|
||||
res = self.db.con.execute("""
|
||||
SELECT C.POSNR, C.KOMPTEILENR, C.ABW_ANZAHL, C.MENGE, C.LAENGE, C.ZUSCHNITT, R.REGEL, B.Bedingung
|
||||
SELECT C.POSNR, C.KOMPTEILENR, C.ABW_ANZAHL, C.MENGE, C.LAENGE, C.ZUSCHNITT, R.LFD_NR, B.UEB_LEISTEN_NR
|
||||
FROM COMP C
|
||||
|
||||
LEFT JOIN VAR_TEIL_BEDINGUNG_2 B
|
||||
ON C.ID = B.COMP_ID
|
||||
ON C.UEBTEILENR = B.UEBTEILENR
|
||||
AND C.POSNR = B.POSNR
|
||||
|
||||
LEFT JOIN STKL_REGEL R
|
||||
ON C.ID = R.COMP_ID
|
||||
ON C.UEBTEILENR = R.UEBTEILENR
|
||||
AND C.POSNR = R.POSNR
|
||||
|
||||
WHERE C.PARENT = :parent_code
|
||||
WHERE C.UEBTEILENR = :parent_code
|
||||
ORDER BY C.POSNR
|
||||
""", {"parent_code": self.parent_code}).fetchall()
|
||||
return res
|
||||
@@ -290,26 +294,26 @@ class BOMProcessing:
|
||||
|
||||
def _get_codes_case_12_or_13(self) -> None:
|
||||
"""
|
||||
Ermittelt alle, die unter Fall 1.2 oder Fall 1.3 fallen.
|
||||
Ermittelt alle Teilenummern, die unter Fall 1.2 oder Fall 1.3 fallen.
|
||||
Es wird dafür geprüft, welche Teilenummern NICHT unter Fall 1.1 fallen.
|
||||
|
||||
Wieso wird nicht geprüft, welche Teilenummern in Fall 1.1 liegen?
|
||||
- Weil die SQL-Abfrage dann deutlich komplexer wird.
|
||||
- Weil die SQL-Abfrage dann komplexer wird.
|
||||
|
||||
Die Prüfung läuft so ab:
|
||||
1. Teilenr-Längen-Kombinationen aus der alten und neuen Stückliste mit UNION ALL zusammenfügen
|
||||
2. Mit COUNT ermitteln, wie oft jede Teilenummer-Längen-Kombination in der zusammengefügten Stückliste auftritt
|
||||
3. Die Teilenummern in die temporäre Tabelle TMP_CODES_CASE_12_OR_13 schreiben, deren Teilenr-Längen-Kombination 1x vorkommen
|
||||
=> Diese Teilenummern unterliegen entweder Fall 1.2 oder Fall 1.3, aber definitiv nicht Fall 1.1, weil eine Zuordnung zu
|
||||
Fall 1.1 nur dann möglich ist, wenn alle Teilenr-Längen-Kombinationen exakt 2x auftreten!
|
||||
1. Teilenr-Längen-Kombinationen aus der alten und neuen Stückliste mit UNION ALL verschmelzen
|
||||
2. Mit COUNT ermitteln, wie oft jede Teilenummer-Längen-Kombination in der verschmolzenen Stückliste auftritt
|
||||
3. Die Teilenummern in die temporäre Tabelle TMP_CODES_CASE_12_OR_13 schreiben, sobald 1x eine Teilenr-Längen-Kombination auftritt, die nur 1x vorkommt
|
||||
=> Diese Teilenummern unterliegen entweder Fall 1.2 oder Fall 1.3, aber definitiv nicht Fall 1.1, weil eine Zuordnung zu Fall 1.1 nur dann möglich ist,
|
||||
wenn alle Teilenr-Längen-Kombinationen einer Teilenummer exakt 2x auftreten!
|
||||
"""
|
||||
self.db.con.execute("DROP TABLE IF EXISTS TMP_CODES_CASE_12_OR_13")
|
||||
self.db.con.execute("CREATE TABLE TMP_CODES_CASE_12_OR_13 (KOMPTEILENR TEXT NOT NULL, PRIMARY KEY (KOMPTEILENR))")
|
||||
self.db.con.execute("CREATE TABLE TMP_CODES_CASE_12_OR_13 (KOMPTEILENR TEXT NOT NULL)")
|
||||
self.db.con.execute("""
|
||||
WITH combined_bom AS (
|
||||
SELECT C.KOMPTEILENR, COALESCE(C.LAENGE, 0) AS LAENGE
|
||||
FROM COMP C
|
||||
WHERE C.PARENT = :parent_code
|
||||
WHERE C.UEBTEILENR = :parent_code
|
||||
|
||||
UNION ALL
|
||||
|
||||
@@ -334,24 +338,24 @@ class BOMProcessing:
|
||||
Fall 1.3 umfasst alle Positionen, die entweder in der neuen Stückliste dazugekommen sind (Fall 1.31) oder deren
|
||||
Teilenr-Längen-Kombination in beiden Stücklisten vorliegen (Fall 1.32).
|
||||
|
||||
Wenn Positionen bereits unter Fall 1.1 oder Fall 1.2 fallen, dann werden sie nicht Fall 1.32 zugeordnet, selbst wenn
|
||||
sie Fall 1.32 auf diese Positionen zutreffen würde (Vorrangsprinzip).
|
||||
Wenn Positionen bereits unter Fall 1.1 oder Fall 1.2 fallen, dann werden sie NICHT Fall 1.32 zugeordnet, selbst wenn
|
||||
Fall 1.32 auf diese Positionen zutreffen würde.
|
||||
|
||||
Die Prüfung läuft so ab:
|
||||
1. Teilenr-Posnr-Kombinationen aus der alten und neuen Stückliste mit UNION ALL zusammenfügen, sofern sich die Teilenummern in der
|
||||
1. Alle Teilenr-Posnr-Kombinationen aus der alten und neuen Stückliste mit UNION ALL verschmelzen, sofern sich die Teilenummern in der
|
||||
Liste an Teilenummern befindet, die unter Fall 1.2 oder Fall 1.3 fallen (siehe Methode _get_codes_case_12_or_13())
|
||||
2. Mit COUNT ermitteln, wie oft jede Teilenr-Posnr-Kombination in der zusammengefügten Stückliste auftritt
|
||||
3. Die Teilenummern ausgeben, deren Teilenr-Posnr-Kombination nur 1x vorkommen in die temporäre Tabelle TMP_CODES_CASE_13 schreiben
|
||||
=> Diese Teilenummern unterliegen definitv Fall 1.3, weil in Fall 1.2 alle Teilenr-Posnr-Kombinationen exakt 2x auftreten müssen!
|
||||
3. Die Teilenummern, deren Teilenr-Posnr-Kombination nur 1x auftritt, in die temporäre Tabelle TMP_CODES_CASE_13 schreiben
|
||||
=> Diese Teilenummern unterliegen definitv Fall 1.3, weil in Fall 1.2 alle Teilenr-Posnr-Kombinationen einer Teilenummer exakt 2x auftreten müssen!
|
||||
"""
|
||||
|
||||
self.db.con.execute("DROP TABLE IF EXISTS TMP_CODES_CASE_13")
|
||||
self.db.con.execute("CREATE TABLE TMP_CODES_CASE_13 (KOMPTEILENR TEXT NOT NULL, PRIMARY KEY(KOMPTEILENR))")
|
||||
self.db.con.execute("CREATE TABLE TMP_CODES_CASE_13 (KOMPTEILENR TEXT NOT NULL)")
|
||||
self.db.con.execute("""
|
||||
WITH combined_bom AS (
|
||||
SELECT KOMPTEILENR, POSNR
|
||||
FROM COMP
|
||||
WHERE PARENT = :parent_code
|
||||
WHERE UEBTEILENR = :parent_code
|
||||
AND KOMPTEILENR IN (SELECT * FROM TMP_CODES_CASE_12_OR_13)
|
||||
|
||||
UNION ALL
|
||||
@@ -378,31 +382,36 @@ class BOMProcessing:
|
||||
|
||||
Deren Ermittlung funktioniert so:
|
||||
1. Teilenummern herausfiltern, die NICHT in der Tabelle TMP_CODES_CASE_12_OR_13 vorliegen
|
||||
2. Zu den gefundenen Teilenummern:
|
||||
- Parent-Teilenr
|
||||
- Posnr. laut neuer Stückliste
|
||||
- ID laut alter Stückliste
|
||||
in die temporäre Tabelle TMP_POSNRS_CASE_11 schreiben.
|
||||
2. Zu den gefundenen Teilenummern folgende Spaltenwerte ermitteln und in die temporäre Tabelle TMP_POSNRS_CASE_11 schreiben:
|
||||
- Teilenr des Parents
|
||||
- Positionsnummer laut alter Stückliste
|
||||
- Positionsnummer laut neuer Stückliste
|
||||
|
||||
Hinweis:
|
||||
- ID dient in der späteren UPDATE-Methode dazu, die Positionsnummer zu finden, die aktualisiert werden sollen
|
||||
- Parent und POSNR werden benötigt, um die neuen Stücklistendaten laut neuer Stückliste identifizieren zu können
|
||||
- Die Positionsnummern aus beiden Stücklisten werden benötigt, um bei der Ermittlung der Update-Daten die Zuordnung zwischen der alten und neuen
|
||||
Stückliste herstellen zu können
|
||||
- Die Teilenummer des Parents wird zusamment mit der Positionsnummer laut alter Stückliste dafür benötigt, um in den Tabellen STKL_REGEL und
|
||||
VAR_TEIL_BEDINGUNG_2 die Zeilen zu ermitteln, die aktualisiert werden müssen
|
||||
"""
|
||||
self.db.con.execute("DROP TABLE IF EXISTS TMP_POSNRS_CASE_11")
|
||||
self.db.con.execute("""CREATE TABLE TMP_POSNRS_CASE_11 (COMP_ID INTEGER NOT NULL,
|
||||
PARENT TEXT NOT NULL,
|
||||
POSNR INTEGER NOT NULL,
|
||||
PRIMARY KEY(POSNR))""")
|
||||
self.db.con.execute("""
|
||||
INSERT INTO TMP_POSNRS_CASE_11 (COMP_ID, PARENT, POSNR)
|
||||
|
||||
SELECT C.ID AS COMP_ID, C.PARENT, RD.Positionsnummer AS POSNR
|
||||
self.db.con.execute("""
|
||||
CREATE TABLE TMP_POSNRS_CASE_11 (UEBTEILENR TEXT NOT NULL,
|
||||
POS_ALT INTEGER NOT NULL,
|
||||
POS_NEU INTEGER NOT NULL)
|
||||
""")
|
||||
|
||||
self.db.con.execute("""
|
||||
INSERT INTO TMP_POSNRS_CASE_11 (UEBTEILENR, POS_ALT, POS_NEU)
|
||||
|
||||
SELECT C.UEBTEILENR, C.POSNR AS POS_ALT, RD.Positionsnummer AS POS_NEU
|
||||
FROM RD_COMP RD
|
||||
|
||||
LEFT JOIN TMP_CODES_CASE_12_OR_13 TMP
|
||||
ON RD.ChildCode = TMP.KOMPTEILENR
|
||||
|
||||
|
||||
LEFT JOIN COMP C
|
||||
ON RD.ParentCode = C.PARENT
|
||||
ON RD.ParentCode = C.UEBTEILENR
|
||||
AND RD.ChildCode = C.KOMPTEILENR
|
||||
AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0)
|
||||
|
||||
@@ -416,69 +425,68 @@ class BOMProcessing:
|
||||
|
||||
Deren Ermittlung funktioniert so:
|
||||
1. Teilenummern herausfiltern, die in der Tabelle TMP_CODES_CASE_12_OR_13, aber NICHT in Tabelle TMP_CODES_CASE_13 existieren
|
||||
2. Zu den gefundenen Teilenummern:
|
||||
- Parent-Teilenr
|
||||
- Posnr. laut neuer Stückliste
|
||||
- ID laut alter Stückliste
|
||||
in die temporäre Tabelle TMP_POSNRS_CASE_12 schreiben.
|
||||
2. Zu den gefundenen Teilenummern folgende Spaltenwerte ermitteln und in die temporäre Tabelle TMP_POSNRS_CASE_12 schreiben:
|
||||
- Teilenr des Parents
|
||||
- Positionsnummer laut alter Stückliste
|
||||
- Positionsnummer laut neuer Stückliste
|
||||
|
||||
Hinweis:
|
||||
- ID dient in der späteren UPDATE-Methode dazu, die Positionsnummer zu finden, die aktualisiert werden sollen
|
||||
- Parent und POSNR werden benötigt, um die neuen Stücklistendaten laut neuer Stückliste identifizieren zu können
|
||||
- Die Positionsnummern aus beiden Stücklisten werden benötigt, um bei der Ermittlung der Update-Daten die Zuordnung zwischen der alten und neuen
|
||||
Stückliste herstellen zu können
|
||||
- Die Teilenummer des Parents wird zusamment mit der Positionsnummer laut alter Stückliste dafür benötigt, um in den Tabellen STKL_REGEL und
|
||||
VAR_TEIL_BEDINGUNG_2 die Zeilen zu ermitteln, die aktualisiert werden müssen
|
||||
"""
|
||||
|
||||
self.db.con.execute("DROP TABLE IF EXISTS TMP_POSNRS_CASE_12")
|
||||
|
||||
self.db.con.execute("""
|
||||
CREATE TABLE TMP_POSNRS_CASE_12 (COMP_ID INTEGER NOT NULL,
|
||||
PARENT TEXT NOT NULL,
|
||||
POSNR INTEGER NOT NULL,
|
||||
PRIMARY KEY(POSNR))
|
||||
CREATE TABLE TMP_POSNRS_CASE_12 (UEBTEILENR TEXT NOT NULL,
|
||||
POS_ALT INTEGER NOT NULL,
|
||||
POS_NEU INTEGER NOT NULL)
|
||||
""")
|
||||
|
||||
self.db.con.execute("""
|
||||
INSERT INTO TMP_POSNRS_CASE_12 (COMP_ID, PARENT, POSNR)
|
||||
INSERT INTO TMP_POSNRS_CASE_12 (UEBTEILENR, POS_ALT, POS_NEU)
|
||||
|
||||
SELECT C.ID AS COMP_ID, C.PARENT, RD.Positionsnummer AS POSNR
|
||||
SELECT C.UEBTEILENR, C.POSNR AS POS_ALT, RD.Positionsnummer AS POS_NEU
|
||||
FROM RD_COMP RD
|
||||
|
||||
LEFT JOIN TMP_CODES_CASE_13 TMP
|
||||
ON RD.ChildCode = TMP.KOMPTEILENR
|
||||
|
||||
LEFT JOIN COMP C
|
||||
ON RD.ParentCode = C.PARENT
|
||||
AND RD.ChildCode = C.KOMPTEILENR
|
||||
AND RD.Positionsnummer = C.POSNR
|
||||
ON RD.ParentCode = C.UEBTEILENR
|
||||
AND RD.ChildCode = C.KOMPTEILENR
|
||||
AND RD.Positionsnummer = C.POSNR
|
||||
|
||||
WHERE RD.ParentCode = :parent_code
|
||||
AND TMP.KOMPTEILENR IS NULL
|
||||
AND RD.Positionsnummer NOT IN (SELECT POSNR FROM TMP_POSNRS_CASE_11);
|
||||
AND RD.Positionsnummer NOT IN (SELECT POS_NEU FROM TMP_POSNRS_CASE_11)
|
||||
""", {"parent_code": self.parent_code})
|
||||
|
||||
def _get_case_131_positions(self):
|
||||
"""
|
||||
Fall 1.31 - Positionsnummern holen, die neu angelegt werden müssen.
|
||||
Fall 1.31 - Positionsnummern ermitteln, die neu angelegt werden müssen.
|
||||
|
||||
Deren Ermittlung funktioniert so:
|
||||
1. Teilenummern herausfiltern, deren Teilenr-Längen-Kombination nur in der neuen Stückliste existieren und die zudem in der Tabelle
|
||||
TMP_CODES_CASE_13 vorliegen.
|
||||
1. Alle Positionsnummern herausfiltern, auf die folgende Kriterien zutreffen:
|
||||
- Teilenr-Längen-Kombination der Position existiert nur in der neuen Stückliste existiert
|
||||
- Teilenummer der Position ist in der Tabelle TMP_CODES_CASE_13 enthalten
|
||||
|
||||
Hinweis:
|
||||
Es reicht nicht aus, lediglich zu prüfen, ob die Teilenr-Längen-Kombination nur in der neuen Stücklist vorliegt
|
||||
Es reicht nicht aus, lediglich zu prüfen, ob die Teilenr-Längen-Kombination nur in der neuen Stückliste vorliegt
|
||||
Grund:
|
||||
Positionsnummern die unter Fall 1.2 fallen, dürfen in der neuen Stückliste eine andere Teilenr-Längen-Kombination
|
||||
als in der alten Stückliste aufweisen, d.h. die Teilenr-Längen-Kombi laut neuer Stückliste liegt auch nur dort vor. Trotzdem
|
||||
werden diese Positionsnummern nicht neu angelegt, sondern von der alten in die neuen Stückliste verschoben!
|
||||
|
||||
2. Zu den gefundenen Teilenummern:
|
||||
- Parent-Teilenr
|
||||
- Posnr. laut neuer Stückliste
|
||||
- ID laut alter Stückliste
|
||||
in die temporäre Tabelle TMP_POSNRS_CASE_131 schreiben.
|
||||
Hinweis:
|
||||
- ID dient in der späteren UPDATE-Methode dazu, die Positionsnummer zu finden, die aktualisiert werden sollen
|
||||
- Parent und POSNR werden benötigt, um die neuen Stücklistendaten laut neuer Stückliste identifizieren zu können
|
||||
"""
|
||||
2. Alle gefundenen Positionen in die temporäre Tabelle TMP_POSNRS_CASE_131 schreiben (mehr Informationen werden nicht benötigt)
|
||||
"""
|
||||
|
||||
self.db.con.execute("DROP TABLE IF EXISTS TMP_POSNRS_CASE_131")
|
||||
self.db.con.execute("CREATE TABLE TMP_POSNRS_CASE_131 (POSNR INTEGER NOT NULL, PRIMARY KEY(POSNR))")
|
||||
|
||||
self.db.con.execute("CREATE TABLE TMP_POSNRS_CASE_131 (POSNR INTEGER NOT NULL)")
|
||||
|
||||
self.db.con.execute("""
|
||||
INSERT INTO TMP_POSNRS_CASE_131
|
||||
|
||||
@@ -486,13 +494,13 @@ class BOMProcessing:
|
||||
FROM RD_COMP RD
|
||||
|
||||
LEFT JOIN COMP C
|
||||
ON RD.ParentCode = C.PARENT
|
||||
ON RD.ParentCode = C.UEBTEILENR
|
||||
AND RD.ChildCode = C.KOMPTEILENR
|
||||
AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0)
|
||||
|
||||
WHERE RD.ParentCode = :parent_code
|
||||
AND RD.ChildCode IN (SELECT * FROM TMP_CODES_CASE_13)
|
||||
AND C.KOMPTEILENR IS NULL;
|
||||
AND RD.ChildCode IN (SELECT KOMPTEILENR FROM TMP_CODES_CASE_13)
|
||||
AND C.KOMPTEILENR IS NULL
|
||||
""", {"parent_code": self.parent_code})
|
||||
|
||||
def _get_case_132_positions(self) -> None:
|
||||
@@ -500,63 +508,76 @@ class BOMProcessing:
|
||||
Fall 1.32 - Positionsnummern holen, die von der alten in die neue Stückliste verschoben werden
|
||||
|
||||
Deren Ermittlung funktioniert so:
|
||||
1. Teilenummern herausfiltern, deren Teilenr-Längen-Kombination in beiden Stückliste existieren und die zudem in der Tabelle
|
||||
TMP_CODES_CASE_13 vorliegen. Lediglich zu prüfen, ob die Teilenr-Längen-Kombination nur in der neuen Stückliste vorliegt reicht nicht aus!
|
||||
1. Alle Positionsnummern herausfiltern, auf die folgende Kriterien zutreffen:
|
||||
- Teilenr-Längen-Kombination existiert in beiden Stücklisten
|
||||
- Teilenummer der Position ist in der Tabelle TMP_CODES_CASE_13 enthalten
|
||||
|
||||
Hinweis:
|
||||
Es reicht nicht aus, lediglich zu prüfen, ob die Teilenr-Längen-Kombination in beiden Stücklisten vorliegt
|
||||
Grund:
|
||||
Positionsnummern die Fall 1.1 zugeordnet werden können oder Positionsnummern, die unter Fall 1.2 fallen und deren Länge dabei in beiden
|
||||
Stücklisten gleich bleibt würden grundlegend ebenfalls unter Fall 1.32 fallen und somit identifiziert werden.
|
||||
Es gilt jedoch das Vorrangsprinzip, d.h. die Zuordnung zu Fall 1.1 oder Fall 1.2 erfolgt (sofern möglich) immer vor der Zuordnung
|
||||
Es gilt jedoch das Prioritätsprinzip, d.h. die Zuordnung zu Fall 1.1 oder Fall 1.2 erfolgt (sofern möglich) immer vor der Zuordnung
|
||||
zu Fall 1.32!
|
||||
|
||||
2. Zu den gefundenen Teilenummern:
|
||||
- Parent-Teilenr
|
||||
- Posnr. laut neuer Stückliste
|
||||
- ID laut alter Stückliste
|
||||
in die temporäre Tabelle TMP_POSNRS_CASE_132 schreiben.
|
||||
2. Zu den gefundenen Teilenummern folgende Spaltenwerte ermitteln und in die temporäre Tabelle TMP_POSNRS_CASE_132 schreiben:
|
||||
- Teilenr des Parents
|
||||
- Positionsnummer laut alter Stückliste
|
||||
- Positionsnummer laut neuer Stückliste
|
||||
|
||||
Hinweis:
|
||||
- ID dient in der späteren UPDATE-Methode dazu, die Positionsnummer zu finden, die aktualisiert werden sollen
|
||||
- Parent und POSNR werden benötigt, um die neuen Stücklistendaten laut neuer Stückliste identifizieren zu können
|
||||
- Die Positionsnummern aus beiden Stücklisten werden benötigt, um bei der Ermittlung der Update-Daten die Zuordnung zwischen der alten und neuen
|
||||
Stückliste herstellen zu können
|
||||
- Die Teilenummer des Parents wird zusamment mit der Positionsnummer laut alter Stückliste dafür benötigt, um in den Tabellen STKL_REGEL und
|
||||
VAR_TEIL_BEDINGUNG_2 die Zeilen zu ermitteln, die aktualisiert werden müssen
|
||||
"""
|
||||
|
||||
self.db.con.execute("DROP TABLE IF EXISTS TMP_POSNRS_CASE_132")
|
||||
self.db.con.execute("""
|
||||
CREATE TABLE TMP_POSNRS_CASE_132 (COMP_ID INTEGER NOT NULL,
|
||||
PARENT TEXT NOT NULL,
|
||||
POSNR INTEGER NOT NULL,
|
||||
PRIMARY KEY(POSNR))""")
|
||||
self.db.con.execute("""
|
||||
INSERT INTO TMP_POSNRS_CASE_132 (COMP_ID, PARENT, POSNR)
|
||||
|
||||
SELECT C.ID AS COMP_ID, C.PARENT, RD.Positionsnummer AS POSNR
|
||||
self.db.con.execute("""
|
||||
CREATE TABLE TMP_POSNRS_CASE_132 (UEBTEILENR TEXT NOT NULL,
|
||||
POS_ALT INTEGER NOT NULL,
|
||||
POS_NEU INTEGER NOT NULL)
|
||||
""")
|
||||
|
||||
self.db.con.execute("""
|
||||
INSERT INTO TMP_POSNRS_CASE_132 (UEBTEILENR, POS_ALT, POS_NEU)
|
||||
|
||||
SELECT C.UEBTEILENR, C.POSNR AS POS_ALT, RD.Positionsnummer AS POS_NEU
|
||||
FROM RD_COMP RD
|
||||
|
||||
INNER JOIN COMP C
|
||||
ON RD.ParentCode = C.PARENT
|
||||
ON RD.ParentCode = C.UEBTEILENR
|
||||
AND RD.ChildCode = C.KOMPTEILENR
|
||||
AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0)
|
||||
|
||||
WHERE RD.ParentCode = :parent_code
|
||||
AND RD.ChildCode IN (SELECT * FROM TMP_CODES_CASE_13)
|
||||
AND RD.ChildCode IN (SELECT KOMPTEILENR FROM TMP_CODES_CASE_13)
|
||||
""", {"parent_code": self.parent_code})
|
||||
|
||||
def delete(self):
|
||||
def _get_ids_to_delete(self) -> None:
|
||||
"""
|
||||
Entfernt die Positionsnummern aus der alten Stückliste, die nicht mehr in der neuen Stückliste vorliegen.
|
||||
Ermittelt alle Positionsnummern, die entfernt werden sollen
|
||||
|
||||
Hinweis:
|
||||
Bei der Ermittlung der zu löschenden Datensätze dürfen die Positionsnummern, die verschoben werden NICHT berücksichtigt werden.
|
||||
Die alte Lösch-Logik: "Die Teile die in der neuen Stückliste nicht drin sind, werden rausgelöscht" nur noch eingeschränkt anwendbar!
|
||||
Bei der Ermittlung dürfen die Positionsnummern, die verschoben werden NICHT berücksichtigt werden. Die alte Lösch-Logik:
|
||||
"Die Teile die in der neuen Stückliste nicht drin sind, werden rausgelöscht"
|
||||
ist daher nur noch eingeschränkt anwendbar!
|
||||
|
||||
Grund:
|
||||
Das liegt vor allem an Fall 1.2, denn per Definition darf in diesem Fall die Länge in der neuen Stückliste abweichen, solange alle
|
||||
Teilenr-Posnr-Kombinationen in beiden Stücklisten identsich sind, siehe hierzu z.B. Pos. 3 in Beispiel 3 unter doc/Beispiele.pdf:
|
||||
Dort liegt die Länge 200 aus der alten Stückliste nicht mehr in der neuen Stückliste vor. Pos. 3 würde also laut alter Logik gelöscht werden.
|
||||
Da diese Positionsnummer aber unter Fall 1.2 fällt, wird sie in die neue Stückliste verschoben, d.h. sie darf nicht gelöscht werden!
|
||||
|
||||
Da diese Positionsnummer aber unter Fall 1.2 fällt, wird sie in die neue Stückliste verschoben, darf also nicht gelöscht werden!
|
||||
"""
|
||||
|
||||
self.db.con.execute("DROP TABLE IF EXISTS TMP_IDS_TO_DELETE")
|
||||
self.db.con.execute("CREATE TABLE TMP_IDS_TO_DELETE (ID INTEGER NOT NULL, PRIMARY KEY(ID))")
|
||||
|
||||
self.db.con.execute("""CREATE TABLE TMP_IDS_TO_DELETE (COMP_ROWID INTEGER NOT NULL,
|
||||
VAR_TEIL_BED_2_ROWID INTEGER,
|
||||
STKL_REGEL_ROWID INTEGER)
|
||||
""")
|
||||
|
||||
self.db.con.execute("""
|
||||
WITH COMBINED_UPDATE_DATA AS (
|
||||
SELECT * FROM TMP_POSNRS_CASE_11
|
||||
@@ -565,45 +586,55 @@ class BOMProcessing:
|
||||
UNION
|
||||
SELECT * FROM TMP_POSNRS_CASE_132
|
||||
)
|
||||
INSERT INTO TMP_IDS_TO_DELETE
|
||||
INSERT INTO TMP_IDS_TO_DELETE (COMP_ROWID, VAR_TEIL_BED_2_ROWID, STKL_REGEL_ROWID)
|
||||
|
||||
SELECT C.ID
|
||||
SELECT C.ROWID AS COMP_ROWID, B.ROWID AS VAR_TEIL_BED_2_ROWID, R.ROWID AS STKL_REGEL_ROWID
|
||||
FROM COMP C
|
||||
|
||||
LEFT JOIN COMBINED_UPDATE_DATA CUD
|
||||
ON C.ID = CUD.COMP_ID
|
||||
ON C.UEBTEILENR = CUD.UEBTEILENR
|
||||
AND C.POSNR = CUD.POS_ALT
|
||||
|
||||
LEFT JOIN VAR_TEIL_BEDINGUNG_2 B
|
||||
ON C.UEBTEILENR = B.UEBTEILENR
|
||||
AND C.POSNR = B.POSNR
|
||||
|
||||
LEFT JOIN STKL_REGEL R
|
||||
ON C.UEBTEILENR = R.UEBTEILENR
|
||||
AND C.POSNR = R.POSNR
|
||||
|
||||
WHERE C.PARENT = :parent_code
|
||||
AND CUD.COMP_ID IS NULL
|
||||
WHERE C.UEBTEILENR = :parent_code
|
||||
AND CUD.UEBTEILENR IS NULL
|
||||
""", {"parent_code": self.parent_code})
|
||||
|
||||
# Entfernung der Stücklistenpositionen aus COMP
|
||||
self.db.con.execute("DELETE FROM COMP WHERE ID IN (SELECT ID FROM TMP_IDS_TO_DELETE)")
|
||||
# Entfernung der TOS-Bedingungen aus VAR_TEIL_BEDINGUNG_2
|
||||
self.db.con.execute("DELETE FROM VAR_TEIL_BEDINGUNG_2 WHERE COMP_ID IN (SELECT ID FROM TMP_IDS_TO_DELETE)")
|
||||
# Entfernung der TOS-Regeln aus STKL_REGEL
|
||||
self.db.con.execute("DELETE FROM STKL_REGEL WHERE COMP_ID IN (SELECT ID FROM TMP_IDS_TO_DELETE)")
|
||||
|
||||
def update(self):
|
||||
|
||||
def _get_update_data(self):
|
||||
"""
|
||||
Aktualisiert die Positionsnummern, die von der alten in die neue Stückliste verschoben werden sollen.
|
||||
Ermittlung der neuen Stücklisteninformationen, mit denen die bestehenden Datzensätze überschrieben werden
|
||||
|
||||
Dies umfasst alle Positionsnummern, die unter die Fälle 1.1, 1.2 und 1.32 fallen. Sie wurden in den Methoden
|
||||
_get_case_11_positions, _get_case_12_positions & _get_case_132_positions ermittelt und in die temporären
|
||||
Tabellen TMP_POSNRS_CASE_11, TMP_POSNRS_CASE_12, TMP_POSNRS_CASE_132 geschrieben.
|
||||
Die neuen Informationen werden für alle Positionsnummern bestimmt, die unter die Fälle 1.1, 1.2 und 1.32 fallen,
|
||||
also die, die sich in den Tabellen TMP_POSNRS_CASE_11, TMP_POSNRS_CASE_12 & TMP_POSNRS_CASE_132 befinden.
|
||||
|
||||
Jetzt passiert folgendes:
|
||||
1. Die Positionen aus den 3 Tabellen werden zu einer temporären Tabelle, ALL_POSNRS_TO_UPDATE kombiniert.
|
||||
2. Zu allen Positionen aus in dieser kombinierten, temporären Tabelle werden dann die neuen Stücklisteninformationen aus COMP,
|
||||
bzw. RD_COMP bestimmt und in eine weitere, temporäre, aber persistente Tabelle TMP_UPDATE_DATA geschrieben.
|
||||
3. Durchführen der Updates in den Tabellen COMP (für die Stücklisteninformationen), VAR_TEIL_BEDINGUNG_2 (für die TOS-Bedingungen)
|
||||
und STKL_REGEL für die TOS-Regeln
|
||||
Hinweis:
|
||||
Es werden in diesem Zuge auch die zugehörigen Zeilen-ID's zu den Positionsnummern in den Tabellen VAR_TEIL_BEDINGUNG_2 und STKL_REGEL ermittelt,
|
||||
da in diesen Tabellen ebenfalls die Positionsnummern aktualisiert werden müssen, sofern welche vorliegen. Die Regeln und Bedingungen selbst
|
||||
bleiben unverändert, da sie nur verschoben werden.
|
||||
"""
|
||||
|
||||
self.db.con.execute("DROP TABLE IF EXISTS TMP_UPDATE_DATA")
|
||||
self.db.con.execute("CREATE TABLE TMP_UPDATE_DATA (ID, POSNR, ABW_ANZAHL, MENGE, LAENGE, ZUSCHNITT, DISPO_AKTIV_JN, RUESTCODE, BEDINGUNG, REGEL)")
|
||||
|
||||
# Neue Stücklisteninformationen ermitteln
|
||||
self.db.con.execute("""
|
||||
CREATE TABLE TMP_UPDATE_DATA (COMP_ROWID INTEGER NOT NULL,
|
||||
VAR_TEIL_BED_2_ROWID INTEGER,
|
||||
STKL_REGEL_ROWID INTEGER,
|
||||
POS_ALT INTEGER NOT NULL,
|
||||
POS_NEU INTEGER NOT NULL,
|
||||
ABW_ANZAHL INTEGER,
|
||||
MENGE REAL,
|
||||
LAENGE REAL,
|
||||
ZUSCHNITT REAL,
|
||||
DISPO_AKTIV_JN TEXT,
|
||||
RUESTCODE TEXT)
|
||||
""")
|
||||
|
||||
self.db.con.execute("""
|
||||
WITH ALL_POSNRS_TO_UPDATE AS (
|
||||
SELECT * FROM TMP_POSNRS_CASE_11
|
||||
@@ -612,54 +643,87 @@ class BOMProcessing:
|
||||
UNION
|
||||
SELECT * FROM TMP_POSNRS_CASE_132
|
||||
)
|
||||
INSERT INTO TMP_UPDATE_DATA (ID, POSNR, ABW_ANZAHL, MENGE, LAENGE, ZUSCHNITT, DISPO_AKTIV_JN, RUESTCODE, BEDINGUNG, REGEL)
|
||||
INSERT INTO TMP_UPDATE_DATA (COMP_ROWID,
|
||||
VAR_TEIL_BED_2_ROWID,
|
||||
STKL_REGEL_ROWID,
|
||||
POS_ALT,
|
||||
POS_NEU,
|
||||
ABW_ANZAHL,
|
||||
MENGE,
|
||||
LAENGE,
|
||||
ZUSCHNITT,
|
||||
DISPO_AKTIV_JN,
|
||||
RUESTCODE)
|
||||
|
||||
SELECT C.ID,
|
||||
RD.Positionsnummer AS POSNR,
|
||||
SELECT C.ROWID AS COMP_ROWID,
|
||||
B.ROWID AS VAR_TEIL_BED_2_ROWID,
|
||||
R.ROWID AS STKL_REGEL_ROWID,
|
||||
P.POS_ALT,
|
||||
RD.Positionsnummer AS POS_NEU,
|
||||
|
||||
-- Bestimmt Wert für Spalte 'ABW_ANZAHL': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Menge' aus CSV
|
||||
CASE
|
||||
WHEN RD.Uebergabelaenge = 0 THEN NULL
|
||||
ELSE RD.Menge
|
||||
END AS ABW_ANZAHL,
|
||||
-- Bestimmt Wert für Spalte 'ABW_ANZAHL': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Menge' aus CSV
|
||||
CASE
|
||||
WHEN RD.Uebergabelaenge = 0 THEN NULL
|
||||
ELSE RD.Menge
|
||||
END AS ABW_ANZAHL,
|
||||
|
||||
-- Bestimmt Wert für Spalte 'MENGE': Berechnung Dezimalwert, wenn Pos. längenabhängig, sonst Wert 'Menge' aus CSV
|
||||
CASE
|
||||
WHEN RD.Uebergabelaenge = 0 THEN RD.Menge
|
||||
ELSE RD.Menge * (RD.Uebergabelaenge + COALESCE(C.ZUSCHNITT, 0)) / 1000
|
||||
END AS MENGE,
|
||||
-- Bestimmt Wert für Spalte 'MENGE': Berechnung Dezimalwert, wenn Pos. längenabhängig, sonst Wert 'Menge' aus CSV
|
||||
CASE
|
||||
WHEN RD.Uebergabelaenge = 0 THEN RD.Menge
|
||||
ELSE RD.Menge * (RD.Uebergabelaenge + COALESCE(C.ZUSCHNITT, 0)) / 1000
|
||||
END AS MENGE,
|
||||
|
||||
-- Bestimmt Wert für Spalte 'LAENGE': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Uebergabelaenge' aus CSV
|
||||
CASE
|
||||
WHEN RD.Uebergabelaenge = 0 THEN NULL
|
||||
ELSE RD.Uebergabelaenge
|
||||
END AS LAENGE,
|
||||
-- Bestimmt Wert für Spalte 'LAENGE': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Uebergabelaenge' aus CSV
|
||||
CASE
|
||||
WHEN RD.Uebergabelaenge = 0 THEN NULL
|
||||
ELSE RD.Uebergabelaenge
|
||||
END AS LAENGE,
|
||||
|
||||
C.ZUSCHNITT,
|
||||
C.DISPO_AKTIV_JN,
|
||||
C.RUESTCODE,
|
||||
B.BEDINGUNG,
|
||||
R.REGEL
|
||||
C.ZUSCHNITT,
|
||||
C.DISPO_AKTIV_JN,
|
||||
C.RUESTCODE
|
||||
|
||||
FROM ALL_POSNRS_TO_UPDATE CUD
|
||||
FROM ALL_POSNRS_TO_UPDATE P
|
||||
INNER JOIN COMP C
|
||||
ON CUD.COMP_ID = C.ID
|
||||
ON P.UEBTEILENR = C.UEBTEILENR
|
||||
AND P.POS_ALT = C.POSNR
|
||||
|
||||
INNER JOIN RD_COMP RD
|
||||
ON CUD.PARENT = RD.ParentCode
|
||||
AND CUD.POSNR = RD.Positionsnummer
|
||||
ON P.UEBTEILENR = RD.ParentCode
|
||||
AND P.POS_NEU = RD.Positionsnummer
|
||||
|
||||
LEFT JOIN VAR_TEIL_BEDINGUNG_2 B
|
||||
ON CUD.COMP_ID = B.COMP_ID
|
||||
ON P.UEBTEILENR = B.UEBTEILENR
|
||||
AND P.POS_ALT = B.POSNR
|
||||
|
||||
LEFT JOIN STKL_REGEL R
|
||||
ON CUD.COMP_ID = R.COMP_ID
|
||||
ON P.UEBTEILENR = R.UEBTEILENR
|
||||
AND P.POS_ALT = R.POSNR
|
||||
""")
|
||||
|
||||
def delete(self):
|
||||
"""
|
||||
- Entfernt die Positionsnummern aus COMP, die nicht mehr in der neuen Stückliste vorliegen
|
||||
- Entfernt die TOS-Regeln und -Bedingungen der Positionsnummern aus VAR_TEIL_BEDINGUNG_2 und STKL_REGEL
|
||||
"""
|
||||
# Stücklistenpositionen entfernen
|
||||
self.db.con.execute("DELETE FROM COMP WHERE ROWID IN (SELECT COMP_ROWID FROM TMP_IDS_TO_DELETE)")
|
||||
|
||||
# TOS-Bedingungen entfernen
|
||||
self.db.con.execute("DELETE FROM VAR_TEIL_BEDINGUNG_2 WHERE ROWID IN (SELECT VAR_TEIL_BED_2_ROWID FROM TMP_IDS_TO_DELETE)")
|
||||
|
||||
# TOS-Regeln entfernen
|
||||
self.db.con.execute("DELETE FROM STKL_REGEL WHERE ROWID IN (SELECT STKL_REGEL_ROWID FROM TMP_IDS_TO_DELETE)")
|
||||
|
||||
def update(self):
|
||||
"""
|
||||
Aktualisiert die Positionsnummern, deren Spaltenanpassungen und TOS-Regeln / -Bedingungen von der alten in die neue Stückliste übernommen werden sollen.
|
||||
"""
|
||||
# Stücklisteninformationen updaten
|
||||
self.db.con.execute("""
|
||||
UPDATE COMP
|
||||
SET POSNR = UD.POSNR,
|
||||
SET
|
||||
POSNR = UD.POS_NEU,
|
||||
ABW_ANZAHL = UD.ABW_ANZAHL,
|
||||
MENGE = UD.MENGE,
|
||||
LAENGE = UD.LAENGE,
|
||||
@@ -667,79 +731,78 @@ class BOMProcessing:
|
||||
DISPO_AKTIV_JN = UD.DISPO_AKTIV_JN,
|
||||
RUESTCODE = UD.RUESTCODE
|
||||
FROM TMP_UPDATE_DATA UD
|
||||
WHERE COMP.ID = UD.ID
|
||||
WHERE ROWID = UD.COMP_ROWID
|
||||
""")
|
||||
|
||||
# TOS-Bedingungen updaten
|
||||
self.db.con.execute("""
|
||||
UPDATE VAR_TEIL_BEDINGUNG_2
|
||||
SET BEDINGUNG = UD.BEDINGUNG
|
||||
SET POSNR = UD.POS_NEU
|
||||
FROM TMP_UPDATE_DATA UD
|
||||
WHERE COMP_ID = UD.ID
|
||||
WHERE ROWID = UD.VAR_TEIL_BED_2_ROWID
|
||||
""")
|
||||
|
||||
# TOS-Regeln updaten
|
||||
self.db.con.execute("""
|
||||
UPDATE STKL_REGEL
|
||||
SET REGEL = UD.REGEL
|
||||
SET POSNR = UD.POS_NEU
|
||||
FROM TMP_UPDATE_DATA UD
|
||||
WHERE COMP_ID = UD.ID
|
||||
WHERE ROWID = UD.STKL_REGEL_ROWID
|
||||
""")
|
||||
|
||||
def insert(self):
|
||||
"""
|
||||
Neuanlage aller Positionen, die nur in der neuen Stückliste vorliegen.
|
||||
Die Positionsnummern wurde bereits in der Methode _get_codes_case_131 ermittelt und in die temporäre Tabelle
|
||||
TMP_POSNRS_CASE_131 geschrieben.
|
||||
Neuanlage aller Positionen, die nur in der neuen Stückliste vorliegen (das sind die aus der Tabelle TMP_POSNRS_CASE_131)
|
||||
|
||||
Hinweise:
|
||||
- Neue Positionen werden immer ohne TOS-Regeln oder -Bedingungen angelegt, d.h. es erfolgen keine INSERT-Statements
|
||||
in den Tabellen VAR_TEIL_BEDINGUNG_2 oder STKL_REGEL!
|
||||
- Zur Verdeutlichung, welche Werte z.B. in der Spalte Ruestcode oder Dispoaktiv nach der Neuanlage vorliegen, werden
|
||||
die Defaultwerte aus der PARTS-Tabelle geholt. Ob ein solcher INSERT auch in SIVAS erforderlich ist, war zum Zeitpunkt
|
||||
der Erstellung nicht klar.
|
||||
der Erstellung dieses Scripts nicht klar.
|
||||
"""
|
||||
self.db.con.execute("""
|
||||
INSERT INTO COMP (PARENT, POSNR, KOMPTEILENR, ABW_ANZAHL, MENGE, LAENGE, ZUSCHNITT, DISPO_AKTIV_JN, RUESTCODE)
|
||||
INSERT INTO COMP (UEBTEILENR, POSNR, KOMPTEILENR, ABW_ANZAHL, MENGE, LAENGE, ZUSCHNITT, DISPO_AKTIV_JN, RUESTCODE)
|
||||
|
||||
SELECT RD.ParentCode AS PARENT,
|
||||
RD.Positionsnummer AS POSNR,
|
||||
RD.ChildCode AS KOMPTEILENR,
|
||||
SELECT RD.ParentCode AS UEBTEILENR,
|
||||
RD.Positionsnummer AS POSNR,
|
||||
RD.ChildCode AS KOMPTEILENR,
|
||||
|
||||
-- Bestimmt Wert für Spalte 'ABW_ANZAHL': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Menge' aus CSV
|
||||
CASE
|
||||
WHEN RD.Uebergabelaenge = 0 THEN NULL
|
||||
ELSE RD.Menge
|
||||
END AS ABW_ANZAHL,
|
||||
-- Bestimmt Wert für Spalte 'ABW_ANZAHL': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Menge' aus CSV
|
||||
CASE
|
||||
WHEN RD.Uebergabelaenge = 0 THEN NULL
|
||||
ELSE RD.Menge
|
||||
END AS ABW_ANZAHL,
|
||||
|
||||
-- Bestimmt Wert für Spalte 'MENGE': Berechnung Dezimalwert, wenn Pos. längenabhängig, sonst Wert 'Menge' aus CSV
|
||||
CASE
|
||||
WHEN RD.Uebergabelaenge = 0 THEN RD.Menge
|
||||
ELSE RD.Menge * (RD.Uebergabelaenge + COALESCE(C.ZUSCHNITT,0)) / 1000
|
||||
END AS MENGE,
|
||||
-- Bestimmt Wert für Spalte 'MENGE': Berechnung Dezimalwert, wenn Pos. längenabhängig, sonst Wert 'Menge' aus CSV
|
||||
CASE
|
||||
WHEN RD.Uebergabelaenge = 0 THEN RD.Menge
|
||||
ELSE RD.Menge * (RD.Uebergabelaenge + COALESCE(C.ZUSCHNITT, 0)) / 1000
|
||||
END AS MENGE,
|
||||
|
||||
-- Bestimmt Wert für Spalte 'LAENGE': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Uebergabelaenge' aus CSV
|
||||
CASE
|
||||
WHEN RD.Uebergabelaenge = 0 THEN NULL
|
||||
ELSE RD.Uebergabelaenge
|
||||
END AS LAENGE,
|
||||
NULL AS ZUSCHNITT,
|
||||
P.DISPO_AKTIV_JN,
|
||||
P.RUESTCODE
|
||||
-- Bestimmt Wert für Spalte 'LAENGE': NULL, wenn Pos. nicht längenabhängig, sonst Wert 'Uebergabelaenge' aus CSV
|
||||
CASE
|
||||
WHEN RD.Uebergabelaenge = 0 THEN NULL
|
||||
ELSE RD.Uebergabelaenge
|
||||
END AS LAENGE,
|
||||
|
||||
NULL AS ZUSCHNITT,
|
||||
P.DISPO_AKTIV_JN,
|
||||
P.RUESTCODE
|
||||
|
||||
FROM RD_COMP RD
|
||||
|
||||
LEFT JOIN COMP C
|
||||
ON RD.ChildCode = C.KOMPTEILENR
|
||||
AND RD.Uebergabelaenge = COALESCE(C.LAENGE, 0)
|
||||
AND RD.ParentCode = C.PARENT
|
||||
AND RD.ParentCode = C.UEBTEILENR
|
||||
|
||||
LEFT JOIN PARTS P
|
||||
ON RD.ChildCode = P.TEILENR
|
||||
|
||||
WHERE C.KOMPTEILENR IS NULL
|
||||
AND RD.ParentCode = :parent_code
|
||||
AND RD.Positionsnummer IN (SELECT * FROM TMP_POSNRS_CASE_131)
|
||||
AND RD.Positionsnummer IN (SELECT POSNR FROM TMP_POSNRS_CASE_131)
|
||||
""", {"parent_code": self.parent_code})
|
||||
|
||||
def drop_tmp_tables(self):
|
||||
@@ -752,7 +815,6 @@ class BOMProcessing:
|
||||
self.db.con.execute("DROP TABLE TMP_IDS_TO_DELETE")
|
||||
self.db.con.execute("DROP TABLE TMP_UPDATE_DATA")
|
||||
|
||||
|
||||
def write_new_bom(self) -> None:
|
||||
self._get_codes_case_12_or_13()
|
||||
self._get_codes_case_13()
|
||||
@@ -760,6 +822,8 @@ class BOMProcessing:
|
||||
self._get_case_12_positions()
|
||||
self._get_case_131_positions()
|
||||
self._get_case_132_positions()
|
||||
self._get_ids_to_delete()
|
||||
self._get_update_data()
|
||||
self.delete()
|
||||
self.insert()
|
||||
self.update()
|
||||
|
||||
Reference in New Issue
Block a user