DEFINITION CREJ_ERR03_800010475 0x6031
DEFINITION CREJ_ERR02_800010475 0x6021
DEFINITION CREJ_ERR04_800010475 0x6041
DEFINITION CREJ_ERR01_800010475 0x6011
DEFINITION duree_conv_max_800010475 648000
DEFINITION C_PREF_SCP_EPORT_800010475 "840"
DEFINITION C_PREF_SRP_EPORT_800010475 "842"
DEFINITION C_PREF_NEUF_800010475 "09999"
DEFINITION C_PREF_ONE2ONE_800010475 "15090"
DEFINITION C_PREF_AUTRES150_800010475 "150"
DEFINITION C_ZDT_800010475 "06#"
DEFINITION NVN_800010475 1
DEFINITION NAZ_800010475 2
DEFINITION NVID_800010475 3
DEFINITION NVIA_800010475 4
DEFINITION NIND2_800010475 5
DEFINITION UIFS_800010475 6
DEFINITION IDSV7_800010475 7
DEFINITION NIND3_800010475 8
DEFINITION NUMNOIR_800010475 18
DEFINITION AUT_BIDON_800010475 "BIDON"
DEFINITION AUT_NDEUR_800010475 "LA_NDEUR"
DEFINITION AUT_NDEUR2_800010475 "LA_NDEUR2"
DEFINITION AUT_NDETR_800010475 "LA_NDETR"
DEFINITION AUT_NDETR2_800010475 "LA_NDETR2"
DEFINITION AUT_NDE_800010475 "LA_NDE"
DEFINITION RES_CLDEST_800010475 1
DEFINITION RES_TYPCTR_800010475 2
DEFINITION RES_CODCIR_800010475 3
DEFINITION RES_CODCIRDR_800010475 5
DEFINITION RES_UNITE_800010475 6
DEFINITION RES_TYPCOM_800010475 0
DEFINITION COD_Q_800010475 2
DEFINITION COD_D_800010475 3
DEFINITION CTR_NONE_800010475 0
DEFINITION CTR_MAX_800010475 1
DEFINITION CTR_EGAL_800010475 3
DEFINITION CODE_LA_800010475 6
DEFINITION BASE_LA_800010475 2
DEFINITION valo_max_800010475 6896500
DEFINITION BASE_AUDIO_800010475 1
DEFINITION CODE_AUDIO_800010475 1
DEFINITION CATEG_AUDIO_800010475 8
REGISTRE ENTIER SCP_SPORTABILITE_800010475
REGISTRE ENTIER REROUTAGE_800010475
REGISTRE ENTIER GVI_800010475
REGISTRE ENTIER REROUTAGE_ACCOMPAGNE_800010475
REGISTRE ENTIER PAYEUR_REROUTE_800010475
REGISTRE ENTIER C_800010475
REGISTRE ENTIER M_800010475
REGISTRE ENTIER M_IDSV20_NAS_800010475
REGISTRE ENTIER UT1_800010475
REGISTRE ENTIER UT2_800010475
REGISTRE ENTIER SRP_800010475
REGISTRE ENTIER SCP_800010475
REGISTRE ENTIER erreur_800010475
REGISTRE ENTIER res_800010475
REGISTRE ENTIER code_rejet_800010475
REGISTRE ENTIER natach_800010475
REGISTRE ENTIER idsv_800010475
REGISTRE ENTIER sdate_conv_800010475
REGISTRE ENTIER sdate_mv_800010475
REGISTRE ENTIER reroutage_nas_800010475
REGISTRE ENTIER inf_idus_800010475
REGISTRE ENTIER dedeini_800010475
REGISTRE ENTIER pref_a_retirer_800010475
REGISTRE ENTIER nelem_800010475
REGISTRE ENTIER indice_800010475
REGISTRE ENTIER detr_inf_800010475
REGISTRE ENTIER detr1_inf_800010475
REGISTRE ENTIER lg_800010475
REGISTRE ENTIER inf2_800010475
REGISTRE ENTIER hdconv_nok_800010475
REGISTRE ENTIER hdconv_800010475
REGISTRE ENTIER duree_conv_800010475
REGISTRE ENTIER duree_mvpar_800010475
REGISTRE ENTIER duree_mvacc_800010475
REGISTRE ENTIER duree_mvaut_800010475
REGISTRE ENTIER categ_800010475
REGISTRE ENTIER categ_IDSV20_NAS_800010475
REGISTRE ENTIER ddeur_etr_800010475
REGISTRE ENTIER CPTX_800010475
REGISTRE ENTIER indice_DETR_800010475
REGISTRE ENTIER indice_NTR_800010475
REGISTRE ENTIER type_valo_800010475
REGISTRE ENTIER D_800010475
REGISTRE ENTIER quantum_800010475
REGISTRE ENTIER One2one_800010475
REGISTRE ENTIER CCD_800010475
REGISTRE ENTIER tmv1_800010475
REGISTRE ENTIER tmv2_800010475
REGISTRE ENTIER unite1_800010475
REGISTRE ENTIER unite2_800010475
REGISTRE ENTIER unite3_800010475
REGISTRE ENTIER DURFACT_800010475
REGISTRE ENTIER val1_800010475
REGISTRE ENTIER val2_800010475
REGISTRE ENTIER bourrage0DEDE_800010475
REGISTRE ENTIER bourrage0DEDEini_800010475
REGISTRE ENTIER VMV1_1_800010475
REGISTRE ENTIER VMV1_2_800010475
REGISTRE ENTIER VMV1_3_800010475
REGISTRE ENTIER VMV2_1_800010475
REGISTRE ENTIER VMV2_2_800010475
REGISTRE ENTIER VMV2_3_800010475
REGISTRE ENTIER CODCIRDR_800010475
REGISTRE ENTIER dede_court_800010475
REGISTRE ENTIER dedeini_court_800010475
REGISTRE ENTIER FLAG1_800010475
REGISTRE POINTEUR pt_memo_800010475
REGISTRE POINTEUR pt_DEMANDE_800010475
REGISTRE POINTEUR pt_NUM_800010475
REGISTRE POINTEUR pt_DEMANDEUR_800010475
REGISTRE POINTEUR pt_BUF_800010475
REGISTRE POINTEUR pt_TRADUIT_800010475
REGISTRE POINTEUR pt_DEDE_NORM_800010475
REGISTRE POINTEUR pt_IDUS_NORM_800010475
REGISTRE POINTEUR pt_DEDE_NUM_N_800010475
REGISTRE POINTEUR pt_ZDT_800010475
REGISTRE POINTEUR pt_CODCIRDA_800010475
################################################################################
#	Article convergent Libre Appel / AudiotelADC Nas Existant
#       RECYCLAGE
################################################################################
#
#     HISTORIQUE
#	04/11/04 -PSA- Creation
#	06/04/05 -DRE- G2R1Cm : Facturation des appels vers SRP tiers avec ITX
#                               depuis des origines IP
#	23/05/05 -PSA- G2R1Ca : initialisation p_memo
#	08/07/05 -PSA- G2R1Ca : FO1382 traitement SCP_SPORTABILITE
#	02/09/05 -FAL- G2R1Cj : FO1429 Dans certains cas VCDR2 vaut FFFF au lieu de la valeur BdC
#	08/09/05 -FAL- G2R1Cj : FO1448 suppression nouveau prefixe 09999 DEDE ou DEDEini
#	12/09/05 -FAL- G2R1Cj : FO1429 bis Dans certains cas VCDR2 vaut FFFF au lieu de la valeur BdC
#	12/10/05 -PSA- G2R1Co : FO1499 Modification IDSV
#	19/12/05 -PSA- G2R2Ca : FO 1592
#	05/01/06 -PSA- G2R2Ca : FO 1668
#	25/01/06 -FAL- G2R2Ca : FO 1696 ne plus cummuler sup prefixe et sup 0 DEDE_NUN et DEDEINI_NUM
#	07/02/06 -PKH- G2R2Ca : Correction message alarme 7718
#	09/02/06 -PSA- G2R2Ca : FO 1715
#	05/04/06 -FAL- G2R2Cd : FO 1769 normalisation du champ ZDT
#	06/04/06 -FAL- G2R2Cg : FO 1730 Message d'erreur DC recycles 7702 7703 7706 7707 7709 7714 7715 et 7716
#	08/08/06 -FAL- G2R2Cu : FO1925 CODCIR cas SRP
# 25/01/07 -RHE- G3R0Ca : lot2  Numero noir
# 19/03/07 -RHE- G3R0Cb : fusion G3R0Ct, FO2117 DEDE = 118xyz : ne pas mettre de zero devant pour appel BNC
# 16/04/07 -RHE- G3R0Cb : FO2149 TARIF pour BSS avec TYPCOM sans distinction de MER
# 11/06/07 -THE- G3R0Cb : FO2176 Convergent numeros noirs (VALO2)
# 15/06/07 -THE- G3R0Cb : FO2176 Convergent numeros noirs (VALO2) partie TAX1
#	05/10/07 -BEA- G3R3Cv : Conv_AULA_S13F5.doc
#	28/05/08 -DRE- G3R7 FO 2402 :  ouverture Z9 sur SCP convergent
#			La mise en Suvre consiste a reutiliser lIDSV 18 anciennement attribue aux numero noir .
#			Et Contrairement au numero noir, le service Z9 nest pas valorise a 0.
#	17/10/08 -RHE- G3R10 : Numero noir IDSV 20
#	10/11/08 -RHE- G3R10 - QC131: IDSV 18 entraine m?me calcul TAX+ que idsv 5 ou 8 ou appel international
#	28/11/08 -RHE- G3R10 - QC147: IDSV 20 - Acces BNC different entre NAS et N? traduit
#	04/12/08 -THE DRE - G3R10 - QC152 : La recherche en BNC du cout appelant ne se produit pas ? tort pour l'IDSV 20
#	26/12/08 -PSA- G3R11Cy : prise en compte du Z=7
#	30/12/08 -THE- G3R13C3 : remise a jour du code recy (a partir du pcode de traitement)
# 	12/10/11 -DRE- VerifPcode
#	22/12/11 -THE- G3R23C2 : remise a jour du code recy (a partir du pcode de traitement)
#
################################################################################
#
#	Definition des codes de rejet. Le code apparait:
#	dans le fichier des articles rejetes.
#
#VerifPcode
# Duree max de conversation : 18H soit 648 000 dixiemes de seconde
# Definition des prefixes caracterisant la communication
#VerifPcode
# Definition des services Libre Appel connus IDSV
# Indice des automates de normalisation
#VerifPcode
# Codes de consultation des parametres proc_copo
# Codes definissant les types de parametre de tranche horaire a recuperer
# Types de controle de proc_copo
# Definition pour appel base de comptage SCP
# Valorisation maximale calculable par la base de comptage
# Definition pour appel base de comptage SRP


#Variables intermediaires utilisees
#VerifPcode
# Taxe MV Parcage Accueil et Debordement
# Taxe MV Fermeture Renvoi et Interdiction


#VerifPcode
#VerifPcode
#VerifPcode


# Initialisation des variables
CODCIRDR_800010475	 = 0xffffffff
UT1_800010475		 = 0xffff
UT2_800010475		 = 0xffff
CCD_800010475		 = 0xff
REROUTAGE_800010475	 = 0
GVI_800010475		 = 0
REROUTAGE_ACCOMPAGNE_800010475 = 0
PAYEUR_REROUTE_800010475	 = 0
C_800010475		 = 0
M_800010475		 = 0
M_IDSV20_NAS_800010475	 = 0
SRP_800010475		 = 0
SCP_800010475		 = 0
SCP_SPORTABILITE_800010475 = 0
idsv_800010475		 = 0
reroutage_nas_800010475	 = 0
inf_idus_800010475	 = 0
dedeini_800010475		 = 0
nelem_800010475		 = 0
detr_inf_800010475	 = 0
detr1_inf_800010475	 = 0
lg_800010475		 = 0
inf2_800010475		 = 0
hdconv_nok_800010475	 = 0
duree_conv_800010475	 = 0
duree_mvpar_800010475	 = 0
duree_mvacc_800010475	 = 0
duree_mvaut_800010475	 = 0
categ_800010475		 = 0
categ_IDSV20_NAS_800010475 = 0
ddeur_etr_800010475	 = 0
CPTX_800010475		 = 0
indice_DETR_800010475	 = 0
indice_NTR_800010475	 = 0
type_valo_800010475	 = 0
One2one_800010475		 = 0
tmv1_800010475		 = 0
tmv2_800010475		 = 0
VMV1_1_800010475		 = 0xffff
VMV1_2_800010475		 = 0xffff
VMV1_3_800010475		 = 0xffff
VMV2_1_800010475		 = 0xffff
VMV2_2_800010475		 = 0xffff
VMV2_3_800010475		 = 0xffff
#VerifPcode
#hdfin		 = 0
#hduree		 = 0
#int_detr	 = 0
hdconv_800010475		 = 0
natach_800010475		 = 0
sdate_conv_800010475	 = 0
sdate_mv_800010475	 = 0
unite1_800010475		 = 0
unite2_800010475		 = 0
unite3_800010475		 = 0
DURFACT_800010475		 = 0xffff
pref_a_retirer_800010475	 = 0
val1_800010475		 = 0
val2_800010475		 = 0
bourrage0DEDE_800010475	 = 0
bourrage0DEDEini_800010475 = 0
dede_court_800010475	 = 0
dedeini_court_800010475	 = 0


