root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/m770/77cnv.cpp

1255 lines
38 KiB
C++
Raw Normal View History

1o Merge della 97.02 git-svn-id: svn://10.65.10.50/trunk@4705 c028cbd2-c16b-5b4b-a496-9718f37d4682
1997-06-18 09:52:29 +00:00
#include <applicat.h>
#include <isam.h>
#include <progind.h>
#include <recarray.h>
#include <utility.h>
#include <fstream.h>
#include <relation.h>
#include <tabutil.h>
#include <text.h>
#include "quadrog.h"
#include "quadrogp.h"
#define usage "Errore - uso : 77cnv [0|1|2|3|4|5|6] 0"
#define G_DUMP "quadrog.dmp" // File di scarico del quadro G
#define CNV_LOG "C770log.txt" // File di log della conversione
class TConvert_app : public TApplication
{
int _conv;
TTextfile* _M770_log;
protected:
virtual bool create();
bool convert_e2() const;
bool convert_f() const;
bool convert_f2() const;
bool dump_quadro_g() const; // Funzioni per convertire quadro G
bool load_quadro_g() const;
bool cnv_ca7_971() const; // conversione causali
bool cnv_quadroA_971() const; // conversione quadro A
bool cnv_quadroAB_971() const; // conversione quadro Abis
bool cnv_quadroA2_971() const; // conversione quadro A2
bool cnv_basebis_971() const; // conversione basebis
public:
TConvert_app(int conv) : _conv(conv) { }
virtual ~TConvert_app() { }
};
bool TConvert_app::create()
{
// istanza file di log
_M770_log = new TTextfile(CNV_LOG);
switch(_conv)
{
// Numeri liberi per conversioni di Luciano;
case 0 :
cnv_ca7_971();
cnv_basebis_971();
break;
case 1 :
cnv_quadroA_971();
cnv_quadroAB_971();
cnv_quadroA2_971();
break;
case 4 : convert_e2(); convert_f(); convert_f2(); break;
case 5 : dump_quadro_g(); break; // Scarica alcuni campi del quadro G da trasportare sulle righe
case 6 : load_quadro_g(); break; // Ricarica gli stessi sulle righe del quadro G
default:break;
}
// libera istanza file di log
delete _M770_log;
return FALSE;
}
bool TConvert_app::convert_e2() const
{
TLocalisamfile righe_e2(LF_QUAE2);
TProgind pi(righe_e2.items(), "Conversione quadro E2", FALSE, TRUE, 60);
TDecoder causali("%CA7");
TRectype& cur = righe_e2.curr();
for (int err = righe_e2.first(); err == NOERR; err = righe_e2.next())
{
pi.addstatus(1);
const TString& desc = causali.decode(cur.get("CODCAUS"));
cur.put("DENCAUS", desc);
int ee = righe_e2.rewrite();
if (ee != NOERR)
{
const long ditta = cur.get_long("CODDITTA");
const int riga = cur.get_int("NUMPROG");
error_box("Impossibile aggiornare la riga %d del quadro E2\n"
"della ditta %ld: errore %d", riga, ditta, ee);
}
}
return TRUE;
}
bool TConvert_app::convert_f() const
{
TLocalisamfile quadro_f(LF_QUAF);
TLocalisamfile righe_f(LF_RIGHEF);
TRectype& cur = righe_f.curr();
TProgind pi(quadro_f.items(), "Conversione quadro F", FALSE, TRUE, 60);
for (int err = quadro_f.first(); err == NOERR; err = quadro_f.next())
{
pi.addstatus(1);
const long ditta = quadro_f.get_long("CODDITTA");
const real e_aliq = quadro_f.get("E_ALIQUOTA");
if (e_aliq < 0.0)
{
// gia' stata convertita!
continue;
}
cur.zero();
cur.put("CODDITTA", ditta);
for (int e = righe_f.read(_isgteq); e == NOERR; e = righe_f.next())
{
if (cur.get_long("CODDITTA") != ditta)
break;
const char prosp = toupper(cur.get_char("TIPOPRO"));
const int riga = cur.get_int("NPROG");
if (prosp >= 'B' && prosp <= 'D')
{
const char newprosp = prosp-1;
cur.put("TIPOPRO", newprosp);
err = righe_f.write();
if (err != NOERR)
{
error_box("Impossibile creare la riga %d del prospetto %c\n"
"della ditta %ld: errore %d", riga, newprosp, ditta, err);
}
}
cur.put("TIPOPRO", prosp);
if (err == NOERR)
{
int err = righe_f.remove();
if (err != NOERR)
{
error_box("Impossibile eliminare la riga %d del prospetto %c\n"
"della ditta %ld: errore %d", riga, prosp, ditta, err);
break;
}
}
else
err = righe_f.reread();
}
const real e_cambiali = quadro_f.get("E_CAMBIALI");
const real e_sogrit = quadro_f.get("E_SOGRIT");
const real e_rope = quadro_f.get("E_ROPE");
if (e_cambiali != ZERO || e_sogrit != ZERO ||
e_aliq != ZERO || e_rope != ZERO)
{
righe_f.zero();
righe_f.put("CODDITTA", ditta);
righe_f.put("TIPOPRO", "D");
righe_f.put("NPROG", "1");
righe_f.put("IMPCAMB", e_cambiali);
righe_f.put("ALIQUOTA", e_aliq);
righe_f.put("SOGRIT", e_sogrit);
righe_f.put("ROPE", e_rope);
int ed = righe_f.write();
if (ed != NOERR)
error_box("Impossibile creare la riga del prospetto D\n"
"della ditta %ld: errore %d", ditta, ed);
}
const real f_aliq = quadro_f.get("F_ALIQUOTA");
const real f_sogrit = quadro_f.get("F_SOGRIT");
const real f_rope = quadro_f.get("F_ROPE");
if (f_aliq != ZERO || f_sogrit != ZERO || f_rope != ZERO)
{
righe_f.zero();
righe_f.put("CODDITTA", ditta);
righe_f.put("TIPOPRO", "E");
righe_f.put("NPROG", "1");
righe_f.put("ALIQUOTA", f_aliq);
righe_f.put("SOGRIT", f_sogrit);
righe_f.put("ROPE", f_rope);
int ee = righe_f.write();
if (ee != NOERR)
error_box("Impossibile creare la riga del prospetto E\n"
"della ditta %ld: errore %d", ditta, ee);
}
// Marca la ditta come convertita
quadro_f.put("E_ALIQUOTA", -1);
quadro_f.rewrite();
}
return TRUE;
}
bool TConvert_app::convert_f2() const
{
TLocalisamfile righe_f2(LF_RIGHEF2);
TProgind pi(righe_f2.items(), "Conversione quadro F2", FALSE, TRUE, 60);
TDecoder causali("%CA7");
TRectype& cur = righe_f2.curr();
for (int err = righe_f2.first(); err == NOERR; err = righe_f2.next())
{
pi.addstatus(1);
const long ditta = cur.get_long("CODDITTA");
const char oldtipo = cur.get_char("TIPOPRO");
if (oldtipo != 'A')
{
const int riga = cur.get_int("NPROG");
cur.put("TIPOPRO", "A");
const TString& desc = causali.decode(cur.get("CODCAUS"));
cur.put("DENCAUS", desc);
int ee = righe_f2.write();
if (ee == NOERR)
{
cur.put("TIPOPRO", oldtipo);
ee = righe_f2.remove();
if (ee != NOERR)
{
error_box("Impossibile eliminare la riga %d del quadro F2\n"
"della ditta %ld: errore %d", riga, ditta, ee);
}
}
else
{
error_box("Impossibile creare la riga %d del quadro F2\n"
"della ditta %ld: errore %d", riga, ditta, ee);
}
}
}
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////////
// Scarico dei campi del prospetto 1 sez I e II da riportare sulle righe quadro G
/////////////////////////////////////////////////////////////////////////////////
bool TConvert_app::dump_quadro_g() const
{
TFilename f;
TLocalisamfile quadrog(LF_QUAG);
TToken_string t;
TString16 fld1,fld2,fld3,fld4;
TString s1,s2,s3,s4;
int err;
f.tempdir();
f << "/" << G_DUMP;
ofstream ofs(f);
TProgind pi(quadrog.items(), "Conversione quadro G - Scarico dati in corso...", FALSE, TRUE, 60);
for (err = quadrog.first(); err == NOERR; err = quadrog.next())
{
pi.addstatus(1);
const long ditta = quadrog.get_long("CODDITTA");
int riga_1 = 1, riga_2 = 1;
fld3 = "P1AMMQx"; fld4 = "P1AMMx";
for (int i = 1; i<=4; i++)
{
fld1 = "P1DATADx"; fld2 = "P1NUMQx"; // Prospetto 1 sez I
fld1.rtrim(1); fld1 << i;
fld2.rtrim(1); fld2 << i;
fld3.rtrim(1); fld3 << i;
fld4.rtrim(1); fld4 << i;
s1 = quadrog.get(fld1);
s2 = quadrog.get(fld2);
s3 = quadrog.get(fld3);
s4 = quadrog.get(fld4);
if (s1.not_empty() || s2.not_empty() || s3.not_empty() || s4.not_empty())
{ // Se tutti vuoti non scrive la riga
t = "";
t.add(ditta);
t.add("1"); t.add("1");t.add(riga_1++);
t.add(s1);
t.add(s2);
t.add(s3);
t.add(s4);
t << "\n";
ofs << t;
}
if (i < 4)
{
fld1 = "P2DESCx"; fld2 = "P2VALx"; // Prospetto 1 sez II
fld1.rtrim(1); fld1 << i;
fld2.rtrim(1); fld2 << i;
s1 = quadrog.get(fld1);
s2 = quadrog.get(fld2);
if (s1.not_empty() || s2.not_empty())
{ // Se tutti vuoti non scrive la riga
t = "";
t.add(ditta);
t.add("1"); t.add("2");t.add(riga_2++);
t.add(s1);
t.add(s2);
t << "\n";
ofs << t;
}
}
}
}
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////////
// Carico dei campi del prospetto 1 sez I e II da riportare sulle righe quadro G
/////////////////////////////////////////////////////////////////////////////////
bool TConvert_app::load_quadro_g() const
{
TFilename f;
f.tempdir();
f << "/" << G_DUMP;
if (fexist(f))
{
TLocalisamfile quadrogp(LF_QUAGP);
TToken_string t;
char buffer[256];
ifstream ifs(f);
int err;
TProgind pi(1, "Conversione quadro G - Caricamento righe in corso...", FALSE, FALSE, 60);
while (ifs.good())
{
ifs.getline(buffer,256,'\n');
t = buffer;
if (t.empty_items()) break;
quadrogp.zero();
quadrogp.put(QGP_CODDITTA,t.get(0));
quadrogp.put(QGP_PROSPETTO,t.get(1));
const char sez = t.get_char(2);
quadrogp.put(QGP_SEZIONE,sez);
quadrogp.put(QGP_NPROG,t.get(3));
if (sez == '1')
{
quadrogp.put(QGP_DATADEL,t.get(4));
quadrogp.put(QGP_NUMQUOTE,t.get(5));
quadrogp.put(QGP_UTILI1S,t.get(6));
quadrogp.put(QGP_UTILI2S,t.get(7));
}
else
{
quadrogp.put(QGP_DESCRBENI,t.get(4));
quadrogp.put(QGP_UTILI1S,t.get(5));
}
err = quadrogp.write();
if (err == _isreinsert)
err = quadrogp.rewrite();
if (err != NOERR)
error_box("Errore %d cercando di caricare le righe del quadro G.",err);
}
}
remove(f); // Let's ignore if the file exists or not
return TRUE;
}
///////////////////////////////////////////////////////////
// Conversione tabella causali versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_ca7_971() const
{
// titolo log
char now[9];
TDate today(TODAY);
TString log_title("[Log Conversione Causali : ");
log_title << today << " " << _strtime(now) << "] Prassi SpA";
_M770_log->append(log_title);
TString log_space(" ");
_M770_log->append(log_space);
// conversione tabella
TTable ca7("%CA7");
TProgind pi(ca7.items(), "Conversione tabella causali", FALSE, FALSE, 60);
for (ca7.first(); ca7.good(); ca7.next())
{
// lettura campi soggetti a modifica
TString old_cod = ca7.get("CODTAB");
TString cod_qua = ca7.get("S1");// codice quadro
bool fl_Inps = ca7.get_bool("B4");// soggetto contributo Inps
bool fl_CT = ca7.get_bool("B2");// flag C.T.
bool fl_TS = ca7.get_bool("B3");// flag T.S.
char caus_C = ca7.get_char("S6");// causale quadro C
char caus_D = ca7.get_char("S2");// causale quadro D
char caus_D1 = ca7.get_char("S3");// causale quadro D1
char caus_DB = ca7.get_char("S7");// causale quadro DB
char caus_E = ca7.get_char("S8");// causale quadro E
char caus_E1 = ca7.get_char("S9");// causale quadro E1
real ass_imp_Inps = ca7.get_real("R2");// assoggettamento imponibile Inps
// conversione causale quadro D
switch(caus_D)
{
case 'A':
if (fl_Inps)
{
cod_qua = "DB";
caus_DB = 'A';
caus_D = ' ';
}
break;
case 'T':
if (fl_Inps)
{
cod_qua = "DB";
caus_DB = 'T';
caus_D = ' ';
}
break;
case 'E':
if (!fl_Inps)
caus_D = 'M';
else
{
TString log_line;
log_line << old_cod << ": ";
log_line << "causale quadro D: -E- con flag contributo Inps";
_M770_log->append(log_line);
}
break;
case 'G':
if (!fl_Inps)
caus_D = 'B';
else
{
TString log_line;
log_line << old_cod << ": ";
log_line << "causale quadro D: -G- con flag contributo Inps";
_M770_log->append(log_line);
}
break;
case 'H':
if (!fl_Inps)
caus_D = 'C';
else
{
TString log_line;
log_line << old_cod << ": ";
log_line << "causale quadro D: -H- con flag contributo Inps";
_M770_log->append(log_line);
}
break;
case 'I':
if (!fl_Inps)
caus_D = 'D';
else
{
TString log_line;
log_line << old_cod << ": ";
log_line << "causale quadro D: -I- con flag contributo Inps";
_M770_log->append(log_line);
}
break;
case 'L':
if (!fl_Inps)
caus_D = 'E';
else
{
TString log_line;
log_line << old_cod << ": ";
log_line << "causale quadro D: -L- con flag contributo Inps";
_M770_log->append(log_line);
}
break;
case 'M':
if (!fl_Inps)
caus_D = 'F';
else
{
TString log_line;
log_line << old_cod << ": ";
log_line << "causale quadro D: -M- con flag contributo Inps";
_M770_log->append(log_line);
}
break;
case 'P':
if (!fl_Inps)
caus_D = 'G';
else
{
TString log_line;
log_line << old_cod << ": ";
log_line << "causale quadro D: -P- con flag contributo Inps";
_M770_log->append(log_line);
}
break;
case 'Q':
if (!fl_Inps)
caus_D = 'H';
else
{
TString log_line;
log_line << old_cod << ": ";
log_line << "causale quadro D: -Q- con flag contributo Inps";
_M770_log->append(log_line);
}
break;
case 'R':
if (!fl_Inps)
caus_D = 'N';
else
{
TString log_line;
log_line << old_cod << ": ";
log_line << "causale quadro D: -R- con flag contributo Inps";
_M770_log->append(log_line);
}
break;
case 'S':
if (!fl_Inps)
caus_D = 'I';
else
{
TString log_line;
log_line << old_cod << ": ";
log_line << "causale quadro D: -S- con flag contributo Inps";
_M770_log->append(log_line);
}
break;
case 'F':
cod_qua = "DB";
caus_DB = 'E';
caus_D = ' ';
fl_Inps = TRUE;
ass_imp_Inps = ZERO;
break;
case 'N':
cod_qua = "DB";
caus_DB = 'F';
caus_D = ' ';
fl_Inps = TRUE;
ass_imp_Inps = ZERO;
break;
case 'B':
cod_qua = "DB";
caus_DB = 'B';
caus_D = ' ';
fl_Inps = TRUE;
ass_imp_Inps = ZERO;
break;
case 'C':
cod_qua = "DB";
caus_DB = 'C';
caus_D = ' ';
fl_Inps = TRUE;
ass_imp_Inps = ZERO;
break;
case 'D':
cod_qua = "DB";
caus_DB = 'D';
caus_D = ' ';
fl_Inps = TRUE;
ass_imp_Inps = ZERO;
break;
}
// conversione causale quadro D1
switch(caus_D1)
{
case 'F':
cod_qua = "DB";
caus_DB = 'F';
caus_D1 = ' ';
fl_Inps = TRUE;
ass_imp_Inps = ZERO;
break;
}
// flag C.T.
if (fl_CT)
caus_C = 'A';
// flag T.S.
if (fl_TS)
{
fl_TS = FALSE;
TString log_line;
log_line << old_cod << ": ";
log_line << "era indicato il flag T.S.";
_M770_log->append(log_line);
}
// clear campi eliminati
ca7.zero("B0");
ca7.zero("B2");
// update campi modificati
ca7.put("S1",cod_qua);// codice quadro
ca7.put("B4",fl_Inps);// soggetto contributo Inps
ca7.put("B3",fl_TS);// flag T.S.
ca7.put("S6",caus_C);// causale quadro C
ca7.put("S2",caus_D);// causale quadro D
ca7.put("S3",caus_D1);// causale quadro D1
ca7.put("S7",caus_DB);// causale quadro DB
ca7.put("S8",caus_E);// causale quadro E
ca7.put("S9",caus_E1);// causale quadro E1
ca7.put("R2",ass_imp_Inps);// assoggettamento imponibile Inps
// riscrittura record
ca7.rewrite();
}
// fine log
_M770_log->append(log_space);
return TRUE;
}
///////////////////////////////////////////////////////////
// Conversione quadro A 770 versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_quadroA_971() const
{
// titolo log
char now[9];
TDate today(TODAY);
TString log_title("[Log Conversione quadro A : ");
log_title << today << " " << _strtime(now) << "] Prassi SpA";
_M770_log->append(log_title);
TString log_space(" ");
_M770_log->append(log_space);
TLocalisamfile dip(LF_DIPEND);
TLocalisamfile qa(LF_QUAA);
TProgind pi(qa.items(), "Conversione quadro A", FALSE, TRUE, 60);
for (qa.first(); qa.good(); qa.next())
{
pi.addstatus(1);
// lettura campi soggetti a modifica
long cod_ditta = qa.get_long("CODDITTA");
long cod_dip = qa.get_long("CODDIP");
int A18 = qa.get_int("CAUSA");// causa
real A29 = qa.get_real("DENARO");// retribuzioni e pensioni
real EX_A21 = qa.get_real("NATURA");// ex in denaro
real A21 = qa.get_real("COBBDIP");// contr.prev.obblig.lav.dip.
real EX_A25 = qa.get_real("IACOBBCD");// ex contr.obbl.carico lav.dip.
real A24 = qa.get_real("NORIT");// somme a valori non assogg. a rit.
real EX_A27 = qa.get_real("TOTIMP");// ex totale imponibile
real EX_A50 = qa.get_real("SVNASSRI");// ex altre somme e valori non ass.rit.
int A11 = qa.get_int("QAQUALIF");// qualifica
// lettura campi dall'anagrafica dipendenti
int ana_qualifica = 0;// qualifica anagrafica
dip.setkey(1);
dip.zero();
dip.put("CODDITTA",cod_ditta);
dip.put("CODDIP",cod_dip);
if (dip.read() == NOERR)
ana_qualifica = dip.get_int("QUALIFICA");
else
{
TString log_line;
log_line.format("Anagrafica inesistente per il dipendente :%06ld, della ditta :%05ld",cod_dip,cod_ditta);
_M770_log->append(log_line);
}
// conversione causa
switch(A18)
{
case 6:
A18 = 0;
break;
case 7:
A18 = 0;
break;
}
// retribuzioni e pensioni
A29 = A29 + EX_A21 - A21 + EX_A27;
// contributi previd.assist.obbl.lav.dip.
A21 = A21 + EX_A25;
// somme e valori non assoggettati a ritenuta
A24 = A24 + EX_A50;
// qualifica
A11 = ana_qualifica;
// update campi modificati
qa.put("CAUSA",A18);// causa
qa.put("DENARO",A29);// retribuzioni e pensioni
qa.put("COBBDIP",A21);// contr.prev.obblig.lav.dip.
qa.put("NORIT",A24);// somme a valori non assogg. a rit.
qa.put("QAQUALIF",A11);// qualifica
// riscrittura record
qa.rewrite();
}
// fine log
_M770_log->append(log_space);
return TRUE;
}
///////////////////////////////////////////////////////////
// Conversione quadro Abis 770 versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_quadroAB_971() const
{
// titolo log
char now[9];
TDate today(TODAY);
TString log_title("[Log Conversione quadro Abis : ");
log_title << today << " " << _strtime(now) << "] Prassi SpA";
_M770_log->append(log_title);
TString log_space(" ");
_M770_log->append(log_space);
// istanza file basebis per riporto flag quadro compilato
TLocalisamfile bb(LF_BASEBIS);
// istanza file Abis e prepara chiave precedente
// per rilevamento rottura del dipendente
TLocalisamfile qab(LF_QUAAB);
qab.setkey(1);
qab.zero();
TRectype prevkey(qab.curr());
int prog = 0;
// istanza conta rettifica di conguaglio
int count_RettA = 0;
int count_RettB = 0;
int count_RettC = 0;
int count_RettX = 0;
// istanza record per scrittura rettifica A
TRectype rec_RettA(qab.curr());
// elaborazione quadri A
TLocalisamfile qa(LF_QUAA);
TProgind pi(qa.items(), "Conversione quadro Abis", FALSE, TRUE, 60);
for (qa.first(); qa.good(); qa.next())
{
pi.addstatus(1);
// lettura campi da copiare su Abis
long cod_ditta = qa.get_long("CODDITTA");// codice ditta
long cod_dip = qa.get_long("CODDIP");// codice dipendente
int rigo = qa.get_int("NPROG");// progressivo rigo
char EX_A52 = qa.get_char("CONEFF");// conguagli non effettuati
real EX_A53 = qa.get_real("IMPVERS");// imposta trattenuta
real EX_A54 = qa.get_real("INTERE");// interessi
real EX_A55 = qa.get_real("CSSN95CV");// contributo trattenuto
real EX_A56 = qa.get_real("INTERE2");// interessi
char EX_A57 = qa.get_char("CNEFF");// conguagli non effettuati
char EX_A58 = qa.get_char("RETCON");// rettifica conguaglio
real EX_A59 = qa.get_real("IMPRIMB");// imposta rimborsata
real EX_A60 = qa.get_real("IMPVER");// imposta trattenuta
real EX_A61 = qa.get_real("INTIRPEF");// interessi
real EX_A62 = qa.get_real("IMPVER2");// imposta trattenuta
real EX_A63 = qa.get_real("INTER");// interessi
real EX_A64 = qa.get_real("STSIRPEF");// soprattasse su Irpef
real EX_A65 = qa.get_real("CONRIMB");// contributo a rimborso
real EX_A66 = qa.get_real("CONVER");// contributo trattenuto
real EX_A67 = qa.get_real("INTER2");// interessi
real EX_A68 = qa.get_real("CONVER2");// contributo trattenuto
real EX_A69 = qa.get_real("INTER3");// interessi
real EX_A70 = qa.get_real("STSCSSN70");// soprattasse su Cssn
int EX_A71 = qa.get_int("M730NLIQ");// Mod.730 non liquidabile
long EX_A72 = qa.get_long("CODCAAF");// codice CAAF
real tot =ZERO;
tot = tot+EX_A53+EX_A54+EX_A55+EX_A56+EX_A59+EX_A60+EX_A61+EX_A62;
tot = tot+EX_A63+EX_A64+EX_A65+EX_A66+EX_A67+EX_A68+EX_A69+EX_A70;
if (tot==ZERO && EX_A52==' ' && EX_A57==' ' && EX_A58==' ' && !EX_A71)
continue;
// preparazione chiave quadro Abis e istanza nuovo record per scrittura
qab.zero();
qab.put("CODDITTA",cod_ditta);
qab.put("CODDIP",cod_dip);
TRectype key(qab.curr());
TRectype newrec(qab.curr());
// controllo rottura dipendente
if (key > prevkey)
{
// creo record rettifica A + valori operazioni di conguaglio
if (count_RettA)
{
long ditta_RettA = rec_RettA.get_long("CODDITTA");
long dip_RettA = rec_RettA.get_long("CODDIP");
rec_RettA.put("NPROG",++prog);
qab.write(rec_RettA);
TString log_line;
log_line.format("Unificato quadro rettifica A con rettifica B per il dipendente :%06ld, della ditta :%05ld",dip_RettA,ditta_RettA);
_M770_log->append(log_line);
// set flag quadro compilato
bb.zero();
bb.put("CODDITTA",ditta_RettA);
if (bb.read() == NOERR)
{
TString qcomp(bb.get("QCOMP"));
TString newqcomp;
newqcomp.spaces(29);
newqcomp.overwrite(qcomp,0);
newqcomp[26] = 'X';
bb.put("QCOMP",newqcomp);
bb.rewrite();
}
}
// reimposto variabili di controllo
prevkey = key;
count_RettA = 0;
count_RettB = 0;
count_RettC = 0;
count_RettX = 0;
// inizializzo record rettifica A
rec_RettA = key;
}
// reperisce ultimo progressivo assegnato
prog = 0;
for (qab.read(_isgteq); qab.good() && qab.curr() == key; qab.next())
prog = qab.get_int("NPROG");
// non posso riportare un record con rettifica C,D,E oppure F,
// se ho gi<67> riportato un qualsiasi altro record
if ((EX_A58 == 'C' || EX_A58 == 'D' || EX_A58 == 'E' || EX_A58 == 'F') && count_RettX > 0)
{
TString log_line;
log_line.format("Non riportato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
_M770_log->append(log_line);
log_line.format("- era un quadro con rettifica %c, ed erano gi<67> stati riportati altri quadri",EX_A58);
_M770_log->append(log_line);
continue;
}
// se gi<67> riportato record con rettifica C,D,E oppure F
// deve esistere solo quest'ultimo
if (count_RettC)
{
TString log_line;
log_line.format("Non riportato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
_M770_log->append(log_line);
log_line.format("- erano gi<67> stati riportati quadri C,D,E oppure F");
_M770_log->append(log_line);
continue;
}
// deve esistere un solo record con rettifica A
if (EX_A58 == 'A' && count_RettA)
{
TString log_line;
log_line.format("Non riportato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
_M770_log->append(log_line);
log_line.format("- era un quadro con rettifica %c, ed era gi<67> stato riportato un quadro A",EX_A58);
_M770_log->append(log_line);
continue;
}
// deve esistere un solo record con rettifica B
if (EX_A58 == 'B' && count_RettB)
{
TString log_line;
log_line.format("Non riportato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
_M770_log->append(log_line);
log_line.format("- era un quadro con rettifica %c, ed era gi<67> stato riportato un quadro B",EX_A58);
_M770_log->append(log_line);
continue;
}
// riporto valori su Abis
switch (EX_A58)
{
// per record con rettifica A memorizzo valori su record rettifica A
case 'A':
rec_RettA.put("CONEFF",EX_A52);// conguagli non effettuati
rec_RettA.put("IMPVERS",EX_A53);// imposta trattenuta
rec_RettA.put("INTERE",EX_A54);// interessi
rec_RettA.put("CSSN95CV",EX_A55);// contributo trattenuto
rec_RettA.put("INTERE2",EX_A56);// interessi
rec_RettA.put("CNEFF",EX_A57);// conguagli non effettuati
rec_RettA.put("RETCON",EX_A58);// rettifica conguaglio
rec_RettA.put("IMPRIMB",EX_A59);// imposta rimborsata
rec_RettA.put("IMPVER",EX_A60);// imposta trattenuta
rec_RettA.put("INTIRPEF",EX_A61);// interessi
rec_RettA.put("IMPVER2",EX_A62);// imposta trattenuta
rec_RettA.put("INTER",EX_A63);// interessi
rec_RettA.put("STSIRPEF",EX_A64);// soprattasse su Irpef
rec_RettA.put("CONRIMB",EX_A65);// contributo a rimborso
rec_RettA.put("CONVER",EX_A66);// contributo trattenuto
rec_RettA.put("INTER2",EX_A67);// interessi
rec_RettA.put("CONVER2",EX_A68);// contributo trattenuto
rec_RettA.put("INTER3",EX_A69);// interessi
rec_RettA.put("STSCSSN70",EX_A70);// soprattasse su Cssn
rec_RettA.put("M730NLIQ",EX_A71);// Mod.730 non liquidabile
break;
// per record con rettifica B memorizzo valori su record rettifica A
case 'B':
rec_RettA.put("QABRCB19",EX_A62);
rec_RettA.put("QABRCB20",EX_A63);
rec_RettA.put("QABRCB21",EX_A64);
rec_RettA.put("QABRCB22",EX_A65);
rec_RettA.put("QABRCB23",EX_A66);
rec_RettA.put("QABRCB24",EX_A67);
rec_RettA.put("QABRCB25",EX_A68);
rec_RettA.put("QABRCB26",EX_A69);
break;
// per gli altri creo record Abis
default:
newrec.put("NPROG",++prog);
newrec.put("CONEFF",EX_A52);// conguagli non effettuati
newrec.put("IMPVERS",EX_A53);// imposta trattenuta
newrec.put("INTERE",EX_A54);// interessi
newrec.put("CSSN95CV",EX_A55);// contributo trattenuto
newrec.put("INTERE2",EX_A56);// interessi
newrec.put("CNEFF",EX_A57);// conguagli non effettuati
newrec.put("RETCON",EX_A58);// rettifica conguaglio
newrec.put("IMPRIMB",EX_A59);// imposta rimborsata
newrec.put("IMPVER",EX_A60);// imposta trattenuta
newrec.put("INTIRPEF",EX_A61);// interessi
newrec.put("IMPVER2",EX_A62);// imposta trattenuta
newrec.put("INTER",EX_A63);// interessi
newrec.put("STSIRPEF",EX_A64);// soprattasse su Irpef
newrec.put("CONRIMB",EX_A65);// contributo a rimborso
newrec.put("CONVER",EX_A66);// contributo trattenuto
newrec.put("INTER2",EX_A67);// interessi
newrec.put("CONVER2",EX_A68);// contributo trattenuto
newrec.put("INTER3",EX_A69);// interessi
newrec.put("STSCSSN70",EX_A70);// soprattasse su Cssn
newrec.put("M730NLIQ",EX_A71);// Mod.730 non liquidabile
qab.write(newrec);
// set flag quadro compilato
bb.zero();
bb.put("CODDITTA",cod_ditta);
if (bb.read() == NOERR)
{
TString qcomp(29);
qcomp = bb.get("QCOMP");
qcomp[27] = 'X';
bb.put("QCOMP",qcomp);
bb.rewrite();
}
}
// aggiorno conta rettifica di conguaglio
switch (EX_A58)
{
case 'A':
++count_RettA;
++count_RettX;
break;
case 'B':
++count_RettB;
++count_RettX;
break;
case 'C':
++count_RettC;
++count_RettX;
break;
case 'D':
++count_RettC;
++count_RettX;
break;
case 'E':
++count_RettC;
++count_RettX;
break;
case 'F':
++count_RettC;
++count_RettX;
break;
default:
++count_RettX;
}
}
// fine log
_M770_log->append(log_space);
return TRUE;
}
///////////////////////////////////////////////////////////
// Conversione quadro A2 770 versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_quadroA2_971() const
{
// titolo log
char now[9];
TDate today(TODAY);
TString log_title("[Log Conversione quadro A2 : ");
log_title << today << " " << _strtime(now) << "] Prassi SpA";
_M770_log->append(log_title);
TString log_space(" ");
_M770_log->append(log_space);
// istanza file A2 e prepara chiave precedente
// per rilevamento rottura del dipendente
TLocalisamfile qa2(LF_QUAA2);
qa2.setkey(1);
qa2.zero();
TRectype prevkey(qa2.curr());
int prog = 0;
// istanza conta rettifica di conguaglio
int count_RettA = 0;
int count_RettB = 0;
int count_RettC = 0;
int count_RettX = 0;
// istanza record per scrittura rettifica A
TRectype rec_RettA(qa2.curr());
// istanza cursore per scansione quadri A2
TRelation rA2(LF_QUAA2);
TCursor cA2(&rA2);
// elaborazione quadri A2 (frizzati)
cA2.freeze();
cA2 = 0L;
TRectype& rc = cA2.curr();
TRecnotype items = cA2.items();
TProgind pi(items, "Conversione quadro A2", FALSE, TRUE, 60);
for (int i = 0; i < items; i++,++cA2)
{
pi.addstatus(1);
// lettura campi da copiare su A2
long cod_ditta = rc.get_long("CODDITTA");// codice ditta
long cod_dip = rc.get_long("CODDIP");// codice dipendente
int rigo = rc.get_int("NPROG");// progressivo rigo
char A2_9 = rc.get_char("RETCON");// rettifica conguaglio
real A2_10 = rc.get_real("SIRPEFRIMB");
real A2_11 = rc.get_real("VIRPEF");
real A2_12 = rc.get_real("INTIRPEF");
real A2_13 = rc.get_real("AIRPEFIV");
real A2_14 = rc.get_real("AIRPEFINT");
real A2_15 = rc.get_real("STASSA15");
real A2_16 = rc.get_real("CONTR16");
real A2_17 = rc.get_real("CONTRVER");
// preparazione chiave quadro A2
qa2.zero();
qa2.put("CODDITTA",cod_ditta);
qa2.put("CODDIP",cod_dip);
TRectype key(qa2.curr());
// controllo rottura dipendente
if (key > prevkey)
{
// aggiorno record rettifica A + valori operazioni di conguaglio
if (count_RettA)
{
long ditta_RettA = rec_RettA.get_long("CODDITTA");
long dip_RettA = rec_RettA.get_long("CODDIP");
qa2.rewrite(rec_RettA);
TString log_line;
log_line.format("Unificato quadro rettifica A con rettifica B per il dipendente :%06ld, della ditta :%05ld",dip_RettA,ditta_RettA);
_M770_log->append(log_line);
}
// reimposto variabili di controllo
prevkey = key;
count_RettA = 0;
count_RettB = 0;
count_RettC = 0;
count_RettX = 0;
}
// non posso riportare un record con rettifica C,D,E oppure F,
// se ho gi<67> riportato un qualsiasi altro record
if ((A2_9 == 'C' || A2_9 == 'D' || A2_9 == 'E' || A2_9 == 'F') && count_RettX > 0)
{
qa2.remove(rc);
TString log_line;
log_line.format("Eliminato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
_M770_log->append(log_line);
log_line.format("- era un quadro con rettifica %c, ed erano gi<67> presenti altri quadri",A2_9);
_M770_log->append(log_line);
continue;
}
// se gi<67> riportato record con rettifica C,D,E oppure F
// deve esistere solo quest'ultimo
if (count_RettC)
{
qa2.remove(rc);
TString log_line;
log_line.format("Eliminato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
_M770_log->append(log_line);
log_line.format("- erano gi<67> presenti quadri C,D,E oppure F");
_M770_log->append(log_line);
continue;
}
// deve esistere un solo record con rettifica A
if (A2_9 == 'A' && count_RettA)
{
qa2.remove(rc);
TString log_line;
log_line.format("Eliminato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
_M770_log->append(log_line);
log_line.format("- era un quadro con rettifica %c, ed era gi<67> presente un quadro A",A2_9);
_M770_log->append(log_line);
continue;
}
// deve esistere un solo record con rettifica B
if (A2_9 == 'B' && count_RettB)
{
qa2.remove(rc);
TString log_line;
log_line.format("Eliminato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
_M770_log->append(log_line);
log_line.format("- era un quadro con rettifica %c, ed era gi<67> presente un quadro B",A2_9);
_M770_log->append(log_line);
continue;
}
// riporto valori su A2
switch (A2_9)
{
// per record con rettifica A memorizzo valori su record rettifica A
case 'A':
rec_RettA = rc;
break;
// per record con rettifica B memorizzo valori su record rettifica A
// ed elimino il record
case 'B':
rec_RettA.put("QA2RCB10",A2_10);
rec_RettA.put("QA2RCB11",A2_11);
rec_RettA.put("QA2RCB12",A2_12);
rec_RettA.put("QA2RCB13",A2_13);
rec_RettA.put("QA2RCB14",A2_14);
rec_RettA.put("QA2RCB15",A2_15);
rec_RettA.put("QA2RCB16",A2_16);
rec_RettA.put("QA2RCB17",A2_17);
qa2.remove(rc);
break;
// per gli altri non f<> nulla
default:
break;
}
// aggiorno conta rettifica di conguaglio
switch (A2_9)
{
case 'A':
++count_RettA;
++count_RettX;
break;
case 'B':
++count_RettB;
++count_RettX;
break;
case 'C':
++count_RettC;
++count_RettX;
break;
case 'D':
++count_RettC;
++count_RettX;
break;
case 'E':
++count_RettC;
++count_RettX;
break;
case 'F':
++count_RettC;
++count_RettX;
break;
default:
++count_RettX;
}
}
// fine log
_M770_log->append(log_space);
return TRUE;
}
///////////////////////////////////////////////////////////
// Conversione basebis 770 versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_basebis_971() const
{
// titolo log
char now[9];
TDate today(TODAY);
TString log_title("[Log Conversione base : ");
log_title << today << " " << _strtime(now) << "] Prassi SpA";
_M770_log->append(log_title);
TString log_space(" ");
_M770_log->append(log_space);
TLocalisamfile bb(LF_BASEBIS);
TProgind pi(bb.items(), "Conversione modello base", FALSE, TRUE, 60);
for (bb.first(); bb.good(); bb.next())
{
pi.addstatus(1);
// lettura campi soggetti a modifica
TString qcomp = bb.get("QCOMP");
// sistemazione flag quadri compilati come flag quadri inviati/ricevuti
const int Lpos = 19;
TString newqcomp;
newqcomp.spaces(29);
int nchar = qcomp.len() < Lpos ? qcomp.len() : Lpos;
for (int i=0; i<nchar; i++)
newqcomp[i] = qcomp[i];
for (i=Lpos; i<qcomp.len(); i++)
if ((i+1)<newqcomp.len())
newqcomp[i+1] = qcomp[i];
// update campi modificati
bb.put("QCOMP",newqcomp);// flag quadri compilati
// riscrittura record
bb.rewrite();
}
// fine log
_M770_log->append(log_space);
return TRUE;
}
///////////////////////////////////////////////////////////
// Programma di conversione archivi 770
///////////////////////////////////////////////////////////
int main(int argc,char** argv)
{
const int r = (argc > 1) ? abs(atoi(argv[1])) : -1;
if (r < 0 || r > 6)
{
error_box(usage);
exit(1);
}
else
{
const int f = (argc > 2) ? atoi(argv[2]) : -1;
if (f == 0)
{
TConvert_app a(r) ;
a.run(argc, argv, "Conversione archivi 770");
}
else
exit(0);
}
return 0;
}
Reference in New Issue Copy Permalink