* test_s9_7_cablare_idfact.prg
* Proba S9-7 (docs\propunere_s9_7_cablare_idfact.md, sectiunea 4): cablajul VFP care impune
* ID_FACT-ul documentului vechi la reemitere, TINTIT pe (nract, serie_act), fara comutator.
*
* Diferenta esentiala fata de test_s9_6_idfact_fortat.prg: acest test NU seteaza el
* pack_contafin.nIdFactFortat/nNractFortat/cSerieFortata si NU seteaza glRegenerareEditare.
* Fortarea e facuta AUTOMAT de do_scrie_articole (ofacturare.vc2, hunk B1), tintita pe
* poDate.nract/poDate.serie_act, imediat ce poSnapshotEditare.id_fact > 0. Comutatorul
* glRegenerareEditare a fost scos (hunk B2) - ruta 1 (regenerare) e vizibila necoditionat.
*
* Parametru tnRulare:
*   1 = P1  reemitere document FARA grup de incasare (id_vanzare 1082)
*   2 = P2  reemitere document CU incasare pe ACEEASI serie ca factura (id_vanzare 1149,
*           cod 1141174 - documentul masurat in propunere sectiunea 1.5 sub codul vechi
*           1141166). Verifica si P3 (comutatorul scos - ruta 1 fara glRegenerareEditare).
*   3 = P4  esec real dupa stergere: documentul 1076 (m.lcListaIncasare gol, defect
*           preexistent). do_scrie_factura() trebuie sa intoarca .F. SI sa curete
*           pack_contafin.nIdFactFortat (piesa 2).
*   4 = P5  D3: dupa o reemitere reusita, o A DOUA chemare a do_scrie_factura() pe acelasi
*           poDate/poSnapshotEditare nu mai scrie nimic (poSnapshotEditare = .Null. dupa
*           succes - hunk B5). Document 1154 (era 1086, consumat de o rulare anterioara cu bug
*           in test - vezi nota din raport).
*   5 = P6  neregresie: reemitere OBISNUITA (fara particularitati), coloanele randului
*           DOCUMENTE reinviat comparate cu setul de 22 coloane din s9_6_snapshot_dupa.txt.
*           Document 1090.
*   6 = CN2 control negativ: tinta GRESITA. poDate.nract se corupe (+1) inainte de apel, deci
*           fortarea automata tinteste un grup care nu exista in bucla. Asteptat: ID_FACT nou,
*           randul vechi ramane sters=1, toate trei variabilele NULL dupa apel (hunk C4).
*           Document 1094. Acelasi mecanism ca rularea 7 din raportul Oracle (deja probat acolo
*           direct in PL/SQL) - aici e probat capat-la-capat prin formularul VFP.
*   7 = CN3 control negativ: piesa 2 FARA curatare. Se seteaza nIdFactFortat direct (apel
*           ForteazaIdFactReemitere, functia livrata de S9-7), apoi ROLLBACK direct - FARA
*           CurataIdFactFortat(). Asteptat: nIdFactFortat ramane NECURATAT (non-NULL) - dovada
*           ca ROLLBACK singur nu rezolva piesa 2, doar apelul explicit o face. Nu scrie/sterge
*           niciun document real.
*   8 = CN4 control negativ: D3 FARA resetare. Dupa o reemitere reusita (poSnapshotEditare
*           devine .Null. prin hunk B5), se RESTAUREAZA manual referinta veche (simuland ca
*           hunk B5 n-ar fi rulat) si se cheama do_scrie_factura() a doua oara. Asteptat: DOUA
*           documente noi (al treilea document, exact bug-ul D3 din raport_s9_4.md). Document 1095.
*
*   CN1 (fara tintire deloc) NU se ruleaza prin acest test: hunk B1 cheama necoditionat
*   ForteazaIdFactReemitere(poSnapshotEditare.id_fact, poDate.nract, poDate.serie_act) - iar
*   poDate.nract al unui document real INCARCAT nu poate fi NULL/gol, deci cablajul VFP nu poate
*   produce scenariul "fara tintire" (comportamentul S9-6 simplu) prin traseul normal, indiferent
*   de documentul ales. Scenariul e deja probat la nivel Oracle (raport_s9_7_oracle.md sectiunea 3,
*   rularea 6: 20 PASS / 4 FAIL - a picat exact cum trebuia, cu id_vanzare 1079 -> 1150), prin apel
*   PL/SQL direct care ocoleste cablajul VFP. Nu se reproduce aici ca sa nu se dubleze un apel de
*   scriere Oracle in afara caii oficiale (StergeDocumentFacturare + SCRIE_IN_ACT) doar ca sa se
*   forteze un caz pe care cablajul insusi nu-l poate produce.
*
* Documente EXCLUSE (folosite de alte suite / DATA_ACT alterata / deja consumate de proba Oracle):
*   1047, 1048, 1055, 1076(folosit explicit la P4), 1113, 1130, 1141, 1146, 1149(folosit explicit
*   la P2), 1150, 1151, 1077, 1078, 1147, 1148, 1079, 1083

LPARAMETERS tnRulare

SET SAFETY OFF
SET TALK OFF

PUBLIC gcErrLog, gnPass, gnFail
PUBLIC poDate, poSnapshotEditare, goFormReemitere, goSnapshotAntic

gcErrLog = 'D:\ROA\ROAFACTURARE\COMUN\utile\Teste\editare_factura\test_s9_7_cablare_idfact_log_' + ;
	STRTRAN(STRTRAN(STRTRAN(TTOC(DATETIME()), '/', ''), ':', ''), ' ', '_') + '.txt'
STRTOFILE('start ' + TRANSFORM(DATETIME()) + '  rulare=' + TRANSFORM(tnRulare) + CHR(13) + CHR(10), gcErrLog)

ON ERROR DO test_error_handler WITH ERROR(), MESSAGE(), PROGRAM(), LINENO()
ON SHUTDOWN QUIT

DO ('D:\ROA\ROAFACTURARE\COMUN\utile\Teste\test_init_env_auto_roafacturare.prg') WITH 'CENTRAL', 'MARIUSM_AUTO', 'ROMFASTSOFT'
IF gnHandle <= 0
	STRTOFILE('EROARE: conectare esuata' + CHR(13) + CHR(10), gcErrLog, 1)
	QUIT
ENDIF
gnIdUtil = 8

SET PROCEDURE TO D:\ROA\ROAFACTURARE\COMUN\programe\ofacturare_editare.prg ADDITIVE
SET PROCEDURE TO D:\ROA\ROAFACTURARE\COMUN\programe\ofacturare_rutare_scriere.prg ADDITIVE

*!* la nume duplicat de procedura castiga PRIMUL fisier din lista SET PROCEDURE, nu ultimul
LOCAL lcProcExistent
lcProcExistent = SET("PROCEDURE")
SET PROCEDURE TO "D:\ROA\ROAFACTURARE\COMUN\utile\Teste\mock_amessagebox.prg", &lcProcExistent