pt_NUM_800010475		 = "999999999999999999999999999999999999999999999999999999999999999"
pt_DEMANDE_800010475	 = "66666666666666666666666666666666666666666666666666666666666666"
pt_DEMANDEUR_800010475	 = "555555555555555555555555555555555555555555555555555555555555"
pt_BUF_800010475		 = "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
#VerifPcode
#pt_BUF100	 = "1001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001001"
pt_TRADUIT_800010475	 = "11111111111111111111111111111111111111111111111111111111111111"
pt_DEDE_NORM_800010475	 = "777777777777777777777777777777777777777777777777777777777777777777"
pt_IDUS_NORM_800010475	 = "888888888888888888888888888888888888888888888888888888888888888888"
pt_DEDE_NUM_N_800010475	 = "000000000000000000000000000000000000000000000000000000000000000"
pt_ZDT_800010475		 = "721345567890"
#VerifPcode
pt_CODCIRDA_800010475	 = "53453546"
pt_memo_800010475		 = "2227685949030222276859490302"


i_strcpy(pt_NUM_800010475,"")
i_strcpy(pt_DEMANDE_800010475,"")
i_strcpy(pt_DEMANDEUR_800010475,"")
i_strcpy(pt_BUF_800010475,"")
#VerifPcode
#i_strcpy(pt_BUF100,"")
i_strcpy(pt_TRADUIT_800010475,"")
i_strcpy(pt_DEDE_NORM_800010475,"")
i_strcpy(pt_IDUS_NORM_800010475,"")
i_strcpy(pt_DEDE_NUM_N_800010475,"")
i_strcpy(pt_ZDT_800010475,"")
#VerifPcode
i_strcpy(pt_CODCIRDA_800010475,"")
i_strcpy(pt_memo_800010475,"")



# Duplication de l'article
erreur_800010475 = i_dup_art_id(g_iartin, g_iartout)

#==============================================================================
#              VARIABLES FONCTIONNELLES
#==============================================================================

#QC425 correction valorisation de SCP_SPORTABILITE avec DETR1_INT si present ou DETR_INT

SI (i_valid_field_n(g_iartout, $TconvNE::DETR1_INT))
ALORS
	res_800010475 = i_get_art_field(g_iartout, $TconvNE::DETR1_INT)
SINON
	res_800010475 = i_get_art_field(g_iartout, $TconvNE::DETR_INT)
FINSI
res_800010475 = res_800010475 / 0x1000

SI (res_800010475==2)
ALORS
	SCP_SPORTABILITE_800010475 = 1
FINSI

SI (i_valid_field_n(g_iartout, $TconvNE::T3enap))
ALORS
	SI (i_valid_field_n(g_iartout, $TconvNE::NTR1))
	ALORS
		REROUTAGE_800010475 = 1
	FINSI

	SI ( ( (i_get_art_field(g_iartout, $TconvNE::DETR_INT) & 0xf000) ) == 0xC000 )
	ALORS
		GVI_800010475 = 1
	FINSI

	SI (i_valid_field_n(g_iartout, $TconvNE::DEDE1_NUM))
	ALORS
		reroutage_nas_800010475 = 1
	FINSI
FINSI

inf_idus_800010475 = i_get_art_field(g_iartout, $TconvNE::IDUS_INF)

SI ((inf_idus_800010475 & 0x01)==1)
ALORS
	REROUTAGE_ACCOMPAGNE_800010475 = 1
FINSI

dedeini_800010475 = i_valid_field_n(g_iartout, $TconvNE::DEDEINI_NUM)

SI (i_valid_field_n(g_iartout, $TconvNE::T3plt))
ALORS
	C_800010475 = (0x7f & (i_get_art_field(g_iartout, $TconvNE::PLT)))
SINON
	C_800010475 = 0x00
FINSI

SI ( REROUTAGE_800010475 &&  GVI_800010475 ) || ( REROUTAGE_800010475 && !GVI_800010475 && ( C_800010475 == 7 ) && !REROUTAGE_ACCOMPAGNE_800010475 )
ALORS
	PAYEUR_REROUTE_800010475 = 1
SINON
	PAYEUR_REROUTE_800010475 = 0
FINSI

idsv_800010475 = i_get_art_field(g_iartout, $TconvNE::IDSV)

SI ( ( idsv_800010475 >= 1 ) && ( idsv_800010475 <= 9 ) ) || ( idsv_800010475 == 18 ) || ( idsv_800010475 == 20 )
ALORS
	SCP_800010475 = 1
SINON
	# G3R23C1 idsv 22
	SI ( idsv_800010475 == 0 ) || ( ( idsv_800010475 >= 11 ) && ( idsv_800010475 <= 17 ) ) || ( idsv_800010475 == 19 ) || ( idsv_800010475 == 21 ) || ( idsv_800010475 == 22 )
	ALORS
		SRP_800010475 = 1
	SINON
		code_rejet_800010475 = CREJ_ERR04_800010475
		erreur_800010475 = i_PlvMessEmettre(7712,2,g_iartin,"",1,code_rejet_800010475,0,0)
		SAUT STOCKE_ERRONE
	FINSI
FINSI

#==============================================================================
#	Controle semantique : verification que tous les quartets d un NAS court
#	( 1er digit a 0) ne sont pas nuls
#==============================================================================

SI ( reroutage_nas_800010475 == 1 )
ALORS
	SI ( g_iartout.DEDE1_NUM[0] == 0 )
	ALORS
		nelem_800010475 = g_iartout.DEDE1_NUM!NELEM
		indice_800010475 = 1

		POINT TEST_DEDE1

		SI ( indice_800010475 < nelem_800010475 )
		ALORS
			SI ( g_iartout.DEDE1_NUM[indice_800010475] == 0 )
			ALORS
				indice_800010475 = indice_800010475 +1
				SAUT TEST_DEDE1
			SINON
				SAUT DEDE1_NON_NUL
			FINSI
		SINON
			SAUT DEDE_NUL
		FINSI
	FINSI
FINSI

POINT DEDE1_NON_NUL

SI ( dedeini_800010475 == 1 )
ALORS
	SI ( g_iartout.DEDEINI_NUM[0] == 0 )
	ALORS
		nelem_800010475 = g_iartout.DEDEINI_NUM!NELEM
		indice_800010475 = 1
		bourrage0DEDEini_800010475 = 1

		POINT TEST_DEDEINI

		SI ( indice_800010475 < nelem_800010475 )
		ALORS
			SI ( g_iartout.DEDEINI_NUM[indice_800010475] == 0 )
			ALORS
				indice_800010475 = indice_800010475 +1
				bourrage0DEDEini_800010475 = bourrage0DEDEini_800010475 + 1
				SAUT TEST_DEDEINI
			SINON
				SAUT DEDEini_NON_NUL
			FINSI
		SINON
			SAUT DEDE_NUL
		FINSI
	FINSI
FINSI

POINT DEDEini_NON_NUL

SI ( g_iartout.DEDE_NUM[0] == 0 )
ALORS
	nelem_800010475 = g_iartout.DEDE_NUM!NELEM
	indice_800010475 = 1
	bourrage0DEDE_800010475 = 1

	POINT TEST_DEDE

	SI ( indice_800010475 < nelem_800010475 )
	ALORS
		SI ( g_iartout.DEDE_NUM[indice_800010475] == 0 )
		ALORS
			indice_800010475 = indice_800010475 +1
			bourrage0DEDE_800010475 = bourrage0DEDE_800010475 + 1
			SAUT TEST_DEDE
		SINON
			SAUT DEDE_NON_NUL
		FINSI
	SINON
		SAUT DEDE_NUL
	FINSI
FINSI

SAUT DEDE_NON_NUL

POINT DEDE_NUL

code_rejet_800010475 = CREJ_ERR04_800010475
erreur_800010475 = i_PlvMessEmettre(7710,2,g_iartin,"",1,code_rejet_800010475,0,0)
SAUT STOCKE_ERRONE

POINT DEDE_NON_NUL

#==============================================================================
#	Mise a jour des Ajouts qui seront utiles pour la distribution
#==============================================================================
erreur_800010475 = i_ajoutChampNum(g_iartout, $TconvNE::T4ccd,$TconvNE::CCD,6)

#################################################################################
# Champs DETR_INF_N et DETR_NUM_N
#################################################################################
# Verifier si le resize est utile
detr_inf_800010475 = i_get_art_field(g_iartout, $TconvNE::DETR_INF)

SI ((detr_inf_800010475 & 0x30) != 0x10) || (!i_valid_field_n(g_iartout, $TconvNE::DETR_NUM))
ALORS
	SI (!i_valid_field_n(g_iartout, $TconvNE::DETD_NUM))
	ALORS
		SI (!i_valid_field_n(g_iartout, $TconvNE::DETN_NUM))
		ALORS
			#trace("On force DETR_NUM_N avec '000000000000'")
			erreur_800010475 = i_resize_tlv(g_iartout, "T4detr_n", "NTR_N", 48)
			erreur_800010475 = i_memset_field(g_iartout, "NTR_N", 0x00)
		SINON
			#trace("On force DETR_NUM_N avec DETN_NUM")
			lg_800010475 = (g_iartout.DETN_NUM!NELEM)*4
			inf2_800010475 = ((i_get_art_field(g_iartout, $TconvNE::DETN_INF) & 0xC0 ) | 0x10)
			erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::DETR_INF_N, inf2_800010475)
			erreur_800010475 = i_dup_chp_1val(g_iartout, g_iartout, $TconvNE::DETN_NUM, $TconvNE::DETR_NUM_N)
			erreur_800010475 = i_resize_tlv(g_iartout, "T4detr_n", "DETR_NUM_N", lg_800010475)
		FINSI
	SINON
		#trace("On force DETR_NUM_N avec DETD-NUM")
		lg_800010475 = (g_iartout.DETD_NUM!NELEM)*4
		inf2_800010475 = ((i_get_art_field(g_iartout, $TconvNE::DETD_INF) & 0xC0 ) | 0x10)
		erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::DETR_INF_N, inf2_800010475)
		erreur_800010475 = i_dup_chp_1val(g_iartout, g_iartout, $TconvNE::DETD_NUM, $TconvNE::DETR_NUM_N)
		erreur_800010475 = i_resize_tlv(g_iartout, "T4detr_n", "DETR_NUM_N", lg_800010475)
	FINSI
SINON
	lg_800010475 = (g_iartout.DETR_NUM!NELEM)*4
	erreur_800010475 = i_dup_chp_1val(g_iartout, g_iartout, $TconvNE::NTR, $TconvNE::NTR_N)
	erreur_800010475 = i_resize_tlv(g_iartout, "T4detr_n", "DETR_NUM_N", lg_800010475)
FINSI

detr_inf_800010475 = i_get_art_field(g_iartout, $TconvNE::DETR_INF)

#################################################################################
# Champs DETR1_INF_N et DETR1_NUM_N
#################################################################################
# Verifier si le resize est utile

