2264 lines
55 KiB
C++
Executable File
2264 lines
55 KiB
C++
Executable File
// cg3300.cpp
|
|
// Stampa allegati iva
|
|
|
|
#include <applicat.h>
|
|
#include <mask.h>
|
|
#include <printapp.h>
|
|
#include <progind.h>
|
|
#include <sort.h>
|
|
#include <tabutil.h>
|
|
#include <utility.h>
|
|
#include <urldefid.h>
|
|
#include <validate.h>
|
|
|
|
#include <comuni.h>
|
|
#include <anagr.h>
|
|
#include <anafis.h>
|
|
#include <anagiu.h>
|
|
#include <nditte.h>
|
|
#include <alleg.h>
|
|
#include <clifo.h>
|
|
#include <mov.h>
|
|
#include <rmoviva.h>
|
|
#include <causali.h>
|
|
|
|
#include "cg3.h"
|
|
#include "cg3300.h"
|
|
|
|
#include "cg3300a.h"
|
|
#include "cg3300b.h"
|
|
|
|
#define LUNGHEZZA_FOOTER 3
|
|
#define DISTANZA_HEADER_CORPO 5
|
|
#define LUNGHEZZA_RECORD 128
|
|
|
|
const int CODTABLEN = 15;
|
|
|
|
HIDDEN const char * SEGNO_MENO = "-";
|
|
HIDDEN const char * BARRA_SESSO = "x";
|
|
|
|
class CG3300_application : public TPrintapp
|
|
{
|
|
TFile_printer * _my_file_printer;
|
|
int _records [13]; // Contatori dei vari tipi-record
|
|
int _num_volume; // numero progressivo dischetti
|
|
word _num_pag; // numero di pagine
|
|
int _num_cf; // numero di C/F
|
|
int _width_modulo; // larghezza modulo
|
|
|
|
const char * _buff; // punta al risultato di retrieve()
|
|
SortRecord * _RecordSort;
|
|
Totali * _t;
|
|
Record_B * _recb;
|
|
Array_desc_campi * _frm;
|
|
|
|
TSort* _sort;
|
|
|
|
TLocalisamfile * _nditte, * _alleg, * _clifo;
|
|
TTable * _tpd, * _attiv;
|
|
|
|
TDate _data_stampa;
|
|
TString _anno_stampa;
|
|
stampe _tipo_stampa;
|
|
modi_stampa _destinazione_stampa;
|
|
|
|
bool _tronc, _arrot, _ordina_desc, _distingui_att,
|
|
_anno_prec, _stampa_tutti, _ricalcola;
|
|
|
|
TString _ricerca_att;
|
|
TString _cod_ditta_a;
|
|
TString _cod_ditta_da;
|
|
TString _tipoa_richiesto;
|
|
|
|
int _SortRecLen;
|
|
int _cur_null;
|
|
|
|
public:
|
|
|
|
const desc_campo& campi (int i) const { return _frm->campi(i); }
|
|
int riga (int i) const { return _frm->riga(i); }
|
|
const char * formato (int i) const { return _frm->formato(i); }
|
|
|
|
virtual bool user_create () ;
|
|
virtual bool user_destroy () ;
|
|
virtual bool set_print (int);
|
|
|
|
bool set_impostazione();
|
|
bool set_ricalcola();
|
|
bool set_dischetti();
|
|
|
|
void init_sort();
|
|
virtual bool preprocess_print (int file, int counter);
|
|
virtual bool preprocess_page (int file, int counter);
|
|
|
|
virtual void preprocess_header ();
|
|
virtual void preprocess_footer ();
|
|
|
|
virtual print_action postprocess_page (int,int);
|
|
virtual print_action postprocess_print (int,int);
|
|
|
|
bool intesta ();
|
|
|
|
void tronca();
|
|
void arrotonda();
|
|
|
|
void stampa_su_disco();
|
|
void ricalcola(const char *);
|
|
void pulisci_alleg(TLocalisamfile *);
|
|
|
|
void stampa_totali(bool);
|
|
|
|
void calcola();
|
|
|
|
bool da_sommare();
|
|
bool buono();
|
|
|
|
bool lo_devo_stampare(const char *, long);
|
|
|
|
void set_rows(int);
|
|
|
|
void scrivi();
|
|
bool scrivi_volume(int);
|
|
|
|
void scrivi_inizio_elenco_clienti();
|
|
void scrivi_coda_elenco_clienti();
|
|
void scrivi_inizio_elenco_fornitori();
|
|
void scrivi_coda_elenco_fornitori();
|
|
|
|
TPrintrow * get_record_inizio_volume (int) ;
|
|
// bool get_clienti (bool *, bool *) ;
|
|
bool get_clienti () ;
|
|
// virtual TPrintrow * get_fornitori (bool *, bool *) ;
|
|
TPrintrow * get_fornitori () ;
|
|
TPrintrow * get_record_fine_volume (bool) ;
|
|
|
|
long cerca_codice_all(TString tipo, long codcf) ;
|
|
const char * decodifica_desc_att (TString & codatt);
|
|
bool corrispettivo (const char * tipodoc);
|
|
|
|
CG3300_application () {}
|
|
virtual ~CG3300_application () {}
|
|
};
|
|
|
|
|
|
// ----------------------------------------------------------------
|
|
//
|
|
// Utility di carattere generale
|
|
//
|
|
// ----------------------------------------------------------------
|
|
|
|
const char * segno (real val)
|
|
{
|
|
if (val < 0)
|
|
return (const char *) SEGNO_MENO;
|
|
else
|
|
return " ";
|
|
}
|
|
|
|
const char * filler (int size, char fill_char = ' ')
|
|
{
|
|
char * _dep = new char(size+1);
|
|
TString dep(size);
|
|
|
|
dep.fill (fill_char);
|
|
strcpy (_dep, (const char *) dep);
|
|
return _dep;
|
|
}
|
|
|
|
long CG3300_application::cerca_codice_all(TString tipo, long codcf)
|
|
{
|
|
TLocalisamfile& clifo = *_clifo;
|
|
|
|
clifo.zero();
|
|
clifo.put (CLI_TIPOCF, tipo);
|
|
clifo.put (CLI_CODCF, codcf);
|
|
clifo.read();
|
|
|
|
if (clifo.good())
|
|
{
|
|
long codice_all = clifo.get_long (CLI_CODALLEG);
|
|
return codice_all;
|
|
}
|
|
|
|
return 0L;
|
|
}
|
|
|
|
const char * CG3300_application::decodifica_desc_att (TString & codatt)
|
|
{
|
|
TTable& attivita = * _attiv;
|
|
|
|
attivita.zero();
|
|
attivita.put ("CODTAB", codatt);
|
|
|
|
attivita.read();
|
|
|
|
if (attivita.bad())
|
|
attivita.zero();
|
|
|
|
TMP = attivita.get ("S0");
|
|
|
|
return TMP;
|
|
}
|
|
|
|
bool CG3300_application::corrispettivo (const char * tipodoc)
|
|
{
|
|
TTable& tpd = * _tpd;
|
|
TString natura_doc;
|
|
bool corrisp;
|
|
|
|
tpd.zero();
|
|
tpd.put ("CODTAB", tipodoc);
|
|
tpd.read();
|
|
if (tpd.bad())
|
|
tpd.zero();
|
|
|
|
natura_doc = tpd.get("I0");
|
|
corrisp = tpd.get_bool ("B0");
|
|
|
|
if ((natura_doc == "1") || (natura_doc == "9"))
|
|
if (corrisp)
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
//
|
|
// Inizio codice
|
|
//
|
|
// --------------------------------------------------------------------
|
|
|
|
void CG3300_application::init_sort()
|
|
{
|
|
_sort = new TSort (_SortRecLen);
|
|
|
|
if (_distingui_att)
|
|
_sort->addsortkey ((char *) &(_RecordSort->Strutt()->codatt_dic)
|
|
- (char *) (_RecordSort->Strutt()), 5);
|
|
|
|
if (_ordina_desc)
|
|
{
|
|
_sort->addsortkey ( (char *) &(_RecordSort->Strutt()->ragsoc_dett) -
|
|
(char *) (_RecordSort->Strutt()), 50);
|
|
_sort->addsortkey ( (char *) &(_RecordSort->Strutt()->codcf_dett) -
|
|
(char *) (_RecordSort->Strutt()), sizeof (long) );
|
|
}
|
|
else
|
|
_sort->addsortkey ( (char *) &(_RecordSort->Strutt()->codcf_dett) -
|
|
(char *) (_RecordSort->Strutt()), sizeof (long) );
|
|
_sort->init();
|
|
}
|
|
|
|
bool CG3300_application::user_create()
|
|
{
|
|
_nditte = new TLocalisamfile (LF_NDITTE);
|
|
_alleg = new TLocalisamfile (LF_ALLEG);
|
|
_clifo = new TLocalisamfile (LF_CLIFO);
|
|
_tpd = new TTable ("%TPD");
|
|
_attiv = new TTable ("%AIS");
|
|
|
|
_RecordSort = new SortRecord;
|
|
_SortRecLen = _RecordSort->RecSize();
|
|
_recb = new Record_B;
|
|
_frm = new Array_desc_campi;
|
|
_t = new Totali;
|
|
|
|
_cur_null = add_cursor (NULL);
|
|
init_sort();
|
|
return TRUE;
|
|
}
|
|
|
|
bool CG3300_application::user_destroy()
|
|
{
|
|
delete _alleg;
|
|
delete _clifo;
|
|
delete _nditte;
|
|
delete _tpd; delete _attiv;
|
|
|
|
// delete _sort; // Adesso e' nella postprocess_print()
|
|
delete _RecordSort;
|
|
delete _recb;
|
|
delete _frm;
|
|
delete _t;
|
|
return TRUE;
|
|
}
|
|
|
|
bool CG3300_application::set_ricalcola()
|
|
{
|
|
ricalcola ("");
|
|
return FALSE;
|
|
}
|
|
|
|
bool CG3300_application::set_dischetti()
|
|
{
|
|
TMask msk("cg3300c") ;
|
|
KEY tasto;
|
|
|
|
tasto = msk.run();
|
|
|
|
if (tasto == K_ENTER)
|
|
{
|
|
_data_stampa = (const char *)msk.get (F_DATA_STAMPA);
|
|
_anno_stampa = msk.get (F_ANNO_STAMPA);
|
|
_tipo_stampa = (stampe) atoi(msk.get (F_TIPO_STAMPA2));
|
|
|
|
_distingui_att = (bool) (msk.get (F_ATTIVITA) == "X");
|
|
_ordina_desc = (bool) (msk.get (F_ORDINA_DESC) == "X");
|
|
_ricalcola = (bool) (msk.get (F_RICALCOLA) == "X");
|
|
|
|
_cod_ditta_da = msk.get (F_DA_DITTA);
|
|
_cod_ditta_a = msk.get (F_A_DITTA);
|
|
|
|
_ricerca_att = msk.get (F_RICERCA_ATT);
|
|
|
|
switch (_tipo_stampa)
|
|
{
|
|
case clienti:
|
|
_tipoa_richiesto = "C";
|
|
_width_modulo = 132;
|
|
break;
|
|
case fornitori:
|
|
_tipoa_richiesto = "F";
|
|
_width_modulo = 132;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// if (_destinazione_stampa == dischetto)
|
|
|
|
// Adesso la scelta 3, che prima era "Modulo101", si chiama "Entrambi"
|
|
// (vedi cg3300a.uml)
|
|
if (_tipo_stampa == modulo101) _tipo_stampa = entrambi;
|
|
|
|
_my_file_printer = new TFile_printer ("IVAECF", "IVAE", 128, 1, 1);
|
|
|
|
stampa_su_disco();
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
bool CG3300_application::set_impostazione()
|
|
{
|
|
TMask msk("cg3300a") ;
|
|
KEY tasto;
|
|
TString descr_modulo;
|
|
|
|
tasto = msk.run();
|
|
|
|
if (tasto == K_ENTER)
|
|
{
|
|
_data_stampa = (const char *)msk.get (F_DATA_STAMPA);
|
|
_anno_stampa = msk.get (F_ANNO_STAMPA);
|
|
_destinazione_stampa = (modi_stampa)atoi(msk.get (F_MODO_STAMPA));
|
|
|
|
_tipo_stampa = (stampe)atoi(msk.get (F_TIPO_STAMPA));
|
|
|
|
_anno_prec = (bool) (msk.get (F_ANNO_PREC) == "X");
|
|
_distingui_att = (bool) (msk.get (F_ATTIVITA) == "X");
|
|
_tronc = (bool) (msk.get (F_TRONC) != "X");
|
|
_arrot = (bool) (msk.get (F_ARROT) != "X");
|
|
_ordina_desc = (bool) (msk.get (F_ORDINA_DESC) == "X");
|
|
_ricalcola = (bool) (msk.get (F_RICALCOLA) == "X");
|
|
|
|
_cod_ditta_da = msk.get (F_DA_DITTA);
|
|
_cod_ditta_a = msk.get (F_A_DITTA);
|
|
|
|
_ricerca_att = msk.get (F_RICERCA_ATT);
|
|
|
|
_stampa_tutti = (bool) (msk.get (F_STAMPA_TUTTI) == "X");
|
|
|
|
switch (_tipo_stampa)
|
|
{
|
|
case clienti:
|
|
_tipoa_richiesto = "C";
|
|
descr_modulo = "clienti";
|
|
_width_modulo = 132;
|
|
break;
|
|
case fornitori:
|
|
_tipoa_richiesto = "F";
|
|
descr_modulo = "fornitori";
|
|
_width_modulo = 132;
|
|
break;
|
|
case modulo101:
|
|
_tipoa_richiesto = "C";
|
|
descr_modulo = "modulo101";
|
|
_width_modulo = 80;
|
|
break;
|
|
case modulo102:
|
|
_tipoa_richiesto = "F";
|
|
descr_modulo = "modulo101";
|
|
_width_modulo = 80;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
// leggo descrizione modulo
|
|
_frm->leggi_modulo ("cg3300.frm", descr_modulo);
|
|
|
|
init_sort();
|
|
_RecordSort->azzera_struttura();
|
|
calcola();
|
|
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
bool CG3300_application::set_print(int scelta)
|
|
{
|
|
switch (scelta)
|
|
{
|
|
case 1:
|
|
return set_impostazione();
|
|
break;
|
|
case 2:
|
|
return set_ricalcola();
|
|
break;
|
|
case 3:
|
|
return set_dischetti();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void CG3300_application::pulisci_alleg (TLocalisamfile * all)
|
|
{
|
|
TProgind prn (all->items(), "Pulizia allegati in corso...", FALSE, TRUE);
|
|
bool immesso;
|
|
|
|
for ( all->first(); !all->eof(); all->next())
|
|
{
|
|
prn.addstatus(1);
|
|
immesso = all->curr().get_bool (ALL_IMMESSO);
|
|
if (immesso) continue;
|
|
else
|
|
{
|
|
all->curr().put (ALL_IMPESC, "0.00");
|
|
all->curr().put (ALL_IVAESC, "0.00");
|
|
all->curr().put (ALL_NIESC, "0.00");
|
|
all->curr().put (ALL_E8ESC, "0.00");
|
|
|
|
all->curr().put (ALL_IMPESP, "0.00");
|
|
all->curr().put (ALL_IVAESP, "0.00");
|
|
all->curr().put (ALL_NIESP, "0.00");
|
|
all->curr().put (ALL_E8ESP, "0.00");
|
|
|
|
all->curr().put (ALL_NDOCESC, "0");
|
|
all->curr().put (ALL_NDOCESP, "0");
|
|
|
|
all->curr().put (ALL_NALLESP, "0.00");
|
|
|
|
all->curr().put (ALL_PROG101102, "0.00");
|
|
|
|
all->rewrite();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CG3300_application::ricalcola (const char * anno)
|
|
{
|
|
// TProgind prn;
|
|
KEY tasto;
|
|
TString anno_dic;
|
|
TString tipo;
|
|
long codcf;
|
|
int ndoc = 0;
|
|
bool immesso;
|
|
bool vendite;
|
|
real imponibile;
|
|
real imposta;
|
|
real ni, imp, iva, e8, nall, prog101102;
|
|
TString tipodoc;
|
|
TString campo_codice_iva;
|
|
TString codice_iva;
|
|
TDate datareg, datadoc;
|
|
TString CAMPO_NALL, CAMPO_IMP, CAMPO_IVA, CAMPO_E8, CAMPO_NI, CAMPO_DOC;
|
|
bool flag_b;
|
|
long nuovo_codcf;
|
|
bool flag_incrementa = FALSE;
|
|
int ndocesc;
|
|
TLocalisamfile all (LF_ALLEG);
|
|
|
|
if (*anno == '\0')
|
|
{
|
|
TMask m ("cg3300b");
|
|
tasto=m.run();
|
|
if (tasto == K_ENTER)
|
|
anno_dic = m.get (F_ANNO_RICALCOLA);
|
|
else
|
|
return;
|
|
}
|
|
else
|
|
anno_dic = anno;
|
|
|
|
TRelation rel (LF_MOV);
|
|
rel.add (LF_RMOVIVA, "NUMREG=NUMREG");
|
|
rel.add ("REG", "CODTAB=DATAREG[7,12]+REG");
|
|
rel.add (LF_CAUSALI, "CODCAUS=CODCAUS");
|
|
rel.add ("%IVA", "CODTAB=CODIVA",1,LF_RMOVIVA);
|
|
|
|
TCursor * cur = new TCursor (&rel, format ("ANNOES=%s", (const char *)anno_dic));
|
|
|
|
pulisci_alleg(&all);
|
|
|
|
for (*cur = 0; !cur->file(LF_MOV).eof(); ++*cur )
|
|
{
|
|
TRectype mov_curr (cur->file(LF_MOV).curr());
|
|
TRectype all_curr (all.curr());
|
|
TRectype reg (cur->file("REG").curr());
|
|
TRectype cau (cur->file(LF_CAUSALI).curr());
|
|
TRectype iva_rec (cur->file("%IVA").curr());
|
|
|
|
TString tiporeg = reg.get ("I0");
|
|
|
|
if ((tiporeg != "2") || (tiporeg != "1"))
|
|
continue;
|
|
|
|
if (tiporeg == "1")
|
|
{
|
|
bool sosp = reg.get_bool ("B0");
|
|
if (sosp) continue;
|
|
vendite = TRUE;
|
|
}
|
|
else
|
|
vendite = FALSE;
|
|
|
|
tipodoc = cau.get (CAU_TIPODOC);
|
|
if (corrispettivo (tipodoc))
|
|
continue;
|
|
|
|
if (vendite)
|
|
{
|
|
campo_codice_iva = "S7";
|
|
flag_b = iva_rec.get_bool("B0");
|
|
}
|
|
else
|
|
{
|
|
campo_codice_iva = "S8";
|
|
flag_b = iva_rec.get_bool("B1");
|
|
}
|
|
|
|
codice_iva = iva_rec.get (campo_codice_iva);
|
|
|
|
anno = mov_curr.get (MOV_ANNOES);
|
|
tipo = mov_curr.get (MOV_TIPO);
|
|
codcf = mov_curr.get_long (MOV_CODCF);
|
|
|
|
nuovo_codcf = cerca_codice_all (tipo, codcf);
|
|
if (nuovo_codcf != 0)
|
|
codcf = nuovo_codcf;
|
|
|
|
all_curr.put (ALL_ANNO, anno);
|
|
all_curr.put (ALL_TIPOCF, tipo);
|
|
all_curr.put (ALL_CODCF, codcf);
|
|
|
|
datareg = mov_curr.get_date (MOV_DATAREG);
|
|
datadoc = mov_curr.get_date (MOV_DATADOC);
|
|
|
|
if (datareg.year() == datadoc.year())
|
|
{
|
|
CAMPO_IMP = "impesc";
|
|
CAMPO_IVA = "ivaesc";
|
|
CAMPO_NI = "niesc";
|
|
CAMPO_E8 = "e8esc";
|
|
CAMPO_NALL = "nallesc";
|
|
CAMPO_DOC = "ndocesc";
|
|
}
|
|
else
|
|
{
|
|
CAMPO_IMP = "impesp";
|
|
CAMPO_IVA = "ivaesp";
|
|
CAMPO_NI = "niesp";
|
|
CAMPO_E8 = "e8esp";
|
|
CAMPO_NALL = "nallesp";
|
|
CAMPO_DOC = "ndocesp";
|
|
}
|
|
|
|
flag_incrementa = FALSE;
|
|
ndoc = 0;
|
|
|
|
while (cur->next_match (LF_RMOVIVA))
|
|
{
|
|
TRectype rmi (cur->file(LF_RMOVIVA).curr());
|
|
|
|
imponibile = rmi.get_real (RMI_IMPONIBILE);
|
|
imposta = rmi.get_real (RMI_IMPOSTA);
|
|
|
|
all.read();
|
|
|
|
if (all.bad()) // aggiungo un record se non presente
|
|
{
|
|
all.write();
|
|
}
|
|
|
|
immesso = all.get_bool (ALL_IMMESSO);
|
|
if (immesso) continue; // scarta i record immessi
|
|
|
|
if ((codice_iva == "1") || (codice_iva == "2") || (codice_iva == "3"))
|
|
flag_incrementa = TRUE;
|
|
|
|
if (codice_iva == "1")
|
|
{
|
|
imp = all.get_real(CAMPO_IMP);
|
|
iva = all.get_real(CAMPO_IVA);
|
|
|
|
imp += imponibile;
|
|
iva += imposta;
|
|
|
|
all.put (CAMPO_IMP, imp);
|
|
all.put (CAMPO_IVA, iva);
|
|
}
|
|
else
|
|
if (codice_iva == "2")
|
|
{
|
|
ni = all.get_real(CAMPO_NI);
|
|
ni += imponibile;
|
|
all.put (CAMPO_NI, ni);
|
|
}
|
|
else
|
|
if (codice_iva == "3")
|
|
{
|
|
e8 = all.get_real(CAMPO_E8);
|
|
e8 += imponibile;
|
|
all.put (CAMPO_E8, e8);
|
|
}
|
|
else
|
|
{
|
|
nall = all.get_real (CAMPO_NALL);
|
|
nall += imponibile;
|
|
all.put(CAMPO_NALL, nall);
|
|
}
|
|
|
|
if (flag_b)
|
|
{
|
|
prog101102 = all.get_real (ALL_PROG101102);
|
|
prog101102 += imponibile;
|
|
}
|
|
|
|
if (flag_incrementa)
|
|
{
|
|
ndoc++;
|
|
ndocesc = all.get_int (CAMPO_DOC);
|
|
ndocesc += ndoc;
|
|
all.put(CAMPO_DOC, ndocesc);
|
|
}
|
|
} // while next_match()
|
|
|
|
all.rewrite();
|
|
|
|
} // for cur=0; ++cur
|
|
|
|
}
|
|
|
|
bool CG3300_application::lo_devo_stampare(const char * tipo, long codcf)
|
|
{
|
|
_clifo->curr().zero();
|
|
_clifo->curr().put (CLI_TIPOCF, tipo);
|
|
_clifo->curr().put (CLI_CODCF, codcf);
|
|
if (_clifo->read() == NOERR)
|
|
{
|
|
TString codice_all = _clifo->curr().get (CLI_ALLEG);
|
|
if ((codice_all == "0") ||
|
|
(codice_all == "3") ||
|
|
(codice_all == "4") )
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool CG3300_application::da_sommare()
|
|
{
|
|
TString tipocf2;
|
|
long codcf2;
|
|
TString anno2;
|
|
TString codatt_dett;
|
|
TString comodo;
|
|
tipocf2 = _alleg->curr().get (ALL_TIPOCF);
|
|
codcf2 = _alleg->curr().get_long (ALL_CODCF);
|
|
anno2 = _alleg->curr().get (ALL_ANNO);
|
|
codatt_dett = _alleg->curr().get (ALL_CODATT);
|
|
|
|
if (_RecordSort->codcf_dett() == -1)
|
|
{
|
|
_RecordSort->compila(_alleg);
|
|
return TRUE; // vuol dire che e' il primo => va messo nella struttura
|
|
}
|
|
|
|
comodo = _RecordSort->Strutt()->tipopers_dett;
|
|
|
|
// Se l'anno e' compilato prendo solo i record di quell'anno altrimenti
|
|
// se e' lasciato in bianco li considero tutti
|
|
|
|
if (_anno_stampa != "")
|
|
if (_anno_stampa != anno2)
|
|
return FALSE;
|
|
|
|
if ((comodo == tipocf2) && (_RecordSort->Strutt()->codcf_dett == codcf2))
|
|
{
|
|
if (_distingui_att)
|
|
if (codatt_dett != _RecordSort->Strutt()->codatt_dic)
|
|
return FALSE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Ritorna vero se il record corrente di alleg
|
|
// contiene dati che vanno bene per la stampa
|
|
//
|
|
// QUI COMPILO IL RECORD B PER I FORNITORI
|
|
//
|
|
bool CG3300_application::buono()
|
|
{
|
|
TString dep;
|
|
TString tipo;
|
|
long codcf;
|
|
TString anno;
|
|
|
|
if (_alleg->curr().empty())
|
|
return FALSE;
|
|
|
|
tipo = _alleg->curr().get (ALL_TIPOCF);
|
|
codcf = _alleg->curr().get_long (ALL_CODCF);
|
|
|
|
//
|
|
// Se stampo i clienti scarto chi non ha codcf = "C"
|
|
//
|
|
if (_tipoa_richiesto != tipo)
|
|
return FALSE;
|
|
|
|
// --------------------------------------------------------------------
|
|
// GESTIONE RECORD B
|
|
// --------------------------------------------------------------------
|
|
if ((_tipo_stampa == fornitori) || (_tipo_stampa == modulo102))
|
|
if (tipo == "B")
|
|
{
|
|
_recb->compila(_alleg);
|
|
return FALSE;
|
|
}
|
|
|
|
if (_ricerca_att != "")
|
|
{
|
|
// strcpy (_RecordSort->Strutt()->codatt_dett, _alleg->curr().get (ALL_CODATT));
|
|
dep = _alleg->curr().get (ALL_CODATT);
|
|
|
|
if (_ricerca_att != dep)
|
|
return FALSE;
|
|
}
|
|
|
|
if (_anno_stampa != "")
|
|
{
|
|
anno = _alleg->curr().get (ALL_ANNO);
|
|
|
|
if (anno != _anno_stampa)
|
|
return FALSE;
|
|
}
|
|
|
|
// se la stampa e' di controllo e voglio tutti i clienti mov. stampo tutti
|
|
if ((_destinazione_stampa == controllo) && _stampa_tutti)
|
|
return TRUE;
|
|
|
|
if (!lo_devo_stampare(tipo, codcf))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------
|
|
// CALCOLA
|
|
//
|
|
// Richiamata dalla preprocess_print()
|
|
//
|
|
// Scorre _nditte
|
|
// Fa le somme su _alleg per ogni ditta
|
|
//
|
|
// ----------------------------------------------------------------
|
|
void CG3300_application::calcola ()
|
|
{
|
|
static long nuova_ditta = 0;
|
|
static long ditta_da, ditta_a;
|
|
long ditta_curr;
|
|
static bool fatto_clienti = FALSE;
|
|
static bool fatto_fornitori = FALSE;
|
|
|
|
_num_cf = 0; // contatore C/F
|
|
|
|
if (_cod_ditta_da == "")
|
|
ditta_da = 0;
|
|
else
|
|
ditta_da = atol (_cod_ditta_da);
|
|
|
|
if (_cod_ditta_a == "")
|
|
ditta_a = 99999;
|
|
else
|
|
ditta_a = atol (_cod_ditta_a);
|
|
|
|
_nditte->curr().zero();
|
|
|
|
if (nuova_ditta == 0)
|
|
_nditte->curr().put (NDT_CODDITTA, ditta_da);
|
|
else
|
|
{
|
|
//
|
|
// Se e' stata cambiata la ditta con set_firm mi posiziono
|
|
// sulla successiva in nditte
|
|
//
|
|
_nditte->curr().put (NDT_CODDITTA, nuova_ditta);
|
|
_nditte->read();
|
|
_nditte->next();
|
|
if (_nditte->good())
|
|
nuova_ditta = _nditte->curr().get_long(NDT_CODDITTA);
|
|
}
|
|
|
|
for (_nditte->read();
|
|
( nuova_ditta =_nditte->curr().get_long(NDT_CODDITTA) ) <= ditta_a;
|
|
_nditte->next())
|
|
|
|
{
|
|
ditta_curr = get_firm();
|
|
|
|
if (ditta_curr != nuova_ditta)
|
|
set_firm (nuova_ditta);
|
|
|
|
if (_ricalcola) ricalcola (_anno_stampa);
|
|
|
|
// Legge i dati anagrafici del dichiarante
|
|
_RecordSort->fill_dati_anag_dic(_nditte);
|
|
|
|
// ---------------------------------------------------------------------
|
|
// ELABORAZIONE ALLEGATI
|
|
// ---------------------------------------------------------------------
|
|
_alleg->zero();
|
|
_alleg->put (ALL_ANNO, _anno_stampa);
|
|
_alleg->put (ALL_CODCF, _tipoa_richiesto);
|
|
|
|
TProgind prnd (_alleg->items(),
|
|
format ("Calcolo in corso \n",
|
|
"Attendere prego... "),
|
|
FALSE, TRUE);
|
|
|
|
if (_ricerca_att != "")
|
|
_alleg->curr().put (ALL_CODATT, _ricerca_att);
|
|
|
|
if (_distingui_att)
|
|
_alleg->setkey (1);
|
|
else
|
|
_alleg->setkey (2); // non distinguo le attivita
|
|
|
|
// for (_alleg->read(); !_alleg->eof(); _alleg->next())
|
|
|
|
_alleg->read();
|
|
do
|
|
{
|
|
prnd.addstatus(1);
|
|
|
|
if (buono())
|
|
{
|
|
if (da_sommare ())
|
|
_RecordSort->somma(_alleg, _tipo_stampa); // somma nella struttura
|
|
else
|
|
{
|
|
if (_RecordSort->importo() != 0)
|
|
{
|
|
_sort->sort (_RecordSort->Strutt_str());
|
|
_num_cf += 1; // incremento contatore numero di C/F
|
|
}
|
|
_t->incrementa_totali(_RecordSort->Strutt(), _tipo_stampa);
|
|
|
|
_RecordSort->compila(_alleg);
|
|
}
|
|
} // if buono()
|
|
_alleg->next();
|
|
} while (!_alleg->eof()); // for !eof su _alleg
|
|
|
|
// rimetto all'inizio il puntatore di _alleg dopo averlo scorso tutto una volta
|
|
_alleg->first();
|
|
|
|
if (_nditte->eof()) break;
|
|
|
|
} // for su nditte
|
|
|
|
//
|
|
// Riazzero nuova_ditta dopo il for altrimenti non riesco a fare due stampe
|
|
// prima di una ditta e poi di un'altra (si posiziona sulla successiva
|
|
// in nditte)
|
|
//
|
|
nuova_ditta = 0;
|
|
|
|
//
|
|
// Se la stampa e' su disco non chiamo subito endsort() perche'
|
|
// potrei richiamare calcola() per mettere nel sort l'elenco fornitori
|
|
//
|
|
if (_destinazione_stampa == dischetto)
|
|
{
|
|
if (_tipoa_richiesto == "C")
|
|
fatto_clienti = TRUE;
|
|
|
|
if (_tipoa_richiesto == "F")
|
|
fatto_fornitori = TRUE;
|
|
|
|
switch (_tipo_stampa)
|
|
{
|
|
case entrambi:
|
|
if ((fatto_clienti) && (fatto_fornitori))
|
|
_sort->endsort();
|
|
break;
|
|
case clienti:
|
|
if (fatto_clienti)
|
|
_sort->endsort();
|
|
break;
|
|
case fornitori:
|
|
if (fatto_fornitori)
|
|
_sort->endsort();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
else // stampa NON su disco
|
|
_sort->endsort();
|
|
|
|
//
|
|
// CALCOLO IL NUMERO DI PAGINE CHE STAMPO FACENDO:
|
|
//
|
|
// NUMERO DI C/F / NUMERO DI RIGHE PER MODULO (letto dal .frm)
|
|
//
|
|
|
|
int righe_mod = _frm->righe_modulo();
|
|
|
|
if ((_num_cf != 0) && (righe_mod != 0))
|
|
_num_pag = (_num_cf / righe_mod) + 1;
|
|
|
|
}
|
|
|
|
print_action CG3300_application::postprocess_print(int file, int counter)
|
|
{
|
|
delete _sort; // E' proprio necessario ???
|
|
return NEXT_PAGE;
|
|
}
|
|
|
|
print_action CG3300_application::postprocess_page(int file, int counter)
|
|
{
|
|
int pagina_corrente = printer().getcurrentpage();
|
|
|
|
switch (_tipo_stampa)
|
|
{
|
|
case clienti:
|
|
case fornitori:
|
|
if ( (_buff = _sort->retrieve()) != NULL)
|
|
{
|
|
return REPEAT_PAGE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
|
|
printer().formfeed();
|
|
//
|
|
// Se sono in una pagina dispari devo fare 2 formfeed
|
|
//
|
|
if (ODD(pagina_corrente)) printer().formfeed();
|
|
|
|
return NEXT_PAGE;
|
|
}
|
|
|
|
bool CG3300_application::preprocess_print (int file, int counter)
|
|
{
|
|
printer().footerlen (LUNGHEZZA_FOOTER);
|
|
reset_print();
|
|
|
|
// init_sort();
|
|
// _RecordSort->azzera_struttura();
|
|
// set_auto_ff (TRUE);
|
|
|
|
select_cursor (_cur_null);
|
|
|
|
//
|
|
// Crea e inizializza il sort.
|
|
// Scorre _nditte
|
|
// Fa le somme su _alleg per ogni ditta
|
|
//
|
|
|
|
// calcola();
|
|
|
|
|
|
// Leggo il primo record dal sort.
|
|
// Le successive letture avvengono nella postprocess_page()
|
|
//
|
|
if ((_buff = _sort->retrieve()) == NULL)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
void CG3300_application::arrotonda()
|
|
{
|
|
struct alleg_sort *_rec = (struct alleg_sort *) _buff;
|
|
|
|
_rec->impesc.round(-3);
|
|
_rec->ivaesc.round(-3);
|
|
_rec->niesc.round(-3);
|
|
_rec->e8esc.round(-3);
|
|
|
|
_rec->tot_rigac.round(-3);
|
|
|
|
_rec->impesp.round(-3);
|
|
_rec->ivaesp.round(-3);
|
|
_rec->niesp.round(-3);
|
|
_rec->e8esp.round(-3);
|
|
|
|
_rec->tot_rigap.round(-3);
|
|
|
|
}
|
|
|
|
void CG3300_application::tronca()
|
|
{
|
|
real dep;
|
|
|
|
alleg_sort *_rec = (alleg_sort *) _buff;
|
|
|
|
dep = _rec->impesc / 1000.00;
|
|
dep.trunc();
|
|
dep = dep * 1000.00;
|
|
_rec->impesc = dep;
|
|
|
|
dep = _rec->ivaesc / 1000.00;
|
|
dep.trunc();
|
|
dep = dep * 1000.00;
|
|
_rec->ivaesc = dep;
|
|
|
|
dep = _rec->niesc / 1000.00;
|
|
dep.trunc();
|
|
dep = dep * 1000.00;
|
|
_rec->niesc = dep;
|
|
|
|
dep = _rec->e8esc / 1000.00;
|
|
dep.trunc();
|
|
dep = dep * 1000.00;
|
|
_rec->e8esc = dep;
|
|
|
|
dep = _rec->tot_rigac / 1000.00;
|
|
dep.trunc();
|
|
dep = dep * 1000.00;
|
|
_rec->tot_rigac = dep;
|
|
|
|
dep = _rec->impesp / 1000.00;
|
|
dep.trunc();
|
|
dep = dep * 1000.00;
|
|
_rec->impesp = dep;
|
|
|
|
dep = _rec->ivaesp / 1000.00;
|
|
dep.trunc();
|
|
dep = dep * 1000.00;
|
|
_rec->ivaesp = dep;
|
|
|
|
dep = _rec->niesp / 1000.00;
|
|
dep.trunc();
|
|
dep = dep * 1000.00;
|
|
_rec->niesp = dep;
|
|
|
|
dep = _rec->e8esp / 1000.00;
|
|
dep.trunc();
|
|
dep = dep * 1000.00;
|
|
_rec->e8esp = dep;
|
|
|
|
dep = _rec->tot_rigap / 1000.00;
|
|
dep.trunc();
|
|
dep = dep * 1000.00;
|
|
_rec->tot_rigap = dep;
|
|
|
|
}
|
|
|
|
void CG3300_application::set_rows(int counter)
|
|
{
|
|
TString cog, nom;
|
|
TString tipo;
|
|
|
|
struct alleg_sort *_rec = (struct alleg_sort *) _buff;
|
|
|
|
tipo = _rec->tipopers_dett;
|
|
if (tipo == "F")
|
|
{
|
|
cog = _rec->cognome_dett;
|
|
nom = _rec->nome_dett;
|
|
}
|
|
|
|
if (_arrot)
|
|
arrotonda();
|
|
|
|
if (_tronc)
|
|
tronca();
|
|
|
|
// -------------------------------------------------------------------------
|
|
// RIGA DETTAGLIO
|
|
// -------------------------------------------------------------------------
|
|
set_row ( riga(COG_DETT), formato(COG_DETT), _rec->cognome_dett);
|
|
set_row ( riga(NOM_DETT), formato(NOM_DETT), _rec->nome_dett);
|
|
set_row ( riga(VIA_DETT), formato(VIA_DETT), _rec->via_dett);
|
|
set_row ( riga(COM_DETT), formato(COM_DETT), _rec->comune_dett);
|
|
|
|
// numero progressivo
|
|
set_row (riga(PRO_DETT), formato(PRO_DETT), counter);
|
|
|
|
if (tipo == "F")
|
|
set_row (riga(CASELLA_PAIVA), formato(CASELLA_PAIVA), "x" );
|
|
|
|
set_row (riga(PAIVA_DETT), formato(PAIVA_DETT), _rec->paiva_dett);
|
|
|
|
set_row (riga(ESC_DETT), formato(ESC_DETT), &_rec->ndocesc);
|
|
|
|
if (_rec->impesc < 0)
|
|
set_row (riga(SEGNO_IMPESC), formato(SEGNO_IMPESC), SEGNO_MENO);
|
|
|
|
set_row (riga(IMPESC_DETT), formato(IMPESC_DETT), &_rec->impesc);
|
|
|
|
if (_rec->ivaesc < 0)
|
|
set_row (riga(SEGNO_IVAESC), formato(SEGNO_IVAESC), SEGNO_MENO);
|
|
|
|
set_row (riga(IVAESC_DETT), formato(IVAESC_DETT), &_rec->ivaesc);
|
|
|
|
if (_rec->niesc < 0)
|
|
set_row (riga(SEGNO_NIESC), formato(SEGNO_NIESC), SEGNO_MENO);
|
|
|
|
set_row (riga(NIESC_DETT), formato(NIESC_DETT), &_rec->niesc);
|
|
|
|
if (_rec->e8esc < 0)
|
|
set_row (riga(SEGNO_E8ESC), formato(SEGNO_E8ESC), SEGNO_MENO);
|
|
|
|
set_row (riga(E8ESC_DETT), formato(E8ESC_DETT), &_rec->e8esc);
|
|
|
|
if (_rec->tot_rigac < 0)
|
|
set_row (riga(SEGNO_TOTC), formato(SEGNO_TOTC), SEGNO_MENO);
|
|
|
|
set_row (riga(TOTC_DETT), formato(TOTC_DETT), &_rec->tot_rigac);
|
|
|
|
set_row (riga(ESP_DETT), formato(ESP_DETT), &_rec->ndocesp);
|
|
|
|
if (_rec->impesp < 0)
|
|
set_row (riga(SEGNO_IMPESP), formato(SEGNO_IMPESP), SEGNO_MENO);
|
|
|
|
set_row (riga(IMPESP_DETT), formato(IMPESP_DETT), &_rec->impesp);
|
|
|
|
if (_rec->ivaesp < 0)
|
|
set_row (riga(SEGNO_IVAESP), formato(SEGNO_IVAESP), SEGNO_MENO);
|
|
|
|
set_row (riga(IVAESP_DETT), formato(IVAESP_DETT), &_rec->ivaesp);
|
|
|
|
if (_rec->niesp < 0)
|
|
set_row (riga(SEGNO_NIESP), formato(SEGNO_NIESP), SEGNO_MENO);
|
|
|
|
set_row (riga(NIESP_DETT), formato(NIESP_DETT), &_rec->niesp);
|
|
|
|
if (_rec->e8esp < 0)
|
|
set_row (riga(SEGNO_E8ESP), formato(SEGNO_E8ESP), SEGNO_MENO);
|
|
|
|
set_row ( riga(E8ESP_DETT), formato(E8ESP_DETT), &_rec->e8esp);
|
|
|
|
if (_rec->tot_rigap < 0)
|
|
set_row (riga(SEGNO_TOTP), formato(SEGNO_TOTP), SEGNO_MENO);
|
|
|
|
set_row (riga(TOTP_DETT), formato(TOTP_DETT), &_rec->tot_rigap);
|
|
|
|
int p = _frm->passo();
|
|
|
|
for (int i=0; i<p; i++)
|
|
set_row ( (riga(TOTP_DETT)+i), "%s", "\0");
|
|
|
|
}
|
|
|
|
bool CG3300_application::preprocess_page(int file,int counter)
|
|
{
|
|
static long codditta_curr;
|
|
static TFixed_string codatt_curr(" "); // Sono 5 spazi
|
|
struct alleg_sort * buff = (struct alleg_sort *) _buff;
|
|
int pagina_corrente = printer().getcurrentpage();
|
|
|
|
// Stampo intestazione se cambia la ditta...
|
|
if (pagina_corrente > 1)
|
|
{
|
|
if ( buff->codditta_dic != codditta_curr )
|
|
{
|
|
codditta_curr = buff->codditta_dic;
|
|
printer().formfeed();
|
|
if (ODD(pagina_corrente)) printer().formfeed();
|
|
_t->azzera_totali();
|
|
}
|
|
else
|
|
{
|
|
// .. e se cambia l'attivita'
|
|
if (_distingui_att)
|
|
if (codatt_curr != buff->codatt_dic)
|
|
{
|
|
codatt_curr = buff->codatt_dic;
|
|
printer().formfeed();
|
|
if (ODD(pagina_corrente)) printer().formfeed();
|
|
}
|
|
}
|
|
}
|
|
|
|
set_rows(counter);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CG3300_application::preprocess_header()
|
|
{
|
|
word pagina_corrente;
|
|
|
|
// printer().footerlen (LUNGHEZZA_FOOTER);
|
|
pagina_corrente = printer().getcurrentpage();
|
|
|
|
if (ODD (pagina_corrente))
|
|
intesta();
|
|
else
|
|
reset_header();
|
|
}
|
|
|
|
void CG3300_application::preprocess_footer()
|
|
{
|
|
word pagina_corrente;
|
|
bool ultima=FALSE;
|
|
|
|
pagina_corrente = printer().getcurrentpage();
|
|
|
|
// Per sapere se deve stampare il record B
|
|
if (pagina_corrente >= _num_pag)
|
|
ultima = TRUE;
|
|
|
|
if (pagina_corrente == 1)
|
|
_t->azzera_totali();
|
|
|
|
if (EVEN (pagina_corrente))
|
|
stampa_totali(ultima);
|
|
}
|
|
|
|
|
|
void CG3300_application::stampa_totali(bool ultima)
|
|
{
|
|
real tot, tot_impes, tot_ivaes, tot_nies, tot_e8es;
|
|
int tot_es;
|
|
|
|
if ((_tipo_stampa == fornitori) || (_tipo_stampa == modulo102))
|
|
_recb->somma();
|
|
else
|
|
_recb->azzera();
|
|
|
|
tot = _t->RipTotTotRiga() + _t->TotTotRigac() + _t->TotTotRigap()
|
|
+ _recb->tot_real();
|
|
tot_es = _t->RipTotEs() + _t->TotEsc() + _t->TotEsp()
|
|
+ _recb->esc_int();
|
|
tot_impes = _t->RipTotImpes() + _t->TotImpesc() + _t->TotImpesp()
|
|
+ _recb->impesc_real();
|
|
tot_ivaes = _t->RipTotIvaes() + _t->TotIvaesc() + _t->TotIvaesp()
|
|
+ _recb->ivaesc_real();
|
|
tot_nies = _t->RipTotNies() + _t->TotNiesc() + _t->TotNiesp() ;
|
|
tot_e8es = _t->RipTotE8es() + _t->TotE8esc() + _t->TotE8esp() ;
|
|
|
|
// ------------------------------------------------------------
|
|
// Record B (dati relativi alle importazioni
|
|
// ------------------------------------------------------------
|
|
|
|
if (_tipo_stampa == fornitori)
|
|
if (ultima)
|
|
{
|
|
set_footer (riga(RECB_ESC), formato(RECB_ESC), _recb->esc_int() );
|
|
set_footer (riga(RECB_IMPESP), formato(RECB_IMPESP), _recb->impesc_str() );
|
|
set_footer (riga(RECB_IVAESC), formato(RECB_IVAESC), _recb->ivaesc_str() );
|
|
|
|
if (_recb->tot_real() < 0)
|
|
set_footer (riga(RECB_SEGNO_TOT), formato(RECB_SEGNO_TOT), SEGNO_MENO);
|
|
|
|
set_footer (riga(RECB_TOT), formato(RECB_TOT), _recb->tot_str() );
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// Riporti dalla pagina precedente
|
|
// ------------------------------------------------------------
|
|
|
|
set_footer (riga(RIP_ESC), formato(RIP_ESC), _t->RipTotEs());
|
|
|
|
set_footer (riga(RIP_SEGNO_IMPESP), formato(RIP_SEGNO_IMPESP),
|
|
segno(_t->RipTotImpes()));
|
|
set_footer (riga(RIP_IMPESP), formato(RIP_IMPESP),
|
|
_t->RipTotImpes().string(12,0));
|
|
|
|
set_footer (riga(RIP_SEGNO_IVAESP), formato(RIP_SEGNO_IVAESP),
|
|
segno(_t->RipTotIvaes()));
|
|
set_footer (riga(RIP_IVAESP), formato(RIP_IVAESP),
|
|
_t->RipTotIvaes().string(12,0));
|
|
|
|
set_footer (riga(RIP_SEGNO_NIESP), formato(RIP_SEGNO_NIESP),
|
|
segno(_t->RipTotNies()));
|
|
set_footer (riga(RIP_NIESP), formato(RIP_NIESP),
|
|
_t->RipTotNies().string(12,0));
|
|
|
|
set_footer (riga(RIP_SEGNO_E8ESP), formato(RIP_SEGNO_E8ESP),
|
|
segno(_t->RipTotE8es()));
|
|
set_footer (riga(RIP_E8ESP), formato(RIP_E8ESP),
|
|
_t->RipTotE8es().string(12,0));
|
|
|
|
// ------------------------------------------------------------
|
|
// Totali
|
|
// ------------------------------------------------------------
|
|
|
|
set_footer (riga(TOT_ESC), formato(TOT_ESC), tot_es);
|
|
|
|
set_footer (riga(TOT_SEGNO_IMPESP), formato(TOT_SEGNO_IMPESP),
|
|
segno(tot_impes));
|
|
set_footer (riga(TOT_IMPESP), formato(TOT_IMPESP), tot_impes.string(12,0));
|
|
|
|
set_footer (riga(TOT_SEGNO_IVAESP), formato(TOT_SEGNO_IVAESP),
|
|
segno(tot_ivaes));
|
|
set_footer (riga(TOT_IVAESP), formato(TOT_IVAESP), tot_ivaes.string(12,0));
|
|
|
|
set_footer (riga(TOT_SEGNO_NIESP), formato(TOT_SEGNO_NIESP),
|
|
segno(tot_nies));
|
|
set_footer (riga(TOT_NIESP), formato(TOT_NIESP), tot_nies.string(12,0));
|
|
|
|
set_footer (riga(TOT_SEGNO_E8ESP), formato(TOT_SEGNO_E8ESP),
|
|
segno(tot_e8es));
|
|
set_footer (riga(TOT_E8ESP), formato(TOT_E8ESP), tot_e8es.string(12,0));
|
|
}
|
|
|
|
// --------------------------------------------------------------------
|
|
// INTESTA
|
|
// --------------------------------------------------------------------
|
|
bool CG3300_application::intesta()
|
|
{
|
|
TString tipoa;
|
|
struct alleg_sort * buff = (struct alleg_sort *) _buff;
|
|
// struct dati_dic * buff = _dati_dic;
|
|
word num_pagina;
|
|
|
|
num_pagina = printer().getcurrentpage();
|
|
|
|
// my_formfeed();
|
|
// reset_header();
|
|
|
|
set_header (riga(PAIVA_DIC), formato(PAIVA_DIC), buff->paiva_dic);
|
|
set_header (riga(PAG_NUM), formato(PAG_NUM), num_pagina);
|
|
set_header (riga(NUM_PAG_TOT), formato(NUM_PAG_TOT), (const char*)_num_pag);
|
|
set_header (riga(NUM_REC), formato(NUM_REC), (const char*)_num_cf);
|
|
|
|
tipoa << buff->tipopers_dic;
|
|
if (tipoa == "F")
|
|
{
|
|
set_header (riga(COGNOME_DIC), formato(COGNOME_DIC), buff->cognome_dic);
|
|
|
|
set_header (riga(NOME_DIC), formato(NOME_DIC), buff->nome_dic);
|
|
|
|
TString gg_na, mm_na, aa_na;
|
|
|
|
gg_na << buff->datana_dic.day();
|
|
mm_na << buff->datana_dic.month();
|
|
aa_na << buff->datana_dic.year ();
|
|
aa_na = aa_na.mid(2);
|
|
|
|
set_header (riga(GG_NA), formato(GG_NA), (const char *)gg_na);
|
|
set_header (riga(MM_NA), formato(MM_NA), (const char *)mm_na);
|
|
set_header (riga(AA_NA), formato(AA_NA), (const char *)aa_na);
|
|
|
|
if (buff->sesso_dic[0] == 'M')
|
|
set_header (riga(MASCHIO), formato(MASCHIO), BARRA_SESSO);
|
|
else
|
|
set_header (riga(FEMMINA), formato(FEMMINA), BARRA_SESSO);
|
|
|
|
set_header (riga(COMUNE_NA), formato(COMUNE_NA),
|
|
(const char *)buff->comunena_dic);
|
|
|
|
set_header (riga(PROV_NA), formato(PROV_NA), (const char *)buff->provna_dic);
|
|
|
|
set_header (riga(IND_FIS), formato(IND_FIS), (const char *)buff->viafis_dic);
|
|
|
|
set_header (riga(COMUNE_FIS), formato(COMUNE_FIS),
|
|
(const char *)buff->comunefis_dic);
|
|
|
|
set_header (riga(PROV_FIS), formato(PROV_FIS),
|
|
(const char *)buff->provfis_dic);
|
|
|
|
set_header (riga(PAIVA_FIS), formato(PAIVA_FIS),
|
|
(const char *)buff->paiva_dic);
|
|
|
|
set_header (riga(ATT_FIS), formato(ATT_FIS),
|
|
(const char *)buff->attivita_dic);
|
|
|
|
set_header (riga(CODATT_FIS), formato(CODATT_FIS),
|
|
(const char *)buff->codatt_dic);
|
|
}
|
|
else
|
|
//
|
|
// Persona giuridica
|
|
//
|
|
{
|
|
set_header (riga(RAGSOC_DIC), formato(RAGSOC_DIC),
|
|
(const char*)buff->ragsoc_dic);
|
|
|
|
set_header (riga(NAT_GIU), formato(NAT_GIU), buff->natgiu_dic);
|
|
|
|
set_header (riga(IND_FIS), formato(IND_FIS),
|
|
(const char*)buff->viafis_dic);
|
|
|
|
set_header (riga(COMUNE_FIS), formato(COMUNE_FIS),
|
|
(const char*)buff->comunefis_dic);
|
|
|
|
set_header (riga(PROV_FIS), formato(PROV_FIS),
|
|
(const char*)buff->provfis_dic);
|
|
|
|
set_header (riga(PAIVA_GIU), formato(PAIVA_GIU),
|
|
(const char*)buff->paiva_dic);
|
|
|
|
set_header (riga(ATT_GIU), formato(ATT_GIU),
|
|
(const char*)buff->attivita_dic);
|
|
|
|
set_header (riga(CODATT_GIU), formato(CODATT_GIU),
|
|
(const char*)buff->codatt_dic);
|
|
|
|
}
|
|
|
|
for (int i = 0; i < DISTANZA_HEADER_CORPO; i++)
|
|
set_header ( (riga(NUM_REC)+i), "%s"," ");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/******************
|
|
const char * CG3300_application::get_paiva_cf (const char * tipoa, long codcf)
|
|
{
|
|
TString dep;
|
|
|
|
_clifo->setkey(1);
|
|
_clifo->first ();
|
|
_clifo->curr().zero();
|
|
_clifo->curr().put (CLI_TIPOCF, tipoa);
|
|
_clifo->curr().put (CLI_CODCF, codcf);
|
|
_clifo->read();
|
|
if (_clifo->good())
|
|
dep = _clifo->curr().get(CLI_PAIV);
|
|
else
|
|
dep = "";
|
|
return dep;
|
|
}
|
|
******************/
|
|
|
|
// ----------------------------------------------------------------------
|
|
//
|
|
// STAMPA SU DISCO
|
|
//
|
|
// ----------------------------------------------------------------------
|
|
|
|
void CG3300_application::stampa_su_disco()
|
|
{
|
|
TPrinter old = printer();
|
|
|
|
if (_tipo_stampa == clienti)
|
|
{
|
|
_tipoa_richiesto = "C";
|
|
calcola();
|
|
}
|
|
|
|
if (_tipo_stampa == fornitori)
|
|
{
|
|
_tipoa_richiesto = "F";
|
|
calcola();
|
|
}
|
|
|
|
if (_tipo_stampa == entrambi)
|
|
{
|
|
_tipoa_richiesto = "C";
|
|
calcola();
|
|
_tipoa_richiesto = "F";
|
|
calcola();
|
|
}
|
|
|
|
// TApplication::set_printer (_my_file_printer);
|
|
_my_file_printer->set();
|
|
|
|
scrivi();
|
|
|
|
_my_file_printer->genera_dischetti();
|
|
// TApplication::set_printer (&old);
|
|
}
|
|
|
|
void CG3300_application::scrivi()
|
|
{
|
|
bool finito = FALSE;
|
|
|
|
while (!finito)
|
|
{
|
|
finito=scrivi_volume(_my_file_printer->num_volumi());
|
|
_my_file_printer->inc_volume();
|
|
}
|
|
}
|
|
|
|
bool CG3300_application::scrivi_volume(int volume)
|
|
{
|
|
bool finito = FALSE;
|
|
TPrintrow * riga;
|
|
TFilename dep ("");
|
|
bool res = FALSE;
|
|
bool inizio_elenco_clienti = TRUE;
|
|
bool inizio_elenco_fornitori = TRUE;
|
|
bool finito_clienti = FALSE;
|
|
bool finito_fornitori = FALSE;
|
|
// static bool fclienti = TRUE;
|
|
// static bool ffornitori = FALSE;
|
|
|
|
dep.temp("TMP$$");
|
|
_my_file_printer->add_file(dep);
|
|
// _tmp_files.add(dep.temp("TMP$$"));
|
|
|
|
_my_file_printer->set_printerfile (dep);
|
|
|
|
riga = get_record_inizio_volume(volume);
|
|
_my_file_printer->print(*riga);
|
|
|
|
for (int i = 0; i < _my_file_printer->num_rec_volume(); i++)
|
|
{
|
|
switch (_tipo_stampa)
|
|
{
|
|
case clienti:
|
|
if (!finito_clienti)
|
|
{
|
|
if (inizio_elenco_clienti) {
|
|
scrivi_inizio_elenco_clienti();
|
|
inizio_elenco_clienti = FALSE;
|
|
}
|
|
// res = get_clienti(&fclienti, &ffornitori);
|
|
res = get_clienti();
|
|
|
|
if (res == FALSE) {
|
|
scrivi_coda_elenco_clienti();
|
|
finito_clienti = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/*******************
|
|
if ((_tipo_stampa == entrambi) || (_tipo_stampa == clienti))
|
|
{
|
|
if (!finito_clienti)
|
|
{
|
|
if (inizio_elenco_clienti) {
|
|
scrivi_inizio_elenco_clienti();
|
|
inizio_elenco_clienti = FALSE; }
|
|
|
|
res = get_clienti(&fclienti, &ffornitori);
|
|
|
|
if (res == FALSE) {
|
|
scrivi_coda_elenco_clienti();
|
|
finito_clienti = TRUE; }
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((_tipo_stampa == entrambi) || (_tipo_stampa == fornitori))
|
|
{
|
|
if (!finito_fornitori)
|
|
{
|
|
if (inizio_elenco_fornitori) {
|
|
scrivi_inizio_elenco_fornitori();
|
|
inizio_elenco_fornitori = FALSE; }
|
|
|
|
// riga = get_fornitori(&fclienti, &ffornitori);
|
|
riga = get_fornitori();
|
|
|
|
if (riga == NULL) {
|
|
scrivi_coda_elenco_fornitori();
|
|
finito_fornitori = TRUE; }
|
|
else
|
|
_my_file_printer->print(*riga);
|
|
}
|
|
}
|
|
} // else
|
|
*******************/
|
|
|
|
} // for
|
|
|
|
finito = finito_clienti && finito_fornitori;
|
|
|
|
riga = get_record_fine_volume(finito);
|
|
_my_file_printer->print(*riga);
|
|
|
|
return (finito);
|
|
}
|
|
|
|
void CG3300_application::scrivi_coda_elenco_clienti()
|
|
{
|
|
TPrintrow * riga = new TPrintrow();
|
|
TString record (LUNGHEZZA_RECORD);
|
|
char segno[8];
|
|
|
|
record.fill (' ');
|
|
|
|
if (_t->TotImpesc() < 0)
|
|
segno[0] = '-';
|
|
else
|
|
segno[0] = ' ';
|
|
|
|
if (_t->TotImpesp() < 0)
|
|
segno[1] = '-';
|
|
else
|
|
segno[1] = ' ';
|
|
|
|
if (_t->TotIvaesc() < 0)
|
|
segno[2] = '-';
|
|
else
|
|
segno[2] = ' ';
|
|
|
|
if (_t->TotIvaesp() < 0)
|
|
segno[3] = '-';
|
|
else
|
|
segno[3] = ' ';
|
|
|
|
if (_t->TotNiesc() < 0)
|
|
segno[4] = '-';
|
|
else
|
|
segno[4] = ' ';
|
|
|
|
if (_t->TotNiesp() < 0)
|
|
segno[5] = '-';
|
|
else
|
|
segno[5] = ' ';
|
|
|
|
if (_t->TotTotRigac() < 0)
|
|
segno[6] = '-';
|
|
else
|
|
segno[6] = ' ';
|
|
|
|
if (_t->TotTotRigap() < 0)
|
|
segno[7] = '-';
|
|
else
|
|
segno[7] = ' ';
|
|
|
|
record.format ("%2s%06d%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%24s",
|
|
"05",
|
|
_records[3],
|
|
(const char *)_t->TotImpesc().string("@@@@@@@@@@@"),
|
|
segno[0],
|
|
(const char *)_t->TotImpesp().string("@@@@@@@@@@@"),
|
|
segno[1],
|
|
(const char *)_t->TotIvaesc().string("@@@@@@@@@@@"),
|
|
segno[2],
|
|
(const char *)_t->TotIvaesp().string("@@@@@@@@@@@"),
|
|
segno[3],
|
|
(const char *)_t->TotNiesc().string("@@@@@@@@@@@"),
|
|
segno[4],
|
|
(const char *)_t->TotNiesp().string("@@@@@@@@@@@"),
|
|
segno[5],
|
|
(const char *)_t->TotTotRigac().string("@@@@@@@@@@@"),
|
|
segno[6],
|
|
(const char *)_t->TotTotRigap().string("@@@@@@@@@@@"),
|
|
segno[7],
|
|
filler(24)
|
|
);
|
|
|
|
_records[5]++;
|
|
riga->put(record);
|
|
_my_file_printer->print(*riga);
|
|
|
|
}
|
|
|
|
void CG3300_application::scrivi_inizio_elenco_clienti()
|
|
{
|
|
TPrintrow * riga = new TPrintrow();
|
|
TString record (LUNGHEZZA_RECORD);
|
|
TString aa = _anno_stampa.mid(2);
|
|
TString tipopers;
|
|
TString datana;
|
|
int cod_nat_giu=0;
|
|
|
|
record.fill (' ');
|
|
tipopers = _RecordSort->Strutt()->tipopers_dic;
|
|
|
|
datana = format ("%6s", _RecordSort->Strutt()->datana_dic.day(),
|
|
_RecordSort->Strutt()->datana_dic.month(),
|
|
_RecordSort->Strutt()->datana_dic.year() );
|
|
|
|
if (tipopers == "F")
|
|
cod_nat_giu = 0;
|
|
|
|
if (tipopers == "F")
|
|
record.format ("%2s%2d%11s%3s%2d%35s%24s%6s%1s%25s%2s",
|
|
"01", (const char *)aa,
|
|
(const char *)_RecordSort->Strutt()->paiva_dic, (const char *)filler(3),
|
|
cod_nat_giu,
|
|
(const char *)_RecordSort->Strutt()->cognome_dic,
|
|
(const char *)_RecordSort->Strutt()->nome_dic,
|
|
(const char *)_RecordSort->Strutt()->sesso_dic,
|
|
(const char *)datana,
|
|
(const char *)_RecordSort->Strutt()->comunena_dic,
|
|
(const char *)_RecordSort->Strutt()->provna_dic);
|
|
|
|
else
|
|
record.format ("%2s%2d%11s%3s%2d%60s%34s%13s",
|
|
"01", (const char *)aa,
|
|
_RecordSort->Strutt()->paiva_dic, filler(3), cod_nat_giu,
|
|
_RecordSort->Strutt()->ragsoc_dic,
|
|
filler (34),
|
|
filler (13) );
|
|
|
|
_records[1]++;
|
|
|
|
riga->put(record);
|
|
_my_file_printer->print(*riga);
|
|
|
|
record.format ("%2s%24s%34s%2s%65s",
|
|
"02", (const char *)_RecordSort->Strutt()->comunefis_dic,
|
|
(const char *)_RecordSort->Strutt()->viafis_dic,
|
|
(const char *)_RecordSort->Strutt()->provfis_dic,
|
|
filler (65) );
|
|
|
|
_records[2]++;
|
|
|
|
riga->put(record);
|
|
_my_file_printer->print(*riga);
|
|
|
|
}
|
|
|
|
void CG3300_application::scrivi_inizio_elenco_fornitori ()
|
|
{
|
|
TPrintrow * riga = new TPrintrow();
|
|
TString record (LUNGHEZZA_RECORD);
|
|
TString aa = _anno_stampa.mid(2);
|
|
TString tipopers;
|
|
TString datana;
|
|
int cod_nat_giu=0;
|
|
|
|
record.fill (' ');
|
|
tipopers = _RecordSort->Strutt()->tipopers_dic;
|
|
|
|
datana = format ("%6s", _RecordSort->Strutt()->datana_dic.day(),
|
|
_RecordSort->Strutt()->datana_dic.month(),
|
|
_RecordSort->Strutt()->datana_dic.year() );
|
|
|
|
if (tipopers == "F")
|
|
cod_nat_giu = 0;
|
|
|
|
if (tipopers == "F")
|
|
record.format ("%2s%2d%11s%3s%2d%35s%24s%6s%1s%25s%2s",
|
|
"01", (const char *)aa,
|
|
(const char *)_RecordSort->Strutt()->paiva_dic, (const char *)filler(3),
|
|
cod_nat_giu,
|
|
(const char *)_RecordSort->Strutt()->cognome_dic,
|
|
(const char *)_RecordSort->Strutt()->nome_dic,
|
|
(const char *)_RecordSort->Strutt()->sesso_dic,
|
|
(const char *)datana,
|
|
(const char *)_RecordSort->Strutt()->comunena_dic,
|
|
(const char *)_RecordSort->Strutt()->provna_dic);
|
|
|
|
else
|
|
record.format ("%2s%2d%11s%3s%2d%60s%34s%13s",
|
|
"01", (const char *)aa,
|
|
_RecordSort->Strutt()->paiva_dic, filler(3), cod_nat_giu,
|
|
_RecordSort->Strutt()->ragsoc_dic,
|
|
filler (34),
|
|
filler (13) );
|
|
|
|
_records[6]++;
|
|
|
|
riga->put(record);
|
|
_my_file_printer->print(*riga);
|
|
|
|
record.format ("%2s%24s%34s%2s%65s",
|
|
"02", (const char *)_RecordSort->Strutt()->comunefis_dic,
|
|
(const char *)_RecordSort->Strutt()->viafis_dic,
|
|
(const char *)_RecordSort->Strutt()->provfis_dic,
|
|
filler (65) );
|
|
|
|
_records[7]++;
|
|
|
|
riga->put(record);
|
|
_my_file_printer->print(*riga);
|
|
|
|
}
|
|
|
|
//TPrintrow * CG3300_application::get_fornitori (bool* clienti, bool *fornitori)
|
|
TPrintrow * CG3300_application::get_fornitori ()
|
|
{
|
|
TPrintrow * riga = new TPrintrow();
|
|
TString record (LUNGHEZZA_RECORD);
|
|
TString tipoa;
|
|
TString rag;
|
|
TString stato, paiva;
|
|
char flag_paiva;
|
|
char flag_tipo_fornitore;
|
|
static int progr = 0;
|
|
char segno[10];
|
|
|
|
record.fill (' ');
|
|
|
|
_buff = _sort->retrieve();
|
|
|
|
if (_buff == NULL)
|
|
{
|
|
// *clienti = TRUE;
|
|
// *fornitori = FALSE;
|
|
return FALSE;
|
|
}
|
|
|
|
arrotonda();
|
|
tronca();
|
|
|
|
struct alleg_sort *_rec = (struct alleg_sort*) _buff;
|
|
|
|
tipoa = _rec->tipopers_dett;
|
|
|
|
if (tipoa != "F") return FALSE;
|
|
|
|
//
|
|
// METTEERE CONTROLLO VALIDITA PAIVA!!!! QUI !!!!
|
|
//
|
|
paiva = _rec->paiva_dett;
|
|
stato = _rec->statopaiva_dett;
|
|
|
|
if (pi_check (stato, paiva))
|
|
flag_paiva = '0';
|
|
else
|
|
flag_paiva = '1';
|
|
|
|
rag = _rec->ragsoc_dett;
|
|
|
|
if (rag.not_empty()) // persona giuridica
|
|
{
|
|
flag_tipo_fornitore = '1';
|
|
record.format ("%2s%06d%60s%34s%24s%2s",
|
|
"08",
|
|
++progr,
|
|
(const char *)_rec->ragsoc_dett,
|
|
(const char *)_rec->via_dett,
|
|
(const char *)_rec->comune_dett,
|
|
(const char *)_rec->prov_dett);
|
|
}
|
|
else
|
|
{
|
|
flag_tipo_fornitore = '0';
|
|
record.format ("%2s%06d%35s%25s%34s%24s%2s",
|
|
"08",
|
|
++progr,
|
|
(const char *)_rec->cognome_dett,
|
|
(const char *)_rec->nome_dett,
|
|
(const char *)_rec->via_dett,
|
|
(const char *)_rec->comune_dett,
|
|
(const char *)_rec->prov_dett);
|
|
}
|
|
|
|
_records[8]++;
|
|
riga->put(record);
|
|
_my_file_printer->print(*riga);
|
|
|
|
if (_rec->impesc < 0)
|
|
segno[0] = '-';
|
|
else
|
|
segno[0] = ' ';
|
|
|
|
if (_rec->impesp < 0)
|
|
segno[1] = '-';
|
|
else
|
|
segno[1] = ' ';
|
|
|
|
if (_rec->ivaesc < 0)
|
|
segno[2] = '-';
|
|
else
|
|
segno[2] = ' ';
|
|
|
|
if (_rec->ivaesp < 0)
|
|
segno[3] = '-';
|
|
else
|
|
segno[3] = ' ';
|
|
|
|
if (_rec->niesc < 0)
|
|
segno[4] = '-';
|
|
else
|
|
segno[4] = ' ';
|
|
|
|
if (_rec->niesp < 0)
|
|
segno[5] = '-';
|
|
else
|
|
segno[5] = ' ';
|
|
|
|
if (_rec->e8esc < 0)
|
|
segno[6] = '-';
|
|
else
|
|
segno[6] = ' ';
|
|
|
|
if (_rec->e8esp < 0)
|
|
segno[7] = '-';
|
|
else
|
|
segno[7] = ' ';
|
|
|
|
if (_rec->tot_rigac < 0)
|
|
segno[8] = '-';
|
|
else
|
|
segno[8] = ' ';
|
|
|
|
if (_rec->tot_rigap < 0)
|
|
segno[9] = '-';
|
|
else
|
|
segno[9] = ' ';
|
|
|
|
record.format ("%2s%11s%1c%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%17s",
|
|
"09",
|
|
(const char *)_rec->paiva_dett,
|
|
flag_paiva,
|
|
flag_tipo_fornitore,
|
|
(const char *)_rec->impesc.string("@@@@@@@@@@@"),
|
|
segno[0],
|
|
(const char *)_rec->impesp.string("@@@@@@@@@@@"),
|
|
segno[1],
|
|
(const char *)_rec->ivaesc.string("@@@@@@@@@@@"),
|
|
segno[2],
|
|
(const char *)_rec->ivaesp.string("@@@@@@@@@@@"),
|
|
segno[3],
|
|
(const char *)_rec->niesc.string("@@@@@@@@@@@"),
|
|
segno[4],
|
|
(const char *)_rec->niesp.string("@@@@@@@@@@@"),
|
|
segno[5],
|
|
(const char *)_rec->e8esc.string("@@@@@@@@@@@"),
|
|
segno[6],
|
|
(const char *)_rec->e8esp.string("@@@@@@@@@@@"),
|
|
segno[7],
|
|
filler(17)
|
|
);
|
|
|
|
_records[9]++;
|
|
riga->put(record);
|
|
_my_file_printer->print(*riga);
|
|
|
|
record.format ("%2s%11s%1c%11s%1c%5d%5d92s",
|
|
"10",
|
|
(const char *)_rec->tot_rigac.string("@@@@@@@@@@@"),
|
|
segno[6],
|
|
(const char *)_rec->tot_rigap.string("@@@@@@@@@@@"),
|
|
segno[7],
|
|
_rec->ndocesc,
|
|
_rec->ndocesp,
|
|
filler(92)
|
|
);
|
|
|
|
_records[10]++;
|
|
riga->put(record);
|
|
|
|
return (riga);
|
|
}
|
|
|
|
void CG3300_application::scrivi_coda_elenco_fornitori()
|
|
{
|
|
TPrintrow * riga = new TPrintrow();
|
|
TString record (LUNGHEZZA_RECORD);
|
|
char segno[10];
|
|
|
|
record.fill (' ');
|
|
|
|
if (_t->TotImpesc() < 0)
|
|
segno[0] = '-';
|
|
else
|
|
segno[0] = ' ';
|
|
|
|
if (_t->TotImpesp() < 0)
|
|
segno[1] = '-';
|
|
else
|
|
segno[1] = ' ';
|
|
|
|
if (_t->TotIvaesc() < 0)
|
|
segno[2] = '-';
|
|
else
|
|
segno[2] = ' ';
|
|
|
|
if (_t->TotIvaesp() < 0)
|
|
segno[3] = '-';
|
|
else
|
|
segno[3] = ' ';
|
|
|
|
if (_t->TotNiesc() < 0)
|
|
segno[4] = '-';
|
|
else
|
|
segno[4] = ' ';
|
|
|
|
if (_t->TotNiesp() < 0)
|
|
segno[5] = '-';
|
|
else
|
|
segno[5] = ' ';
|
|
|
|
if (_t->TotE8esc() < 0)
|
|
segno[8] = '-';
|
|
else
|
|
segno[8] = ' ';
|
|
|
|
if (_t->TotE8esp() < 0)
|
|
segno[8] = '-';
|
|
else
|
|
segno[8] = ' ';
|
|
|
|
if (_t->TotTotRigac() < 0)
|
|
segno[8] = '-';
|
|
else
|
|
segno[8] = ' ';
|
|
|
|
if (_t->TotTotRigap() < 0)
|
|
segno[9] = '-';
|
|
else
|
|
segno[9] = ' ';
|
|
|
|
record.format ("%2s%06d%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%24s",
|
|
"11",
|
|
_records[3],
|
|
_t->TotImpesc().string("@@@@@@@@@@@"),
|
|
segno[0],
|
|
_t->TotImpesp().string("@@@@@@@@@@@"),
|
|
segno[1],
|
|
_t->TotIvaesc().string("@@@@@@@@@@@"),
|
|
segno[2],
|
|
_t->TotIvaesp().string("@@@@@@@@@@@"),
|
|
segno[3],
|
|
_t->TotNiesc().string("@@@@@@@@@@@"),
|
|
segno[4],
|
|
_t->TotNiesp().string("@@@@@@@@@@@"),
|
|
segno[5],
|
|
_t->TotE8esc().string("@@@@@@@@@@@"),
|
|
segno[6],
|
|
_t->TotE8esp().string("@@@@@@@@@@@"),
|
|
segno[7],
|
|
_t->TotTotRigac().string("@@@@@@@@@@@"),
|
|
segno[8],
|
|
_t->TotTotRigap().string("@@@@@@@@@@@"),
|
|
segno[9]
|
|
);
|
|
|
|
_records[11]++;
|
|
riga->put(record);
|
|
_my_file_printer->print(*riga);
|
|
|
|
record.format ("%2s%11s%11s%11s%5d%88s",
|
|
"12",
|
|
_recb->impesc_str(),
|
|
_recb->ivaesc_str(),
|
|
_recb->tot_str(),
|
|
_recb->esc_int(),
|
|
filler(88)
|
|
);
|
|
|
|
_records[12]++;
|
|
riga->put(record);
|
|
_my_file_printer->print(*riga);
|
|
}
|
|
|
|
// bool CG3300_application::get_clienti (bool * clienti, bool * fornitori)
|
|
bool CG3300_application::get_clienti ()
|
|
{
|
|
TPrintrow * riga = new TPrintrow();
|
|
TString record (LUNGHEZZA_RECORD);
|
|
TString tipoa;
|
|
TString rag;
|
|
TString paiva, stato;
|
|
char flag_paiva;
|
|
char flag_tipo_cliente;
|
|
static int progr = 0;
|
|
char segno[8];
|
|
|
|
record.fill (' ');
|
|
|
|
_buff = _sort->retrieve();
|
|
|
|
if (_buff == NULL)
|
|
{
|
|
// *clienti = FALSE;
|
|
// *fornitori = TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
arrotonda();
|
|
tronca();
|
|
|
|
struct alleg_sort *_rec = (struct alleg_sort*) _buff;
|
|
|
|
tipoa = _rec->tipopers_dett;
|
|
|
|
if (tipoa != "C") return FALSE;
|
|
|
|
//
|
|
// METTEERE CONTROLLO VALIDITA PAIVA!!!! QUI !!!!
|
|
//
|
|
paiva = _rec->paiva_dett;
|
|
stato = _rec->statopaiva_dett;
|
|
|
|
if (pi_check (stato, paiva))
|
|
flag_paiva = '0';
|
|
else
|
|
flag_paiva = '1';
|
|
|
|
rag = _rec->ragsoc_dett;
|
|
|
|
if (rag.not_empty()) // persona giuridica
|
|
{
|
|
flag_tipo_cliente = '1';
|
|
record.format ("%2s%06d%60s%34s%24s%2s",
|
|
"03",
|
|
++progr,
|
|
(const char *)_rec->ragsoc_dett,
|
|
(const char *)_rec->via_dett,
|
|
(const char *)_rec->comune_dett,
|
|
(const char *)_rec->prov_dett);
|
|
}
|
|
else
|
|
{
|
|
flag_tipo_cliente = '0';
|
|
record.format ("%2s%06d%35s%25s%34s%24s%2s",
|
|
"03",
|
|
++progr,
|
|
(const char *)_rec->cognome_dett,
|
|
(const char *)_rec->nome_dett,
|
|
(const char *)_rec->via_dett,
|
|
(const char *)_rec->comune_dett,
|
|
(const char *)_rec->prov_dett);
|
|
}
|
|
|
|
_records[3]++;
|
|
riga->put(record);
|
|
_my_file_printer->print(*riga);
|
|
|
|
if (_rec->impesc < 0)
|
|
segno[0] = '-';
|
|
else
|
|
segno[0] = ' ';
|
|
|
|
if (_rec->impesp < 0)
|
|
segno[1] = '-';
|
|
else
|
|
segno[1] = ' ';
|
|
|
|
if (_rec->ivaesc < 0)
|
|
segno[2] = '-';
|
|
else
|
|
segno[2] = ' ';
|
|
|
|
if (_rec->ivaesp < 0)
|
|
segno[3] = '-';
|
|
else
|
|
segno[3] = ' ';
|
|
|
|
if (_rec->niesc < 0)
|
|
segno[4] = '-';
|
|
else
|
|
segno[4] = ' ';
|
|
|
|
if (_rec->niesp < 0)
|
|
segno[5] = '-';
|
|
else
|
|
segno[5] = ' ';
|
|
|
|
if (_rec->tot_rigac < 0)
|
|
segno[6] = '-';
|
|
else
|
|
segno[6] = ' ';
|
|
|
|
if (_rec->tot_rigap < 0)
|
|
segno[7] = '-';
|
|
else
|
|
segno[7] = ' ';
|
|
|
|
record.format ("%2s%11s%1c%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%11s%1c%17s",
|
|
"04",
|
|
(const char *)_rec->paiva_dett,
|
|
flag_paiva,
|
|
flag_tipo_cliente,
|
|
(const char *)_rec->impesc.string("@@@@@@@@@@@"),
|
|
segno[0],
|
|
(const char *)_rec->impesp.string("@@@@@@@@@@@"),
|
|
segno[1],
|
|
(const char *)_rec->ivaesc.string("@@@@@@@@@@@"),
|
|
segno[2],
|
|
(const char *)_rec->ivaesp.string("@@@@@@@@@@@"),
|
|
segno[3],
|
|
(const char *)_rec->niesc.string("@@@@@@@@@@@"),
|
|
segno[4],
|
|
(const char *)_rec->niesp.string("@@@@@@@@@@@"),
|
|
segno[5],
|
|
(const char *)_rec->tot_rigac.string("@@@@@@@@@@@"),
|
|
segno[6],
|
|
(const char *)_rec->tot_rigap.string("@@@@@@@@@@@"),
|
|
segno[7],
|
|
filler(17)
|
|
);
|
|
|
|
_records[4]++;
|
|
riga->put(record);
|
|
_my_file_printer->print(*riga);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
TPrintrow * CG3300_application::get_record_inizio_volume (int volume_progr)
|
|
{
|
|
TPrintrow * riga = new TPrintrow();
|
|
TString record (LUNGHEZZA_RECORD);
|
|
TString aa = _anno_stampa.mid(2);
|
|
|
|
record.format ("%2s%02d%1s%2s%121s", "00", volume_progr, "2",
|
|
(const char *) aa, filler(121));
|
|
|
|
riga->put(record);
|
|
return riga;
|
|
}
|
|
|
|
TPrintrow * CG3300_application::get_record_fine_volume (bool finito)
|
|
{
|
|
TPrintrow * riga = new TPrintrow();
|
|
TString record (LUNGHEZZA_RECORD);
|
|
char fine_volume;
|
|
|
|
if (finito)
|
|
fine_volume = 'F';
|
|
else
|
|
fine_volume = 'S';
|
|
|
|
record.format ("%2s%1c%06ul%06ul%06ul%06ul%06ul%06ul%06ul%06ul%06ul%06ul%06ul%06ul%49s",
|
|
"13",
|
|
fine_volume,
|
|
_records[1],
|
|
_records[2],
|
|
_records[3],
|
|
_records[4],
|
|
_records[5],
|
|
_records[6],
|
|
_records[7],
|
|
_records[8],
|
|
_records[9],
|
|
_records[10],
|
|
_records[11],
|
|
_records[12],
|
|
filler(49)
|
|
);
|
|
|
|
riga->put(record);
|
|
return riga;
|
|
}
|
|
|
|
int cg3300(int argc, char* argv[])
|
|
{
|
|
CG3300_application a;
|
|
a.run(argc, argv, "Stampa Allegati");
|
|
return 0;
|
|
}
|
|
|
|
|