*!* stub_verificare inaintea lui COMUN\FERESTRE: Do Form verificare (ofacturare.vc2) nu se afiseaza
LOCAL lcPathVechi, lcPathNou
lcPathVechi = SET("PATH")
lcPathNou = 'D:\ROA\ROAFACTURARE\COMUN\Utile\Teste\achizitie_import\stub_verificare;' + lcPathVechi
SET PATH TO &lcPathNou

PUBLIC gnMockRaspuns, gcMockUltimMesaj, gnMockUltimTip
gnMockRaspuns = 7
gcMockUltimMesaj = ''
gnMockUltimTip = 0
gnPass = 0
gnFail = 0

STRTOFILE('perioada activa gnAn/gnLuna = ' + TRANSFORM(gnAn) + '/' + TRANSFORM(gnLuna) + CHR(13) + CHR(10), gcErrLog, 1)

LOCAL lnRulare
lnRulare = VAL(TRANSFORM(tnRulare))
STRTOFILE('rulare ceruta: ' + TRANSFORM(lnRulare) + CHR(13) + CHR(10), gcErrLog, 1)

DO CASE
CASE lnRulare = 1
	DO ProbaP1
CASE lnRulare = 2
	DO ProbaP2
CASE lnRulare = 3
	DO ProbaP4
CASE lnRulare = 4
	DO ProbaP5
CASE lnRulare = 5
	DO ProbaP6
CASE lnRulare = 6
	DO ProbaCN2
CASE lnRulare = 7
	DO ProbaCN3
CASE lnRulare = 8
	DO ProbaCN4
OTHERWISE
	STRTOFILE('EROARE: tnRulare trebuie sa fie intre 1 si 8' + CHR(13) + CHR(10), gcErrLog, 1)
ENDCASE

STRTOFILE('REZULTAT: ' + TRANSFORM(gnPass) + ' PASS / ' + TRANSFORM(gnFail) + ' FAIL' + CHR(13) + CHR(10), gcErrLog, 1)
STRTOFILE('end ' + TRANSFORM(DATETIME()) + CHR(13) + CHR(10), gcErrLog, 1)

QUIT


*==============================================================================================
* P1 - reemitere fara grup de incasare. Identitatea (ID_FACT) trebuie pastrata integral.
*==============================================================================================
PROCEDURE ProbaP1
	LOCAL lnIdV, lnIdFactVechi, lnIdUtilInainte, lcDataOraInainte, lnIdVNou, llRez, lnIdFactNou
	LOCAL lcSerieNoua, lnNumarNou, lnNrDocFortat, lnFortatDupa

	*!* sursa se alege la rulare: reemiterea o consuma, iar un id fix face proba verde o singura
	*!* data (1082 -> 1152 -> 1160, toate consumate de rularile anterioare)
	lnIdV = AlegeDocS97(.F.)
	DO asserteaza WITH 'P1 exista un document reemitabil fara grup de incasare', lnIdV > 0, TRANSFORM(lnIdV)
	IF lnIdV <= 0
		RETURN
	ENDIF

	IF !CititStareInainte(lnIdV, @lnIdFactVechi, @lnIdUtilInainte, @lcDataOraInainte)
		RETURN
	ENDIF

	IF !ReemiteDocumentAuto(lnIdV, @lnIdVNou, @llRez, 0, '')
		RETURN
	ENDIF

	lnFortatDupa = CitesteFortat()
	DO asserteaza WITH 'P1-C1  do_scrie_factura() a intors .T.', llRez, TRANSFORM(llRez)
	DO asserteaza WITH 'P1-C10 nIdFactFortat e consumat (NULL) dupa apel', ;
		lnFortatDupa = -1 OR lnFortatDupa = -999, TRANSFORM(lnFortatDupa)

	lnIdFactNou = Val1([select nvl(id_fact,0) as v from vanzari where id_vanzare = ] + TRANSFORM(lnIdVNou))
	DO asserteaza WITH 'P1-C4  ID_FACT-ul documentului nou = ID_FACT-ul vechi (identitate pastrata)', ;
		lnIdFactNou = lnIdFactVechi, TRANSFORM(lnIdFactVechi) + ' vs ' + TRANSFORM(lnIdFactNou)

	lnNrDocFortat = Val1([select count(*) as v from documente where id_doc = ] + TRANSFORM(lnIdFactVechi))
	DO asserteaza WITH 'P1-C5  DOCUMENTE are exact UN rand pe ID_DOC-ul pastrat', lnNrDocFortat = 1, TRANSFORM(lnNrDocFortat)

	CititStareDupa(lnIdVNou, @lcSerieNoua, @lnNumarNou)
	DO VerificaRandulReinviat WITH lnIdFactVechi, lcSerieNoua, lnNumarNou, lnIdUtilInainte, lcDataOraInainte, 'P1'
ENDPROC


*==============================================================================================
* P2 - reemitere document CU incasare pe aceeasi serie ca factura. Randul DOCUMENTE reinviat
* trebuie sa poarte seria/numarul FACTURII, nu ale chitantei (riscul 4). Verifica si P3
* (comutatorul scos): NU se seteaza glRegenerareEditare, deci daca ruta 1 nu ar mai fi vizibila
* ar aparea mesajul "nu e inca implementata" prin mock.
*==============================================================================================
PROCEDURE ProbaP2
	LOCAL lnIdV, lnIdFactVechi, lnIdUtilInainte, lcDataOraInainte, lnIdVNou, llRez, lnIdFactNou
	LOCAL lcSerieNoua, lnNumarNou

	*!* 1161 = succesorul lui 1149 -> 1153 (ambii consumati); acelasi id_fact=8010203 (SSS/601),
	*!* aceeasi pereche de grupuri ACT (factura SSS/601 + incasare SSS/45, aceeasi serie) - verificat
	*!* inainte de aceasta rulare
	lnIdV = 1161
	IF !CititStareInainte(lnIdV, @lnIdFactVechi, @lnIdUtilInainte, @lcDataOraInainte)
		RETURN
	ENDIF
	DO ListeazaGrupuriAct WITH Val1([select nvl(cod,0) as v from vanzari where id_vanzare = ] + TRANSFORM(lnIdV))

	IF !ReemiteDocumentAuto(lnIdV, @lnIdVNou, @llRez, 0, '')
		RETURN
	ENDIF

	*!* P3: comutatorul a fost scos - gcMockUltimMesaj nu trebuie sa contina textul vechi
	DO asserteaza WITH 'P3   comutatorul glRegenerareEditare e scos (fara mesaj "nu e inca implementata")', ;
		!('nu e inca implementata' $ LOWER(gcMockUltimMesaj)), '[' + gcMockUltimMesaj + ']'
	DO asserteaza WITH 'P2-C1  do_scrie_factura() a intors .T.', llRez, TRANSFORM(llRez)

	lnIdFactNou = Val1([select nvl(id_fact,0) as v from vanzari where id_vanzare = ] + TRANSFORM(lnIdVNou))
	DO asserteaza WITH 'P2-C4  ID_FACT-ul documentului nou = ID_FACT-ul vechi (identitate pastrata)', ;
		lnIdFactNou = lnIdFactVechi, TRANSFORM(lnIdFactVechi) + ' vs ' + TRANSFORM(lnIdFactNou)

	CititStareDupa(lnIdVNou, @lcSerieNoua, @lnNumarNou)
	DO VerificaRandulReinviat WITH lnIdFactVechi, lcSerieNoua, lnNumarNou, lnIdUtilInainte, lcDataOraInainte, 'P2'

	*!* riscul 4: grupul FACTURII (nract=numarul nou) trebuie sa poarte id_fact-ul vechi, grupul
	*!* de INCASARE trebuie sa fi primit alt id_fact, din secventa
	DO ListeazaGrupuriAct WITH Val1([select nvl(cod,0) as v from vanzari where id_vanzare = ] + TRANSFORM(lnIdVNou))
	DO VerificaTintireGrupuri WITH lnIdVNou, lnIdFactVechi, lcSerieNoua, lnNumarNou, 'P2'
