root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/m770/77cnv.cpp
alex 96f33c01ee Patch level : 4.0 979 
Files correlati     : ve6.exe
Ricompilazione Demo : [ ]
Commento            :

Riportata la versione 3.1 patch 979


git-svn-id: svn://10.65.10.50/trunk@15623 c028cbd2-c16b-5b4b-a496-9718f37d4682
2007-09-17 15:33:04 +00:00

2347 lines
74 KiB
C++
Executable File
Raw Blame History

#include <incstr.h>
#include <applicat.h>
#include <mask.h>
#include <progind.h>
#include <recarray.h>
#include <relation.h>
#include <sheet.h>
#include <tabutil.h>
#include <text.h>
#include <utility.h>
#include "quadrif.h"
#include "quadroe2.h"
#include "quadrog.h"
#include "quadrogp.h"
#include "77cnva.h"
#define usage "Errore - uso : 77cnv [0|1|2|3|4|5|6|7|8|9] 0"
#define G_DUMP "quadrog.dmp" // File di scarico del quadro G
#define CNV_LOG "C770log.txt" // File di log della conversione
// struttura completa riga di pagamento
struct Pag_struct
{
TDate datapag;
real imponibile;
real perc;
real ritenuta;
real compenso;
real netto;
long numvers;
real spesa;
real ctssnperc;
real ctssncomp;
real ritlorda;
real controbb;
real detfamil;
real detlavdip;
real totdet;
int giolavdip;
real impcpa;
real somregconv;
real alqimp10;
TString16 cod10;
real utpagati;
real utspett;
real ritutpag;
real ritutspe;
real nquote;
real somnsrit;
real ammlordo;
real quotaprov;
real impnetto;
real comnetto;
};
// posizione flag quadri compilati
enum {A,A1,A2,A3,B,B1,C,D,D1,E,E1,E2,F,F1,F2,G,G1,H,I,L,N,P,Q,R,S,T,AB,DB,U};
// Items per causale quadro D
const int NUM_ITEMS_D = 1;
const char* ITEMS_D[] = {
"L|prestaz. di lavoro autonomo non esercitate abitualmente"};
// Items per causale quadro Dbis
const int NUM_ITEMS_DB = 2;
const char* ITEMS_DB[] = {
"A|prestaz. di lav. auton. ..... iscritti in albi senza cassa",
"T|altro titolo diverso dai precedenti"};
// Items per causale quadro E
const int NUM_ITEMS_E = 5;
const char* ITEMS_E[] = {
"A|redditi di capitale corrisp. a sogg. resid. non eserc......",
"B|prov. corrisp. a stabili organiz. estere di impr. resid....",
"C|comp. per avviamento commerc. assogg. alla rit. a tit. acc.",
"D|contrib. degli enti pubbl. e premi corrisp. dall'Unione....",
"E|interessi, premi e altri frutti dei tit. obbligaz. emessi.."};
// Items per causale quadro E1
const int NUM_ITEMS_E1 = 4;
const char* ITEMS_E1[] = {
"A|somme deriv. dal riscatto di contratti di assic. sulla vita",
"B|capitali corrisp. in dipend... per i quali rit. del 12,50..",
"C|capitali corrisp. in dipend. di contr. di assic. sulla vita",
"D|capitali corrisp. in dipend. di contr. di capitalizzazione"};
class TConvert_app : public TApplication
{
int _conv;
TTextfile* _M770_log;
protected:
virtual bool create();
bool dump_quadro_f1() const; // Funzioni per convertire quadro F/F1
bool load_quadro_f1() const;
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
bool cnv_schede_971() const; // conversione schede percipiente
bool cnv_schede_man1_971() const; // conversione manuale schede percipiente
bool cnv_schede_man2_971() const; // conversione manuale schede percipiente
// azzera struttura pagamento
Pag_struct& clear_struct(Pag_struct& s) const;
// calcola una riga di pagamento dove <s> <20> la struttura con i dati,
// <c> <20> la struttura con i calcolati per eventuali controlli,
// <force> consente di forzare la sostituzione dei valori di riga
// con i calcolati anche se sono diversi da zero
Pag_struct& calcola_riga_pag(Pag_struct& s,
Pag_struct& c,
bool force,
const real h_PercAssImp,
const real h_PercCassaPrev,
const real h_PercRitenuta,
const real h_PercInps,
const real h_PercAssImpInps,
const real h_PercCommitInps) const;
// costruisce sheet con schede aventi prerequisiti di conversione
bool choicesheet(const long codditta, const TString& codcaus, const TString& codqua, const TString& causqua) const;
// handler maschera principale conversione cnv_schede_man2_971
static bool F_CODCAUS_handler(TMask_field& f, KEY k);
// ricalcolo complessivo schede
void totalrecalc() const;
public:
TConvert_app(int conv) : _conv(conv) { }
virtual ~TConvert_app() { }
};
inline TConvert_app& app() { return (TConvert_app&) main_app(); }
bool TConvert_app::create()
{
const long f = (argc() > 2) ? atol(argv(2)) : -1;
if (f != 0)
return FALSE;
// 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 2 : cnv_schede_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
case 7 : cnv_schede_man1_971(); break;
case 8 : cnv_schede_man2_971(); break;
case 9 : dump_quadro_f1(); break;
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(QE2_CODCAUS));
cur.put(QE2_DENCAUS, desc.left(50));
int ee = righe_e2.rewrite();
if (ee != NOERR)
{
const long ditta = cur.get_long(QE2_CODDITTA);
const int riga = cur.get_int(QE2_NPROG);
error_box("Impossibile aggiornare la riga %d del quadro E2\n"
"della ditta %ld: errore %d", riga, ditta, ee);
}
}
return TRUE;
}
bool TConvert_app::dump_quadro_f1() const
{
TToken_string str;
TLocalisamfile quadrof1(LF_QUAF1);
TFilename f; f.tempdir(); f.add("quaf1.txt");
ofstream ofs(f);
TProgind pi(quadrof1.items(), "Conversione quadro F1 - Scarico dati in corso...", FALSE, TRUE, 60);
for (int err = quadrof1.first(); err == NOERR; err = quadrof1.next())
{
pi.addstatus(1);
str.cut(0);
str.add(quadrof1.get("CODDITTA"));
str.add(quadrof1.get("F1_A1"));
str.add(quadrof1.get("F1_A2"));
ofs << str << endl;
}
return TRUE;
}
bool TConvert_app::load_quadro_f1() const
{
TFilename f; f.tempdir(); f.add("quaf1.txt");
if (!fexist(f))
return FALSE;
TProgind pi(1, "Conversione quadro F - Caricamento prospetto F...", FALSE, FALSE, 60);
TScanner osf(f);
TToken_string str;
TLocalisamfile righef(LF_RIGHEF);
while (osf.line().not_empty())
{
str = osf.token();
righef.zero();
long ditta = str.get_long(0);
righef.put("CODDITTA", ditta);
righef.put("TIPOPRO", "F");
righef.put("NPROG", "1");
righef.put("SOGRIT", str.get());
righef.put("ROPE", str.get());
int err = righef.write();
if (err != NOERR)
error_box("Impossibile creare la riga del prospetto F\n"
"della ditta %ld: errore %d", ditta, err);
}
remove(f);
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);
TDecoder causali("%CA7");
for (int err = quadro_f.first(); err == NOERR; err = quadro_f.next())
{
pi.addstatus(1);
const real e_aliq = quadro_f.get("E_ALIQUOTA");
if (e_aliq < 0.0)
{
// gia' stata convertita!
continue;
}
const long ditta = quadro_f.get_long(QUF_CODDITTA);
cur.zero();
cur.put(QUF_CODDITTA, ditta);
for (int e = righe_f.read(_isgteq); e == NOERR; e = righe_f.next())
{
if (cur.get_long(QUF_CODDITTA) != ditta)
break;
const TString& desc = causali.decode(cur.get("CODCAUS"));
cur.put("DENCAUS", desc.left(50));
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();
}
// Carica nel prospetto f le testate del vecchio quadro f1
// Vale per tutte le ditte contemporaneamente
load_quadro_f1();
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.left(50));
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
real Perc_Inps = ca7.get_real("R1");// percentuale contributo Inps
real Perc_Comm_Inps = ca7.get_real("R3");// percentuale contributo Inps committente
// salvo flag Inps per sapere se pulire i campi ad esso legato
bool old_fl_Inps = fl_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;
break;
case 'N':
cod_qua = "DB";
caus_DB = 'F';
caus_D = ' ';
fl_Inps = TRUE;
break;
case 'B':
cod_qua = "DB";
caus_DB = 'B';
caus_D = ' ';
fl_Inps = TRUE;
break;
case 'C':
cod_qua = "DB";
caus_DB = 'C';
caus_D = ' ';
fl_Inps = TRUE;
break;
case 'D':
cod_qua = "DB";
caus_DB = 'D';
caus_D = ' ';
fl_Inps = TRUE;
break;
default:
if (fl_Inps && cod_qua == "D")
{
TString log_line;
log_line << old_cod << ": ";
log_line << "causale quadro D: -senza causale";
log_line << "- con flag contributo Inps";
_M770_log->append(log_line);
}
break;
}
// conversione causale quadro D1
switch(caus_D1)
{
case 'F':
cod_qua = "DB";
caus_DB = 'G';
caus_D1 = ' ';
fl_Inps = TRUE;
break;
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
if (fl_Inps)
{
TString log_line;
log_line << old_cod << ": ";
log_line << "causale quadro D1: -" << caus_D1;
log_line << "- con flag contributo Inps";
_M770_log->append(log_line);
}
break;
default:
if (fl_Inps && cod_qua == "D1")
{
TString log_line;
log_line << old_cod << ": ";
log_line << "causale quadro D1: -senza causale";
log_line << "- con flag contributo Inps";
_M770_log->append(log_line);
}
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);
}
// reset campi contributo Inps se disattivati
if (!old_fl_Inps)
{
ass_imp_Inps = ZERO;
Perc_Inps = ZERO;
Perc_Comm_Inps = ZERO;
}
// 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
ca7.put("R1",Perc_Inps);// percentuale contributo Inps
ca7.put("R3",Perc_Comm_Inps);// percentuale contributo Inps committente
// 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[(int)AB] = '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);
TLocalisamfile ql(LF_QUAL);
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
long codditta = bb.get_long("CODDITTA");
TString qcomp = bb.get("QCOMP");
// sistemazione flag quadri compilati come flag quadri inviati/ricevuti
const int Lpos = L;
TString newqcomp;
newqcomp.spaces(29);
int nchar = qcomp.len() < Lpos ? qcomp.len() : Lpos;
int i;
for (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];
// set flag quadro L compilato
ql.zero();
ql.put("CODDITTA",codditta);
ql.put("QLAP",1996);
TRectype& currec = ql.curr();
TRectype keyrec = currec;
if (ql.read(_isgteq) == NOERR && currec == keyrec)
newqcomp[(int)L] = 'X';
// update campi modificati
bb.put("QCOMP",newqcomp);// flag quadri compilati
// riscrittura record
bb.rewrite();
}
// fine log
_M770_log->append(log_space);
return TRUE;
}
///////////////////////////////////////////////////////////
// Conversione schede percipienti versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_schede_971() const
{
// titolo log
char now[9];
TDate today(TODAY);
TString log_title("[Log Conversione schede percipienti : ");
log_title << today << " " << _strtime(now) << "] Prassi SpA";
_M770_log->append(log_title);
TString log_space(" ");
_M770_log->append(log_space);
TLocalisamfile sch(LF_SCPERC);
TLocalisamfile pag(LF_RPAG);
TLocalisamfile ver(LF_RVER);
TTable ca7("%ca7");
TProgind pi(sch.items(), "Conversione Schede Percipienti", FALSE, TRUE, 60);
for (sch.first(); sch.good(); sch.next())
{
pi.addstatus(1);
// lettura campi soggetti a modifica
long codditta = sch.get_long("CODDITTA");
TString16 tipoa = sch.get("TIPOA");
long codanagr = sch.get_long("CODANAGR");
int nprog = sch.get_int("NPROG");
TString16 codcaus = sch.get("CODCAUS");
TString16 causqua = sch.get("CAUSQUA");
TString16 flagts = sch.get("FLAGTS");
real ritope = sch.get_real("RITOPE");
real ritver = sch.get_real("RITVER");
// decodifica valori da tabella causali
TString16 t_quadro = "";
TString16 t_causqc = "";
TString16 t_causqd = "";
TString16 t_causqdb = "";
TString16 t_causqd1 = "";
TString16 t_causqe = "";
TString16 t_causqe1 = "";
TString16 t_flagts = "";
real t_PercRit = ZERO;
real t_PercInps = ZERO;
real t_PercAssInps = ZERO;
real t_PercComInps = ZERO;
real t_PercAssImp = ZERO;
real t_PercCassaPrev = ZERO;
bool t_FlagInps = FALSE;
ca7.zero();
ca7.put("CODTAB", codcaus);
if (ca7.read() == NOERR)
{
t_quadro = ca7.get("S1");
t_causqc = ca7.get("S6");
t_causqd = ca7.get("S2");
t_causqdb = ca7.get("S7");
t_causqd1 = ca7.get("S3");
t_causqe = ca7.get("S8");
t_causqe1 = ca7.get("S9");
t_flagts = ca7.get("S4");
t_PercRit = ca7.get_real("R0");
t_PercInps = ca7.get_real("R1");
t_PercAssInps = ca7.get_real("R2");
t_PercComInps = ca7.get_real("R3");
t_PercAssImp = ca7.get_real("R4");
t_PercCassaPrev = ca7.get_real("R5");
t_FlagInps = ca7.get_bool("B4");
}
// conversione pagamenti collegati
pag.zero();
pag.put("CODDITTA", codditta);
pag.put("TIPOA", tipoa);
pag.put("CODANAGR", codanagr);
pag.put("NPROG", nprog);
TRectype& rec = pag.curr();
TRectype keypag = rec;
// azzero totali da riportare su scheda
ritope = ZERO;
// elaborazione pagamenti della scheda
for (pag.read(_isgteq); pag.good() && rec == keypag; pag.next())
{
// elimina pagamenti di quadro diverso da C,D,DB,D1,E,E1,G
if (t_quadro != "C" && t_quadro != "D" && t_quadro != "DB" && t_quadro != "D1" &&
t_quadro != "E" && t_quadro != "E1" && t_quadro != "G")
{
pag.remove();
continue;
}
// lettura campi soggetti a modifica
Pag_struct s;
s.datapag = rec.get_date("DATAPAG");
s.imponibile = rec.get_real("IMPONIBILE");
s.perc = rec.get_real("PERC");
s.ritenuta = rec.get_real("RITENUTA");
s.compenso = rec.get_real("COMPENSO");
s.netto = rec.get_real("NETTO");
s.numvers = rec.get_long("NUMVERS");
s.spesa = rec.get_real("SPESA");
s.ctssnperc = rec.get_real("CTSSNPERC");
s.ctssncomp = rec.get_real("CTSSNCOMP");
s.ritlorda = rec.get_real("RITLORDA");
s.controbb = rec.get_real("CONTROBB");
s.detfamil = rec.get_real("DETFAMIL");
s.detlavdip = rec.get_real("DETLAVDIP");
s.totdet = rec.get_real("TOTDET");
s.giolavdip = rec.get_int("GIOLAVDIP");
s.impcpa = rec.get_real("IMPCPA");
s.somregconv = rec.get_real("SOMREGCONV");
s.alqimp10 = rec.get_real("ALQIMP10");
s.cod10 = rec.get("COD10");
s.utpagati = rec.get_real("UTPAGATI");
s.utspett = rec.get_real("UTSPETT");
s.ritutpag = rec.get_real("RITUTPAG");
s.ritutspe = rec.get_real("RITUTSPE");
s.nquote = rec.get_real("NQUOTE");
s.somnsrit = rec.get_real("SOMNSRIT");
s.ammlordo = rec.get_real("AMMLORDO");
s.quotaprov = rec.get_real("QUOTAPROV");
s.impnetto = rec.get_real("IMPNETTO");
s.comnetto = rec.get_real("COMNETTO");
// riporto contributi obbligatori
if (t_quadro == "C")
s.controbb = s.ctssnperc;
// riporto percentuale assogg.imp.Inps
if (t_quadro == "DB")
s.alqimp10 = t_PercAssInps;
// codice contributo Inps
if (t_quadro == "DB")
{
s.cod10 = "B";
if ((t_PercAssInps == 95.00 || t_PercAssInps == 100.00) && t_PercInps == 10.00)
s.cod10 = "A";
if (t_PercAssInps == ZERO || t_PercInps == ZERO)
s.cod10 = "C";
}
// azzero valori Inps per quadri che non li gestiscono
if (t_quadro != "DB")
{
s.ctssnperc = ZERO;
s.ctssncomp = ZERO;
}
// azzero spesa per quadri che non la gestiscono
if (t_quadro == "G")
s.spesa = ZERO;
// ricalcolo riga pagamento
Pag_struct c;
calcola_riga_pag(s,
c,
FALSE,
t_PercAssImp,
t_PercCassaPrev,
t_PercRit,
t_PercInps,
t_PercAssInps,
t_PercComInps);
// totalizzo ritenuta per scheda
ritope += s.ritenuta;
// forzo -1 nel numero versamento collegato se uguale a zero
// perch<63> da luogo poi a malfunzionamenti in gestione
if (s.numvers == 0L)
s.numvers = -1L;
// update campi modificati
rec.put("DATAPAG",s.datapag);
rec.put("IMPONIBILE",s.imponibile);
rec.put("PERC",s.perc);
rec.put("RITENUTA",s.ritenuta);
rec.put("COMPENSO",s.compenso);
rec.put("NETTO",s.netto);
rec.put("NUMVERS",s.numvers);
rec.put("SPESA",s.spesa);
rec.put("CTSSNPERC",s.ctssnperc);
rec.put("CTSSNCOMP",s.ctssncomp);
rec.put("RITLORDA",s.ritlorda);
rec.put("CONTROBB",s.controbb);
rec.put("DETFAMIL",s.detfamil);
rec.put("DETLAVDIP",s.detlavdip);
rec.put("TOTDET",s.totdet);
rec.put("GIOLAVDIP",s.giolavdip);
rec.put("IMPCPA",s.impcpa);
rec.put("SOMREGCONV",s.somregconv);
rec.put("ALQIMP10",s.alqimp10);
rec.put("COD10",s.cod10);
rec.put("UTPAGATI",s.utpagati);
rec.put("UTSPETT",s.utspett);
rec.put("RITUTPAG",s.ritutpag);
rec.put("RITUTSPE",s.ritutspe);
rec.put("NQUOTE",s.nquote);
rec.put("SOMNSRIT",s.somnsrit);
rec.put("AMMLORDO",s.ammlordo);
rec.put("QUOTAPROV",s.quotaprov);
rec.put("IMPNETTO",s.impnetto);
rec.put("COMNETTO",s.comnetto);
// riscrittura record
pag.rewrite();
}
// conversione versamenti collegati
ver.zero();
ver.put("CODDITTA", codditta);
ver.put("TIPOA", tipoa);
ver.put("CODANAGR", codanagr);
ver.put("NPROG", nprog);
TRectype keyver = ver.curr();
// azzero totali da riportare su scheda
ritver =ZERO;
// elaborazione versamenti della scheda
for (ver.read(_isgteq); ver.good() && ver.curr() == keyver; ver.next())
{
// elimina versamenti di quadro diverso da C,D,DB,D1,E,E1,G
if (t_quadro != "C" && t_quadro != "D" && t_quadro != "DB" && t_quadro != "D1" &&
t_quadro != "E" && t_quadro != "E1" && t_quadro != "G")
{
ver.remove();
continue;
}
// totalizzo ritenuta per scheda
ritver += ver.get_real("RITENUTA");
}
// elimina scheda di quadro diverso da C,D,DB,D1,E,E1,G
if (t_quadro != "C" && t_quadro != "D" && t_quadro != "DB" && t_quadro != "D1" &&
t_quadro != "E" && t_quadro != "E1" && t_quadro != "G")
{
sch.remove();
TString log_line;
log_line.format("Eliminata scheda n.%04d di quadro %s per il percipiente :%s,%05ld, della ditta :%05ld",nprog,(const char*)t_quadro,(const char*)tipoa,codanagr,codditta);
_M770_log->append(log_line);
continue;
}
// riporto casuale quadro
if (t_quadro == "C")
causqua = t_causqc;
if (t_quadro == "D")
causqua = t_causqd;
if (t_quadro == "DB")
causqua = t_causqdb;
if (t_quadro == "D1")
causqua = t_causqd1;
if (t_quadro == "E")
causqua = t_causqe;
if (t_quadro == "E1")
causqua = t_causqe1;
// riporto flag TS
if (t_quadro == "C")
flagts = t_flagts;
// update campi modificati
sch.put("CAUSQUA",causqua);
sch.put("FLAGTS",flagts);
sch.put("RITOPE",ritope);
sch.put("RITVER",ritver);
// riscrittura record
sch.rewrite();
}
// fine log
_M770_log->append(log_space);
return TRUE;
}
///////////////////////////////////////////////////////////
// Conversione manuale schede percipienti versione 971
// calcolo valore CPA
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_schede_man1_971() const
{
// conferma
if (!yesno_box("Conferma calcolo automatico del CPA in Schede Percipienti?"))
return FALSE;
// titolo log
char now[9];
TDate today(TODAY);
TString log_title("[Log Conversione schede percipienti : ");
log_title << today << " " << _strtime(now) << "] Prassi SpA";
_M770_log->append(log_title);
TString log_space(" ");
_M770_log->append(log_space);
TString log_line("Eseguita conversione manuale di riporto valore CPA");
_M770_log->append(log_line);
// almeno una scheda convertita
bool one_conv = FALSE;
TLocalisamfile sch(LF_SCPERC);
TLocalisamfile pag(LF_RPAG);
TTable ca7("%ca7");
TProgind pi(sch.items(), "Riporto valore CPA delle schede percipienti", FALSE, TRUE, 60);
for (sch.first(); sch.good(); sch.next())
{
pi.addstatus(1);
// lettura campi soggetti a modifica
long codditta = sch.get_long("CODDITTA");
TString16 tipoa = sch.get("TIPOA");
long codanagr = sch.get_long("CODANAGR");
int nprog = sch.get_int("NPROG");
TString16 codcaus = sch.get("CODCAUS");
// decodifica valori da tabella causali
TString16 t_quadro = "";
real t_PercCassaPrev = ZERO;
ca7.zero();
ca7.put("CODTAB", codcaus);
if (ca7.read() == NOERR)
{
t_quadro = ca7.get("S1");
t_PercCassaPrev = ca7.get_real("R5");
}
// conversione pagamenti collegati
pag.zero();
pag.put("CODDITTA", codditta);
pag.put("TIPOA", tipoa);
pag.put("CODANAGR", codanagr);
pag.put("NPROG", nprog);
TRectype& rec = pag.curr();
TRectype keypag = rec;
// elaborazione pagamenti della scheda
for (pag.read(_isgteq); pag.good() && rec == keypag; pag.next())
{
// lettura campi soggetti a modifica
Pag_struct s;
s.compenso = rec.get_real("COMPENSO");
s.impcpa = rec.get_real("IMPCPA");
// calcolo CPA
real c_impcpa = (s.compenso * t_PercCassaPrev) / (100.00 + t_PercCassaPrev);
c_impcpa.round();
if (s.impcpa == ZERO)
{
s.impcpa = c_impcpa;
one_conv = TRUE;
}
// update campi modificati
rec.put("IMPCPA",s.impcpa);
// riscrittura record
pag.rewrite();
}
}
// ricalcolo totale schede
if (one_conv)
totalrecalc();
// fine log
_M770_log->append(log_space);
return TRUE;
}
///////////////////////////////////////////////////////////
// Conversione manuale schede percipienti versione 971
// modifica causali in schede percipienti
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_schede_man2_971() const
{
// titolo log
char now[9];
TDate today(TODAY);
TString log_title("[Log Conversione schede percipienti : ");
log_title << today << " " << _strtime(now) << "] Prassi SpA";
_M770_log->append(log_title);
TString log_space(" ");
_M770_log->append(log_space);
// almeno una scheda convertita
bool one_conv = FALSE;
// istanza maschera principale
TMask mainmsk("77cnva.msk");
mainmsk.set_handler(F_CODCAUS, F_CODCAUS_handler);
// prima escuzione maschera principale
mainmsk.open_modal();
KEY tasto = mainmsk.run();
// gestione maschera principale
while (tasto != K_ESC)
{
// gestione schede convertibili
if (choicesheet(mainmsk.get_long(F_CODDITTA), mainmsk.get(F_CODCAUS), mainmsk.get(F_CODQUA), mainmsk.get(F_CAUSQUA)))
one_conv = TRUE;
// riesecuzione maschera
tasto = mainmsk.run();
}
// chiusura maschera principale
mainmsk.close_modal();
// ricalcolo totale schede
if (one_conv)
totalrecalc();
// fine log
_M770_log->append(log_space);
return TRUE;
}
Pag_struct& TConvert_app::clear_struct(Pag_struct& s) const
{
s.datapag = NULLDATE;
s.imponibile = ZERO;
s.perc = ZERO;
s.ritenuta = ZERO;
s.compenso = ZERO;
s.netto = ZERO;
s.numvers = -1L;
s.spesa = ZERO;
s.ctssnperc = ZERO;
s.ctssncomp = ZERO;
s.ritlorda = ZERO;
s.controbb = ZERO;
s.detfamil = ZERO;
s.detlavdip = ZERO;
s.totdet = ZERO;
s.giolavdip = 0;
s.impcpa = ZERO;
s.somregconv = ZERO;
s.alqimp10 = ZERO;
s.cod10 = "";
s.utpagati = ZERO;
s.utspett = ZERO;
s.ritutpag = ZERO;
s.ritutspe = ZERO;
s.nquote = ZERO;
s.somnsrit = ZERO;
s.ammlordo = ZERO;
s.quotaprov = ZERO;
s.impnetto = ZERO;
s.comnetto = ZERO;
return s;
}
Pag_struct& TConvert_app::calcola_riga_pag(Pag_struct& s,
Pag_struct& c,
bool force,
const real h_PercAssImp,
const real h_PercCassaPrev,
const real h_PercRitenuta,
const real h_PercInps,
const real h_PercAssImpInps,
const real h_PercCommitInps) const
{
// azzera struttura di valori calcolati
clear_struct(c);
// calcolo imponibile
c.imponibile = ((s.compenso - s.impcpa) * h_PercAssImp) / 100.00;
c.imponibile.round();
if (s.imponibile == ZERO || force)
s.imponibile = c.imponibile;
// percentuale ritenuta acconto
if (s.perc == ZERO || force)
s.perc = h_PercRitenuta;
// calcolo ritenuta lorda
c.ritlorda = (s.imponibile * s.perc) / 100.00;
c.ritlorda.round();
s.ritlorda = c.ritlorda;
// calcolo totale detrazioni
c.totdet = s.detfamil + s.detlavdip;
if (c.totdet > s.ritlorda)
c.totdet = s.ritlorda;
s.totdet = c.totdet;
// calcolo ritenuta
c.ritenuta = s.ritlorda - s.totdet;
if (s.ritenuta == ZERO || force)
s.ritenuta = c.ritenuta;
// percentuale assoggettamento Inps
if (s.alqimp10 == ZERO || force)
s.alqimp10 = h_PercAssImpInps;
// calcolo contributo Inps complessivo
c.ctssncomp = (((s.compenso * s.alqimp10) / 100.00) * h_PercInps) / 100.00;
c.ctssncomp.round();
if (s.ctssncomp == ZERO || force)
s.ctssncomp = c.ctssncomp;
// calcolo contributo Inps del percipiente
if (h_PercCommitInps == ZERO)
c.ctssnperc = s.ctssncomp - ((s.ctssncomp * 2) / 3);
else
c.ctssnperc = s.ctssncomp - ((s.ctssncomp * h_PercCommitInps) / 100.00);
c.ctssnperc.round();
if (s.ctssnperc == ZERO || force)
s.ctssnperc = c.ctssnperc;
// calcolo utili pagati
c.utpagati = s.imponibile;
if (s.utpagati == ZERO || force)
s.utpagati = c.utpagati;
if (abs(s.utpagati) > abs(s.imponibile))
s.utpagati = s.imponibile;
// calcolo ritenute utili pagati
c.ritutpag = (s.utpagati * s.perc) / 100.00;
c.ritutpag.round();
if (s.ritutpag == ZERO || force)
s.ritutpag = c.ritutpag;
if (abs(s.ritutpag) > abs(s.ritenuta))
s.ritutpag = s.ritenuta;
// calcolo utili spettanti
s.utspett = s.imponibile - s.utpagati;
// calcolo ritenute utili spettanti
s.ritutspe = s.ritenuta - s.ritutpag;
// calcolo compenso netto
s.netto = s.compenso + s.spesa - s.ritenuta - s.ctssnperc;
// calcolo somme non soggette a ritenuta
s.somnsrit = s.compenso - s.imponibile + s.spesa - s.impcpa - s.somregconv;
// calcolo ammontare lordo
s.ammlordo = s.imponibile + s.somnsrit + s.controbb + s.somregconv;
// calcolo quota provvigioni
s.quotaprov = s.somnsrit - s.spesa;
// calcolo imponibile al netto delle ritenute
s.impnetto = s.imponibile - s.ritenuta;
// calcolo compenso al netto delle ritenute
s.comnetto = s.compenso - s.ritenuta;
return s;
}
///////////////////////////////////////////////////////////
// Conversione manuale schede percipienti versione 971
// modifica causali in schede percipienti
// Costruisce ed esegue sheet con schede selezionabili
///////////////////////////////////////////////////////////
bool TConvert_app::choicesheet(const long codditta, const TString& codcaus, const TString& codqua, const TString& causqua) const
{
// almeno una scheda convertita
bool one_conv = FALSE;
// istanza relation
TRelation* rel = new TRelation(LF_SCPERC);
rel->add(LF_ANAG, "TIPOA=TIPOA|CODANAGR=CODANAGR");
rel->add("%CA7", "CODTAB=CODCAUS", 1, LF_SCPERC, 101);
// costruisce range per cursor
TRectype fromto = rel->curr();
fromto.zero();
fromto.put("CODDITTA", codditta);
// costruisce espressione filtro per cursor
TString exprfilter;
if (codqua == "DB" && causqua == "A")
exprfilter = "(101@->S1==\"D\") && (CAUSQUA==\"A\")";
if (codqua == "DB" && causqua == "T")
exprfilter = "(101@->S1==\"D\") && (CAUSQUA== \"T\")";
if (codqua == "D" && causqua == "L")
exprfilter = "(101@->S1==\"D\") && (CAUSQUA== \"T\")";
if (codqua == "E" || codqua == "E1")
exprfilter.format("(101@->S1==\"%s\")", (const char*)codqua);
// istanza cursor
TCursor* cur = new TCursor(rel, "", 1, &fromto, &fromto);
// attiva espressione filtro + update (perch<63> uso campi non del file principale)
cur->setfilter(exprfilter, TRUE);
// caption dello sheet
TString caption = "Schede percipienti convertibili";
// intestazione colonne dello sheet
TString head = "@1|";
head << "Percipiente@30|";
head << "Data docum.@R|";
head << "N<EFBFBD>docum.|";
head << "Quadro|";
head << "Caus.|";
head << "Rit.operate@15@R|";
head << "Rit.versate@15@R|";
head << "Tipo|";
head << "Codice@R|";
head << "Scheda@R|";
// colonne dello sheet
TString columns = " |";
columns << LF_ANAG << "->RAGSOC|";
columns << "DATADOC|";
columns << "NUMDOC|";
columns << "101@->S1|";
columns << "CAUSQUA|";
columns << "RITOPE|";
columns << "RITVER|";
columns << "TIPOA|";
columns << "CODANAGR|";
columns << "NPROG";
// istanza cursor sheet
TCursor_sheet* she = new TCursor_sheet(cur, columns, caption, head, 0, 3);
// esecuzione sheet
KEY retkey = she->run();
// conversione schede selezionate
if (retkey == K_ENTER && she->one_checked())
{
TString log_line;
log_line.format("Eseguita conversione manuale di modifica causale, ditta:%05ld, nuova causale:%s, causale quadro:%s", codditta, (const char*)codcaus, (const char*)causqua);
_M770_log->append(log_line);
TLocalisamfile& scperc = cur->file();
TLocalisamfile pag(LF_RPAG);
long items = she->items();
// scansione schede convertibili
for (long i=0; i<items; i++)
if (she->checked(i))
{
// modifica valori su scheda selezionata
TToken_string& t = she->row(i);
TString16 tipoa = t.get(8);
long codanagr = t.get_long(9);
int nprog = t.get_int(10);
scperc.zero();
scperc.put("CODDITTA", codditta);
scperc.put("TIPOA", tipoa);
scperc.put("CODANAGR", codanagr);
scperc.put("NPROG", nprog);
if (scperc.read() == NOERR)
{
log_line.format("- convertita scheda n.%04d per il percipiente :%s,%05ld",nprog,(const char*)tipoa,codanagr);
_M770_log->append(log_line);
scperc.put("CODCAUS", codcaus);
scperc.put("CAUSQUA", causqua);
scperc.rewrite();
one_conv = TRUE;
// set codice 10% nelle righe pagamento
// se causale nuova di quadro Dbis
if (codqua == "DB")
{
pag.zero();
pag.put("CODDITTA", codditta);
pag.put("TIPOA", tipoa);
pag.put("CODANAGR", codanagr);
pag.put("NPROG", nprog);
TRectype& rec = pag.curr();
TRectype keypag = rec;
for (pag.read(_isgteq); pag.good() && rec == keypag; pag.next())
{
rec.put("COD10", "C");
pag.rewrite();
}
}
}
}
}
delete she;
delete cur;
delete rel;
return one_conv;
}
///////////////////////////////////////////////////////////
// Conversione manuale schede percipienti versione 971
// modifica causali in schede percipienti
// Handler codice causale su maschera principale
///////////////////////////////////////////////////////////
bool TConvert_app::F_CODCAUS_handler(TMask_field& f, KEY k)
{
TMask& m = f.mask();
TString16 cod_qua(m.get(F_CODQUA));
// creo run-time gli items per la causale quadro
TEdit_field& f_causqua = m.efield(F_CAUSQUA);
// refernce allo sheet del campo causale quadro
TString_array& Items = f_causqua.sheet()->rows_array();
// rimuovo tutti gli items
Items.destroy();
// genero i nuovi items
if (cod_qua == "D")
for (int i=0; i<NUM_ITEMS_D; i++)
Items.add(ITEMS_D[i]);
if (cod_qua == "DB")
for (int i=0; i<NUM_ITEMS_DB; i++)
Items.add(ITEMS_DB[i]);
if (cod_qua == "E")
for (int i=0; i<NUM_ITEMS_E; i++)
Items.add(ITEMS_E[i]);
if (cod_qua == "E1")
for (int i=0; i<NUM_ITEMS_E1; i++)
Items.add(ITEMS_E1[i]);
// cose da fare solo se viene modificato il codice causale
if (f.to_check(k) && k != K_ENTER)
{
// forzo causale quadro con il valore in tabella
f_causqua.reset();
if (cod_qua == "D")
f_causqua.set(m.get(F_TABCAUSQUAD));
if (cod_qua == "DB")
f_causqua.set(m.get(F_TABCAUSQUADB));
if (cod_qua == "E")
f_causqua.set(m.get(F_TABCAUSQUAE));
if (cod_qua == "E1")
f_causqua.set(m.get(F_TABCAUSQUAE1));
}
return TRUE;
}
///////////////////////////////////////////////////////////
// Ricalcolo complessivo schede percipienti
///////////////////////////////////////////////////////////
void TConvert_app::totalrecalc() const
{
TLocalisamfile sch(LF_SCPERC);
TLocalisamfile pag(LF_RPAG);
TTable ca7("%ca7");
TProgind pi(sch.items(), "Ricalcolo Schede Percipienti", FALSE, TRUE, 60);
for (sch.first(); sch.good(); sch.next())
{
pi.addstatus(1);
// lettura campi soggetti a modifica
long codditta = sch.get_long("CODDITTA");
TString16 tipoa = sch.get("TIPOA");
long codanagr = sch.get_long("CODANAGR");
int nprog = sch.get_int("NPROG");
TString16 codcaus = sch.get("CODCAUS");
real ritope = sch.get_real("RITOPE");
// decodifica valori da tabella causali
TString16 t_quadro = "";
ca7.zero();
ca7.put("CODTAB", codcaus);
if (ca7.read() == NOERR)
t_quadro = ca7.get("S1");
// conversione pagamenti collegati
pag.zero();
pag.put("CODDITTA", codditta);
pag.put("TIPOA", tipoa);
pag.put("CODANAGR", codanagr);
pag.put("NPROG", nprog);
TRectype& rec = pag.curr();
TRectype keypag = rec;
// azzero totali da riportare su scheda
ritope = ZERO;
// elaborazione pagamenti della scheda
for (pag.read(_isgteq); pag.good() && rec == keypag; pag.next())
{
// lettura campi soggetti a modifica
Pag_struct s;
s.datapag = rec.get_date("DATAPAG");
s.imponibile = rec.get_real("IMPONIBILE");
s.perc = rec.get_real("PERC");
s.ritenuta = rec.get_real("RITENUTA");
s.compenso = rec.get_real("COMPENSO");
s.netto = rec.get_real("NETTO");
s.numvers = rec.get_long("NUMVERS");
s.spesa = rec.get_real("SPESA");
s.ctssnperc = rec.get_real("CTSSNPERC");
s.ctssncomp = rec.get_real("CTSSNCOMP");
s.ritlorda = rec.get_real("RITLORDA");
s.controbb = rec.get_real("CONTROBB");
s.detfamil = rec.get_real("DETFAMIL");
s.detlavdip = rec.get_real("DETLAVDIP");
s.totdet = rec.get_real("TOTDET");
s.giolavdip = rec.get_int("GIOLAVDIP");
s.impcpa = rec.get_real("IMPCPA");
s.somregconv = rec.get_real("SOMREGCONV");
s.alqimp10 = rec.get_real("ALQIMP10");
s.cod10 = rec.get("COD10");
s.utpagati = rec.get_real("UTPAGATI");
s.utspett = rec.get_real("UTSPETT");
s.ritutpag = rec.get_real("RITUTPAG");
s.ritutspe = rec.get_real("RITUTSPE");
s.nquote = rec.get_real("NQUOTE");
s.somnsrit = rec.get_real("SOMNSRIT");
s.ammlordo = rec.get_real("AMMLORDO");
s.quotaprov = rec.get_real("QUOTAPROV");
s.impnetto = rec.get_real("IMPNETTO");
s.comnetto = rec.get_real("COMNETTO");
// azzero CPA se quadro diverso da D
if (t_quadro != "D")
s.impcpa = ZERO;
// calcolo ritenuta lorda
s.ritlorda = (s.imponibile * s.perc) / 100.00;
s.ritlorda.round();
// calcolo totale detrazioni
s.totdet = s.detfamil + s.detlavdip;
if (s.totdet > s.ritlorda)
s.totdet = s.ritlorda;
// calcolo utili spettanti
s.utspett = s.imponibile - s.utpagati;
// calcolo ritenute utili spettanti
s.ritutspe = s.ritenuta - s.ritutpag;
// calcolo compenso netto
s.netto = s.compenso + s.spesa - s.ritenuta - s.ctssnperc;
// calcolo somme non soggette a ritenuta
s.somnsrit = s.compenso - s.imponibile + s.spesa - s.impcpa - s.somregconv;
// calcolo ammontare lordo
s.ammlordo = s.imponibile + s.somnsrit + s.controbb + s.somregconv;
// calcolo quota provvigioni
s.quotaprov = s.somnsrit - s.spesa;
// calcolo imponibile al netto delle ritenute
s.impnetto = s.imponibile - s.ritenuta;
// calcolo compenso al netto delle ritenute
s.comnetto = s.compenso - s.ritenuta;
// totalizzo ritenuta per scheda
ritope += s.ritenuta;
// update campi modificati
rec.put("NETTO",s.netto);
rec.put("RITLORDA",s.ritlorda);
rec.put("TOTDET",s.totdet);
rec.put("IMPCPA",s.impcpa);
rec.put("UTSPETT",s.utspett);
rec.put("RITUTSPE",s.ritutspe);
rec.put("SOMNSRIT",s.somnsrit);
rec.put("AMMLORDO",s.ammlordo);
rec.put("QUOTAPROV",s.quotaprov);
rec.put("IMPNETTO",s.impnetto);
rec.put("COMNETTO",s.comnetto);
// riscrittura record
pag.rewrite();
}
// update campi modificati
sch.put("RITOPE",ritope);
// riscrittura record
sch.rewrite();
}
}
///////////////////////////////////////////////////////////
// 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 <= 9)
{
TConvert_app a(r) ;
a.run(argc, argv, "Conversione archivi 770");
}
else
error_box(usage);
exit(0);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink