Le moteur de décomposition 10.12

Pour des raisons d’optimisation du code et du nombre de requêtes SQL, le parcours des nomenclatures est réalisé en itératif (pas d’appel récursif)

Le parcours utilise 2 itérations imbriquées.

On traite tous les composants du composé dans l'itération de niveau 2.

Si un composant est également un composé on l’ajoute dans une liste qui sera traiter dans l'itération de niveau 1

Ce type de parcours implique de faire un traitement en 2 étapes pour générer les OF dans le même ordre que le moteur historique (qui faisait directement le parcourt des éléments fils).

Les 2 étapes sont :

E1 : Le parcours de construction
E2 : le parcours d'ouverture

E1 : le parcours de construction

Son rôle est le suivant :

parcourir intégralement une nomenclature avec tous les fils et les fils des fils …
calculer les quantités nécessaires et faire les conversions d’unités
gérer le lotissement
fournir des ouvertures pour valider les chargements
- Nomenclature_Compose_Chargement_Av
- Nomenclature_Composant_Chargement_Av
faire les substitutions pour les articles gérés en sous référence
vérifier les boucles infinies
alimenter la liste des entêtes de nomenclature List_BA
alimenter la liste des composants List_BB
alimenter la liste des paramètres de nomenclature list_GH
traiter les composants qui sont eux-mêmes des composés

L’algorithme

Charger les données du composé BA

Début itération 1

Ajouter le BA à List_BA

Extraire les composants BB du composé BA

Début itération 2 pour chaque ligne de composant BB

Ajouter le composant à List_BB

Traiter le composant BB

Si le composant BB est également un composé BA

Ajouter le composé BA dans la liste List_BA_Fils

Fin si

Fin itération 2 sur les composants (BB)

Si List_BA_Fils contient un composé BA

Charger le 1er composé BA de List_BA_Fils

Supprimer le 1er élément de List_BA_Fils

Sinon

Plus de de fils à traiter car tout les fils sont traité

Fin si

Poursuivre itération 1 avec le compose BA

A la fin de l'étape E1 les 3 listes suivantes sont alimentées :

liste des entêtes de nomenclature List_BA
liste des composants List_BB
liste des paramètres de nomenclature list_GH

E2 : le parcours d'ouverture

Le parcours d’ouverture se fait en explorant entièrement chaque nœud avec les listes List_BA + List_BB son objectif et d’appeler les ouvertures permettant de générer les données des OF

Nomenclature_Compose_Chargement_Ap
Nomenclature_Compose_Chargement_Ap

Ouvertures vers le programme appelant : ggppfab100

Ouverture du programme appelant

Etape

d’appel

Rôle

Ancienne

Ouverture du programme appelant	Etape d’appel	Rôle	Ancienne
`Nomenclature_Compose_Chargement_Av`	E1	Valider le chargement d’un composé Si la fonction retourne 0 on traite le composé Prototype `Function Int Nomenclature_Compose_Chargement_Av (&G6, &G6T2, &ART, &SART, NivFict, Niveau, NiveauReel, Qte, Unit, QteComposant)`	`Compose_Chargement_Av`
`Nomenclature_Composant_Virtuel_Chargement`	E1	Gérer le découpage en lots d’un OF Prototype `Function int Nomenclature_Composant_Virtuel_Chargement (G6, &BA, &BB, &GH, QteComposant, List_BB_Virtuel)`	`Composant_Virtuel_Chargement`
`Nomenclature_Composant_Chargement_Av`	E1	Avant de traiter un composant Prototype `Procedure Nomenclature_Composant_Chargement_Av(&tBA_compose, &tBB, Niveau, NiveauReel, SubstitutionOK)`	`Composant_Chargement_Av`
`Nomenclature_Decomposition_Retour_Av`	E1	Après parcours de tous les composants d’un composé Prototype `Procedure Nomenclature_Decomposition_Retour_Av ()`	`Decomposition_Retour_Av`
`Nomenclature_Compose_Chargement_Ap`	E2	Traiter le composé - Créer un OF Prototype `Procedure Nomenclature_Decomposition_Retour_Av ()`	`Compose_Chargement_Ap`
`Nomenclature_Composant_Chargement_Ap`	E2	Traiter le composant - Créer les composant de OF Prototype `Procedure Nomenclature_Composant_Chargement_Ap (&G6T1, &G6T2, Niveau, NiveauReel, CdQte, Unit, BA_Trouve, TicketRes)`	`Composant_Chargement_Ap`
`Nomenclature_Compose_Retour_Av`	E2	Traitement de fin d’un composé - après avoir traiter le composé et ses composants Prototype `Procedure Nomenclature_Compose_Retour_Av(&G6T2, NiveauReel)`	`Compose_Retour_Av`
`Nomenclature_OverFlow_Erreur_Erreur`		Se produit lors	`OverFlow_Erreur`

