root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/m770/772100.cpp
villa ca0ea9529a Aggiustati include errati e stronzatine 
git-svn-id: svn://10.65.10.50/trunk@3004 c028cbd2-c16b-5b4b-a496-9718f37d4682
1996-06-17 10:04:38 +00:00

1343 lines
43 KiB
C++
Executable File
Raw Blame History

// 772100.cpp - Stampa schede percipienti
#include <mask.h>
#include <printapp.h>
#include <relation.h>
#include <config.h>
#include <tabutil.h>
#include <utility.h>
#include <sort.h>
#include <lffiles.h>
#include "scperc.h"
#include "rpag.h"
#include "rver.h"
#include <comuni.h>
#include <nditte.h>
#include <anagr.h>
#include <anafis.h>
#include "perc.h"
#include <mailbox.h>
#include <execp.h>
#include "772.h"
#include "772100.h"
#include "77lib.h"
//
// Lista modifiche
//
// 23.11.95 Nella stampa a 198 una colonna sola comprendente quote e
// spese non soggette
// 27.11.95 Scarta le schede con annodoc MAGGIORE di annodic
// 27.11.95 Se l'annopag e' successivo mette il pag. nei NON pagati e non lo stampa
// 7.12.95 Riparte da pag.1 con un nuovo percipiente
// 11. 1.96 Nel tot_comp_non_pagati somma anche i pagamenti di anni precedenti
// 11. 1.96 Scarta le schede SOLO SE non hanno NESSUN pag con annopag==annodic
// non piu' in base al loro annodoc
//
/****************************************************************************
11.1.96
Layout della stampa a 198
I numeri indicati sono gia' calcolati come parametri per set_row() e set_header()
145
80 Somme o D
Cod. 43 60 70 Totale Data 101 115 122 134 quote T C Serie Numero 183
Caus. Descrizione Data Numero Imponibili Spese Imposte Documento Pagamento Imponibili % Ritenute Compensi non sogg. C B Data ABI CAB Importo versato
3 8 24 33 41 53 65 77 90 99 112 118 130 142 155 159 168 174 186
II I__I I_15__________I I______I I_____I I_IMPONIB__II_SPESE____II_IMPOSTE__II_TOTDOC___I I______I I_IMPOPAG__I I___I I_RITPAG___II_COMPENS__II_NSOGG____I I I I______I I___I I_________I I_IMPVERS__I
157
****************************************************************************/
void calcola_non_pagate(TSchedaP& sch_corr, real& comp_npag, real& spese_npag, const int anno_in_corso);
HIDDEN TString256 tmp;
HIDDEN const int RIGHE_FOOTER = 2;
HIDDEN const char* P198_REAL_PICTURE = "############";
class TStampa_perc : public TPrintapp
{
char _liv; // Se stampa a livello di studio
int _anno_dic; // Anno dichiarazione nei paramentri utente o studio
bool _changed_perc; // flag che segnala il passaggio a nuovo perc.
struct righe_pag
{
char codq[3];
char codc[5];
char perc[7];
real totale;
real somme;
real quote;
real imp;
real rit;
real netto;
};
TRelation* _rel;
TCursor* _cur;
righe_pag* _bil;
TSort* _sort;
TVersamento_stampa _stvers;
const char* _buf;
TLocalisamfile* _nditte, *_anag, *_rpag, *_rver, *_comuni;
TString16 _section;
TConfig* _cnf;
TString _ragsocER,_indER,_civER,_capER,_dencomER,_provER,_cofiER;
TString _ragsocPE,_indPE,_civPE,_capPE,_dencomPE,_provPE,_cofiPE;
TString _dencomnscER,_provnscER,_dencomnscPE,_provnscPE;
TString _datanascER,_datanascPE,_desc_cau,_numdoc;
TDate _datadoc;
int _nprog;
int _anno,_numcarat,_codcaus,_codtrib;
long _codditta,_codanagER,_codanagPE;
char _tipoa, _tipoaER;
real _impondoc,_spesedoc,_imposdoc,_totaledoc;
real _tot_comp,_tot_fatt;
real _tot_somme_non_soggette, _tot_comp_non_pagati; // tot.delle rimanenze di un percipiente
real _compenso_dovuto, _spese_dovute; // usati per calcolare rimanenza di una scheda
bool _rifai_sort,_stampa_modulo;
int _ind,_mesecomp,_annocomp;
bool _stampa_scheda; // stampo o no la scheda corrente
bool _almeno_una_scheda; // c'e' almeno una scheda stampabile
bool init_print();
void add(TVersamento& vers);
bool find(TVersamento& vers);
protected:
virtual void on_config_change();
virtual bool user_create() ;
virtual bool user_destroy();
virtual bool set_print(int m);
virtual bool preprocess_page (int,int);
virtual bool preprocess_print(int,int);
virtual print_action postprocess_page (int,int);
virtual void preprocess_header();
public:
int stampa_vers(TVersamento_stampa& vers, int riga, const int numvers, const real& ritenpag);
void dati_erogante();
void dati_percipiente();
int stampa_dati_erog_perc();
int ricerca_causale(TString&,TString&);
void setta_righe_documento();
void setta_righe_pagamenti (TDate& datapag, const real& imponpag,const TString& percent,const real& ritenpag,const real& compenpag,const real& spesepag, const real& quotepag,int i);
void setta_righe_versamenti(char luo, char tipo, TDate& dataver, const TString& serie, const TString& numero,const real& impvers,int j);
void do_sort(const TString&,int,const real&,const real&,const real&,const real&,const real&,const real&);
void setta_righe_documento_modulo();
int setta_righe_pagamenti_modulo(TDate& datapag, const real& imponpag,const TString& percent,const real& ritenpag,const real& compenpag,const real& spesepag, const real& quotepag,int j);
int setta_righe_versamenti_modulo(char luo,char tipo,TDate& dataver,const TString&,const TString&,const real&,int);
void init_sort();
void riempi_record(const TString&,int,const real&,const real&,const real&,const real&,const real&,const real&,const real&);
void set_bil_key(righe_pag* b,const char* codq,int codc,const real& perc);
void set_bil_val(righe_pag* b, const real& totale = ZERO,const real& somme = ZERO,
const real& quote = ZERO,const real& imp = ZERO,
const real& rit = ZERO,const real& netto = ZERO);
void intestazione_riepilogo(const bool redo_header=FALSE, const int start_riga=0);
real fatture();
static bool codditta_hnd(TMask_field& f, KEY k);
// D = stampa ditta, S = stampa a livello di studio
TStampa_perc(char livello='D') : _liv(toupper(livello)) {}
};
HIDDEN TStampa_perc& app() { return (TStampa_perc&) main_app(); }
void TStampa_perc::add(TVersamento& vers)
{
_stvers.add(vers);
}
bool TStampa_perc::find(TVersamento& vers)
{
return _stvers.find(vers);
}
bool TStampa_perc::codditta_hnd(TMask_field& f, KEY k)
{
if (k == K_TAB && !(f.mask().is_running()) )
{
TString16 codditta; codditta << app()._codditta;
if (codditta != "0")
{
f.set(codditta);
f.check();
}
}
return TRUE;
}
void TStampa_perc::init_sort()
{
_sort->reset(sizeof(righe_pag));
_sort -> addsortkey ((char*)&(_bil->codq) - (char*)&(_bil->codq),2);
_sort -> addsortkey ((char*)&(_bil->codc) - (char*)&(_bil->codq),4);
_sort -> addsortkey ((char*)&(_bil->perc) - (char*)&(_bil->codq),6);
_sort -> init();
}
void TStampa_perc::set_bil_key(righe_pag* b,const char* codq,int codc,const real& perc)
{
strcpy (b->codq, codq);
sprintf(b->codc , "%4d", codc);
TString16 pp(perc.string("###,@@"));
sprintf(b->perc, "%s", (const char*)pp);
}
void TStampa_perc::set_bil_val(righe_pag* b, const real& totale,
const real& somme,const real& quote,
const real& imp,const real& rit, const real& netto)
{
b->totale = totale;
b->somme = somme;
b->quote = quote;
b->imp = imp;
b->rit = rit;
b->netto = netto;
}
void TStampa_perc::riempi_record(const TString& codq,int codc,const real& perc,
const real& totale,const real& somme,
const real& quote,const real& imp,
const real& rit,const real& netto )
{
set_bil_key(_bil, codq, codc, perc);
set_bil_val(_bil, totale, somme, quote, imp, rit, netto);
_sort->sort ((const char*) _bil);
}
void TStampa_perc::do_sort(const TString& codqua,int codcaus,const real& perc,const real& spese,
const real& quote,const real& imp,const real& rit,const real& comp)
{
real totale,netto;
netto = imp - rit;
totale = comp + spese ;
riempi_record(codqua,codcaus,perc,totale,spese,quote,imp,rit,netto);
}
int TStampa_perc::ricerca_causale(TString& desc,TString& codqua)
{
TTable ca7 ("%CA7");
TString16 dep;
int cod = 0;
ca7.zero();
dep.format("%02d", _codcaus);
ca7.put("CODTAB", dep);
if (ca7.read() == NOERR)
{
desc = ca7.get("S0");
cod = ca7.get_int("I0");
codqua = ca7.get("S1");
}
return cod;
}
bool TStampa_perc::preprocess_print(int file, int counter)
{
if (file == LF_SCPERC)
{
// _tot_comp_testata = ZERO;
// _tot_spese_testata = ZERO;
_tot_somme_non_soggette = _tot_comp_non_pagati = ZERO;
_almeno_una_scheda = FALSE;
}
return TRUE;
}
void TStampa_perc::setta_righe_documento()
{
reset_print();
TString spesedoc(20), imposdoc(20), totdoc(20), impondoc(20);
spesedoc = _spesedoc.string(P198_REAL_PICTURE);
imposdoc = _imposdoc.string(P198_REAL_PICTURE);
totdoc = _totaledoc.string(P198_REAL_PICTURE);
impondoc = _impondoc.string(P198_REAL_PICTURE);
if (_numcarat == 1)
{
set_row (1, "Documento del %10s", (const char*) _datadoc);
set_row (1, "@26gNumero@33g%-7s", (const char*) _numdoc);
set_row (1, "@41gPeriodo di competenza %2d / %4d", _mesecomp,_annocomp);
set_row (2, "Cod.");
if (_codtrib != 0)
set_row (2, "@5g%4d", _codtrib);
set_row (2, "@10g%.35s", (const char*) _desc_cau);
set_row (2, "@46gCompenso %12s", (const char*)impondoc);
set_row (2, "@69gSpese %12s", (const char*)spesedoc);
set_row (2, "@89gImposta %12s", (const char*)imposdoc);
set_row (2, "@111gTotale %12s", (const char*)totdoc);
/* set_row (2, "@46gCompenso %12r", &_impondoc);
set_row (2, "@69gSpese %12r", &_spesedoc);
set_row (2, "@89gImposta %12r", &_imposdoc);
set_row (2, "@111gTotale %12r", &_totaledoc);*/
}
else
if (_numcarat == 2)
{
reset_row(1);
set_row (1, "@0g%02d", _codcaus);
set_row (1, "@3g%4d", _codtrib);
set_row (1, "@8g%.15s", (const char*) _desc_cau);
TString16 dep(_datadoc.string(brief));
set_row (1, "@24g%8s", (const char*) dep);
set_row (1, "@33g%-7s", (const char*) _numdoc);
set_row (1, "@41g%12s", (const char*)impondoc);
set_row (1, "@53g%12s", (const char*)spesedoc);
set_row (1, "@65g%12s", (const char*)imposdoc);
set_row (1, "@77g%12s", (const char*)totdoc);
/* set_row (1, "@41g%12r", &_impondoc);
set_row (1, "@53g%12r", &_spesedoc);
set_row (1, "@65g%12r", &_imposdoc);
set_row (1, "@77g%12r", &_totaledoc); */
}
}
void TStampa_perc::setta_righe_documento_modulo()
{
reset_print();
if (_numcarat == 1)
{
set_row (1, "@18g%10s", (const char*) _datadoc);
set_row (1, "@10g%7s", (const char*) _numdoc);
set_row (1, "@42g%.29s", (const char*) _desc_cau);
set_row (1, "@74g%12r", &_impondoc);
set_row (1, "@105g%12r", &_spesedoc);
set_row (1, "@89g%12r", &_imposdoc);
set_row (3, "@14g%12r", &_totaledoc);
set_row (4, "");
}
else
if (_numcarat == 2)
{
set_row (1, "@0g%02d", _codcaus);
set_row (1, "@3g%4d", _codtrib);
set_row (1, "@8g%.15s", (const char*) _desc_cau);
TString16 dep(_datadoc.string(brief));
set_row (1, "@24g%10s", (const char*) dep);
set_row (1, "@33g%-7s", (const char*) _numdoc);
set_row (1, "@41g%12r", &_impondoc);
set_row (1, "@53g%12r", &_spesedoc);
set_row (1, "@65g%12r", &_imposdoc);
set_row (1, "@77g%12r", &_totaledoc);
}
}
void TStampa_perc::setta_righe_pagamenti(TDate& datapag,const real& imponpag,
const TString& percent,const real& ritenpag,const real& compenpag,
const real& spesepag, const real& quotepag,int i)
{
if (_numcarat == 1)
{
set_row (i, "%10s", (const char*) datapag.string());
set_row (i, "@11g%12r", &imponpag);
set_row (i, "@24g%s", (const char*)percent);
set_row (i, "@30g%12r", &ritenpag);
set_row (i, "@42g%12r", &compenpag);
set_row (i, "@54g%12r", &spesepag);
if (quotepag != ZERO)
set_row (i, "@67g%12r", &quotepag);
}
else
if (_numcarat == 2)
{
TString16 dep(datapag.string(brief));
real quotepag198 = ZERO;
set_row (i, "@90g%8s", (const char*) dep);
set_row (i, "@99g%12r", &imponpag);
set_row (i, "@112g%s", (const char*)percent);
set_row (i, "@118g%12r", &ritenpag);
set_row (i, "@130g%12r", &compenpag);
// 23.11.95
// Nella stampa a 198 una colonna sola comprendente quote e spese non soggette
quotepag198 = compenpag - imponpag + spesepag;
set_row (i, "@142g%12r", &quotepag198);
}
}
int TStampa_perc::setta_righe_pagamenti_modulo(TDate& datapag,const real& imponpag,
const TString& percent,const real& ritenpag,const real& compenpag,
const real& spesepag, const real& quotepag,int i)
{
if (_numcarat == 1)
{
set_row (i, "@29g%10s", (const char*) datapag.string());
i += 2;
set_row (i, "@56g%s", (const char*)percent);
}
else
if (_numcarat == 2)
{
TString16 dep(datapag.string(brief));
real quotepag198 = ZERO;
set_row (i, "@89g%8s", (const char*) dep);
set_row (i, "@97g%12r", &imponpag);
TString16 app (percent.left(4));
app.ltrim();
set_row (i, "@110g%s", (const char*)app);
set_row (i, "@115g%12r", &ritenpag);
set_row (i, "@127g%12r", &compenpag);
// 23.11.95
// Nella stampa a 198 una colonna sola comprendente quote e spese non soggette
quotepag198 = compenpag - imponpag + spesepag;
set_row (i, "@139g%12r", &quotepag198);
}
return i;
}
void TStampa_perc::setta_righe_versamenti(char luovers,char tipovers, TDate& dataver,
const TString& serie,const TString& numero,
const real& impvers,int j)
{
if (_numcarat == 1)
{
set_row (j, "@84g%c", luovers);
set_row (j, "@87g%c", tipovers);
set_row (j, "@91g%10s", (const char*) dataver.string());
set_row (j, "@102g%s", (const char*) serie);
set_row (j, "@108g%s", (const char*) numero);
set_row (j, "@120g%12r", &impvers);
}
else
if (_numcarat == 2)
{
set_row (j, "@155g%c", luovers);
set_row (j, "@157g%c", tipovers);
TString16 dep(dataver.string(brief));
set_row (j, "@159g%8s", (const char*) dep);
set_row (j, "@168g%5s", (const char*) serie);
set_row (j, "@174g%-11s", (const char*)numero);
set_row (j, "@186g%12r", &impvers);
}
}
int TStampa_perc::setta_righe_versamenti_modulo(char luovers,char tipovers,TDate& dataver,
const TString& serie,const TString& numero,
const real& impvers,int j)
{
if (_numcarat == 1)
{
j += 2;
set_row (j, "@80g%c", luovers);
set_row (j, "@84g%c", tipovers);
set_row (j, "@87g%10s", (const char*) dataver.string());
}
else
if (_numcarat == 2)
{
set_row (j, "@155g%c", luovers);
set_row (j, "@157g%c", tipovers);
TString dep(dataver.string(brief));
set_row (j, "@159g%8s", (const char*) dep);
set_row (j, "@168g%5s", serie);
set_row (j, "@174g%11s", numero);
set_row (j, "@186g%12r", &impvers);
}
return j;
}
int TStampa_perc::stampa_vers(TVersamento_stampa& ve, int nriga, const int numvers, const real& ritenpag)
{
TString16 serie, numero;
int j = nriga;
real vers_stampa = ZERO;
_rver->setkey(1);
_rver->zero();
_rver->put(SPR_CODDITTA, _codditta);
_rver->put(SPR_TIPOA, _tipoa);
_rver->put(SPR_CODANAGR, _codanagPE);
_rver->put(SPR_NPROG, _nprog);
_rver->put(VER_NRIGA, numvers);
if (_rver->read(_isequal) == NOERR)
{
char luovers = _rver->get(VER_LUOVERS)[0];
char tipovers = _rver->get(VER_TIPOVERS)[0];
TDate dataver(_rver->get_date(VER_DATAVERS));
serie = _rver->get(VER_SERIE);
numero = _rver->get(VER_NUMERO);
real impvers = _rver->get_real(VER_IMPVERS);
ve.set(_codditta, _tipoa, _codanagPE, _nprog, numvers, impvers);
const bool gia_visto = find(ve);
if (gia_visto)
{
real vvee = ve.importo_versato_residuo();
impvers = vvee;
}
vers_stampa = ve.vers_stampa(_rpag, numvers, impvers, ritenpag);
if (_numcarat == 1 && !_stampa_modulo)
if (j == 3)
{
set_row (j++, "@83gEstremi versamento@102gSerie@108gNumero");
set_row (j++, "@83gTC DCB@91gData@102gABI@108gCAB@121gImp.versato");
}
if (_stampa_modulo)
j = setta_righe_versamenti_modulo(luovers,tipovers,dataver,serie,numero,vers_stampa,j);
else
setta_righe_versamenti(luovers,tipovers,dataver,serie,numero,vers_stampa,j);
j += _stampa_modulo ? 2 : 1;
}
return j;
}
void calcola_non_pagate(TSchedaP& sch, real& compensi_non_pagati,
real& spese_non_pagate, const int anno_in_corso)
{
real comp, spese;
real comp_doc, spese_doc, comp_pagato, spese_pagate;
TDate data_pag;
int anno_pag;
comp = spese = ZERO;
TLocalisamfile* rpag = new TLocalisamfile(LF_RPAG);
sch.read();
// anno_doc = sch.anno_doc();
comp_doc = sch.compenso_doc();
spese_doc = sch.spese_doc();
rpag->zero();
rpag->put(PAG_CODDITTA, sch.codditta());
rpag->put(PAG_TIPOA, sch.tipoa());
rpag->put(PAG_CODANAGR, sch.codanagr());
rpag->put(PAG_NPROG, sch.nprog());
TRectype mst(rpag->curr());
for (rpag->read(_isgteq); !rpag->eof(); rpag->next())
{
if (rpag->curr() > mst) break;
comp_pagato = rpag->get_real(PAG_COMPENSO);
spese_pagate = rpag->get_real(PAG_SPESA);
data_pag = rpag->get_date(PAG_DATAPAG);
anno_pag = data_pag.year();
if (anno_pag <= anno_in_corso)
{
comp_doc -= comp_pagato;
spese_doc -= spese_pagate;
}
}
compensi_non_pagati = comp_doc;
spese_non_pagate = spese_doc;
}
bool TStampa_perc::preprocess_page(int file, int counter)
{
TString16 datapag,dataver;
TString16 codqua;
real imponpag,ritenpag,compenpag,spesepag,quotepag;
int i, rigaver, numvers, anno_doc;
bool pagato_anno_in_corso = FALSE;
if (counter)
return TRUE;
if (!_stampa_modulo)
{
if (_numcarat == 1)
i = rigaver = 3;
else
if (_numcarat == 2)
i = rigaver = 1;
}
else
i = rigaver = 1;
if (file == LF_SCPERC)
{
reset_print();
TRectype sch_curr(current_cursor()->curr(LF_SCPERC));
_tipoa = current_cursor()->curr(LF_SCPERC).get (SPR_TIPOA)[0];
_codanagPE = current_cursor()->curr(LF_SCPERC).get_long(SPR_CODANAGR);
_nprog = current_cursor()->curr(LF_SCPERC).get_int(SPR_NPROG);
_codcaus = current_cursor()->curr(LF_SCPERC).get_int (SPR_CODCAUS);
_codtrib = ricerca_causale(_desc_cau,codqua);
_datadoc = current_cursor()->curr(LF_SCPERC).get_date(SPR_DATADOC);
_numdoc = current_cursor()->curr(LF_SCPERC).get (SPR_NUMDOC);
_impondoc = current_cursor()->curr(LF_SCPERC).get_real(SPR_COMPENSO);
_spesedoc = current_cursor()->curr(LF_SCPERC).get_real(SPR_SPESE);
_imposdoc = current_cursor()->curr(LF_SCPERC).get_real(SPR_IVA);
_totaledoc = current_cursor()->curr(LF_SCPERC).get_real(SPR_TOTALE);
_mesecomp = current_cursor()->curr(LF_SCPERC).get_int (SPR_MESEC);
_annocomp = current_cursor()->curr(LF_SCPERC).get_int (SPR_ANNOC);
anno_doc = _datadoc.year();
_compenso_dovuto = _impondoc;
_spese_dovute = _spesedoc;
TSchedaP scheda(sch_curr);
bool esiste_pag_anno_in_corso = esiste_pag_in_anno(scheda, _anno_dic);
_stampa_scheda = anno_doc <= _anno_dic && esiste_pag_anno_in_corso;
TSchedaP sch_corr(_codditta, _tipoa, _codanagPE, _nprog);
if (_stampa_scheda)
{
_tot_fatt += _totaledoc;
if (_stampa_modulo)
setta_righe_documento_modulo();
else
setta_righe_documento();
_almeno_una_scheda = TRUE;
}
if (_rifai_sort)
{
init_sort();
_rifai_sort = FALSE;
}
TRectype recpag(_rpag->curr());
recpag.zero();
recpag.put(SPR_CODDITTA, _codditta);
recpag.put(SPR_TIPOA, _tipoa);
recpag.put(SPR_CODANAGR, _codanagPE);
recpag.put(SPR_NPROG, _nprog);
_rpag->setkey(1);
_rpag->zero();
_rpag->curr() = recpag;
TDate datapag;
TVersamento_stampa ve;
bool aggiorna_totali = FALSE;
for (_rpag->read(_isgteq); _rpag->good(); _rpag->next())
{
if (_rpag->curr() > recpag)
break;
datapag = _rpag->get_date(PAG_DATAPAG);
const int anno_pag = datapag.year();
compenpag = _rpag->get_real(PAG_COMPENSO);
spesepag = _rpag->get_real(PAG_SPESA);
// Aggiorna i tot. per questa scheda
if (anno_pag <= _anno_dic)
{
_compenso_dovuto -= compenpag;
_spese_dovute -= spesepag;
aggiorna_totali = TRUE;
}
// 28.11.95 Se sono di anni precedenti non li stampo
// (v. prospetto di Omero)
// 10.1.96 pero' sommo compenso e spese nei non pagati
if (anno_pag < _anno_dic)
continue;
// Non devo stampare nulla, si resta nel ciclo solo per aggiornare i totali
if (!_stampa_scheda)
continue;
pagato_anno_in_corso = anno_pag == _anno_dic;
imponpag = _rpag->get_real(PAG_IMPONIBILE);
real r_perc;
r_perc = _rpag->get_real(PAG_PERC);
TString16 st_perc(r_perc.string("###,@@"));
ritenpag = _rpag->get_real(PAG_RITENUTA);
quotepag = compenpag - imponpag;
numvers = _rpag->get_int(PAG_NUMVERS);
// 27.11.95 se l'anno e' successivo deve restare nei NON pagati
// e non si stampa
if (pagato_anno_in_corso)
{
if (_numcarat == 1 && !_stampa_modulo)
if (i == 3)
{
set_row (i++, "Data@54gSpese@67gQuote");
set_row (i++, "Pagamento@13gImponibili@27g%%@32gRitenute@45gCompensi@54gnon soggette@67gnon soggette");
}
if (_stampa_modulo)
i = setta_righe_pagamenti_modulo(datapag,imponpag,st_perc,ritenpag,compenpag,spesepag,quotepag,i);
else
setta_righe_pagamenti(datapag,imponpag,st_perc,ritenpag,compenpag,spesepag,quotepag,i);
i += _stampa_modulo ? 2 : 1;
do_sort(codqua,_codtrib,r_perc,spesepag,quotepag,imponpag,ritenpag,compenpag);
if (numvers > 0)
rigaver = stampa_vers(ve, rigaver, numvers, ritenpag);
}
} // for (rpag.. legge pagamento successivo
// Aggiorna i totali delle spese e comp. ancora da pagare
if (aggiorna_totali)
{
_tot_comp_non_pagati += _compenso_dovuto;
_tot_somme_non_soggette += _spese_dovute;
}
// Determina se questa e' l'ultima scheda di questo percipiente
current_cursor()->save_status();
++(*current_cursor());
char tipoa = current_cursor()->curr(LF_SCPERC).get_char(SPR_TIPOA);
long codanag = current_cursor()->curr(LF_SCPERC).get_long(SPR_CODANAGR);
--(*current_cursor());
current_cursor()->restore_status();
// Se e' l'ultima chiude il sort (cioe' il riepilogo)
if (_tipoa != tipoa || _codanagPE != codanag)
_sort->endsort();
}
return TRUE;
}
real TStampa_perc::fatture()
{
TLocalisamfile perc (LF_PERC);
real fatt_bil;
fatt_bil = ZERO;
perc.setkey(1);
perc.zero();
perc.put(PRC_CODDITTA, _codditta);
perc.put(PRC_TIPOA, _tipoa);
perc.put(PRC_CODANAGR, _codanagPE);
if (perc.read() == NOERR)
fatt_bil = perc.get_real(PRC_FATTBIL);
return fatt_bil;
}
print_action TStampa_perc::postprocess_page(int file, int counter)
{
char tipoa;
long codanag;
bool intesta_sort = TRUE;
if (counter)
{
printer().formfeed();
reset_print(); // per evitare che stampi di nuovo il totale prec.
// 7.12.95 Riparto da pag.1 con un nuovo percipiente
if (_changed_perc)
{
printer().setcurrentpage(1);
_changed_perc = FALSE;
}
return NEXT_PAGE;
}
if (file == LF_SCPERC)
{
if (!_stampa_scheda && !_almeno_una_scheda)
return NEXT_PAGE;
current_cursor()->save_status();
++(*current_cursor());
tipoa = current_cursor()->curr(LF_SCPERC).get_char(SPR_TIPOA);
codanag = current_cursor()->curr(LF_SCPERC).get_long(SPR_CODANAGR);
--(*current_cursor());
current_cursor()->restore_status();
_changed_perc = _tipoa != tipoa || _codanagPE != codanag;
if (_changed_perc)
{
TString16 codqua,codqua_t;
int codcau,codcau_t;
real totale,somme,quote,imp,rit,netto;
real totale_t,somme_t,quote_t,imp_t,rit_t,netto_t;
TString key(20),keyp(20);
real perc,perc_t;
_almeno_una_scheda = FALSE;
reset_print();
if (_tot_fatt != ZERO)
{
set_row (2, "@62gTotale fatturato@79g%12.0r", &_tot_fatt);
set_row (2, "@93gComprensivo d'iva");
_ind = 4;
}
else
// _ind = 2;
_ind = 3;
struct righe_pag* bil = (struct righe_pag*) _buf;
_buf = _sort->retrieve();
int righe_libbere = printer().rows_left();
if (_buf != NULL)
{
do
{
bil = (struct righe_pag*) _buf;
codqua = bil->codq;
codcau = atoi(bil->codc);
real dumb;
const char* eng_perc = dumb.ita2eng(bil->perc);
const double ppp = atof(eng_perc);
perc = ppp;
totale = bil->totale;
somme = bil->somme;
quote = bil->quote;
imp = bil->imp;
rit = bil->rit;
netto = bil->netto;
TString16 st_perc(perc.string("###,@@"));
if (!intesta_sort)
key.format("%2s%4d%s", (const char*) codqua,codcau,(const char*)st_perc);
if (intesta_sort)
{
intestazione_riepilogo();
righe_libbere -= 6;
intesta_sort = FALSE;
key.format("%2s%4d%s", (const char*) codqua,codcau,(const char*)st_perc);
keyp.format("%2s%4d%s", (const char*) codqua,codcau,(const char*)st_perc);
}
if (key == keyp)
{
codqua_t = codqua;
codcau_t = codcau;
perc_t = perc;
totale_t += totale;
somme_t += somme;
quote_t += quote;
imp_t += imp;
rit_t += rit;
netto_t += netto;
}
else
{
if (righe_libbere <= 1)
{
intestazione_riepilogo();
righe_libbere = printer().formlen() - printer().headersize();
}
set_row (_ind, "%2s", (const char*) codqua_t);
set_row (_ind, "@4g%4d", codcau_t);
TString16 st_perc_t(perc_t.string("###,@@"));
set_row (_ind, "@10g%s", (const char*) st_perc_t);
set_row (_ind, "@17g%12r", &totale_t);
set_row (_ind, "@31g%12r", &somme_t);
set_row (_ind, "@47g%12r", &quote_t);
set_row (_ind, "@63g%12r", &imp_t);
set_row (_ind, "@79g%12r", &rit_t);
set_row (_ind, "@94g%12r", &netto_t);
_ind++;
righe_libbere--;
codqua_t = codqua;
codcau_t = codcau;
perc_t = perc;
totale_t = totale;
somme_t = somme;
quote_t = quote;
imp_t = imp;
rit_t = rit;
netto_t = netto;
}
keyp = key;
_buf = _sort->retrieve();
}
while ( _buf != NULL);
}
set_row (_ind, "%2s", (const char*) codqua_t);
set_row (_ind, "@4g%4d", codcau_t);
TString16 st_perc_t(perc_t.string("###,@@"));
set_row (_ind, "@10g%s", (const char*)st_perc_t);
set_row (_ind, "@17g%12r", &totale_t);
set_row (_ind, "@31g%12r", &somme_t);
set_row (_ind, "@47g%12r", &quote_t);
set_row (_ind, "@63g%12r", &imp_t);
set_row (_ind, "@79g%12r", &rit_t);
set_row (_ind, "@94g%12r", &netto_t);
_ind++;
// Prospetto delle sommee **NON PAGATE**
// _tot_comp_non_pagati = _tot_comp_testata - _tot_comp_pagati;
// _tot_somme_non_soggette = _tot_spese_testata - _tot_spese_pagate;
real fatt_bil, totale_non_pagate;
fatt_bil = fatture();
totale_non_pagate = _tot_comp_non_pagati + _tot_somme_non_soggette;
set_row (_ind++, "");
if (fatt_bil != ZERO)
{
set_row (_ind++, "***************************");
set_row (_ind++, "*** FATTURE DA RICEVERE ***@30g%12.0r", &fatt_bil);
set_row (_ind++, "***************************");
set_row (_ind++, "");
}
set_row (_ind++, "************** Compensi@42g%12.0r@56g+", &_tot_comp_non_pagati);
set_row (_ind++, "* NON PAGATE * Somme non soggette@42g%12.0r@56g=", &_tot_somme_non_soggette);
set_row (_ind++, "**************@42g----------------");
set_row (_ind , " Totale@42g%12.0r", &totale_non_pagate);
_rifai_sort = TRUE;
_tot_comp = ZERO;
_tot_fatt = ZERO;
_tot_somme_non_soggette = _tot_comp_non_pagati = ZERO;
return REPEAT_PAGE;
}
}
return NEXT_PAGE;
}
void TStampa_perc::intestazione_riepilogo(const bool redo_header, const int start_riga)
{
TString sep(110);
if (redo_header)
{
int ind = start_riga;
sep.fill('_');
set_header (ind++, (const char*) sep);
set_header (ind++, "Q@4gCod.@31gSomme@47gQuote@95gNetto");
set_header (ind++, "D@4gCaus.@13g%%@23gTotale@31gnon soggette@47gnon soggette@65gImponibili@83gRitenute@95gcorrisposto");
set_header (ind++, (const char*) sep);
}
else
{
sep.fill('_');
set_row (_ind++, (const char*) sep);
set_row (_ind++, "Q@4gCod.@31gSomme@47gQuote@95gNetto");
set_row (_ind++, "D@4gCaus.@13g%%@23gTotale@31gnon soggette@47gnon soggette@65gImponibili@83gRitenute@95gcorrisposto");
set_row (_ind++, (const char*) sep);
}
}
void TStampa_perc::on_config_change()
{
TConfig conf(_liv == 'S' ? CONFIG_USER : CONFIG_STUDIO);
_anno_dic = (int)conf.get_long(ANNO_SEL, _section);
}
bool TStampa_perc::init_print()
{
KEY tasto;
TLocalisamfile* fl;
TMask msk ("772100a");
_changed_perc = FALSE;
printer().footerlen(RIGHE_FOOTER);
msk.set_handler (F_CODDITTA, codditta_hnd);
tasto = msk.run();
if (tasto == K_ENTER)
{
char tipoa_da = msk.get(F_TIPODA)[0];
long cod_da = msk.get_long(F_CODDA);
char tipoa_a = msk.get(F_TIPOA)[0];
long cod_a = msk.get_long(F_CODA);
_numcarat = msk.get_int (F_CARATTERE);
_stampa_modulo = msk.get_bool(F_MODULO);
//Crea il cursore su gruppo, conto e sottoconto del file RMOV
reset_files(); //resetta l'albero di stampa
add_file(LF_SCPERC);
fl = &(current_cursor()->file(LF_SCPERC));
TRectype da (fl->curr());
TRectype a (fl->curr());
da.zero();
a.zero();
da.put(SPR_CODDITTA, _codditta);
da.put(SPR_TIPOA, tipoa_da);
da.put(SPR_CODANAGR, cod_da);
a.put(SPR_CODDITTA, _codditta);
a.put(SPR_TIPOA, tipoa_a);
a.put(SPR_CODANAGR, cod_a);
current_cursor()->setregion(da, a);
_anno = _anno_dic;
dati_erogante();
_rifai_sort = TRUE;
}
return tasto == K_ENTER;
}
bool TStampa_perc::set_print(int)
{
long codditta_prec;
int i = 0;
if (_liv == 'S')
{
codditta_prec = get_firm_770();
while ((_codditta = _cnf->get_long(DITTE_SEL, _section, i++)) != 0L)
{
set_firm_770(_codditta);
// init_print ritorna TRUE solo se K_ENTER
if (init_print())
print();
else
break;
}
set_firm_770(codditta_prec);
// Non richiamare di nuovo print()!
return FALSE;
}
else
return init_print();
}
void TStampa_perc::preprocess_header()
{
int riga;
dati_percipiente();
riga = stampa_dati_erog_perc();
}
void TStampa_perc::dati_erogante()
{
TString com,comnasc;
TDate data;
_nditte->setkey(1);
_nditte->curr().zero();
_nditte->curr().put(NDT_CODDITTA, _codditta);
if (_nditte->read() == NOERR)
{
_tipoaER = _nditte->get_char(NDT_TIPOA);
_codanagER = _nditte->get_long(NDT_CODANAGR);
}
_anag->setkey(1);
_anag->zero();
_anag->put(ANA_TIPOA, _tipoaER);
_anag->put(ANA_CODANAGR, _codanagER);
if (_anag->read() == NOERR)
{
_ragsocER = _anag->get(ANA_RAGSOC);
_cofiER = _anag->get(ANA_COFI);
if (_tipoaER == 'F')
{
TString80 nome = _ragsocER.mid(30);
_ragsocER.cut(30);
_ragsocER.trim(); nome.trim();
_ragsocER << ' ' << nome;
}
com = _anag->get(ANA_COMRF);
if (com != "")
{
_indER = _anag->get(ANA_INDRF);
_civER = _anag->get(ANA_CIVRF);
_capER = _anag->get(ANA_CAPRF);
}
else
{
_indER = _anag->get(ANA_INDRES);
_civER = _anag->get(ANA_CIVRES);
_capER = _anag->get(ANA_CAPRES);
com = _anag->get(ANA_COMRES);
}
}
_comuni->setkey(1);
_comuni->zero();
_comuni->put(COM_COM,com);
if (_comuni->read() == NOERR)
{
_dencomER = _comuni->get(COM_DENCOM);
_provER = _comuni->get(COM_PROVCOM);
}
if (_tipoaER == 'F')
{
TLocalisamfile anagfis(LF_ANAGFIS);
anagfis.setkey(1);
anagfis.zero();
anagfis.put(ANF_CODANAGR, _codanagER);
if (anagfis.read() == NOERR)
{
data = anagfis.get_date(ANF_DATANASC);
_datanascER = data.string();
comnasc = anagfis.get (ANF_COMNASC);
}
_comuni->setkey(1);
_comuni->zero();
_comuni->put(COM_COM,comnasc);
if (_comuni->read() == NOERR)
{
_dencomnscER = _comuni->get(COM_DENCOM);
_provnscER = _comuni->get(COM_PROVCOM);
}
_dencomnscER.rtrim();
_provnscER.rtrim();
}
else
{
_dencomnscER = "";
_provnscER = "";
}
_indER.rtrim();
_dencomER.rtrim();
}
void TStampa_perc::dati_percipiente()
{
TString com;
TDate data;
TString comnasc;
_anag->setkey(1);
_anag->zero();
_anag->put(ANA_TIPOA, _tipoa);
_anag->put(ANA_CODANAGR, _codanagPE);
if (_anag->read() == NOERR)
{
_ragsocPE = _anag->get(ANA_RAGSOC);
_cofiPE = _anag->get(ANA_COFI);
if (_tipoa == 'F')
{
TString80 nome = _ragsocPE.mid(30);
_ragsocPE.cut(30);
_ragsocPE.trim(); nome.trim();
_ragsocPE << ' ' << nome;
}
com = _anag->get(ANA_COMRF);
if (com != "")
{
_indPE = _anag->get(ANA_INDRF);
_civPE = _anag->get(ANA_CIVRF);
_capPE = _anag->get(ANA_CAPRF);
}
else
{
_indPE = _anag->get(ANA_INDRES);
_civPE = _anag->get(ANA_CIVRES);
_capPE = _anag->get(ANA_CAPRES);
com = _anag->get(ANA_COMRES);
}
}
_comuni->setkey(1);
_comuni->zero();
_comuni->put(COM_COM,com);
if (_comuni->read() == NOERR)
{
_dencomPE = _comuni->get(COM_DENCOM);
_provPE = _comuni->get(COM_PROVCOM);
}
if (_tipoa == 'F')
{
TLocalisamfile anagfis(LF_ANAGFIS);
anagfis.setkey(1);
anagfis.zero();
anagfis.put(ANF_CODANAGR, _codanagPE);
if (anagfis.read() == NOERR)
{
data = anagfis.get_date(ANF_DATANASC);
_datanascPE = data.string();
comnasc = anagfis.get (ANF_COMNASC);
}
_comuni->setkey(1);
_comuni->zero();
_comuni->put(COM_COM,comnasc);
if (_comuni->read() == NOERR)
{
_dencomnscPE = _comuni->get(COM_DENCOM);
_provnscPE = _comuni->get(COM_PROVCOM);
}
_dencomnscPE.rtrim();
_provnscPE.rtrim();
}
else
{
_dencomnscPE = "";
_provnscPE = "";
}
_indPE.rtrim();
_dencomPE.rtrim();
}
int TStampa_perc::stampa_dati_erog_perc()
{
int riga, riga2;
TString sep(200);
reset_header();
// Dati del soggetto erogante
if (_stampa_modulo)
{
riga = 7;
set_header (riga, "@12g%4d", _anno);
sep << "@#";
sep.right_just(105);
set_header(riga,(const char*) sep);
riga += 4; // da 7 a 11
set_header (riga, "@10g%s", (const char*) _ragsocER);
riga += 3;
set_header (riga++, "@10g%s %s", (const char*) _indER, (const char*) _civER);
set_header (riga, "@10g%5s", (const char*) _capER);
set_header (riga++, "@17g%s %s", (const char*) _dencomER, (const char*) _provER);
set_header (riga++, "@10gxxx");
set_header (riga++, "@10g%-16s", (const char*) _cofiER);
}
else
{
// 7.12.95 Numeri di pagina qui!
riga = 1;
set_header (riga++, _numcarat == 1 ? "SOGGETTO EROGANTE @122gPag. @#" : "SOGGETTO EROGANTE @188gPag. @#");
set_header (riga++, "Codice@15g%5d", _codditta);
set_header (riga++, "Denominazione@15g%s", (const char*) _ragsocER);
set_header (riga++, "Domicilio in@15g%s %s", (const char*) _indER, (const char*) _civER);
set_header (riga, "@15g%5s", (const char*) _capER);
set_header (riga++, "@21g%s %s", (const char*) _dencomER, (const char*) _provER);
set_header (riga++, "Codice fiscale@15g%-16s",(const char*) _cofiER);
if (_tipoaER == 'F')
set_header (riga++, "Luogo data di nascita@22g%s %s %10s", (const char*) _dencomnscER, (const char*) _provnscER, (const char*) _datanascER);
}
// Dati del soggetto percipiente
if (_stampa_modulo)
{
set_header (11, "@65g%s", (const char*) _ragsocPE);
set_header (14, "@65g%s %s", (const char*) _indPE, (const char*) _civPE);
set_header (15, "@65g%5s", (const char*) _capPE);
set_header (15, "@72g%s %s", (const char*) _dencomPE, (const char*) _provPE);
set_header (17, "@65g%-16s",(const char*) _cofiPE);
set_header (23, "");
}
else
{
if (_numcarat == 1)
{
riga2 = 1;
set_header (riga2++, "@66gSOGGETTO PERCIPIENTE");
set_header (riga2++, "@66gCodice@81g%c %5d", _tipoa, _codanagPE);
set_header (riga2++, "@66gDenominazione@81g%s", (const char*) _ragsocPE);
set_header (riga2++, "@66gDomicilio in@81g%s %s", (const char*) _indPE, (const char*) _civPE);
set_header (riga2, "@81g%5s", (const char*) _capPE);
set_header (riga2++, "@87g%s %s", (const char*) _dencomPE, (const char*) _provPE);
set_header (riga2++, "@66gCodice fiscale@81g%-16s",(const char*) _cofiPE);
if (_tipoa == 'F')
set_header (riga2++, "@66gLuogo data di nascita@88g%s %s %s", (const char*) _dencomnscPE, (const char*) _provnscPE, (const char*) _datanascPE);
else
riga2++;
set_header (riga2++, "Conto individuale percipiente anno %4d", _anno);
TString app(132);
app.fill('_');
set_header(riga2++, (const char*) app);
}
else
if (_numcarat == 2)
{
TString app(198);
app.fill('_');
riga2=1;
set_header (riga2++, "@110gSOGGETTO PERCIPIENTE");
set_header (riga2++, "@110gCodice@125g%c %5d", _tipoa, _codanagPE);
set_header (riga2++, "@110gDenominazione@125g%s", (const char*) _ragsocPE);
set_header (riga2++, "@110gDomicilio in@125g%s %s", (const char*) _indPE, (const char*) _civPE);
set_header (riga2 /*5*/, "@125g%5s", (const char*) _capPE);
set_header (riga2++ /*5*/, "@131g%s %s", (const char*) _dencomPE, (const char*) _provPE);
set_header (riga2++, "@110gCodice fiscale@125g%-16s",(const char*) _cofiPE);
if (_tipoa == 'F')
set_header (riga2++, "@110gLuogo data di nascita@132g%s %s %s", (const char*) _dencomnscPE, (const char*) _provnscPE, (const char*) _datanascPE);
else
riga2++;
set_header (riga2++, "Conto individuale percipiente anno %4d", _anno);
set_header (riga2++, (const char*) app);
set_header (riga2++, "@50gESTREMI DOCUMENTO @101gESTREMI PAGAMENTO @145gSomme e@157gD@165gESTREMI VERSAMENTO");
set_header (riga2++, "Cod.@80gTotale@90gData@145gquote@155gT@157gC@168gSerie@174gNumero");
set_header (riga2 /*13*/, "Caus.@8gDescrizione@24gData@33gNumero@43gImponibili@60gSpese@70gImposte@80gDocumento@90gPagamento@101gImponibili@115g%%@122gRitenute");
set_header (riga2++ /*13*/, "@134gCompensi@145gnon sogg.@155gC@157gB@159gData@168gABI @174gCAB @183gImporto versato");
set_header (riga2++, (const char*) app);
}
}
// ritorna la prima riga libera
return riga > riga2 ? riga : riga2;
}
/*
// Crea l'intestazione per la stampa a 132 e a 198 caratteri
void TStampa_perc::intesta_fissa()
{
set_background();
if (_numcarat == 1)
set_background("W4l{1 10 132 10}");
else if (_numcarat == 2)
set_background("W4l{1 10 198 10} W4l{1 13 198 13}");
}
*/
bool TStampa_perc::user_create()
{
TToken_string exp;
// Parametri configurazione
_section = name();
_section.cut(2);
_cnf = new TConfig(CONFIG_USER, _section);
_rel = new TRelation (LF_SCPERC);
_cur = new TCursor(_rel,"",2);
add_cursor(_cur);
_nditte = new TLocalisamfile (LF_NDITTE);
_comuni = new TLocalisamfile (LF_COMUNI);
_anag = new TLocalisamfile (LF_ANAG);
_rpag = new TLocalisamfile (LF_RPAG);
_rver = new TLocalisamfile (LF_RVER);
_bil = new righe_pag;
_sort = new TSort();
_codditta = get_firm_770();
return TRUE;
}
bool TStampa_perc::user_destroy()
{
delete _rel;
delete _cur;
delete _nditte;
delete _anag;
delete _comuni;
delete _rpag;
delete _rver;
delete _bil;
delete _sort;
delete _cnf;
return TRUE;
}
int m72100(int argc, char* argv[])
{
TStampa_perc a(*argv[2]);
a.run(argc, argv, "Stampa schede percipienti");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink