FVERS = 2 REFOBJET : ID = 860026233 ; ID_INIT = 860025811 ; NOM = Pdistribution ; VERSION = V172 ; DATE = 01/07/14-08:22:31 ( 1404202951 ) ; CAT = 8 ; ETAT = 0 ; NB_FILS =0 ; ID_FILS = ID_EST = 860000110 COMMENT = "06/02/2014 DRE G4R5 QC791 fonction CalculHT : Modif calcul du champ PRICE_HT --- 07/01/2014 - DRE - G4R5 fonction CalculHT QC777 + Modif. nom pointeur --- 20/02/08 DRE Ajout fonction CONV_ASCIINUMDEC_INT - FO1965 Ajout fonction convNum_Str G2R2Cs - FO727 : mauvaise utilisation de g_inull dans CleIP et CodeEffIP" CREATEUR = teguire # DEBUT_CORPS PCODE_PERE= # DRE 23/05/2013 Modification fonction "ConvTransgrp" # DRE 27/05/2013 Ajout fonction RECHERCHE_CHAINE # DRE 19/06/2013 G4R3 QC731 Modification fonction "ConvTransgrp" # DRE 15/11/2013 G4R4 Ajout fonction CalculHT #--------------------------------------------------------------------------------------- # # FONCTION: CalculHT : Conversion d'un Montant TTC (pt_MontantTTC) en Montant HT (pt_MTHT) # # BUT # Determiner le Montant HT des orders des DOM # # DESCRIPTION: # cette fonction Calcul les montants Hors Taxe arrondi (pt_MTHT1), non arrondi (pt_MTHT2) et avec 5 decimales (pt_MTHTDOM) # a partir d'un montant TTC (par exemple 134.02 ou 134,02) et d'un taux de TVA sous la forme 1 + taux de TVA (par exemple 1.085 ou 1,085) # et retourne une chaine de caracteres representant un montant HT avec 2 decimamale (par exemple 123.52 ou 125,52). # A noter : le separateur decimale de sortie, est le meme que celui du montant TTC d'entree. # # PARAMETRES: # pt_MontantTTC = Montant TTC ex: "123456,12345" ou "123456.12345" # pt_CoefTVA = Taux TVA ex: "1,085" ou "1.085" # pt_CoefConvTVA = Coefficient TVA (= 1 / pt_CoefTVA) ex : "0,9216589861751152" ou "0.9216589861751152" # pt_MTHTDOM = vide en entree, Resultat du calcul du Montant HT DOM, pour recuperation en sortie # # RETOUR: # Pointeur # pt_MTHT = Valeur ASCII du Montant Hors Taxe en cetime d'euros arrondi a 2 decimales ex 1234 pour 12,34 Euros # pt_MTHTDOM = Valeur ASCII du Montant Hors Taxe en Euros avec 5 decimales ex : 123456,12345 ou 123456.12345 # # HISTORIQUE: # 07/01/2014 - DRE - G4R5 fonction CalculHT QC777 + Modif. nom pointeur # 05/02/2014 - DRE - G4R5 QC791 Bug calcul Price_HT # 12/02/2014 - DRE - G4R5 QC791 + Mise en forme pt_MntTTC pour comparaison avec pt_MntTTC2 # #--------------------------------------------------------------------------------------- FONCTION POINTEUR CalculHT(POINTEUR pt_MontantTTC, POINTEUR pt_CoefTVA, POINTEUR pt_CoefConvTVA, POINTEUR pt_MTHTDOM) REGISTRE ENTIER erreur REGISTRE ENTIER VAL REGISTRE POINTEUR pt_temp REGISTRE POINTEUR pt_ValEntier REGISTRE POINTEUR pt_MTHT REGISTRE POINTEUR pt_MTHT1 REGISTRE POINTEUR pt_MTHT2 REGISTRE POINTEUR pt_ValDec REGISTRE POINTEUR pt_Separateur REGISTRE POINTEUR pt_MntTTC REGISTRE POINTEUR pt_MntTTC2 REGISTRE POINTEUR pt_MntCoefTVA REGISTRE POINTEUR pt_MntCoefConvTVA DEBUT_FONCTION # pt_temp = "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" pt_ValEntier = "444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444" pt_MTHT = "555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555" pt_MTHT1 = "333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333" pt_MTHT2 = "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" pt_ValDec = "666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666" pt_Separateur = "7777777" pt_MntTTC = "888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888" pt_MntTTC2 = "222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222" pt_MntCoefTVA = "999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999" pt_MntCoefConvTVA = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" i_strcpy(pt_temp,"") i_strcpy(pt_ValEntier,"") i_strcpy(pt_MTHT,"") i_strcpy(pt_MTHT1,"") i_strcpy(pt_MTHT2,"") i_strcpy(pt_ValDec,"") i_strcpy(pt_Separateur,".") i_strcpy(pt_MntTTC,"") i_strcpy(pt_MntTTC2,"") i_strcpy(pt_MntCoefTVA,"") i_strcpy(pt_MntCoefConvTVA,"") erreur = 0 VAL = 0 # Recuperation des donnees d'entree i_strcpy(pt_MntTTC,pt_MontantTTC) i_strcpy(pt_MntCoefTVA,pt_CoefTVA) i_strcpy(pt_MntCoefConvTVA,pt_CoefConvTVA) #trace2(" ############# pt_MntTTC = >%s< #############",pt_MntTTC,"") #trace2(" ############# pt_MntCoefTVA = >%s< #############",pt_MntCoefTVA,"") # Traitement Montant TTC # si le montant en entree contient une virgule alors remplacement par un point SI i_adequation_chaine_expreg(pt_MntTTC,",") == 0 ALORS i_replace_str(pt_MntTTC,",",".",pt_MntTTC) i_strcpy(pt_Separateur,",") FINSI i_strcpy(pt_temp,pt_MntTTC) #trace2(" ############# pt_temp = >%s< ##### pt_MntTTC = >%s< ########",pt_temp,pt_MntTTC) # extraction de la partie entiere et decimale erreur = i_recupererValeur(pt_temp, pt_ValEntier, i_strlen(pt_temp),'.') i_strcpy(pt_ValDec,pt_temp) #trace2(" ############# pt_ValDec = >%s< #############",pt_ValDec,"") # forcage a 5 decimales si besoin SI i_strlen(pt_ValDec) < 5 ALORS erreur = i_format_str2( pt_ValDec, "%s%s", pt_temp,"00000" ) FINSI i_get_sub_str (pt_ValDec, 0, 4,pt_ValDec) #trace2(" ############# pt_ValDec (5) = >%s< #############",pt_ValDec,"") # reconstitution du montant TTC sous forme de chaine sans separateur i_strcpy(pt_MntTTC,pt_ValDec) SI i_strcmp(pt_ValEntier,"0") != 0 ALORS erreur = i_format_str2( pt_MntTTC, "%s%s", pt_ValEntier,pt_ValDec ) FINSI SI i_strplcmp (pt_MntTTC,"0",0,1) == 0 ALORS i_get_sub_str (pt_MntTTC, 1, -1,pt_MntTTC) FINSI # Traitement CoefTVA # remplacement d'une virgule par un point i_replace_str(pt_MntCoefTVA,",",".",pt_MntCoefTVA) i_strcpy(pt_temp,pt_MntCoefTVA) # extraction de la partie entiere et decimale erreur = i_recupererValeur(pt_temp, pt_ValEntier, i_strlen(pt_temp),'.') # forcage a 6 decimales si besoin i_strcpy(pt_ValDec,pt_temp) SI i_strlen(pt_ValDec) < 3 ALORS erreur = i_format_str2( pt_ValDec, "%s%s", pt_temp,"000" ) FINSI i_get_sub_str (pt_ValDec, 0, 2,pt_ValDec) # reconstitution du montant TVA sous forme de chaine sans separateur i_strcpy(pt_MntCoefTVA,pt_ValDec) SI i_strcmp(pt_ValEntier,"0") != 0 ALORS erreur = i_format_str2( pt_MntCoefTVA, "%s%s", pt_ValEntier,pt_ValDec ) FINSI #trace2(" ############# pt_MntTTC = >%s< ##### pt_MntCoefTVA = >%s< ########",pt_MntTTC,pt_MntCoefTVA) # Traitement CoefConvTVA # remplacement d'une virgule par un point i_replace_str(pt_MntCoefConvTVA,",",".",pt_MntCoefConvTVA) # extraction de la partie decimale erreur = i_recupererValeur(pt_MntCoefConvTVA, pt_ValEntier, i_strlen(pt_temp),'.') # forcage a 8 entier SI i_strlen(pt_MntCoefConvTVA) < 8 ALORS i_strcpy(pt_temp,pt_MntCoefConvTVA) erreur = i_format_str2( pt_MntCoefConvTVA, "%s%s", pt_temp,"00000000" ) FINSI i_get_sub_str (pt_MntCoefConvTVA, 0, 7,pt_MntCoefConvTVA) # Calcul des montanrts HT # Calcul du montant HT pour MMDM prevu pour 5 decimales i_strcpy(pt_temp,pt_MntTTC) erreur = i_largeIntegersMultiply (pt_temp, 255, pt_MntCoefConvTVA, 255) i_get_sub_str (pt_temp, 0, -9,pt_temp) #Montant HT DOM en centieme d'euro exemple 94460523 pour 944,60523 euros (5 decimales) # Stockage dans le parametre de sortie i_strcpy(pt_MTHTDOM,pt_temp) # trace2(" ############# pt_MTHTDOM = >%s< ############",pt_MTHTDOM,"") # Calcul du montant HT NON arrondi tronque au centieme d'euro (2 decimales) i_strcpy(pt_temp,pt_MTHTDOM) SI i_strlen(pt_temp) < 6 ALORS erreur = i_format_str2( pt_ValEntier, "%s%s","000000",pt_temp ) i_get_sub_str (pt_ValEntier, -6, -1,pt_temp) FINSI i_get_sub_str (pt_temp, 0, -4,pt_temp) # Montant HT arrondi en centieme d'euro exemple : TTC = 1025,63000 euros, HT = 94461 pour 944,61 euros i_strcpy(pt_MTHT2,pt_temp) SI i_strlen(pt_temp) < 3 ALORS erreur = i_format_str2( pt_MTHT2, "%s%s","000",pt_temp ) i_get_sub_str (pt_MTHT2, -3, -1,pt_MTHT2) FINSI # Calcul du montant HT arrondi tronque au centieme d'euro (2 decimales) i_strcpy(pt_temp,pt_MTHTDOM) SI i_strlen(pt_temp) < 6 ALORS erreur = i_format_str2( pt_ValEntier, "%s%s","000000",pt_temp ) i_get_sub_str (pt_ValEntier, -6, -1,pt_temp) FINSI # on fait l'arrondi par ajout de 500 puis troncature au centieme d'euro erreur = i_largeIntegersAdd (pt_temp, 255, "500", 255) i_get_sub_str (pt_temp, 0, -4,pt_temp) # Montant HT arrondi en centieme d'euro exemple : TTC = 1025,63000 euros, HT = 94461 pour 944,61 euros i_strcpy(pt_MTHT1,pt_temp) SI i_strlen(pt_temp) < 3 ALORS erreur = i_format_str2( pt_MTHT1, "%s%s","00",pt_temp ) i_get_sub_str (pt_MTHT1, -3, -1,pt_MTHT1) FINSI #trace2(" ############# pt_MTHT1 arrondi = >%s< ###### pt_MTHT2 non arrondi = >%s< #######",pt_MTHT1,pt_MTHT2) # Recalcul du montant TTC a partir du montant HT arrondi en centieme d'euro i_strcpy(pt_temp,pt_MTHT1) erreur = i_largeIntegersMultiply (pt_temp, 255, pt_MntCoefTVA, 255) erreur = i_largeIntegersAdd (pt_temp, 255, "500", 255) i_strcpy(pt_MntTTC2,pt_temp) # 12/02/2014 - DRE - G4R5 QC791 Mise en forme pt_MntTTC (meme nombre de caractere que pt_MntTTC2) pour comparaison des chaines SI i_strlen(pt_MntTTC) < i_strlen(pt_MntTTC2) ALORS erreur = i_format_str2( pt_temp, "%s%s", "0",pt_MntTTC ) i_strcpy(pt_MntTTC,pt_temp) FINSI i_get_sub_str (pt_MntTTC2, 0, -4,pt_MntTTC2) i_get_sub_str (pt_MntTTC, 0, -4,pt_MntTTC) #trace2(" #-#-#-#-#-#-#-# pt_MntTTC2 apres = >%s< ###### pt_MntTTC = >%s< #-#-#-#-#-#-#-#",pt_MntTTC2,pt_MntTTC) # La difference entre les 2 montants TTC se fait par comparaison des 2 chaines # si le resultat est negatif, on renvoie le monatnt HT NON ARRONDI # sinon on renvoie le monant HT ARRONDI VAL = i_strcmp(pt_MntTTC, pt_MntTTC2) #trace1("############# VAL = %d #############",VAL) SI VAL < 0 ALORS i_strcpy(pt_MTHT,pt_MTHT2) SINON i_strcpy(pt_MTHT,pt_MTHT1) FINSI # Formatage et Stockage dans le parametre de sortie MTHTDOM (format : 123456,12345 ou 123456.12345) i_strcpy(pt_temp,pt_MTHTDOM) # DRE - G4R5 QC791 Bug calcul Price_HT formatage pour valeur inferieure a 1 euro SI i_strlen(pt_temp) < 6 ALORS erreur = i_format_str2( pt_ValEntier, "%s%s","000000",pt_temp ) i_get_sub_str (pt_ValEntier, -6, -1,pt_temp) FINSI i_get_sub_str (pt_temp, 0, -6,pt_ValEntier) i_get_sub_str (pt_temp, -5, -1,pt_ValDec) erreur = i_format_str2( pt_temp, "%s%s", pt_ValEntier,pt_Separateur ) erreur = i_format_str2( pt_MTHTDOM, "%s%s", pt_temp,pt_ValDec ) RETOUR pt_MTHT FIN_FONCTION #--------------------------------------------------------------------------------------- # # FONCTION: Recherche d'une sous-chaine de caractere(s)(pt_chaine2) dans une chaine (pt_chaine1) # # DESCRIPTION: # cette fonction recherche partir de la gauche une sous-chaine dans une chaine # et retourne sa position # # PARAMETRES: # pt_chaine1 chaine de recherche # pt_chaine2 sous-chaine a rechercher # # RETOUR: # Entier # la position, dans la chaine, du premier caractere, de la sous-chaine de caractere(s) recherchee # -longueur de la chaine si la chaine ne contient pas la sous-chaine de caractere(s) recherchee. #--------------------------------------------------------------------------------------- FONCTION ENTIER RECHERCHE_CHAINE(POINTEUR pt_chaine1, POINTEUR pt_chaine2) REGISTRE ENTIER long1 REGISTRE ENTIER long2 REGISTRE ENTIER ind1 REGISTRE ENTIER RESULTAT REGISTRE POINTEUR pt_Ch_ext DEBUT_FONCTION pt_Ch_ext = "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\ BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" i_strcpy(pt_Ch_ext,"") long1 = i_strlen(pt_chaine1) long2 = i_strlen(pt_chaine2) ind1 = 0 RESULTAT = long1 * -1 SI ( long2 > long1 ) || ( long2 < 1 ) ALORS SAUT FIN_RECHERCHE_CHAINE FINSI POINT BOUCLE_RECHERCHE SI ( ind1 < long1 ) ALORS i_get_sub_str(pt_chaine1, ind1, ind1 + long2 - 1, pt_Ch_ext) SI i_strcmp(pt_Ch_ext, pt_chaine2) == 0 ALORS RESULTAT = ind1 SINON ind1 = ind1 + 1 SAUT BOUCLE_RECHERCHE FINSI FINSI POINT FIN_RECHERCHE_CHAINE RETOUR RESULTAT FIN_FONCTION ########################################################################################### FONCTION POINTEUR rechercheDicho(POINTEUR cle,POINTEUR Table_Externe ,ENTIER date_art) ############################################################################ # # Nom du fichier: rechercheDicho # # Fonction: # Recherche dichotomique de la valeur correspondante a la cle # dans la table externe # # En entree : # cle # Table_Externe # date_art # # En sortie: # si OK : pt_valeur # Erreur : g_inull # ############################################################################ # 23/03/2011 Creation DRE ############################################################################ #------------------------------------------------------------------------------------ #nombre de valeur dans la table REGISTRE ENTIER nb_entree #indice de debut REGISTRE ENTIER id #indice de fin REGISTRE ENTIER ifin #indice de milieu REGISTRE ENTIER im #different de 0 tant que la valeur "cle" n'aura pas ete trouvee REGISTRE ENTIER trouve REGISTRE ENTIER erreur #REGISTRE ENTIER NbCycle REGISTRE POINTEUR pt_cle REGISTRE POINTEUR pt_valeur REGISTRE POINTEUR pt_clevaleur REGISTRE POINTEUR pt_Buffer DEBUT_FONCTION #Allocation des pointeurs pt_cle = "pt_clept_cle01234567890123456789-01234567890123456" pt_valeur = "pt_valeurpt_valeur012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901" pt_Buffer = "pt_Bufferpt_Buffer01234567890123456789-01234567890123456789;012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456" pt_clevaleur = "pt_clevaleurpt_clevaleur01234567890123456789-01234567890123456789;0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234" #Initialisation des variables #NbCycle = 0 trouve = -1 id = 0 #Recherce du nombre d'occurence de la table externe nb_entree = i_get_tab_nb_entries(Table_Externe,date_art) ifin = nb_entree - 1 #Initialisation des pointeurs i_strcpy(pt_cle,g_inull) i_strcpy(pt_valeur,g_inull) i_strcpy(pt_clevaleur,g_inull) i_strcpy(pt_Buffer,g_inull) #boucle de recherche POINT Boucle_rechercheDicho SI(trouve != 0 && ((ifin - id) >= 0)) ALORS # NbCycle = NbCycle + 1 #on determine l'indice de milieu im = (id + ifin)/2 erreur=i_get_tab_one_entry (Table_Externe,date_art,im,pt_Buffer) #on ajoute un ';' pour facilit? l'utilisation de 'i_recupererValeur' erreur=i_format_str2(pt_clevaleur,"%s%s",pt_Buffer,";") erreur=i_recupererValeur(pt_clevaleur,pt_cle,i_strlen(pt_clevaleur),';') trouve = i_strplcmp ( cle, pt_cle, 0, i_strlen(pt_cle)) SI trouve < 0 ALORS ifin = im - 1 SINON id = im + 1 FINSI SAUT Boucle_rechercheDicho FINSI #FIN Boucle_rechercheDicho #trace1("Nombre de cycle de recherche = %d ", NbCycle) SI trouve == 0 ALORS erreur=i_recupererValeur(pt_clevaleur,pt_valeur,i_strlen(pt_clevaleur),';') #trace2 ("valeur associee a <%s> : <%s>", cle, pt_valeur) RETOUR pt_valeur SINON #trace("cle non trouvee dans la table externe") RETOUR 0 FINSI FIN_FONCTION #------------------------------------------------------------------------------------------------------------------ # # FONCTION : table_exp # # PARAMETRES: # cle de type POINTEUR # Table_externe de type POINTEUR # date_art de type ENTIER # RETOUR: # POINTEUR #--------------------------------------------------- FONCTION POINTEUR table_exp(POINTEUR cle,POINTEUR Table_Externe ,ENTIER date_art) #FONCTION ENTIER table_exp(POINTEUR cle,POINTEUR Table_Externe ,ENTIER date_art) ############################################################################ # # Nom du fichier: table_exp_reg # # Fonction: # Recupere la valeur correspondante a la cle (valeur reguliere) # trouvee dans la table externe Prefixe_Portabilite # # En entree : # cle # Table_Externe # date_art # # En sortie: # si OK : pt_valeur # Erreur : g_inull # ############################################################################ # 14/09/2006 FO1965 core ############################################################################ #------------------------------------------------------------------------------------ REGISTRE ENTIER nb_entree REGISTRE ENTIER indice REGISTRE ENTIER erreur REGISTRE ENTIER res REGISTRE ENTIER pos_sep REGISTRE ENTIER caract REGISTRE ENTIER longueur REGISTRE POINTEUR pt_cle REGISTRE POINTEUR pt_valeur REGISTRE POINTEUR pt_clevaleur DEBUT_FONCTION #-initialisation des variables pt_cle="01234567890123456789-01234567890123456789" pt_valeur="01234567890123456789" pt_clevaleur="01234567890123456789-01234567890123456789;01234567890123456789" indice=0 longueur=0 #-- recuperer le nombre d entree dans la table exterbe Table_Externe nb_entree=i_get_tab_nb_entries(Table_Externe,date_art) #trace1(" nb entree de la table est :<%d>",nb_entree) # Pour chaque entree SI(nb_entree==0) ALORS trace("Pas de valeur dans la table") RETOUR 0 FINSI indice=0 POINT BOUCLE_NB_ENTRY erreur=i_get_tab_one_entry (Table_Externe,date_art,indice,pt_clevaleur) SI(!i_strcmp(pt_clevaleur,g_inull)) ALORS #cle non trouve EOF table externe trace("EOF table externe") RETOUR 0 FINSI # Appel a la fonction i_recuperValeur pour extraire la cle et la valeur erreur=i_recupererValeur(pt_clevaleur,pt_cle,42,';') SI(erreur!=0) ALORS trace("Erreur fonction i_recupererValeur") RETOUR 0 FINSI longueur = i_strlen(pt_cle) erreur=i_recupererValeur(pt_clevaleur,pt_valeur,21,';') SI(erreur!=0) ALORS trace("Erreur fonction i_recupererValeur") RETOUR 0 FINSI SI ( i_strplcmp ( cle, pt_cle, 0, longueur) == 0 ) ALORS #trace2 ("valeur associee a <%s> : <%s>", pt_valeur, pt_resultat) RETOUR pt_valeur FINSI indice=indice+1 SI(indice long1 ) || ( long2 < 1 ) ALORS SAUT FIN_REMPLACE_CHAINE FINSI POINT BOUCLE_REMPLACE_CHAINE SI ( ind1 < long1) ALORS i_get_sub_str(pt_Chaine, ind1, ind1 + long2 - 1, pt_Ch_ext) SI i_strcmp(pt_Ch_ext, pt_chaine2) == 0 ALORS i_strcpy(pt_Ch_ext,"") SI ind1 > 0 ALORS i_get_sub_str(pt_Chaine, 0, ind1 - 1 , pt_Ch_ext) FINSI erreur = i_format_str2( pt_temp, "%s%s", pt_Ch_ext, pt_chaine3 ) i_get_sub_str(pt_Chaine, ind1 + long2, -1 , pt_Ch_ext) erreur = i_format_str2( pt_Chaine, "%s%s", pt_temp, pt_Ch_ext ) long1 = i_strlen(pt_Chaine) ind1 = ind1 + long3 SINON ind1 = ind1 + 1 FINSI SAUT BOUCLE_REMPLACE_CHAINE FINSI POINT FIN_REMPLACE_CHAINE RETOUR pt_Chaine FIN_FONCTION ############################################################################ # # FONCTION: affectation_tab # # DESCRIPTION: # # PARAMETRES: # artobj de type ARTOBJ # ic_champ de type ENTIER # alphanum de type POINTEUR # # RETOUR: # ENTIER # # HISTORIQUE # 14/09/05 -FAL/DRE- FO1406 Retour Fonction i_LireInfoECC (doit etre != et non >) #--------------------------------------------------- FONCTION ENTIER affectation_tab(ARTOBJ artobj, ENTIER ic_champ, POINTEUR alphanum) ############################################################################ # # nom du fichier: affectation_tab.src # affecte element par element un champ de type tableau au format DCB (dont l indice est passe en entree), # par des elements constituant la variable pointeur passe en entree. # Pour savoir quels elements alphanumeriques sont convertis, se reporter a la fonction conversion2. # La longueur de la variable pointeur ne doit pas depasser la taille maximale autorisee du champ. # Retourne le NB elements du tableau initialises. # Retourne 0 si aucune affectation n a ete faite. # ############################################################################ REGISTRE POINTEUR p_val REGISTRE ENTIER erreur REGISTRE ENTIER indice REGISTRE ENTIER digit REGISTRE ENTIER longueur DEBUT_FONCTION p_val="1234567890123456789012345" indice=0 trace("Appel affectation_tab") trace2("chaine passee = <%s>", alphanum, "") # Longueur de la chaine: longueur=i_strlen(alphanum) trace1("Longueur de la chaine passee: <%d>", longueur) # Bourrage possible avec "F": SI (longueur % 2) ALORS trace("Nb octets impair, bourrage avec F") erreur=i_format_str2(alphanum,"%s%s",alphanum,"F") longueur=longueur+1 FINSI trace2("chaine apres bourrage = <%s>", alphanum, "") POINT BOUCLE i_get_sub_str(alphanum,indice,indice,p_val) digit=conversion2(p_val) erreur=i_set_art_fieldtab(artobj,ic_champ,indice,digit) trace1("index <%d>",indice) trace2("chaine = <%s>",p_val,"") trace1("DCB = <%d>", digit) indice=indice+1 SI (indice>=longueur) ALORS SAUT TAILLE_MAX FINSI SAUT BOUCLE POINT TAILLE_MAX trace1("Nb elements du tableau: <%d>",longueur) RETOUR longueur FIN_FONCTION #--------------------------------------------------- # # FONCTION: conversion2 # # DESCRIPTION: # # PARAMETRES: # alphanum de type POINTEUR # # RETOUR: # ENTIER #--------------------------------------------------- FONCTION ENTIER conversion2(POINTEUR alphanum) ############################################################################ # # nom du fichier: conversion2.src # Retourne la valeur numerique DCB correspondante a la valeur alphanumerique d un digit en entree # ENTIER num = conversion( POINTEUR alphanum) # SI la valeur alphanumerique = "*" alors la valeur numerique DCB correspondante = 0xB # SI la valeur alphanumerique != "*" et !="1" et !="2" ... et !="9" alors la valeur numerique DCB correspondante = 0xF # ############################################################################ #--------------------------------------------------------------------------- # VARIABLES LOCALES #--------------------------------------------------------------------------- REGISTRE ENTIER num # # recuperation des valeurs d'entree # DEBUT_FONCTION SI !(i_strcmp(alphanum,"0")) ALORS num=0 SINON SI !(i_strcmp(alphanum,"1")) ALORS num=1 SINON SI !(i_strcmp(alphanum,"2")) ALORS num=2 SINON SI !(i_strcmp(alphanum,"3")) ALORS num=3 SINON SI !(i_strcmp(alphanum,"4")) ALORS num=4 SINON SI !(i_strcmp(alphanum,"5")) ALORS num=5 SINON SI !(i_strcmp(alphanum,"6")) ALORS num=6 SINON SI !(i_strcmp(alphanum,"7")) ALORS num=7 SINON SI !(i_strcmp(alphanum,"8")) ALORS num=8 SINON SI !(i_strcmp(alphanum,"9")) ALORS num=9 SINON SI !(i_strcmp(alphanum,"*")) ALORS num=0xB SINON num=0xF FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI RETOUR num FIN_FONCTION #--------------------------------------------------- # # FONCTION: conversion # # DESCRIPTION: # # PARAMETRES: # num_digit de type ENTIER # # RETOUR: # POINTEUR #--------------------------------------------------- FONCTION POINTEUR conversion(ENTIER num_digit) ############################################################################ # # nom du fichier: conversion.src # Retourne la valeur alphanumerique correspondante a la valeur numerique en entree # Specifique aux valeurs numerique correspondant aux elements d un tableau dont le contenu est un numero de tel # # POINTEUR alpha_num_digit = conversion( ENTIER num_digit) # ############################################################################ #--------------------------------------------------------------------------- # VARIABLES LOCALES #--------------------------------------------------------------------------- REGISTRE POINTEUR alpha_num_digit # # recuperation des valeurs d'entree # DEBUT_FONCTION SI (num_digit == 0x0) ALORS alpha_num_digit="0" SINON SI (num_digit == 1) ALORS alpha_num_digit="1" SINON SI (num_digit == 2) ALORS alpha_num_digit="2" SINON SI (num_digit == 3) ALORS alpha_num_digit="3" SINON SI (num_digit == 4) ALORS alpha_num_digit="4" SINON SI (num_digit == 5) ALORS alpha_num_digit="5" SINON SI (num_digit == 6) ALORS alpha_num_digit="6" SINON SI (num_digit == 7) ALORS alpha_num_digit="7" SINON SI (num_digit == 8) ALORS alpha_num_digit="8" SINON SI (num_digit == 9) ALORS alpha_num_digit="9" SINON SI (num_digit == 0xB) ALORS alpha_num_digit="*" SINON alpha_num_digit="F" FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI RETOUR alpha_num_digit FIN_FONCTION #--------------------------------------------------- # # FONCTION: Normalisation_Num # # DESCRIPTION: # # PARAMETRES: # ic_num_demande12 de type ENTIER # # RETOUR: # POINTEUR #--------------------------------------------------- FONCTION POINTEUR Normalisation_Num(ENTIER ic_num_demande12) ############################################################################ # # Nom du fichier: Normalisation_Num.src # # Fonction de normalisation du numero demande pour le 12. # LE RETOUR EST "F" EN CAS D ERREUR # # POINTEUR NUM_DEMANDE = Normalisation_Num( ic_num_demande12 ) # # 28/09/2001 Creation # Version : 00.00 # # 14/02/2002 Utilisation des automates de normalisation # avec g_icopo ( LRA - FOEX326 ). ############################################################################ #--------------------------------------------------------------------------- # VARIABLES #--------------------------------------------------------------------------- REGISTRE ENTIER erreur REGISTRE POINTEUR NORM_DEMANDE # Indices fixes TrtcNdc et Tcopo DEFINITION ic_num_demandeCOPO 6 DEFINITION ic_num_demandeur12 28 DEFINITION ic_num_demandeurCOPO 5 #--------------------------------------------------------------------------- # DEBUT DES TRAITEMENTS #--------------------------------------------------------------------------- DEBUT_FONCTION trace("APPEL Normalisation_Num pour le 12") # Initialisation pointeur NORM_DEMANDE = "112233445566778899112212345" # Normalisation erreur = i_normal( g_iartin,ic_num_demandeur12,ic_num_demande12,g_icopo,ic_num_demandeurCOPO,ic_num_demandeCOPO,3,"ATL_NDEUR3","ATL_ZN_NDE2+" ) SI (erreur<0) ALORS trace("Retour en erreur de la fonction de normalisation") erreur = i_PlvMessEmettre( 8500, 0, g_iartin,"", 3, "Normalisation_num", "i_normal", g_ieec ) RETOUR "F" FINSI # Recuperation du numero demande normalise NORM_DEMANDE = i_get_art_fieldptr( g_icopo,ic_num_demandeCOPO ) #trace2("i_get_art_fieldptr = <<%s>>",NORM_DEMANDE,"" ) RETOUR NORM_DEMANDE #--------------------------------------------------------------------------- # FIN DES TRAITEMENTS #--------------------------------------------------------------------------- FIN_FONCTION #--------------------------------------------------- # # FONCTION: OP_CSV # # DESCRIPTION: # # PARAMETRES: # Service de type POINTEUR # Num de type POINTEUR # date_pivot de type ENTIER # # RETOUR: # POINTEUR #--------------------------------------------------- FONCTION POINTEUR OP_CSV(POINTEUR Service, POINTEUR Num, ENTIER date_pivot) ############################################################################ # # Nom du fichier: OP_CSV.src # # Fonction: # Recupere la valeur du champ OP_CSV dans une table externe # # En entree : # Service # Num # # En sortie: # si OK : OP_CSV (1 caractere) # Erreur : g_inull # ############################################################################ # 14/09/2006 FO1965 core ############################################################################ REGISTRE POINTEUR Cle REGISTRE POINTEUR valeur REGISTRE ENTIER erreur REGISTRE POINTEUR res # # Recuperation des arguments en entree # DEBUT_FONCTION #FO1965 Cle = "123456789012345" #FO1965 valeur = "12305612345" #FO1965 res = "11111112345" Cle = "OPCLEOPCLEOPCLEOPCLEOPCLEOPCLEOPCLEOPCLEOPCLEOPCLEOPCLEOPCLEOPCLEOPCLEOPCLE" valeur = "OPVALOPVALOPVALOPVALOPVALOPVALOPVALOPVALOPVALOPVAL" res = "OPRESOPRES" #FO1965 i_strcpy(Cle,"") i_strcpy(valeur,"") i_strcpy(res,"") #trace1("date_pivot: <%u>", date_pivot) #trace2("Service: <%s>", Service,"") #trace2("Num: <%s>", Num,"") # # Concatenation de Service et Num pour former la cle # erreur = i_format_str2(Cle,"%s%s",Service,Num) #trace2("Cle: <%s>", Cle,"") # # Recherche dans la table externe, de la valeur correspondante a la cle # valeur = i_get_tab_field( "csv", date_pivot, Cle ) SI( valeur == g_inull ) ALORS # trace2( "ERREUR: cle <%s> non trouve dans la table externe csv", Cle,"" ) RETOUR 0 FINSI #trace2("Valeur trouvee: <%s> : %s", valeur, "") # # Recuperation du 1er caractere de la valeur trouvee pour former OP_CSV # i_get_sub_str( valeur, 0, 0, res ) #trace2("OP_CSV: <%s> : %s", res, "") RETOUR res FIN_FONCTION #--------------------------------------------------- # # FONCTION: ConvTransgrp # # DESCRIPTION: # # PARAMETRES: # ic_entree de type ENTIER # article de type ARTOBJ # ic_sortie de type ENTIER # # RETOUR: # ENTIER #--------------------------------------------------- FONCTION ENTIER ConvTransgrp(ENTIER ic_entree, ARTOBJ article, ENTIER ic_sortie) ########################################################################### # Fonction ConvTransgrp # # # # FONCTION DE CONVERSION TRANSGROUPE POUR LE CHAMP # # DEDE_NUM DE g_iartin : # # # ########################################################################### # nom du fichier: ConvTransgrp.src # # # # ENTIER retour = ConvTransgrp( ENTIER indice du champ en entree # # ARTOBJ artobj de sortie # # ENTIER indice du champ en sortie ) # # retour=0 => OK # # retour=1 => NOK # # # # Plages des valeurs de DEDE_NUM: # # # # ****** => *31*#9 DEDE_NUM = DEDE_NUM # # *31*0* => *31*09 # # *31*10 => *31*99 DEDE_NUM = DEDE_NUM # # *31#** => #99999 DEDE_NUM = DEDE_NUM # # 0***** => 0*31*# # # 0*31*0 # # 0*31*1 => 0*31*9 DEDE_NUM = DEDE_NUM # # 0*31#* => 03172# DEDE_NUM = DEDE_NUM(2,n) # # 0*31#* => 03651# DEDE_NUM = DEDE_NUM(2,n) # # 031720 DEDE_NUM = 3172+DEDE_NUM(7,n) # # 036510 DEDE_NUM = 3651+DEDE_NUM(7,n) # # 036511 => 036519 DEDE_NUM = DEDE_NUM # # 031721 => 031729 DEDE_NUM = DEDE_NUM # # 03652* => 099999 # # 1***** => 999999 DEDE_NUM = DEDE_NUM # # # # Creation: LRA - 28/05/2001 # # # # LRA - 25/07/2001 # # Ajout de la transformation des caracteres alphanumeriques # # A, B, C => A, *, # # # # # Modif. : LRA - 05/02/2002 FOEX341 # # 17/05/2013 DRE G4R3 lot2 + 19/06/2013 G4R3 QC731 # # Plage 0*31#* => 03172# # # Cas 031720 # # Plage 031721 => 031729 # ########################################################################### #--------------------------------------------------------------------------- # CONSTANTES LOCALES #--------------------------------------------------------------------------- DEFINITION OK 0 DEFINITION NOK 1 #--------------------------------------------------------------------------- # VARIABLES LOCALES #--------------------------------------------------------------------------- REGISTRE POINTEUR pt_dede REGISTRE ENTIER dede0 REGISTRE ENTIER dede1 REGISTRE ENTIER dede2 REGISTRE ENTIER dede3 REGISTRE ENTIER dede4 REGISTRE ENTIER dede5 REGISTRE ENTIER res REGISTRE ENTIER bornSup REGISTRE ENTIER bornInf REGISTRE ENTIER pas_de_modif #--------------------------------------------------------------------------- # DEBUT DES TRAITEMENTS #--------------------------------------------------------------------------- #trace("Debut de ConvTransgrp") # Recuperation de l'artobj # Allocation DEBUT_FONCTION pt_dede="01234567890123456789012345612345" # Recuperation des valeurs de DEDE_NUM dede0=i_get_art_fieldtab(g_iartin,ic_entree,0) dede1=i_get_art_fieldtab(g_iartin,ic_entree,1) dede2=i_get_art_fieldtab(g_iartin,ic_entree,2) dede3=i_get_art_fieldtab(g_iartin,ic_entree,3) dede4=i_get_art_fieldtab(g_iartin,ic_entree,4) dede5=i_get_art_fieldtab(g_iartin,ic_entree,5) #trace("AVANT =>") #trace1("dede0=<%d>",dede0) #trace1("dede1=<%d>",dede1) #trace1("dede2=<%d>",dede2) #trace1("dede3=<%d>",dede3) #trace1("dede4=<%d>",dede4) #trace1("dede5=<%d>",dede5) # Initialisations bornSup=NOK bornInf=NOK pas_de_modif=NOK ## Plage *31*0* => *31*09 SI ( (dede0==0xB)&&(dede1==0x3)&&(dede2==0x1)&&(dede3==0xB)&&(dede4==0x0) ) ALORS SI ( (dede5==0xB)||(dede5==0xC)||(dede5<=0x9) ) ALORS #res = i_supp_quart_num(ic_entree,4,2,0x0f,g_iartin,g_iartout8) #SI (res!=2) res = i_supp_quart_num(ic_entree,4,1,0x0f,g_iartin,g_iartout8) SI (res!=1) ALORS # trace1("Retour i_supp_quart_num: <%d>",res) SAUT FONC_NOK FINSI SAUT FONC_OK FINSI FINSI ## Plage 0***** => 0*31*# SI ( (dede0==0x0)&&(dede1==0xB) ) ALORS SI ( (dede2==0xB)||(dede2==0xC)||(dede2<0x3) ) ALORS #res = i_supp_quart_num(ic_entree,0,2,0x0f,g_iartin,g_iartout8) #SI (res!=2) res = i_supp_quart_num(ic_entree,0,1,0x0f,g_iartin,g_iartout8) SI (res!=1) ALORS # trace1("Retour i_supp_quart_num: <%d>",res) SAUT FONC_NOK FINSI SAUT FONC_OK FINSI # Gestion de la borne sup. uniquement SI (dede2==0x3) ALORS SI ( (dede3==0xB)||(dede3==0xC)||(dede3<0x1) ) ALORS bornSup=OK FINSI SI (dede3==0x1) ALORS SI ( (dede4==0xB)&&( (dede5==0xB)||(dede5==0xC) ) ) ALORS bornSup=OK FINSI FINSI FINSI SI ( bornSup==OK) ALORS #res = i_supp_quart_num(ic_entree,0,2,0x0f,g_iartin,g_iartout8) #SI (res!=2) res = i_supp_quart_num(ic_entree,0,1,0x0f,g_iartin,g_iartout8) SI (res!=1) ALORS # trace1("Retour i_supp_quart_num: <%d>",res) SAUT FONC_NOK FINSI SAUT FONC_OK FINSI FINSI ## Cas 0*31*0 SI ( (dede0==0x0)&&(dede1==0xB)&&(dede2==0x3)&&(dede3==0x1)&&(dede4==0xB)&&(dede5==0x0) ) ALORS #res = i_supp_quart_num(ic_entree,5,2,0x0f,g_iartin,g_iartout9) #SI (res!=2) res = i_supp_quart_num(ic_entree,5,1,0x0f,g_iartin,g_iartout9) SI (res!=1) ALORS # trace1("Retour i_supp_quart_num: <%d>",res) SAUT FONC_NOK FINSI res = i_supp_quart_num(ic_entree,0,1,0x0f,g_iartout9,g_iartout8) SI (res!=1) ALORS # trace1("Retour i_supp_quart_num: <%d>",res) SAUT FONC_NOK FINSI SAUT FONC_OK FINSI #DRE G4R3 lot2 # Plage 0*31#* => 03651# 03172# SI (dede0==0x0) ALORS SI ( (dede1==0xC)||(dede1<0x3) ) ALORS #res = i_supp_quart_num(ic_entree,0,2,0x0f,g_iartin,g_iartout8) #SI (res!=2) res = i_supp_quart_num(ic_entree,0,1,0x0f,g_iartin,g_iartout8) SI (res!=1) ALORS # trace1("Retour i_supp_quart_num: <%d>",res) SAUT FONC_NOK FINSI SAUT FONC_OK FINSI # Gestion de la borne inf. SI (dede1==0xB) ALORS SI ( (dede2>0x3)&&(dede2!=0xB)&&(dede2!=0xC) ) ALORS bornInf=OK FINSI SI (dede2==0x3) ALORS SI ( (dede3>0x1)&&(dede3!=0xB)&&(dede3!=0xC) ) ALORS bornInf=OK FINSI SI (dede3==0x1) ALORS SI ( (dede4>=0x0)&&(dede4!=0xB)&&(dede4!=0xC) ) ALORS bornInf=OK FINSI SI (dede4==0xC) ALORS SI (dede5>=0x0) ALORS bornInf=OK FINSI FINSI FINSI FINSI FINSI # gestion de la borne sup. SI (dede1==0x3) ALORS #DRE QC731 SI ( (dede2==0xB)||(dede2==0xC)||(dede2<0x6) ) SI ( (dede2==0xB)||(dede2==0xC)||(dede2!=0x6 && dede2!=0x1) ) ALORS bornSup=OK FINSI #DRE QC731 SI (dede2==0x6) SI (dede2==0x6 || dede2==0x1) ALORS #DRE QC731 SI ( (dede3==0xB)||(dede3==0xC)||(dede3<0x5) ) SI ( (dede3==0xB)||(dede3==0xC)||(dede3!=0x5 && dede3!=0x7) ) ALORS bornSup=OK FINSI #DRE QC731 SI (dede3==0x5) SI (dede3==0x5 || dede3==0x7) ALORS #DRE QC731 SI ( (dede4==0xB)||(dede4==0xC)||(dede4<0x1) ) SI ( (dede4==0xB)||(dede4==0xC)||(dede4!=0x1 && dede4!=0x2) ) ALORS bornSup=OK FINSI #DRE QC731 SI (dede4==0x1) SI (dede4==0x1 || dede4==0x2) ALORS SI ( (dede5==0xB)||(dede5==0xC) ) ALORS bornSup=OK FINSI FINSI FINSI FINSI FINSI SI ( (bornInf==OK)||(bornSup==OK) ) ALORS #res = i_supp_quart_num(ic_entree,0,2,0x0f,g_iartin,g_iartout8) #SI (res!=2) res = i_supp_quart_num(ic_entree,0,1,0x0f,g_iartin,g_iartout8) SI (res!=1) ALORS # trace1("Retour i_supp_quart_num: <%d>",res) SAUT FONC_NOK FINSI SAUT FONC_OK FINSI FINSI # Cas 031720 SI ( (dede0==0x0)&&(dede1==0x3)&&(dede2==0x1)&&(dede3==0x7)&&(dede4==0x2)&&(dede5==0x0) ) ALORS #res = i_supp_quart_num(ic_entree,5,2,0x0f,g_iartin,g_iartout9) #SI (res!=2) res = i_supp_quart_num(ic_entree,5,1,0x0f,g_iartin,g_iartout9) SI (res!=1) ALORS # trace1("Retour i_supp_quart_num: <%d>",res) SAUT FONC_NOK FINSI res = i_supp_quart_num(ic_entree,0,1,0x0f,g_iartout9,g_iartout8) SI (res!=1) ALORS # trace1("Retour i_supp_quart_num: <%d>",res) SAUT FONC_NOK FINSI SAUT FONC_OK FINSI #\DRE G4R3 lot2 ############ ## Cas 036510 SI ( (dede0==0x0)&&(dede1==0x3)&&(dede2==0x6)&&(dede3==0x5)&&(dede4==0x1)&&(dede5==0x0) ) ALORS #res = i_supp_quart_num(ic_entree,5,2,0x0f,g_iartin,g_iartout9) #SI (res!=2) res = i_supp_quart_num(ic_entree,5,1,0x0f,g_iartin,g_iartout9) SI (res!=1) ALORS # trace1("Retour i_supp_quart_num: <%d>",res) SAUT FONC_NOK FINSI res = i_supp_quart_num(ic_entree,0,1,0x0f,g_iartout9,g_iartout8) SI (res!=1) ALORS # trace1("Retour i_supp_quart_num: <%d>",res) SAUT FONC_NOK FINSI SAUT FONC_OK FINSI ## Plage 03652* => 099999 SI (dede0==0x0) ALORS SI ( (dede1>0x3)&&(dede1<0x9) ) ALORS #res = i_supp_quart_num(ic_entree,0,2,0x0f,g_iartin,g_iartout8) #SI (res!=2) res = i_supp_quart_num(ic_entree,0,1,0x0f,g_iartin,g_iartout8) SI (res!=1) ALORS # trace1("Retour i_supp_quart_num: <%d>",res) SAUT FONC_NOK FINSI SAUT FONC_OK FINSI # Gestion de la borne sup. SI (dede1==0x9) ALORS SI ( (dede2==0xB)||(dede2==0xC)||(dede2<0x9) ) ALORS bornSup=OK FINSI SI (dede2==0x9) ALORS SI ( (dede3==0xB)||(dede3==0xC)||(dede3<0x9) ) ALORS bornSup=OK FINSI SI (dede3==0x9) ALORS SI ( (dede4==0xB)||(dede4==0xC)||(dede4<0x9) ) ALORS bornSup=OK FINSI SI (dede4==0x9) ALORS SI ((dede5==0xB)||(dede5==0xC)||(dede5<=0x9) ) ALORS bornSup=OK FINSI FINSI FINSI FINSI FINSI # Gestion de la borne inf. SI (dede1==0x3) ALORS SI ( (dede2>0x6)&&(dede2!=0xB)&&(dede2!=0xC) ) ALORS bornInf=OK FINSI SI (dede2==0x6) ALORS SI ( (dede3>0x5)&&(dede3!=0xB)&&(dede3!=0xC) ) ALORS bornInf=OK FINSI SI (dede3==0x5) ALORS SI ( (dede4>0x2)&&(dede4!=0xB)&&(dede4!=0xC) ) ALORS bornInf=OK FINSI SI (dede4==0x2) ALORS SI (dede5>=0) ALORS bornInf=OK FINSI FINSI FINSI FINSI FINSI SI ( (bornInf==OK)||(bornSup==OK) ) ALORS #res = i_supp_quart_num(ic_entree,0,2,0x0f,g_iartin,g_iartout8) #SI (res!=2) res = i_supp_quart_num(ic_entree,0,1,0x0f,g_iartin,g_iartout8) SI (res!=1) ALORS # trace1("Retour i_supp_quart_num: <%d>",res) SAUT FONC_NOK FINSI SAUT FONC_OK FINSI FINSI # Cas ou le numero n est pas modifie: # plages => ****** => *31*#9 # *31*10 => *31*99 # *31#** => #99999 # 0*31*1 => 0*31*9 # 036511 => 036519 #DRE G4R3 lot2 # 031721 => 031729 # 1***** => 999999 # #trace("Pas de modification de DEDE_NUM !") pas_de_modif=OK # Retour OK de la fonction POINT FONC_OK #trace(g_iartin!NOM[]) #trace(article!NOM[]) #trace1("ic_entree=<%d>",ic_entree) #trace1("ic_sortie=<%d>",ic_sortie) SI (pas_de_modif==OK) ALORS res=i_get_art_str(g_iartin,ic_entree,pt_dede) SINON res=i_get_art_str(g_iartout8,ic_entree,pt_dede) FINSI i_replace_str(pt_dede,"ABC","A*#",pt_dede) res=i_set_art_str(article,ic_sortie,pt_dede) #trace2("DEDE Apres => <<< %s >>>",pt_dede,"") trace("Retour OK de ConvTransgrp") RETOUR OK # Retour NOK de la fonction POINT FONC_NOK trace("Retour NOK de ConvTransgrp") RETOUR NOK #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -# #- - - - - - - - - - - - - - - - - Fin formatage DEDE_NUM - - - - - - - - - - - - - - - - - - - - - - - -# #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -# FIN_FONCTION #--------------------------------------------------- # # FONCTION: C_CSV # # DESCRIPTION: # # PARAMETRES: # Service de type POINTEUR # Num de type POINTEUR # date_pivot de type ENTIER # # RETOUR: # POINTEUR #--------------------------------------------------- FONCTION POINTEUR C_CSV(POINTEUR Service, POINTEUR Num, ENTIER date_pivot) ############################################################################ # # Nom du fichier: C_CSV.src # # Fonction: # Recupere la valeur du champ C_CSV dans une table externe # # En entree : # Service # Num # # En sortie: # si OK : C_CSV (sous forme de chaine de caracteres) # Erreur : g_inull # ############################################################################ # 14/09/2006 FO1965 core ############################################################################ REGISTRE POINTEUR Cle REGISTRE POINTEUR valeur REGISTRE ENTIER erreur REGISTRE POINTEUR res # # Recuperation des arguments en entree # DEBUT_FONCTION #FO1965 Cle = "123456789012345" #FO1965 valeur = "12305612345" #FO1965 res = "11111112345" Cle = "CCLECCLECCLECCLECCLECCLECCLECCLECCLECCLECCLECCLECCLECCLECCLECCLECCLECCLECCLE" valeur = "CVALCVALCVALCVALCVALCVALCVALCVALCVALCVALCVAL" res = "CRESCRES" #FO1965 i_strcpy(Cle,"") i_strcpy(valeur,"") i_strcpy(res,"") #trace1("date_pivot: <%u>", date_pivot) #trace2("Service: <%s>", Service,"") #trace2("Num: <%s>", Num,"") # # Concatenation de Service et Num pour former la cle # erreur = i_format_str2(Cle,"%s%s",Service,Num) #trace2("Cle: <%s>", Cle,"") # # Recherche dans la table externe, de la valeur correspondante a la cle # valeur = i_get_tab_field( "csv", date_pivot, Cle ) SI( valeur == g_inull ) ALORS # trace2( "ERREUR: cle <%s> non trouve dans la table externe csv", Cle, "" ) RETOUR 0 FINSI #trace2("Valeur trouvee: <%s> : %s", valeur, "") # # Retrait du 1er caractere de la valeur trouvee pour former C_CSV # i_get_sub_str( valeur, 1, -1, res) #trace2("C_CSV: <%s> : %s", res, "") RETOUR res FIN_FONCTION #--------------------------------------------------- # # FONCTION: SetChampCsv # # DESCRIPTION: # # PARAMETRES: # artobjout de type ARTOBJ # traude_num de type ENTIER # finser de type ENTIER # ic_c_csv1 de type ENTIER # # RETOUR: # ENTIER #--------------------------------------------------- FONCTION ENTIER SetChampCsv(ARTOBJ artobjout, ENTIER traude_num, ENTIER finser, ENTIER ic_c_csv1) ############################################################################ # # Nom du fichier: SetChampCsv.src # # Fonction: # Mise a jour des champs C_csv et OP_csv # pour l' application FE, TRAFIC, DELTA MINUTE # # En entree : # traude_num : numero du traude # finser : cause de fin de service # ic_c_csv1 : indice du 1er champ C_CSV de l'artobjout # artobjout : article recevoir des mises a jour # # En sortie: # Bon : TRAIT_OK # Erreur : -1 # ############################################################################ REGISTRE ENTIER erreur REGISTRE ENTIER ic_c_csv REGISTRE ENTIER ic_op_csv REGISTRE ENTIER nb_csv_i REGISTRE POINTEUR p_buffer REGISTRE POINTEUR p_octet # # recuperation des valeurs d'entree # DEBUT_FONCTION trace1("distribution - Debut SetChampCsv traude_num %d", traude_num) #trace1("finser %d", finser) #trace1("ic_c_csv1 %d", ic_c_csv1) # # Champ C_CSVi et OP_CSVi ( i = 1 a 5 ) # nb_csv_i = 0 POINT INIT_C_CSV # Initialiser les champs C_CSV et OP_CSV a blanc ( 0x40 format EBCDIC) ic_c_csv = ic_c_csv1 + 2*nb_csv_i ic_op_csv = ic_c_csv + 1 erreur = i_memset_field_n(artobjout, ic_c_csv, 0x40) erreur = i_memset_field_n(artobjout, ic_op_csv, 0x40) SI ( erreur != 0 ) ALORS RETOUR -1 FINSI SI ( traude_num != 1 ) ALORS SI ( ( finser == 0x00 ) || ( finser == 0x01 ) ) ALORS p_buffer = "2" SINON SI ( finser == 0x02 ) ALORS p_buffer = "S" SINON SI ( ( finser == 0x03 ) || ( finser == 0x04 ) ) ALORS p_buffer = "4" SINON p_buffer = " " FINSI FINSI FINSI SI ( ( finser != -1 ) && (finser <= 0x04 ) ) ALORS p_octet = "U" SINON p_octet = " " FINSI ### chaines ASCII ( p_buffer et p_octet ) ### seront stockees dans les champs C_CSVi et OP_CSVi ### conversion de chaine ASCII en chaine EBCDIC SI ( ( i_set_art_str(artobjout, ic_c_csv, p_buffer) != 0 ) || ( i_set_art_str(artobjout, ic_op_csv, p_octet) != 0 ) ) ALORS trace(" Erreur de i_set_art_field OP_CSVi " ) RETOUR -1 FINSI FINSI ### Initialiser un autre C_CSVi nb_csv_i = nb_csv_i + 1 SI ( nb_csv_i < 5 ) ALORS SAUT INIT_C_CSV FINSI RETOUR TRAIT_OK FIN_FONCTION #--------------------------------------------------- # # FONCTION: ChercherAjoutECC # # DESCRIPTION: # # PARAMETRES: # instanceECC de type ENTIER # instCible de type ENTIER # # RETOUR: # ENTIER #--------------------------------------------------- FONCTION ENTIER ChercherAjoutECC(ENTIER instanceECC, ENTIER instCible) ################################################################################ # Module : ChercherAjoutECC.src # # Test de presence de chaque ECC dans les listes "deja alimentee" # et "resultat de la derniere requete" pour construire la liste # courante des destinataires # ################################################################################ # Instances REGISTRE ENTIER res REGISTRE ENTIER valeur REGISTRE ENTIER adresseInfo # # recuperation des valeurs d'entree # DEBUT_FONCTION trace1 ("Debut ChercherAjoutECC : instanceECC %d", instanceECC) SI ( instanceECC > 0 ) ALORS res = 0 SI ( i_ChercherEmiseECC(instanceECC) != 0 ) ALORS ### instance ECC absence de la liste emise adresseInfo = i_LireInfoECC(instanceECC, 0) trace1 ("i_LireInfoECC : adresseInfo %d", adresseInfo) #G2R1Cj_PLUS_FO1406 SI ( adresseInfo > 0 ) SI (adresseInfo != 0) ALORS ### Tests eventuels sur les informations TRAFIC SI ( instCible == 2 ) ALORS # A VERIFIER CHAINE CFR #i_strcpy(CFR, adresse) res = 0 SINON ### Tests eventuels sur les informations complementaires pour VTG SI ( instCible == 1 ) ALORS valeur = i_LireEntierInfo( adresseInfo, 0 ,0 ) FINSI FINSI ### Ajout de l'ECC a la liste courante des destinataires res = i_AjouterCouranteECC(instanceECC) SINON res = -1 FINSI FINSI SINON res = -1 FINSI RETOUR res FIN_FONCTION #--------------------------------------------------- # # FONCTION: CalculTaxe # # DESCRIPTION: # # PARAMETRES: # traude_numero de type ENTIER # reroutage2_type6 de type ENTIER # reroutage3_type6 de type ENTIER # reroutage4_type6 de type ENTIER # reroutage5_type6 de type ENTIER # reroutage6_type6 de type ENTIER # tax_elementaire1 de type ENTIER # tax_elementaire2 de type ENTIER # tax_elementaire3 de type ENTIER # tax_elementaire4 de type ENTIER # tax_elementaire5 de type ENTIER # tax_elementaire6 de type ENTIER # # RETOUR: # ENTIER #--------------------------------------------------- FONCTION ENTIER CalculTaxe(ENTIER traude_numero, ENTIER reroutage2_type6, ENTIER reroutage3_type6, ENTIER reroutage4_type6, ENTIER reroutage5_type6, ENTIER reroutage6_type6, ENTIER tax_elementaire1, ENTIER tax_elementaire2, ENTIER tax_elementaire3, ENTIER tax_elementaire4, ENTIER tax_elementaire5, ENTIER tax_elementaire6) ################################################################################ # Module : CalculTaxe.src # Calculer Taxe ################################################################################ REGISTRE ENTIER tax # codes de rejet DEFINITION VRAI 1 DEFINITION FAUX 0 # # recuperation des valeurs d'entree # DEBUT_FONCTION trace1("Debut CalculTaxe traude_numero %d", traude_numero) ################################################################################### # Taxe calculer a partir du 1 er Traude en fonction de reroutage type6 ################################################################################### SI ( traude_numero == 1 ) ALORS # reroutage toujours faux pour le 1er traude SI( reroutage2_type6 > 0 ) ALORS tax = tax_elementaire1 tax = tax + tax_elementaire2 SI( reroutage3_type6 == FAUX ) ALORS RETOUR tax FINSI tax = tax + tax_elementaire3 SI( reroutage4_type6 == FAUX ) ALORS RETOUR tax FINSI tax = tax + tax_elementaire4 SI( reroutage5_type6 == FAUX ) ALORS RETOUR tax FINSI tax = tax + tax_elementaire5 RETOUR tax SINON tax = tax_elementaire1 RETOUR tax FINSI FINSI ################################################################################### # Taxe calculer a partir du 2eme Traude en fonction de reroutage type6 ################################################################################### SI ( traude_numero == 2 ) ALORS SI ( (reroutage3_type6 > 0 ) && (reroutage2_type6 == FAUX) ) ALORS tax = tax_elementaire2 tax = tax + tax_elementaire3 SI (reroutage4_type6 == FAUX) ALORS RETOUR tax FINSI tax = tax + tax_elementaire4 SI (reroutage5_type6 == FAUX) ALORS RETOUR tax FINSI tax = tax + tax_elementaire5 SI( reroutage6_type6 == FAUX ) ALORS RETOUR tax FINSI tax = tax + tax_elementaire6 RETOUR tax SINON tax = tax_elementaire2 RETOUR tax FINSI FINSI ################################################################################### # Taxe calculer a partir du 3eme Traude en fonction de reroutage type6 ################################################################################### SI ( traude_numero == 3 ) ALORS SI ( (reroutage4_type6 > 0 ) && (reroutage3_type6 == FAUX) ) ALORS tax = tax_elementaire3 tax = tax + tax_elementaire4 SI (reroutage5_type6 == FAUX) ALORS RETOUR tax FINSI tax = tax + tax_elementaire5 SI( reroutage6_type6 == FAUX ) ALORS RETOUR tax FINSI tax = tax + tax_elementaire6 RETOUR tax SINON tax = tax_elementaire3 RETOUR tax FINSI FINSI ################################################################################### # Taxe calculer a partir du 4eme Traude en fonction de reroutage type6 ################################################################################### SI ( traude_numero == 4 ) ALORS SI ( (reroutage5_type6 > 0) && (reroutage4_type6 == FAUX) ) ALORS tax = tax_elementaire4 tax = tax + tax_elementaire5 SI( reroutage6_type6 == FAUX ) ALORS RETOUR tax FINSI tax = tax + tax_elementaire6 RETOUR tax SINON tax = tax_elementaire4 RETOUR tax FINSI FINSI ################################################################################### # Taxee calculer a partir du 5eme Traude en fonction de reroutage type6 ################################################################################### SI ( traude_numero == 5 ) ALORS SI ( (reroutage6_type6 > 0) && (reroutage5_type6 == FAUX) ) ALORS tax = tax + tax_elementaire6 FINSI RETOUR tax SINON # traude_numero == 6 tax = tax_elementaire6 RETOUR tax FINSI FIN_FONCTION #--------------------------------------------------- # # FONCTION: CalculDuree # # DESCRIPTION: # # PARAMETRES: # traude_numero de type ENTIER # reroutage2_type6 de type ENTIER # reroutage3_type6 de type ENTIER # reroutage4_type6 de type ENTIER # reroutage5_type6 de type ENTIER # reroutage6_type6 de type ENTIER # dur_elementaire1 de type ENTIER # dur_elementaire2 de type ENTIER # dur_elementaire3 de type ENTIER # dur_elementaire4 de type ENTIER # dur_elementaire5 de type ENTIER # dur_elementaire6 de type ENTIER # # RETOUR: # ENTIER #--------------------------------------------------- FONCTION ENTIER CalculDuree(ENTIER traude_numero, ENTIER reroutage2_type6, ENTIER reroutage3_type6, ENTIER reroutage4_type6, ENTIER reroutage5_type6, ENTIER reroutage6_type6, ENTIER dur_elementaire1, ENTIER dur_elementaire2, ENTIER dur_elementaire3, ENTIER dur_elementaire4, ENTIER dur_elementaire5, ENTIER dur_elementaire6) ################################################################################ # Module : CalculDuree.src # Calculer Duree de TRAUDEi # en fonction de reroutage_type6 et duree elementaire ################################################################################ REGISTRE ENTIER dur # codes de rejet DEFINITION VRAI 1 DEFINITION FAUX 0 # # recuperation des valeurs d'entree # DEBUT_FONCTION trace1("Debut CalculDuree traude_numero %d", traude_numero) ################################################################################### # Duree calculer a partir du 1 er Traude en fonction de reroutage type6 ################################################################################### SI ( traude_numero == 1 ) ALORS # reroutage toujours faux pour le 1er traude SI( reroutage2_type6 > 0 ) ALORS dur = dur_elementaire1 dur = dur + dur_elementaire2 SI( reroutage3_type6 == FAUX ) ALORS RETOUR dur FINSI dur = dur + dur_elementaire3 SI( reroutage4_type6 == FAUX ) ALORS RETOUR dur FINSI dur = dur + dur_elementaire4 SI( reroutage5_type6 == FAUX ) ALORS RETOUR dur FINSI dur = dur + dur_elementaire5 RETOUR dur SINON dur = dur_elementaire1 RETOUR dur FINSI FINSI ################################################################################### # Duree calculer a partir du 2eme Traude en fonction de reroutage type6 ################################################################################### SI ( traude_numero == 2 ) ALORS SI ( (reroutage3_type6 > 0) && (reroutage2_type6 == FAUX) ) ALORS dur = dur_elementaire2 dur = dur + dur_elementaire3 SI (reroutage4_type6 == FAUX) ALORS RETOUR dur FINSI dur = dur + dur_elementaire4 SI (reroutage5_type6 == FAUX) ALORS RETOUR dur FINSI dur = dur + dur_elementaire5 SI( reroutage6_type6 == FAUX ) ALORS RETOUR dur FINSI dur = dur + dur_elementaire6 RETOUR dur SINON dur = dur_elementaire2 RETOUR dur FINSI FINSI ################################################################################### # Duree calculer a partir du 3eme Traude en fonction de reroutage type6 ################################################################################### SI ( traude_numero == 3 ) ALORS SI ( (reroutage4_type6 > 0) && (reroutage3_type6 == FAUX) ) ALORS dur = dur_elementaire3 dur = dur + dur_elementaire4 SI (reroutage5_type6 == FAUX) ALORS RETOUR dur FINSI dur = dur + dur_elementaire5 SI( reroutage6_type6 == FAUX ) ALORS RETOUR dur FINSI dur = dur + dur_elementaire6 RETOUR dur SINON dur = dur_elementaire3 RETOUR dur FINSI FINSI ################################################################################### # Duree calculer a partir du 4eme Traude en fonction de reroutage type6 ################################################################################### SI ( traude_numero == 4 ) ALORS SI ( (reroutage5_type6 > 0) && (reroutage4_type6 == FAUX) ) ALORS dur = dur_elementaire4 dur = dur + dur_elementaire5 SI( reroutage6_type6 == FAUX ) ALORS RETOUR dur FINSI dur = dur + dur_elementaire6 RETOUR dur SINON dur = dur_elementaire4 RETOUR dur FINSI FINSI ################################################################################### # Duree calculer a partir du 5eme Traude en fonction de reroutage type6 ################################################################################### SI ( traude_numero == 5 ) ALORS dur = dur_elementaire5 SI ( (reroutage6_type6 > 0) && (reroutage5_type6 == FAUX) ) ALORS dur = dur + dur_elementaire6 FINSI RETOUR dur SINON # traude_numero == 6 dur = dur_elementaire6 RETOUR dur FINSI FIN_FONCTION #--------------------------------------------------- # # FONCTION: CtrlTraude # # DESCRIPTION: # # PARAMETRES: # artobj de type ARTOBJ # valeur de type ENTIER # # RETOUR: # ENTIER #--------------------------------------------------- FONCTION ENTIER CtrlTraude(ARTOBJ artobj, ENTIER valeur) ################################################################################ # Module : CtrlTraude.src # # controle des champs de NTRE # - de NTRE_NUM evaluation de NTRE_DIST_N possible (Codage DCB, bourrage 0xF) # # controle des champs de DEDE # - des bits EFGH de DEDE_INF ( A B C D E F G H = 0 0 0 0 1 1 1 1 ) = 0x0F # Bits EFGH = 0000 reserve # - de DEDE_NUM evaluation de DEDE_DIST_N possible (Codage DCB, bourrage 0xF) # # Retour: # - TRAIT_OK # - ERR_xxx # - ################################################################################ REGISTRE ENTIER code_erreur REGISTRE ENTIER erreur # indices du champ dede REGISTRE ENTIER ic_dede REGISTRE ENTIER ic_longueur REGISTRE ENTIER ic_dede_inf REGISTRE ENTIER ic_dede_num REGISTRE ENTIER dede_inf REGISTRE ENTIER dede_num_longueur # indices du champ ntre REGISTRE ENTIER ic_ntre REGISTRE ENTIER ic_ntre_num REGISTRE ENTIER ntre_num_longueur # codes de rejet DEFINITION ERR_SYNTAX 1 DEFINITION ERR_SEMANT 2 DEFINITION ERR_EXCLUSIF 3 DEFINITION ERR_TRANSAC 4 # code plus de TRAUDE DEFINITION TRAIT_FIN 100 # # recuperation des valeurs d'entree # DEBUT_FONCTION trace1("distribution - Debut CtrlDede valeur %d", valeur) # code_erreur initialise a 0 (pas d'erreur) code_erreur = TRAIT_OK # # Identifier TRAUDE (de 1 a 6) # SI ( valeur == 1 ) ALORS ############################################################################## # Tester la presence de TRAUDE1 ############################################################################## SI ( i_valid_field( artobj, "T2traude1") ) ALORS # 1er dede (indice du champ dans l'article) ic_dede = i_get_field_num(artobj, "T3dede1" ) ic_ntre = i_get_field_num(artobj, "T3ntre1" ) SINON RETOUR TRAIT_FIN FINSI SINON SI ( valeur == 2 ) ALORS ######################################################################### # Tester la presence de TRAUDE2 ######################################################################### SI ( i_valid_field( artobj, "T2traude2") ) ALORS # 2e dede (indice du champ dans l'article) ic_dede = i_get_field_num(artobj, "T3dede2" ) ic_ntre = i_get_field_num(artobj, "T3ntre2" ) SINON RETOUR TRAIT_FIN FINSI SINON SI ( valeur == 3 ) ALORS #################################################################### # Tester la presence de TRAUDE3 #################################################################### SI ( i_valid_field( artobj, "T2traude3") ) ALORS # 3e dede (indice du champ dans l'article) ic_dede = i_get_field_num(artobj, "T3dede3" ) ic_ntre = i_get_field_num(artobj, "T3ntre3" ) SINON RETOUR TRAIT_FIN FINSI SINON SI ( valeur == 4 ) ALORS ############################################################### # Tester la presence de TRAUDE4 ############################################################### SI ( i_valid_field( artobj, "T2traude4") ) ALORS # 4e dede (indice du champ dans l'article) ic_dede = i_get_field_num(artobj, "T3dede4" ) ic_ntre = i_get_field_num(artobj, "T3ntre4" ) SINON RETOUR TRAIT_FIN FINSI SINON SI ( valeur == 5 ) ALORS ########################################################## # Tester la presence de TRAUDE5 ########################################################## SI ( i_valid_field( artobj, "T2traude5") ) ALORS # 5e dede (indice du champ dans l'article) ic_dede = i_get_field_num(artobj, "T3dede5" ) ic_ntre = i_get_field_num(artobj, "T3ntre5" ) SINON RETOUR TRAIT_FIN FINSI SINON ########################################################## # Tester la presence de TRAUDE6 ########################################################## SI ( i_valid_field( artobj, "T2traude6") ) ALORS # 6e dede (indice du champ dans l'article) ic_dede = i_get_field_num(artobj, "T3dede6" ) ic_ntre = i_get_field_num(artobj, "T3ntre6" ) SINON RETOUR TRAIT_FIN FINSI FINSI FINSI FINSI FINSI FINSI ################################################################################### # Tester l'existence de DEDE - Type (T3 L3) ################################################################################### SI ( ic_dede != -1 ) ALORS ic_longueur = ic_dede + 1 ic_dede_inf = ic_dede + 2 ic_dede_num = ic_dede + 3 dede_num_longueur = i_get_art_field(artobj, ic_longueur) # longueur reelle de dede_num dede_num_longueur = dede_num_longueur - 1 ############################################################################## # Tester la validation de DEDE_INF nature de service - Type numerique ############################################################################## dede_inf = i_get_art_field(artobj, ic_dede_inf) SI ((dede_inf & 0x0F) != 0x00) ALORS trace1("Codage du champs TRAUDE%d/DEDE/INF incorrect", valeur) erreur = i_PlvMessEmettre(7502,1,artobj,"",0,0,0,0) code_erreur = ERR_SEMANT SINON ######################################################################### # Evaluation de DEDE_NUM NAS (Codage DCB et bourrage a 0xF) -Type tableau ######################################################################### trace1("Appel CtrlDCB ic_dede_num %d", ic_dede_num) trace1("Appel CtrlDCB dede_num_longueur %d", dede_num_longueur) code_erreur = CtrlDCB(artobj, ic_dede_num, 2*dede_num_longueur, 1) FINSI SI ( code_erreur != TRAIT_OK ) ALORS SAUT FIN_CTRLTRAUDE FINSI FINSI ################################################################################### # Tester validation de NTRE - Type (T3 L3) ################################################################################### SI ( ic_ntre != -1 ) ALORS ic_longueur = ic_ntre + 1 ic_ntre_num = ic_ntre + 3 ntre_num_longueur = i_get_art_field(artobj, ic_longueur) # longueur reelle du champ ntre_num ntre_num_longueur = ntre_num_longueur - 1 code_erreur = CtrlDCB(artobj, ic_ntre_num, 2*ntre_num_longueur, 1) SINON trace("Absence du champs TRAUDE/NTRE !!! Impossible") code_erreur = -1 FINSI POINT FIN_CTRLTRAUDE RETOUR code_erreur FIN_FONCTION #--------------------------------------------------- # # FONCTION: CtrlDede # # DESCRIPTION: # # PARAMETRES: # artobj de type ARTOBJ # valeur de type ENTIER # # RETOUR: # ENTIER #--------------------------------------------------- FONCTION ENTIER CtrlDede(ARTOBJ artobj, ENTIER valeur) ################################################################################ # Module : CtrlDede.src # controle des champs de DEDE # - des bits EFGH de DEDE_INF ( A B C D E F G H = 0 0 0 0 1 1 1 1 ) = 0x0F # Bits EFGH = 0000 reserve # - de DEDE_NUM evaluation de DEDE_DIST_N possible (Codage DCB, bourrage 0xF) ################################################################################ REGISTRE ENTIER code_erreur REGISTRE ENTIER erreur # indices du champ dede REGISTRE ENTIER ic_dede REGISTRE ENTIER ic_longueur REGISTRE ENTIER ic_dede_inf REGISTRE ENTIER ic_dede_num REGISTRE ENTIER dede_inf REGISTRE ENTIER dede_num REGISTRE ENTIER dede_num_longueur # codes de rejet DEFINITION ERR_SYNTAX 1 DEFINITION ERR_SEMANT 2 DEFINITION ERR_EXCLUSIF 3 DEFINITION ERR_TRANSAC 4 # # recuperation des valeurs d'entree # DEBUT_FONCTION trace1("distribution - Debut CtrlDede valeur %d", valeur) # code_erreur initialise a 0 (pas d'erreur) code_erreur = TRAIT_OK # # Identifier DEDE (de 1 a 6) # SI ( valeur == 1 ) ALORS # 1er dede (indice du champ dans l'article) # ic_dede = i_get_field_num(artobj, "T3dede1" ) # SI ( ic_dede != 0 ) # ALORS # RETOUR code_erreur # FINSI ic_dede = 74 SINON SI ( valeur == 2 ) ALORS # 2e dede (indice du champ dans l'article) # ic_dede = i_get_field_num(artobj, "T3dede2") ic_dede = 102 SINON SI ( valeur == 3 ) ALORS # 3e dede (indice du champ dans l'article) # ic_dede = i_get_field_num(artobj, "T3dede3") ic_dede = 130 SINON SI ( valeur == 4 ) ALORS # 4e dede (indice du champ dans l'article) # ic_dede = i_get_field_num(artobj, "T3dede4") ic_dede = 158 SINON SI ( valeur == 5 ) ALORS # 5e dede (indice du champ dans l'article) # ic_dede = i_get_field_num(artobj, "T3dede5") ic_dede = 186 SINON # 6e dede (indice du champ dans l'article) # ic_dede = i_get_field_num(artobj, "T3dede6") ic_dede = 214 FINSI FINSI FINSI FINSI FINSI ################################################################################### # Tester l'existence de DEDE - Type (T3 L3) ################################################################################### SI ( i_valid_field_n( artobj, ic_dede) ) ALORS ic_longueur = ic_dede + 1 ic_dede_inf = ic_dede + 2 ic_dede_num = ic_dede + 3 dede_num_longueur = i_get_art_field(artobj, ic_longueur) # longueur reelle de dede_num dede_num_longueur = dede_num_longueur - 1 ############################################################################## # Tester la validation de DEDE_INF nature de service - Type numerique ############################################################################## dede_inf = i_get_art_field(artobj, ic_dede_inf) SI ((dede_inf & 0x0F) != 0x00) ALORS trace1("Codage du champs TRAUDE%d/DEDE/INF incorrect", valeur) erreur = i_PlvMessEmettre(7502,1,artobj,"",0,0,0,0) code_erreur = ERR_SEMANT SINON ######################################################################### # Evaluation de DEDE_NUM NAS (Codage DCB et bourrage a 0xF) -Type tableau ######################################################################### trace1("Appel CtrlDCB ic_dede_num %d", ic_dede_num) trace1("Appel CtrlDCB dede_num_longueur %d", dede_num_longueur) code_erreur = CtrlDCB(artobj, ic_dede_num, 2*dede_num_longueur, 1) FINSI FINSI RETOUR code_erreur FIN_FONCTION #--------------------------------------------------- # # FONCTION: CtrlDCB # # DESCRIPTION: # # PARAMETRES: # artobj de type ARTOBJ # ic_num de type ENTIER # longueur de type ENTIER # unite de type ENTIER # # RETOUR: # ENTIER #--------------------------------------------------- FONCTION ENTIER CtrlDCB(ARTOBJ artobj, ENTIER ic_num, ENTIER longueur, ENTIER unite) ################################################################################ # Module : CtrlDCB.src # controle des champs de valeur DCB # ################################################################################ REGISTRE ENTIER code_erreur REGISTRE ENTIER erreur # indices du champ dede REGISTRE ENTIER index REGISTRE ENTIER valeur REGISTRE ENTIER valeurHexa REGISTRE ENTIER quartetFort REGISTRE ENTIER quartetFaible # codes de rejet DEFINITION ERR_SYNTAX 1 DEFINITION ERR_SEMANT 2 DEFINITION ERR_EXCLUSIF 3 DEFINITION ERR_TRANSAC 4 DEFINITION UNIT_OCTET 0 # # recuperation des valeurs d'entree # DEBUT_FONCTION trace1("Debut CtrlDCB ic_num %d", ic_num) trace1("Debut CtrlDCB longueur %d", longueur) # code_erreur initialise a 0 (pas d'erreur) code_erreur = TRAIT_OK ################################################################################### # Codage DCB sur un octet ################################################################################### SI ( unite == UNIT_OCTET ) ALORS # # Si ce n'est pas un tableau numerique, la valeur de longueur est # la valeur de l'octet a tester # valeurHexa = i_get_art_field(artobj, ic_num) trace1("Octet valeurHexa %d", valeurHexa) FINSI index = 0 POINT BOUCLE trace1("index %d", index) SI ( index < longueur ) ALORS SI ( unite == UNIT_OCTET ) ALORS valeur = ( ( valeurHexa >> index*8 ) & 0xFF ) trace1("Octet valeur %d", valeur) SINON valeur = i_get_art_fieldtab(artobj, ic_num, index) trace1("DCB valeur %d", valeur) FINSI quartetFort = (valeur & 0xF0) >> 4 quartetFaible = valeur & 0x0F ############################################################################## # Tester quartet de poid fort ############################################################################## SI ( ( quartetFort > 9 ) || ( ( quartetFaible != 0x0F ) && ( quartetFaible > 9 ) ) ) ALORS trace1("Mauvais codage du numero demande %d incorrect", valeur) erreur = i_PlvMessEmettre(7502,1,artobj,"",0,0,0,0) code_erreur = ERR_SEMANT SINON index = index + 1 SAUT BOUCLE FINSI FINSI RETOUR code_erreur FIN_FONCTION #--------------------------------------------------- # # FONCTION: VTG_TRANSCCD # # DESCRIPTION: # # PARAMETRES: # instance_VTG de type ENTIER # E de type ENTIER # CCD de type ENTIER # # RETOUR: # ENTIER #--------------------------------------------------- FONCTION ENTIER VTG_TRANSCCD(ENTIER instance_VTG, ENTIER E, ENTIER CCD) # --------------------------------------------------------------------------- # # FICHIER : VTG_TRANSCCD.src # # VERSION : %version: 4.2 % # # AUTEUR : %created_by: loic % # # CREE le : 05/03/02 09:27 # # MODIFIE le : %date_modified: 05/03/02 09:27 % # # DESCRIPTION : Cette fonction retourne un booleen indiquant si le DC correspond a # l'appel d'un client VTG ayant souscrit a "l'offre 1" (offre basee sur le E # du numero demande et le CCD du DC. # # HISTORIQUE : # 09/04/2001 Creation # 22/01/2002 - FOEX334 - LRA : Correction algo par rapport aux specs Intro aux DC 4.2 # 14/02/2002 - FOEX402 - CMI : Evolution de specs (inversion et E et CCD dans l'algo) # # EN ENTREE : # instance_VTG : instance VTG # E : numero_demande # CCD : ECC Virtuelle # # EN SORTIE: # Aucune # # RETOUR: 0 = FAUX # 1 = VRAI # # --------------------------------------------------------------------------- #--------------------------------------------------------------------------- # CONSTANTES LOCALES #--------------------------------------------------------------------------- #--------------------------------------------------------------------------- # VARIABLES LOCALES #--------------------------------------------------------------------------- # -------------------------------------------------------- # Variables pour la reception des arguments de la fonction # -------------------------------------------------------- # Instance de VTG # E du numero demande # CCD # -------------------------------------------------------- # Infos complementaires de la table de distribution # -------------------------------------------------------- REGISTRE ENTIER adresse_infos REGISTRE ENTIER infos # Divers REGISTRE ENTIER VRAI REGISTRE ENTIER FAUX REGISTRE ENTIER indice # La taille max. des info. complementaires est de 8 octets, indexes de 0 a 7: DEFINITION IND_MAX_INFO 7 # --------------------------------------------------------------------------- # DEBUT DES TRAITEMENTS # --------------------------------------------------------------------------- DEBUT_FONCTION trace( "APPEL VTG_TRANSCCD" ) # --- # recuperation des valeurs d'entree # --- #trace1( " CCD = <%d>", CCD ) #trace1( " E du numero demande = <%d>", E ) #trace1( " instance_VTG = <%d>", instance_VTG ) # --- # Valeur des variables # --- VRAI = 1 FAUX = 0 indice = 0 # --------------------------------------------------------------------------- # Tests en entre ( E=0 ou 8 ) # --------------------------------------------------------------------------- SI( ( E != 0 ) && ( E != 8 ) && ( E != 0xBB ) ) ALORS trace( "E!=0, E!=8 et E!=BB => VTG_TRANSCCD = FAUX)" ) # retour VTG_TRANSCCD = FAUX RETOUR FAUX FINSI # --------------------------------------------------------------------------- # Recuperation de l'adresse des infos complementaires de la table de distribution # --------------------------------------------------------------------------- # 14/02/2002 - FOEX402 - CMI adresse_infos= i_LireInfoECC( instance_VTG, CCD ) #trace1("Retour de i_LireInfoECC - VTG: <%p>", adresse_infos) #G2R1Cj_PLUS_FO1406 SI ( adresse_infos <= 0 ) SI ( adresse_infos == 0 ) ALORS trace1( "VTG n'est pas dans la table DISTRI avec CCD = %d (=>VTG_TRANSCCD = FAUX)", CCD ) # retour VTG_TRANSCCD = FAUX RETOUR FAUX FINSI # --------------------------------------------------------------------------- # E = info complementaire ? # --------------------------------------------------------------------------- POINT INFO_BOUCLE infos = i_LireEntierInfo( adresse_infos, indice, 1 ) trace1("Infos complementaires = <%d>", infos) # 22/01/2002 - FOEX334 - LRA # 14/02/2002 - FOEX402 - CMI SI ( E == infos ) ALORS trace( "E = info complementaire (=>VTG_TRANSCCD = VRAI)" ) # retour VTG_TRANSCCD = VRAI RETOUR VRAI FINSI SI ( (indice < IND_MAX_INFO) && ( infos != 0xFF ) ) ALORS indice = indice + 1 SAUT INFO_BOUCLE FINSI trace1( "E (%d) != info complementaire (=>VTG_TRANSCCD = FAUX)", E ) # retour VTG_TRANSCCD = FAUX RETOUR FAUX # fin de fichier FIN_FONCTION #--------------------------------------------------- # # FONCTION: Extraction_STP # # DESCRIPTION: # # PARAMETRES: # article_in de type ARTOBJ # ic_num_demande de type ENTIER # TransG de type ENTIER # ETSI_N de type ENTIER # ETSI_I de type ENTIER # PrefixeTrans de type ENTIER # ic_num_demandeur de type ENTIER # # RETOUR: # ENTIER #--------------------------------------------------- FONCTION ENTIER Extraction_STP(ARTOBJ article_in, ENTIER ic_num_demande, ENTIER TransG, ENTIER ETSI_N, ENTIER ETSI_I, ENTIER PrefixeTrans, ENTIER ic_num_demandeur) ############################################################################ # # Nom du fichier: Extraction_STP.src # Retourne pour le numero demande le transporteur correspondant (France Telecom ou autre) # (Renvoie la valeur E du numero (premier chiffre) ou la valeur XY caracteristique du transporteur ) # # ENTIER E =Extraction_STP( ARTOBJ article, # ENTIER indice_numero_demande, # ENTIER TransG, # ENTIER ETSI_N, # ENTIER ETSI_I, # ENTIER PrefixeTrans, # ENTIER indice_numero_demandeur ) # # avec : TransG, ETSI_N, ETSI_I des booleens ( 1 pour vrai ) # et PrefixeTrans le prefixe transporteur s'il est deja connu (<0 sinon) # # 09/04/2001 Creation # Version : 00.00 # ############################################################################ #--------------------------------------------------------------------------- # CONSTANTES LOCALES #--------------------------------------------------------------------------- #--------------------------------------------------------------------------- # VARIABLES LOCALES #--------------------------------------------------------------------------- # Variables pour la reception des arguments de la fonction # TransG, ETSI_N, ETSI_I sont en fait des booleens # 1er chiffre du numero demande REGISTRE ENTIER U # Indice du 1er chiffre du numero demande dans le numero demande # (en fait on ne fait aucune modification du numero demande [ajout ou # suppression de quartet] mais on "marque" la position du 1er chiffre, # qui peut se trouver en position 1, 4 ou 6...) REGISTRE ENTIER indice # XY d'un numero debutant par 16XY REGISTRE ENTIER XY # Divers REGISTRE ENTIER erreur REGISTRE POINTEUR p_buffer #--------------------------------------------------------------------------- # DEBUT DES TRAITEMENTS #--------------------------------------------------------------------------- DEBUT_FONCTION trace("APPEL Extraction_STP") # # recuperation des valeurs d'entree # trace1( " ic_num_demande = <%d>", ic_num_demande ) trace1( " TransG = <%d>", TransG ) trace1( " ETSI_N = <%d>", ETSI_N ) trace1( " ETSI_I = <%d>", ETSI_I ) trace1( " PrefixeTrans = <%d>", PrefixeTrans) trace1( "ic_num_demandeur = <%d>", ic_num_demandeur) ######################################################################################### # Numero demandeur debutant par 262, 590, 594 ou 596 et qui comporte moins de 10 chiffres ######################################################################################### SI( ( i_get_art_fieldlength( article_in, ic_num_demande ) < 10 ) &&( ( (i_get_art_fieldtab( article_in, ic_num_demandeur, 0 ) == 0x2) && (i_get_art_fieldtab( article_in, ic_num_demandeur, 1 ) == 0x6) && (i_get_art_fieldtab( article_in, ic_num_demandeur, 2 ) == 0x2) ) ||( (i_get_art_fieldtab( article_in, ic_num_demandeur, 0 ) == 0x5) && (i_get_art_fieldtab( article_in, ic_num_demandeur, 1 ) == 0x9) && ( (i_get_art_fieldtab( article_in, ic_num_demandeur, 2 ) == 0x0) || (i_get_art_fieldtab( article_in, ic_num_demandeur, 2 ) == 0x4) || (i_get_art_fieldtab( article_in, ic_num_demandeur, 2 ) == 0x6) ) ) ) ) ALORS #trace( "Numero demandeur debutant par 262, 590, 594 ou 596 et qui comporte moins de 10 chiffres" ) RETOUR 0 FINSI # initialisation indice et 1er chiffre du numero demande indice = 0 U = -1 ########################################################### # Numero demandeur transgroupe ? ########################################################### SI( TransG ) ALORS # Numero demandeur transgroupe #trace( "Le numero demandeur est transgroupe" ) # => "simlation automate T1" ( appels debutants par 036510, 0*31*0 ou simplement 0 ) SI( i_get_art_fieldtab( article_in, ic_num_demande, 0 ) == 0x0 ) ALORS trace( "Appel debutant par 0" ) SI( ( (i_get_art_fieldtab( article_in, ic_num_demande, 1 ) == 0x3) && (i_get_art_fieldtab( article_in, ic_num_demande, 2 ) == 0x6) && (i_get_art_fieldtab( article_in, ic_num_demande, 3 ) == 0x5) && (i_get_art_fieldtab( article_in, ic_num_demande, 4 ) == 0x1) && (i_get_art_fieldtab( article_in, ic_num_demande, 5 ) == 0x0) ) ||( (i_get_art_fieldtab( article_in, ic_num_demande, 1 ) == 0xB) && (i_get_art_fieldtab( article_in, ic_num_demande, 2 ) == 0x3) && (i_get_art_fieldtab( article_in, ic_num_demande, 3 ) == 0x1) && (i_get_art_fieldtab( article_in, ic_num_demande, 4 ) == 0xB) && (i_get_art_fieldtab( article_in, ic_num_demande, 5 ) == 0x0) ) ) ALORS trace( "Appel debutant par 036510 ou 0*31*0 => retrait 6 premiers chiffres" ) # "Retrait" des 6 premiers chiffres du numero demandeur indice = 6 SINON trace( "Appel debutant par 0XXXX...=> retrait du 0" ) # "Retrait" 0 du debut au numero demandeur indice = 1 FINSI FINSI SINON # Numero demandeur non transgroupe #trace( "Numero demandeur non transgroupe" ) # => "simulation automate T2" ( traitement uniquement pour les appels # debutants par 3651 ou *31* [secret dus demandeur] ) SI( ( (i_get_art_fieldtab( article_in, ic_num_demande, 0 ) == 0x3) && (i_get_art_fieldtab( article_in, ic_num_demande, 1 ) == 0x6) && (i_get_art_fieldtab( article_in, ic_num_demande, 2 ) == 0x5) && (i_get_art_fieldtab( article_in, ic_num_demande, 3 ) == 0x1) ) ||( (i_get_art_fieldtab( article_in, ic_num_demande, 0 ) == 0xB) && (i_get_art_fieldtab( article_in, ic_num_demande, 1 ) == 0x3) && (i_get_art_fieldtab( article_in, ic_num_demande, 2 ) == 0x1) && (i_get_art_fieldtab( article_in, ic_num_demande, 3 ) == 0xB) ) ) ALORS #trace( "Appel debutant par 3651 ou *31* => retrait 4 premiers chiffres" ) # "Retrait" des 4 premiers chiffres du numero demandeur indice = 4 #SINON #trace( "Tous appels sauf ceux debutant par 3651 ou *31*" ) # Rien a faire ici FINSI FINSI ############################################################# # Communication ETSI nationale ou internationale ############################################################# SI( ( ETSI_N ) || ( ETSI_I ) ) ALORS #trace( "Appel ETSI national ou ETSI international (ETSI_N ou ETSI_I) => ajout 0 ou 00 en debut de numero" ) # 1er chiffre = 0 U = 0 #SINON #trace( "Appel ni ETSI_N ni ETSI_I" ) # Rien a faire ici FINSI ############################################################## # En fonction du 1er chiffre du numero demande ############################################################## #Si U non renseigne, recuperation "1er chiffre" (qui peut se trouver en position 1, 4 ou 6 ) du numero demande SI( U != 0 ) ALORS U = i_get_art_fieldtab( article_in, ic_num_demande, indice ) #trace1( "1er chiffre = <%d>", U ) FINSI # En fonction de U SI( U==0 ) ALORS SI( PrefixeTrans>=0 ) ALORS trace1( "PrefixeTransporteur deja renseigne => E = <%d> ", PrefixeTrans ) RETOUR PrefixeTrans SINON trace( "PrefixeTransporteur non renseigne => E = 0" ) RETOUR 0 FINSI SINON SI( ( U!=1 ) && ( U!=3 ) && ( U!=0x0B ) && ( U!=0x0C ) ) ALORS trace1( "1er chiffre different de 1,3,* et # => E = <%d>", U ) RETOUR U SINON SI( (U==1) && (i_get_art_fieldtab( article_in, ic_num_demande, indice+1 ) == 0x6) ) ALORS #trace( "Appel debutant par 16XY" ) XY = i_get_art_fieldtab( article_in, ic_num_demande, indice+2 )*10 + i_get_art_fieldtab( article_in, ic_num_demande, indice+3 ) trace1( "Retour E = XY=<%d>", XY) RETOUR XY SINON trace( "Retour E = 0" ) RETOUR 0 FINSI FINSI FINSI FIN_FONCTION --------------------------------------------------- # # FONCTION: EfficaceIP # # DESCRIPTION: # # PARAMETRES: # Service de type POINTEUR # Num de type POINTEUR # date_pivot de type ENTIER # # RETOUR: # POINTEUR #--------------------------------------------------- FONCTION POINTEUR EfficaceIP(POINTEUR Service, POINTEUR Num, ENTIER date_pivot) ############################################################################ # # Nom du fichier: EfficaceIP.src # # Fonction: # Recupere la valeur du champ Efficacite dans une table externe # # En entree : # Service # Num # # En sortie: # si OK : EfficaceIP (1er caractere) # Erreur : I # ############################################################################ REGISTRE POINTEUR Cle REGISTRE POINTEUR valeur REGISTRE ENTIER erreur REGISTRE POINTEUR res # # Recuperation des arguments en entree # DEBUT_FONCTION Cle = "123456789012345" valeur = "12305612345" res = "11111112345" #trace1("date_pivot: <%u>", date_pivot) #trace2("Service: <%s>", Service,"") #trace2("Num: <%s>", Num,"") # # Concatenation de Service et Num pour former la cle # erreur = i_format_str2(Cle,"%s%s",Service,Num) #trace2("Cle: <%s>", Cle,"") # # Recherche dans la table externe, de la valeur correspondante a la cle # valeur = i_get_tab_field( "Inter", date_pivot, Cle ) SI( valeur == g_inull ) ALORS # trace2( "ERREUR: cle <%s> non trouve dans la table externe InefInt", Cle,"" ) res = "I" RETOUR res FINSI #trace2("Valeur trouvee: <%s> : %s", valeur, "") # # Recuperation du 1er caractere de la valeur trouvee # i_get_sub_str( valeur, 0, 0, res ) #trace2("EfficaceIP: <%s> : %s", res, "") RETOUR res FIN_FONCTION #--------------------------------------------------------------------------------- FONCTION POINTEUR CodeOperateur(ENTIER date, POINTEUR Num) # Nom du fichier: CodeOperateur.src # # Fonction: # Recupere le code operateur en fonction de la date et du numero demande # # En entree : # DATE # Numero Demande # # En sortie: # si OK : Code operateur # si NOK : 0 # # FO49 : on prend les 9 derniers caracteres du NUM pour appel a la table # FO55 : utilisation de i_EnvoiReqConsTabDistDouble ############################################################################ REGISTRE POINTEUR pt_Code REGISTRE POINTEUR pt_Buffer REGISTRE ENTIER erreur REGISTRE ENTIER res REGISTRE ENTIER inst45s REGISTRE ENTIER L_Num #DEBUT_FONCTION # Recuperation des arguments en entree # # Initialisation des variables pt_Buffer="123456789012345" pt_Code ="111111111112345" #################################################### # Recherche instance 45S ##################################################### inst45s = i_LireInstanceECC("45S") trace1("inst45s=<%d>",inst45s) ############################################################################ # Envoi requetes Table de Distribution ############################################################################ # Correction PSA G1R2C3 : on prend les 9 derniers digits du demande # A revoir : probleme de surnumerotation #i_get_sub_str(Num,1,i_strlen(Num)-1,Num) i_get_sub_str(Num,-9,-1,Num) L_Num = i_conv_ascii_dcb(Num, pt_Buffer) #erreur = i_EnvoiReqConsTabDist(6, date, pt_Buffer, L_Num,0,1) erreur = i_EnvoiReqConsTabDistDouble(6, 6, date, pt_Buffer, L_Num,L_Num,1,0,1) SI (erreur != 0) ALORS trace("Erreur i_EnvoiReqConsTabDist") RETOUR 0 FINSI ############################################################################ # Attente requetes Table de Distribution ############################################################################ erreur = i_LireReqConsTabDist() SI ( erreur != 0 ) ALORS trace1( "Erreur i_LireReqConsTabDist: <%d>", erreur) RETOUR 0 FINSI ############################################################################ # Lecture du Code Operateur ############################################################################ res = i_LireInfoECC( inst45s, 0 ) #G2R1Cj_PLUS_FO1406 SI (res > 0) SI (res != 0) ALORS erreur = i_LireChaineInfo( res, 0, 5, pt_Code ) trace2( " - Resultat de i_LireChaineInfo : <%s>", pt_Code, "" ) SINON trace("pas trouve dans le referentiel 45s") RETOUR 0 FINSI RETOUR pt_Code FIN_FONCTION #--------------------------------------------------------------------------------- FONCTION POINTEUR CodeOperateurTable6(ENTIER date, POINTEUR pt_Num, POINTEUR pt_table) # Nom du fichier: CodeOperateurTable6.src # # Fonction: # Recupere le code operateur en fonction de la date du numero demande et # de la table 6 (45S ou ACLA) # En entree : # DATE # Numero Demande # Nom de la table "45S" ou "ACLA" # # En sortie: # si OK : Code operateur # si NOK : 0 # # FO49 : on prend les 9 derniers caracteres du NUM pour appel a la table # FO55 : utilisation de i_EnvoiReqConsTabDistDouble # 10/01/05 : FAL creation pour Cbb a partir de CodeOperateur # 18/03/05 : FAL FO1164 optimisation appel ACLA 3BPQ ou Z=8 # 24/06/14 : THE G4R7 Lot1 Appel ACLA pour tous les dde # ############################################################################ REGISTRE POINTEUR pt_Code REGISTRE POINTEUR pt_Buffer REGISTRE ENTIER erreur REGISTRE ENTIER res REGISTRE ENTIER instTable6 REGISTRE ENTIER L_Num #DEBUT_FONCTION # Recuperation des arguments en entree # # Initialisation des variables pt_Buffer ="AAAAAAAAAAAAAAA" pt_Code ="BBBBBBBBBBBBBBB" ############################################################################# # # Correction PSA G1R2C3 : on prend les 9 derniers digits du demande # A revoir : probleme de surnumerotation #i_get_sub_str(Num,1,i_strlen(Num)-1,Num) SI (i_strlen(pt_Num) >= 9) ALORS i_get_sub_str(pt_Num,-9,-1,pt_Num) SINON i_get_sub_str(pt_Num,-4,-1,pt_Num) FINSI #SI (i_strcmp(pt_table, "ACLA") == 0) #ALORS # trace ("concerne ACLA") # i_get_sub_str(pt_Num,0,0,pt_Buffer) # SI ((i_strcmp(pt_Buffer, "3") != 0) && (i_strcmp(pt_Buffer, "8") != 0)) # ALORS # trace (" pas d appel ACLA cause optimise ") # RETOUR 0 # FINSI #FINSI #################################################### # Recherche instance 45S ##################################################### instTable6 = i_LireInstanceECC(pt_table) #trace1("instTable6=<%d>",instTable6) ############################################################################ # Envoi requetes Table de Distribution ############################################################################ L_Num = i_conv_ascii_dcb(pt_Num, pt_Buffer) #erreur = i_EnvoiReqConsTabDist(6, date, pt_Buffer, L_Num,0,1) erreur = i_EnvoiReqConsTabDistDouble(6, 6, date, pt_Buffer, L_Num,L_Num,1,0,1) SI (erreur != 0) ALORS trace("Erreur i_EnvoiReqConsTabDist") RETOUR 0 FINSI ############################################################################ # Attente requetes Table de Distribution ############################################################################ erreur = i_LireReqConsTabDist() SI ( erreur != 0 ) ALORS trace1( "Erreur i_LireReqConsTabDist: <%d>", erreur) RETOUR 0 FINSI ############################################################################ # Lecture du Code Operateur ############################################################################ res = i_LireInfoECC( instTable6, 0 ) SI (res != 0) ALORS erreur = i_LireChaineInfo( res, 0, 5, pt_Code ) trace2( " Resultat de i_LireChaineInfo : <%s>", pt_Code, "" ) SINON trace2("pas trouve dans le referentiel %s", pt_table, "") RETOUR 0 FINSI RETOUR pt_Code FIN_FONCTION # Fonction PCODE ############################################################################ FONCTION POINTEUR type_commut(POINTEUR Service, POINTEUR Code_SGTQS, ENTIER date_pivot) # # Nom du fichier: type_commut.src # # Fonction: # Recupere le type de commutateur dans une table externe inef # en fonction du code SGTQS # # En entree : # Service # Code_SGTQS # date_pivot # # En sortie: # si OK : valeur (sous forme de chaine de caracteres) # Erreur : g_inull # ############################################################################ REGISTRE POINTEUR Cle REGISTRE POINTEUR valeur REGISTRE ENTIER erreur REGISTRE POINTEUR res DEBUT_FONCTION # # Recuperation des arguments en entree # Cle = "333333333312345" valeur = "22222212345" res = "11111112345" trace1("date_pivot: %u>", date_pivot) trace2("Code_SGTQS: %s>", Code_SGTQS,"") trace2("Service: %s>", Service,"") # # Concatenation de Service et Code_SGTQS pour former la cle # erreur = i_format_str2(Cle,"%s%s",Service,Code_SGTQS) trace2("Cle: %s>", Cle, "") # # Recherche dans la table externe, de la valeur correspondante a la cle # valeur = i_get_tab_field( "type_caa", date_pivot, Cle ) SI( valeur == g_inull ) ALORS trace2( "ERREUR: Code_SGTQS %s> non trouve dans la table externe inef",Cle, "" ) RETOUR 0 FINSI trace2("Valeur trouvee: %s>", valeur, "") RETOUR valeur FIN_FONCTION # Fonction PCODE ############################################################################ FONCTION POINTEUR inef_std(POINTEUR Service, POINTEUR commut, POINTEUR code_inef_spec, ENTIER date_pivot) # # Nom du fichier: inef_std.src # # Fonction: # Recupere la valeur code inefficacite standard dans la table externe # inef en fonction du type de commut et du code ineff. specifique # # En entree : # Service # commut # code_inef_spec # date_pivot # # En sortie: # si OK : INEF_STD (sous forme de chaine de caracteres) # Erreur : g_inull # ############################################################################ REGISTRE POINTEUR Cle1 REGISTRE POINTEUR Cle2 REGISTRE POINTEUR valeur REGISTRE ENTIER erreur REGISTRE POINTEUR res DEBUT_FONCTION # # Recuperation des arguments en entree # Cle2 = "444444444412345" Cle1 = "333333333312345" valeur = "22222212345" res = "11111112345" trace1("date_pivot: %u>", date_pivot) trace2("type_commut:%s>", commut,"") trace2("code_inef_spec:%s>", code_inef_spec,"") trace2("Service:%s>", Service,"") # # Concatenation de type_commut et code_inef_spec pour former la cle1 # erreur = i_format_str2(Cle1,"%s%s",commut,code_inef_spec) trace2("Cle1: %s>", Cle1,"") # # Concatenation de Service avec Cle1 pour former la cle2 erreur = i_format_str2(Cle2,"%s%s",Service,Cle1) trace2("Cle2: %s>", Cle2,"") # # Recherche dans la table externe, de la valeur correspondante a la cle # valeur = i_get_tab_field( "inef_std", date_pivot, Cle2 ) SI( valeur == g_inull ) ALORS trace2( "ERREUR: Code_SGTQS %s> non trouve dans la table externe inef",Cle2, "" ) RETOUR 0 FINSI trace2("Valeur trouvee: %s> : %s", valeur, "") RETOUR valeur FIN_FONCTION # Fonction PCODE ############################################################################ FONCTION POINTEUR code_apache(POINTEUR Service, POINTEUR Code_SGTQS, ENTIER date_pivot) # # Nom du fichier: code_apache.src # # Fonction: # Indique si le code SGTQS est un code pour l'application APACHE # # En entree : # Service # Code_SGTQS # date_pivot # # En sortie: # si OK : valeur (sous forme de chaine de caracteres) # Erreur : g_inull # ############################################################################ REGISTRE POINTEUR Cle REGISTRE POINTEUR valeur REGISTRE ENTIER erreur REGISTRE POINTEUR res DEBUT_FONCTION # # Recuperation des arguments en entree # Cle = "333333333312345" valeur = "22222212345" res = "11111112345" trace1("date_pivot: %u>", date_pivot) trace2("Code_SGTQS: %s>", Code_SGTQS,"") trace2("Service: %s>", Service,"") # # Concatenation de Service et Code_SGTQS pour former la cle # erreur = i_format_str2(Cle,"%s%s",Service,Code_SGTQS) trace2("Cle: %s>", Cle,"") # # Recherche dans la table externe, de la valeur correspondante a la cle # valeur = i_get_tab_field( "code_apache", date_pivot, Cle ) SI( valeur == g_inull ) ALORS trace2( "ERREUR: Code_SGTQS %s> non trouve dans la table externe inef",Cle, "" ) RETOUR 0 FINSI trace2("Valeur trouvee: %s> : %s", valeur, "") RETOUR valeur FIN_FONCTION # Fonction PCODE ############################################################################ FONCTION POINTEUR inef_apache(POINTEUR Service, POINTEUR code_inef_std, ENTIER date_pivot) # Nom du fichier: inef_apache.src # # Fonction: # Indique si le code inefficacite est un code pour l'application APACHE # # En entree : # Service # code_inef_std # date_pivot # # En sortie: # si OK : valeur (sous forme de chaine de caracteres) # Erreur : g_inull # ############################################################################ REGISTRE POINTEUR Cle REGISTRE POINTEUR valeur REGISTRE ENTIER erreur REGISTRE POINTEUR res DEBUT_FONCTION # # Recuperation des arguments en entree # Cle = "333333333312345" valeur = "22222212345" res = "11111112345" trace1("date_pivot: %u>", date_pivot) trace2("code_inef_std: %s>", code_inef_std,"") # # Concatenation de Service et code_inef_std pour former la cle # erreur = i_format_str2(Cle,"%s%s",Service,code_inef_std) trace2("Cle: %s>", Cle,"") # # Recherche dans la table externe, de la valeur correspondante a la cle # valeur = i_get_tab_field( "inef_apache", date_pivot, Cle ) SI( valeur == g_inull ) ALORS trace2( "ERREUR: Code_SGTQS %s> non trouve dans la table externe inef", Cle, "" ) RETOUR 0 FINSI trace2("Valeur trouvee: %s> : %s", valeur, "") RETOUR valeur FIN_FONCTION # Fonction PCODE ############################################################################ FONCTION POINTEUR Norm_NDE_DEA(POINTEUR Num, ENTIER sty, ENTIER inf) # # Nom du fichier: Norm_NDE_DEA.src # # Fonction: # Normalise un NDE pour les DEA # # En entree : # NDE # champ sty # champ inf # # En sortie: # si OK : NDE normalise # Erreur : g_inull # ############################################################################ REGISTRE ENTIER erreur REGISTRE POINTEUR TEMP DEBUT_FONCTION # # Recuperation des arguments en entree # TEMP = "AZEATRTYETRGSGDGHJHRYUUGFHBCBGTHFJITIT" erreur = i_cree_art("Conversion",g_iartout13) erreur = i_set_art_str(g_iartout13,$Conversion::IDUS_NUM,Num) SI ((sty & 0x40) == 0x40 ) ALORS # Transgroupe SI ((g_iartout13.IDUS_NUM[0] == 0x30) && (g_iartout13.IDUS_NUM[1] == 0x42) && (g_iartout13.IDUS_NUM[2] == 0x33) && (g_iartout13.IDUS_NUM[3] == 0x31) && (g_iartout13.IDUS_NUM[4] == 0x42) && (g_iartout13.IDUS_NUM[5] == 0x30)) ALORS i_get_sub_str(Num,6,-1,Num) SAUT SUITE FINSI SI ((g_iartout13.IDUS_NUM[0] == 0x30) && (g_iartout13.IDUS_NUM[1] == 0x33) && (g_iartout13.IDUS_NUM[2] == 0x36) && (g_iartout13.IDUS_NUM[3] == 0x35) && (g_iartout13.IDUS_NUM[4] == 0x31) && (g_iartout13.IDUS_NUM[5] == 0x30)) ALORS i_get_sub_str(Num,6,-1,Num) SAUT SUITE FINSI SI ((g_iartout13.IDUS_NUM[0] == 0x42) && (g_iartout13.IDUS_NUM[1] == 0x33) && (g_iartout13.IDUS_NUM[2] == 0x31) && (g_iartout13.IDUS_NUM[3] == 0x42) && (g_iartout13.IDUS_NUM[4] == 0x30)) ALORS i_get_sub_str(Num,5,-1,Num) SAUT SUITE FINSI SI ((g_iartout13.IDUS_NUM[0] == 0x33) && (g_iartout13.IDUS_NUM[1] == 0x36) && (g_iartout13.IDUS_NUM[2] == 0x35) && (g_iartout13.IDUS_NUM[3] == 0x31) && (g_iartout13.IDUS_NUM[4] == 0x30)) ALORS i_get_sub_str(Num,5,-1,Num) SAUT SUITE FINSI SI (g_iartout13.IDUS_NUM[0] == 0x30) ALORS i_get_sub_str(Num,1,-1,Num) SAUT SUITE FINSI SINON # non Transgroupe SI ((g_iartout13.IDUS_NUM[0] == 0x30) && (g_iartout13.IDUS_NUM[1] == 0x42) && (g_iartout13.IDUS_NUM[2] == 0x33) && (g_iartout13.IDUS_NUM[3] == 0x31) && (g_iartout13.IDUS_NUM[4] == 0x42)) ALORS i_get_sub_str(Num,5,-1,Num) SAUT SUITE FINSI SI ((g_iartout13.IDUS_NUM[0] == 0x30) && (g_iartout13.IDUS_NUM[1] == 0x33) && (g_iartout13.IDUS_NUM[2] == 0x36) && (g_iartout13.IDUS_NUM[3] == 0x35) && (g_iartout13.IDUS_NUM[4] == 0x31)) ALORS i_get_sub_str(Num,5,-1,Num) SAUT SUITE FINSI SI ((g_iartout13.IDUS_NUM[0] == 0x42) && (g_iartout13.IDUS_NUM[1] == 0x33) && (g_iartout13.IDUS_NUM[2] == 0x31) && (g_iartout13.IDUS_NUM[3] == 0x42)) ALORS i_get_sub_str(Num,4,-1,Num) SAUT SUITE FINSI SI ((g_iartout13.IDUS_NUM[0] == 0x33) && (g_iartout13.IDUS_NUM[1] == 0x36) && (g_iartout13.IDUS_NUM[2] == 0x35) && (g_iartout13.IDUS_NUM[3] == 0x31)) ALORS i_get_sub_str(Num,4,-1,Num) SAUT SUITE FINSI FINSI POINT SUITE erreur = i_set_art_str(g_iartout13,$Conversion::IDUS_NUM,Num) # 16XY SI ((g_iartout13.IDUS_NUM[0] == 0x31) && (g_iartout13.IDUS_NUM[1] == 0x36)) ALORS i_get_sub_str(Num,4,-1,Num) SAUT SUITE2 FINSI # 840XY SI ((g_iartout13.IDUS_NUM[0] == 0x38) && (g_iartout13.IDUS_NUM[1] == 0x34) && (g_iartout13.IDUS_NUM[2] == 0x30)) ALORS i_get_sub_str(Num,5,-1,Num) FINSI POINT SUITE2 erreur = i_set_art_str(g_iartout13,$Conversion::IDUS_NUM,Num) # Retrait du zero eventuel en debut d article SI (g_iartout13.IDUS_NUM[0] == 0x30) ALORS i_get_sub_str(Num,1,-1,Num) FINSI i_get_sub_str(Num,0,8,Num) RETOUR Num FIN_FONCTION #--------------------------------------------------- FONCTION POINTEUR CodeEffIP(POINTEUR Service, POINTEUR Num, ENTIER date_pivot) ############################################################################ # # Nom du fichier: CodeEffIP.src # # Fonction: # Recupere la valeur associee (a partir du second caractere) a la clef dans une table externe # # En entree : # Service # Num # # En sortie: # si OK : CodeEffIP (tous les carateres a partir du second) # Erreur : 0 # # Historique : NSA 22/01/04 Normalisation pointeurs ############################################################################ REGISTRE POINTEUR pt_Cle REGISTRE POINTEUR pt_valeur REGISTRE ENTIER erreur REGISTRE POINTEUR pt_res # # Recuperation des arguments en entree # DEBUT_FONCTION pt_Cle = "aaaaaaaaaaaaaaa" pt_valeur = "bbbbbbbbbbb" pt_res = "ccccccccccc" #trace1("date_pivot: <%u>", date_pivot) #trace2("Service: <%s>", Service,"") #trace2("Num: <%s>", Num,"") # # Concatenation de Service et Num pour former la cle # erreur = i_format_str2(pt_Cle,"%s%s",Service,Num) #trace2("pt_Cle: <%s>", pt_Cle,"") # # Recherche dans la table externe, de la valeur correspondante a la cle # i_strcpy(pt_valeur,i_get_tab_field( "Inter", date_pivot, pt_Cle )) SI(!i_strcmp(pt_valeur,g_inull)) ALORS # trace2( "ERREUR: pt_Cle <%s> non trouvee dans la table externe InefInt", pt_Cle,"" ) i_strcpy(pt_res,"00") RETOUR pt_res FINSI #trace2("Valeur trouvee: <%s> : %s", pt_valeur, "") # # Recuperation du 2ieme et 3ieme caractere # i_get_sub_str( pt_valeur, 1, 2, pt_res ) #trace2("CodeEffIP: <%s> : %s", pt_res, "") RETOUR pt_res FIN_FONCTION #--------------------------------------------------- FONCTION POINTEUR DEDE9(POINTEUR Service, POINTEUR Num, ENTIER date_pivot) ############################################################################ # # Nom du fichier: DEDE9.src # # Fonction: # Recupere la valeur associee a la clef dans une table externe # Pour les clefs commencant par 0,4 et 7 ajouter les 3 derniers chiffres de la clef a la valeur # # En entree : # Service # Num # # En sortie: # si OK : Valeur table Ext + caracteres supplementairs dans certains cas # Erreur : 0 # Historique : NSA 22/01/04 Normalisation pointeurs # NSA 26/03/2004 FO595 modif du test de retour de l'appel ` la table# # ############################################################################ REGISTRE POINTEUR pt_Cle REGISTRE POINTEUR pt_Cle2 REGISTRE POINTEUR pt_DebCle REGISTRE POINTEUR pt_FinCle REGISTRE POINTEUR pt_valeur REGISTRE ENTIER erreur REGISTRE POINTEUR pt_res REGISTRE POINTEUR pt_resul REGISTRE ENTIER longueur # # Recuperation des arguments en entree # DEBUT_FONCTION pt_Cle = "aaaaaaaaaaaaaaa" pt_Cle2 = "bbbbbbbbb" pt_FinCle = "cccccccccccccccc" pt_DebCle = "ddddddd" pt_valeur = "eeeeeeeeeeeeeee" pt_res = "fffffffffffffff" pt_resul = "ggggggggggggggg" #trace1("date_pivot: <%u>", date_pivot) #trace2("Num: <%s>", Num,"") #trace2("pt_Cle: <%s>", pt_Cle,"") # Concatenation de Service et Num pour former la cle # erreur = i_format_str2(pt_Cle,"%s%s",Service,Num) #trace2("pt_Cle: <%s>", pt_Cle,"") # Lecture du premier caracteres du numero i_get_sub_str( Num, 0, 0, pt_DebCle ) # Recherche dans la table externe, de la valeur correspondante a la cle SI ( !i_strcmp(pt_DebCle,"0")||!i_strcmp(pt_DebCle,"4")||!i_strcmp(pt_DebCle,"7")) ALORS i_get_sub_str( Num, 1, 3, pt_FinCle ) i_get_sub_str( pt_Cle, 0, 3, pt_Cle2 ) i_strcpy(pt_valeur,i_get_tab_field( "Inter", date_pivot, pt_Cle2 )) SINON i_strcpy(pt_valeur,i_get_tab_field( "Inter", date_pivot, pt_Cle ) ) FINSI # SI( !i_strcmp(pt_valeur,g_inull )) ALORS # trace2( "ERREUR: pt_Cle <%s> non trouvee dans la table externe Inter", pt_Cle,"" ) i_strcpy(pt_res,"0") RETOUR pt_res FINSI #trace2("Valeur trouvee: <%s> : %s", pt_valeur, "") # # Recuperation de la valeur et ajout de caracteres a la fin de la valeur trouvee # dans le cas de num commencant par 0, 4 ou 7 SI ( !i_strcmp(pt_DebCle,"0")||!i_strcmp(pt_DebCle,"4")||!i_strcmp(pt_DebCle,"7")) ALORS erreur = i_format_str2(pt_res,"%s%s",pt_valeur,pt_FinCle) SINON i_strcpy(pt_res,pt_valeur) FINSI # Longueur de la chaine: longueur=i_strlen(pt_res) trace1("Longueur de la chaine passee: <%d>", longueur) # Bourrage possible avec "F": SI (longueur % 2) ALORS trace("Nb octets impair, bourrage avec F") erreur=i_format_str2(pt_resul,"%s%s",pt_res,"F") longueur=longueur+1 FINSI trace2("chaine apres bourrage = <%s>", pt_resul, "") RETOUR pt_resul FIN_FONCTION #--------------------------------------------------- FONCTION POINTEUR CleIP(POINTEUR Service, POINTEUR Num, ENTIER date_pivot) ############################################################################ # # Nom du fichier: CleIP.src # # Fonction: # Recupere la valeur associee a la clef dans une table externe # # En entree : # Num # # En sortie: # si OK : la valeur trouvee dans la table # Erreur : 0 # ############################################################################ REGISTRE POINTEUR pt_Cle REGISTRE POINTEUR pt_Cle2 REGISTRE POINTEUR pt_valeur REGISTRE ENTIER erreur REGISTRE POINTEUR pt_DebNum # allocation memoire pt_Cle2 = "aaaaaaaaaaaaaa" pt_Cle = "bbbbbbbbbbbbbbbbb" pt_valeur = "ccccccccccccccc" pt_DebNum = "ddddddddddd" # # Recuperation des arguments en entree # DEBUT_FONCTION #trace1("date_pivot: <%u>", date_pivot) #trace2("Num: <%s>", Num,"") # Prendre au maximum les 9 premiers caracthres de DEDE_NUM (caracteres efficaces) i_get_sub_str( Num, 0, 8, Num ) # ## Concatenation de Service et Num pour former la cle # erreur = i_format_str2(pt_Cle,"%s%s",Service,Num) #trace2("pt_Cle: <%s>", pt_Cle,"") # Recherche dans la table externe, de la valeur correspondante a la cle # #trace1("date_pivot: <%u>", date_pivot) #trace2("Num: <%s>", Num,"") # Lecture des 6 premiers caracteres du num i_get_sub_str( Num, 0, 5, pt_DebNum ) # Lecture des 9 premiers caracteres de la cle i_get_sub_str( pt_Cle, 0, 8, pt_Cle2 ) # Recherche dans la table externe, de la valeur correspondante a la cle SI ( (!i_strcmp(pt_DebNum,"860880")) || (!i_strcmp(pt_DebNum,"860004")) || (!i_strcmp(pt_DebNum,"860007")) ) ALORS i_strcpy(pt_valeur,i_get_tab_field( "Inter", date_pivot, pt_Cle2 )) SINON i_strcpy(pt_valeur,i_get_tab_field( "Inter", date_pivot, pt_Cle)) FINSI SI(!i_strcmp(pt_valeur,g_inull)) ALORS # trace2( "ERREUR: pt_Cle <%s> non trouvee dans la table externe NumLCleInt", Num,"" ) i_strcpy(pt_valeur,"0") FINSI RETOUR pt_valeur FIN_FONCTION --------------------------------------------------- # # FONCTION: ICOM # # DESCRIPTION: # # PARAMETRES: # Service de type POINTEUR # NomGK de type POINTEUR # date_pivot de type ENTIER # # RETOUR: # POINTEUR #--------------------------------------------------- FONCTION POINTEUR ICOM(POINTEUR Service, POINTEUR NomGK, ENTIER date_pivot) ############################################################################ # # Nom du fichier: ICOM.src # # Fonction: # Recupere l ICOM d'un GK Service correspondant ` un FAI # # En entree : # Service # NumGK # # En sortie: # si OK : Num RTC du FAI # VIDE # Erreur : g_inull # ############################################################################ REGISTRE POINTEUR pt_cle REGISTRE POINTEUR pt_valeur REGISTRE POINTEUR pt_res REGISTRE ENTIER erreur # # Recuperation des arguments en entree # DEBUT_FONCTION pt_cle = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJK" pt_valeur = "JKLMNOPQRSTUVWJKLMNOPQRSTUVWJKLMNOPQR" pt_res = "RSTUVWXYZABCDERSTUVWXYZABCDERSTUVWXYZABCDE" #trace1("date_pivot: <%u>", date_pivot) #trace2("Service: <%s>", Service,"") #trace2("Num: <%s>", Num,"") # # Concatenation de Service et Num pour former la cle # erreur = i_format_str2(pt_cle,"%s%s",Service,NomGK) #trace2("Cle: <%s>", Cle,"") # # Recherche dans la table externe, de la valeur correspondante a la cle # i_strcpy(pt_valeur, i_get_tab_field( "Inter", date_pivot, pt_cle )) SI (i_strcmp(pt_valeur,g_inull) == 0 ) ALORS # trace2( "ERREUR: cle <%s> non trouve dans la table externe InefInt", Cle,"" ) i_strcpy(pt_res, "ERR") SINON i_strcpy(pt_res, pt_valeur) FINSI #trace2("Valeur trouvee: <%s> : %s", valeur, "") RETOUR pt_res FIN_FONCTION #--------------------------------------------------- # # FONCTION: POINTEUR convNum_Str # # DESCRIPTION: # # PARAMETRES: # artobj de type ARTOBJ # ic_champ de type ENTIER indice du champ a convertir # Longueur de type ENTIER longueur en octet du resultat # # RETOUR: # POINTEUR # # Exemple : # pt_RESUL = convNum_Str(g_iartin, $TconvNE::IDSV, 2) # pt_RESUL = convNum_Str(g_iartin, $TconvNE::CPCS, 4) # #--------------------------------------------------- ############################################################################ FONCTION POINTEUR convNum_Str(ARTOBJ artobj, ENTIER ic_champ, ENTIER longueur) REGISTRE POINTEUR pt_BUF REGISTRE ENTIER erreur pt_BUF="abcdefghijklmnopqrstuvwxyz" DEBUT_FONCTION erreur=i_cree_art("Conversion",g_iartout13) erreur= i_dup_chp_1val(artobj,g_iartout13,ic_champ,$Conversion::NUM) erreur = i_get_art_str(g_iartout13, $Conversion::DCB,pt_BUF) i_get_sub_str(pt_BUF,-longueur,-1,pt_BUF) RETOUR pt_BUF FIN_FONCTION #--------------------------------------------------------------------------------------- # # FONCTION: Conversion ASCII DECIMAL vers Entier # # DESCRIPTION: # cette fonction fait la conversion d'un champ ASCII numerique decimal vers Entier # # PARAMETRES: # # # # RETOUR: # Entier # - la chaine converti en entier si OK # - -1 si KO (chaine ASCII trop longue ou non numerique) #--------------------------------------------------------------------------------------- FONCTION ENTIER CONV_ASCIINUMDEC_INT(POINTEUR pt_valeurIN) REGISTRE ENTIER taille REGISTRE ENTIER indice REGISTRE ENTIER puissance REGISTRE POINTEUR pt_val REGISTRE ENTIER total REGISTRE ENTIER erreur pt_val = "pt_val" total = 0 puissance = 1 DEBUT_FONCTION #recuperation taille champIN taille = i_strlen(pt_valeurIN) #test si champIN trop long SI (taille > 9) ALORS RETOUR -1 FINSI indice = 1 POINT BOUCLE_PUISSANCE_MAX SI indice < taille ALORS puissance = puissance * 10 indice = indice + 1 SAUT BOUCLE_PUISSANCE_MAX FINSI #conversion indice = -1 POINT DEBUT_BOUCLE_ASCIItoINT indice = indice + 1 SI (indice < taille) ALORS i_get_sub_str(pt_valeurIN, indice, indice, pt_val) SI i_strcmp(pt_val,"0") == 0 ALORS SAUT BOUCLE_ASCIItoINT FINSI SI i_strcmp(pt_val,"1") == 0 ALORS total = total + (1 * puissance) SAUT BOUCLE_ASCIItoINT FINSI SI i_strcmp(pt_val,"2") == 0 ALORS total = total + (2 * puissance) SAUT BOUCLE_ASCIItoINT FINSI SI i_strcmp(pt_val,"3") == 0 ALORS total = total + (3 * puissance) SAUT BOUCLE_ASCIItoINT FINSI SI i_strcmp(pt_val,"4") == 0 ALORS total = total + (4 * puissance) SAUT BOUCLE_ASCIItoINT FINSI SI i_strcmp(pt_val,"5") == 0 ALORS total = total + (5 * puissance) SAUT BOUCLE_ASCIItoINT FINSI SI i_strcmp(pt_val,"6") == 0 ALORS total = total + (6 * puissance) SAUT BOUCLE_ASCIItoINT FINSI SI i_strcmp(pt_val,"7") == 0 ALORS total = total + (7 * puissance) SAUT BOUCLE_ASCIItoINT FINSI SI i_strcmp(pt_val,"8") == 0 ALORS total = total + (8 * puissance) SAUT BOUCLE_ASCIItoINT FINSI SI i_strcmp(pt_val,"9") == 0 ALORS total = total + (9 * puissance) SAUT BOUCLE_ASCIItoINT FINSI RETOUR -1 POINT BOUCLE_ASCIItoINT puissance = puissance / 10 SAUT DEBUT_BOUCLE_ASCIItoINT FINSI RETOUR total FIN_FONCTION #------------------------------------------------------------------------------------------------------------------ # # FONCTION : table_exp_reg # # PARAMETRES: # cle de type POINTEUR # Table_externe de type POINTEUR # date_art de type ENTIER # RETOUR: # POINTEUR #--------------------------------------------------- FONCTION POINTEUR table_exp_reg(POINTEUR cle,POINTEUR Table_Externe ,ENTIER date_art) #FONCTION ENTIER table_exp_reg(POINTEUR cle,POINTEUR Table_Externe ,ENTIER date_art) ############################################################################ # # Nom du fichier: table_exp_reg # # Fonction: # Recupere la valeur correspondante ? la cle (valeur reguliere) # trouvee dans la table externe Prefixe_Portabilite # # En entree : # cle # Table_Externe # date_art # # En sortie: # si OK : pt_valeur # Erreur : g_inull # ############################################################################ # 14/09/2006 FO1965 core ############################################################################ #------------------------------------------------------------------------------------ REGISTRE ENTIER nb_entree REGISTRE ENTIER indice REGISTRE ENTIER erreur REGISTRE ENTIER res REGISTRE ENTIER pos_sep REGISTRE ENTIER caract REGISTRE POINTEUR pt_cle REGISTRE POINTEUR pt_valeur REGISTRE POINTEUR pt_clevaleur DEBUT_FONCTION #-initialisation des variables pt_cle="01234567890123456789-01234567890123456789" pt_valeur="01234567890123456789" pt_clevaleur="01234567890123456789-01234567890123456789;01234567890123456789" indice=0 #-- recuperer le nombre d entree dans la table exterbe Table_Externe nb_entree=i_get_tab_nb_entries(Table_Externe,date_art) trace1("SMS-C nb entree de la table est :<%d>",nb_entree) # Pour chaque entree SI(nb_entree==0) ALORS trace("Zero entree dans la table") RETOUR 0 FINSI indice=0 POINT BOUCLE_NB_ENTRY erreur=i_get_tab_one_entry (Table_Externe,date_art,indice,pt_clevaleur) SI(!i_strcmp(pt_clevaleur,g_inull)) ALORS # cle non trouve EOF table externe trace("EOF table externe") RETOUR 0 FINSI # Appel a la fonction i_recuperValeur pour extraire la cle et la valeur erreur=i_recupererValeur(pt_clevaleur,pt_cle,42,';') SI(erreur!=0) ALORS trace("Erreur fonction i_recupererValeur") RETOUR 0 FINSI erreur=i_recupererValeur(pt_clevaleur,pt_valeur,21,';') SI(erreur!=0) ALORS trace("Erreur fonction i_recupererValeur") RETOUR 0 FINSI SI ( i_adequation_chaine_expreg(cle, pt_cle)==0 ) ALORS # trace2 ("valeur associee a <%s> : <%s>", pt_valeur, pt_resultat) #RETOUR 1 RETOUR pt_valeur FINSI indice=indice+1 SI(indice> 24 SI poids_fort == 0 ALORS val_AB = res SINON # restauration a 1 du poids fort val_AB = res | 128 FINSI SI val_AB == 0 ALORS i_strcpy(pt_AB, "00") SINON fort = 0 SI val_AB > 15 ALORS fort = val_AB >> 4 SI fort == 0 ALORS i_strcpy(pt_A, "0") SINON SI fort == 1 ALORS i_strcpy(pt_A, "1") SINON SI fort == 2 ALORS i_strcpy(pt_A, "2") SINON SI fort == 3 ALORS i_strcpy(pt_A, "3") SINON SI fort == 4 ALORS i_strcpy(pt_A, "4") SINON SI fort == 5 ALORS i_strcpy(pt_A, "5") SINON SI fort == 6 ALORS i_strcpy(pt_A, "6") SINON SI fort == 7 ALORS i_strcpy(pt_A, "7") SINON SI fort == 8 ALORS i_strcpy(pt_A, "8") SINON SI fort == 9 ALORS i_strcpy(pt_A, "9") SINON SI fort == 10 ALORS i_strcpy(pt_A, "A") SINON SI fort == 11 ALORS i_strcpy(pt_A, "B") SINON SI fort == 12 ALORS i_strcpy(pt_A, "C") SINON SI fort == 13 ALORS i_strcpy(pt_A, "D") SINON SI fort == 14 ALORS i_strcpy(pt_A, "E") SINON SI fort == 15 ALORS i_strcpy(pt_A, "F") FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI faible = val_AB & 15 SI faible == 0 ALORS i_strcpy(pt_B, "0") SINON SI faible == 1 ALORS i_strcpy(pt_B, "1") SINON SI faible == 2 ALORS i_strcpy(pt_B, "2") SINON SI faible == 3 ALORS i_strcpy(pt_B, "3") SINON SI faible == 4 ALORS i_strcpy(pt_B, "4") SINON SI faible == 5 ALORS i_strcpy(pt_B, "5") SINON SI faible == 6 ALORS i_strcpy(pt_B, "6") SINON SI faible == 7 ALORS i_strcpy(pt_B, "7") SINON SI faible == 8 ALORS i_strcpy(pt_B, "8") SINON SI faible == 9 ALORS i_strcpy(pt_B, "9") SINON SI faible == 10 ALORS i_strcpy(pt_B, "A") SINON SI faible == 11 ALORS i_strcpy(pt_B, "B") SINON SI faible == 12 ALORS i_strcpy(pt_B, "C") SINON SI faible == 13 ALORS i_strcpy(pt_B, "D") SINON SI faible == 14 ALORS i_strcpy(pt_B, "E") SINON SI faible == 15 ALORS i_strcpy(pt_B, "F") FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI res = i_format_str2( pt_AB, "%s%s", pt_A, pt_B) FINSI # **************************************** Octet CD **************************************** # masque de AB (00FFFFFF = 16777215) res = num & 16777215 val_CD = res >> 16 SI val_CD == 0 ALORS i_strcpy(pt_CD, "00") SINON fort = 0 SI val_CD > 15 ALORS fort = val_CD >> 4 SI fort == 0 ALORS i_strcpy(pt_C, "0") SINON SI fort == 1 ALORS i_strcpy(pt_C, "1") SINON SI fort == 2 ALORS i_strcpy(pt_C, "2") SINON SI fort == 3 ALORS i_strcpy(pt_C, "3") SINON SI fort == 4 ALORS i_strcpy(pt_C, "4") SINON SI fort == 5 ALORS i_strcpy(pt_C, "5") SINON SI fort == 6 ALORS i_strcpy(pt_C, "6") SINON SI fort == 7 ALORS i_strcpy(pt_C, "7") SINON SI fort == 8 ALORS i_strcpy(pt_C, "8") SINON SI fort == 9 ALORS i_strcpy(pt_C, "9") SINON SI fort == 10 ALORS i_strcpy(pt_C, "A") SINON SI fort == 11 ALORS i_strcpy(pt_C, "B") SINON SI fort == 12 ALORS i_strcpy(pt_C, "C") SINON SI fort == 13 ALORS i_strcpy(pt_C, "D") SINON SI fort == 14 ALORS i_strcpy(pt_C, "E") SINON SI fort == 15 ALORS i_strcpy(pt_C, "F") FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI faible = val_CD & 15 SI faible == 0 ALORS i_strcpy(pt_D, "0") SINON SI faible == 1 ALORS i_strcpy(pt_D, "1") SINON SI faible == 2 ALORS i_strcpy(pt_D, "2") SINON SI faible == 3 ALORS i_strcpy(pt_D, "3") SINON SI faible == 4 ALORS i_strcpy(pt_D, "4") SINON SI faible == 5 ALORS i_strcpy(pt_D, "5") SINON SI faible == 6 ALORS i_strcpy(pt_D, "6") SINON SI faible == 7 ALORS i_strcpy(pt_D, "7") SINON SI faible == 8 ALORS i_strcpy(pt_D, "8") SINON SI faible == 9 ALORS i_strcpy(pt_D, "9") SINON SI faible == 10 ALORS i_strcpy(pt_D, "A") SINON SI faible == 11 ALORS i_strcpy(pt_D, "B") SINON SI faible == 12 ALORS i_strcpy(pt_D, "C") SINON SI faible == 13 ALORS i_strcpy(pt_D, "D") SINON SI faible == 14 ALORS i_strcpy(pt_D, "E") SINON SI faible == 15 ALORS i_strcpy(pt_D, "F") FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI res = i_format_str2( pt_CD, "%s%s", pt_C, pt_D) FINSI # **************************************** Octet EF **************************************** # masque de ABCD (0000FFFF = 65535) res = num & 65535 val_EF = res >> 8 SI val_EF == 0 ALORS i_strcpy(pt_EF, "00") SINON fort = 0 SI val_EF > 15 ALORS fort = val_EF >> 4 SI fort == 0 ALORS i_strcpy(pt_E, "0") SINON SI fort == 1 ALORS i_strcpy(pt_E, "1") SINON SI fort == 2 ALORS i_strcpy(pt_E, "2") SINON SI fort == 3 ALORS i_strcpy(pt_E, "3") SINON SI fort == 4 ALORS i_strcpy(pt_E, "4") SINON SI fort == 5 ALORS i_strcpy(pt_E, "5") SINON SI fort == 6 ALORS i_strcpy(pt_E, "6") SINON SI fort == 7 ALORS i_strcpy(pt_E, "7") SINON SI fort == 8 ALORS i_strcpy(pt_E, "8") SINON SI fort == 9 ALORS i_strcpy(pt_E, "9") SINON SI fort == 10 ALORS i_strcpy(pt_E, "A") SINON SI fort == 11 ALORS i_strcpy(pt_E, "B") SINON SI fort == 12 ALORS i_strcpy(pt_E, "C") SINON SI fort == 13 ALORS i_strcpy(pt_E, "D") SINON SI fort == 14 ALORS i_strcpy(pt_E, "E") SINON SI fort == 15 ALORS i_strcpy(pt_E, "F") FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI faible = val_EF & 15 SI faible == 0 ALORS i_strcpy(pt_F, "0") SINON SI faible == 1 ALORS i_strcpy(pt_F, "1") SINON SI faible == 2 ALORS i_strcpy(pt_F, "2") SINON SI faible == 3 ALORS i_strcpy(pt_F, "3") SINON SI faible == 4 ALORS i_strcpy(pt_F, "4") SINON SI faible == 5 ALORS i_strcpy(pt_F, "5") SINON SI faible == 6 ALORS i_strcpy(pt_F, "6") SINON SI faible == 7 ALORS i_strcpy(pt_F, "7") SINON SI faible == 8 ALORS i_strcpy(pt_F, "8") SINON SI faible == 9 ALORS i_strcpy(pt_F, "9") SINON SI faible == 10 ALORS i_strcpy(pt_F, "A") SINON SI faible == 11 ALORS i_strcpy(pt_F, "B") SINON SI faible == 12 ALORS i_strcpy(pt_F, "C") SINON SI faible == 13 ALORS i_strcpy(pt_F, "D") SINON SI faible == 14 ALORS i_strcpy(pt_F, "E") SINON SI faible == 15 ALORS i_strcpy(pt_F, "F") FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI res = i_format_str2( pt_EF, "%s%s", pt_E, pt_F) FINSI # **************************************** Octet GH **************************************** # masque de ABCDEF (000000FF = 255) val_GH = num & 255 SI val_GH == 0 ALORS i_strcpy(pt_GH, "00") SINON fort = 0 SI val_GH > 15 ALORS fort = val_GH >> 4 SI fort == 0 ALORS i_strcpy(pt_G, "0") SINON SI fort == 1 ALORS i_strcpy(pt_G, "1") SINON SI fort == 2 ALORS i_strcpy(pt_G, "2") SINON SI fort == 3 ALORS i_strcpy(pt_G, "3") SINON SI fort == 4 ALORS i_strcpy(pt_G, "4") SINON SI fort == 5 ALORS i_strcpy(pt_G, "5") SINON SI fort == 6 ALORS i_strcpy(pt_G, "6") SINON SI fort == 7 ALORS i_strcpy(pt_G, "7") SINON SI fort == 8 ALORS i_strcpy(pt_G, "8") SINON SI fort == 9 ALORS i_strcpy(pt_G, "9") SINON SI fort == 10 ALORS i_strcpy(pt_G, "A") SINON SI fort == 11 ALORS i_strcpy(pt_G, "B") SINON SI fort == 12 ALORS i_strcpy(pt_G, "C") SINON SI fort == 13 ALORS i_strcpy(pt_G, "D") SINON SI fort == 14 ALORS i_strcpy(pt_G, "E") SINON SI fort == 15 ALORS i_strcpy(pt_G, "F") FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI faible = val_GH & 15 SI faible == 0 ALORS i_strcpy(pt_H, "0") SINON SI faible == 1 ALORS i_strcpy(pt_H, "1") SINON SI faible == 2 ALORS i_strcpy(pt_H, "2") SINON SI faible == 3 ALORS i_strcpy(pt_H, "3") SINON SI faible == 4 ALORS i_strcpy(pt_H, "4") SINON SI faible == 5 ALORS i_strcpy(pt_H, "5") SINON SI faible == 6 ALORS i_strcpy(pt_H, "6") SINON SI faible == 7 ALORS i_strcpy(pt_H, "7") SINON SI faible == 8 ALORS i_strcpy(pt_H, "8") SINON SI faible == 9 ALORS i_strcpy(pt_H, "9") SINON SI faible == 10 ALORS i_strcpy(pt_H, "A") SINON SI faible == 11 ALORS i_strcpy(pt_H, "B") SINON SI faible == 12 ALORS i_strcpy(pt_H, "C") SINON SI faible == 13 ALORS i_strcpy(pt_H, "D") SINON SI faible == 14 ALORS i_strcpy(pt_H, "E") SINON SI faible == 15 ALORS i_strcpy(pt_H, "F") FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI res = i_format_str2( pt_GH, "%s%s", pt_G, pt_H) FINSI # concatenation AB CD EF GH res = i_format_str2( pt_hex, "%s%s", pt_AB, pt_CD) res = i_format_str2( pt_BUF, "%s%s", pt_hex, pt_EF) res = i_format_str2( pt_hex, "%s%s", pt_BUF, pt_GH) RETOUR pt_hex FIN_FONCTION # FIN_CORPS