Ouvertures distributeur et correspondances avec le moteur historique

Note : uniquement disponible à partir de la 222A

Le nouveau moteur n’utilise plus aucun enregistrement publique (G6, BA, BB ...)

Les appels des ouvertures pour les distributeurs du nouveau moteur de décomposition sont centralisées dans le module ggtm600_sql.dhsp .

Chaque ouverture est appelée avec les paramètres qui sont nécessaires.

Chaque paramètre de la procédure est placée dans le tunnel local via des appels PingLocal.

La procédure appelle Xmt_Call pour le code de surcharge dans les modules TT de chaque programme

Exemple de la procédure ggtm600_sql / Composant_Utilisation_Av

public procedure Composant_Utilisation_Av(G6, &BB, &BA_composant, Niveau, NiveauReel)
; L’appel est fait avant d’utiliser le composant BB  - Il permet de le modifier ci nécessaire
		Record GTFDD.dhsd			G6
		Record GTFDD.dhsd			BB										; Le composant
		Record GTFDD.dhsd			BA BA_composant					; Si le composant est aussi un composé 
1		Niveau						> GTFDD.dhsd	Niv				; Niveau de l'en-tête de production (y compris fictif)
1		NiveauReel					> GTFDD.dhsd	Niv				; Niveau en tenant compte des fictifs
beginp
	; envoyer les données en ping
	PingLocal("PM600_SQL_G6", G6)
	PingLocal("PM600_SQL_BB", BB)
	PingLocal("PM600_SQL_BA_COMPOSANT", BA_composant)
	PingLocal("PM600_SQL_NIVEAU", Niveau)
	PingLocal("PM600_SQL_NIVEAUREEL", NiveauReel)
	G3_Xmt_Call ("Composant_Utilisation_Av")
	; recupérer les records modifiés par l'ouverture
	PingLocalReceiveAndDelete("PM600_SQL_BB", BB)
	PingLocalReceiveAndDelete("PM600_SQL_BA_composant", BA_composant)
endp

Ouverture pour la génération des OF ggttfab100.dhsp / Composant_Chargement_Av

;* 
procedure Composant_Utilisation_Av
; Ouverture pour le moteur de Composant_Utilisation_Av
		Record GTFDD.dhsd			G6
		Record GTFDD.dhsd			BB								; Le composant
		Record GTFDD.dhsd			BA BA_composant					; Si le composant est aussi un composé 
1		Niveau						> GTFDD.dhsd	Niv				; Niveau de l'en-tête de production (y compris fictif)
1		NiveauReel					> GTFDD.dhsd	Niv				; Niveau en tenant compte des fictifs
beginp
	; Lire les enregistrements transmis par la procedure [ggtm600_sql.dhsp / Composant_Utilisation_Av]
	PingLocalReceive("PM600_SQL_G6", G6)
	PingLocalReceive("PM600_SQL_BB", BB)
	PingLocalReceive("PM600_SQL_BA_composant", BA_composant)
	PingLocalReceive("PM600_SQL_NIVEAU", Niveau)
	PingLocalReceive("PM600_SQL_NIVEAUREEL", NiveauReel)
	; Modifier les données de BB et BA_Composant ici
	; retourner les enregistrements modifiés à [ggtm600_sql.dhsp / Composant_Utilisation_Av]
	PingLocal("PM600_SQL_BB", BB)
	PingLocal("PM600_SQL_BA_composant", BA_composant)
endp

Le parcours des nomenclatures est réalisé en itératif (pas d’appel récursif) pour limiter les instructions SQL.

Ce type de parcours implique de faire un traitement en 2 étapes E1 + E2 afin de conserver l’ordre de génération des OF.

Les 2 étapes sont :

E1 : Le parcours de construction → il sert essentiellement à alimenter les listes BA + BB et réaliser les appels des ouvertures xxx_avqui permettent d’agir sur les BA + BB
E2 : le parcours d'ouverture → il sert à refaire le parcours des listes BA + BB en explorant les fils et à réaliser les appels des ouvertures xxx_ap

Moteur 10.12 (ggtm600_sql)	Appel	Rôle et prototype	Moteur historique (tt)

Moteur 10.12 (ggtm600_sql)	Appel	Rôle et prototype	Moteur historique (tt)
`Decomposition_avec_test_boucle_infinie`	INIT	Permet de débrayer le test des boucles infinies Attention en cas d'erreur de nomenclature le programme boucle indéfiniment `public function char Decomposition_avec_test_boucle_infinie(G6)`	`Decomposition_avec_test_boucle_infinie`
`Compose_Utilisation_Av`	E1	L’appel est fait avant d’utiliser le composé `BA` - Il permet de modifier `BA` ci nécessaire `public procedure Compose_Utilisation_Av(G6, &BA, Niveau, NiveauReel)`	`BA_Utilisation_Compose_Av`
`Compose_Chargement_Av`	E1	L’appel est fait avant de stocker l’enregistrement lié au composé `G6T2` dans la liste des composés `public procedure Compose_Chargement_Av (G6, &G6T2, &ART, &SART, Niveau, NiveauReel)`
`Compose_Chargement_Ap`	E2	L’appel est fait après le traitement du composé Si le moteur est utilisé pour générer des OF, l'appel est fait après avoir créé l’entête d’OF et les séquences `public procedure Compose_Chargement_Ap (G6, G6T2, GH, Niveau, NiveauReel)`	`Compose_Chargement_Ap` `Compose_Fictif_Chargement_Ap`
`Composant_Chargement_Av`	E1	L’appel est fait avant de stocker l’enregistrement lié au composant `G6T1` dans la liste des composants. `Composant_Chargement_Av` est appelé avant `Composant_Utilisation_Av` et permet de connaitre le `BA` père `public Procedure Composant_Chargement_Av(&G6T2_pere, &G6T1, Niveau, NiveauReel)`	`Composant_Chargement_Av`
`Composant_Utilisation_Av`	E1	L’appel est fait avant d’utiliser le composant `BB` - Il permet de modifier `BB` ou son `BA` associé si le `BB` est également un composé `public procedure Composant_Utilisation_Av(G6, &BB, &BA_composant, Niveau, NiveauReel)`	`BA_Utilisation_Composant_Av`
`Composant_Chargement_Ap`	E2	L’appel est fait après le traitement du composant Si le moteur est utilisé pour générer des OF, l'appel est fait après avoir crée le composant `public Procedure Composant_Chargement_Ap (G6, G6T1, G6T2)`	`Composant_Chargement_Ap`
`Composant_Test_stock`	E1	Permet de valider le test de stock d’un composant `public function char Composant_Test_stock(G6, BB)`	`Decompo_Test_stock_composant`
`Decomposition_Retour_Av`	E1	Le parcours des composants du composé est terminé `public Procedure Decomposition_Retour_Av (G6, BA)`	`Decomposition_Retour_Av`
`Mode_Traitement_Decoupage_Contrainte_Lot_SF`	E1	Règle de découpage des lots `public function char Mode_Traitement_Decoupage_Contrainte_Lot_SF(G6, BB)`	`Mode_Traitement_Decoupage_Contrainte_Lot_SF`
`Compose_Secondaire_Init_Quantite`	E1	Permet d’initialiser la quantité du composé secondaire dans la ventilation `public procedure Compose_Secondaire_Init_Quantite(G6, BB, &RefQte)`	`Compose_Secondaire_Init_Quantite`