ENDPROC


*==============================================================================================
* P4 - esec real dupa stergere: documentul 1076 pica in do_scrie_factura (lcListaIncasare gol,
* defect preexistent). Proba piesei 2: nIdFactFortat trebuie curatat chiar si pe esec.
*==============================================================================================
PROCEDURE ProbaP4
	LOCAL lnIdV, lnIdFactVechi, lnIdUtilInainte, lcDataOraInainte, lnIdVNou, llRez, lnFortatDupa
	LOCAL lnStersDupa, lnIdFactDupa

	lnIdV = 1076
	IF !CititStareInainte(lnIdV, @lnIdFactVechi, @lnIdUtilInainte, @lcDataOraInainte)
		RETURN
	ENDIF

	*!* aici NU se asteapta succes - ReemiteDocumentAuto intoarce .T. daca s-a ajuns pana la apel;
	*!* rezultatul apelului insusi (llRez) trebuie sa fie .F.
	IF !ReemiteDocumentAuto(lnIdV, @lnIdVNou, @llRez, 0, '')
		STRTOFILE('P4: nu s-a putut incarca/pregati documentul 1076' + CHR(13) + CHR(10), gcErrLog, 1)
		RETURN
	ENDIF

	DO asserteaza WITH 'P4-1  do_scrie_factura() a intors .F. (esec real, dupa stergere)', !llRez, TRANSFORM(llRez)

	lnFortatDupa = CitesteFortat()
	STRTOFILE('P4: nIdFactFortat dupa esec = ' + TRANSFORM(lnFortatDupa) + ' (-1=NULL, -999=necitibil)' + CHR(13) + CHR(10), gcErrLog, 1)
	IF lnFortatDupa <> -999
		DO asserteaza WITH 'P4-2  nIdFactFortat e curatat (NULL) chiar si pe esecul real (piesa 2)', ;
			lnFortatDupa = -1, TRANSFORM(lnFortatDupa)
	ELSE
		STRTOFILE('P4-2 NECONCLUDENT: variabila nu s-a putut citi prin bind OUT' + CHR(13) + CHR(10), gcErrLog, 1)
	ENDIF

	lnStersDupa = Val1([select nvl(sters,-1) as v from vanzari where id_vanzare = ] + TRANSFORM(lnIdV))
	DO asserteaza WITH 'P4-3  documentul 1076 ramane STERS = 0 (nu s-a scris nimic)', lnStersDupa = 0, TRANSFORM(lnStersDupa)
	lnIdFactDupa = Val1([select nvl(id_fact,0) as v from vanzari where id_vanzare = ] + TRANSFORM(lnIdV))
	DO asserteaza WITH 'P4-4  ID_FACT-ul documentului 1076 neschimbat', lnIdFactDupa = lnIdFactVechi, ;
		TRANSFORM(lnIdFactVechi) + ' vs ' + TRANSFORM(lnIdFactDupa)
ENDPROC


*==============================================================================================
* P5 - D3: dupa o reemitere reusita, poSnapshotEditare devine .Null. (hunk B5). O a doua
* chemare a do_scrie_factura() pe acelasi obiect NU mai scrie nimic (ruta 0).
*==============================================================================================
PROCEDURE ProbaP5
	LOCAL lnIdV, lnIdFactVechi, lnIdUtilInainte, lcDataOraInainte, lnIdVNou, llRez, lnIdVMaxDupa1
	LOCAL llRez2, lnCntDupa2

	*!* 1155 = succesorul lui 1086 -> 1154 (ambii consumati de rularile anterioare); acelasi id_fact=8010083
	lnIdV = 1155
	IF !CititStareInainte(lnIdV, @lnIdFactVechi, @lnIdUtilInainte, @lcDataOraInainte)
		RETURN
	ENDIF

	IF !ReemiteDocumentAuto(lnIdV, @lnIdVNou, @llRez, 0, '')
		RETURN
	ENDIF
	DO asserteaza WITH 'P5-1  prima scriere a reusit', llRez, TRANSFORM(llRez)

	DO asserteaza WITH 'P5-2  poSnapshotEditare devine .Null. dupa succes (hunk B5)', ;
		VARTYPE(poSnapshotEditare) <> 'O', VARTYPE(poSnapshotEditare)

	lnIdVMaxDupa1 = Val1([select nvl(max(id_vanzare),0) as v from vanzari])

	DO urma WITH 'P5: a doua chemare do_scrie_factura() pe acelasi obiect'
	llRez2 = goFormReemitere.do_scrie_factura()
	STRTOFILE('P5: a doua chemare a intors ' + TRANSFORM(llRez2) + CHR(13) + CHR(10), gcErrLog, 1)
	DO asserteaza WITH 'P5-3  a doua chemare intoarce .T. (ruta 0, nimic de scris)', llRez2, TRANSFORM(llRez2)

	lnCntDupa2 = Val1([select count(*) as v from vanzari where sters = 0 and id_vanzare > ] + TRANSFORM(lnIdVMaxDupa1))
	DO asserteaza WITH 'P5-4  niciun document nou dupa a doua chemare (fara al treilea document)', ;
		lnCntDupa2 = 0, TRANSFORM(lnCntDupa2)
ENDPROC