SI (i_valid_field_n(g_iartout, $TconvNE::DETR1_NUM))
ALORS
	detr1_inf_800010475 = i_get_art_field(g_iartout, $TconvNE::DETR1_INF)

	SI ((detr1_inf_800010475 & 0x30) != 0x10)
	ALORS
		SI (!i_valid_field_n(g_iartout, $TconvNE::DETD_NUM))
		ALORS
			SI (!i_valid_field_n(g_iartout, $TconvNE::DETN_NUM))
			ALORS
				#trace("On force DETR1_NUM_N avec '000000000000'")
				erreur_800010475 = i_resize_tlv(g_iartout, "T4detr1_n", "NTR1_N", 48)
				erreur_800010475 = i_memset_field(g_iartout, "NTR1_N", 0x00)
			SINON
				#trace("On force DETR1_NUM_N avec DETN_NUM")
				lg_800010475 = (g_iartout.DETN_NUM!NELEM)*4
				inf2_800010475 = ((i_get_art_field(g_iartout, $TconvNE::DETN_INF) & 0xC0 ) | 0x10)
				erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::DETR1_INF_N, inf2_800010475)
				erreur_800010475 = i_dup_chp_1val(g_iartout, g_iartout, $TconvNE::DETN_NUM, $TconvNE::DETR1_NUM_N)
				erreur_800010475 = i_resize_tlv(g_iartout, "T4detr1_n", "DETR1_NUM_N", lg_800010475)
			FINSI
		SINON
			#trace("On force DETR1_NUM_N avec DETD-NUM")
			lg_800010475 = (g_iartout.DETD_NUM!NELEM)*4
			inf2_800010475 = ((i_get_art_field(g_iartout, $TconvNE::DETD_INF) & 0xC0 ) | 0x10)
			erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::DETR1_INF_N, inf2_800010475)
			erreur_800010475 = i_dup_chp_1val(g_iartout, g_iartout, $TconvNE::DETD_NUM, $TconvNE::DETR1_NUM_N)
			erreur_800010475 = i_resize_tlv(g_iartout, "T4detr1_n", "DETR1_NUM_N", lg_800010475)
		FINSI
	SINON
		lg_800010475 = (g_iartout.DETR1_NUM!NELEM)*4
		erreur_800010475 = i_dup_chp_1val(g_iartout, g_iartout, $TconvNE::NTR1, $TconvNE::NTR1_N)
		erreur_800010475 = i_resize_tlv(g_iartout, "T4detr1_n", "DETR1_NUM_N", lg_800010475)
	FINSI
SINON
	erreur_800010475 = i_supprChamp(g_iartout, "T4detr1_n")
FINSI

# Champs DETR_INF_PAY et DETR_NUM_PAY

SI PAYEUR_REROUTE_800010475
ALORS
	lg_800010475 = (g_iartout.DETR1_NUM_N!NELEM)*4
	erreur_800010475 = i_dup_chp_1val(g_iartout, g_iartout, $TconvNE::DETR1_INT, $TconvNE::DETR_INT_PAY)
	erreur_800010475 = i_dup_chp_1val(g_iartout, g_iartout, $TconvNE::NTR1_N, $TconvNE::NTR_PAY)
SINON
	lg_800010475 = (g_iartout.DETR_NUM_N!NELEM)*4
	erreur_800010475 = i_dup_chp_1val(g_iartout, g_iartout, $TconvNE::DETR_INT, $TconvNE::DETR_INT_PAY)
	erreur_800010475 = i_dup_chp_1val(g_iartout, g_iartout, $TconvNE::NTR_N, $TconvNE::NTR_PAY)
FINSI

erreur_800010475 = i_resize_tlv(g_iartout, "T4detr_pay", "DETR_NUM_PAY", lg_800010475)

# Champ DEDE_N
# !!!!!!! A verifier : pour SRP, on utilise en priorite DEDE1 puis DEDE (calcul du CCD par apport au NAS reroute) : traitement non conforme a la spec
# !!!!!!! A verifier : pour SCP, on utilise en priorite DEDEINI puis DEDE (calcul du cout appelant par rapport au NAS initial)

lg_800010475 = (g_iartout.DEDE_NUM!NELEM)*4
erreur_800010475 = i_dup_chp_1val(g_iartout, g_iartout, $TconvNE::DEDE_NUM, $TconvNE::DEDE_NUM_N)
i_strcpy(pt_DEMANDE_800010475, "DEDE_NUM")
erreur_800010475 = i_resize_tlv(g_iartout, "T4dede_n", "DEDE_NUM_N", lg_800010475)

erreur_800010475 = i_get_art_str(g_iartout, $TconvNE::DEDE_NUM_N, pt_NUM_800010475)
#trace2(" ##### DEDE_NUM_N avec prefixe <%s> ", pt_NUM,"")

# Si on detecte un prefixe devant le demande, on met a jour le champ DEDE_PREF en respectant la norme suivante :
# - prefixe vaut 840XY, DEDE_PREF vaut 1
# - prefixe vaut 150XY, DEDE_PREF vaut 2
# - prefixe vaut 842XY, DEDE_PREF vaut 3

# prefixes sur 5 digits
i_get_sub_str(pt_NUM_800010475,0,4,pt_NUM_800010475)

SI (( i_strcmp(pt_NUM_800010475, C_PREF_ONE2ONE_800010475) == 0 ) && (idsv_800010475 == 2))
ALORS
	erreur_800010475 = i_set_art_field(g_iartout,$TconvNE::DEDE_PREF,2)
	One2one_800010475 = 1
	pref_a_retirer_800010475 = 1
	UT2_800010475 = 0
FINSI

SI ( i_strcmp(pt_NUM_800010475, C_PREF_NEUF_800010475) == 0 )
ALORS
	erreur_800010475 = i_set_art_field(g_iartout,$TconvNE::DEDE_PREF,2)
	pref_a_retirer_800010475 = 1
FINSI

#####################################################################################
# Evolution a venir : gestion du prefixe 088888 (audiotel court depuis un tiers)
# Penser a mettre dede_court a 1
# A faire aussi pour DEDEini
#####################################################################################

# prefixes sur 3 digits
i_get_sub_str(pt_NUM_800010475,0,2,pt_NUM_800010475)

SI ( i_strcmp(pt_NUM_800010475, C_PREF_SCP_EPORT_800010475) == 0 )
ALORS
	pref_a_retirer_800010475 = 1
	erreur_800010475 = i_set_art_field(g_iartout,$TconvNE::DEDE_PREF,1)
FINSI

SI ( i_strcmp(pt_NUM_800010475, C_PREF_AUTRES150_800010475) == 0 )
ALORS
	pref_a_retirer_800010475 = 1
	erreur_800010475 = i_set_art_field(g_iartout,$TconvNE::DEDE_PREF,2)
FINSI

SI ( i_strcmp(pt_NUM_800010475, C_PREF_SRP_EPORT_800010475) == 0 )
ALORS
	erreur_800010475 = i_set_art_field(g_iartout,$TconvNE::DEDE_PREF,3)
	pref_a_retirer_800010475 = 1
FINSI

SI ( pref_a_retirer_800010475 == 1)
ALORS
	erreur_800010475 = i_supp_quart_num($TconvNE::DEDE_NUM_N, 0, 5, 0x0f, g_iartout, g_iartout)
	#trace("WWW #### DEDE_NUM_N pas de suppression des 0 car deja sup prefixe")
SINON
	# suppression des 0 de gauche pour les numeros courts
	SI (bourrage0DEDE_800010475 > 0)
	ALORS
		erreur_800010475 = i_supp_quart_num($TconvNE::DEDE_NUM_N, 0, bourrage0DEDE_800010475, 0x0f, g_iartout, g_iartout)
		#trace("WWW FO1696 DEDE_NUM_N suppression des 0 car pas de prefixe")
		dede_court_800010475 = 1
	FINSI
FINSI

# Champ DEDEINI_N

# pref_a_retirer du DEDE_NUM n implique pas pref_a_retirer du DEDEINI_NUM donc init a 0
pref_a_retirer_800010475 = 0

SI ( dedeini_800010475 == 1 )
ALORS
	lg_800010475 = (g_iartout.DEDEINI_NUM!NELEM)*4
	erreur_800010475 = i_dup_chp_1val(g_iartout, g_iartout, $TconvNE::DEDEINI_NUM, $TconvNE::DEDEINI_NUM_N)
	i_strcpy(pt_DEMANDE_800010475, "DEDEini_NUM")
	erreur_800010475 = i_resize_tlv(g_iartout, "T4dedeini_n", "DEDEINI_NUM_N", lg_800010475)

	erreur_800010475 = i_get_art_str(g_iartout, $TconvNE::DEDEINI_NUM_N, pt_NUM_800010475)
	#trace2(" DEDEINI_NUM_N avec prefixe <%s> ", pt_NUM,"")

	# prefixes sur 5 digits
	i_get_sub_str(pt_NUM_800010475,0,4,pt_NUM_800010475)

	SI (( i_strcmp(pt_NUM_800010475, C_PREF_ONE2ONE_800010475) == 0 ) && (idsv_800010475 == 2))
	ALORS
		One2one_800010475 = 1
		pref_a_retirer_800010475 = 2
		UT2_800010475 = 0
	FINSI

	SI ( i_strcmp(pt_NUM_800010475, C_PREF_NEUF_800010475) == 0 )
	ALORS
		pref_a_retirer_800010475 = 1
	FINSI

	# prefixes sur 3 digits
	i_get_sub_str(pt_NUM_800010475,0,2,pt_NUM_800010475)

	SI ( i_strcmp(pt_NUM_800010475, C_PREF_AUTRES150_800010475) == 0 )
	ALORS
		pref_a_retirer_800010475 = 1
	FINSI

	SI ( i_strcmp(pt_NUM_800010475, C_PREF_SCP_EPORT_800010475) == 0 )
	ALORS
		pref_a_retirer_800010475 = 1
	FINSI

	SI ( i_strcmp(pt_NUM_800010475, C_PREF_SRP_EPORT_800010475) == 0 )
	ALORS
		pref_a_retirer_800010475 = 2
	FINSI

	erreur_800010475 = i_set_art_field(g_iartout,$TconvNE::DEDEINI_PREF,pref_a_retirer_800010475)

	SI ( pref_a_retirer_800010475 != 0)
	ALORS
		erreur_800010475 = i_supp_quart_num($TconvNE::DEDEINI_NUM_N, 0, 5, 0x0f, g_iartout, g_iartout)
		#trace("WWW #### DEDEINI_NUM_N pas de suppression des 0 car deja sup prefixe")
		# soit sup prefixe soit 0
	SINON
		#trace1(" DEDEINI_NUM One2one (rmq)  <%d> " ,One2one)
		#trace1(" DEDEINI_NUM UT2     (rmq)  <%d> " ,UT2)
		#trace1(" DEDEINI_NUM pref_a_retirer <%d> " ,pref_a_retirer)

		# suppression des 0 de gauche pour les numeros courts
		SI (bourrage0DEDEini_800010475 > 0)
		ALORS
			erreur_800010475 = i_supp_quart_num($TconvNE::DEDEINI_NUM_N, 0, bourrage0DEDEini_800010475, 0x0f, g_iartout, g_iartout)
			dedeini_court_800010475 = 1
			#trace("WWW #### DEDEINI_NUM_N suppression des 0 car pas de prefixe")
		FINSI
	FINSI
FINSI

# Champ DEDE_PAY

SI PAYEUR_REROUTE_800010475 && reroutage_nas_800010475
ALORS
	lg_800010475 = (g_iartout.DEDE1_NUM!NELEM)*4
	erreur_800010475 = i_dup_chp_1val(g_iartout, g_iartout, $TconvNE::DEDE1_NUM, $TconvNE::DEDE_NUM_N)
	erreur_800010475 = i_resize_tlv(g_iartout, "T4dede_n", "DEDE_NUM_N", lg_800010475)
	erreur_800010475 = i_set_art_field(g_iartout,$TconvNE::DEDE_REROUTE,1)
FINSI

# A partir de la, on differencie le traitement selon le service

SI ( SCP_800010475 == 1 )
ALORS
	SAUT TRAITEMENT_SCP
FINSI

SI ( SRP_800010475 == 1 )
ALORS
	SAUT TRAITEMENT_SRP
FINSI

# IDSV incorrect : erreur semantique

code_rejet_800010475 = CREJ_ERR04_800010475
erreur_800010475 = i_PlvMessEmettre(7710,2,g_iartin,"",1,code_rejet_800010475,0,0)
SAUT STOCKE_ERRONE

##########################################################
# Valorisation SCP : reprise/adaptation du pcode Tlane16 #
##########################################################

POINT TRAITEMENT_SCP

# Controle semantique sur le champ HDCONV
# si    HDCONV = FFFFFF alors pas de controle syntaxique => DUREE = 0
# sinon controle syntaxique de HDCONV
erreur_800010475 = i_get_art_str(g_iartout, $TconvNE::HDCONVN,pt_BUF_800010475)

SI (i_strcmp(pt_BUF_800010475,"FFFFFF"))
ALORS
	#trace("Champ HDCONV different de FFFFFF -> controle syntaxique")
	hdconv_800010475 = i_get_art_field(g_iartout, $TconvNE::HDCONV)
	#trace1("hdconv %d",hdconv)

	SI (hdconv_800010475 < 0)
	ALORS
		code_rejet_800010475 = CREJ_ERR04_800010475
		erreur_800010475 =i_PlvMessEmettre(7704,2,g_iartin,"",1,code_rejet_800010475,0,0)
		SAUT STOCKE_ERRONE
	FINSI
SINON
	#trace("Champ HDCONV force a FFFFFF -> pas de controle syntaxique")
	hdconv_nok_800010475 = 1
FINSI

#==============================================================================
#			IDENTIFICATION DES SERVICES
#==============================================================================

# DC porte sortant non valorise
SI SCP_SPORTABILITE_800010475 == 1
ALORS
	SAUT STOCKE_OK
FINSI

# service NVID non valorise
SI (idsv_800010475 == NVID_800010475)
ALORS
#		trace("Article ADCNE LA: service NVID Pas de Valorisation")
	SAUT STOCKE_OK
FINSI

# Controle du champ INF-DETR AB=10 (NRI): TEST 603
# services avec NRI (numero de routage international) non valorises

SI ((detr_inf_800010475 & 0xc0) == 0x80)
ALORS
	#trace("Valorisation nulle imposee NRI")
	UT1_800010475 = 0
	CPTX_800010475 = 0
	SAUT STOCKE_OK
FINSI

# service NVIA et NVN valorise car pas de NRI
# on fixe le parametre M pour le calcul ulterieur de la categorie

SI ((idsv_800010475 == NVIA_800010475) || (idsv_800010475 == NVN_800010475))
ALORS
	M_800010475 = 0
FINSI

# service NAZ valorise
# on fixe le parametre M pour le calcul ulterieur de la categorie

SI (idsv_800010475 == NAZ_800010475)
ALORS
	M_800010475 = 1
FINSI

# services NIND2 valorise
# on fixe le parametre M pour le calcul ulterieur de la categorie
# pour le 802, 820 ou 821, on aura M = 2
# pour le 803, 825 ou 826, on aura M = 3
SI ((idsv_800010475 == NIND2_800010475) || (idsv_800010475 == IDSV7_800010475))
ALORS
	M_800010475 = 2
FINSI

SI (idsv_800010475 == NIND3_800010475)
ALORS
	M_800010475 = 3
FINSI

SI (idsv_800010475 == 6)
ALORS
	M_800010475 = 4
FINSI

SI (idsv_800010475 == NUMNOIR_800010475)
ALORS
	M_800010475 = 6
	UT2_800010475 = 0
FINSI

SI (idsv_800010475 == 20)
ALORS
	M_800010475 = 7
	M_IDSV20_NAS_800010475 = 512
FINSI

#==============================================================================
#			RECUPERATION DES DUREES
#==============================================================================

# Recuperation de la duree de Conversation
# Si INF-DETR CD<>01 alors pas de conversation ou HDCONV non significative

SI ( ( (detr_inf_800010475 & 0x30) != 0x10 ) || ( hdconv_nok_800010475 == 1 ) )
ALORS
	duree_conv_800010475 = 0
SINON
	duree_conv_800010475 = i_get_art_field(g_iartout, $TconvNE::DUREE)
FINSI

SI ( duree_conv_800010475 > duree_conv_max_800010475 )
ALORS
	code_rejet_800010475 = CREJ_ERR04_800010475
	erreur_800010475 = i_PlvMessEmettre(7701,2,g_iartin,"",1,code_rejet_800010475,0,0)
	SAUT STOCKE_ERRONE
FINSI

# Conversion duree conversation en 1/10 secondes en secondes
# (arrondi pas exces)
duree_conv_800010475 = (duree_conv_800010475 + 9) / 10

# Recuperation des durees de Messages Vocaux et conversion de 1/10 secondes
# en seconde (arrondi par exces)

SI (i_valid_field_n(g_iartout, $TconvNE::T3mv))
ALORS
	duree_mvpar_800010475 = i_get_art_field(g_iartout, $TconvNE::DURP)
	duree_mvpar_800010475 = (duree_mvpar_800010475 + 9) / 10
	duree_mvacc_800010475 = i_get_art_field(g_iartout, $TconvNE::DURACC)
	duree_mvacc_800010475 = (duree_mvacc_800010475 + 9) / 10
	duree_mvaut_800010475 = i_get_art_field(g_iartout, $TconvNE::DURAUT)
	duree_mvaut_800010475 = (duree_mvaut_800010475 + 9) / 10
FINSI

# Si aucune duree > 0 alors pas de traitement

SI ( ( duree_conv_800010475 == 0 ) && ( duree_mvpar_800010475 == 0 )
  && ( duree_mvacc_800010475 == 0 ) && ( duree_mvaut_800010475 == 0 ) )
ALORS
	#trace("Toutes les durees sont nulles ...")
	SAUT STOCKE_OK
FINSI

#==============================================================================
#			CALCUL CATEGORIES
#==============================================================================

# Calcul de categorie Duree reelle

categ_800010475 = (8 * C_800010475) + M_800010475
categ_IDSV20_NAS_800010475 = (8 * C_800010475) + M_IDSV20_NAS_800010475

#==============================================================================
#			NORMALISATION LIGNE APPELANTE
#==============================================================================

# Cas INF-IDUS A=1 : appel international insuffisant
# Cas GLA2_NATACH bit A a 0 = definition acheminement national
# => appel national y compris les mobiles etranger appelant de France
# modification ordre des tests

natach_800010475 = i_get_art_field(g_iartout, $TconvNE::NATACH)

FLAG1_800010475 = 0
SI (natach_800010475 & 0x80)
ALORS
	SI ((idsv_800010475 == NVIA_800010475) || (idsv_800010475 == UIFS_800010475))
	ALORS
		SI (i_valid_field_n(g_iartout, $TconvNE::T3cdpo))
		ALORS
			#trace("Normalisation CDPO (0#9ABPQ)")
			erreur_800010475 = i_normal(g_iartout, $TconvNE::CDPO, $TconvNE::CDPO, g_icopo, $Tcopo::NDR,$Tcopo::NDE ,3, AUT_NDEUR2_800010475, AUT_BIDON_800010475)
			i_strcpy(pt_DEMANDEUR_800010475, "CDPO")

			# TEST 632: erreur normalisation CDPO
			SI (erreur_800010475 == -1)
			ALORS
				#trace("Erreur Normalisation CDPO --> (**14)")
				erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR, "**14", 5)
				i_strcpy(pt_DEMANDEUR_800010475, "CDPO par defaut")
			FINSI
		SINON
			# TEST 621: CDPO non present et appel international
			#trace("Normalisation CDPO (**14)")
			i_strcpy(pt_DEMANDEUR_800010475, "CDPO par defaut")
			erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR, "**14", 5)
		FINSI
	SINON
		SI !REROUTAGE_ACCOMPAGNE_800010475
		ALORS
			#trace("Normalisation DDEUR(**22)")
			ddeur_etr_800010475 = 1
			erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR,"**22", 5)
			i_strcpy(pt_DEMANDEUR_800010475, "NATACH par defaut")
		SINON
			FLAG1_800010475 = 1
		FINSI
	FINSI
SINON
	FLAG1_800010475 = 1
FINSI

SI FLAG1_800010475 == 1
ALORS
	# Cas Natach bit A=0 : appel national ou REROUTAGE_ACCOMPAGNE
	#trace ("appel national- bit A natach a 0")
	# Si Z = 8 ou 6 ou 7
	SI ( (g_iartout.IDUS_NUM[0] == 0x6) || (g_iartout.IDUS_NUM[0] == 0x7) ||((g_iartout.IDUS_NUM[0] == 0x8) && (g_iartout.IDUS_NUM[1] != 0x7)) )
	ALORS
		# Si ICCM present
		SI (i_valid_field_n(g_iartout, $TconvNE::T3iccm))
		ALORS
			#trace("Normalisation NUM-ICCM (0ZABPQMCDU)")
			erreur_800010475 = i_normal(g_iartout, $TconvNE::ICCM_NUM,  $TconvNE::ICCM_NUM, g_icopo, $Tcopo::NDR, $Tcopo::NDE ,3, AUT_NDEUR_800010475, AUT_BIDON_800010475)
			i_strcpy(pt_DEMANDEUR_800010475, "ICCM_NUM")

			# TEST 631: erreur normalisation ICCM
			SI (erreur_800010475 == -1)
			ALORS
				#trace("Erreur Normalisation ICCM --> (**13)")
				erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR, "**13", 5)
				i_strcpy(pt_DEMANDEUR_800010475, "ICCM par defaut")
			FINSI
			# Sinon ICCM non present
		SINON
			# Si ZABPQ=8xxx1 ou Z=6
			# TEST 620: ICCM non present et IDUS ZABPQ=8xxx1 ou Z=6 ou Z=7
			SI ((g_iartout.IDUS_NUM[4] == 0x1) || (g_iartout.IDUS_NUM[0] == 0x6) || (g_iartout.IDUS_NUM[0] == 0x7))
			ALORS
				#trace("Normalisation NUM-IDUS (**13)")
				erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR, "**13", 5)
				i_strcpy(pt_DEMANDEUR_800010475, "IDUS_NUM par defaut")
				# Sinon ZABPQ=8xxxx
			SINON
				#trace("Normalisation NUM-IDUS (**00)")
				i_strcpy(pt_DEMANDEUR_800010475, "IDUS_NUM par defaut")
				erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR, "**00", 5)
			FINSI
		FINSI
		# Sinon Z <> 8 ou 6
	SINON
		#trace("Normalisation NUM-IDUS (0ZABPQMCDU)")
		#trace("Normalisation NUM-IDUS (0*ZABPQMCDU) si demandeur MLV")
		erreur_800010475 = i_normal(g_iartout, $TconvNE::IDUS_NUM, $TconvNE::IDUS_NUM, g_icopo, $Tcopo::NDR, $Tcopo::NDE ,3, AUT_NDEUR_800010475, AUT_BIDON_800010475)
		i_strcpy(pt_DEMANDEUR_800010475, "IDUS_NUM")
		# TEST 630: erreur normalisation IDUS
		SI (erreur_800010475 == -1)
		ALORS
			#trace("Erreur Normalisation IDUS --> (**00)")
			i_strcpy(pt_DEMANDEUR_800010475, "IDUS_NUM par defaut")
			erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR, "**00", 5)
		FINSI
	FINSI
FINSI

#==============================================================================
#			CONVERSATION
#==============================================================================

POINT	CONVERSATION

# Si la duree de conversation est nulle pas de valorisation conversation

SI (!duree_conv_800010475)
ALORS
	#trace("Pas de valorisation Conversation: duree nulle")
	SAUT MESS_VOCAUX
FINSI

# Recuperation de la date de debut de conversation
# Il faut trouver la date de debut de conversation en AAMMJJhhmmss
# avec HDCONV (hhmmss) et ICAR (AAMMJJhhmmss) ??????

sdate_conv_800010475 = i_concat_date(g_iartout, $TconvNE::DATE, $TconvNE::HDCONV, 0)

# Recuperation parametre CPTX

SI (i_valid_field_n(g_iartout, $TconvNE::T3cptx))
ALORS
	CPTX_800010475 = i_get_art_field(g_iartout, $TconvNE::CPTX)
SINON
	CPTX_800010475 = 0
FINSI

#==============================================================================
#			NORMALISATION DEMANDE TRADUIT
#==============================================================================

# En cas de reroutage (A-C, A-D, ...), il faut normaliser DETR1_N

SI ( REROUTAGE_800010475 == 1)
ALORS
	indice_DETR_800010475 = $TconvNE::DETR1_NUM_N
	indice_NTR_800010475 = $TconvNE::NTR1_N
	i_strcpy(pt_TRADUIT_800010475, "DETR1_NUM")
SINON
	indice_DETR_800010475 = $TconvNE::DETR_NUM_N
	indice_NTR_800010475 = $TconvNE::NTR_N
	i_strcpy(pt_TRADUIT_800010475, "DETR_NUM")
FINSI

# Il faut detecter le cas des Speciaux 1X[YT] et 36PQ car ils ne sont
# pas traites par l'automate
# Si tarification GVI, affectation de **23 a $Tcopo::NDE
# Si comm BC d un reroutage accompagne, affectation **26 a $Tcopo::NDE

