root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ab/ab2102.cpp
sauro 22557d5d80 Per il modulo ab1 (stampe) sono state commentate delle righe di codice che non 
servivano.
Le maschere sono state modificate solo dal punto di vista estetico.
Il modulo ab2 (invio e ricezione) è stato completato: esegue ricezioni da as400 e
interne, ed esegue invii ad as400 (tranne la parte di analisi) e invii interni.
Il file ab2100a.ini è il file di configurazione per as400
Il file ab2100b.ini è il file di configurazione per l'interno


git-svn-id: svn://10.65.10.50/trunk@6073 c028cbd2-c16b-5b4b-a496-9718f37d4682
1998-01-30 16:32:36 +00:00

505 lines
17 KiB
C++
Executable File
Raw Blame History

//AB2102.CPP Trasferimento tabelle
#include <utility.h> //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 "relana.h" //Contiene le definizioni di costanti relative ai nomi dei campi di LF_RELANA
#include "ab2100.h"
#include "ab2100a.h"
#include <progind.h>
#include <assoc.h>
#include <varrec.h>
#define TABELLA_TIPO_BILANCI "NTBBB"
const char* get_ordinamento(TVariable_rectype & rec)
{
if (rec.get(ABMD_TIPODETT) == FLAG_DETT_DT || rec.get(ABMD_TIPODETT) == FLAG_COGE_CG )
{ //E' un record di MOVI3
return (MOVIMENTO3);
}
if (rec.get(ABMD_TIPODETT) == FLAG_CLIENTE_CL)
{//E' un record di MOVI4
return (MOVIMENTO4);
}
if (rec.get(ABMD_TIPODETT) == FLAG_FORNITORE_FO)
{//E' un record di MOVI5
return (MOVIMENTO5);
}
if (rec.get(ABMD_TIPODETT) == FLAG_MOVIMENTO_MO)
{//Può essere MOVI 1 2
real r(rec.get(ABMD_IMPORTO));
if (r > 0)
//Se è un saldo il record va in MOVI1
return (MOVIMENTO1);
//Se è un progressivo o una riclassificazione va in MOVI2
return (MOVIMENTO2);
}
//A questo punto la funzione non dovrebbe mai arrivare
CHECK (FALSE,"La funzione get_ordinamento ritorna un valore non valido");
return NULL;
}
bool TInvio_AS400::cerca_padre(TLocalisamfile & padre, TRectype &node)
{
padre.put(ABMD_CODDITTA,node.get(ABMD_CODDITTA));
padre.put(ABMD_ANNO,node.get(ABMD_ANNO));
padre.put(ABMD_CODPDB,node.get(ABMD_CODPDB));
padre.put(ABMD_TIPOBIL,node.get(ABMD_TIPOBIL));
padre.put(ABMD_CODCBL,node.get(ABMD_CODCBL));
padre.put(ABMD_ID,node.get(ABMD_IDPADRE));
if (padre.read() == NOERR)
return TRUE;
return FALSE;
}
long TInvio_AS400::my_num(TLocalisamfile& mov, TAssoc_array& progressivi)
{
long ret = 1;
TToken_string my_key;
my_key.add(mov.get(ABMD_CODDITTA));
my_key.add(mov.get(ABMD_ANNO));
my_key.add(mov.get(ABMD_CODPDB));
my_key.add(mov.get(ABMD_TIPOBIL));
my_key.add(mov.get(ABMD_CODCBL));
my_key.add(mov.get(ABMD_ID));
if (progressivi.is_key(my_key))
{
ret = atol(*(TString*)progressivi.objptr(my_key));
}
else
{
long id_prec =mov.get_long(ABMD_IDPREC);
// if (id_prec != ID_NULLO) // Se il padre di un movimento è nullo significa che è un movimento di un saldo
// {
mov.put(ABMD_ID,id_prec);
if (mov.read()== NOERR)
{
ret=my_num(mov,progressivi)+1;
}
// else
// CHECK (FALSE,"Si è verificata una inconsistenza nei dati: è stato trovato un movimento senza il padre!");
//}
TString16 str_ret;
str_ret << ret;
progressivi.add(my_key,str_ret);
}
return ret;
}
void TInvio_AS400::trasferisci_albero(TRectype &node, TRecord_text &rec, TAssoc_array &progressivi)
{
TLocalisamfile mov(LF_MOVDETT);
//Se è un COGE scrivo il CODICE_COGE nel relativo campo
if (node.get(ABMD_TIPODETT) == FLAG_COGE_CG)
rec.add(node.get(ABMD_CODDETT),CONTO_COGE_MOVDETT);
//Se è un movimento ...
if (node.get(ABMD_TIPODETT)== FLAG_MOVIMENTO_MO)
{ //... sono all'ultimo livello: trovo il padre
if (cerca_padre(mov,node))
{//Questo è il padre del movimento
if (mov.get(ABMD_TIPODETT) == FLAG_COGE_CG) //Se il padre è un COGE scrivo il CONTO COGE nel relativo campo
rec.add(node.get(ABMD_CODDETT),CONTO_COGE_MOVDETT);
//altrimenti, se il padre è un dettaglio, non scrivo nessuna informazione aggiuntiva
}
// Se il padre del movimento non esiste, allora è un movimento di un saldo
// else
// {//Non dovrebbe mai succedere: non esiste il padre del movimento
// CHECK (FALSE,"Si è verificata una inconsistenza nei dati: è stato trovato un movimento senza il padre!");
// }
//Questa parte esegue la "numerazione progressiva" dei movimenti: assegna il numero di riga
TString16 num_riga;
mov.curr()=node;
num_riga << my_num(mov,progressivi);
rec.add(num_riga,NUMERO_RIGA_MOVDETT);
//Trovo il padre se esiste
long id_padre = atol(node.get(ABMD_IDPADRE));
real r(node.get(ABMD_CODDETT));
if ((id_padre != ID_NULLO) && (r == 0)) //Se esiste il padre e non sono un COGE devo assegnarmi
//nel campo PROGRESSIVO_DETT il numero progressivo del padre
{//Leggo il padre
mov.curr()=node;
mov.put(ABMD_ID,id_padre);
if (mov.read()==NOERR)
{
TString16 num_prog;
num_prog << my_num(mov,progressivi);
rec.add(num_prog,PROGRESSIVO_DETT_MOVDETT); //Questo è un record di tipo MOVIMENTI
}
else
CHECK (FALSE,"Si è verificata una inconsistenza nei dati: è stato trovato un movimento senza il padre!");
}
}//Fine parte "ricostruzione" albero dei movimenti
//Questa parte "ricostruisce" l'albero dei dettaglio
if (node.get(ABMD_TIPODETT)== FLAG_DETT_DT)
{
mov.curr()=node;
TString16 num;
num << my_num(mov,progressivi);
rec.add(num,PROGRESSIVO_DETT_MOVDETT); //Questo è un record di tipo DETTAGLI
}
}
bool TInvio_AS400::mov_da_scrivere(TRectype &node)
{
TLocalisamfile dett(LF_MOVDETT);
if (node.get_long(ABMD_IDPADRE) == ID_NULLO) //Sono al primo livello
return TRUE;
if (cerca_padre(dett,node))
{
if (dett.get_long(ABMD_IDPADRE) == ID_NULLO) //Sono al secondo livello
return TRUE;
else
{
if (dett.get(ABMD_TIPODETT) == FLAG_COGE_CG) //Sono al terzo livello, ma ammetto solo i COGE
return TRUE;
}
}
return FALSE; //Tutti i livelli superiori a 2 e tutti i casi che non riesco a gestire
}
void TInvio_AS400::formatta(TRecord_text &rec, TRectype &node, int &logic_num)
{
if (logic_num == LF_MOVDETT)
{
if ((rec.type() == MOVIMENTO1) || (rec.type() == MOVIMENTO2))
{//Se c'è un valore significativo in IMPORTO significa che questo valore va
//inserito nel campo IMPORTO del file di testo e settato il flag D/A
//Il tipo record (già settato) è MOVI1
real r(node.get(ABMD_IMPORTO));
if (r > 0)
{
TString imp = node.get(ABMD_IMPORTO);
rec.add(node.get(ABMD_FLDA),FLAG_DA_MOVDETT);
rec.add(imp.rtrim(4),IMPORTO_MOVDETT);
}
else
{//Questi valori vanno inseriti in IMPORTO di MOVI2
real rpd(node.get(ABMD_PDARE));
real rpa(node.get(ABMD_PAVERE));
real rrd(node.get(ABMD_RDARE));
real rra(node.get(ABMD_RAVERE));
if (rpd > 0)
{
TString imp =node.get(ABMD_PDARE);
rec.add("D",FLAG_DA_MOVDETT);
rec.add(imp.rtrim(4),IMPORTO_MOVDETT);
}
if (rpa > 0)
{
TString imp = node.get(ABMD_PAVERE);
rec.add("A",FLAG_DA_MOVDETT);
rec.add(imp.rtrim(4),IMPORTO_MOVDETT);
}
if (rrd > 0)
{
TString imp = node.get(ABMD_RDARE);
rec.add("X",FLAG_RICLASSIFICAZIONE_MOVDETT);
rec.add("D",FLAG_DA_MOVDETT);
rec.add(imp.rtrim(4),IMPORTO_MOVDETT);
}
if (rra > 0)
{
TString imp = node.get(ABMD_RAVERE);
rec.add("X",FLAG_RICLASSIFICAZIONE_MOVDETT);
rec.add("A",FLAG_DA_MOVDETT);
rec.add(imp.rtrim(4),IMPORTO_MOVDETT);
}
}
}
else
{//Questi sono gli importi dei dettagli
TString sld = rec.row(SALDO_INIZIO_ANNO_MOVDETT);
rec.add(sld.rtrim(4),SALDO_INIZIO_ANNO_MOVDETT);
TString pda = rec.row(PROGRESSIVO_DARE_MOVDETT);
rec.add(pda.rtrim(4),PROGRESSIVO_DARE_MOVDETT);
TString pav = rec.row(PROGRESSIVO_AVERE_MOVDETT);
rec.add(pav.rtrim(4),PROGRESSIVO_AVERE_MOVDETT);
TString rda = rec.row(RICLASSIFICAZIONE_DARE_MOVDETT);
rec.add(rda.rtrim(4),RICLASSIFICAZIONE_DARE_MOVDETT);
TString rav = rec.row(RICLASSIFICAZIONE_AVERE_MOVDETT);
rec.add(rav.rtrim(4),RICLASSIFICAZIONE_AVERE_MOVDETT);
}
}// end if LF_MOVDETT
if (logic_num == LF_ABSALDI)
{
TString sld = rec.row(SALDO_INIZIO_ANNO_SLD_MOVDETT);
rec.add(sld.rtrim(4),SALDO_INIZIO_ANNO_SLD_MOVDETT);
TString pda = rec.row(PROGRESSIVO_DARE_SLD_MOVDETT);
rec.add(pda.rtrim(4),PROGRESSIVO_DARE_SLD_MOVDETT);
TString pav = rec.row(PROGRESSIVO_AVERE_SLD_MOVDETT);
rec.add(pav.rtrim(4),PROGRESSIVO_AVERE_SLD_MOVDETT);
TString rda = rec.row(RICLASSIFICAZIONE_DARE_SLD_MOVDETT);
rec.add(rda.rtrim(4),RICLASSIFICAZIONE_DARE_SLD_MOVDETT);
TString rav = rec.row(RICLASSIFICAZIONE_AVERE_SLD_MOVDETT);
rec.add(rav.rtrim(4),RICLASSIFICAZIONE_AVERE_SLD_MOVDETT);
}// end if LF_ABSALDI
if (logic_num == LF_TABCOM && rec.type() == TIPO_TABELLA_PERIODI)
{
rec.add(SIGLA_TABELLA_PERIODI,SIGLA_TAB_PER);
}
}
void TObject_send::converti(int logic_num)
{
TRelation *tr_relation=_trasfile->t_rec(logic_num)->relation();
TRecord_text rec(_trasfile->t_rec(logic_num)->type()); //Istanzio un tipo record_text
TCursor *cur=NULL;
cur = new TCursor(tr_relation);
//Leggo il numero di records da convertire
long items =cur->items();
//Barra scorrevole di attesa
TProgind idle(items,"Attendere: conversione in corso ...",TRUE,TRUE,60);
//Ciclo principale di conversione
for (*cur=0;cur->pos()<items;++*cur)
{
idle.addstatus(1);
_trasfile->autoload(rec,logic_num);
rec.add(rec.type(),0);
_trasfile->write(rec);
}
delete cur;
}
void TObject_send::converti(int main_file, const char * tabname)
{
TRelation *tr_relation=_trasfile->t_rec(main_file,tabname)->relation();
TRecord_text rec(_trasfile->t_rec(main_file,tabname)->type()); //Istanzio un tipo record_text
TCursor *cur=NULL;
cur = new TCursor(tr_relation);
int logic_num= tr_relation->lfile().num();
//Leggo il numero di records da convertire
long items =cur->items();
//Barra scorrevole di attesa
TProgind idle(items,"Attendere: conversione in corso ...",TRUE,TRUE,60);
//Ciclo principale di conversione
for (*cur=0;cur->pos()<items;++*cur)
{
idle.addstatus(1);
// _trasfile->autoload(rec,logic_num);
_trasfile->autoload(rec,tabname);
rec.add(rec.type(),0);
_trasfile->write(rec);
}
delete cur;
}
void TInvio_AS400::converti(int logic_num)
{
TRelation *tr_relation=trans_file()->t_rec(logic_num)->relation();
TRecord_text rec(trans_file()->t_rec(logic_num)->type()); //Istanzio un tipo record_text
TCursor *cur=NULL;
TAssoc_array progressivi;
if (logic_num == LF_MOVDETT)
{
TVariable_rectype *vrec_rmov= new TVariable_rectype(LF_MOVDETT);
vrec_rmov->add_field(new TVariable_field (ABMD_TIPO_TRACCIATO,get_ordinamento,5));
//Costruisco la chiave del TSorted_cursor
TToken_string exp(ABMD_TIPO_TRACCIATO);
exp.add(ABMD_CODDITTA);
exp.add(ABMD_ANNO);
exp.add(ABMD_CODPDB);
exp.add(ABMD_TIPOBIL);
exp.add(ABMD_CODCBL);
exp.add(ABMD_ID);
cur = new TSorted_cursor(tr_relation,exp);
cur->file().set_curr(vrec_rmov);
}
else
cur = new TCursor(tr_relation);
//Leggo il numero di records da convertire
long items =cur->items();
//Barra scorrevole di attesa
TProgind idle(items,"Attendere: conversione in corso ...",TRUE,TRUE,60);
//Ciclo principale di conversione
for (*cur=0;cur->pos()<items;++*cur)
{
idle.addstatus(1);
if (logic_num == LF_MOVDETT)
{//In questo caso la conversione è un po' particolare
rec.set_type(tr_relation->lfile().get(ABMD_TIPO_TRACCIATO));
trans_file()->autoload(rec,*cur,&rec.type());
if (mov_da_scrivere(tr_relation->lfile().curr()))
{
trasferisci_albero(tr_relation->lfile().curr(),rec,progressivi);
formatta(rec,tr_relation->lfile().curr(),logic_num);
trans_file()->write(rec);
}
}
else
{//in tutti gli altri casi la conversione è semplice
trans_file()->autoload(rec,logic_num);
if (logic_num == LF_ABSALDI || logic_num == LF_TABCOM)
formatta(rec,tr_relation->lfile().curr(),logic_num);
trans_file()->write(rec);
}
}
delete cur;
}
//Handler per l'inserimento del percorso completo
bool TInvio::inseriscipercorso(TMask_field& f, KEY k)
{
TString percorso;
percorso=f.get(); //Leggo il contenuto del campo
return TRUE;
}
//Funzione membro che esegue la conversione di trasferimento
//bool TInvio_AS400::menu(MENU_TAG)
void TInvio::main_loop()
{
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);
msk.hide(F_TIPO_BILANCIO); //nascondo questo campo poichè non mi serve
msk.hide(F_TESTO_TIPOBIL); //nascondo questo campo poichè non mi serve
msk.enable(-1,TRUE);
if (msk.run()== K_ENTER) //Eseguo la maschera
{
//A questo punto il percorso e' corretto
percorso=msk.get(F_PERCORSO); //Leggo il contenuto di F_PERCORSO
if (msk.get_int(F_TIPO_RICE) == RICEZIONE_AS400)
{
if ((msk.get_bool(F_VOCI) == TRUE) ||
(msk.get_bool(F_RELAZ) == TRUE) ||
(msk.get_bool(F_SRELAZ) == TRUE))
{
message_box("L'ivio a AS400 delle VOCI, RELAZIONI e SOTTORELAZIONI non è attualmente previsto");
}
_invio = new TInvio_AS400(percorso);
}
if (msk.get_int(F_TIPO_RICE) == RICEZIONE_INTERNA)
{
_invio = new TObject_send(percorso);
}
if (msk.get_int(F_TIPO_RICE) == RICEZIONE_USER_DEFINED)
{
TString config_file(msk.get(F_PERCORSO_UTENTE)); //Nome del file di configurazione
_invio = new TInvio_user_defined(config_file,percorso);
}
// Parte di invio
if (msk.get_bool(F_PIANO_CONTI)==TRUE) //Controllo se si è scelto di convertire il piano dei conti
{
_invio->converti(LF_ABPCON); //Conversione
}
if (msk.get_bool(F_PERIODI_BILANCI)==TRUE) //Scelta di convertire la tabella periodi bilanci
{
if (msk.get_int(F_TIPO_RICE) == RICEZIONE_AS400)
{//Se eseguo un invio a AS400 converto passando il numero del file
_invio->converti(LF_TABCOM);
}
else
{ //Se eseguo un invio interno converto passando il nome della tabella comune
_invio->converti(LF_TABCOM,"%PDB");
_invio->converti(LF_TABCOM,"%NTB");
}
}
if (msk.get_bool(F_ANALISI)==TRUE) //scelta di cnverite la tabella tipi analisi di bilancio
{
_invio->converti(LF_ANALISI);
}
if (msk.get_bool(F_MOVIMENTI)==TRUE) //scelta di cnverite la tabella tipi analisi di bilancio
{
_invio->converti(LF_MOVDETT);
}
if (msk.get_bool(F_SALDI)==TRUE) //scelta di cnverite la tabella tipi analisi di bilancio
{
_invio->converti(LF_ABSALDI);
}
if (msk.get_int(F_TIPO_RICE) != RICEZIONE_AS400)
{// Solo se non è un invio ad AS400
if (msk.get_bool(F_VOCI)==TRUE) //scelta di cnverite la tabella tipi analisi di bilancio
{
_invio->converti(LF_VOCI);
}
if (msk.get_bool(F_RELAZ)==TRUE) //scelta di cnverite la tabella tipi analisi di bilancio
{
_invio->converti(LF_RELVOCI);
}
if (msk.get_bool(F_SRELAZ)==TRUE) //scelta di cnverite la tabella tipi analisi di bilancio
{
if (msk.get_int(F_TIPO_RICE) == RICEZIONE_INTERNA)
{
_invio->converti(LF_CARADD);
_invio->converti(LF_COLLDICH);
}
_invio->converti(LF_RELANA);
}
}
delete _invio;
//messaggio finale
message_box(" ... aggiornamento delle tabelle effettuato");
} //end if (msk.run())
// return FALSE;
}
int ab2102(int argc, char **argv)
{
TInvio a;
a.run(argc,argv,"Trasferimento su file di testo");
return 0;
}
TObject_send::TObject_send(const TFilename &percorso)
{
if (_trasfile != NULL)
delete _trasfile;
_trasfile = new TFile_text(percorso, "AB2100B.INI"); /*DA CAMBIARE*/
_trasfile->open('w'); //apro il TFile_text in lettura
}
TInvio_AS400::TInvio_AS400(const TFilename &percorso)
{
if (_trasfile != NULL)
delete _trasfile;
_trasfile = new TFile_text(percorso, "AB2100A.INI"); /*DA CAMBIARE*/
_trasfile->open('w'); //apro il TFile_text in lettura
}
TInvio_user_defined::TInvio_user_defined(const TString & config, const TFilename &percorso)
{
if (_trasfile != NULL)
delete _trasfile;
_trasfile = new TFile_text(percorso, config); //Leggo il file di configurazione
_trasfile->open('w'); //apro il TFile_text in lettura
}
Reference in New Issue View Git Blame Copy Permalink