*==============================================================================================
* P6 - neregresie: reemitere obisnuita, coloanele randului DOCUMENTE reinviat comparate cu
* setul de 22 coloane din s9_6_snapshot_dupa.txt (acelasi set, aceeasi semantica).
*==============================================================================================
PROCEDURE ProbaP6
	LOCAL lnIdV, lnIdFactVechi, lnIdUtilInainte, lcDataOraInainte, lnIdVNou, llRez

	*!* 1156 = succesorul lui 1090 (consumat de rularea anterioara); acelasi id_fact=8010090
	lnIdV = 1156
	IF !CititStareInainte(lnIdV, @lnIdFactVechi, @lnIdUtilInainte, @lcDataOraInainte)
		RETURN
	ENDIF

	IF !ReemiteDocumentAuto(lnIdV, @lnIdVNou, @llRez, 0, '')
		RETURN
	ENDIF
	DO asserteaza WITH 'P6-1  scrierea a reusit', llRez, TRANSFORM(llRez)

	IF USED('v_p6')
		USE IN v_p6
	ENDIF
	IF !goExecutor.oExecuta([select id_doc, dataora, id_util, sters, dataoras, id_utils, tva_incasare, ] + ;
			[serie_act, nract, dataact, id_part, id_ctr, cont, acont, id_valuta, id_sucursala, ] + ;
			[ip_ani, ip_lunai, ip_soldi, id_set, dataireg, tip_saft from documente where id_doc = ] + ;
			TRANSFORM(lnIdFactVechi), 'v_p6')
		DO asserteaza WITH 'P6-2  randul reinviat s-a putut citi cu toate cele 22 coloane', .F., 'eroare interogare'
		RETURN
	ENDIF
	DO asserteaza WITH 'P6-2  randul reinviat s-a putut citi cu toate cele 22 de coloane din s9_6_snapshot_dupa.txt', ;
		RECCOUNT('v_p6') = 1, TRANSFORM(RECCOUNT('v_p6'))
	SELECT v_p6
	GO TOP
	STRTOFILE('P6 RAND (22 coloane): id_doc=' + TRANSFORM(id_doc) + ' sters=' + TRANSFORM(sters) + ;
		' serie_act=[' + ALLTRIM(NVL(serie_act,'')) + '] nract=' + TRANSFORM(NVL(nract,-1)) + ;
		' id_util=' + TRANSFORM(NVL(id_util,-1)) + ' tva_incasare=' + TRANSFORM(NVL(tva_incasare,-1)) + ;
		' id_set=' + TRANSFORM(NVL(id_set,-1)) + ' tip_saft=' + TRANSFORM(NVL(tip_saft,-1)) + CHR(13) + CHR(10), gcErrLog, 1)
	DO asserteaza WITH 'P6-3  randul reinviat are STERS = 0 (aceeasi semantica ca s9_6_snapshot_dupa.txt)', ;
		NVL(sters,-1) = 0, TRANSFORM(NVL(sters,-1))
	USE IN v_p6
ENDPROC


*==============================================================================================
* CN2 - control negativ: tinta GRESITA. poDate.nract se corupe (+1) chiar inainte de apel, deci
* fortarea automata (nNractFortat = poDate.nract corupt) nu se potriveste cu niciun grup real.
* Asteptat: ID_FACT nou, randul vechi ramane sters=1, toate variabilele NULL dupa apel (hunk C4).
*==============================================================================================
PROCEDURE ProbaCN2
	LOCAL lnIdV, lnIdFactVechi, lnIdUtilInainte, lcDataOraInainte, lnIdVNou, llRez, lnIdFactNou
	LOCAL lnStersDoc, lnFortatDupa

	*!* 1096 = candidat proaspat, fara incasare (1094 deja consumat de rularea anterioara)
	lnIdV = 1096
	IF !CititStareInainte(lnIdV, @lnIdFactVechi, @lnIdUtilInainte, @lcDataOraInainte)
		RETURN
	ENDIF

	*!* corupe tinta: poDate.nract + 1000 (nu exista niciun grup ACT cu acest nract)
	IF !ReemiteDocumentAuto(lnIdV, @lnIdVNou, @llRez, 1000, '')
		RETURN
	ENDIF

	lnIdFactNou = Val1([select nvl(id_fact,0) as v from vanzari where id_vanzare = ] + TRANSFORM(lnIdVNou))
	DO asserteaza WITH 'CN2-1 cu tinta gresita, ID_FACT-ul documentului nou e DIFERIT de cel vechi', ;
		lnIdFactNou > 0 AND lnIdFactNou <> lnIdFactVechi, TRANSFORM(lnIdFactVechi) + ' -> ' + TRANSFORM(lnIdFactNou)

	lnStersDoc = Val1([select nvl(sters,-1) as v from documente where id_doc = ] + TRANSFORM(lnIdFactVechi))
	DO asserteaza WITH 'CN2-2 randul vechi din DOCUMENTE ramane sters = 1', lnStersDoc = 1, TRANSFORM(lnStersDoc)

	lnFortatDupa = CitesteFortat()
	IF lnFortatDupa <> -999
		DO asserteaza WITH 'CN2-3 nIdFactFortat e NULL dupa apel (resetare dupa bucla, hunk C4)', ;
			lnFortatDupa = -1, TRANSFORM(lnFortatDupa)
	ELSE
		STRTOFILE('CN2-3 NECONCLUDENT: variabila nu s-a putut citi prin bind OUT' + CHR(13) + CHR(10), gcErrLog, 1)
	ENDIF
	DO VerificaVariabileTinta WITH 'CN2'
ENDPROC


*==============================================================================================
* CN3 - control negativ: piesa 2 FARA curatare. Se seteaza direct nIdFactFortat (functia livrata
* de S9-7, ForteazaIdFactReemitere), apoi se face ROLLBACK direct pe handle - FARA
* CurataIdFactFortat(). Nu scrie/sterge niciun document real - foloseste un id_fact existent
* doar ca valoare de proba.
*==============================================================================================
PROCEDURE ProbaCN3
	LOCAL lnIdFactProba, llSetat, lnFortatDupa

	lnIdFactProba = Val1([select nvl(max(id_fact),0) as v from vanzari where sters=0])
	DO asserteaza WITH 'CN3-precond exista un id_fact de proba', lnIdFactProba > 0, TRANSFORM(lnIdFactProba)
	IF lnIdFactProba <= 0
		RETURN
	ENDIF

	llSetat = ForteazaIdFactReemitere(lnIdFactProba, 999999, 'ZZ')
	DO asserteaza WITH 'CN3-1 ForteazaIdFactReemitere a reusit (functie livrata de S9-7)', llSetat, TRANSFORM(llSetat)

	*!* ROLLBACK direct, FARA CurataIdFactFortat() - simuleaza piesa 2 lipsa
	goExecutor.oExecuta('ROLLBACK')

	lnFortatDupa = CitesteFortat()
	STRTOFILE('CN3: nIdFactFortat dupa ROLLBACK fara curatare = ' + TRANSFORM(lnFortatDupa) + CHR(13) + CHR(10), gcErrLog, 1)
	IF lnFortatDupa <> -999
		DO asserteaza WITH 'CN3-2 nIdFactFortat NU e curatat de ROLLBACK singur (asteptat sa PICE ca "NULL")', ;
			lnFortatDupa <> -1, TRANSFORM(lnFortatDupa)
	ELSE
		STRTOFILE('CN3-2 NECONCLUDENT: variabila nu s-a putut citi prin bind OUT' + CHR(13) + CHR(10), gcErrLog, 1)
	ENDIF

	*!* curatare finala, ca sesiunea sa nu ramana contaminata pentru rularile urmatoare
	CurataIdFactFortatDirect()
	lnFortatDupa = CitesteFortat()
	STRTOFILE('CN3: nIdFactFortat dupa curatare finala manuala = ' + TRANSFORM(lnFortatDupa) + CHR(13) + CHR(10), gcErrLog, 1)