SI ( (GVI_800010475 == 1) && (REROUTAGE_800010475 == 0) )
ALORS
	#trace("Normalisation DETR : **23")
	i_strcpy(pt_TRADUIT_800010475, "DETR_NUM par defaut")
	erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**23", 5)
	SAUT FIN_NORM_DETR
FINSI

SI (REROUTAGE_ACCOMPAGNE_800010475==1)
ALORS
	#trace("Normalisation DETR: **26")
	i_strcpy(pt_TRADUIT_800010475, "DETR_NUM par defaut")
	erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**26", 5)
	SAUT FIN_NORM_DETR
FINSI

erreur_800010475 = i_get_art_str(g_iartout, indice_DETR_800010475, pt_BUF_800010475)
lg_800010475 = i_strlen(pt_BUF_800010475)
SI ( lg_800010475 < 5 )
ALORS
	#trace("Normalisation DETR: 1X[YT] ou 36PQ")
	erreur_800010475 = i_normal(g_iartout, indice_NTR_800010475, indice_NTR_800010475, g_icopo,$Tcopo::NDE ,$Tcopo::NDE ,3 , AUT_BIDON_800010475, AUT_NDETR2_800010475)
	SAUT FIN_NORM_DETR
FINSI

#Cas standard de normalisation
#trace("Normalisation DETR (NTR)")
erreur_800010475 = i_normal(g_iartout, indice_NTR_800010475, indice_NTR_800010475, g_icopo,$Tcopo::NDE ,$Tcopo::NDE ,3, AUT_BIDON_800010475, AUT_NDETR_800010475)

POINT FIN_NORM_DETR

# TEST 634: erreur de normalisation Demande Traduit

SI (erreur_800010475 == -1)
ALORS
	#erreur = i_PlvMessEmettre(7713,2,g_iartin,"",1,C_7703,0,0)
	#SAUT STOCKE_RECYCLE
	#pour le recyclage depuis la FO1730 les alarmes ne sont pas les memes entre le trt et le rcy
	code_rejet_800010475 = CREJ_ERR01_800010475
	erreur_800010475 = i_PlvMessEmettre(7703,2,g_iartin,"",1,code_rejet_800010475,0,0)
	SAUT STOCKE_ERRONE
FINSI

#==============================================================================
#			CALCUL DE VALORISATION VALOC_AF (utile pour TAX+)
#==============================================================================

# Calcul de valorisation a la Duree Reelle TAX+ entre IDUS et DETR

#trace("Calcul de VALO1")

type_valo_800010475 = 1

#VerifPcode
pt_memo_800010475 = i_init_tax_param()
erreur_800010475 = i_set_art_date(g_icopo, sdate_conv_800010475)

g_icopo.DUREE  = duree_conv_800010475
g_icopo.CATEG  = categ_800010475
g_icopo.CODE   = CODE_LA_800010475
g_icopo.TAXE   = 0
g_icopo.CREDIT = 0
g_icopo.SUP[0] = 0
g_icopo.SUP[1] = 0
g_icopo.SUP[2] = 0
g_icopo.SUP[3] = 0
g_icopo.SUP[4] = 0
g_icopo.SUP[5] = 0

erreur_800010475 = i_comptage(g_icopo, BASE_LA_800010475, sdate_conv_800010475)

# resultat calcul de la taxe

# Cas particulier d'appel a la base avec :
# - ICCM mal renseigne : on force Tcopo.NDR avec **25
# - IDUS mal renseigne : on utilise le code du departement contenu dans ZDT
SI (g_ierrno == 2100) && (erreur_800010475 != 0)
ALORS
	erreur_800010475 = i_get_art_str(g_icopo, $Tcopo::NDR,pt_BUF_800010475)
	erreur_800010475 = i_conv_ascii_dcb(pt_BUF_800010475, pt_IDUS_NORM_800010475)
	code_rejet_800010475=CREJ_ERR02_800010475

	SI !i_strcmp(pt_DEMANDEUR_800010475,"ICCM_NUM")
	ALORS
		erreur_800010475 = i_PlvMessEmettre(7717,2,g_iartin,"",2,code_rejet_800010475,pt_IDUS_NORM_800010475,0)
		erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR,"**25", 5)
	SINON
		SI i_valid_field_n(g_iartout, $TconvNE::ZDT)
		ALORS
			erreur_800010475 = i_PlvMessEmettre(7718,2,g_iartin,"",1,pt_IDUS_NORM_800010475,0,0)
			erreur_800010475=i_get_art_str(g_iartout, $TconvNE::ZDT,pt_BUF_800010475)
			#trace2(" ZDT etape 1 <%s>",pt_BUF,"")
			erreur_800010475 = i_format_str2(pt_ZDT_800010475,"%s%s","00",pt_BUF_800010475)
			i_get_sub_str(pt_ZDT_800010475, -2, -1, pt_BUF_800010475)
			#trace2(" ZDT etape 2 <%s>",pt_BUF,"")
			erreur_800010475=i_format_str2(pt_ZDT_800010475, "%s%s", C_ZDT_800010475, pt_BUF_800010475)
			##trace2(" ZDT etape 3 <%s>",pt_ZDT,"")
			erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR, pt_ZDT_800010475, 6)
		SINON
			SAUT FIN_DEMANDEUR_INCORRECT
		FINSI
	FINSI

	pt_memo_800010475 = i_init_tax_param()
	g_icopo.DUREE  = duree_conv_800010475
	g_icopo.CATEG  = categ_800010475
	g_icopo.CODE   = CODE_LA_800010475
	g_icopo.TAXE   = 0
	g_icopo.CREDIT = 0
	g_icopo.SUP[0] = 0
	g_icopo.SUP[1] = 0
	g_icopo.SUP[2] = 0
	g_icopo.SUP[3] = 0
	g_icopo.SUP[4] = 0
	g_icopo.SUP[5] = 0
	erreur_800010475 = i_comptage(g_icopo, BASE_LA_800010475, sdate_conv_800010475)
FINSI

POINT 	FIN_DEMANDEUR_INCORRECT

SI (erreur_800010475 != 0)
ALORS
	SAUT ERR_VAL_CONV
SINON
	SI ( g_icopo.TAXE > valo_max_800010475 )
	ALORS
		code_rejet_800010475 = CREJ_ERR03_800010475
		erreur_800010475 = i_PlvMessEmettre(7708,2,g_iartin,"",1,code_rejet_800010475,0,0)
		SAUT STOCKE_ERRONE
	FINSI

	UT1_800010475 = g_icopo.TAXE


# Sauvegarde des resultats supplementaires

	CCD_800010475 = g_icopo.SUP[RES_CLDEST_800010475]
	CODCIRDR_800010475 = g_icopo.SUP[RES_CODCIRDR_800010475]
	unite1_800010475 = g_icopo.SUP[RES_UNITE_800010475]

	erreur_800010475 = i_cree_art("Conversion", g_iartout10)
	erreur_800010475 = i_set_art_field(g_iartout10,$Conversion::CODCIRDR,CODCIRDR_800010475)
	erreur_800010475 = i_get_art_str(g_iartout10,$Conversion::CODCIRDA,pt_CODCIRDA_800010475)
	SI (g_iartout10.CODCIRDA[2] > 9)
	ALORS
		i_get_sub_str(pt_CODCIRDA_800010475,2,5,pt_CODCIRDA_800010475)
	SINON
		i_get_sub_str(pt_CODCIRDA_800010475,1,5,pt_CODCIRDA_800010475)
	FINSI

# 1) Demandeur international ou partiellement identifie --> DURFACT forcee a 0
# 2) Duree de conversation>30 secondes --> DURFACT = DURCONV
# 3) Duree de conversation<30 secondes et IDSV=1 --> DURFACT=30
# 4) Duree de conversation<30 secondes et IDSV<>1 --> DURFACT=DURCONV

	DURFACT_800010475 = duree_conv_800010475
	SI ((idsv_800010475 == 1) || (idsv_800010475 == 2) || (idsv_800010475 == 5) || (idsv_800010475 == 7) || (idsv_800010475 == 8) || (idsv_800010475 == 18))
	ALORS
		SI ( (natach_800010475 & 0x80) || ((inf_idus_800010475 & 0x60) != 0x00) )
		ALORS
			DURFACT_800010475 = 0
		SINON
			SI ( (duree_conv_800010475 < 30) && (idsv_800010475 == 1) )
			ALORS
				DURFACT_800010475 = 30
			FINSI
		FINSI
	FINSI
FINSI

# Communication type AB pour un GVI reroute
# Calcul de VALO1b

SI ( ( REROUTAGE_800010475 == 0 ) && ( GVI_800010475 == 1) )
ALORS
	# Palliatif pour pb procopo 2.8.1 ???
	D_800010475 = i_get_tax_param(pt_memo_800010475, COD_D_800010475, 0)

	# Fin palliatif pour pb procopo 2.8.1
	quantum_800010475 = i_get_tax_param(pt_memo_800010475, COD_Q_800010475, 0)

	g_icopo.DUREE  = duree_conv_800010475 + D_800010475
	g_icopo.CATEG  = categ_800010475
	g_icopo.CODE   = CODE_LA_800010475
	g_icopo.TAXE   = 0
	g_icopo.CREDIT = 0
	g_icopo.SUP[0] = 0
	g_icopo.SUP[1] = 0
	g_icopo.SUP[2] = 0
	g_icopo.SUP[3] = 0
	g_icopo.SUP[4] = 0
	g_icopo.SUP[5] = 0

	erreur_800010475 = i_comptage(g_icopo, BASE_LA_800010475, sdate_conv_800010475)

	SI ( g_icopo.TAXE > valo_max_800010475 )
	ALORS
		code_rejet_800010475 = CREJ_ERR03_800010475
		erreur_800010475 = i_PlvMessEmettre(7708,2,g_iartin,"",1,code_rejet_800010475,0,0)
		SAUT STOCKE_ERRONE
	FINSI

	UT1_800010475 = g_icopo.TAXE - quantum_800010475
FINSI

SI (g_icopo.SUP[RES_TYPCTR_800010475] != CTR_EGAL_800010475)
ALORS
	SI ((g_icopo.SUP[RES_TYPCTR_800010475] == CTR_MAX_800010475) ||
	(g_icopo.SUP[RES_TYPCTR_800010475] == CTR_NONE_800010475))
	ALORS
		#trace("Controle MAX ou SANS: Forcage Vc=0")
		UT1_800010475 = 0
	SINON
		SAUT ERR_TYPE_CONTROLE
	FINSI
FINSI

# Si IDSV = NAZ ou NIND alors il faut calculer TAX-
# Meme chose si le demandeur a ete detecte comme etranger
# Cas particulier pour One2one : on ne sait pas tarifer geographiquement le cout appelant donc ne calcule pas du tout
#
# Convergent numeros noirs (IDSV = 18) la variable VALO2 doit etre forcee a zero meme si le demandeur est international.
# La mise en Suvre consiste a reutiliser IDSV 18 anciennement attribue aux numero noir.
# Et Contrairement au numero noir, le service Z9 n est pas valorise a 0.
SI ( ( (idsv_800010475 == NAZ_800010475) || (idsv_800010475 == NIND2_800010475) || (idsv_800010475 == IDSV7_800010475) ||(idsv_800010475 == NIND3_800010475) || (ddeur_etr_800010475 == 1) || (idsv_800010475 == NUMNOIR_800010475) || (idsv_800010475 == 20) ) && (One2one_800010475 == 0) )
ALORS
	SAUT NORM_DEDE
SINON
	SAUT MESS_VOCAUX
FINSI

#==============================================================================
#			NORMALISATION DEMANDE
#==============================================================================

POINT	NORM_DEDE

# Comm BC d un reroutage accompagne
SI (REROUTAGE_ACCOMPAGNE_800010475==1)
ALORS
	#trace("Normalisation DEDE: en **27")
	i_strcpy(pt_DEMANDE_800010475, "DEDE_NUM par defaut")
	erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**27", 5)
	SAUT FIN_NORM_DEDE
FINSI

# Comm AB d un reroutage GVI
SI ( (GVI_800010475 == 1) && (ddeur_etr_800010475 == 0) && (REROUTAGE_800010475 == 0) )
ALORS
	#trace("Normalisation DEDE: en **24")
	i_strcpy(pt_DEMANDE_800010475, "DEDE_NUM par defaut")
	erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**24", 5)
	SAUT FIN_NORM_DEDE
FINSI

# La normalisation du NAS se fait en respectant les regles suivantes :
# - si DEDEini est present, on utilise le champ DEDEINI_N (correspond a DEDEini eventuellement ampute de son prefixe)
# - dans le cas contraire, on utilise DEDE_N (correspond a DEDE eventuellement ampute de son prefixe)
#
# Attention : si on a un payeur reroute, DEDE_N contient la valeur de DEDE1. On doit reprendre le champ DEDE initial
# et eventuellement lui retirer son prefixe (utilisation d un autre g_iartout pour garantir l'integrite du champ)
#
# Attention (bis) : si le numero a normaliser a ete detecte comme court (suppression de 0 en tete),
# la normalisation doit se faire en tenant compte de IDSV

SI dedeini_800010475
ALORS
	SI ( dedeini_court_800010475 == 1 )
	ALORS
		SAUT NORM_DEDE_IDSV
	SINON
		erreur_800010475 = i_normal(g_iartout, $TconvNE::DEDEINI_NUM_N, $TconvNE::DEDEINI_NUM_N, g_icopo,$Tcopo::NDE ,$Tcopo::NDE ,3, AUT_BIDON_800010475, AUT_NDE_800010475)
		SAUT FIN_NORM_DEDE
	FINSI
SINON
	val1_800010475 = i_get_art_field(g_iartout, $TconvNE::DEDE_PREF)
	val2_800010475 = i_get_art_field(g_iartout, $TconvNE::DEDE_REROUTE)
	SI ( val1_800010475 > 0 ) && ( val2_800010475 == 1 )
	ALORS
		erreur_800010475 = i_dup_art_id(g_iartout, g_iartout7)
		erreur_800010475 = i_supp_quart_num($TconvNE::DEDE_NUM, 0, 5, 0x0f, g_iartout7, g_iartout7)
		SI ( g_iartout7.DEDE_NUM[0] == 0 )
		ALORS
			SAUT NORM_DEDE_IDSV
		SINON
			erreur_800010475 = i_normal(g_iartout7,$TconvNE::DEDE_NUM,$TconvNE::DEDE_NUM,g_icopo,$Tcopo::NDE,$Tcopo::NDE,3,AUT_BIDON_800010475,AUT_NDE_800010475)
			SAUT FIN_NORM_DEDE
		FINSI
	SINON
		SI ( dede_court_800010475 == 1 )
		ALORS
			SAUT NORM_DEDE_IDSV
		SINON
			erreur_800010475 = i_normal(g_iartout, $TconvNE::DEDE_NUM_N, $TconvNE::DEDE_NUM_N, g_icopo,$Tcopo::NDE ,$Tcopo::NDE ,3, AUT_BIDON_800010475, AUT_NDE_800010475)
			SAUT FIN_NORM_DEDE
		FINSI
	FINSI
FINSI

POINT NORM_DEDE_IDSV

SI (idsv_800010475 == NVN_800010475)
ALORS
	erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**30", 5)
	i_strcpy(pt_DEMANDE_800010475, "IDSV par defaut")
	SAUT FIN_NORM_DEDE
FINSI

SI (idsv_800010475 == NAZ_800010475)
ALORS
	i_strcpy(pt_DEMANDE_800010475, "IDSV par defaut")
	erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**31", 5)
	SAUT FIN_NORM_DEDE
FINSI

SI (idsv_800010475 == NIND2_800010475)
ALORS
	i_strcpy(pt_DEMANDE_800010475, "IDSV par defaut")
	erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**32", 5)
	SAUT FIN_NORM_DEDE
FINSI

SI (idsv_800010475 == IDSV7_800010475)
ALORS
	i_strcpy(pt_DEMANDE_800010475, "IDSV par defaut")
	erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**34", 5)
	SAUT FIN_NORM_DEDE
FINSI

SI (idsv_800010475 == NIND3_800010475)
ALORS
	i_strcpy(pt_DEMANDE_800010475, "IDSV par defaut")
	erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**33", 5)
	SAUT FIN_NORM_DEDE
FINSI

POINT FIN_NORM_DEDE

# TEST 633: erreur de normalisation Demande

SI (erreur_800010475 == -1)
ALORS
	#erreur = i_PlvMessEmettre(7713,2,g_iartin,"",1,C_7702,0,0)
	#SAUT STOCKE_RECYCLE
	#pour le recyclage depuis la FO1730 les alarmes ne sont pas les memes entre le trt et le rcy
	code_rejet_800010475 = CREJ_ERR01_800010475
	erreur_800010475 = i_PlvMessEmettre(7702,2,g_iartin,"",1,code_rejet_800010475,0,0)
	SAUT STOCKE_ERRONE
FINSI

#==============================================================================
#		CALCUL DE VALORISATION DE VALOC_AF (utile pour TAX-)
#==============================================================================

# Calcul de valorisation a la Duree Reelle TAX- entre IDUS et DEDE

#trace("calcul de VALO2")

type_valo_800010475 = 2

#VerifPcode
pt_memo_800010475 = i_init_tax_param()
erreur_800010475 = i_set_art_date(g_icopo, sdate_conv_800010475)

g_icopo.DUREE  = duree_conv_800010475

SI (idsv_800010475 == 20)
ALORS
	g_icopo.CATEG  = categ_IDSV20_NAS_800010475
SINON
	g_icopo.CATEG  = categ_800010475
FINSI
g_icopo.CODE   = CODE_LA_800010475
g_icopo.TAXE   = 0
g_icopo.CREDIT = 0
g_icopo.SUP[0] = 0
g_icopo.SUP[1] = 0
g_icopo.SUP[2] = 0
g_icopo.SUP[3] = 0
g_icopo.SUP[4] = 0
g_icopo.SUP[5] = 0

erreur_800010475 = i_comptage(g_icopo, BASE_LA_800010475, sdate_conv_800010475)

# resultat calcul de la taxe

SI (erreur_800010475 != 0)
ALORS
	SAUT ERR_VAL_CONV
SINON
	UT2_800010475 = g_icopo.TAXE
	unite2_800010475 = g_icopo.SUP[RES_UNITE_800010475]
FINSI

SI ( g_icopo.TAXE > valo_max_800010475 )
ALORS
	code_rejet_800010475 = CREJ_ERR03_800010475
	erreur_800010475 = i_PlvMessEmettre(7708,2,g_iartin,"",1,code_rejet_800010475,0,0)
	SAUT STOCKE_ERRONE
FINSI

# Communication (A-C, A-D...) emanant d'un reroutage (aveugle ou GVI)
# ou GVI reroute (comm A-B) service Azur (calcul de VALO2b)

SI ( ( REROUTAGE_800010475 == 1 ) || ( ( GVI_800010475 == 1 ) && ( idsv_800010475 == NAZ_800010475 ) ) )
ALORS
	# Palliatif pour pb procopo 2.8.1
	D_800010475 = i_get_tax_param(pt_memo_800010475, COD_D_800010475, 0)

	# Fin palliatif pour pb procopo 2.8.1
	quantum_800010475 = i_get_tax_param(pt_memo_800010475, COD_Q_800010475, 0)

	g_icopo.DUREE  = duree_conv_800010475 + D_800010475

	SI (idsv_800010475 == 20)
	ALORS
		g_icopo.CATEG  = categ_IDSV20_NAS_800010475
	SINON
		g_icopo.CATEG  = categ_800010475
	FINSI
	g_icopo.CODE   = CODE_LA_800010475
	g_icopo.TAXE   = 0
	g_icopo.CREDIT = 0
	g_icopo.SUP[0] = 0
	g_icopo.SUP[1] = 0
	g_icopo.SUP[2] = 0
	g_icopo.SUP[3] = 0
	g_icopo.SUP[4] = 0
	g_icopo.SUP[5] = 0

	erreur_800010475 = i_comptage(g_icopo, BASE_LA_800010475, sdate_conv_800010475)

	SI ( g_icopo.TAXE > valo_max_800010475 )
	ALORS
		code_rejet_800010475 = CREJ_ERR03_800010475
		erreur_800010475 = i_PlvMessEmettre(7708,2,g_iartin,"",1,code_rejet_800010475,0,0)
		SAUT STOCKE_ERRONE
	FINSI

	UT2_800010475 = g_icopo.TAXE - quantum_800010475
FINSI

# Type de controle <> EGALITE

SI (g_icopo.SUP[RES_TYPCTR_800010475] != CTR_EGAL_800010475)
ALORS
	SI ((g_icopo.SUP[RES_TYPCTR_800010475] == CTR_MAX_800010475) ||
	(g_icopo.SUP[RES_TYPCTR_800010475] == CTR_NONE_800010475))
	ALORS
		#trace("Controle MAX ou SANS: Forcage Vc=0")
		UT2_800010475 = 0
	SINON
		SAUT ERR_TYPE_CONTROLE
	FINSI
FINSI

# Pour valorisation Messages Vocaux
SAUT MESS_VOCAUX

#==============================================================================
#			MESSAGES VOCAUX
#==============================================================================

POINT	MESS_VOCAUX

# Si toutes les durees des MV sont nulles
# pas de valorisation messages vocaux

SI (((!duree_mvpar_800010475) && (!duree_mvacc_800010475) && (!duree_mvaut_800010475)))
ALORS
	#trace("Pas de valorisation Messages Vocaux: durees nulles")
	SAUT STOCKE_OK
FINSI

# Recuperation de la date de debut de l'article pour les messages vocaux

sdate_mv_800010475 = i_get_art_field(g_iartout, $TconvNE::DATE)

#==============================================================================
#		NORMALISATION ET VALORISATION DES MESSAGES VOCAUX
#==============================================================================

# Normalement IDUS a deja ete normalise pour la Conversation

POINT	NORM_MESS_VOCAUX
erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR,"**00", 5)

tmv1_800010475 = i_get_art_field(g_iartout, $TconvNE::TMV1)
tmv2_800010475 = i_get_art_field(g_iartout, $TconvNE::TMV2)

# Message Vocal Personnalise Parcage: TMV1-A = 1
# Message Vocal Standard/Film Parcage: TMV1-C = 1

SI (tmv1_800010475 & 0xa0)
ALORS
	# TEST 645: MVS/Film et MVP Parcage (TMV1-A=1 et TMV1-C=1) impossible

	SI ((tmv1_800010475 & 0x80) && (tmv1_800010475 & 0x20))
	ALORS
		#trace("MVS/Film et MVP Parcage (defaut=MVS)")
		tmv1_800010475 = tmv1_800010475 & 0x7f
		erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::TMV1, tmv1_800010475)
	FINSI

# Normalisation des MV parcage

	SI (tmv1_800010475 & 0x80)
	ALORS
		#trace("MVP sur Parcage")
		erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**01", 5)
	FINSI

	SI (tmv1_800010475 & 0x20)
	ALORS
		#trace("MVS/Film sur Parcage")
		erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**02", 5)
	FINSI

	# Calcul de valorisation au Palier MV Parcage

	#trace("VALORISATION MV Parcage au Palier")
	#trace("VALORISATION VALOP_AF")

	erreur_800010475 = i_set_art_date(g_icopo, sdate_mv_800010475)

	g_icopo.DUREE  = duree_mvpar_800010475
	g_icopo.CATEG  = categ_800010475
	g_icopo.CODE   = CODE_LA_800010475
	g_icopo.TAXE   = 0
	g_icopo.CREDIT = 0

	erreur_800010475 = i_comptage(g_icopo, BASE_LA_800010475, sdate_mv_800010475)

# Resultat calcul de la taxe
# Cas particulier d'appel a la base avec :
# - ICCM mal renseigne : on force Tcopo.NDR avec **25
# - IDUS mal renseigne : on utilise le code du departement contenu dans ZDT
	SI (g_ierrno == 2100) && (erreur_800010475 != 0)
	ALORS
		erreur_800010475 = i_get_art_str(g_icopo, $Tcopo::NDR,pt_BUF_800010475)
		erreur_800010475 = i_conv_ascii_dcb(pt_BUF_800010475, pt_IDUS_NORM_800010475)
		code_rejet_800010475=CREJ_ERR02_800010475

		SI !i_strcmp(pt_DEMANDEUR_800010475,"ICCM_NUM")
		ALORS
			erreur_800010475 = i_PlvMessEmettre(7717,2,g_iartin,"",2,code_rejet_800010475,pt_IDUS_NORM_800010475,0)
			erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR,"**25", 5)
		SINON
			SI i_valid_field_n(g_iartout, $TconvNE::ZDT)
			ALORS
				erreur_800010475 = i_PlvMessEmettre(7718,2,g_iartin,"",1,pt_IDUS_NORM_800010475,0,0)
				erreur_800010475=i_get_art_str(g_iartout, $TconvNE::ZDT,pt_BUF_800010475)
				erreur_800010475=i_format_str2(pt_ZDT_800010475, "%s%s", C_ZDT_800010475, pt_BUF_800010475)
				erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR, pt_ZDT_800010475, 5)
			SINON
				SAUT FIN_DEMANDEUR_INCORRECT_MV
			FINSI

			g_icopo.DUREE  = duree_mvpar_800010475
			g_icopo.CATEG  = categ_800010475
			g_icopo.CODE   = CODE_LA_800010475
			g_icopo.TAXE   = 0
			g_icopo.CREDIT = 0
			erreur_800010475 = i_comptage(g_icopo, BASE_LA_800010475, sdate_mv_800010475)
		FINSI
	FINSI

	POINT 	FIN_DEMANDEUR_INCORRECT_MV

	SI (erreur_800010475 != 0)
	ALORS
		SAUT ERR_VAL_MV
	SINON
		VMV1_1_800010475 = g_icopo.TAXE
		unite3_800010475 = g_icopo.SUP[RES_UNITE_800010475]
	FINSI

	SI ( g_icopo.TAXE > valo_max_800010475 )
	ALORS
		code_rejet_800010475 = CREJ_ERR03_800010475
		erreur_800010475 = i_PlvMessEmettre(7708,2,g_iartin,"",1,code_rejet_800010475,0,0)
		SAUT STOCKE_ERRONE
	FINSI

	# TEST 639: Type de controle <> EGALITE

	SI (g_icopo.SUP[RES_TYPCTR_800010475] != CTR_EGAL_800010475)
	ALORS
		SAUT ERR_TYPE_CONTROLE
	FINSI
FINSI

#
# Message Vocal Personnalise Accueil: TMV1-B = 1
# Message Vocal Standard/Film Accueil: TMV1-D = 1
#

SI (tmv1_800010475 & 0x50)
ALORS
	# TEST 646: MVS/Film et MVP Accueil (TMV1-B=1 et TMV1-D=1) impossible

	SI ((tmv1_800010475 & 0x40) && (tmv1_800010475 & 0x10))
	ALORS
		#trace("MVS/Film et MVP Accueil (defaut=MVS)")
		tmv1_800010475 = tmv1_800010475 & 0xbf
		erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::TMV1, tmv1_800010475)
	FINSI

# Normalisation des MV accueil

	SI (tmv1_800010475 & 0x40)
	ALORS
		#trace("MVP sur Accueil")
		erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**03", 5)
	FINSI
	SI (tmv1_800010475 & 0x10)
	ALORS
		#trace("MVS/Film sur Accueil")
		erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**04", 5)
	FINSI

	# Calcul de valorisation au Palier MV Accueil

	#trace("VALORISATION MV Accueil au Palier")
	#trace("VALORISATION VALOACC_AF")

	erreur_800010475 = i_set_art_date(g_icopo, sdate_mv_800010475)

	g_icopo.DUREE  = duree_mvacc_800010475
	g_icopo.CATEG  = categ_800010475
	g_icopo.CODE   = CODE_LA_800010475
	g_icopo.TAXE   = 0
	g_icopo.CREDIT = 0

	erreur_800010475 = i_comptage(g_icopo, BASE_LA_800010475, sdate_mv_800010475)

	# Cas particulier d'appel a la base avec un ICCM mal renseigne par le PCS
	SI (g_ierrno == 2100) && !i_strcmp(pt_DEMANDEUR_800010475,"ICCM_NUM") && (erreur_800010475 != 0)
	ALORS
		erreur_800010475 = i_get_art_str(g_icopo, $Tcopo::NDR,pt_BUF_800010475)
		erreur_800010475 = i_conv_ascii_dcb(pt_BUF_800010475, pt_IDUS_NORM_800010475)
		code_rejet_800010475=CREJ_ERR02_800010475
		erreur_800010475 = i_PlvMessEmettre(7717,2,g_iartin,"",2,code_rejet_800010475,pt_IDUS_NORM_800010475,0)
		erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR,"**25", 5)
		g_icopo.DUREE  = duree_mvacc_800010475
		g_icopo.CATEG  = categ_800010475
		g_icopo.CODE   = CODE_LA_800010475
		g_icopo.TAXE   = 0
		g_icopo.CREDIT = 0
		erreur_800010475 = i_comptage(g_icopo, BASE_LA_800010475, sdate_mv_800010475)
	FINSI

	# Resultat calcul de la taxe
	SI (erreur_800010475 != 0)
	ALORS
		SAUT ERR_VAL_MV
	SINON
		VMV1_2_800010475 = g_icopo.TAXE
		unite3_800010475 = g_icopo.SUP[RES_UNITE_800010475]
	FINSI

	SI ( g_icopo.TAXE > valo_max_800010475 )
	ALORS
		code_rejet_800010475 = CREJ_ERR03_800010475
		erreur_800010475 = i_PlvMessEmettre(7708,2,g_iartin,"",1,code_rejet_800010475,0,0)
		SAUT STOCKE_ERRONE
	FINSI

	# TEST 639: Type de controle <> EGALITE
	SI (g_icopo.SUP[RES_TYPCTR_800010475] != CTR_EGAL_800010475)
	ALORS
		SAUT ERR_TYPE_CONTROLE
	FINSI
FINSI

# Message Vocal Interdiction: TMV2-A = 1
# Message Vocal Debordement: TMV2-B = 1
# Message Vocal Fermeture: TMV2-C = 1
# Message Vocal Renvoi: TMV2-D = 1

# Message Vocal Personnalise: INF-DETR-CD = 10
# Message Vocal Standard/Film: INF-DETR-CD = 11 ou 00

# Normalisation des MV Autres
SI (tmv2_800010475)
ALORS
	# TEST 647: MV Autres Multiple (TMV2-A et B et C et D=1) impossible

	SI ((tmv2_800010475 != 0x80) && (tmv2_800010475 != 0x40) &&
	(tmv2_800010475 != 0x20) && (tmv2_800010475 != 0x10))
	ALORS
		code_rejet_800010475 = CREJ_ERR04_800010475
		erreur_800010475 = i_PlvMessEmettre(7705,2,g_iartin,"",1,code_rejet_800010475,0,0)
		SAUT STOCKE_ERRONE
	FINSI

	# Normalisation MV Interdiction
	SI (tmv2_800010475 & 0x80)
	ALORS
		SI ((detr_inf_800010475 & 0x30) == 0x20)
		ALORS
			#trace("MVP sur Interdiction")
			erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**05", 5)
		SINON
			#trace("MVS/Film sur Interdiction")
			erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**06", 5)
		FINSI
	FINSI

	# Normalisation MV Debordement/Occupation
	SI (tmv2_800010475 & 0x40)
	ALORS
		SI ((detr_inf_800010475 & 0x30) == 0x20)
		ALORS
			#trace("MVP sur Debordement/Occupation")
			erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**07", 5)
		SINON
			#trace("MVS/Film sur Debordement/Occupation")
			erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**08", 5)
		FINSI
	FINSI

	# Normalisation MV Fermeture
	SI (tmv2_800010475 & 0x20)
	ALORS
		SI ((detr_inf_800010475 & 0x30) == 0x20)
		ALORS
			#trace("MVP sur Fermeture")
			erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**09", 5)
		SINON
			#trace("MVS/Film sur Fermeture")
			erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**10", 5)
		FINSI
	FINSI

	# Normalisation MV Renvoi
	SI (tmv2_800010475 & 0x10)
	ALORS
		SI ((detr_inf_800010475 & 0x30) == 0x20)
		ALORS
			#trace("MVP sur Renvoi")
			erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**11", 5)
		SINON
			#trace("MVS/Film sur Renvoi")
			erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, "**12", 5)
		FINSI
	FINSI

	# Calcul de valorisation au Palier MV Autres

	#trace("VALORISATION MV Autres au Palier")
	#trace("VALORISATION VALOAUT_AF")

	erreur_800010475 = i_set_art_date(g_icopo, sdate_mv_800010475)

	g_icopo.DUREE  = duree_mvaut_800010475
	g_icopo.CATEG  = categ_800010475
	g_icopo.CODE   = CODE_LA_800010475
	g_icopo.TAXE   = 0
	g_icopo.CREDIT = 0

	erreur_800010475 = i_comptage(g_icopo, BASE_LA_800010475, sdate_mv_800010475)

	# Cas particulier d'appel a la base avec un ICCM mal renseigne par le PCS
	SI (g_ierrno == 2100) && !i_strcmp(pt_DEMANDEUR_800010475,"ICCM_NUM") && (erreur_800010475 != 0)
	ALORS
		erreur_800010475 = i_get_art_str(g_icopo, $Tcopo::NDR,pt_BUF_800010475)
		erreur_800010475 = i_conv_ascii_dcb(pt_BUF_800010475, pt_IDUS_NORM_800010475)
		code_rejet_800010475=CREJ_ERR02_800010475
		erreur_800010475 = i_PlvMessEmettre(7717,2,g_iartin,"",2,code_rejet_800010475,pt_IDUS_NORM_800010475,0)
		erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR,"**25", 5)
		g_icopo.DUREE  = duree_mvaut_800010475
		g_icopo.CATEG  = categ_800010475
		g_icopo.CODE   = CODE_LA_800010475
		g_icopo.TAXE   = 0
		g_icopo.CREDIT = 0

		erreur_800010475 = i_comptage(g_icopo, BASE_LA_800010475, sdate_mv_800010475)
	FINSI

	# Resultat calcul de la taxe
	SI (erreur_800010475 != 0)
	ALORS
		SAUT ERR_VAL_MV
	SINON
		SI (tmv2_800010475 & 0x80)
		ALORS
			VMV2_3_800010475 = g_icopo.TAXE
			unite3_800010475 = g_icopo.SUP[RES_UNITE_800010475]
		SINON
			SI (tmv2_800010475 & 0x40)
			ALORS
				VMV1_3_800010475 = g_icopo.TAXE
				unite3_800010475 = g_icopo.SUP[RES_UNITE_800010475]
			SINON
				SI (tmv2_800010475 & 0x20)
				ALORS
					VMV2_1_800010475 = g_icopo.TAXE
					unite3_800010475 = g_icopo.SUP[RES_UNITE_800010475]
				SINON
					SI (tmv2_800010475 & 0x10)
					ALORS
						VMV2_2_800010475 = g_icopo.TAXE
						unite3_800010475 = g_icopo.SUP[RES_UNITE_800010475]
					FINSI
				FINSI
			FINSI
		FINSI
	FINSI

	SI ( g_icopo.TAXE > valo_max_800010475 )
	ALORS
		code_rejet_800010475 = CREJ_ERR03_800010475
		erreur_800010475 = i_PlvMessEmettre(7708,2,g_iartin,"",1,code_rejet_800010475,0,0)
		SAUT STOCKE_ERRONE
	FINSI

	# TEST 639: Type de controle <> EGALITE

	SI (g_icopo.SUP[RES_TYPCTR_800010475] != CTR_EGAL_800010475)
	ALORS
		SAUT ERR_TYPE_CONTROLE
	FINSI
FINSI

# Fin de valorisation MV

SAUT	STOCKE_OK

#==============================================================================
#		TEST 6.1: Calcul de valorisation conversation impossible
#==============================================================================

POINT	ERR_VAL_CONV

code_rejet_800010475 = CREJ_ERR02_800010475

SI ( g_ierrno == 2100 )
ALORS
	erreur_800010475 = i_get_art_str(g_icopo, $Tcopo::NDR,pt_BUF_800010475)
	erreur_800010475 = i_conv_ascii_dcb(pt_BUF_800010475, pt_IDUS_NORM_800010475)

	#erreur= i_format_str2( pt_BUF100, "%s%s", C_7714 , pt_IDUS_NORM)
	#erreur= i_format_str2( pt_BUF, "%s%s", pt_BUF100 , pt_DEMANDEUR)
	#trace2(" G2R2Cd FO1730 ancienne 7714 <%s>",pt_BUF,"")
	#erreur = i_PlvMessEmettre(7713,2,g_iartin,"",1,pt_BUF,0,0)
	#SAUT STOCKE_RECYCLE
	#pour le recyclage depuis la FO1730 les alarmes ne sont pas les memes entre le trt et le rcy
	erreur_800010475 = i_PlvMessEmettre(7714,2,g_iartin,"",3,code_rejet_800010475,pt_IDUS_NORM_800010475,pt_DEMANDEUR_800010475)
	SAUT STOCKE_ERRONE
FINSI

SI ( g_ierrno == 1100 )
ALORS
	erreur_800010475 = i_get_art_str(g_icopo, $Tcopo::NDE,pt_BUF_800010475)
	erreur_800010475 = i_conv_ascii_dcb(pt_BUF_800010475, pt_DEDE_NORM_800010475)
	SI ( type_valo_800010475 == 1)
	ALORS
		#erreur= i_format_str2( pt_BUF100, "%s%s", C_7715 , pt_DEDE_NORM)
		#erreur= i_format_str2( pt_BUF, "%s%s", pt_BUF100 , pt_TRADUIT)
		#erreur = i_PlvMessEmettre(7713,2,g_iartin,"",1,pt_BUF,0,0)
		#SAUT STOCKE_RECYCLE
		#pour le recyclage depuis la FO1730 les alarmes ne sont pas les memes entre le trt et le rcy
		erreur_800010475 = i_PlvMessEmettre(7715,2,g_iartin,"",3,code_rejet_800010475,pt_DEDE_NORM_800010475,pt_TRADUIT_800010475)
		SAUT STOCKE_ERRONE
	SINON
		SI ( type_valo_800010475 == 2)
		ALORS
			#erreur= i_format_str2( pt_BUF100, "%s%s", C_7715 , pt_DEDE_NORM)
			#erreur= i_format_str2( pt_BUF, "%s%s", pt_BUF100 , pt_DEMANDE)
			#erreur = i_PlvMessEmettre(7713,2,g_iartin,"",1,pt_BUF,0,0)
			#SAUT STOCKE_RECYCLE
			#pour le recyclage depuis la FO1730 les alarmes ne sont pas les memes entre le trt et le rcy
			erreur_800010475 = i_PlvMessEmettre(7715,2,g_iartin,"",3,code_rejet_800010475,pt_DEDE_NORM_800010475,pt_DEMANDE_800010475)
			SAUT STOCKE_ERRONE
		FINSI
	FINSI
FINSI

SI ( g_ierrno == 40 )
ALORS
	erreur_800010475 = i_get_art_str(g_icopo, $Tcopo::NDR,pt_BUF_800010475)
	erreur_800010475 = i_conv_ascii_dcb(pt_BUF_800010475, pt_IDUS_NORM_800010475)
	erreur_800010475 = i_get_art_str(g_icopo, $Tcopo::NDE,pt_BUF_800010475)
	erreur_800010475 = i_conv_ascii_dcb(pt_BUF_800010475, pt_DEDE_NORM_800010475)
	#erreur= i_format_str2( pt_BUF100, "%s%s", C_7716 , pt_IDUS_NORM)
	#erreur= i_format_str2( pt_BUF, "%s%s", pt_BUF100 , pt_DEDE_NORM)
	#erreur = i_PlvMessEmettre(7713,2,g_iartin,"",1,pt_BUF,0,0)
	#SAUT STOCKE_RECYCLE
	#pour le recyclage depuis la FO1730 les alarmes ne sont pas les memes entre le trt et le rcy
	erreur_800010475 = i_PlvMessEmettre(7716,2,g_iartin,"",3,code_rejet_800010475,pt_IDUS_NORM_800010475,pt_DEDE_NORM_800010475)
	SAUT STOCKE_ERRONE
FINSI

#erreur = i_PlvMessEmettre(7713,2,g_iartin,"",1,C_7707,0,0)
#SAUT STOCKE_RECYCLE
#pour le recyclage depuis la FO1730 les alarmes ne sont pas les memes entre le trt et le rcy
erreur_800010475 = i_PlvMessEmettre(7707,2,g_iartin,"",1,code_rejet_800010475,0,0)
SAUT STOCKE_ERRONE

#==============================================================================
#		TEST 6.2: Calcul de valorisation MV impossible
#==============================================================================

POINT	ERR_VAL_MV

#erreur = i_PlvMessEmettre(7713,2,g_iartin,"",1,C_7709,0,0)
#SAUT STOCKE_RECYCLE
#pour le recyclage depuis la FO1730 les alarmes ne sont pas les memes entre le trt et le rcy
code_rejet_800010475 = CREJ_ERR02_800010475
erreur_800010475 = i_PlvMessEmettre(7709,2,g_iartin,"",1,code_rejet_800010475,0,0)
SAUT STOCKE_ERRONE

#==============================================================================
#		TEST 639: Type de controle different de EGALITE,MAX ou SANS
#==============================================================================

POINT	ERR_TYPE_CONTROLE

code_rejet_800010475 = CREJ_ERR03_800010475
erreur_800010475 = i_PlvMessEmettre(7706,2,g_iartin,"",1,code_rejet_800010475,0,0)

#SAUT STOCKE_RECYCLE
SAUT STOCKE_ERRONE

##########################################################
# Valorisation SRP : uniquement pour calculer CCD	 #
##########################################################

POINT TRAITEMENT_SRP

# Appel base de comptage
# !!!!!!! A verifier : on utilise systematiquement **00 en demandeur (idem Tauddce)
# !!!!!!! A verifier : on utilise systematiquement DEDE_NUM_N
# !!!!!!! A verifier : on analyse ce numero pour eventuellement eliminer les 0 de bourrage au debut

erreur_800010475 = i_get_art_str(g_iartout,$TconvNE::DEDE_NUM_N, pt_DEDE_NUM_N_800010475)
lg_800010475 = i_strlen(pt_DEDE_NUM_N_800010475)
# on n a plus besoin d analyser les 0 en tete de DEDE_NUM_N car ils ont ete retires

SI (dede_court_800010475 == 0) && (lg_800010475 > 6)
ALORS
	# on est dans le cas d un NAS de type ZABPQMCDU : on ajoute un 0 devant pour la normalisation
	erreur_800010475 = i_format_str2(pt_DEDE_NORM_800010475, "%s%s", "0", pt_DEDE_NUM_N_800010475)
SINON
	# on est dans le cas d un NAS court : on recopie DEDE_NUM_N tel quel pour l appel a la BNC
	i_strcpy(pt_DEDE_NORM_800010475, pt_DEDE_NUM_N_800010475)
FINSI

i_strcpy(pt_IDUS_NORM_800010475, "**00")
lg_800010475 = i_strlen(pt_DEDE_NORM_800010475)

erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDR, pt_IDUS_NORM_800010475, 5)
erreur_800010475 = i_memcpy_art_field_n(g_icopo, $Tcopo::NDE, pt_DEDE_NORM_800010475, lg_800010475+1)

# Recuperation de la date de debut de conversation
# Il faut trouver la date de debut de conversation en AAMMJJhhmmss
# avec HDCONV (hhmmss) et ICAR (AAMMJJhhmmss) ??????

sdate_conv_800010475 = i_concat_date(g_iartout, $TconvNE::DATE, $TconvNE::HDCONV, 0)

# Initialisation de l'interface "proc_copo" et calcul taxation
g_icopo.TAXE   = 0
g_icopo.CREDIT = 0
erreur_800010475 = i_set_art_date(g_icopo, sdate_conv_800010475)
g_icopo.DUREE  = 0
g_icopo.CODE   = CODE_AUDIO_800010475
g_icopo.CATEG  = CATEG_AUDIO_800010475
g_icopo.SUP[0] = 0
g_icopo.SUP[1] = 0
g_icopo.SUP[2] = 0
g_icopo.SUP[3] = 0
g_icopo.SUP[4] = 0
g_icopo.SUP[RES_CLDEST_800010475] = 0xff

erreur_800010475 = i_comptage( g_icopo, BASE_AUDIO_800010475, sdate_conv_800010475 )

SI (   erreur_800010475 == 0 )
ALORS
	CCD_800010475 = g_icopo.SUP[RES_CLDEST_800010475]
	val1_800010475 = g_icopo.SUP[RES_CODCIR_800010475]
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::ACE_N1, val1_800010475)
	val1_800010475 = g_icopo.SUP[RES_TYPCOM_800010475]
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::ACE_N2, val1_800010475)
FINSI

SAUT STOCKE_OK

#==============================================================================
#				STOCKAGE DANS VALIDE
#==============================================================================

POINT	STOCKE_OK

SI SRP_800010475 ==0
ALORS
	erreur_800010475 = i_supprChamp(g_iartout, "T4ACE_N1")
	erreur_800010475 = i_supprChamp(g_iartout, "T4ACE_N2")
FINSI

# Initialisation ajout OADC (sera utile pour la correlation)
SI ( i_valid_field_n(g_iartout, $TconvNE::OADC_CAU) )
ALORS
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::OADC_COR, i_get_art_field(g_iartout, $TconvNE::OADC_CAU))
SINON
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::OADC_COR, 0xff)
FINSI

erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::REROUT_TYPE, 0)

# Initialisation parametre optionnel CODCIRDR (3 octets DCB)
SI (CODCIRDR_800010475 != 0xffffffff )
ALORS
	erreur_800010475 = i_set_art_str(g_iartout, $TconvNE::CODCIRDR, pt_CODCIRDA_800010475)
SINON
	erreur_800010475 = i_supprChamp(g_iartout, "T4codcirdr")
FINSI

# Initialisation parametre obligatoire CCD
erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::CCD, CCD_800010475)

# Initialisation parametre optionnel TAX1 (UT1 + 100*CPTX)

SI (UT1_800010475 != 0xffff)
ALORS
	#trace("ajout T4tax1")
	SI (ddeur_etr_800010475 == 1) || (idsv_800010475 == NIND2_800010475) || (idsv_800010475 == NIND3_800010475)  || (idsv_800010475 == IDSV7_800010475) || (idsv_800010475 == 18) || (idsv_800010475 == 20)
	ALORS
		UT1_800010475 = UT1_800010475 + UT2_800010475
	FINSI
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::TAX1, UT1_800010475 + (100*CPTX_800010475))
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::UNITE1, unite1_800010475)
SINON
	erreur_800010475 = i_supprChamp(g_iartout, "T4tax1")
FINSI

# Initialisation parametre optionnel TAX2 (TDN)

SI (UT2_800010475 != 0xffff)
ALORS
	#trace("ajout T4tax2")
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::TAX2, UT2_800010475)
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::UNITE2, unite2_800010475)
SINON
	erreur_800010475 = i_supprChamp(g_iartout, "T4tax2")
FINSI

# Initialisation parametres optionnels VMV1_1 VMV1_2 VMV1_3 VMV2_1 VMV2_2 VMV2_3

SI ((VMV1_1_800010475 != 0xffff) || (VMV1_2_800010475 != 0xffff) || (VMV1_3_800010475 != 0xffff) || (VMV2_1_800010475 != 0xffff) || (VMV2_2_800010475 != 0xffff) || (VMV2_3_800010475 != 0xffff))
ALORS
	#trace("ajout T4vmv")
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::VMV1_1, VMV1_1_800010475)
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::VMV1_2, VMV1_2_800010475)
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::VMV1_3, VMV1_3_800010475)
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::VMV2_1, VMV2_1_800010475)
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::VMV2_2, VMV2_2_800010475)
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::VMV2_3, VMV2_3_800010475)
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::UNITE3, unite3_800010475)
SINON
	erreur_800010475 = i_supprChamp(g_iartout, "T4vmv")
FINSI

# Initialisation parametre optionnel DURFACT

SI  (DURFACT_800010475 != 0xffff)
ALORS
	#trace("ajout T4durfact")
	erreur_800010475 = i_set_art_field(g_iartout, $TconvNE::DURFACT, DURFACT_800010475)
SINON
	erreur_800010475 = i_supprChamp(g_iartout, "T4durfact")
FINSI

# Stockage en Valide

#trace2("Stockage en VALIDE %s", "", "")

erreur_800010475 = i_stocke_art(g_iartout, 0, PT_OK, 0)

RETOUR TRAIT_OK

#==============================================================================
#				STOCKAGE DANS RECYCLABLE
#==============================================================================

#POINT	STOCKE_RECYCLE

#trace2("Stockage en RECYCLE %s", "", "")

#erreur = i_stocke_art(g_iartin, 0, PT_RECYCLE, 0)

#RETOUR TRAIT_OK

#==============================================================================
#				STOCKAGE DANS ERRONE
#==============================================================================

POINT	STOCKE_ERRONE

#trace2("Stockage en ERRONE %s", "", "")

erreur_800010475 = i_make_art_rej(g_iartin, g_iartout5, code_rejet_800010475)
erreur_800010475 = i_stocke_art(g_iartout5, 0, PT_ERRONE, 0)

RETOUR TRAIT_OK
