diff --git a/ab/ab2.cpp b/ab/ab2.cpp new file mode 100755 index 000000000..f2f767b29 --- /dev/null +++ b/ab/ab2.cpp @@ -0,0 +1,24 @@ +//AB2.CPP: Menù principale + +#include +#include +#include "ab2.h" //nome delle applicazione + +#define usage "Error - usage : %s -{0|1|2|3|4|5}" + +int main(int argc,char **argv) +{ + int n = (argc > 1) ? atoi(argv[1]+1) : -1; + + switch (n) + { + case 0: + ab2100(argc,argv); break; //Trasferimento e Ricezione +// case 1: +// ab2200(argc,argv); break; + default: + error_box(usage, argv[0]) ; + } + return 0; +} + diff --git a/ab/ab2.h b/ab/ab2.h new file mode 100755 index 000000000..5f4d2c9b3 --- /dev/null +++ b/ab/ab2.h @@ -0,0 +1,12 @@ +//AB2.H: Nome delle applicazioni + +#ifndef __AB2_H +#define __AB2_H + +int ab2100(int argc, char **argv); +int ab2101(int argc, char **argv); +int ab2102(int argc, char **argv); +//int ab2200(int argc, char **argv); + + +#endif //__AB2_H \ No newline at end of file diff --git a/ab/ab2100.cpp b/ab/ab2100.cpp new file mode 100755 index 000000000..8ac7de641 --- /dev/null +++ b/ab/ab2100.cpp @@ -0,0 +1,70 @@ +//AB2100.CPP: Ricezione-Trasferimetno tabelle +#include +#include +#include "ab2100a.h" +#include "ab2.h" +#include "ab2100.h" + + +bool TRiceTras::create() +{ + dispatch_e_menu(BAR_ITEM(1)); //Simula la scelta di una voce di menu + return TRUE; +} + +TFile_text* TRiceTras::set_config_name(TString &config, const TMask &msk, const TFilename &percorso) +{ + int tipo_ricezione = msk.get_int(F_TIPO_RICE); + switch (tipo_ricezione) + { + case 1: + { + config="ab2100a.ini"; + _trasfile = new TABfile_text(percorso, config); //Leggo il file di configurazione + return _trasfile; + } + case 2: + { + config="ab2100a.ini"; /*DA CAMBIARE*/ + _trasfile = new TFile_text(percorso, config); //Leggo il file di configurazione + return _trasfile; + } + case 3: + { + config=msk.get(F_PERCORSO_UTENTE); break; + _trasfile = new TFile_text(percorso, config); //Leggo il file di configurazione + return _trasfile; + } + } + return NULL; +} + +bool TRiceTras::destroy() //Distruttore +{ + return TRUE; +} + + +int ab2100(int argc, char **argv) +{ + char *rt = argv[2]+1; //Leggo se è richiesta la ricezine (r/R) o il trasferimento (t/T) + *rt=toupper(*rt); + + switch (*rt) + { + case 'R': //Ricezione + + { + ab2101(argc,argv); + break; + } + case 'T': //Trasferimento + { + ab2102(argc,argv); + break; + } + default: + error_box ("Sintassi: \n -0 -R - per ricezione \n -0 -T - per trasferimetno"); + } + return 0; +} \ No newline at end of file diff --git a/ab/ab2100.h b/ab/ab2100.h new file mode 100755 index 000000000..34f691760 --- /dev/null +++ b/ab/ab2100.h @@ -0,0 +1,116 @@ +//AB2100.H: Classe principale e definizione di costanti +#ifndef _AB2100_H + +#ifndef __FILETEXT_H +#include +#endif // __FILETEXT_H + +#ifndef __APPLICAT_H +#include //Definizione della classe TApplication +#endif //__APPLICAT_H + +#ifndef __MASK_H +#include //Definizione della maschera +#endif //__MASK_H + +#ifndef __URLDEFID_H +#include //Definizione di BAR_ITEM(1) +#endif //__URLDEFID_H + +#define ID_NULLO 0 + +#define MOVIMENTO1 "MOVI1" +#define MOVIMENTO2 "MOVI2" +#define MOVIMENTO3 "MOVI3" +#define MOVIMENTO4 "MOVI4" +#define MOVIMENTO5 "MOVI5" + +#define TIPO_TABELLA_PERIODI "TBBBD" +#define SIGLA_TABELLA_PERIODI "BB" + +#define TIPO_SRELAZ "STABI" +#define TIPO_VOCI "ATAB2" + +#define TIPO_VOCI "ATAB2" + +//Costanti di posizionamento nel record_text +#define SIGLA_TAB_PER 1 + +//Costanti di posizionamento nel record_text dei MOVIMENTI e DETTAGLI +#define CODICE_DITTA_MOVDETT 1 +#define ANNO_BILANCIO_MOVDETT 2 +#define CODICE_PERIODO_MOVDETT 3 +#define CODICE_TABELLA_MOVDETT 4 +#define CONTO_COGE_MOVDETT 5 +#define PROGRESSIVO_DETT_MOVDETT 6 +#define NUMERO_REG_MOVDETT 8 +#define NUMERO_RIGA_MOVDETT 9 +#define SALDO_INIZIO_ANNO_MOVDETT 13 +#define PROGRESSIVO_DARE_MOVDETT 14 +#define PROGRESSIVO_AVERE_MOVDETT 15 +#define RICLASSIFICAZIONE_DARE_MOVDETT 16 +#define RICLASSIFICAZIONE_AVERE_MOVDETT 17 +#define FLAG_DA_MOVDETT 17 +#define IMPORTO_MOVDETT 19 +#define FLAG_RICLASSIFICAZIONE_MOVDETT 21 +#define SALDO_INIZIO_ANNO_SLD_MOVDETT 9 +#define PROGRESSIVO_DARE_SLD_MOVDETT 10 +#define PROGRESSIVO_AVERE_SLD_MOVDETT 11 +#define RICLASSIFICAZIONE_DARE_SLD_MOVDETT 12 +#define RICLASSIFICAZIONE_AVERE_SLD_MOVDETT 13 + + + +//Costanti di posizionamento nel record_text per VOCI +#define TIPO_VOCE_VOCI 6 +#define NCA_VOCI 4 +#define CODVC_VOCI 1 +#define CODCOMP_ANA_VOCI 2 +#define DESCR1_VOCI 5 +#define DESCR2_VOCI 43 +#define VOCI_INCIDENZA 41 + +//Costanti di posizionamento nel record_text per SOTTORELAZIONI +#define CODAN_SOTTOREL 1 +#define CODVC_SOTTOREL 2 +#define NCOMP_SOTTOREL 3 +#define NSREL_SOTTOREL 5 + +//classe derivata nella quale viene gestita la funzione di trasferimento +class TRiceTras: public TApplication +{ + protected: + TFile_text* _trasfile; //File di testo + + public: + virtual bool create(); + virtual bool destroy(); + virtual bool menu(MENU_TAG) pure;//Gli dico che non è implementata in questa classe, ma obbligatoriamente in un'altra + //Seleziona da quale file prelevare le informazioni del tracciato record +// void set_config_name(TString&,TMask&); + TFile_text* set_config_name(TString&,const TMask&, const TFilename&); + TRiceTras() {} + virtual ~TRiceTras() {} +}; + +class TABfile_text: public TFile_text +{ + TAssoc_array _last_id; + static long _idcaradd; + long _idncomp; + long _idcoldich; + TString _codvc_prec; +protected: + // virtual void preformat_field(TRelation& rel,const TFieldref&field,const TRecord_text& rec,TString &str); + virtual void preformat_field(const TFieldref&field,TString &str,TRelation& rel,const TString &tipo_tr); + void cambia_anno(TString& str); + void cambia_data(TString& str); + virtual bool pre_writerel(TRelation& rel,const TRecord_text& rec); + void scrivi_temp_link(TRelation& rel,const TRecord_text& rec); +public: + TABfile_text(const char* file_name, const char* set_config_name); + virtual ~TABfile_text() {} +}; + + +#endif //_AB2100_H diff --git a/ab/ab2100a.h b/ab/ab2100a.h new file mode 100755 index 000000000..5f4b60b3b --- /dev/null +++ b/ab/ab2100a.h @@ -0,0 +1,22 @@ +//AB2100A.H: Campi della maschera +#ifndef __AB2100A_H +#define __AB2100A_H + +#define F_PERCORSO 200 +#define F_TESTO_PERCORSO 201 +#define F_TESTO_SELEZIONE 202 +#define F_PIANO_CONTI 203 +#define F_PERIODI_BILANCI 204 +#define F_ANALISI 205 +#define F_TIPO_RICE 206 +#define F_TESTO_UTENTE 207 +#define F_PERCORSO_UTENTE 208 +#define F_MOVIMENTI 209 +#define F_SALDI 210 +#define F_VOCI 211 +#define F_RELAZ 212 +#define F_SRELAZ 213 +#define F_TESTO_TIPOBIL 214 +#define F_TIPO_BILANCIO 215 + +#endif //__AB2100A_H \ No newline at end of file diff --git a/ab/ab2100a.uml b/ab/ab2100a.uml new file mode 100755 index 000000000..0cccac8d0 --- /dev/null +++ b/ab/ab2100a.uml @@ -0,0 +1,135 @@ +#include "ab2100a.h" +PAGE "" 0 -1 0 19 + +GROUPBOX DLG_NULL 76 5 +BEGIN + PROMPT 1 0 "" + FLAGS "R" +END + +TEXT F_TESTO_PERCORSO +BEGIN + PROMPT 2 1 "Percorso completo del file di testo:" +END + +STRING F_PERCORSO 80 70 +BEGIN + PROMPT 2 3 "" + FIELD PERCORSO + CHECKTYPE REQUIRED +END + +TEXT F_TESTO_SELEZIONE +BEGIN + PROMT 2 7 "Selezionare le tabelle:" +END + +LISTBOX F_TIPO_RICE 15 +BEGIN + PROMPT 2 5 "Tipo: " + ITEM "1|AS400" + MESSAGE DISABLE,F_PERCORSO_UTENTE|DISABLE,F_TESTO_UTENTE + ITEM "2|WINDOWS" + MESSAGE DISABLE,F_PERCORSO_UTENTE|DISABLE,F_TESTO_UTENTE + ITEM "3|USER DEFINED" + MESSAGE ENABLE,F_PERCORSO_UTENTE|DISABLE,F_TESTO_UTENTE +END + +TEXT F_TESTO_UTENTE +BEGIN + PROMPT 2 17 "Percorso completo del file di configurazione:" +END + +STRING F_PERCORSO_UTENTE 80 50 +BEGIN + PROMPT 2 18 "" + FIELD PERCORSO + CHECKTYPE REQUIRED +END + +TEXT F_TESTO_TIPOBIL +BEGIN + PROMPT 55 17 "Tipo bilancio" +END + +STRING F_TIPO_BILANCIO 2 2 +BEGIN + PROMPT 60 18 "" + FLAG "RU" + KEY 1 + USE %NTB KEY 1 + INPUT %NTB->CODTAB F_TIPO_BILANCIO + DISPLAY "Cod@5" %NTB->CODTAB + DISPLAY "Descrizione@40" %NTB->S0 + OUTPUT F_TIPO_BILANCIO %NTB->CODTAB + CHECKTYPE REQUIRED +END + +GROUPBOX DLG_NULL 76 10 +BEGIN + PROMPT 1 7 "" + FLAGS "R" +END + +BOOLEAN F_PIANO_CONTI +BEGIN + PROMPT 2 9 "Piano dei conti" +END + +BOOLEAN F_PERIODI_BILANCI +BEGIN + PROMPT 2 11 "Tabella periodi di bilanci" +END + +BOOLEAN F_ANALISI +BEGIN + PROMPT 2 13 "Tabella analisi di bilancio" +END + +BOOLEAN F_MOVIMENTI +BEGIN + PROMPT 2 15 "Movimenti" + MESSAGE TRUE ENABLE,F_TIPO_BILANCIO | COPY, F_SALDI +END + +BOOLEAN F_SALDI +BEGIN + PROMPT 40 9 "Saldi" + MESSAGE TRUE ENABLE,F_TIPO_BILANCIO + MESSAGE FALSE COPY, F_MOVIMENTI | DISABLE, F_TIPO_BILANCIO +END + +BOOLEAN F_VOCI +BEGIN + PROMPT 40 11 "Voci" + MESSAGE TRUE COPY, F_RELAZ | COPY, F_SRELAZ + MESSAGE FALSE COPY, F_RELAZ | COPY, F_SRELAZ +END + +BOOLEAN F_RELAZ +BEGIN + PROMTP 40 13 "Relazioni" + MESSAGE TRUE COPY, F_VOCI | COPY, F_SRELAZ + MESSAGE FALSE COPY, F_VOCI | COPY, F_SRELAZ +END + +BOOLENAN F_SRELAZ +BEGIN + PROMPT 40 15 "Sottorelazioni" + MESSAGE TRUE COPY, F_RELAZ | COPY, F_VOCI + MESSAGE FALSE COPY, F_RELAZ | COPY, F_VOCI +END + +BUTTON DLG_OK 10 2 +BEGIN + PROMPT 15 20 "" +END + +BUTTON DLG_QUIT 10 2 +BEGIN + PROMPT 50 20 "" +END + +ENDPAGE + +ENDMASK \ No newline at end of file diff --git a/ab/ab2101.cpp b/ab/ab2101.cpp new file mode 100755 index 000000000..103187fde --- /dev/null +++ b/ab/ab2101.cpp @@ -0,0 +1,984 @@ +//AB2101.CPP: Ricezione tabelle + +#include //Definizione di fexit +#include "movdett.h" //Contiene le definizioni di costanti relative ai nomi dei campi di LF_MOVDETT +#include "saldi.h" //Contiene le definizioni di costanti relative ai nomi dei campi di LF_SALDI +#include "voci.h" //Contiene le definizioni di costanti relative ai nomi dei cmapi di LF_VOCI +#include "relvoci.h" //Contiene le definizioni di costanti relative ai nomi dei cmapi di LF_RELVOCI +#include "relana.h" //Contiene le definizioni di costanti relative ai nomi dei cmapi di LF_RELANA +#include "caradd.h" //Contiene le definizioni di costanti relative ai nomi dei cmapi di LF_CARADD +#include "colldich.h" //Contiene le definizioni di costanti relative ai nomi dei cmapi di LF_COLLDICH +#include "ab2100.h" //Definizione della classe principale e di constanti che indicano l'indice nel file di configurazione +#include "ab2100a.h" //Campi della maschera +#include +#include + +#define FLAG_COGE '1' +#define FLAG_DETT '2' +#define FLAG_MOVIMENTO '3' // così i movs sono alla fine +#define FLAG_INDICE "I" +#define FLAG_SOTTOD "S" +#define FLAG_COMPOSTA "C" +#define FLAG_ANALISI "A" +#define FLAG_VOCI "V" +long TABfile_text::_idcaradd=1; //In questo modo questa variabile è visibile a tutti gli oggetti di questa classe +//Costruttore di TABfile_text: lo inizializzo a 0 +TABfile_text::TABfile_text(const char* file_name, const char* set_config_name) + : TFile_text(file_name, set_config_name),_idncomp(1),_idcoldich(1) +{ + TLocalisamfile f(LF_CARADD); + if (f.last()==NOERR) + _idcaradd=atol(f.get(ABCA_ID))+1; + else + _idcaradd=1; +} + +class TAlbero_record : public TAssoc_array +{ + static TToken_string wrk_string; +public: + void dept_first(TToken_string key, TRectype * padre, TRectype * prec, int &curr_id, TString_array & allkeys, TToken_string ** prog_key); + + TToken_string& cerca_fratello (TToken_string &key, TString_array& allkeys, TToken_string ** next_key); + TToken_string& cerca_figlio (TToken_string &key, TString_array& allkeys, TToken_string ** next_key); + TAlbero_record() {} + virtual ~TAlbero_record(){} +}; + +TToken_string TAlbero_record ::wrk_string; + +//Classe derivata per la ricezione +class TRicezione:public TRiceTras +{ + TString _tipo_bilancio; + protected: + virtual void leggi_temp_link(TRectype& cur_rec,TToken_string& k); + public: + void set_tipo_bil(const TString&); + const TString & get_tipo_bil() const {return _tipo_bilancio;} + virtual bool menu(MENU_TAG); + //Controlla che il percorso e il file specificati esistono + static bool inseriscipercorso(TMask_field& f, KEY k); + //Esegue il ciclo di ricezione + void ricevi(TMask &); + void build_balancetree(int); + void naviga_array(TAlbero_record &a); + void scrivi_array(TAssoc_array &s_rec, int); + void build_relana(TString&, const TMask&, const TFilename&); + void build_ana_tree(long&, TRectype&, TRectype*, TRectype*, TAssoc_array&); + TRicezione() {} + virtual ~TRicezione() {} +}; + +inline TRicezione& app() +{ + return (TRicezione&) main_app(); +} + +void TABfile_text::cambia_anno(TString& str) +{ + if (atoi(str)>0) + { + if (str > "50") //Trasformo dal formato aa al formato aaaa + str.insert("19"); + else + str.insert("20"); + } +} + +void TABfile_text::cambia_data(TString &str) +{ + if (atoi(str)>0) + { + int aa= atoi(str.left(2)); + int mm= atoi(str.mid(2,2)); + int gg= atoi(str.right(2)); + + if (aa > 50) + aa=aa+1900; + else + aa=aa+2000; + + TDate data(gg,mm,aa); + str=data.string(); + } +} + +//Questa funzione esegue la conversione dell'anno dal formato aa al formato aaaa +//void TABfile_text::preformat_field(TRelation& rel,const TFieldref&field,const TRecord_text& rec,TString &str) +void TABfile_text::preformat_field(const TFieldref& field, TString &str,TRelation& rel,const TString &tipo_tr) +{ + if (field.file()==LF_MOVDETT) + {//Parte riservata ai MOVIMENTI/DETTAGLI + if (field.name()==ABMD_ANNO) + cambia_anno(str); //formatto l'anno: aa --> aaaa + + if (field.name()==ABMD_DREG || field.name()==ABMD_DDOC) + cambia_data(str); //formatta la data aammgg --> aaaammgg + }//Fine MOVIMENTI/DETTAGLI + + if (field.file()==LF_ABSALDI) + {//Parte riservata ai SALDI + if (field.name()==ABMD_ANNO) //formatto l'anno: aa ---> aaaa + cambia_anno(str); + }//Fine parte riservata ai SALDI + + if (field.file()==LF_VOCI) + {//Va cambiato il TIPOVC da S a C, tutti gli altri casi rimangono inalterati + if((field.name()==ABVC_TIPOVC) && (str == FLAG_SOTTOD)) + str = FLAG_COMPOSTA; + } + if (field.file()==LF_RELVOCI) + { + if((field.name()==ABRL_CODCOMP)) + {//Lo accorcio di 5 caratteri + str.ltrim(5); + } + } +} + +//Assegno valori temporanei a IDPADRE, IDFIGLIO, IDSUCC, IDPREC +void TABfile_text::scrivi_temp_link(TRelation& rel,const TRecord_text& rec) +{ + if ((rec.type() == MOVIMENTO3) || (rec.type() == MOVIMENTO4) || (rec.type() == MOVIMENTO5)) + { + real r(rec.get(PROGRESSIVO_DETT_MOVDETT));//Eseguo una conversione per un controllo numerico + if (r > 0) //E' un PROGRESSIVO DETTAGLIO + { + TString16 str1,str2; + str1 << FLAG_DETT << rec.get(PROGRESSIVO_DETT_MOVDETT).left(5); + rel.lfile().put(ABMD_IDPADRE,str1); + str2 << rec.get(PROGRESSIVO_DETT_MOVDETT).right(5); + rel.lfile().put(ABMD_IDFIGLIO,str2); + rel.lfile().put(ABMD_IDSUCC,0); //Assegno il numero di registrazione 0 + rel.lfile().put(ABMD_IDPREC,0); //Assegno il numero di riga 0 + } + else //E' un COGE + { + TString16 str1,str2; + str1 << FLAG_COGE << rec.get(CONTO_COGE_MOVDETT).left(5); + rel.lfile().put(ABMD_IDPADRE,str1); + str2 << rec.get(CONTO_COGE_MOVDETT).right(5); + rel.lfile().put(ABMD_IDFIGLIO,str2); + rel.lfile().put(ABMD_IDSUCC,0); //Assegno il numero di registrazione 0 + rel.lfile().put(ABMD_IDPREC,0); //Assegno il numero di riga 0 + } + } + else + { //E' un movimento: tipo_rec =movi1 o movi2 + TString16 str1,str2; + //Se è un movimento di progressivo + real r(rec.get(PROGRESSIVO_DETT_MOVDETT)); //Eseguo una conversione per un controllo numerico + if (r > 0) + { + str1 << FLAG_MOVIMENTO << rec.get(PROGRESSIVO_DETT_MOVDETT).left(5); + str2 << rec.get(PROGRESSIVO_DETT_MOVDETT).right(5); + } + else //... è un movimento di un saldo o di un coge + { + real r(rec.get(CONTO_COGE_MOVDETT)); //Eseguo una conversione per un controllo numerico + if (r > 0) + { + str1 << FLAG_MOVIMENTO << rec.get(CONTO_COGE_MOVDETT).left(5); + str2 << rec.get(CONTO_COGE_MOVDETT).right(5); + } + else + { //C'è scritto la stessa cosa dell'if, in reltà CONTO_COGE contiene solo zeri + //e mi serve per riempire correttamente str1 che deve essere del tipo FCCCCC dove + //F è il flag_movimento e C è la prima parte del CONTO_COGE: se non avessi messo + //così str1 sarebbe stata del tipo F + str1 << FLAG_MOVIMENTO << rec.get(CONTO_COGE_MOVDETT).left(5); + str2 << rec.get(CONTO_COGE_MOVDETT).right(5); + } + } + + rel.lfile().put(ABMD_IDPADRE,str1); + rel.lfile().put(ABMD_IDFIGLIO,str2); + rel.lfile().put(ABMD_IDSUCC,rec.get(NUMERO_REG_MOVDETT)); //Assegno il numero di registrazione + rel.lfile().put(ABMD_IDPREC,rec.get(NUMERO_RIGA_MOVDETT)); //Assegno il numero di riga + } +} + + +bool TABfile_text::pre_writerel(TRelation& rel,const TRecord_text& rec) +{ + int logic_num=rel.lfile().num(); //Carico il numero logico del file che sto utilizzando + + if (logic_num==LF_ABSALDI) + {//Parte riservata ai SALDI + rel.lfile().put(ABMD_TIPOBIL,app().get_tipo_bil()); + return TRUE; + }//Fine parte riservata ai SALDI + + + if (logic_num==LF_MOVDETT) + { //Parte riservata ai DETTAGLI e MOVIMENTI + //Inserisco nel file isam tutti i dati che mi servono + //per la costruzione dell'albero. + //Si divide in 3 parti. + + //PARTE 1: Assegno degli id temporanei + TString id = "1"; + + //Costruisco un chiave composta con i vari campi letti che interessano + TToken_string key; + key.add(rec.get(CODICE_DITTA_MOVDETT)); + key.add(rec.get(ANNO_BILANCIO_MOVDETT)); + key.add(rec.get(CODICE_PERIODO_MOVDETT)); + key.add(rec.get(CODICE_TABELLA_MOVDETT)); + + //Controllo che esiste nell'assoc_array un elemento con chiave uguale a quella appena generata + //se esiste last_id contiene l'ultimo indice associato a quella chiave + TString *last_id=(TString*)_last_id.objptr(key); + if (last_id) + { + long val=atol(*last_id); //Se esiste incremento l'indice + val++; + id.format("%ld",val); + } + _last_id.add(key,id,TRUE); //se esiste già una chiave giusta, sovrascrivo l'indice aggiornato + //se non esiste creo la nuova chiave con indice 1 + + rel.lfile().put(ABMD_ID,id); //scrivo sulla relazione assegnando a ABMD_ID l'indice calcolato + //FINE PARTE 1 + + + //PARTE 2: inserisco il TIPODETT, TIPOBIL e evenutalmente CODDETT + if ((rec.type() == MOVIMENTO3) || (rec.type() == MOVIMENTO4) || (rec.type() == MOVIMENTO5)) + { //E' di tipo "dettaglio" o "conto contabile": non può essere "movimento" + real r(rec.get(CONTO_COGE_MOVDETT)); //Eseguo una conversione per un controllo numerico + if (r > 0) + {//E' un COGE e quindi inserisco anche il Coddett + rel.lfile().put(ABMD_TIPODETT,"CG"); + rel.lfile().put(ABMD_CODDETT,rec.get(CONTO_COGE_MOVDETT)); + rel.lfile().put(ABMD_TIPOBIL,app().get_tipo_bil()); + } + else + {//In questo caso inserisco Coddett = 0 per azzerare eventuali altri valori + //già scritti precedentemente + rel.lfile().put(ABMD_TIPODETT,"DT"); + rel.lfile().put(ABMD_CODDETT,0); + rel.lfile().put(ABMD_TIPOBIL,app().get_tipo_bil()); + } + } + else + {//Può essere solo un "movimento" perchè il tipo record è MOVI1 o MOVI2 + rel.lfile().put(ABMD_TIPODETT,"MO"); + rel.lfile().put(ABMD_TIPOBIL,app().get_tipo_bil()); + rel.lfile().put(ABMD_CODDETT,0); //Azzero il contenuto del campo da valori precedenti + real r(rec.get(CONTO_COGE_MOVDETT)); //Eseguo una conversione per un controllo numerico + if (r > 0) + {//E' un movimento di un COGE e quindi devo scrivere anche CODDETT + rel.lfile().put(ABMD_CODDETT,rec.get(CONTO_COGE_MOVDETT)); + } + }//FINE PARTE 2 + + //PARTE 3. Nel caso in cui il record sia un movimento, devo gestire diversamente il saldo: + //Se il flag di riclassificazione è attivato, l'importo del movimento va scritto in RDARE o RAVERE + //a seconda del flag D/A + //Se il flag di riclassificazione non è ativato + // l'importo va inserito nel saldo (e settato il flag D/A) se il record è MOVI1 + // l'importo va inserito in PDARE o PAVERE a seconda del flag D/A + + + if (rec.type() == MOVIMENTO1 || rec.type() == MOVIMENTO2) + { + if (rec.get(FLAG_RICLASSIFICAZIONE_MOVDETT) == "X") + {//L'importo va comunque in RDARE o RAVERE + if (rec.get(FLAG_DA_MOVDETT) == "D") + rel.lfile().put(ABMD_RDARE,rec.get(IMPORTO_MOVDETT)); + else + rel.lfile().put(ABMD_RAVERE,rec.get(IMPORTO_MOVDETT)); + } + else + {//L'importo va nel campo IMPORTO se MOVIMENTO1 + if (rec.type() == MOVIMENTO1) + { + rel.lfile().put(ABMD_IMPORTO,rec.get(IMPORTO_MOVDETT)); + rel.lfile().put(ABMD_FLDA,rec.get(FLAG_DA_MOVDETT)); + } + else + {// ... oppure in PDARE o PAVERE se MOVI2 + if (rec.get(FLAG_DA_MOVDETT) == "D") + rel.lfile().put(ABMD_PDARE,rec.get(IMPORTO_MOVDETT)); + else + rel.lfile().put(ABMD_PAVERE,rec.get(IMPORTO_MOVDETT)); + } + } + }//FINE PARTE 3 + + //PARTE 4 + scrivi_temp_link(rel,rec); + //FINE PARTE 4 + return TRUE; + }//Fine parte riservata ai DETTAGLI e MOVIMENTI + + if (logic_num==LF_VOCI) + {//Parte riservata alle voci + bool write_rec=TRUE; + if ((rec.get(TIPO_VOCE_VOCI) != FLAG_INDICE) ) + {//Scrivo la chiave anche sul file secondario della relazione + long idcaradd_ra=ID_NULLO; + rel.lfile(LF_CARADD).put(ABCA_ID,_idcaradd); + TLocalisamfile fil(LF_VOCI); + fil.curr()=rel.curr(); + if (fil.read() != NOERR) + { + // Voce non ancora inserita; la caradd diventa il default + rel.lfile().put(ABVC_IDCARADD,_idcaradd); + _idcaradd++; + //long prova = atol(rec.get(NCA_VOCI)); + } else { + // non scrivero' la voce + write_rec=FALSE; + // cerco il default + TLocalisamfile caradd(LF_CARADD); + caradd.put(ABCA_ID,rel.lfile().get(ABVC_IDCARADD)); + caradd.read(); + caradd.put(ABCA_ID,_idcaradd); + if (rel.lfile(LF_CARADD).curr()!=caradd.curr()) + { + // diverso dal default: va scritto in relana + idcaradd_ra=_idcaradd; + rel.lfile(LF_CARADD).put(ABCA_ID,idcaradd_ra); + rel.lfile(LF_CARADD).write(); + _idcaradd++; + } + } + if (atol(rec.get(NCA_VOCI)) > 0) + {//Aggiorno anche radici: inserisco solo le "voci" di primo livello + //e sono le tabelle di analisi, cioè le radici dell'albero + //Aggiorno RELVOCI + TLocalisamfile & relvoc=rel.lfile(LF_RELVOCI); + + relvoc.put(ABRL_TIPOCOD,FLAG_ANALISI); //Analisi di bilancio + // >>>relvoc.put(ABRL_CODVC,rec.get(CODVC_VOCI)); //Codice della tabella di analisi + // >>>relvoc.put(ABRL_NCOMP,atol(rec.get(NCA_VOCI))); //Id progressivo della tabella di analisi + relvoc.put(ABRL_CODCOMP,rel.lfile().get(ABVC_CODVC)); + relvoc.write(); //Scrivo effettivamente sull'isamfile + + //Aggiorno RELANA + TLocalisamfile &ran=rel.lfile(LF_RELANA); + + ran.put(ABRA_CODAN,relvoc.get(ABRL_CODVC)); + ran.put(ABRA_ID,relvoc.get(ABRL_NCOMP)); //Assegno questo "ID" provvisorio per poterlo rintracciare dopo + ran.put(ABRA_DESCRIZ,rel.lfile().get(ABVC_DESCR)); + ran.put(ABRA_TIPOCOD,FLAG_ANALISI); + ran.put(ABRA_CODVC,relvoc.get(ABRL_CODVC)); + ran.put(ABRA_NCOMP,relvoc.get(ABRL_NCOMP)); + //>>>ran.put(ABRA_VOCEINCID,voceincid.right_just(12,'0')); + ran.put(ABRA_IDCARADD,idcaradd_ra); + ran.put(ABRA_USACARADD,idcaradd_ra==ID_NULLO ? FALSE : TRUE); + ran.write(); + + //Aggiorno il collegamento a dichiarazione + //TLocalisamfile col(LF_COLLDICH); + //col.put(ABCD_ID,_idcoldich); //e alla relazione secondaria + //_idcoldich++; + } + } else + // tipo di voce non più supportata + write_rec=FALSE; + return write_rec; + }//Fine parte riservata alle voci + + if (logic_num==LF_RELVOCI) + {//Parte riservata alle relazioni + rel.lfile().put(ABRL_TIPOCOD,FLAG_VOCI); + return TRUE; + }//Fine parte riservata alle relaizioni + + if (logic_num==LF_RELANA) + {//Parte riservata a SOTTORELAZIONI e COLLEGAMENTO A DICHIARAZIONE + rel.lfile().put(ABRA_IDCOLDICH,_idcoldich); //Assegno l'ID del collegamento alla relazione principale + rel.lfile(LF_COLLDICH).put(ABCD_ID,_idcoldich); //e alla relazione secondaria + _idcoldich++; + + //Parte riservata a SOTTORELAZIONI e CARATTERISTICHE ADDIZIONALI + TString codice_voce=rel.lfile().get(ABRA_CODVC);//Estraggo da RELANA il codice di ricerca su VOCI + codice_voce.ltrim(2); //e la formatto + + TLocalisamfile voc(LF_VOCI); //gatto + voc.put(ABVC_CODVC,codice_voce); + if (voc.read() == NOERR) + {//Ho trovato la voce + TRelation rela(LF_RELANA); + rela.add(LF_CARADD,"ID=IDCARADD"); + rela.lfile().put(ABRA_CODAN,rec.get(CODAN_SOTTOREL)); + rela.lfile().put(ABRA_ID,voc.get(ABVC_IDCARADD)); + if (rela.read() == NOERR) + {//Ho trovato le caratteristiche addizionali di default della voce + rel.lfile(LF_CARADD).put(ABCA_ID,rela.lfile(LF_CARADD).get(ABCA_ID)); + if (rel.lfile(LF_CARADD).curr()==rela.lfile(LF_CARADD).curr()) + return TRUE; //Se sono uguali (ho già inserito l'ID corretto) sovrascrivo le caradd + } + } + //Non ho trovato la VOCE o CARATTERISTICA ADDIZIONALE oppure è diversa + //l'ID è già stato incrementato in precedenza + rel.lfile().put(ABRA_IDCARADD,_idcaradd); //Aggiungo il collegamento alla carat. add. + rel.lfile().put(ABRA_USACARADD,"X"); //Setto il flag + rel.lfile(LF_CARADD).put(ABCA_ID,_idcaradd); + _idcaradd++; + return TRUE; + } + return TRUE; +} + +//Handler per controllare la validita' del campo F_PERCORSO +bool TRicezione::inseriscipercorso(TMask_field& f, KEY k) +{ + if (f.to_check(k)) + { + TString percorso; + bool esiste; + percorso=f.get(); //Leggo il contenuto del campo + esiste = fexist(percorso); //Controllo l'esistenza del file + if (esiste==FALSE) + return error_box("Il percorso o il file specificato non esiste."); + } + return TRUE; +} + + +void TRicezione::ricevi(TMask & msk) +{ + TRecord_text rec; //Istanzio un tipo record_text + + //Ciclo di lettura-scrittura fino a quando la lettura è possibile + while (_trasfile->ok_r()) + { + if(_trasfile->read(rec) == NOERR) + { + if (msk.get_bool(F_PIANO_CONTI)) //Controllo se si è scelto di convertire il piano dei conti + { + _trasfile->autosave(LF_ABPCON,rec); + } + if (msk.get_bool(F_PERIODI_BILANCI)) //Scelta di convertire la tabella periodi bilanci + { + _trasfile->autosave(LF_TABCOM,rec); + } + if (msk.get_bool(F_ANALISI)) //scelta di cnverite la tabella tipi analisi di bilancio + { + _trasfile->autosave(LF_ANALISI,rec); + } + if (msk.get_bool(F_MOVIMENTI)) //scelta di cnverite la tabella tipi analisi di bilancio + { + _trasfile->autosave(LF_MOVDETT,rec); + } + if (msk.get_bool(F_SALDI)) //scelta di cnverite la tabella tipi analisi di bilancio + { + _trasfile->autosave(LF_ABSALDI,rec); + } + if (msk.get_bool(F_VOCI)) + { + _trasfile->autosave(LF_VOCI,rec); + } + if (msk.get_bool(F_RELAZ)) + { + _trasfile->autosave(LF_RELVOCI,rec); + } + } + } + //Finita prima fase di aggionamento, si passa eventualmente alla seconda +} + +// prepara l'albero di record per la navigazione e lo naviga +void TRicezione::naviga_array(TAlbero_record &a) +{ + int curr_id=1; + TString_array allkeys; + a.get_keys(allkeys); + allkeys.sort(); + TToken_string radice,*next_key; + radice=(TToken_string &)*allkeys.first_item();// radice + next_key=(TToken_string *)allkeys.succ_item();// chiave seguente (figlio? fratello?) + + a.dept_first(radice, NULL,NULL, curr_id,allkeys,&next_key); +} + +// visita in dept first e aggiunge man mano i link corretti ai nodi +void TAlbero_record::dept_first(TToken_string key, TRectype * padre, TRectype * prec, int &curr_id, + TString_array & allkeys, TToken_string ** prog_key) // param . per ricerche COGE +{ + TRectype * myself=(TRectype * )objptr(key); + // ********* + // insert this node + myself->put(ABMD_ID,curr_id); + myself->put(ABMD_IDPADRE,padre ? padre->get(ABMD_ID):ID_NULLO); + myself->put(ABMD_IDFIGLIO,ID_NULLO); + myself->put(ABMD_IDPREC,prec ? prec->get(ABMD_ID) : ID_NULLO); + myself->put(ABMD_IDSUCC,ID_NULLO); + if (prec==NULL) // il primo figlio aggiorna il tipodett del padre + if (padre) + { + padre->put(ABMD_DETTFIGLIO,myself->get(ABMD_TIPODETT)); + } + else + { // il padre è un saldo + TLocalisamfile rel(LF_ABSALDI); //Creo un nuova relazione + //compongo la chiave che mi interessa + rel.put(ABS_CODDITTA,myself->get(ABMD_CODDITTA)); + rel.put(ABS_ANNO,myself->get(ABMD_ANNO)); + rel.put(ABS_CODPDB,myself->get(ABMD_CODPDB)); + rel.put(ABS_TIPOBIL,myself->get(ABMD_TIPOBIL)); + rel.put(ABS_CODCBL,myself->get(ABMD_CODCBL)); + //ricerco la chiave + if (rel.read()==NOERR) + {//se esiste aggiorno il campo + rel.put(ABS_DETTFIGLIO,myself->get(ABMD_TIPODETT)); + rel.rewrite(); + } + else + {// ... questa situazione non dovrebbe accadere: se succede si è verificata una + //inconsistenza nei dati + fatal_box("Si è verificato una inconsistenza nei dati: \n controllare che tutti i movimenti abbiano il relativo saldo"); + } + } + TToken_string key_figlio, key_fratello; + // ********* + // scende sul figlio + key_figlio=cerca_figlio(key,allkeys,prog_key); + if (key_figlio.not_empty()) // esiste il figlio + { + curr_id++; + myself->put(ABMD_IDFIGLIO,curr_id); + + dept_first(key_figlio, myself, NULL ,curr_id, allkeys, prog_key); + } + // ********* + // passa al fratello + + key_fratello=cerca_fratello(key,allkeys,prog_key); + if (key_fratello.not_empty()) // esiste il fratello + { + curr_id++; + myself->put(ABMD_IDSUCC,curr_id); + dept_first(key_fratello, padre, myself ,curr_id, allkeys, prog_key); + } +} + +//key is: FLAG|CODDETT|NREG|NRIG +TToken_string& TAlbero_record ::cerca_figlio (TToken_string &key, + TString_array& allkeys, // parametri ricerca COGE + TToken_string ** next_key + ) +{ + + TString cod_dett(key.get(1)); + wrk_string.cut(0); + if (*key.get(0)==FLAG_COGE) + { + // sono un COGE? il figlio può essere un mov o un COGE + // cerco un MOV + wrk_string.cut(0); + wrk_string.add(FLAG_MOVIMENTO); + wrk_string.add(cod_dett); + wrk_string.add("0"); + wrk_string.add("1"); + if (!is_key(wrk_string)) + { + // il mov non c'è, cerco un COGE + wrk_string.cut(0); + TString cod_grp(cod_dett.left(2)), + cod_con(cod_dett.mid(2,4)), + cod_scon(cod_dett.right(4)); + + if (atoi(cod_scon) > 0) // sono all'ultimo livello + return wrk_string; + + if (*next_key) + { + TString cod_dett_succ=(*next_key)->get(1); + if (atoi(cod_con) > 0) + { + // il figlio di un conto è un sottoconto e ha lo stesso gruppo/conto + if (cod_dett_succ.left(2)!=cod_grp ||cod_dett_succ.mid(2,4)!=cod_con) + return wrk_string; + } else { + // il figlio di un gruppo è un conto e ha lo stesso gruppo + if (cod_dett_succ.left(2)!=cod_grp) + return wrk_string; + } + wrk_string.add(FLAG_COGE); + wrk_string.add(cod_dett_succ); + wrk_string.add("0"); + wrk_string.add("0"); + *next_key=(TToken_string *)allkeys.succ_item(); + } + } + } + else if (*key.get(0)==FLAG_DETT) + { + // sono un dettaglio immesso + // il figlio può solo essere un mov + wrk_string.add(FLAG_MOVIMENTO); + wrk_string.add(cod_dett); + wrk_string.add("0"); + wrk_string.add("1"); + } + // else ... sono un movimento? non ho figli! + else + return wrk_string; + + if (!is_key(wrk_string)) + wrk_string.cut(0); + return wrk_string; +} + +//key is: FLAG|CODDETT|NREG|NRIG +TToken_string& TAlbero_record ::cerca_fratello (TToken_string &key, + TString_array& allkeys, // parametri ricerca COGE + TToken_string ** next_key + ) +{ + TString cod_dett(key.get(1)); + wrk_string.cut(0); + if (*key.get(0)==FLAG_COGE) + { + // sono un COGE? + // cerco la chiave successiva + + TString cod_grp(cod_dett.left(2)), + cod_con(cod_dett.mid(2,4)), + cod_scon(cod_dett.right(4)); + + if (*next_key) + { + TString cod_dett_succ=(*next_key)->get(1); + if (atoi(cod_scon) > 0) + { + // fratello di un sottoconto + if (cod_dett_succ.left(2)!=cod_grp ||cod_dett_succ.mid(2,4)!=cod_con) + return wrk_string; + } + else if (atoi(cod_con) > 0) + { + // fratello di un conto + if (cod_dett_succ.left(2)!=cod_grp) + return wrk_string; + } else { + // fratello di un gruppo + if (*(*next_key)->get(0)!=FLAG_COGE) + return wrk_string; + } + wrk_string.add(FLAG_COGE); + wrk_string.add(cod_dett_succ); + wrk_string.add("0"); + wrk_string.add("0"); + *next_key=(TToken_string *)allkeys.succ_item(); + } + } + else if (*key.get(0)==FLAG_DETT) + { + real r(cod_dett); //Eseguo una conversione per una operazione numerica + TString cod_dett_succ=(r+1).string(); + + cod_dett_succ.right_just(10,'0'); + // sono un dettaglio immesso + wrk_string.add(FLAG_DETT); + wrk_string.add(cod_dett_succ); + wrk_string.add("0"); + wrk_string.add("0"); + } + else + { + // sono un movimento + TString nrig(key.get(3)); + nrig.format("%d",atoi(nrig)+1); + wrk_string.add(FLAG_MOVIMENTO); + wrk_string.add(cod_dett); + wrk_string.add(key.get(2)); + wrk_string.add(nrig); + } + if (!is_key(wrk_string)) + wrk_string.cut(0); + return wrk_string; +} + +void TRicezione::scrivi_array(TAssoc_array &s_rec, int logic_num) +{ + + TRectype *rec; //Creo un tipo di record dove inserire il record + int i=s_rec.items(); + TRelation *rel=_trasfile->t_rec(logic_num)->relation(); + + rec=(TRectype*)s_rec.first_item(); //Metto il primo record dell'assoc_array in un tipo_record + for (i=0; i < s_rec.items(); i++) + { + rel->curr()=*rec; //Metto sul record corrente della relazione il record letto + int err = rel->rewrite(); //Scrivo sulla relazione + //non dovrebbe mai succedere + if (err != NOERR) + { + message_box("Si è verificato un errore nella costruzione dell'albero"); + err = rel->write(); + } + rec=(TRectype*)s_rec.succ_item(); + } +} + +void TRicezione::leggi_temp_link(TRectype& cur_rec,TToken_string& k) +{ + TString campo1 = cur_rec.get(ABMD_IDPADRE); + TString campo2 = cur_rec.get(ABMD_IDFIGLIO); + + k.add(campo1.left(1)); + campo1=campo1.ltrim(1); + campo2.right_just(5,'0'); + campo1 = campo1 << campo2; + k.add(campo1); + k.add(atol(cur_rec.get(ABMD_IDSUCC))); + k.add(atol(cur_rec.get(ABMD_IDPREC))); +} + + +void TRicezione::build_balancetree(int logic_num) +{ + TAlbero_record seleziona_record; //Dichiarazione di un assoc_array + TRelation rel(logic_num); //Creo un nuova relazione + TRectype prev_rec(logic_num); //Creo un tipo di record temporaneo dove inserire il record precedente + TRectype& cur_rec =rel.lfile().curr(); //Creo un tipo di record dove inserire il record attuale + + for (int err = rel.first(); err == NOERR; err = rel.next()) + { + if (cur_rec.compare_key(prev_rec,1,1) != 0) //Confronto la chiave precedente con quella appena letta escludendo + //l'ultimo campo della chiave + {//La chiave è diversa, quindi l'assoc array è completo + + if (seleziona_record.items() > 0) + { + naviga_array(seleziona_record); //Aggiorno gli indici + scrivi_array(seleziona_record,logic_num); //e riscrivo tutto sul file isam + } + seleziona_record.destroy(); //Vuoto completamente l'array + prev_rec = cur_rec; //Aggiorno il record precedente + } + //Se arriva qui, significa che ho trovato una chiave uguale e deve essere inserita nell'array + + //Questa parte ricostruisce la chiave originaria + TToken_string k; //Chiave dell'assoc_array + + leggi_temp_link(cur_rec,k); + //La chiave è stata ricostruita + + cur_rec.put(ABMD_IDPADRE,0); //Azzero i campi da riscrivere + cur_rec.put(ABMD_IDFIGLIO,0); + cur_rec.put(ABMD_IDSUCC,0); + cur_rec.put(ABMD_IDPREC,0); + + //Aggiorno l'assoc_array con la chiave corretta + seleziona_record.add(k,cur_rec); + } + if (seleziona_record.items() > 0) + { + //Queste due servono per l'ultima tipo di chiave letta + naviga_array(seleziona_record); + scrivi_array(seleziona_record,logic_num); + } +} + +void TRicezione::build_relana(TString& config_file, const TMask &msk, const TFilename& percorso) +{ + TString16 curr_ana; + TToken_string key; + TLocalisamfile radici(LF_RELVOCI); + TRelation rel(LF_RELANA); + TAssoc_array tabtree; + TRecord_text rec; //Creo un record text + TFile_text *ft; //Dichiaro un nuovo file_text + rel.add(LF_COLLDICH,"ID=IDCOLDICH"); + rel.add(LF_CARADD,"ID=IDCARADD"); + rel.write_enable(); + ft = set_config_name(config_file,msk,percorso); + ft->open('r'); //Apro il file di testo in lettura + + //Inizia il ciclo sulle Analisi in radici + if (radici.first() != NOERR) //Mi posiziono sul primo record di LF_RELVOCI + return; //e controllo che i dati siano "corretti" + CHECK(radici.get(ABRL_TIPOCOD)==FLAG_ANALISI, "Ci sono voci ma non tabelle ???"); + + //Posiziona la lettura sul file di testo + do + { + ft->read(rec); + } while (rec.type() != TIPO_SRELAZ); + //Aggiorno il tipo di analisi corrente + curr_ana = radici.get(ABRL_CODVC); + do + { + tabtree.destroy(); //Azzero l'assoc_array + long currid=1; + build_ana_tree(currid,radici.curr(),NULL,NULL,tabtree); // costruisce l'albero in memoria + + // legge dal file di testo e completa i record in tabtree + do + { + // chiave per l'assoc array + key.cut(0); + key.add(FLAG_VOCI); + key.add(rec.get(CODVC_SOTTOREL)); + + real k1(rec.get(NCOMP_SOTTOREL)); + key.add(k1.string()); + + real k2(rec.get(NSREL_SOTTOREL)); + key.add(k2.string()); + // rintraccia il record sull'assoc array + rel.lfile().curr() = (TRectype & )tabtree[key]; + //Aggiorno il TIPOCOD: non può essere fatto in PRE_WRITE perchè può assumere valori diversi + rel.lfile().put(ABRA_TIPOCOD,FLAG_VOCI); + // modifica e scarica il record + ft->autosave(rel,rec); //La relazione principale è basata su RELANA + tabtree.remove(key); + } while ((ft->read(rec) == NOERR) && (rec.type() == TIPO_SRELAZ)); + + //A questo punto ho scritto sull'isamfile tutte le voci: ora devo + //scrivere le analisi + tabtree.restart(); + for (int i=tabtree.items(); i > 0 ; i--) + { + THash_object *obj; + obj=tabtree.get_hashobj(); //Ritorna il primo elemento dell'assoc_array completo di chiave + TToken_string key = obj->key(); //Estraggo la chiave dell'oggetto estratto dall'assoc_array + rel.lfile().write((TRectype&)obj->obj()); //Aggiorno il file isam + tabtree.remove(key); //Tolgo il record dall'assoc_array + } + + // passa alla prossima Analisi + while (radici.next() == NOERR && curr_ana == radici.get(ABRL_CODVC)); + + //Aggiorno il tipo di analisi corrente + curr_ana = radici.get(ABRL_CODVC); + + //Riposiziono la lettura sul testo + do + { + ft->read(rec); + } while ((rec.type() != TIPO_SRELAZ) && rec.get(CODVC_VOCI) == curr_ana); + + } while (radici.get(ABRL_TIPOCOD)=="A"); +} + + +// naviga per ricostruire il numero di sottorelazione +void TRicezione::build_ana_tree(long &currid, TRectype & nodo, TRectype * father, TRectype * brother, TAssoc_array & tabtree) +{ + TRectype *ana_node; + TToken_string key; + //TString16 curr_ana = nodo.get(RELVOCI_CODANA); //S Non so dove venga usata + // calcola il numero di sottorelazione + int c=1; + do { + key.add(nodo.get(ABRL_TIPOCOD)); + key.add(nodo.get(ABRL_CODVC)); + key.add(nodo.get(ABRL_NCOMP)); + key.add(c); + c++; + } while (tabtree.objptr(key)!=NULL); + + ana_node = new TRectype(LF_RELANA); + //ana_node->zero(' '); //Solo per vederlo a livello di debug + + // setta il nodo + if (father == NULL) + {//Sono la radice principale e leggo i dati già inseriti con la vecchia chiave + TLocalisamfile rela(LF_RELANA); + + rela.put(ABRA_CODAN,key.get(1)); + TString16 old_id = key.get(); + rela.put(ABRA_ID,atol(old_id)); + if (rela.read() == NOERR) //Leggo i dati inseriti precedentemente + { + *ana_node=rela.curr(); + rela.remove(); //E li elimino dal file_isam per aggiornare la chiave + } + else + CHECK (FALSE,"Errore di consistenza nei dati"); + } + //Aggiorno la chiave + ana_node->put(ABRA_ID, currid); + ana_node->put(ABRA_IDPADRE, father ? father->get(ABRA_ID) : ID_NULLO); + ana_node->put(ABRA_IDPREC, brother ? brother->get(ABRA_ID) : ID_NULLO); + tabtree.add(key,ana_node); + + // passa al figlio leggendo su RELVOCI se esso esiste + TLocalisamfile relvoci(LF_RELVOCI); + relvoci.put(ABRL_TIPOCOD,'V'); //Deve essere una voce + relvoci.put(ABRL_CODVC,nodo.get(ABRL_CODCOMP));//Prendo il codice del mio figlio + relvoci.put(ABRL_NCOMP,1); //Prendo la prima istanza + if (relvoci.read()==NOERR) + { + currid++; + ana_node->put(ABRA_IDFIGLIO, currid); + build_ana_tree(currid,relvoci.curr(),ana_node,NULL,tabtree); //Richiamo questa funzione + } + else + ana_node->put(ABRA_IDFIGLIO, ID_NULLO); + + // passa al fratello + relvoci.curr().zero(); + relvoci.put(ABRL_TIPOCOD,nodo.get(ABRL_TIPOCOD)); + relvoci.put(ABRL_CODVC,nodo.get(ABRL_CODVC)); + relvoci.put(ABRL_NCOMP,nodo.get_int(ABRL_NCOMP)+1); + + if (relvoci.read()==NOERR) + { + // && relvoci.get(RELVOCI_CODANA)==curr_ana + currid++; + ana_node->put(ABRA_IDSUCC, currid); + build_ana_tree(currid,relvoci.curr(),father,ana_node,tabtree); + } + else + ana_node->put(ABRA_IDSUCC, ID_NULLO); +} + + +void TRicezione::set_tipo_bil(const TString &tipo_bil) +{ + _tipo_bilancio = tipo_bil; +} + +//Funzione membro che effettua la conversione +bool TRicezione::menu(MENU_TAG) +{ + TString config_file; //Nome del file di configurazione + TMask msk("AB2100A"); //Maschera dove si chiede di immettere il percorso del file sorgente + TFilename percorso; //Contiene il percorso completo del file sorgente + msk.set_handler(F_PERCORSO, inseriscipercorso); //Assegno un handler al campo F_PERCORSO + //inseriscipercorso controlla che il percorso (e il file) esista e sia corretto + msk.set_handler(F_PERCORSO_UTENTE, inseriscipercorso); + + //A questo punto il percorso e' corretto + if (msk.run()== K_ENTER) //Eseguo la maschera + { + //Visualizza una finestra di attesa + TIndwin idle(0,"Attendere: aggiornamento della tabella in corso.\n\nL'operazione potrebbe richiedere qualche minuto ... ",FALSE,FALSE,60); + percorso=msk.get(F_PERCORSO); //Leggo il contenuto di F_PERCORSO + _trasfile=set_config_name(config_file,msk,percorso); + _trasfile->open('r'); //Apro il file di testo in rettura + set_tipo_bil(msk.get(F_TIPO_BILANCIO)); + + ricevi(msk); + + _trasfile->close(); + delete _trasfile; + _trasfile =NULL; + + if (msk.get_bool(F_MOVIMENTI)) + build_balancetree(LF_MOVDETT); + + if (msk.get_bool(F_SRELAZ)) + build_relana(config_file,msk,percorso); + + //messaggio finale + message_box(" ... aggiornamento delle tabelle selezionate effettuato"); + } //end if (msk.run()) + return FALSE; +} + +int ab2101(int argc, char **argv) +{ + TRicezione a; + a.run(argc,argv,"Ricezione da file di testo"); + return 0; +} \ No newline at end of file diff --git a/ab/movdett.h b/ab/movdett.h new file mode 100755 index 000000000..3059f92aa --- /dev/null +++ b/ab/movdett.h @@ -0,0 +1,28 @@ +//Nomi dei campi di LF_MOVDETT +#ifndef _MOVDETT_H +#define _MOVDETT_H + +#define ABMD_CODDITTA "CODDITTA" +#define ABMD_ANNO "ANNO" +#define ABMD_CODPDB "CODPDB" +#define ABMD_TIPOBIL "TIPOBIL" +#define ABMD_CODCBL "CODCBL" +#define ABMD_DREG "DATAREG" +#define ABMD_DDOC "DATADOC" +#define ABMD_ID "ID" +#define ABMD_DETTFIGLIO "DETT" +#define ABMD_TIPODETT "TIPODETT" +#define ABMD_CODDETT "CODDETT" +#define ABMD_FLDA "FLDA" +#define ABMD_IMPORTO "IMPORTO" +#define ABMD_PDARE "PDARE" +#define ABMD_PAVERE "PAVERE" +#define ABMD_RDARE "RDARE" +#define ABMD_RAVERE "RAVERE" +#define ABMD_IDPADRE "IDPADRE" +#define ABMD_IDFIGLIO "IDFIGLIO" +#define ABMD_IDPREC "IDPREC" +#define ABMD_IDSUCC "IDSUCC" +#define ABMD_TIPO_TRACCIATO "ORD_FIELD" + +#endif //_MOVDETT_H \ No newline at end of file diff --git a/ab/saldi.h b/ab/saldi.h new file mode 100755 index 000000000..dc8a56238 --- /dev/null +++ b/ab/saldi.h @@ -0,0 +1,12 @@ +//Nomi dei campi di LF_SALDI +#ifndef _SALDI_H +#define _SALDI_H + +#define ABS_CODDITTA "CODDITTA" +#define ABS_ANNO "ANNO" +#define ABS_CODPDB "CODPDB" +#define ABS_TIPOBIL "TIPOBIL" +#define ABS_CODCBL "CODCBL" +#define ABS_DETTFIGLIO "DETTFIGLIO" + +#endif //_SALDI_H \ No newline at end of file