ENDPROC


*==============================================================================================
* CN4 - control negativ: D3 FARA resetare. Dupa o reemitere reusita (poSnapshotEditare devine
* .Null. prin hunk B5), se RESTAUREAZA manual referinta veche (simuland ca hunk B5 n-ar fi
* rulat) si se cheama do_scrie_factura() a doua oara. Asteptat: DOUA documente noi (al treilea
* document total) - bug-ul D3 reprodus.
*==============================================================================================
PROCEDURE ProbaCN4
	LOCAL lnIdV, lnIdFactVechi, lnIdUtilInainte, lcDataOraInainte, lnIdVNou, llRez, lnIdVMaxDupa1
	LOCAL llRez2, lnCntDupa2

	*!* 1097 = candidat proaspat (1095 deja consumat de rularea anterioara)
	lnIdV = 1097
	IF !CititStareInainte(lnIdV, @lnIdFactVechi, @lnIdUtilInainte, @lcDataOraInainte)
		RETURN
	ENDIF

	IF !ReemiteDocumentAuto(lnIdV, @lnIdVNou, @llRez, 0, '')
		RETURN
	ENDIF
	DO asserteaza WITH 'CN4-1 prima scriere a reusit', llRez, TRANSFORM(llRez)

	DO asserteaza WITH 'CN4-precond poSnapshotEditare a devenit .Null. dupa succes (confirmare hunk B5 activ)', ;
		VARTYPE(poSnapshotEditare) <> 'O', VARTYPE(poSnapshotEditare)
	DO asserteaza WITH 'CN4-precond referinta veche (goSnapshotAntic) a fost pastrata, pre-scriere', ;
		VARTYPE(goSnapshotAntic) = 'O', VARTYPE(goSnapshotAntic)

	*!* restaureaza manual - simuleaza "fara poSnapshotEditare = .Null." dupa succes
	poSnapshotEditare = goSnapshotAntic

	lnIdVMaxDupa1 = Val1([select nvl(max(id_vanzare),0) as v from vanzari])

	DO urma WITH 'CN4: a doua chemare do_scrie_factura() cu instantaneul VECHI restaurat manual'
	llRez2 = goFormReemitere.do_scrie_factura()
	STRTOFILE('CN4: a doua chemare (fara reset) a intors ' + TRANSFORM(llRez2) + CHR(13) + CHR(10), gcErrLog, 1)

	lnCntDupa2 = Val1([select count(*) as v from vanzari where sters = 0 and id_vanzare > ] + TRANSFORM(lnIdVMaxDupa1))
	STRTOFILE('CN4: documente noi dupa a doua chemare fara reset = ' + TRANSFORM(lnCntDupa2) + CHR(13) + CHR(10), gcErrLog, 1)
	DO asserteaza WITH 'CN4-2 fara resetare apare un AL TREILEA document (asteptat sa PICE fata de comportamentul corect)', ;
		lnCntDupa2 >= 1, TRANSFORM(lnCntDupa2)
ENDPROC


*==============================================================================================
* ReemiteDocumentAuto: incarca documentul in editare, modifica o cantitate, cheama
* do_scrie_factura() REAL - fara nicio forta manuala si fara glRegenerareEditare. tnCorupeNract
* (0 = normal) se aduna la poDate.nract chiar inainte de apel, pentru CN2.
*==============================================================================================
PROCEDURE ReemiteDocumentAuto
	LPARAMETERS tnIdV, tnIdVNou, tlRez, tnCorupeNract, tcNefolosit, toFormIesire
	LOCAL loForm, lnDiscRon, lnDiscVal, lnCantVeche, lnCantNoua, lnNr, lnIdVMaxInainte, lnCod, lnAn, lnLuna, lnIdFactVechi

	lnIdVMaxInainte = Val1([select nvl(max(id_vanzare),0) as v from vanzari])
	lnCod = Val1([select nvl(cod,0) as v from vanzari where id_vanzare = ] + TRANSFORM(tnIdV))
	lnIdFactVechi = Val1([select nvl(id_fact,0) as v from vanzari where id_vanzare = ] + TRANSFORM(tnIdV))
	lnAn = gnAn
	lnLuna = gnLuna

	DO urma WITH 'IncarcaAntetFacturaEditare ' + TRANSFORM(tnIdV)
	lnDiscRon = 0
	lnDiscVal = 0
	poDate = IncarcaAntetFacturaEditare(tnIdV, @lnDiscRon, @lnDiscVal)
	DO asserteaza WITH 'antetul documentului ' + TRANSFORM(tnIdV) + ' s-a incarcat', VARTYPE(poDate) = 'O', VARTYPE(poDate)
	IF VARTYPE(poDate) <> 'O'
		RETURN .F.
	ENDIF

	DO urma WITH 'IncarcaLiniiFacturaEditare ' + TRANSFORM(tnIdV)
	IncarcaLiniiFacturaEditare(poDate, tnIdV)
	DO asserteaza WITH 'liniile documentului ' + TRANSFORM(tnIdV) + ' s-au incarcat', ;
		USED('crsfactura') AND RECCOUNT('crsfactura') > 0, TRANSFORM(IIF(USED('crsfactura'), RECCOUNT('crsfactura'), -1))
	IF !USED('crsfactura') OR RECCOUNT('crsfactura') = 0
		RETURN .F.
	ENDIF

	update_jtva_coloane([JV], [jtva_coloane_temp])
	update_saft_taxtable()
	IF USED('jtva_coloane')
		USE IN jtva_coloane
	ENDIF
	IF poDate.tva_incasare = 0
		SELECT * FROM jtva_coloane_temp WHERE ISNULL(id_jtva_ex) AND !'RORTC' $ UPPER(coloana_jv) INTO CURSOR jtva_coloane
	ELSE
		SELECT * FROM jtva_coloane_temp WHERE ISNULL(id_jtva_neex) AND !'RORTC' $ UPPER(coloana_jv) INTO CURSOR jtva_coloane
	ENDIF

	loForm = CREATEOBJECT('frm_facturare_articole2')
	loForm.ndiscfactron = lnDiscRon
	loForm.ndiscfactval = lnDiscVal
	loForm.do_calculeaza_totaluri()
	poSnapshotEditare = CreeazaSnapshotEditare(poDate, loForm.ndiscfactron, loForm.ndiscfactval, ;
		tnIdV, lnIdFactVechi, lnCod, lnAn, lnLuna)
	IF VARTYPE(poSnapshotEditare) <> 'O'
		DO asserteaza WITH 'instantaneul de editare s-a creat (' + TRANSFORM(tnIdV) + ')', .F., VARTYPE(poSnapshotEditare)
		RETURN .F.
	ENDIF
	*!* referinta PRE-scriere - poSnapshotEditare devine .Null. dupa succes (hunk B5); pastrata
	*!* aici pentru controlul negativ CN4, care simuleaza absenta acelei resetari
	goSnapshotAntic = poSnapshotEditare

	SELECT crsfactura
	GO TOP
	lnCantVeche = cantitate
	lnCantNoua = lnCantVeche + 1
	REPLACE cantitate WITH lnCantNoua IN crsfactura
	loForm.do_calculeaza_totaluri()
	STRTOFILE('cantitate ' + TRANSFORM(lnCantVeche) + ' -> ' + TRANSFORM(lnCantNoua) + CHR(13) + CHR(10), gcErrLog, 1)

	DO asserteaza WITH 'ruta aleasa e 1 (regenerare), doc ' + TRANSFORM(tnIdV), ;
		AlegeRutaScriereEditare(poSnapshotEditare, poDate, loForm.ndiscfactron, loForm.ndiscfactval, 'crsfactura') = 1, ;
		TRANSFORM(AlegeRutaScriereEditare(poSnapshotEditare, poDate, loForm.ndiscfactron, loForm.ndiscfactval, 'crsfactura'))

	IF tnCorupeNract <> 0
		STRTOFILE('CORUPERE TINTA: poDate.nract ' + TRANSFORM(poDate.nract) + ' -> ' + ;
			TRANSFORM(poDate.nract + tnCorupeNract) + CHR(13) + CHR(10), gcErrLog, 1)
		poDate.nract = poDate.nract + tnCorupeNract
	ENDIF

	*!* FARA nicio fortare manuala, FARA glRegenerareEditare - fortarea o face automat hunk B1
	DO urma WITH 'do_scrie_factura (SCRIE IN ORACLE, fortare automata prin cablaj) doc ' + TRANSFORM(tnIdV)
	tlRez = loForm.do_scrie_factura()
	DO urma WITH 'do_scrie_factura a revenit, doc ' + TRANSFORM(tnIdV)
	STRTOFILE('ultimul mesaj prin mock: [' + gcMockUltimMesaj + ']' + CHR(13) + CHR(10), gcErrLog, 1)

	goFormReemitere = loForm

	lnNr = Val1([select count(*) as v from vanzari where sters = 0 and id_vanzare > ] + TRANSFORM(lnIdVMaxInainte))
	tnIdVNou = 0
	IF lnNr >= 1
		tnIdVNou = Val1([select nvl(max(id_vanzare),0) as v from vanzari where sters = 0 and id_vanzare > ] + TRANSFORM(lnIdVMaxInainte))
	ENDIF
	STRTOFILE('documente noi nesterse dupa apel = ' + TRANSFORM(lnNr) + '  id_vanzare nou=' + TRANSFORM(tnIdVNou) + CHR(13) + CHR(10), gcErrLog, 1)

	RETURN .T.
ENDPROC


*==============================================================================================
*==============================================================================================
* Alege la rulare un document reemitabil, dupa acelasi tipar ca AlegeCandidat din
* test_s9_6_idfact_fortat.prg: viu, in perioada activa, cu ID_FACT, cu note in vact_tot, cu
* cantitate pe linii, fara referinte / urmasi / eFactura. tlCuIncasare cere (sau exclude) un grup
* de incasare pe cod - randuri ACT cu SCD care incepe cu 5 si SCC <> 418.
* Documentele-martor ale celorlalte teste din suita se exclud: reemiterea le consuma.
* Doar ProbaP1 alege dinamic; probele P2/P4/P5/P6/CN2/CN3/CN4 au inca id-uri fixe.
FUNCTION AlegeDocS97
	LPARAMETERS tlCuIncasare

	LOCAL lcSql, lnOk, lnAles, lnAn, lnLuna, lnIdV, lnCod, lnIdFact
	lnAles = 0
	lcSql = [select v.id_vanzare, v.cod, v.data_act, v.id_fact from vanzari v where v.sters = 0 ] + ;
		[ and extract(year from v.data_act) = ] + TRANSFORM(gnAn) + ;
		[ and extract(month from v.data_act) = ] + TRANSFORM(gnLuna) + ;
		[ and nvl(v.eproforma,0) = 0 and nvl(v.id_fact,0) > 0 ] + ;
		[ and v.tip not in (4,3,21,25,28,42,47,44,45,46,51) ] + ;
		[ and v.id_vanzare not in (1047,1048,1049,1050,1055,1071,1072,1076,1113,1125,1126,1128,1129,1130,1160) ] + ;
		[ and exists (select 1 from ] + gcs + [.vact_tot a where a.sters = 0 and a.an = ] + TRANSFORM(gnAn) + ;
		[ and a.luna = ] + TRANSFORM(gnLuna) + [ and a.cod = v.cod) ] + ;
		[ and exists (select 1 from vanzari_detalii d where d.sters = 0 and d.id_vanzare = v.id_vanzare ] + ;
		[ and nvl(d.cantitate,0) > 0) ] + ;
		[ and ] + IIF(m.tlCuIncasare, [], [not ]) + ;
		[exists (select 1 from act i where i.sters = 0 and i.cod = v.cod ] + ;
		[ and substr(i.scd,1,1) = '5' and i.scc <> '418') ] + ;
		[order by v.id_vanzare]

	IF USED('v_cand97')
		USE IN v_cand97
	ENDIF
	lnOk = goExecutor.oExecuta(lcSql, 'v_cand97')
	IF !lnOk
		RETURN 0
	ENDIF
	SELECT v_cand97
	SCAN
		*!* campurile se citesc INAINTE de apeluri - garzile schimba zona curenta
		lnIdV = v_cand97.id_vanzare
		lnCod = v_cand97.cod
		lnIdFact = NVL(v_cand97.id_fact, 0)
		lnAn = YEAR(v_cand97.data_act)
		lnLuna = MONTH(v_cand97.data_act)
		IF !ReferinteDocumenteNota(lnAn, lnLuna, lnCod) AND !DocumentAreUrmasi(lnIdV) ;
				AND !EsteInEFactura(lnIdFact)
			lnAles = m.lnIdV
			EXIT
		ENDIF
		SELECT v_cand97
	ENDSCAN
	USE IN v_cand97

	STRTOFILE('sursa aleasa la rulare: id_vanzare=' + TRANSFORM(lnAles) + ;
		' (cu incasare=' + TRANSFORM(m.tlCuIncasare) + ')' + CHR(13) + CHR(10), gcErrLog, 1)
	RETURN m.lnAles
ENDFUNC


PROCEDURE CititStareInainte
	LPARAMETERS tnIdV, tnIdFactVechi, tnIdUtilInainte, tcDataOraInainte

	tnIdFactVechi = Val1([select nvl(id_fact,0) as v from vanzari where id_vanzare = ] + TRANSFORM(tnIdV) + [ and sters = 0])
	DO asserteaza WITH 'PRECONDITIE documentul ' + TRANSFORM(tnIdV) + ' e viu si are ID_FACT', tnIdFactVechi > 0, TRANSFORM(tnIdFactVechi)
	IF tnIdFactVechi <= 0
		RETURN .F.
	ENDIF

	tnIdUtilInainte = -1
	tcDataOraInainte = ''
	IF USED('v_doc97')
		USE IN v_doc97
	ENDIF
	IF goExecutor.oExecuta([select id_util, to_char(dataora,'dd.mm.yyyy hh24:mi:ss') as dataorat from documente ] + ;
			[where id_doc = ] + TRANSFORM(tnIdFactVechi), 'v_doc97')
		SELECT v_doc97
		IF RECCOUNT('v_doc97') = 1
			GO TOP
			tnIdUtilInainte = NVL(id_util, -1)
			tcDataOraInainte = ALLTRIM(NVL(dataorat, ''))
		ENDIF
		USE IN v_doc97
	ENDIF
	STRTOFILE('INAINTE doc ' + TRANSFORM(tnIdV) + ': id_fact=' + TRANSFORM(tnIdFactVechi) + ;
		' documente.id_util=' + TRANSFORM(tnIdUtilInainte) + ' documente.dataora=' + tcDataOraInainte + CHR(13) + CHR(10), gcErrLog, 1)
	RETURN .T.
ENDPROC


PROCEDURE CititStareDupa
	LPARAMETERS tnIdVNou, tcSerie, tnNumar
	tcSerie = ''
	tnNumar = 0
	IF USED('v_ant97')
		USE IN v_ant97
	ENDIF
	IF goExecutor.oExecuta([select serie_act, numar_act from vanzari where id_vanzare = ] + TRANSFORM(tnIdVNou), 'v_ant97')
		SELECT v_ant97
		IF RECCOUNT('v_ant97') = 1
			GO TOP
			tcSerie = ALLTRIM(NVL(serie_act, ''))
			tnNumar = NVL(numar_act, 0)
		ENDIF
		USE IN v_ant97
	ENDIF
ENDPROC


*==============================================================================================
PROCEDURE VerificaRandulReinviat
	LPARAMETERS tnIdDoc, tcSerieNoua, tnNumarNou, tnIdUtilInainte, tcDataOraInainte, tcPrefix
	LOCAL lnSters, lcSerie, lnNract, lnIdUtil, lcDataOra

	IF USED('v_ver97')
		USE IN v_ver97
	ENDIF
	IF !goExecutor.oExecuta([select sters, nvl(serie_act,' ') as serie_act, nvl(nract,-1) as nract, ] + ;
			[id_util, to_char(dataora,'dd.mm.yyyy hh24:mi:ss') as dataorat ] + ;
			[from documente where id_doc = ] + TRANSFORM(tnIdDoc), 'v_ver97')
		DO asserteaza WITH tcPrefix + '-rand  randul reinviat s-a putut citi', .F., 'eroare interogare'
		RETURN
	ENDIF
	SELECT v_ver97
	IF RECCOUNT('v_ver97') <> 1
		DO asserteaza WITH tcPrefix + '-rand  randul reinviat exista o singura data', .F., TRANSFORM(RECCOUNT('v_ver97'))
		USE IN v_ver97
		RETURN
	ENDIF
	GO TOP
	lnSters = NVL(sters, -1)
	lcSerie = ALLTRIM(NVL(serie_act, ''))
	lnNract = NVL(nract, -1)
	lnIdUtil = NVL(id_util, -1)
	lcDataOra = ALLTRIM(NVL(dataorat, ''))
	USE IN v_ver97

	STRTOFILE(tcPrefix + ' RAND REINVIAT id_doc=' + TRANSFORM(tnIdDoc) + ': sters=' + TRANSFORM(lnSters) + ;
		' serie_act=[' + lcSerie + '] nract=' + TRANSFORM(lnNract) + ' id_util=' + TRANSFORM(lnIdUtil) + ;
		' dataora=' + lcDataOra + CHR(13) + CHR(10), gcErrLog, 1)

	DO asserteaza WITH tcPrefix + '-C6  randul reinviat are STERS = 0', lnSters = 0, TRANSFORM(lnSters)
	DO asserteaza WITH tcPrefix + '-C7a serie_act = seria documentului NOU (nu a chitantei)', lcSerie == tcSerieNoua, ;
		'[' + lcSerie + '] vs [' + tcSerieNoua + ']'
	DO asserteaza WITH tcPrefix + '-C7b nract = numarul documentului NOU (nu al chitantei)', lnNract = tnNumarNou, ;
		TRANSFORM(lnNract) + ' vs ' + TRANSFORM(tnNumarNou)
	DO asserteaza WITH tcPrefix + '-C8a ID_UTIL neschimbat (audit de creare)', lnIdUtil = tnIdUtilInainte, ;
		TRANSFORM(tnIdUtilInainte) + ' -> ' + TRANSFORM(lnIdUtil)
	DO asserteaza WITH tcPrefix + '-C8b DATAORA neschimbata (audit de creare)', lcDataOra == tcDataOraInainte, ;
		'[' + tcDataOraInainte + '] -> [' + lcDataOra + ']'
ENDPROC


*==============================================================================================
PROCEDURE VerificaTintireGrupuri
	LPARAMETERS tnIdVNou, tnIdFactVechi, tcSerieNoua, tnNumarNou, tcPrefix
	LOCAL lnCodNou, lnIdFactFactura, lnIdFactIncasare, lnNractIncasare

	lnCodNou = Val1([select nvl(cod,0) as v from vanzari where id_vanzare = ] + TRANSFORM(tnIdVNou))
	lnIdFactFactura = Val1([select nvl(min(id_fact),0) as v from act where cod = ] + TRANSFORM(lnCodNou) + ;
		[ and sters = 0 and nract = ] + TRANSFORM(tnNumarNou) + ;
		[ and nvl(serie_act,'+_') = '] + ALLTRIM(tcSerieNoua) + ['])
	lnIdFactIncasare = Val1([select nvl(min(id_fact),0) as v from act where cod = ] + TRANSFORM(lnCodNou) + ;
		[ and sters = 0 and nract <> ] + TRANSFORM(tnNumarNou))
	lnNractIncasare = Val1([select nvl(min(nract),-1) as v from act where cod = ] + TRANSFORM(lnCodNou) + ;
		[ and sters = 0 and nract <> ] + TRANSFORM(tnNumarNou))

	STRTOFILE(tcPrefix + ' TINTIRE: grup factura (nract=' + TRANSFORM(tnNumarNou) + ') id_fact=' + TRANSFORM(lnIdFactFactura) + ;
		'  grup incasare (nract=' + TRANSFORM(lnNractIncasare) + ') id_fact=' + TRANSFORM(lnIdFactIncasare) + ;
		'  vechi=' + TRANSFORM(tnIdFactVechi) + CHR(13) + CHR(10), gcErrLog, 1)

	DO asserteaza WITH tcPrefix + '-T6  documentul are grup de incasare pe alt nract', lnIdFactIncasare > 0, TRANSFORM(lnNractIncasare)
	DO asserteaza WITH tcPrefix + '-T7  ID_FACT-ul pastrat a ajuns pe grupul FACTURII', ;
		lnIdFactFactura = tnIdFactVechi, TRANSFORM(tnIdFactVechi) + ' vs ' + TRANSFORM(lnIdFactFactura)
	DO asserteaza WITH tcPrefix + '-T7b grupul de INCASARE a primit alt ID_FACT (din secventa)', ;
		lnIdFactIncasare > 0 AND lnIdFactIncasare <> tnIdFactVechi, ;
		TRANSFORM(tnIdFactVechi) + ' vs ' + TRANSFORM(lnIdFactIncasare)
ENDPROC


*==============================================================================================
PROCEDURE ListeazaGrupuriAct
	LPARAMETERS tnCod

	IF USED('v_gr98')
		USE IN v_gr98
	ENDIF
	IF !goExecutor.oExecuta([select id_fact, nvl(serie_act,' ') as serie_act, nract, ] + ;
			[max(case when scd like '5%' or scc like '5%' then 1 else 0 end) as e_inc, count(*) as n ] + ;
			[from act where cod = ] + TRANSFORM(tnCod) + [ and sters = 0 ] + ;
			[group by id_fact, serie_act, nract order by id_fact], 'v_gr98')
		STRTOFILE('EROARE la listarea grupurilor ACT' + CHR(13) + CHR(10), gcErrLog, 1)
		RETURN
	ENDIF
	STRTOFILE('--- grupuri ACT cod ' + TRANSFORM(tnCod) + ' (' + TRANSFORM(RECCOUNT('v_gr98')) + ') ---' + CHR(13) + CHR(10), gcErrLog, 1)
	SELECT v_gr98
	SCAN
		STRTOFILE('  id_fact=' + TRANSFORM(id_fact) + ' serie=[' + ALLTRIM(serie_act) + '] nract=' + ;
			TRANSFORM(nract) + ' incasare=' + TRANSFORM(e_inc) + ' randuri=' + TRANSFORM(n) + CHR(13) + CHR(10), gcErrLog, 1)
	ENDSCAN
	USE IN v_gr98
ENDPROC


*==============================================================================================
* CitesteFortat: variabila de pachet nu poate fi citita din SQL - se citeste prin bind OUT
* intr-un bloc PL/SQL anonim, pe acelasi handle (deci aceeasi sesiune Oracle).
* -1 = NULL (consumata), -999 = apelul nu a reusit (rezultat neconcludent).
*==============================================================================================
FUNCTION CitesteFortat
	LOCAL lnRez
	PRIVATE pnFortat97
	pnFortat97 = 0
	lnRez = SQLEXEC(gnHandle, "begin ?@pnFortat97 := nvl(pack_contafin.nIdFactFortat, -1); end;")
	IF lnRez < 0
		RETURN -999
	ENDIF
	RETURN NVL(pnFortat97, -999)
ENDFUNC


*==============================================================================================
PROCEDURE VerificaVariabileTinta
	LPARAMETERS tcPrefix
	LOCAL lnRez
	PRIVATE pnNract97, pcSerie97
	pnNract97 = 0
	pcSerie97 = ''
	lnRez = SQLEXEC(gnHandle, "begin ?@pnNract97 := nvl(pack_contafin.nNractFortat, -1); " + ;
		"?@pcSerie97 := nvl(pack_contafin.cSerieFortata, '#NULL#'); end;")
	IF lnRez < 0
		STRTOFILE(tcPrefix + '-T8/T9 NECONCLUDENT: variabilele de tintire nu s-au putut citi' + CHR(13) + CHR(10), gcErrLog, 1)
		RETURN
	ENDIF
	STRTOFILE(tcPrefix + ' DUPA APEL: nNractFortat=' + TRANSFORM(NVL(pnNract97, -999)) + ;
		' cSerieFortata=[' + ALLTRIM(NVL(pcSerie97, '?')) + ']' + CHR(13) + CHR(10), gcErrLog, 1)
	DO asserteaza WITH tcPrefix + '-T8  nNractFortat e NULL dupa apel (resetarea de dupa bucla)', ;
		NVL(pnNract97, -999) = -1, TRANSFORM(NVL(pnNract97, -999))
	DO asserteaza WITH tcPrefix + '-T9  cSerieFortata e NULL dupa apel (resetarea de dupa bucla)', ;
		ALLTRIM(NVL(pcSerie97, '?')) == '#NULL#', '[' + ALLTRIM(NVL(pcSerie97, '?')) + ']'
ENDPROC


*==============================================================================================
* CurataIdFactFortatDirect: apel direct la functia CurataIdFactFortat livrata de S9-7, ocolind
* garda pe plRegenerareEditare (nedeclarata in acest scop) - folosit doar pentru curatare finala
* dupa CN3, ca sesiunea Oracle sa nu ramana contaminata pentru rularile urmatoare.
*==============================================================================================
FUNCTION CurataIdFactFortatDirect
	RETURN goExecutor.oExecuta([begin pack_contafin.nIdFactFortat := NULL; ] + ;
		[pack_contafin.nNractFortat := NULL; pack_contafin.cSerieFortata := NULL; end;])
ENDFUNC


*==============================================================================================
* Val1: o singura valoare numerica dintr-un select care aliaseaza coloana ca "v".
*==============================================================================================
FUNCTION Val1
	LPARAMETERS tcSql
	LOCAL lnRet
	lnRet = -1
	IF USED('v_val97')
		USE IN v_val97
	ENDIF
	IF goExecutor.oExecuta(tcSql, 'v_val97')
		SELECT v_val97
		IF RECCOUNT('v_val97') > 0
			GO TOP
			lnRet = NVL(v_val97.v, -1)
		ENDIF
		USE IN v_val97
	ELSE
		STRTOFILE('EROARE Val1: ' + goExecutor.cEroare + CHR(13) + CHR(10), gcErrLog, 1)
	ENDIF
	RETURN lnRet
ENDFUNC


PROCEDURE urma
	LPARAMETERS tcPas
	STRTOFILE('URMA ' + TTOC(DATETIME()) + '  ' + m.tcPas + CHR(13) + CHR(10), gcErrLog, 1)
ENDPROC


PROCEDURE asserteaza
	LPARAMETERS tcNume, tlConditie, tcValoare

	IF m.tlConditie
		gnPass = gnPass + 1
		STRTOFILE('PASS  ' + m.tcNume + CHR(13) + CHR(10), gcErrLog, 1)
	ELSE
		gnFail = gnFail + 1
		STRTOFILE('FAIL  ' + m.tcNume + ' (valoare: ' + TRANSFORM(m.tcValoare) + ')' + CHR(13) + CHR(10), gcErrLog, 1)
	ENDIF
ENDPROC


PROCEDURE test_error_handler
	LPARAMETERS tnError, tcMessage, tcProgram, tnLineNo

	STRTOFILE('EROARE ' + TRANSFORM(tnError) + ' [' + tcProgram + ':' + TRANSFORM(tnLineNo) + '] ' + tcMessage + CHR(13) + CHR(10), gcErrLog, 1)
ENDPROC