4467 lines
133 KiB
C++
Executable File
4467 lines
133 KiB
C++
Executable File
//
|
||
// Stampa registri IVA
|
||
// Usurpatore di Liberta'...
|
||
// Nemico ed Oscuro Messo di Malvagita'...
|
||
|
||
#include "cg4.h"
|
||
#include "cg4400.h"
|
||
#include "cg4400a.h"
|
||
#include "cg4400b.h"
|
||
#include "cglib01.h"
|
||
|
||
#include <defmask.h>
|
||
#include <execp.h>
|
||
#include <mailbox.h>
|
||
#include <modaut.h>
|
||
#include <progind.h>
|
||
#include <recarray.h>
|
||
#include <recset.h>
|
||
#include <utility.h>
|
||
|
||
#include <anagr.h>
|
||
#include <attiv.h>
|
||
#include <causali.h>
|
||
#include <clifo.h>
|
||
#include <comuni.h>
|
||
#include <mov.h>
|
||
#include <nditte.h>
|
||
#include <rmoviva.h>
|
||
#include <occas.h>
|
||
#include <unloc.h>
|
||
|
||
static enum tipo_sospensione { nessuna, normale, vol_affari, liquidazione };
|
||
|
||
inline TStampa_registri_app& app() { return (TStampa_registri_app&)main_app(); }
|
||
|
||
// Righe da saltare nel footer per evitare di scrivere sulla perforazione
|
||
#define RIGHE_FOOTER 3
|
||
|
||
bool TStampa_registri_app::filter_func (const TRelation * r)
|
||
{
|
||
const TRectype& mov = r->curr(LF_MOV);
|
||
const int annoiva = mov.get_int(MOV_ANNOIVA);
|
||
const TString& codreg = mov.get(MOV_REG);
|
||
|
||
if (codreg != (app()._codreg) || annoiva != (app()._annoes))
|
||
return false;
|
||
|
||
if (app()._tipo_stampa != prova) //stampa di bollato
|
||
{
|
||
const bool regst = mov.get_bool(MOV_REGST);
|
||
if (regst) //il movimento e' gia'
|
||
return false; //stato stampato in forma definitiva
|
||
const tipo_sospensione ts = (tipo_sospensione)r->lfile("REG").get_int("I9");
|
||
if (ts == liquidazione) // Movimento valido solo ai fini della liquidazione
|
||
return false;
|
||
}
|
||
|
||
const TDate datareg = mov.get(MOV_DATAREG);
|
||
if (datareg.month() < app()._stampa_mese)
|
||
app()._stampa_mese = datareg.month();
|
||
|
||
return true;
|
||
}
|
||
|
||
HIDDEN int compare_rows(const TObject** o1, const TObject** o2)
|
||
{
|
||
const TRiga& r1 = *(const TRiga*)*o1;
|
||
const TRiga& r2 = *(const TRiga*)*o2;
|
||
return r1._codiva.compare(r2._codiva);
|
||
}
|
||
|
||
HIDDEN int compare_righeiva(const TObject** o1, const TObject** o2)
|
||
{
|
||
const TRigaiva& r1 = *(const TRigaiva*)*o1;
|
||
const TRigaiva& r2 = *(const TRigaiva*)*o2;
|
||
|
||
int diff = r1._tipodet - r2._tipodet; // Confronto il tipo indetraibilita'
|
||
if (diff == 0) // Se ho un uguale indetraibilita' ...
|
||
diff = r1._codiva.compare(r2._codiva); // ... confronto il codice IVA
|
||
|
||
return diff;
|
||
}
|
||
|
||
//********* funzioni accessorie e di ricerca *********//
|
||
|
||
bool TStampa_registri_app::stampa_totali_finali()
|
||
{ return ini_get_bool(CONFIG_DITTA, "cg", "StTfFr"); }
|
||
|
||
bool TStampa_registri_app::stampa_datareg()
|
||
{ return ini_get_bool(CONFIG_STUDIO, "cg", "NoDtRg"); }
|
||
|
||
const char* TStampa_registri_app::descr_doc()
|
||
{ return cache().get("%TPD", _tipodoc, "S0"); }
|
||
|
||
const char* TStampa_registri_app::descr_iva(const char* cod)
|
||
{ return cache().get("%IVA", cod, "S0"); }
|
||
|
||
const char* TStampa_registri_app::tipo_attivita()
|
||
{
|
||
TString16 key;
|
||
key.format("%ld|%s", get_firm(), (const char *) _codatt);
|
||
return cache().get(LF_ATTIV, key, ATT_TIPOATT);
|
||
}
|
||
|
||
const char* TStampa_registri_app::desc_attivita(const TString& cod)
|
||
{
|
||
TString16 key;
|
||
key.format("%ld|%s", get_firm(), (const char *) cod);
|
||
return cache().get(LF_ATTIV, key, ATT_DESCR);
|
||
}
|
||
|
||
const TRectype& TStampa_registri_app::ricerca_cf(char tipocf, long codcf)
|
||
{
|
||
TString8 key;
|
||
key.format("%c|%ld", tipocf, codcf);
|
||
return cache().get(LF_CLIFO, key);
|
||
}
|
||
|
||
const TRectype& TStampa_registri_app::ricerca_occ(const char* occ)
|
||
{ return cache().get(LF_OCCAS, occ); }
|
||
|
||
const TRectype& TStampa_registri_app::look_comuni(const TString& stato, const TString& cod)
|
||
{
|
||
TString8 key;
|
||
key << stato << '|' << cod;
|
||
return cache().get(LF_COMUNI, key);
|
||
}
|
||
|
||
const TRectype& TStampa_registri_app::look_comuni (const char* cod)
|
||
{
|
||
return look_comuni(EMPTY_STRING, cod);
|
||
}
|
||
|
||
void TStampa_registri_app::get_dati_ditta()
|
||
{
|
||
const TRectype& nditte = cache().get(LF_NDITTE, get_firm());
|
||
_ragsoc = nditte.get(NDT_RAGSOC);
|
||
|
||
const char tipoa = nditte.get_char(NDT_TIPOA);
|
||
const long codanagr = nditte.get_long(NDT_CODANAGR);
|
||
const TRectype& anag = cache().get(LF_ANAG, format("%c|%ld", tipoa, codanagr));
|
||
|
||
_cofi = anag.get(ANA_COFI);
|
||
_paiva = anag.get(ANA_PAIV);
|
||
_comunefis = anag.get(ANA_COMRF);
|
||
_cap = anag.get(ANA_CAPRF);
|
||
|
||
if (_comunefis.empty())
|
||
_comunefis = anag.get(ANA_COMRES);
|
||
if (_cap.empty())
|
||
_cap = anag.get(ANA_CAPRES);
|
||
|
||
const TRectype& dep = look_comuni (_comunefis);
|
||
|
||
_comunefis = dep.get(COM_DENCOM);
|
||
_provfis = dep.get(COM_PROVCOM);
|
||
if (_comunefis.empty())
|
||
{
|
||
_viafis = anag.get(ANA_INDRF);
|
||
_viafis.rtrim();
|
||
_viafis << " " << anag.get (ANA_CIVRF);
|
||
}
|
||
else
|
||
{
|
||
_viafis = anag.get(ANA_INDRES);
|
||
_viafis.rtrim();
|
||
_viafis << ' ' << anag.get (ANA_CIVRES);
|
||
}
|
||
|
||
if (_cod_un_loc)
|
||
{
|
||
const TRectype& unloc = cache().get(LF_UNLOC, format("%ld|%d", get_firm(), _cod_un_loc));
|
||
if (!unloc.empty())
|
||
{
|
||
const TRectype& dep = look_comuni (unloc.get(ULC_COMULC));
|
||
_comunefis = dep.get(COM_DENCOM);
|
||
_provfis = dep.get(COM_PROVCOM);
|
||
_cap = unloc.get(ULC_CAPULC);
|
||
_viafis = unloc.get(ULC_INDULC);
|
||
_viafis.rtrim();
|
||
_viafis << ' ' << unloc.get(ULC_CIVULC);
|
||
}
|
||
}
|
||
}
|
||
|
||
const TRectype& TStampa_registri_app::look_lia(long ditta)
|
||
{
|
||
if (ditta <= 0)
|
||
ditta = get_firm();
|
||
|
||
TString16 y; y.format("%05ld%04d", ditta, _annoes);
|
||
const TRectype& lia = cache().get("%LIA", y);
|
||
|
||
_credito = lia.get_real("R0");
|
||
return lia;
|
||
}
|
||
|
||
//guarda tutti i mesi a partire da gennaio e controlla
|
||
//se ce ne' almeno uno per cui e' necessario rilanciare
|
||
//il calcolo (il flag B1 e' invalidato dalla prima nota).
|
||
//In tal caso si richiamera' il prg di liquidazione con
|
||
//'C' e sara' tale prg che si preoccupera' di ricalcolare
|
||
//tutti i mesi a partire dall'inizio dell'anno (e a settare
|
||
//B1 nelle lim di tutti i mesi calcolati)
|
||
bool TStampa_registri_app::ricalcola(int mese)
|
||
{
|
||
TTable lim ("LIM");
|
||
//controllo i periodi precedenti al mese passato
|
||
for (int m = 1; m < mese; m++)
|
||
{
|
||
//L'if seguente e' necessario perche' se la ditta ha
|
||
//_frequiva == 'T' => esiste la lim solo se m == 3/6/9/12
|
||
//(no problem: la Prima Nota pensa lei a invalidare B0 e B1
|
||
//dei trimestri a cui appartiene il mese modificato)
|
||
if (_frequiva == 'M' || (m == 3 || m == 6 || m == 9 || m == 12))
|
||
{
|
||
TString8 key; key.format("%04d%02d", _annoes, m);
|
||
lim.put("CODTAB", key);
|
||
if (lim.read() != NOERR || !lim.get_bool("B1"))
|
||
return true;
|
||
}
|
||
}
|
||
//controllo il mese passato
|
||
if (_frequiva == 'M')
|
||
{
|
||
TString8 key; key.format("%04d%02d", _annoes, mese);
|
||
lim.put("CODTAB", key);
|
||
if (lim.read() != NOERR || !lim.get_bool("B1"))
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
//aggiusta il mese al trimestre a cui appartiene
|
||
mese += 2 - ((mese-1) % 3);
|
||
TString8 key; key.format("%04d%02d", _annoes, mese);
|
||
lim.put("CODTAB", key);
|
||
if (lim.read() != NOERR || !lim.get_bool("B1"))
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void TStampa_registri_app::look_reg()
|
||
{
|
||
_liquidazione = _tabreg->get_bool("B7");
|
||
_riep_liq = _tabreg->get_bool("B6");
|
||
_corrispettivi = _tabreg->get_bool("B0");
|
||
_sosp_imposta = _tabreg->get_bool("B1");
|
||
_pagine_stampate = _tabreg->get_long("I1");
|
||
_numini = _pagine_stampate;
|
||
_cod_un_loc = _tabreg->get_int("I7");
|
||
_mese_ultima_liq = _tabreg->get_int("I4");
|
||
_mese_credito = _tabreg->get_int("I8");
|
||
_codatt = _tabreg->get("S8");
|
||
_tipoatt = tipo_attivita();
|
||
_attivita = desc_attivita(_codatt);
|
||
_desc_lib = _tabreg->get ("S0");
|
||
_stampa_ind_ditta = _tabreg->get_bool("B9");
|
||
_stampa_ind_comp = _tabreg->get_bool("B5");
|
||
_stampa_cred_pre = _tabreg->get_bool("B4");
|
||
_freq_riepilogo = _tabreg->get_char("S9");
|
||
_stampa_plafonds = _tabreg->get_char("S10") == 'X';
|
||
_stampa_num_pag = _tabreg->get_char("S11") == 'X';
|
||
}
|
||
|
||
bool TStampa_registri_app::compila_reg(const TMask& m)
|
||
{
|
||
TString8 cod_lib_un;
|
||
TDate sca_vid;
|
||
|
||
_tipo_stampa = (tipo_stampa) m.get_int(TIPO_STAMPA);
|
||
if (_tipo_stampa == libro_unico) //stampa su libro unico di studio
|
||
_codreg = m.get(CODICE_LIBRO_IVA);
|
||
else if (_tipo_stampa == prova) //stampa di prova
|
||
_codreg = m.get(CODICE_LIBRO_PROVA);
|
||
else _codreg = m.get(CODICE_LIBRO);
|
||
|
||
if (_codreg.trim().empty())
|
||
{
|
||
_stampa_tutti_i_registri = true;
|
||
_tabreg->first();
|
||
if (!_tabreg->eof())
|
||
{
|
||
const TString16 codtab = _tabreg->get("CODTAB");
|
||
const int anno = atoi(codtab.mid(0,4));
|
||
if (anno > _annoes)
|
||
{
|
||
if (_tipo_stampa != libro_unico) //per il libro unico e' gia' stato controllato nell'handler
|
||
warning_box(FR("Non esistono registri IVA della Ditta %ld per l'anno %d"),
|
||
_ditta, _annoes);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
else // stampa un solo registro
|
||
{
|
||
_stampa_tutti_i_registri = false;
|
||
TString16 codtab; codtab << _annoes << _codreg;
|
||
_tabreg->zero();
|
||
_tabreg->put("CODTAB", codtab);
|
||
if (_tabreg->read() != NOERR)
|
||
{
|
||
if (_tipo_stampa != libro_unico)
|
||
warning_box(FR("Il registro IVA %s della ditta %ld non esiste"), (const char*)_codreg, _ditta);
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
_tipo_reg = (tiporeg) _tabreg->get_int("I0");
|
||
if (_tipo_reg == vendita || _tipo_reg == acquisto || _tipo_reg == riepilogativo)
|
||
{
|
||
cod_lib_un = _tabreg->get("S6");
|
||
sca_vid = _tabreg->get_date("D1");
|
||
if (_tipo_stampa != prova)
|
||
_u_data = _tabreg->get_date ("D3");
|
||
if ( _tipo_stampa == bollato || _tipo_stampa == rif_giornale )
|
||
{
|
||
if (cod_lib_un.not_empty())
|
||
{
|
||
warning_box (FR("Ditta %ld: sul registro non deve essere indicato il codice del libro unico"), _ditta);
|
||
return false;
|
||
}
|
||
if (sca_vid.ok())
|
||
if (sca_vid.month() < _fino_a_mese)
|
||
{
|
||
warning_box (FR("Ditta %ld: il mese della data scadenza vidimazione riportata sul registro non deve essere inferiore al mese indicato"), _ditta);
|
||
return false;
|
||
}
|
||
if (_u_data.ok())
|
||
if (_data_a < _u_data)
|
||
{
|
||
return warning_box (FR("Ditta %ld: la data specificata non deve essere inferiore al %s (ultima data di stampa specificata sul registro)"), _ditta, (const char*)_u_data.string());
|
||
}
|
||
if (_tipo_stampa == rif_giornale) //stampa con riferimenti al libro giornale
|
||
{
|
||
TDate datas;
|
||
bool good;
|
||
bool found = cerca_libro_gio(datas, good);
|
||
if (!found || !good)
|
||
{
|
||
warning_box (FR("Ditta %ld: la data indicata non deve essere superiore al %s (ultima data di stampa del libro giornale)"), _ditta, (const char*)datas.string());
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
_pagine_stampate = _tabreg->get_long("I1");
|
||
_numini = _pagine_stampate;
|
||
_corrispettivi = _tabreg->get_bool("B0");
|
||
_sosp_imposta = _tabreg->get_bool("B1");
|
||
_liquidazione = _tabreg->get_bool("B7");
|
||
_riep_liq = _tabreg->get_bool("B6");
|
||
_stampa_cred_pre = _tabreg->get_bool("B4");
|
||
_stampa_ind_ditta = _tabreg->get_bool("B9");
|
||
_stampa_ind_comp = _tabreg->get_bool("B5");
|
||
_stampa_plafonds = _tabreg->get_char ("S10") == 'X';
|
||
_stampa_num_pag = _tabreg->get_char ("S11") == 'X';
|
||
_cod_un_loc = _tabreg->get_int ("I7");
|
||
_mese_credito = _tabreg->get_int ("I8"); //campo nascosto sulla tabella dei registri: mese di stampa credito anno precedente
|
||
_mese_ultima_liq = _tabreg->get_int ("I4");
|
||
_codatt = _tabreg->get("S8");
|
||
_tipoatt = tipo_attivita();
|
||
_attivita = desc_attivita(_codatt);
|
||
_desc_lib = _tabreg->get("S0");
|
||
_freq_riepilogo = _tabreg->get_char("S9");
|
||
}
|
||
else return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TStampa_registri_app::compila_lib()
|
||
{
|
||
TString8 cod; cod << _annoes << _codlib;
|
||
const TRectype& lib = cache().get("%LBU", cod);
|
||
_stampa_ind_ditta = lib.get_bool("B1");
|
||
return !lib.empty();
|
||
}
|
||
|
||
bool TStampa_registri_app::cerca_libro_gio(TDate& datas, bool& good)
|
||
{
|
||
TRelation reg("REG");
|
||
TRectype& curr = reg.curr();
|
||
TString16 filter;
|
||
filter.format("%04d", _annoes);
|
||
curr.put("CODTAB", filter);
|
||
filter.format("I0=%d", giornale);
|
||
TCursor cur(®, filter, 1, &curr, &curr);
|
||
const bool found = cur.items() > 0;
|
||
good = false;
|
||
if (found)
|
||
{
|
||
cur = 0L;
|
||
datas = curr.get_date("D3"); // Data ultima stampa
|
||
good = datas.month() >= _data_a.month(); // CM000027
|
||
}
|
||
return found;
|
||
}
|
||
|
||
bool TStampa_registri_app::is_mese_ok(int x, int month)
|
||
{
|
||
bool ret = x == month;
|
||
if (!ret && _freq_riepilogo == 'T')
|
||
{
|
||
month += 2 - ((month-1) % 3);
|
||
ret = x > (month - 3) && x <= month;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
//********* handlers *********/
|
||
|
||
bool TStampa_registri_app::mask_azzera (TMask_field& f, KEY k)
|
||
{
|
||
if (k == K_SPACE)
|
||
{
|
||
f.mask().reset(F_SELECT);
|
||
f.mask().reset(DA_CODICE);
|
||
f.mask().reset(A_CODICE);
|
||
app()._ditte->check(-1, false);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TStampa_registri_app::mask_tipo_stampa(TMask_field& f, KEY k)
|
||
{
|
||
if (k == K_SPACE)
|
||
{
|
||
TMask& m = f.mask();
|
||
const int tipo_stampa = m.get_int(TIPO_STAMPA);
|
||
if (tipo_stampa == 3) //stampa su libro unico
|
||
{
|
||
m.enable_page(1);
|
||
TMask_field& cc = m.field(CODICE_LIB_UN);
|
||
cc.set_dirty();
|
||
}
|
||
else
|
||
m.disable_page(1);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TStampa_registri_app::mask_mese (TMask_field& f, KEY k)
|
||
{
|
||
TMask& m = f.mask();
|
||
if (k == K_SPACE)
|
||
{
|
||
const short id = f.dlg();
|
||
int mese;
|
||
if (id == MESE) //Per stampa su libro unico
|
||
mese = f.mask().get_int(MESE);
|
||
if (id == FINO_A_MESE)
|
||
mese = m.get_int(FINO_A_MESE); //Per stampa su bollato
|
||
if (id == MESE)
|
||
{
|
||
if (mese == 12)
|
||
{
|
||
m.show (TIPO_RIEPILOGATIVO);
|
||
m.show (RIF_VID);
|
||
}
|
||
else
|
||
{
|
||
m.hide (TIPO_RIEPILOGATIVO);
|
||
m.hide (RIF_VID);
|
||
}
|
||
}
|
||
if (id == FINO_A_MESE)
|
||
{
|
||
if (mese == 12)
|
||
m.show (TIPO_RIEPILOGATIVO);
|
||
else m.hide (TIPO_RIEPILOGATIVO);
|
||
}
|
||
}
|
||
if (k==K_TAB && f.mask().is_running())
|
||
{
|
||
const short id = f.dlg();
|
||
if (id == MESE)
|
||
m.send_key(K_TAB, CODICE_LIBRO_IVA);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TStampa_registri_app::look_reg(int i, int anno, const TString& codlib, int m, const char* cod, int* umese, long ditta)
|
||
{
|
||
TString8 y;
|
||
|
||
y << anno << cod;
|
||
_tabreg->zero();
|
||
_tabreg->put("CODTAB", y);
|
||
|
||
if (_tabreg->read() == NOERR)
|
||
{
|
||
tiporeg tipo = (tiporeg)_tabreg->get_int("I0");
|
||
if (tipo == vendita || tipo == acquisto || tipo == riepilogativo)
|
||
{
|
||
const bool only_you = _ditte->one_checked() && _ditte->checked() == 1;
|
||
TString16 cod_lib_un = _tabreg->get("S6");
|
||
TDate u_data = _tabreg->get_date("D3");
|
||
TDate sca_vid = _tabreg->get_date("D1");
|
||
if (codlib != cod_lib_un)
|
||
{
|
||
if (only_you && _ditte->checked(i))
|
||
message_box(FR("Ditta %ld: il codice libro unico del registro non e' uguale al codice libro unico indicato"), ditta);
|
||
return false;
|
||
}
|
||
if (m < *umese)
|
||
{
|
||
if (only_you && _ditte->checked(i))
|
||
message_box(FR("Ditta %ld: il mese indicato e' inferiore al mese dell'ultima data di stampa del registro"), ditta);
|
||
return false;
|
||
}
|
||
if (u_data.ok())
|
||
*umese = u_data.month();
|
||
else *umese = 0;
|
||
|
||
if (sca_vid.ok())
|
||
if (sca_vid.month() < m)
|
||
{
|
||
if (only_you && _ditte->checked(i))
|
||
message_box(FR("Ditta %ld: la data scadenza di vidimazione del registro non deve essere inferiore al mese indicato"), ditta);
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool TStampa_registri_app::look_regs(int anno, const TString& codlib, int m, int* umese, long ditta, TProgind* prog)
|
||
{
|
||
bool ok = false;
|
||
|
||
*umese = 13;
|
||
|
||
_tabreg->zero();
|
||
_tabreg->put("CODATB", anno);
|
||
for (int err = _tabreg->read(_isgteq); err == NOERR; err = _tabreg->next())
|
||
{
|
||
const tiporeg tipo = (tiporeg)_tabreg->get_int("I0");
|
||
const TString16 codtab = _tabreg->get("CODTAB");
|
||
const int a = atoi(codtab.left(4));
|
||
if (a < anno)
|
||
continue; // Should never happen!
|
||
if (a > anno)
|
||
break;
|
||
if (tipo == vendita || tipo == acquisto || tipo == riepilogativo) //registro iva
|
||
{
|
||
TString16 cod_lib_un = _tabreg->get("S6");
|
||
TDate sca_vid = _tabreg->get_date("D1");
|
||
TDate u_data = _tabreg->get_date("D3");
|
||
if (codlib != cod_lib_un)
|
||
continue;
|
||
if (u_data.ok())
|
||
if (m < u_data.month())
|
||
continue;
|
||
if (u_data.ok())
|
||
*umese = (*umese < u_data.month()) ? *umese : u_data.month();
|
||
if (sca_vid.ok())
|
||
if (sca_vid.month() < m)
|
||
continue;
|
||
int month;
|
||
if (!u_data.ok())
|
||
month = 0;
|
||
else month = u_data.month();
|
||
if (month < m - 1)
|
||
{
|
||
prog->addstatus(1);
|
||
app().set_firm(__firm);
|
||
delete prog;
|
||
error_box(FR("Ditta %ld: Stampare i registri dei mesi precedenti"), ditta);
|
||
app().stop_run();
|
||
}
|
||
ok = true;
|
||
}
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
//funzione di controllo parametri prima di stampare su libro unico
|
||
//una fra le cose piu' orrende che mi potessero capitare
|
||
bool TStampa_registri_app::mask_libun (TMask_field& f, KEY k)
|
||
{
|
||
if (k==K_TAB && f.mask().is_running())
|
||
{
|
||
const TString& codlib = f.mask().get(CODICE_LIB_UN);
|
||
if (codlib.empty())
|
||
return app()._test = true;
|
||
|
||
if (!app()._ditte->one_checked())
|
||
return true;
|
||
|
||
TProgind* p = new TProgind(2,TR("Verifica parametri in corso..."),false,true);
|
||
|
||
TString16 cod(f.mask().get(CODICE_LIBRO_IVA));
|
||
int fino_a_mese = f.mask().get_int(MESE);
|
||
int anno = f.mask().get_int(ANNO);
|
||
bool ok = false;
|
||
int last_mese = 13;
|
||
int mese = 0;
|
||
|
||
p->addstatus(1);
|
||
app().__firm = app().get_firm();
|
||
|
||
for (int i = 0; i < app()._ditte->items(); i++)
|
||
{
|
||
long ditta = app()._ditte->row(i).get_long(1);
|
||
if (prefix().exist(ditta))
|
||
{
|
||
app().set_firm(ditta);
|
||
if (cod.not_empty())
|
||
{
|
||
ok = app().look_reg(i,anno,codlib,fino_a_mese,cod,&mese,ditta);
|
||
if (!ok)
|
||
continue;
|
||
if (mese < fino_a_mese - 1) //indipendentemente se si tratta di una ditta selezionata oppure no
|
||
{
|
||
p->addstatus(1);
|
||
app().set_firm(app().__firm);
|
||
delete p;
|
||
f.error_box(FR("Ditta %ld: Stampare i registri dei mesi precedenti"), ditta);
|
||
app().stop_run();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ok = app().look_regs(anno,codlib,fino_a_mese,&mese,ditta,p);
|
||
if (!ok)
|
||
{
|
||
if (app()._ditte->checked() == 1L) //solo se ho selezionato 1 ditta devo dare il messaggio
|
||
if (app()._ditte->checked(i)) //ed e' proprio quella selezionata
|
||
{
|
||
p->addstatus(1);
|
||
app().set_firm(app().__firm);
|
||
delete p;
|
||
f.message_box(FR("Ditta %ld: nessun registro soddisfa i parametri indicati"), ditta);
|
||
app().stop_run();
|
||
}
|
||
continue;
|
||
}
|
||
}
|
||
last_mese = (last_mese < mese) ? last_mese : mese;
|
||
}
|
||
}
|
||
p->addstatus(1);
|
||
app().set_firm(app().__firm);
|
||
|
||
if (last_mese == 13)
|
||
last_mese = 0; //l'ultima data di stampa sul/sui registri specificati e' vuota
|
||
//(cioe' non sono ancora stati stampati sul libro unico specificato)
|
||
TString16 me;
|
||
me.format("%02d", last_mese);
|
||
f.mask().set(ULTIMO_MESE, me);
|
||
delete p;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TStampa_registri_app::mask_cod (TMask_field& f, KEY k)
|
||
{
|
||
if (k == K_TAB)
|
||
{
|
||
TTable TabLbu ("%LBU");
|
||
TString codtab;
|
||
int anno;
|
||
|
||
TString16 codlib(f.get());
|
||
anno = f.mask().get_int(ANNO);
|
||
TabLbu.zero();
|
||
codtab.format ("%04d%-3s", anno, (const char*)codlib);
|
||
TabLbu.put ("CODTAB", codtab);
|
||
TabLbu.read();
|
||
if ( TabLbu.good() )
|
||
{
|
||
f.mask().set(ULTIMA_PAGINA,TabLbu.get_long("I1"));
|
||
app()._codice_vidi = TabLbu.get("S4");
|
||
}
|
||
if (app()._test)
|
||
{
|
||
f.mask().send_key(K_TAB, CODICE_LIBRO_IVA);
|
||
app()._test = false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TStampa_registri_app::mask_data(TMask_field& f, KEY k)
|
||
{
|
||
if (k == K_TAB && f.mask().is_running())
|
||
{
|
||
const TDate data(f.get());
|
||
if (data.ok())
|
||
{
|
||
TMask& m = f.mask();
|
||
const int anno = m.get_int(ANNO);
|
||
if (data.year() != anno)
|
||
return f.warning_box(FR("L'anno delle date limite deve essere %d"), anno);
|
||
if (f.dlg() == A_DATA)
|
||
m.show (TIPO_RIEPILOGATIVO, data.day() == 31 && data.month() == 12);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TStampa_registri_app::year_freq_handler(TMask_field& f, KEY key)
|
||
{
|
||
if (key == K_TAB && f.focusdirty())
|
||
{
|
||
TMask& m = f.mask();
|
||
app().set_year(m.get_int(ANNO));
|
||
const int freq = m.get_int(F_FREQUENZA);
|
||
app().build_ditte_sheet(freq);
|
||
app().set_choice_limits(m);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void TStampa_registri_app::build_ditte_sheet(int flags)
|
||
{
|
||
if (_nomiditte.empty())
|
||
build_nomiditte();
|
||
|
||
TBit_array sel;
|
||
FOR_EACH_CHECKED_ROW(*_ditte, r, riga)
|
||
{
|
||
const long ditta = riga->get_long(1);
|
||
sel.set(ditta);
|
||
}
|
||
|
||
// build sheet
|
||
_ditte->destroy();
|
||
_ditte->enable_row(-1);
|
||
long good_one = -1;
|
||
for (int i = 0; i < _nomiditte.items(); i++)
|
||
{
|
||
TToken_string d = _nomiditte.row(i);
|
||
const char vers = d.get_char(2);
|
||
if ((flags == 0x1 && vers != 'M') || (flags == 0x2 && vers != 'T'))
|
||
continue;
|
||
|
||
d.insert(" |", 0);
|
||
const long pos = _ditte->add(d);
|
||
if (vers == '?')
|
||
_ditte->disable_row(pos);
|
||
else
|
||
{
|
||
const long ditta = d.get_long(1);
|
||
if (sel[ditta])
|
||
_ditte->check(pos); // Ripristino eventuale selezione precedente
|
||
if (good_one == -1)
|
||
good_one = pos; else
|
||
if (good_one >= 0)
|
||
good_one = -2;
|
||
}
|
||
}
|
||
if (good_one >= 0 && !_ditte->one_checked())
|
||
_ditte->check(good_one);
|
||
}
|
||
|
||
// --------- handlers per selezione ditte
|
||
|
||
bool TStampa_registri_app::to_ditt_handler(TMask_field& f, KEY key)
|
||
{
|
||
TMask& m = f.mask();
|
||
if (key == K_F9)
|
||
{
|
||
TArray_sheet* sh = app().get_ditte_sheet();
|
||
TMask& m = f.mask();
|
||
|
||
sh->disable_check();
|
||
sh->disable(DLG_USER);
|
||
if (sh->run() == K_ENTER)
|
||
{
|
||
m.set(A_CODICE, sh->row(sh->selected()).get_long(1));
|
||
key = K_TAB;
|
||
}
|
||
sh->enable(DLG_USER);
|
||
}
|
||
if (key == K_TAB && f.focusdirty())
|
||
{
|
||
app().select_firm_range(m.get_long(DA_CODICE), m.get_long(A_CODICE));
|
||
app().set_choice_limits(m);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TStampa_registri_app::fr_ditt_handler(TMask_field& f, KEY key)
|
||
{
|
||
TMask& m = f.mask();
|
||
if (key == K_F9)
|
||
{
|
||
TMask& m = f.mask();
|
||
TArray_sheet* sh = app().get_ditte_sheet();
|
||
|
||
sh->disable_check();
|
||
sh->disable(DLG_USER);
|
||
if (sh->run() == K_ENTER)
|
||
{
|
||
m.set(DA_CODICE, sh->row(sh->selected()).get_long(1));
|
||
key = K_TAB;
|
||
}
|
||
sh->enable(DLG_USER);
|
||
}
|
||
if (key == K_TAB && f.focusdirty())
|
||
{
|
||
app().select_firm_range(m.get_long(DA_CODICE), m.get_long(A_CODICE));
|
||
app().set_choice_limits(m);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void TStampa_registri_app::set_choice_limits(TMask& m)
|
||
{
|
||
long first = 0, last = 0;
|
||
FOR_EACH_CHECKED_ROW(*_ditte, i, riga)
|
||
{
|
||
const long dit = riga->get_long(1);
|
||
if (first <= 0) first = dit;
|
||
if (last < dit) last = dit;
|
||
}
|
||
m.set(DA_CODICE, first);
|
||
m.set(A_CODICE, last);
|
||
m.set(F_SELECT, _ditte->checked());
|
||
if (m.is_running() && first > 0)
|
||
app().set_firm(first);
|
||
}
|
||
|
||
long TStampa_registri_app::select_firm_range(long from, long to)
|
||
{
|
||
if (to <= 0l) to = 99999L;
|
||
for (int i = 0; i < _ditte->items(); i++)
|
||
{
|
||
if (_ditte->row_disabled(i))
|
||
continue;
|
||
|
||
TToken_string& d = _ditte->row(i);
|
||
const char vers = d.get_char(3);
|
||
if (vers == '?')
|
||
continue;
|
||
|
||
const long cod = d.get_long(1);
|
||
if (cod >= from && cod <= to)
|
||
_ditte->check(i);
|
||
else
|
||
_ditte->uncheck(i);
|
||
}
|
||
return _ditte->checked();
|
||
}
|
||
|
||
void TStampa_registri_app::build_nomiditte()
|
||
{
|
||
_nomiditte.destroy();
|
||
|
||
TString_array codes;
|
||
prefix().firms(codes);
|
||
FOR_EACH_ARRAY_ROW(codes, i, row)
|
||
{
|
||
const long cod = atol(*row);
|
||
// check no archivi
|
||
TToken_string* d = new TToken_string(63);
|
||
d->add(cod);
|
||
d->add(cache().get(LF_NDITTE, cod, NDT_RAGSOC));
|
||
|
||
const TRectype& lia = look_lia(cod);
|
||
const TString& freq = lia.get("S7");
|
||
if (freq.blank())
|
||
d->add("??");
|
||
else
|
||
d->add(freq);
|
||
_nomiditte.add(d);
|
||
}
|
||
}
|
||
|
||
bool TStampa_registri_app::set_ditte(TMask& m)
|
||
{
|
||
m.set(TIPO_STAMPA, 1);
|
||
m.reset(DA_DATA);
|
||
m.reset(A_DATA);
|
||
m.reset(CODICE_LIBRO_PROVA);
|
||
|
||
KEY tasto = K_SPACE;
|
||
while (tasto != K_ENTER && tasto != K_QUIT)
|
||
{
|
||
tasto = m.run();
|
||
if (tasto == DLG_SELECT)
|
||
{
|
||
_ditte->enable_check();
|
||
// seleziona e aggiungi alle gi<67> selezionate
|
||
if (_ditte->run() == K_ENTER)
|
||
{
|
||
const long sel = _ditte->selected();
|
||
if (sel >= 0 && _ditte->row_enabled(sel) && !_ditte->checked(sel))
|
||
_ditte->check(sel);
|
||
set_choice_limits(m);
|
||
}
|
||
}
|
||
}
|
||
return tasto == K_ENTER;
|
||
}
|
||
|
||
bool TStampa_registri_app::user_create()
|
||
{
|
||
open_files(LF_TAB, LF_TABCOM, LF_NDITTE, LF_MOV, LF_ATTIV, LF_CLIFO, LF_OCCAS,
|
||
LF_COMUNI, LF_ANAG, LF_UNLOC, LF_CAUSALI, LF_RMOVIVA, LF_INDLIB, 0);
|
||
_tabreg = new TTable("REG");
|
||
_nditte = new TRelation(LF_NDITTE);
|
||
_rel = new TRelation (LF_MOV);
|
||
_rel->add(LF_CAUSALI,"CODCAUS=CODCAUS",1,LF_MOV);
|
||
_rel->add(LF_RMOVIVA,"NUMREG=NUMREG",1,LF_MOV);
|
||
_rel->add ("REG", "CODTAB[1,4]=ANNOIVA|CODTAB[5,7]=REG");
|
||
_cur = new TSorted_cursor(_rel, "DATAREG|PROTIVA|NUMREG","", 2);
|
||
_ditte = new TArray_sheet(-1, 4, -4, -4, TR("Selezione Ditte"),
|
||
HR("@1|Cod.@5R|Ragione Sociale@50|Vers."));
|
||
__firm = TApplication::get_firm();
|
||
|
||
const TDate oggi(TODAY);
|
||
_annoes = oggi.year(); // Anno per frequenza IVA ditte
|
||
build_ditte_sheet(0x3);
|
||
|
||
add_cursor(_cur);
|
||
add_file(LF_MOV);
|
||
add_file(LF_RMOVIVA);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool TStampa_registri_app::user_destroy()
|
||
{
|
||
delete _ditte;
|
||
delete _nditte;
|
||
delete _tabreg;
|
||
delete _rel;
|
||
|
||
return true;
|
||
}
|
||
|
||
//********* funzioni di calcolo e di controllo *********//
|
||
|
||
// Questa funzione calcola i progressivi del periodo e totali, oltre a quelli
|
||
// del periodo precedente.
|
||
void TStampa_registri_app::calcola_progressivi()
|
||
{
|
||
TString80 chiave, codtab;
|
||
|
||
int num=0;
|
||
if (_tipo_stampa == libro_unico)
|
||
num = _fino_a_mese; else
|
||
if ( _tipo_stampa == bollato || _tipo_stampa == rif_giornale )
|
||
num = _datareg.month();
|
||
|
||
// Chiave per selezione records progressivi
|
||
chiave << _annoes << _codatt;
|
||
|
||
//calcolo i totali del periodo; calcola anche i totali da Periodo Precedente (se _annoes > 1997)
|
||
//_codatt e' gia' Z perche' lo leggo dal registro
|
||
//calcolo i totali progressivi e del periodo (tra questi anche quelli di cui periodo precedente)
|
||
for (int i=1; i<=num; i++)
|
||
{
|
||
const int start = 0, stop = (i == num) ? 1 : 0;
|
||
|
||
for (int j = start; j <= stop; j++)
|
||
{
|
||
const bool calc_prp = j == 1; // Calcola progressivi precedenti
|
||
TTable tab(calc_prp ? "PRP" : _tabname);
|
||
|
||
tab.zero();
|
||
tab.put("CODTAB", chiave);
|
||
|
||
const TRectype r(tab.curr());
|
||
|
||
tab.read(_isgteq);
|
||
for (; !tab.eof() && tab.curr() == r; tab.next())
|
||
{
|
||
codtab = tab.get("CODTAB");
|
||
TString4 codreg = codtab.mid(10,3); codreg.trim();
|
||
const int mese = atoi(codtab.mid(13,2));
|
||
if (_codreg == codreg && mese == i)
|
||
{
|
||
const TString4 codiva = codtab.mid(16,4);
|
||
const int tipodet = atoi(codtab.mid(20,1));
|
||
real impo = tab.get_real("R0");
|
||
real impos = tab.get_real("R1");
|
||
real implo = tab.get_real("R2");
|
||
//se il registro e' corrispettivi l'imponibile e l'iva li trovo in S2
|
||
if (_corrispettivi)
|
||
{
|
||
TToken_string cs (tab.get("S2"),'!');
|
||
impo = cs.get(0);
|
||
impos = cs.get(1);
|
||
}
|
||
//se in sospensione d'imposta l'imponibile e l'iva li trovo in R11 e R12
|
||
if (_sosp_imposta)
|
||
{
|
||
impo = tab.get_real("R11");
|
||
impos = tab.get_real("R12");
|
||
}
|
||
TToken_string fatt_rit (tab.get("S1"),'!');
|
||
real im (fatt_rit.get(0));
|
||
real is (fatt_rit.get(1));
|
||
impo += im;
|
||
impos += is;
|
||
implo += im+is;
|
||
if (impo != ZERO || impos != ZERO || implo != ZERO)
|
||
{
|
||
if (!calc_prp && _tipo_stampa != prova)
|
||
_tot_iva_array.add_riga(ZERO,ZERO,ZERO,impo,impos,implo,codiva); // progressivi
|
||
if (mese == num)
|
||
{
|
||
if (calc_prp)
|
||
_tot_prec_iva_array.add_riga(impo,impos,implo,ZERO,ZERO,ZERO,codiva); // periodo prec
|
||
else
|
||
_tot_iva_array.add_riga(impo,impos,implo,ZERO,ZERO,ZERO,codiva); // periodo
|
||
}
|
||
}
|
||
|
||
if (!calc_prp && _tipo_reg == acquisto) //registro acquisti
|
||
{
|
||
if (impo != ZERO || impos != ZERO)
|
||
{
|
||
if (_tipo_stampa != prova)
|
||
_iva_array.add_riga(ZERO,ZERO,impo,impos,codiva,tipodet,0,true, 0); //progressivi
|
||
if (mese == num)
|
||
_iva_array.add_riga(impo,impos,ZERO,ZERO,codiva,tipodet,0,true, 0); // periodo
|
||
}
|
||
}
|
||
}
|
||
} // for table
|
||
} // for start to stop
|
||
} // for i to num
|
||
}
|
||
|
||
int TStampa_registri_app::riga_rmoviva()
|
||
{
|
||
int nrec = 0;
|
||
|
||
bool ok = _cur->is_first_match(LF_RMOVIVA);
|
||
if (!ok)
|
||
return nrec;
|
||
|
||
const TRectype& mov = _cur->curr(LF_MOV);
|
||
const int mese_liq = mov.get_int(MOV_MESELIQ);
|
||
|
||
TLocalisamfile& rmoviva = _cur->file(LF_RMOVIVA);
|
||
const TRecnotype nr = rmoviva.recno();
|
||
|
||
const TRectype& iva = rmoviva.curr();
|
||
while (ok)
|
||
{
|
||
nrec++;
|
||
const real impo = iva.get_real(RMI_IMPONIBILE);
|
||
const real impos = iva.get_real(RMI_IMPOSTA);
|
||
const TString4 codiva = iva.get(RMI_CODIVA);
|
||
|
||
_riga_rmi.add_riga(iva);
|
||
|
||
if (!mov.get_bool(MOV_LIQDIFF) && !(mov.get_bool(MOV_IVAXCASSA) && mov.get_int(MOV_TIPOMOV)>0))
|
||
_riga_prospettoXcassa.add_riga(impo, impos, codiva);
|
||
|
||
if (is_split_payment(mov))
|
||
_riga_split.add_riga(impo, impos, codiva);
|
||
|
||
//stampa di prova, cumula progressivi dai movimenti, anziche' dalle tabelle (solo bollato)
|
||
if (_tipo_stampa == prova)
|
||
{
|
||
if (_tipodoc == "FS")
|
||
{
|
||
const real somma = -(impo + impos);
|
||
_tot_iva_array.add_riga(ZERO,ZERO,somma,ZERO,ZERO,ZERO,codiva);
|
||
if (mese_liq != 0)
|
||
_tot_prec_iva_array.add_riga(ZERO,ZERO,somma,ZERO,ZERO,ZERO,codiva);
|
||
}
|
||
else if (_tipodoc == "CR" || _tipodoc == "RF" || _tipodoc == "SC")
|
||
{
|
||
_tot_iva_array.add_riga(ZERO,ZERO,impo+impos,ZERO,ZERO,ZERO,codiva);
|
||
if (mese_liq != 0)
|
||
_tot_prec_iva_array.add_riga(ZERO,ZERO,impo+impos,ZERO,ZERO,ZERO,codiva);
|
||
}
|
||
|
||
if (_tipodoc != "CR" && _tipodoc != "SC" && _tipodoc != "RF")
|
||
{
|
||
_tot_iva_array.add_riga(impo,impos,codiva);
|
||
if (mese_liq != 0)
|
||
_tot_prec_iva_array.add_riga(impo,impos,codiva);
|
||
}
|
||
|
||
if (_tipo_reg == acquisto) //registro acquisti (non ha senso parlare di importi lordi)
|
||
_iva_array.add_riga(iva);
|
||
}
|
||
|
||
ok = _cur->next_match(LF_RMOVIVA);
|
||
}
|
||
rmoviva.readat(nr); // riposiziona righe IVA
|
||
|
||
return nrec;
|
||
}
|
||
|
||
int TStampa_registri_app::setta_riga(int r, const TRigaiva& riga, real& tot1,
|
||
real& tot2, real& tot3, real& tot4)
|
||
{
|
||
set_row(r, riga._codiva);
|
||
|
||
TString descrizione = descr_iva(riga._codiva);
|
||
if (riga._tipocr > 0)
|
||
{
|
||
const char* cr = NULL;
|
||
switch (riga._tipocr)
|
||
{
|
||
case 1: cr = TR("Beni per rivendita"); break;
|
||
case 2: cr = TR("Beni ammortizzabili"); break;
|
||
case 3: cr = TR("Beni ammortizzabili con detr. 6%"); break;
|
||
case 4: cr = TR("Beni strumentali art. 17"); break;
|
||
case 5: cr = TR("Beni per rivendita da non ventilare"); break;
|
||
case 8: cr = TR("Altri beni strumentali in leasing"); break;
|
||
case 9: cr = TR("Spese generali"); break;
|
||
default: break;
|
||
}
|
||
if (cr && *cr)
|
||
descrizione << " (" << cr << ')';
|
||
}
|
||
if (descrizione.full())
|
||
{
|
||
TParagraph_string descr(descrizione, 23);
|
||
--r;
|
||
FOR_EACH_TOKEN(descr, d)
|
||
set_row(++r, "@5g%-.23s", d);
|
||
}
|
||
if (!riga._imponibile.is_zero())
|
||
set_row(r, "@29g%r", &riga._imponibile);
|
||
if (!riga._imposta.is_zero())
|
||
set_row(r, "@45g%r", &riga._imposta);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (!riga._imponibilep.is_zero())
|
||
set_row(r, "@81g%r", &riga._imponibilep);
|
||
if (!riga._impostap.is_zero())
|
||
set_row(r, "@98g%r", &riga._impostap);
|
||
}
|
||
r++; // Incrementa sempre!
|
||
|
||
tot1 += riga._imponibile;
|
||
tot2 += riga._imposta;
|
||
tot3 += riga._imponibilep;
|
||
tot4 += riga._impostap;
|
||
|
||
return r;
|
||
}
|
||
|
||
messaggio TStampa_registri_app::controlla_liquidazione()
|
||
{
|
||
TTable lim("LIM");
|
||
TString mesi_cal;
|
||
TString8 chiave, ditta;
|
||
bool continua = false;
|
||
ditta << get_firm();
|
||
|
||
int mese = 0;
|
||
if (_tipo_stampa == prova) //stampa di prova
|
||
mese = _data_a.month();
|
||
else
|
||
mese = _fino_a_mese;
|
||
|
||
if (_tipo_riepilogativo == ' ' || _tipo_riepilogativo == 'P')
|
||
{
|
||
if (_frequiva == 'T') //la LIM esiste solo per i mesi 3, 6, 9, 12
|
||
{
|
||
for (int i=3; i<=mese; i+=3)
|
||
{
|
||
chiave.format("%04d%02d", _annoes, i);
|
||
lim.put("CODTAB", chiave);
|
||
if (lim.read() != NOERR || !lim.get_bool("B0"))
|
||
mesi_cal << itom(i) << '\n';
|
||
}
|
||
} else
|
||
if (_frequiva == 'M')
|
||
{
|
||
for (int i=1; i<=mese; i++)
|
||
{
|
||
chiave.format("%04d%02d", _annoes, i);
|
||
lim.put("CODTAB", chiave);
|
||
if (lim.read() != NOERR || !lim.get_bool("B0"))
|
||
mesi_cal << itom(i) << '\n';
|
||
}
|
||
}
|
||
if (mesi_cal.not_empty())
|
||
{
|
||
warning_box (FR("Ditta %s: la liquidazione da stampare sul registro %s relativa ai mesi di \n %s non e' stata ancora calcolata"),
|
||
(const char*)ditta, (const char*) _codreg, (const char *)mesi_cal);
|
||
continua = yesno_box(TR("Si desidera ugualmente proseguire?"));
|
||
if (!continua) return non_proseguire;
|
||
continua = yesno_box(TR("Si desidera proseguire con il calcolo e la stampa di liquidazione? \n (altrimenti si prosegue con la sola stampa liquidazione)"));
|
||
if (!continua) return prosegui_stampa;
|
||
return prosegui_cal_stampa;
|
||
}
|
||
}
|
||
else if (_tipo_riepilogativo == 'A')
|
||
{
|
||
chiave.format("%04d%02d", _annoes, 13);
|
||
lim.put("CODTAB", chiave);
|
||
if (lim.read() != NOERR || !lim.get_bool("B0"))
|
||
{
|
||
continua = yesno_box(FR("Ditta %s: non eseguito calcolo liquidazione annuale da stampare sul registro %s. Si desidera ugualmente proseguire?"), (const char*)ditta, (const char*) _codreg);
|
||
if (!continua) return non_proseguire;
|
||
continua = yesno_box(TR("Si desidera proseguire con il calcolo e la stampa di liquidazione? \n (altrimenti si prosegue con la sola stampa liquidazione)"));
|
||
if (!continua) return prosegui_stampa;
|
||
return prosegui_cal_stampa;
|
||
}
|
||
else
|
||
{
|
||
bool need_refresh = false;
|
||
for (int m=1; m<13; m++)
|
||
if (_frequiva == 'M' ||
|
||
(m==3 || m==6 || m==9 || m==12))
|
||
{
|
||
chiave.format("%04d%02d", _annoes, m);
|
||
lim.put("CODTAB", chiave);
|
||
if (lim.read() != NOERR || !lim.get_bool("B0"))
|
||
{
|
||
need_refresh = true;
|
||
break;
|
||
}
|
||
}
|
||
if (need_refresh)
|
||
{
|
||
continua = yesno_box(FR("Ditta %s: la liquidazione di alcuni mesi precedenti deve essere ricalcolata.\n"
|
||
"Si desidera ugualmente proseguire?"), (const char*)ditta);
|
||
if (!continua) return non_proseguire;
|
||
continua = yesno_box(TR("Si desidera proseguire con il calcolo e la stampa di liquidazione?\n"
|
||
"(altrimenti si prosegue con la sola stampa liquidazione)"));
|
||
if (!continua) return prosegui_stampa;
|
||
return prosegui_cal_stampa;
|
||
}
|
||
}
|
||
}
|
||
return B0_settato;
|
||
}
|
||
|
||
//controlla che i movimenti con anno data di registrazione < dell'anno indicato a video siano stati gia' stampati in forma definitiva*/
|
||
//questo controllo viene fatto solo per stampa di bollato (non su libro unico)
|
||
bool TStampa_registri_app::controlla_mov()
|
||
{
|
||
TLocalisamfile mov (LF_MOV);
|
||
bool ok = true;
|
||
tiporeg tipo;
|
||
|
||
TRecnotype rec = _tabreg->recno();
|
||
for (mov.first(); !mov.eof(); mov.next())
|
||
{
|
||
const TString4 reg = mov.get(MOV_REG);
|
||
if (reg.empty()) continue; //non e' un movimento iva
|
||
if (_stampa_tutti_i_registri)
|
||
tipo = cerca_reg (reg);
|
||
if ( (_stampa_tutti_i_registri && (tipo == vendita || tipo == acquisto || tipo == riepilogativo))
|
||
|| (!_stampa_tutti_i_registri && reg == _codreg) )
|
||
{
|
||
const TDate datareg = mov.get_date(MOV_DATAREG);
|
||
const bool stampato = mov.get_bool(MOV_REGST);
|
||
if ( datareg.year() < _annoes )
|
||
{
|
||
const long numreg = mov.get_long(MOV_NUMREG);
|
||
if (!stampato)
|
||
ok = false;
|
||
}
|
||
}
|
||
}
|
||
_tabreg->readat(rec);
|
||
return ok;
|
||
}
|
||
|
||
tiporeg TStampa_registri_app::cerca_reg(const TString& c)
|
||
{
|
||
tiporeg t = vendita;
|
||
TString8 cod; cod << _annoes << c;
|
||
_tabreg->zero();
|
||
_tabreg->put("CODTAB", cod);
|
||
if (_tabreg->read() == NOERR)
|
||
t = (tiporeg)_tabreg->get_int ("I0");
|
||
return t;
|
||
}
|
||
|
||
int TStampa_registri_app::stampa_prospetto_IVA(int rr, int tipo_prosp)
|
||
{
|
||
const bool print_prec = tipo_prosp == 1;
|
||
|
||
if (tipo_prosp == 0) // Stampa il prospetto iniziale per progressivi attuali (periodo)
|
||
{
|
||
reset_print();
|
||
TString riga(_stampa_width, '-');
|
||
set_row(rr++, riga);
|
||
|
||
riga = TR("Legenda Tipo Operazione: 1=intra; 2=AF art.34 comma 3");
|
||
if (_auto_intraf)
|
||
riga << TR("; 3=intra e AF art.34 comma 3");
|
||
riga << TR("; 4=liquidazione differita");
|
||
if (has_module(ICAUT))
|
||
riga << TR("; 5=IVA per cassa");
|
||
riga << TR("; 6=Scissione pagamenti art.17 ter");
|
||
set_row(rr++, riga);
|
||
|
||
_stampa = _st_tot_fin;
|
||
if (_stampa)
|
||
{
|
||
set_row(++rr, FR("Tipo documento@54gTotale documento"));
|
||
rr+=2;
|
||
for (int j = 0; j < _doc_array.items(); j++)
|
||
{
|
||
const TTipodoc& doc = (TTipodoc&)_doc_array[j];
|
||
set_row(rr, "%2s", (const char*) doc._tipodoc);
|
||
set_row(rr, "@3g%s", (const char*) doc._descrdoc);
|
||
set_row(rr, "@54g%r", &doc._totdoc);
|
||
rr++;
|
||
}
|
||
_doc_array.destroy();
|
||
}
|
||
|
||
if (_stampa && _tipo_reg == acquisto)
|
||
{
|
||
if (_stampa_cred_pre && _datareg.month() == 1 && _credito > ZERO)
|
||
{
|
||
set_row (++rr, FR("** CREDITO INIZIO ANNO @39g%r"), &_credito);
|
||
rr++;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
if (_esiste_riga_iva && _stampa)
|
||
{
|
||
if (tipo_prosp == 2)
|
||
{
|
||
set_row(++rr, FR("@30g-------- S C I S S I O N E ---------"));
|
||
set_row(++rr, FR("@30g P A G A M E N T I"));
|
||
}
|
||
else
|
||
{
|
||
if (print_prec)
|
||
set_row(++rr, TR("DI CUI PERIODO PRECEDENTE"));
|
||
|
||
if (_tipo_reg == vendita && _corrispettivi)
|
||
set_row(++rr, FR("@30g------------------ P E R I O D O -------------------"));
|
||
else
|
||
set_row(++rr, FR("@30g---------- P E R I O D O -----------"));
|
||
if (_tipo_stampa != prova && !print_prec)
|
||
{
|
||
if (_tipo_reg == vendita && _corrispettivi)
|
||
set_row(rr,FR("@84g----------- P R O G R E S S I V I --------------"));
|
||
else
|
||
set_row(rr,FR("@82g------ P R O G R E S S I V I ------"));
|
||
}
|
||
rr++;
|
||
set_row(rr, TR("Cod."));
|
||
if (_tipo_reg == acquisto)
|
||
{
|
||
set_row(rr, FR("@40gA C Q U I S T I"));
|
||
if (_tipo_stampa != prova && !print_prec)
|
||
set_row(rr, FR("@92gA C Q U I S T I"));
|
||
} else
|
||
if (_tipo_reg == vendita) //un registro corrispettivi puo' solo essere un registro vendite
|
||
{
|
||
set_row(rr, FR("@41gV E N D I T E"));
|
||
if (_corrispettivi)
|
||
set_row(rr, FR("@67gCORRISPETTIVI"));
|
||
if (_tipo_stampa != prova && !print_prec)
|
||
{
|
||
if (_corrispettivi)
|
||
set_row(rr, FR("@94gV E N D I T E@118gCORRISPETTIVI"));
|
||
else
|
||
set_row(rr, FR("@93gV E N D I T E"));
|
||
}
|
||
}
|
||
}
|
||
rr++;
|
||
set_row(rr, FR("IVA Descrizione@34gImponibile@53gImposta"));
|
||
if (_tipo_reg == vendita && _corrispettivi)
|
||
set_row(rr, FR("@67gImporti lordi"));
|
||
if (_tipo_stampa != prova && !print_prec)
|
||
{
|
||
if (_tipo_reg == vendita && _corrispettivi)
|
||
set_row(rr++, FR("@87gImponibile@107gImposta@118gImporti lordi"));
|
||
else
|
||
set_row(rr++, FR("@86gImponibile@106gImposta"));
|
||
}
|
||
else
|
||
rr++;
|
||
rr++;
|
||
}
|
||
return rr;
|
||
}
|
||
|
||
//*** stampa "tipi di indetraibilita'" : solo per gli acquisti! ***//
|
||
int TStampa_registri_app::stampa_acquisti(int row)
|
||
{
|
||
real tot_imponib, tot_imposta, tot_imponibp, tot_impostap;
|
||
row+=2;
|
||
int tdetprec = -1;
|
||
int rw = row;
|
||
tot_imponib = tot_imposta = tot_imponibp = tot_impostap = ZERO;
|
||
|
||
_iva_array.sort(compare_righeiva);
|
||
for (int s = 0; s < _iva_array.items(); s++)
|
||
{
|
||
const TRigaiva& riga = _iva_array.riga(s);
|
||
const int tipodet = riga._tipodet;
|
||
switch (tipodet)
|
||
{
|
||
case 1:
|
||
if (tdetprec == 3 || tdetprec == 9)
|
||
{
|
||
set_row(++rw, TR("TOTALE"));
|
||
if (tot_imponib != ZERO)
|
||
set_row(rw, "@29g%r", &tot_imponib);
|
||
if (tot_imposta != ZERO)
|
||
set_row(rw, "@45g%r", &tot_imposta);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (tot_imponibp != ZERO)
|
||
set_row(rw, "@81g%r", &tot_imponibp);
|
||
if (tot_impostap != ZERO)
|
||
set_row(rw, "@98g%r", &tot_impostap);
|
||
}
|
||
tot_imponib = tot_imposta = tot_imponibp = tot_impostap = ZERO;
|
||
rw+=2;
|
||
}
|
||
if (tipodet != tdetprec)
|
||
{
|
||
set_row(rw++, TR("----- Indetraibile su op.es. -----"));
|
||
set_row(rw, TR("Cod."));
|
||
rw++;
|
||
set_row(rw, FR("iva Descrizione@34gImponibile@53gImposta"));
|
||
if (_tipo_stampa != prova) set_row(rw, FR("@86gImponibile@106gImposta"));
|
||
rw+=2;
|
||
}
|
||
rw = setta_riga(rw, riga, tot_imponib, tot_imposta, tot_imponibp, tot_impostap);
|
||
tdetprec = tipodet;
|
||
break;
|
||
case 3:
|
||
if (tdetprec == 1 || tdetprec == 9)
|
||
{
|
||
set_row(++rw, TR("TOTALE"));
|
||
if (tot_imponib != ZERO)
|
||
set_row(rw, "@29g%r", &tot_imponib);
|
||
if (tot_imposta != ZERO)
|
||
set_row(rw, "@45g%r", &tot_imposta);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (tot_imponibp != ZERO)
|
||
set_row(rw, "@81g%r", &tot_imponibp);
|
||
if (tot_impostap != ZERO)
|
||
set_row(rw, "@98g%r", &tot_impostap);
|
||
}
|
||
tot_imponib = tot_imposta = tot_imponibp = tot_impostap = ZERO;
|
||
rw+=2;
|
||
}
|
||
if (tipodet != tdetprec)
|
||
{
|
||
set_row(rw++, TR("----- Passaggi interni -----"));
|
||
set_row(rw, TR("Cod."));
|
||
rw++;
|
||
set_row(rw, FR("iva Descrizione@34gImponibile@53gImposta"));
|
||
if (_tipo_stampa != prova)
|
||
set_row(rw, FR("@86gImponibile@106gImposta"));
|
||
rw+=2;
|
||
}
|
||
rw = setta_riga(rw, riga, tot_imponib, tot_imposta, tot_imponibp, tot_impostap);
|
||
tdetprec = tipodet;
|
||
break;
|
||
case 9:
|
||
if (tdetprec == 1 || tdetprec == 3)
|
||
{
|
||
set_row(++rw, TR("TOTALE"));
|
||
if (tot_imponib != ZERO)
|
||
set_row(rw, "@29g%r", &tot_imponib);
|
||
if (tot_imposta != ZERO)
|
||
set_row(rw, "@45g%r", &tot_imposta);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (tot_imponibp != ZERO)
|
||
set_row(rw, "@81g%r", &tot_imponibp);
|
||
if (tot_impostap != ZERO)
|
||
set_row(rw, "@98g%r", &tot_impostap);
|
||
}
|
||
tot_imponib = tot_imposta = tot_imponibp = tot_impostap = ZERO;
|
||
rw+=2;
|
||
}
|
||
if (tipodet != tdetprec)
|
||
{
|
||
set_row(rw++, TR("----- N.D. 9 - acquisti indeducibili per ART.19 -----"));
|
||
set_row(rw, TR("Cod."));
|
||
rw++;
|
||
set_row(rw, FR("iva Descrizione@34gImponibile@53gImposta"));
|
||
if (_tipo_stampa != prova)
|
||
set_row(rw, FR("@86gImponibile@106gImposta"));
|
||
rw+=2;
|
||
}
|
||
rw = setta_riga(rw, riga, tot_imponib, tot_imposta, tot_imponibp, tot_impostap);
|
||
tdetprec = tipodet;
|
||
break;
|
||
default: break;
|
||
}
|
||
}
|
||
if (_iva_array.items() > 0)
|
||
{
|
||
if (tdetprec == 1 || tdetprec == 3 || tdetprec == 9)
|
||
{
|
||
set_row(++rw, TR("TOTALE"));
|
||
if (!tot_imponib.is_zero())
|
||
set_row(rw, "@29g%r", &tot_imponib);
|
||
if (!tot_imposta.is_zero())
|
||
set_row(rw, "@45g%r", &tot_imposta);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (!tot_imponibp.is_zero())
|
||
set_row(rw, "@81g%r", &tot_imponibp);
|
||
if (tot_impostap != ZERO)
|
||
set_row(rw, "@98g%r", &tot_impostap);
|
||
}
|
||
}
|
||
_iva_array.destroy();
|
||
}
|
||
rw++;
|
||
return rw;
|
||
}
|
||
|
||
void TStampa_registri_app::set_page_tot_reg()
|
||
{
|
||
int rr = 1;
|
||
rr = stampa_prospetto_IVA(rr, 0); // Intestazione prospetto IVA per aliquota
|
||
|
||
//*****deve azzerare i totali progressivi dei riporti e segnalare all'header di non stampare
|
||
//la riga di riporto
|
||
_totali_stampati = true; //siamo in stampa totali, quindi...
|
||
_riporti_stampati = false; //inoltre non deve stapare riporti mentre stampa i totali
|
||
|
||
_totdoc_prog = _totimpn_prog = _totimps_prog = ZERO;
|
||
|
||
if (_esiste_riga_iva && _stampa)
|
||
{
|
||
for (int tipo_prosp = 0; tipo_prosp <= (_tipo_reg == vendita ? 2 : 1); tipo_prosp++)
|
||
{
|
||
TRiga_array& arriva = tipo_prosp == 0 ? _tot_iva_array : (tipo_prosp == 1 ? _tot_prec_iva_array : _riga_split);
|
||
if (arriva.empty())
|
||
continue;
|
||
arriva.sort(compare_rows); //viene ordinato per codice iva
|
||
|
||
if (tipo_prosp > 0)
|
||
rr = stampa_prospetto_IVA(rr, tipo_prosp); // Intestazione Prospetto IVA
|
||
|
||
real tot_imponib, tot_imposta, tot_lordo, tot_imponibp, tot_impostap, tot_lordop;
|
||
|
||
for (int k = 0; k < arriva.items(); k++) // Mamma mia, mamma mia...
|
||
{
|
||
const TRiga& riga = (const TRiga&)arriva[k];
|
||
|
||
if (_tipo_stampa == prova && riga._imponibile.is_zero() && riga._imposta.is_zero() && riga._implordo.is_zero())
|
||
continue;
|
||
|
||
set_row(rr, "%-4s", (const char*)riga._codiva);
|
||
const TString& descr = descr_iva(riga._codiva);
|
||
set_row(rr, "@5g%-.23s",(const char*)descr);
|
||
if (riga._imponibile != ZERO)
|
||
set_row(rr, "@29g%r", &riga._imponibile);
|
||
if (riga._imposta != ZERO)
|
||
set_row(rr, "@45g%r", &riga._imposta);
|
||
if (_tipo_reg == vendita && _corrispettivi)
|
||
if (riga._implordo != ZERO)
|
||
set_row(rr, "@65g%r", &riga._implordo);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (riga._imponibilep != ZERO)
|
||
set_row(rr, "@81g%r", &riga._imponibilep);
|
||
if (riga._impostap != ZERO)
|
||
set_row(rr, "@98g%r", &riga._impostap);
|
||
if (_tipo_reg == vendita && _corrispettivi)
|
||
if (riga._implordop != ZERO)
|
||
set_row(rr, "@116g%r", &riga._implordop);
|
||
}
|
||
rr++;
|
||
tot_imponib += riga._imponibile;
|
||
tot_imposta += riga._imposta;
|
||
tot_lordo += riga._implordo;
|
||
tot_imponibp+= riga._imponibilep;
|
||
tot_impostap+= riga._impostap;
|
||
tot_lordop += riga._implordop;
|
||
}
|
||
arriva.destroy(); // Azzera il marciume
|
||
rr++;
|
||
set_row(rr, TR("TOTALE"));
|
||
if (tot_imponib != ZERO)
|
||
set_row(rr, "@29g%r", &tot_imponib);
|
||
if (tot_imposta != ZERO)
|
||
set_row(rr, "@45g%r", &tot_imposta);
|
||
if (_tipo_reg == vendita && _corrispettivi)
|
||
if (tot_lordo != ZERO)
|
||
set_row(rr, "@65g%r", &tot_lordo);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (tot_imponibp != ZERO)
|
||
set_row(rr, "@81g%r", &tot_imponibp);
|
||
if (tot_impostap != ZERO)
|
||
set_row(rr, "@98g%r", &tot_impostap);
|
||
if (_tipo_reg == vendita && _corrispettivi)
|
||
if (tot_lordop != ZERO)
|
||
set_row(rr, "@116g%r", &tot_lordop);
|
||
}
|
||
if (tipo_prosp == 0) // Solo per il primo prospetto complessivo
|
||
{
|
||
if (_tipo_reg == acquisto)
|
||
rr = stampa_acquisti(rr);
|
||
else
|
||
rr += 3;
|
||
}
|
||
} // for
|
||
}
|
||
|
||
if (_stampa_plafonds)
|
||
stampa_plafonds(rr);
|
||
}
|
||
|
||
HIDDEN void print_real(TPrintrow& row, const real& num, int pos)
|
||
{
|
||
const TCurrency cur(num);
|
||
TString80 str = cur.string(true);
|
||
str.right_just(15);
|
||
row.put(str, pos);
|
||
}
|
||
|
||
bool TStampa_registri_app::stampa_plafonds(int r, bool test_mode)
|
||
{
|
||
TTable pla("%PLA");
|
||
TTable ppa("PPA");
|
||
TString80 chiave;
|
||
int num;
|
||
real r1, r2, r3, r8, r8b, r9, disponibile;
|
||
|
||
if (_tipo_stampa == libro_unico)
|
||
num = _fino_a_mese;
|
||
if ( _tipo_stampa == bollato || _tipo_stampa == prova || _tipo_stampa == rif_giornale )
|
||
num = _datareg.month();
|
||
|
||
TString16 nm; nm.format("%02d", num);
|
||
|
||
// forza il tipoatt a 1
|
||
chiave.format("%05ld", get_firm());
|
||
chiave << _annoes << _codatt << "1";
|
||
pla.put("CODTAB", chiave);
|
||
|
||
const bool print_now = r == -1;
|
||
TPrintrow riga;
|
||
TPrinter& pr = printer();
|
||
|
||
if (pla.read() == NOERR)
|
||
{
|
||
r1 = pla.get_real("R5"); //totali esp. art.8
|
||
r2 = pla.get_real("R6"); //totali esp. art.8 bis
|
||
r3 = pla.get_real("R7"); //totali esp. art 9
|
||
r8 = stampa_valori_plafonds(r1, num, ppa, "1"); // Disponibile art. 8
|
||
r8b = stampa_valori_plafonds(r2, num, ppa, "2"); // Disponibile art. 8 bis
|
||
r9 = stampa_valori_plafonds(r3, num, ppa, "3"); // Disponibile art. 9
|
||
disponibile = r8 + r8b + r9;
|
||
}
|
||
|
||
const bool print_prospect = (r1 > ZERO || r2 > ZERO || r3 > ZERO) && disponibile > ZERO;
|
||
|
||
if (test_mode)
|
||
return print_prospect;
|
||
|
||
if (print_prospect)
|
||
{
|
||
if (print_now)
|
||
{
|
||
riga.reset();
|
||
pr.print(riga);
|
||
riga.put(TR("QUADRO RELATIVO ALLA DISPONIBILITA' E UTILIZZAZIONE MENSILE DEI PLAFONDS"),0);
|
||
pr.print(riga);
|
||
}
|
||
else
|
||
{
|
||
set_row(++r, TR("QUADRO RELATIVO ALLA DISPONIBILITA' E UTILIZZAZIONE MENSILE DEI PLAFONDS"));
|
||
r++;
|
||
}
|
||
TString mese(9);
|
||
mese = itom(num);
|
||
mese.right_just();
|
||
|
||
if (print_now)
|
||
{
|
||
riga.reset();
|
||
pr.print(riga);
|
||
riga.put((const char*)mese, 0);
|
||
riga.put(TR("Disponibile"), 35);
|
||
print_real(riga, disponibile, 55);
|
||
pr.print(riga);
|
||
}
|
||
else
|
||
{
|
||
set_row(++r, FR("%s@35gDisponibile @55g%r"), (const char*)mese, &disponibile);
|
||
set_row(++r, "");
|
||
r++;
|
||
}
|
||
}
|
||
else
|
||
return false;
|
||
|
||
const bool is_bollato = _tipo_stampa == bollato;
|
||
|
||
if (r1 > ZERO)
|
||
{
|
||
if (r8 > ZERO && is_bollato || !is_bollato && !r8.is_zero())
|
||
{
|
||
real pri = ZERO;
|
||
real pre = ZERO;
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "1" << nm << "1";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri = ppa.get_real("R0");
|
||
pre = ppa.get_real("R1");
|
||
}
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "2" << nm << "1";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri += ppa.get_real("R0");
|
||
pre += ppa.get_real("R1");
|
||
}
|
||
disponibile -= pri + pre;
|
||
if (print_now)
|
||
{
|
||
riga.reset();
|
||
pr.print(riga);
|
||
riga.reset();
|
||
riga.put(TR("ART. 8 1<> comma lettere a-b"), 0);
|
||
pr.print(riga);
|
||
riga.reset();
|
||
riga.put(TR("Utilizzato all'interno"),0);
|
||
print_real(riga, pri, 55);
|
||
|
||
|
||
pr.print(riga);
|
||
riga.reset();
|
||
riga.put(TR("Utilizzato per l'importazione"),0);
|
||
print_real(riga, pre, 55);
|
||
pr.print(riga);
|
||
}
|
||
else
|
||
{
|
||
set_row(r++, TR("ART. 8 1<> comma lettere a-b"));
|
||
set_row(r++, FR("Utilizzato all'interno@55g%r"), &pri);
|
||
set_row(r++, FR("Utilizzato per l'importazione@55g%r"), &pre);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (r2 > ZERO)
|
||
{
|
||
if (r8b > ZERO && is_bollato || !is_bollato && !r8b.is_zero())
|
||
{
|
||
real pri = ZERO;
|
||
real pre = ZERO;
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "1" << nm << "2";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri = ppa.get_real("R0");
|
||
pre = ppa.get_real("R1");
|
||
}
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "2" << nm << "2";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri += ppa.get_real("R0");
|
||
pre += ppa.get_real("R1");
|
||
}
|
||
disponibile -= pri + pre;
|
||
r++;
|
||
if (print_now)
|
||
{
|
||
riga.reset();
|
||
pr.print(riga); pr.print(riga);
|
||
riga.put(TR("ART. 8 bis 1<> comma"), 0);
|
||
pr.print(riga);
|
||
riga.reset();
|
||
riga.put(TR("Utilizzato all'interno"),0);
|
||
print_real(riga, pri, 55);
|
||
|
||
pr.print(riga);
|
||
riga.reset();
|
||
riga.put(TR("Utilizzato per l'importazione"),0);
|
||
print_real(riga, pre, 55);
|
||
pr.print(riga);
|
||
}
|
||
else
|
||
{
|
||
set_row(r++, TR("ART. 8 bis 1<> comma"));
|
||
set_row(r++, FR("Utilizzato all'interno@55g%r"), &pri);
|
||
set_row(r++, FR("Utilizzato per l'importazione@55g%r"), &pre);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (r3 > ZERO)
|
||
{
|
||
if (r9 > ZERO && is_bollato || !is_bollato && !r9.is_zero())
|
||
{
|
||
real pri = ZERO;
|
||
real pre = ZERO;
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "1" << nm << "3";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri = ppa.get_real("R0");
|
||
pre = ppa.get_real("R1");
|
||
}
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "2" << nm << "3";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri += ppa.get_real("R0");
|
||
pre += ppa.get_real("R1");
|
||
}
|
||
disponibile -= pri + pre;
|
||
r++;
|
||
if (print_now)
|
||
{
|
||
riga.reset();
|
||
pr.print(riga);pr.print(riga);
|
||
riga.put(TR("ART. 9 1<> comma"), 0);
|
||
pr.print(riga);
|
||
riga.reset();
|
||
riga.put(TR("Utilizzato all'interno"),0);
|
||
print_real(riga, pri, 55);
|
||
pr.print(riga);
|
||
riga.reset();
|
||
riga.put(TR("Utilizzato per l'importazione"),0);
|
||
print_real(riga, pre, 55);
|
||
pr.print(riga);
|
||
}
|
||
else
|
||
{
|
||
set_row(r++, TR("ART. 9 1<> comma"));
|
||
set_row(r++, FR("Utilizzato all'interno@55g%r"), &pri);
|
||
set_row(r++, FR("Utilizzato per l'importazione@55g%r"), &pre);
|
||
}
|
||
}
|
||
}
|
||
if (r1 > ZERO || r2 > ZERO || r3 > ZERO)
|
||
if (print_now)
|
||
{
|
||
riga.reset();
|
||
pr.print(riga);
|
||
riga.put(TR("Riporto"),35);
|
||
print_real(riga, disponibile, 55);
|
||
pr.print(riga);
|
||
}
|
||
else
|
||
set_row(++r, FR("@35gRiporto @55g%r"), &disponibile);
|
||
return true;
|
||
}
|
||
|
||
real TStampa_registri_app::stampa_valori_plafonds(const real& r1, const int mese, TTable& ppa, const char* tipo)
|
||
{
|
||
real r, si8, se8;
|
||
TString80 chiave;
|
||
int i;
|
||
|
||
r = r1;
|
||
si8 = se8 = ZERO;
|
||
if (mese > 1)
|
||
{
|
||
for (i=1; i<mese; i++)
|
||
{
|
||
chiave = "";
|
||
TString16 m; m.format("%02d", i);
|
||
chiave << _annoes << _codatt << "1" << m << tipo;
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
si8 += ppa.get_real("R0");
|
||
se8 += ppa.get_real("R1");
|
||
}
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "2" << m << tipo;
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
si8 += ppa.get_real("R0");
|
||
se8 += ppa.get_real("R1");
|
||
}
|
||
}
|
||
r = r1 - si8 - se8;
|
||
}
|
||
return r;
|
||
}
|
||
|
||
bool TStampa_registri_app::some_IVAxCassa(int da_mese, int a_mese) const
|
||
{
|
||
if ((_tipo_reg != vendita || _corrispettivi) && _tipo_reg != acquisto )
|
||
return false;
|
||
|
||
if (ini_get_bool(CONFIG_STUDIO, "cg", "NoIdRg"))
|
||
return false;
|
||
|
||
if (_tipo_reg == acquisto && !gestione_IVAxCassa(_data_da))
|
||
{
|
||
int cazzone = 1;
|
||
// return false;
|
||
}
|
||
|
||
TString query;
|
||
query << "USE IVADIFF KEY 2 SELECT (TIPOMOV>2)&&(MESELIQ<13)&&(TIPOIVA=" << _tipo_reg << ')';
|
||
query << "\nFROM ANNOLIQ=" << _data_da.year() << " MESELIQ=" << da_mese;
|
||
query << "\nTO ANNOLIQ=" << _data_a.year() << " MESELIQ=" << a_mese;
|
||
TISAM_recordset id(query);
|
||
const TRecnotype recs = id.items();
|
||
|
||
#ifdef DBG
|
||
TString msg;
|
||
if (a_mese > da_mese)
|
||
msg << "Nei mesi da " << itom(da_mese) << " a " < itom(a_mese);
|
||
else
|
||
msg << "Nel mese di " << itom(da_mese);
|
||
msg << " ci sarebbero " << recs << " incassi/pagamenti per cassa.";
|
||
__trace(msg);
|
||
#endif
|
||
|
||
return recs > 0;
|
||
}
|
||
|
||
bool TStampa_registri_app::print_IVAxCassa(int da_month, int a_month)
|
||
{
|
||
// 3 Test paranoici gi<67> effettuati dalla funzione SomeIVAxCassa
|
||
|
||
if ((_tipo_reg != vendita || _corrispettivi) && _tipo_reg != acquisto)
|
||
return false;
|
||
|
||
// Non stampare il prospetto IVA differita sui registri
|
||
if (ini_get_bool(CONFIG_STUDIO, "cg", "NoIdRg"))
|
||
{
|
||
_riga_prospettoXcassa.destroy();
|
||
return false;
|
||
}
|
||
|
||
const bool IVAxCassa = gestione_IVAxCassa(_data_da);
|
||
if (_tipo_reg == acquisto && !IVAxCassa)
|
||
{
|
||
_riga_prospettoXcassa.destroy(); // ????
|
||
return false;
|
||
}
|
||
|
||
|
||
TPrinter& pr = printer();
|
||
TPrintrow riga;
|
||
const TString linea(_stampa_width, '-');
|
||
|
||
TDate data_da(1, da_month, _data_da.year());
|
||
if (data_da < _data_da)
|
||
data_da = _data_da;
|
||
|
||
TDate data_a = _data_a;
|
||
if (a_month < data_a.month())
|
||
{
|
||
data_a = TDate(1, a_month, _data_da.year());
|
||
data_a.set_end_month();
|
||
}
|
||
|
||
TString query;
|
||
query = "USE IVADIFF SELECT (BETWEEN(DATAREGP,#DAL,#AL))&&(MOV.REG=#REG)&&(STR((MESELIQ<13)&&(TIPOMOV>2)&&(MOV.TOTDOC>0)))";
|
||
query << "\nBY DATAREGP DATAREG NUMPRO";
|
||
query << "\nJOIN MOV INTO NUMREG==NUMREG";
|
||
query << "\nJOIN CLIFO TO MOV INTO TIPOCF==TIPO CODCF==CODCF";
|
||
TISAM_recordset id(query);
|
||
id.set_var("#DAL", data_da);
|
||
id.set_var("#AL", data_a);
|
||
id.set_var("#REG", _codreg);
|
||
|
||
// Sporco trucco per evitare intestazioni inutili
|
||
const bool il = _intesta_liq;
|
||
_intesta_liq = true;
|
||
|
||
const TRecnotype recs = id.items();
|
||
#ifdef DBG
|
||
TString msg;
|
||
if (a_month > a_month)
|
||
msg << "Nei mesi da " << itom(da_month) << " a " < itom(a_month);
|
||
else
|
||
msg << "Nel mese di " << itom(da_month);
|
||
msg << " ci sono effettivamente " << recs << " incassi/pagamenti per cassa.";
|
||
__trace(msg);
|
||
#endif
|
||
|
||
if (recs > 0)
|
||
{
|
||
riga.reset();
|
||
if (pr.rows_left() < pr.rows() && pr.rows_left() < id.items()+8)
|
||
{
|
||
pr.formfeed();
|
||
riga.put(linea, 0);
|
||
}
|
||
pr.print(riga);
|
||
|
||
riga.reset();
|
||
if (_tipo_reg == vendita)
|
||
{
|
||
TString msg = TR("DETTAGLIO INCASSI FATTURE CON IVA DIFFERITA");
|
||
if (IVAxCassa)
|
||
msg << TR(" O PER CASSA");
|
||
riga.put(msg, 40);
|
||
}
|
||
else
|
||
riga.put(TR("DETTAGLIO PAGAMENTI FATTURE CON IVA PER CASSA"), 40);
|
||
pr.print(riga);
|
||
|
||
riga.reset(); pr.print(riga);
|
||
|
||
riga.put(linea, 0); pr.print(riga);
|
||
|
||
riga.reset();
|
||
riga.put(TR("Documento"), 19);
|
||
riga.put(TR("T Tipo"), 66);
|
||
riga.put(TR("Forz"), 123);
|
||
if (_tipo_stampa == prova)
|
||
riga.put(TR("Num"), 128);
|
||
pr.print(riga);
|
||
|
||
riga.reset();
|
||
riga.put(TR("Data pag. prot."), 0);
|
||
riga.put(TR("Data"), 17);
|
||
riga.put(TR("Numero Codice Ragione Sociale"), 24);
|
||
riga.put(TR("O Doc."), 66);
|
||
riga.put(TR("Importo"), 78);
|
||
riga.put(TR("Imponibile"), 90);
|
||
riga.put(TR("IVA"), 102);
|
||
riga.put(TR("Imposta"), 115);
|
||
riga.put(TR("Scad"), 123);
|
||
if (_tipo_stampa == prova)
|
||
riga.put(TR("Reg"), 128);
|
||
pr.print(riga);
|
||
|
||
riga.put(linea, 0); pr.print(riga);
|
||
|
||
const TRectype& rec = id.cursor()->curr();
|
||
for (bool ok = id.move_first(); ok; ok = id.move_next())
|
||
{
|
||
const TString4 codiva = rec.get("CODIVA");
|
||
const real importo = rec.get("IMPORTO");
|
||
const real imponibile = rec.get("IMPONIBILE");
|
||
const real imposta = rec.get("IMPOSTA");
|
||
const int tipodiff = rec.get_int("TIPODIFF");
|
||
|
||
TString rs = id.get("CLIFO.RAGSOC").as_string();
|
||
rs.strip_double_spaces();
|
||
TParagraph_string clifo(rs, 27);
|
||
|
||
riga.reset();
|
||
riga.put(rec.get_date("DATAREGP").string(brief, '/'), 0);
|
||
riga.put(format("%6ld", id.get("MOV.PROTIVA").as_int()), 8);
|
||
riga.put(rec.get_date(MOV_DATAREG).string(brief, '/'), 15);
|
||
riga.put(id.get("MOV.NUMDOC").as_string(), 24);
|
||
riga.put(format("%6ld", id.get("CLIFO.CODCF").as_int()), 31);
|
||
riga.put(clifo.get(), 38);
|
||
riga.put(tipodiff == 2 ? "5" : "4", 66); // 4 = Differita; 5 = x Cassa;
|
||
riga.put(id.get("MOV.TIPODOC").as_string(), 68);
|
||
print_real(riga, importo, 70);
|
||
print_real(riga, imponibile, 85);
|
||
riga.put(rec.get("CODIVA"), 102);
|
||
print_real(riga, imposta, 107);
|
||
riga.put(rec.get_int("NUMPRO") >= 999 ? "X" : "", 123);
|
||
if (_tipo_stampa == prova)
|
||
riga.put(format("%6ld", rec.get_long(MOV_NUMREG)), 125);
|
||
pr.print(riga);
|
||
|
||
switch (tipodiff)
|
||
{
|
||
case 1: _riga_prospettoXcassa.add_riga(ZERO, ZERO, imponibile, imposta, ZERO, ZERO, codiva); break;
|
||
case 2: _riga_prospettoXcassa.add_riga(ZERO, ZERO, ZERO, ZERO, imponibile, imposta, codiva); break;
|
||
default: break;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_intesta_liq = il; // Ripristina flag intestazioni
|
||
return false; // Ho stampato qualcosa?
|
||
}
|
||
|
||
int flags = 0x0;
|
||
FOR_EACH_ARRAY_ITEM(_riga_prospettoXcassa, r, obj)
|
||
{
|
||
const TRiga& ri = *(const TRiga*)obj;
|
||
if (!ri._implordo.is_zero())
|
||
flags |= 0x1;
|
||
if (!ri._impostap.is_zero())
|
||
flags |= 0x2;
|
||
}
|
||
|
||
if (flags != 0x0)
|
||
{
|
||
riga.reset();
|
||
if (pr.rows_left() < _riga_prospettoXcassa.items()+8)
|
||
{
|
||
pr.formfeed();
|
||
riga.put(linea, 0);
|
||
}
|
||
pr.print(riga);
|
||
|
||
riga.reset();
|
||
pr.print(riga);
|
||
|
||
TString str = TR("PROSPETTO IMPORTI CON IVA NORMALE");
|
||
if (flags & 0x1)
|
||
str << ((flags == 0x1) ? TR(" ED ") : ", ") << TR("IVA DIFFERITA");
|
||
if (flags & 0x2)
|
||
str << " ED " << TR("IVA PER CASSA");
|
||
|
||
riga.put(str, (132-str.len())/2);
|
||
pr.print(riga);
|
||
|
||
riga.reset();
|
||
pr.print(riga);
|
||
|
||
riga.put(TR("NORMALE"), 45);
|
||
if (flags & 0x1)
|
||
riga.put(TR("DIFFERITA"), 78);
|
||
if (flags & 0x2)
|
||
riga.put(TR("PER CASSA"), 112);
|
||
pr.print(riga);
|
||
|
||
riga.reset();
|
||
riga.put(TR("IVA Descrizione"), 0);
|
||
riga.put(TR("Imponibile"), 34);
|
||
riga.put(TR("Imposta"), 53);
|
||
if (flags & 0x1)
|
||
{
|
||
riga.put(TR("Imponibile"), 68);
|
||
riga.put(TR("Imposta"), 87);
|
||
}
|
||
if (flags & 0x2)
|
||
{
|
||
riga.put(TR("Imponibile"), 102);
|
||
riga.put(TR("Imposta"), 121);
|
||
}
|
||
pr.print(riga);
|
||
|
||
real tot_imponib0, tot_imposta0, tot_imponib1, tot_imposta1, tot_imponib2, tot_imposta2;
|
||
_riga_prospettoXcassa.sort(compare_rows);
|
||
for (int s = 0; s < _riga_prospettoXcassa.items(); s++)
|
||
{
|
||
const TRiga& ri = _riga_prospettoXcassa.riga(s);
|
||
|
||
riga.reset();
|
||
riga.put(ri._codiva, 0);
|
||
riga.put(descr_iva(ri._codiva), 5);
|
||
print_real(riga, ri._imponibile, 29);
|
||
print_real(riga, ri._imposta, 45);
|
||
if (flags & 0x1)
|
||
{
|
||
print_real(riga, ri._implordo, 63);
|
||
print_real(riga, ri._imponibilep, 79);
|
||
}
|
||
if (flags & 0x2)
|
||
{
|
||
print_real(riga, ri._impostap, 97);
|
||
print_real(riga, ri._implordop, 113);
|
||
}
|
||
pr.print(riga);
|
||
|
||
tot_imponib0 += ri._imponibile;
|
||
tot_imposta0 += ri._imposta;
|
||
tot_imponib1 += ri._implordo;
|
||
tot_imposta1 += ri._imponibilep;
|
||
tot_imponib2 += ri._impostap;
|
||
tot_imposta2 += ri._implordop;
|
||
}
|
||
|
||
riga.reset();
|
||
pr.print(riga);
|
||
riga.put(TR("TOTALI"), 0);
|
||
print_real(riga, tot_imponib0, 29);
|
||
print_real(riga, tot_imposta0, 45);
|
||
if (flags & 0x1)
|
||
{
|
||
print_real(riga, tot_imponib1, 63);
|
||
print_real(riga, tot_imposta1, 79);
|
||
}
|
||
if (flags & 0x2)
|
||
{
|
||
print_real(riga, tot_imponib2, 97);
|
||
print_real(riga, tot_imposta2, 113);
|
||
}
|
||
pr.print(riga);
|
||
}
|
||
|
||
_riga_prospettoXcassa.destroy();
|
||
|
||
_intesta_liq = il; // Ripristina flag intestazioni
|
||
|
||
return true;
|
||
}
|
||
|
||
//********* PRINT!!! *********//
|
||
|
||
bool TStampa_registri_app::preprocess_print(int file, int counter)
|
||
{
|
||
if (file == LF_MOV)
|
||
{
|
||
long items = _cur->items();
|
||
if (!items)
|
||
return false;
|
||
_iva_array.destroy();
|
||
_riga_rmi.destroy();
|
||
_tot_iva_array.destroy();
|
||
_tot_prec_iva_array.destroy();
|
||
_doc_array.destroy();
|
||
_dataregp = "";
|
||
_esiste_riga_iva = false;
|
||
_auto_intraf = false;
|
||
_intesta_liq = false;
|
||
set_print_zero();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TStampa_registri_app::preprocess_page(int file, int counter)
|
||
{
|
||
if (file == LF_MOV)
|
||
{
|
||
if (counter) return true;
|
||
|
||
reset_print();
|
||
int rr = 0, riga = 0;
|
||
bool intra;
|
||
TString80 comune, prov, comcf, capcf, civcf, stacf;
|
||
TString80 viacf;
|
||
TString ragsoc, codfis, piva;
|
||
TString4 tipo_op = "";
|
||
|
||
TLocalisamfile& mov = _cur->file(LF_MOV);
|
||
TLocalisamfile& caus = _cur->file(LF_CAUSALI);
|
||
|
||
_datareg = mov.get_date(MOV_DATAREG);
|
||
|
||
if (_tipo_stampa != libro_unico && _liquidazione)
|
||
{
|
||
const int da = (_tipo_stampa == prova) ? _data_da.month() : 1;
|
||
const int a = _datareg.month();
|
||
for (int m = da; m < a; m++)
|
||
{
|
||
if (!_st_liq[m])
|
||
if (stampo_liquidazione(m))
|
||
{
|
||
_datareg = TDate(1, m, _annoes); // Meglio cosi'
|
||
TFilename t;
|
||
t.temp("reg");
|
||
if (_scelta == B0_settato || _scelta == prosegui_stampa)
|
||
{
|
||
if (_tipo_stampa == prova)
|
||
send_message('S',t, m);
|
||
else
|
||
send_message('s',t, m);
|
||
}
|
||
else //_scelta == prosegui_cal_stampa
|
||
{
|
||
if (_tipo_stampa == prova)
|
||
send_message('L', t, m);
|
||
else
|
||
send_message('l', t, m);
|
||
}
|
||
if (t.exist())
|
||
{
|
||
_intesta_liq = true;
|
||
if (!_mov_empty) printer().formfeed();
|
||
merge_export_file(t,false,true);
|
||
_intesta_liq = false;
|
||
reset_print();
|
||
remove(t);
|
||
}
|
||
}
|
||
_st_liq[m] = true;
|
||
}
|
||
}
|
||
|
||
_datareg = mov.get_date(MOV_DATAREG);
|
||
_mov_empty = false;
|
||
|
||
if ( _datareg.month() != _dataregp.month() && _dataregp.ok() )
|
||
{
|
||
_auto_intraf = false;
|
||
printer().formfeed();
|
||
_totali_stampati = false; //siamo al cambio periodo (mese/trimestre),quindi resetto il flag di stampa totali
|
||
_riporti_stampati = false;//e pure quello dei riporti,visto che "A Riporto" non va nella prima pagina del mese
|
||
}
|
||
|
||
_dataregp = _datareg;
|
||
|
||
TDate datadoc = mov.get_date(MOV_DATADOC);
|
||
long numreg = mov.get_long(MOV_NUMREG);
|
||
long protiva = mov.get_long(MOV_PROTIVA);
|
||
long uprotiva = mov.get_long(MOV_UPROTIVA);
|
||
TString16 numdoc = mov.get(MOV_NUMDOC);
|
||
int meseliq = mov.get_int(MOV_MESELIQ);
|
||
char tipocf = mov.get(MOV_TIPO)[0];
|
||
TString16 ocfpi = mov.get(MOV_OCFPI);
|
||
long codcf = mov.get_long(MOV_CODCF);
|
||
long numgio = mov.get_long(MOV_NUMGIO);
|
||
bool stampato = mov.get_bool(MOV_REGST);
|
||
TString4 codval = mov.get(MOV_CODVALI);
|
||
real corrval = mov.get_real(MOV_CORRVALUTA);
|
||
const bool autof = caus.get_bool(CAU_AUTOFATT);
|
||
|
||
const bool splitpay = tipocf == 'C' && is_split_payment(mov.curr());
|
||
const bool liqdiff = !splitpay && mov.get_bool(MOV_LIQDIFF);
|
||
const bool IVAxcassa= !splitpay && !liqdiff && mov.get_bool(MOV_IVAXCASSA);
|
||
|
||
TString80 descrcau = caus.get(CAU_DESCR);
|
||
|
||
real totdoc = mov.get_real(MOV_TOTDOC);
|
||
real ritsoc = mov.get_real(MOV_RITSOC);
|
||
real ritfis = mov.get_real(MOV_RITFIS);
|
||
if (totdoc < ZERO) // Controlla il segno corretto da assegnare alle ritenute
|
||
{
|
||
ritsoc = -ritsoc;
|
||
ritfis = -ritfis;
|
||
}
|
||
|
||
if (_cur->pos() == 0)
|
||
_uprotivap = uprotiva ? uprotiva : protiva;
|
||
|
||
//aggiornamento di mov
|
||
if (_tipo_stampa != prova)
|
||
if (!stampato)
|
||
{
|
||
mov.put(MOV_REGST,true);
|
||
mov.rewrite();
|
||
}
|
||
|
||
if (codcf == 0l)
|
||
ragsoc = descrcau;
|
||
else
|
||
{
|
||
ocfpi.trim();
|
||
comune = "";
|
||
prov = "";
|
||
if (ocfpi.empty())
|
||
{
|
||
TRectype dep = ricerca_cf(tipocf, codcf);
|
||
ragsoc = dep.get (CLI_RAGSOC); ragsoc.strip_double_spaces();
|
||
viacf = dep.get (CLI_INDCF);
|
||
civcf = dep.get (CLI_CIVCF);
|
||
capcf = dep.get (CLI_CAPCF);
|
||
comcf = dep.get (CLI_COMCF);
|
||
comune = dep.get (CLI_LOCCF);
|
||
stacf = dep.get (CLI_STATOCF);
|
||
codfis = dep.get (CLI_COFI);
|
||
piva = dep.get (CLI_STATOPAIV);
|
||
if (piva.not_empty())
|
||
piva << ' ';
|
||
piva << dep.get (CLI_PAIV);
|
||
char tipoa = dep.get_char(CLI_TIPOAPER);
|
||
if (tipoa == 'F')
|
||
{
|
||
TString80 cognome, nome;
|
||
cognome = ragsoc.mid(0,30);
|
||
nome = ragsoc.mid(30,20);
|
||
cognome.trim(); nome.trim();
|
||
ragsoc = cognome;
|
||
ragsoc << ' ' << nome;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
const TRectype& dep = ricerca_occ(ocfpi);
|
||
ragsoc = dep.get (OCC_RAGSOC);
|
||
viacf = dep.get (OCC_INDIR);
|
||
civcf = dep.get (OCC_CIV);
|
||
capcf = dep.get (OCC_CAP);
|
||
comcf = dep.get (OCC_COM);
|
||
stacf = dep.get (OCC_STATO);
|
||
codfis = "";
|
||
piva = "";
|
||
}
|
||
const TRectype& com = look_comuni(stacf,comcf);
|
||
if (!com.empty())
|
||
{
|
||
comune = com.get(COM_DENCOM);
|
||
prov = com.get(COM_PROVCOM);
|
||
}
|
||
}
|
||
|
||
_tipodoc = mov.get(MOV_TIPODOC);
|
||
_descr_doc = descr_doc();
|
||
TString app(datadoc.string(brief, '/'));
|
||
|
||
totdoc += ritsoc+ritfis;
|
||
|
||
if (_st_tot_fin)
|
||
_doc_array.add_riga(_tipodoc,_descr_doc,totdoc);
|
||
|
||
//setto le righe di stampa
|
||
_r = 1;
|
||
|
||
if (!_stampa_data_reg)
|
||
set_row(_r, "%s", (const char* ) _datareg.string(brief, '/'));
|
||
set_row(_r, "@9g%5ld", protiva);
|
||
if (datadoc.ok())
|
||
set_row(_r, "@15g%s", (const char*) app);
|
||
set_row(_r, "@24g%s", (const char*) numdoc);
|
||
if (codcf != 0l)
|
||
set_row(_r, "@31g%6ld", codcf);
|
||
if (meseliq > 0)
|
||
set_row(_r, "@62g%02d", meseliq);
|
||
set_row(_r, "@68g%2s", (const char*) _tipodoc);
|
||
if (_stampa_width == 132)
|
||
set_row(_r, "@70g%r", &totdoc);
|
||
else
|
||
set_row(_r, "@78g%r", &totdoc);
|
||
|
||
if (_tipo_stampa == prova) //in caso di stampa di prova
|
||
{
|
||
if (! (_tipo_reg == vendita && _corrispettivi)) //e se non si tratta di registro vendite corrispettivi
|
||
{
|
||
if (_cur->pos()!=0 || protiva <= 0) //il primo movimento non va controllato
|
||
{
|
||
if (protiva != _uprotivap + 1)
|
||
{
|
||
set_row(_r+1, FR(" @b*** NUM.PROT.FUORI SEQUENZA@r"));
|
||
riga = _r+2;
|
||
}
|
||
_uprotivap = uprotiva ? uprotiva : protiva;
|
||
}
|
||
}
|
||
|
||
if (mov.get_bool(MOV_IVAXCASSA) && mov.get_int(MOV_TIPOMOV) <= 0)
|
||
{
|
||
set_row(_r+1, FR(" @b*** IVA PER CASSA SENZA SALDACONTO@r"));
|
||
riga = _r+2;
|
||
}
|
||
}
|
||
|
||
const char* r;
|
||
int i = 1;
|
||
TParagraph_string desc(ragsoc, 23);
|
||
|
||
while ((r = desc.get()) != NULL)
|
||
{
|
||
set_row (i, "@38g%s", r);
|
||
i++;
|
||
}
|
||
if (i > riga) riga = i;
|
||
|
||
if (codcf != 0l && _stampa_ind_comp)
|
||
{
|
||
if (viacf.not_empty())
|
||
{
|
||
set_row (i++, "@38g%-.23s %-3s",(const char *)viacf, (const char *)civcf);
|
||
if (comune.not_empty())
|
||
set_row ( i++, "@38g%s %-.21s (%2s)", (const char *)capcf, (const char *)comune, (const char *)prov);
|
||
riga = i;
|
||
}
|
||
else if (comune.not_empty())
|
||
{
|
||
set_row ( i++, "@38g%s %-.21s (%2s)", (const char *)capcf, (const char *)comune, (const char *)prov);
|
||
riga = i;
|
||
}
|
||
|
||
if (codfis.not_empty() || piva.not_empty())
|
||
{
|
||
if (codfis.not_empty() && codfis != piva)
|
||
set_row ( i++, FR("@38gC.F. %s"), (const char*)codfis);
|
||
if (piva.not_empty())
|
||
set_row ( i++, FR("@38gP.I. %s"), (const char*)piva);
|
||
riga = i;
|
||
}
|
||
}
|
||
//progressivi righe iva azzerati
|
||
_progr_doc = 0;
|
||
_progr_impn = 0;
|
||
_progr_imps = 0;
|
||
const TRecnotype nrec = riga_rmoviva();
|
||
if (nrec > 0L)
|
||
{
|
||
_esiste_riga_iva = true;
|
||
for (int j = 0; j < _riga_rmi.items(); j++)
|
||
{
|
||
const TRigaiva& riga = _riga_rmi.riga(j);
|
||
const int tipodet = riga._tipodet;
|
||
rr = _r+j;
|
||
intra = riga._intra;
|
||
if (_stampa_width == 132)
|
||
{
|
||
set_row(rr, "@85g%r", &riga._imponibile);
|
||
set_row(rr, "@101g%4s",(const char*)riga._codiva);
|
||
if (_tipo_reg == acquisto)
|
||
set_row(rr, "@106g%d", tipodet);
|
||
set_row(rr, "@107g%r", &riga._imposta);
|
||
|
||
set_row(rr, "@123g%d", riga._tipocr);
|
||
if (_tipoatt == "E" && _tipo_reg != acquisto)
|
||
set_row(rr, "@125g%d", riga._tipoatt);
|
||
if (_tipo_stampa == rif_giornale) //stampa con riferimento al libro giornale
|
||
set_row(rr, "@126g%5ld", numgio);
|
||
}
|
||
else //stampa a 198
|
||
{
|
||
set_row(rr, "@93g%r", &riga._imponibile);
|
||
|
||
set_row(rr, "@109g%4s",(const char*)riga._codiva);
|
||
if (_tipo_reg == acquisto)
|
||
set_row(rr, "@114g%d", tipodet);
|
||
set_row(rr, "@116g%r", &riga._imposta);
|
||
|
||
if (_tipoatt == "E" && _tipo_reg != acquisto)
|
||
set_row(rr, "@132g%d", riga._tipoatt);
|
||
set_row(rr, "@134g%d", riga._tipocr);
|
||
if (_tipo_stampa == rif_giornale) //stampa con riferimento al libro giornale
|
||
set_row(rr, "@136g%7ld", numgio);
|
||
}
|
||
//*****Calcolo dei progressivi (un casino mondiale!!!)
|
||
_progr_impn += riga._imponibile;
|
||
_progr_imps += riga._imposta;
|
||
|
||
}
|
||
//*****aggiornamento del totale documento,imponibile e imposta progressivi
|
||
const real totdoc = mov.get_real(MOV_TOTDOC);
|
||
_progr_doc = totdoc;
|
||
|
||
if (_rows_left > 0)
|
||
{
|
||
_totdoc_prog += _progr_doc; //progressivo totale documento
|
||
_totimpn_prog += _progr_impn; // " imponibile
|
||
_totimps_prog += _progr_imps; // " imposta
|
||
|
||
}
|
||
|
||
_riga_rmi.destroy();
|
||
}
|
||
|
||
if (intra && autof)
|
||
{
|
||
_auto_intraf = true;
|
||
tipo_op = "3";
|
||
} else
|
||
if (intra)
|
||
tipo_op = "1"; else
|
||
if (autof)
|
||
tipo_op = "2"; else
|
||
if (splitpay)
|
||
{
|
||
tipo_op = "6";
|
||
}
|
||
else
|
||
{
|
||
if (liqdiff)
|
||
tipo_op = "4"; else
|
||
if (IVAxcassa)
|
||
tipo_op = "5";
|
||
}
|
||
|
||
set_row(_r, "@66g%s", (const char*)tipo_op);
|
||
|
||
if (_tipo_stampa == prova) //stampa di prova
|
||
{
|
||
if (_stampa_width == 132)
|
||
{
|
||
set_row(_r, "@126g%5ld", numreg);
|
||
if (stampato)
|
||
set_row(_r, "@131g*"); //solo in stampa di prova!
|
||
}
|
||
else //198
|
||
{
|
||
set_row(_r, "@136g%7ld", numreg);
|
||
if (stampato)
|
||
set_row(_r, "@144g*");
|
||
}
|
||
}
|
||
if (_tipo_stampa == rif_giornale && _stampa_width == 198)
|
||
{
|
||
TLocalisamfile rmoviva (LF_RMOVIVA);
|
||
rmoviva.zero();
|
||
rmoviva.put(RMI_NUMREG,numreg);
|
||
TRectype rec(rmoviva.curr());
|
||
rmoviva.read(_isgteq);
|
||
for ( ; !rmoviva.eof(); rmoviva.next())
|
||
{
|
||
if (rmoviva.curr() != rec) break;
|
||
|
||
int gruppo = rmoviva.get_int("GRUPPO");
|
||
int conto = rmoviva.get_int("CONTO");
|
||
long sottoc = rmoviva.get_long("SOTTOCONTO");
|
||
TBill tc (gruppo,conto,sottoc);
|
||
TString80 descr = tc.descrizione();
|
||
set_row(_r, "@144g%3d %3d %6d", gruppo, conto, sottoc);
|
||
set_row(_r, "@159g%-.39s", (const char*) descr);
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (riga <= rr)
|
||
riga = ++rr;
|
||
|
||
if (!corrval.is_zero())
|
||
{
|
||
TCurrency curr(corrval, codval);
|
||
TString80 vall = curr.string(true);
|
||
vall.right_just(19);
|
||
set_row(riga, FR("@24gCodice valuta %-3s Corrispettivo in valuta %s"), (const char*)codval, (const char*)vall);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
print_action TStampa_registri_app::postprocess_page (int file, int counter)
|
||
{
|
||
if (file == LF_MOV)
|
||
{
|
||
if (counter) //dopo aver fatto un REPEAT_PAGE (cioe' dopo aver stampato
|
||
//le righe settate in set_page_tot_reg()), in pratica a rottura di mese o alla fine
|
||
{
|
||
reset_print();
|
||
|
||
const TRecnotype pos = _cur->pos();
|
||
const TRecnotype items = _cur->items();
|
||
const bool last_mov = pos == items-1;
|
||
|
||
if (_stampa_plafonds && !last_mov)
|
||
{
|
||
// Nel caso sia richiesta la stampa prospetto mensile plafond e vi siano mesi
|
||
// senza movimenti, <20> necessario forzarne la stampa
|
||
const TDate save_date(_datareg);
|
||
|
||
// Caso speciale, in cui non vi siano movimenti sull'ultimo mese indicato in stampa
|
||
//const bool print_over = last_mov && _dataregp == _dataregs && _dataregp.month() < _data_a.month();
|
||
|
||
const int m1 = _dataregp.month()+1;
|
||
const int m2 = _dataregs.month();
|
||
for (int kk = m1; kk < m2; kk++)
|
||
{
|
||
_datareg = TDate(1, kk, _annoes);
|
||
if (stampa_plafonds(-1, true))
|
||
{
|
||
printer().formfeed();
|
||
stampa_plafonds(-1);
|
||
}
|
||
}
|
||
_datareg = save_date;
|
||
}
|
||
|
||
const int a_mese = _datareg.month();
|
||
int da_mese = 0;
|
||
if (_frequiva == 'T')
|
||
{
|
||
if (a_mese % 3 == 0)
|
||
da_mese = a_mese-2;
|
||
}
|
||
else
|
||
da_mese = a_mese;
|
||
if (da_mese > 0)
|
||
{
|
||
if (some_IVAxCassa(da_mese, a_mese))
|
||
{
|
||
printer().formfeed();
|
||
print_IVAxCassa(da_mese, a_mese);
|
||
da_mese = 0; // vieta ristampa!
|
||
}
|
||
_riga_prospettoXcassa.destroy(); // Elimina comunque tracking movimenti
|
||
}
|
||
|
||
if (_liquidazione)
|
||
{
|
||
if (!_st_liq[a_mese] && stampo_liquidazione(a_mese))
|
||
{
|
||
_st_liq[a_mese] = true;
|
||
if (_scelta == B0_settato)
|
||
liq_b0_settato();
|
||
|
||
|
||
if (_scelta == prosegui_stampa || _scelta == prosegui_cal_stampa)
|
||
{
|
||
if (_t.exist())
|
||
{
|
||
printer().formfeed();
|
||
_intesta_liq = true;
|
||
merge_export_file(_t,false,true);
|
||
_intesta_liq = false;
|
||
remove(_t);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (last_mov)
|
||
{
|
||
if (_stampa_plafonds || (_tipo_stampa != libro_unico && _liquidazione))
|
||
stampa_liq_mesi_succ();
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
int da = _datareg.month() + 1;
|
||
int a = _data_a.month();
|
||
for (int m=da; m<=a; m++)
|
||
{
|
||
TDate data(1, m, _annoes);
|
||
data.set_end_month();
|
||
scrivi_reg(data);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
const TRectype& mov = _cur->curr(LF_MOV);
|
||
const TRecnotype pos = _cur->pos();
|
||
const long items = _cur->items();
|
||
const bool FINITO = (pos == items-1);
|
||
if ( FINITO )
|
||
{
|
||
liq_other_case();
|
||
if (_tipo_stampa != prova)
|
||
calcola_progressivi();
|
||
set_page_tot_reg();
|
||
return REPEAT_PAGE;
|
||
}
|
||
else
|
||
{
|
||
_cur->save_status();
|
||
++(*_cur);
|
||
_dataregs = mov.get_date(MOV_DATAREG);
|
||
--(*_cur);
|
||
_cur->restore_status();
|
||
|
||
if (_dataregs.month() != _dataregp.month())
|
||
{
|
||
liq_other_case();
|
||
if (_tipo_stampa != prova)
|
||
calcola_progressivi();
|
||
set_page_tot_reg();
|
||
return REPEAT_PAGE;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return NEXT_PAGE;
|
||
}
|
||
|
||
//--------- Intestazione (un casino allucinante!!!) ---------//
|
||
|
||
int TStampa_registri_app::stampa_intestazione()
|
||
{
|
||
int r = 1;
|
||
TString riga(_stampa_width);
|
||
|
||
get_dati_ditta();
|
||
riga.format(FR("Ditta %ld %s %s %s %s %s"), get_firm(),
|
||
(const char*)_ragsoc, (const char*)_viafis,
|
||
(const char*)_cap, (const char*)_comunefis,
|
||
(const char*)_provfis);
|
||
|
||
set_header (r++, riga);
|
||
|
||
riga.format("");
|
||
if (_tipo_stampa == prova)
|
||
{
|
||
riga.format(FR("REGISTRO DI PROVA Data %s"), TDate(TODAY).string());
|
||
riga.right_just(_stampa_width);
|
||
}
|
||
|
||
TString80 tmp;
|
||
tmp.format(FR("Partita iva %s Codice fiscale %s"), (const char*)_paiva, (const char*)_cofi);
|
||
riga.overwrite(tmp);
|
||
set_header (r, riga);
|
||
|
||
return r;
|
||
}
|
||
|
||
void TStampa_registri_app::preprocess_header()
|
||
{
|
||
int r=1;
|
||
char cor, nd1, nd2;
|
||
char tipo = ' ';
|
||
char type = ' ';
|
||
int mese, anno;
|
||
|
||
if (_tipo_stampa != libro_unico)
|
||
{
|
||
mese = _datareg.month();
|
||
anno = _datareg.year();
|
||
}
|
||
else //se _tipo_stampa == 3 (su libro unico) sto stampando un solo mese
|
||
{
|
||
mese = _fino_a_mese;
|
||
anno = _annoes;
|
||
}
|
||
|
||
TString data;
|
||
if (mese > 0)
|
||
data.format(FR("mese di %s %d"), itom(mese), anno);
|
||
|
||
reset_header();
|
||
|
||
if (_tipo_stampa == bollato || _tipo_stampa == rif_giornale)
|
||
{
|
||
if (_stampa_ind_ditta)
|
||
r = stampa_intestazione();
|
||
else
|
||
r+=2;
|
||
}
|
||
else // se stampa di prova o su libro unico l'intestazione della ditta va sempre stampata
|
||
r = stampa_intestazione();
|
||
|
||
if (_stampa_num_pag) // Stampa numero di pagina in alto a destra
|
||
{
|
||
TString16 numpag, riga;
|
||
numpag.format("%d/%d", _annoes, _numini+printer().getcurrentpage());
|
||
const int tab = _stampa_width - numpag.len();
|
||
riga.format("@%dg%s", tab, (const char*)numpag);
|
||
set_header(1, riga); // Sempre sulla prima riga!
|
||
}
|
||
|
||
if (_tipo_stampa == libro_unico && !_intesta_vidi)
|
||
{
|
||
++_u_stampata;
|
||
++_pagine_stampate;
|
||
}
|
||
|
||
if (_tipo_stampa == bollato || _tipo_stampa == rif_giornale)
|
||
++_pagine_stampate;
|
||
|
||
if (_tipo_stampa == libro_unico)
|
||
set_header(r, FR("@94gProgr.Studio %ld@114gProgr.Utente %ld"), _u_stampata, _pagine_stampate);
|
||
|
||
// cosi' sono sicura che l'aggiornamento viene fatto ad ogni salto pagina (cioe' a rottura di mese)
|
||
if (_tipo_stampa != prova)
|
||
aggiorna_reg(_ok_vidi);
|
||
|
||
r++;
|
||
|
||
if (!_intesta_vidi)
|
||
{
|
||
if (_intesta_liq)
|
||
set_header(r, FR("Registro IVA: %s %s %s"), (const char*)_codreg,
|
||
(const char*)_desc_lib, (const char*) data);
|
||
else
|
||
{
|
||
if (_annoes > 2007)
|
||
{
|
||
TString key;
|
||
|
||
key.format("%ld|%s", _ditta, (const char *)_codatt);
|
||
const TString16 codateco = cache().get(LF_ATTIV, key, ATT_CODATECO);
|
||
|
||
set_header(r, FR("Registro IVA: %s %s %s Attivita\' %s %s"),
|
||
(const char*) _codreg, (const char*) _desc_lib,
|
||
(const char*) data, (const char*) codateco,
|
||
(const char*) _attivita);
|
||
}
|
||
else
|
||
set_header(r, FR("Registro IVA: %s %s %s Attivita\' %s %s"),
|
||
(const char*) _codreg, (const char*) _desc_lib,
|
||
(const char*) data, (const char*) _codatt,
|
||
(const char*) _attivita);
|
||
|
||
}
|
||
}
|
||
else
|
||
{
|
||
set_header(r++, FR("Registro IVA: %s %s"), (const char *) _codreg, (const char *) _desc_lib);
|
||
set_header(r, TR("RIFERIMENTI VIDIMAZIONE"));
|
||
}
|
||
|
||
//se sto stampando sul registro la liquidazione
|
||
//l'intestazione (piuttosto dettagliata) e' gestita
|
||
//dal prg di liquidazione perche' molte info che devono
|
||
//comparire in questa intestazione la stampa reg. non le conosce.
|
||
const TString riga(_stampa_width, '-');
|
||
|
||
//non sto stampando la liquidazione
|
||
if (!_intesta_liq)
|
||
{
|
||
r++;
|
||
set_header(r++, riga);
|
||
|
||
if (_tipo_reg == vendita) //registro vendite
|
||
{
|
||
cor = 'R'; // Ricavi
|
||
nd1 = ' ';
|
||
nd2 = ' ';
|
||
}
|
||
if (_tipo_reg == acquisto)
|
||
{
|
||
cor = 'C'; // Cessioni
|
||
nd1 = 'N';
|
||
nd2 = 'D';
|
||
}
|
||
if (_tipoatt == "E") //attivita' mista
|
||
{
|
||
tipo = 'A';
|
||
type = 'T';
|
||
}
|
||
if (_tipo_stampa == prova) //stampa di prova (_intesta_vidi e' di sicuro false)
|
||
{
|
||
if (_tipo_reg == riepilogativo)
|
||
set_header(r++,TR("RIEPILOGO TOTALI REGISTRI IVA"));
|
||
else
|
||
{
|
||
if (_stampa_width == 132)
|
||
{
|
||
set_header(r,FR("@10gNum.@19gDocumento@61gMese@66gT Tipo@102gCod %c@123gT %c@128gNum"), nd1, tipo);
|
||
r++;
|
||
set_header(r, FR("Data reg. prot.@17gData@24gNumero Codice Ragione sociale/descr. liq.@66gO Doc.@74gTotale doc.@90gImponibile Iva %c@115gImposta@123g%c %c@128gReg"), nd2, cor, type);
|
||
r++;
|
||
}
|
||
else //stampa a 198
|
||
{
|
||
set_header(r,FR("Registrazione Documento@61gMese@66gT Tipo@110gCod %c@132g%c T@139gNum."), nd1, tipo, cor);
|
||
r++;
|
||
set_header(r, FR("Data Protocollo Data@24gNumero Codice Ragione sociale/descr. liq.@66gO Documento@80gTot.Documento@98gImponibile Iva %c@124gImposta@132g%c %c@139gReg."), nd2, type, cor);
|
||
r++;
|
||
}
|
||
}
|
||
}
|
||
else if (!_intesta_vidi)
|
||
{
|
||
if (_tipo_reg == riepilogativo)
|
||
set_header(r++,TR("RIEPILOGO TOTALI REGISTRI IVA"));
|
||
else
|
||
{
|
||
if (_stampa_width == 132)
|
||
{
|
||
set_header(r,FR("@10gNum.@19gDocumento@61gMese@66gT Tipo@102gCod %c@123gT %c"), nd1, tipo);
|
||
if (_tipo_stampa == rif_giornale) //stampa definitiva con rif. al libro giornale
|
||
set_header(r, FR("@128gNum."));
|
||
r++;
|
||
set_header(r, FR("Data reg. prot.@17gData@24gNumero Codice Ragione sociale/descr. liq.@66gO Doc.@74gTotale doc.@90gImponibile Iva %c@115gImposta@123g%c %c"),
|
||
nd2, cor, type);
|
||
if (_tipo_stampa == rif_giornale)
|
||
set_header(r, FR("@128gop."));
|
||
r++;
|
||
}
|
||
else //stampa a 198
|
||
{
|
||
set_header(r,FR("Registrazione Documento@61gMese@66gT Tipo@110gCod %c@132g%c T"), nd1, tipo);
|
||
if (_tipo_stampa == rif_giornale)
|
||
set_header(r, FR("@139gNum."));
|
||
r++;
|
||
set_header(r, FR("Data Protocollo Data@24gNumero Codice Ragione sociale/descr. liq.@66gO Documento@80gTot.Documento@98gImponibile Iva %c@124gImposta@132g%c %c"), nd2, type, cor);
|
||
if (_tipo_stampa == rif_giornale)
|
||
set_header(r, FR("@139gop. @144gCodice conto @159gDescrizione sottoconto"));
|
||
r++;
|
||
}
|
||
}
|
||
}
|
||
else if (_tipo_stampa == libro_unico && _intesta_vidi)
|
||
{
|
||
TString tr(52);
|
||
tr.fill('-');
|
||
set_header(r++,FR("@10gPagine studio Pagine utente ---------------- V I D I M A Z I O N E %s"), (const char*)tr);
|
||
set_header(r++,FR("Mese@12gda@20ga@27gda@35ga Intestatario@71gN.fogli Pag.in. Pag.fin. Data Ufficio"));
|
||
}
|
||
|
||
if (_tipo_reg != riepilogativo)
|
||
if (_stampa_ind_comp && !_intesta_vidi)
|
||
set_header(r++, FR("@38gGeneralita'"));
|
||
|
||
set_header(r++, riga);
|
||
|
||
//*****valori della riga Riporto
|
||
if (_riporti_stampati)
|
||
{
|
||
if (_stampa_width == 132)
|
||
set_header(r++, FR("@0gRiporto progressivi@70g%15s@85g%15s@107g%15s"),
|
||
_totdoc_prog.string(".2"), _totimpn_prog.string(".2"), _totimps_prog.string(".2"));
|
||
if (_stampa_width == 198)
|
||
set_header(r++, FR("@0gRiporto progressivi@78g%15s@93g%15s@116g%15s"),
|
||
_totdoc_prog.string(".2"), _totimpn_prog.string(".2"), _totimps_prog.string(".2"));
|
||
|
||
if (_rows_left == 0)
|
||
{
|
||
_totdoc_prog += _progr_doc;
|
||
_totimpn_prog += _progr_impn;
|
||
_totimps_prog += _progr_imps;
|
||
}
|
||
set_header(r++, riga);
|
||
_totali_stampati = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
void TStampa_registri_app::preprocess_footer()
|
||
{
|
||
reset_footer();
|
||
|
||
if (!_totali_stampati)
|
||
{
|
||
int r=1;
|
||
TString riga(_stampa_width);
|
||
riga.fill('-');
|
||
set_footer(r++, riga);
|
||
|
||
if (_stampa_width == 132)
|
||
set_footer(r++, FR("@0gTotale progressivi@70g%15s@85g%15s@107g%15s"),
|
||
_totdoc_prog.string(".2"), _totimpn_prog.string(".2"), _totimps_prog.string(".2"));
|
||
if (_stampa_width == 198)
|
||
set_footer(r++, FR("@0gTotale progressivi@78g%15s@93g%15s@116g%15s"),
|
||
_totdoc_prog.string(".2"), _totimpn_prog.string(".2"), _totimps_prog.string(".2"));
|
||
|
||
set_footer(r++, riga);
|
||
_riporti_stampati = true;
|
||
}
|
||
else
|
||
_riporti_stampati = false;
|
||
}
|
||
|
||
void TStampa_registri_app::on_page_printed(int file)
|
||
{
|
||
if (file == LF_MOV)
|
||
{
|
||
_rows_left = printer().rows_left();
|
||
}
|
||
}
|
||
|
||
bool TStampa_registri_app::stampo_liquidazione(int mese)
|
||
{
|
||
//test tradotti alla lettera da AS/400
|
||
//assolutamente incongruenti !!!
|
||
const bool trim_month_flag = (_frequiva == 'T' && (mese == 3 || mese == 6 || mese == 9 || mese == 12))
|
||
||_frequiva != 'T' || (mese == 12 && _tipo_riepilogativo == 'A');
|
||
|
||
if (_tipo_stampa == prova)
|
||
{
|
||
if (trim_month_flag)
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
if (trim_month_flag)
|
||
if ( (mese == 12 && _tipo_riepilogativo == 'A' && _mese_ultima_liq != 13)
|
||
|| (mese != 12 && mese > _mese_ultima_liq)
|
||
|| (mese == 12 && _tipo_riepilogativo != 'A' && mese > _mese_ultima_liq) )
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void TStampa_registri_app::liq_b0_settato()
|
||
{
|
||
TFilename f;
|
||
f.temp("rg");
|
||
if (_tipo_stampa == prova)
|
||
send_message('S', f, _datareg.month());
|
||
else
|
||
send_message('s', f, _datareg.month());
|
||
|
||
if (f.exist())
|
||
{
|
||
printer().formfeed();
|
||
_intesta_liq = true;
|
||
merge_export_file(f,false,true);
|
||
_intesta_liq = false;
|
||
remove(f);
|
||
}
|
||
}
|
||
|
||
void TStampa_registri_app::liq_other_case()
|
||
{
|
||
const bool calc_reg = _annoes > 1997; // Flag per effettuare nuovo calcolo registri
|
||
char tipo_messaggio; // Tipo messaggio per chiamata a programma calcolo/stampa liquidazione
|
||
|
||
switch (_scelta)
|
||
{
|
||
case prosegui_cal_stampa:
|
||
tipo_messaggio = 'L'; // Stampa Liquidazione con ricalcolo
|
||
break;
|
||
case prosegui_stampa:
|
||
tipo_messaggio = 'S'; // Stampa Liquidazione senza ricalcolo
|
||
break;
|
||
default:
|
||
tipo_messaggio = '\0';
|
||
break;
|
||
}
|
||
|
||
if (_tipo_stampa != prova)
|
||
tipo_messaggio = tolower(tipo_messaggio); // Prova o definitiva ?
|
||
|
||
// Calcolo/Stampa liquidazione
|
||
if (stampo_liquidazione(_datareg.month()) && tipo_messaggio != '\0')
|
||
{
|
||
_t.temp("reg");
|
||
send_message(tipo_messaggio, _t, _datareg.month());
|
||
}
|
||
|
||
// Ricalcolo Progressivi Registri. Il vecchio calcolo viene mantenuto. Nel
|
||
// caso si tratti di un nuovo anno, chiama il nuovo calcolo specifico per registri.
|
||
if (_tipo_stampa != prova)
|
||
{ // Se sta stampando i bollati ricalcola sempre (ignorando il flag LIM->B1, a causa delle nuove norme)
|
||
// Cio' viene fatto poiche' in caso di ripristino di stampa registro bollato
|
||
// sarebbe necessario un ricalcolo progressivi per sicurezza.
|
||
if (ricalcola(_fino_a_mese) || calc_reg)
|
||
{
|
||
TFilename app; app.temp();
|
||
int mese = _fino_a_mese;
|
||
//se la frequenza e' trimestrale
|
||
//aggiusta il mese al trimestre a cui appartiene
|
||
if (_frequiva == 'T')
|
||
mese += 2 - ((mese-1) % 3);
|
||
send_message(calc_reg ? 'R' : 'C', app, calc_reg ? _datareg.month() : mese);
|
||
}
|
||
}
|
||
}
|
||
|
||
void TStampa_registri_app::stampa_vidi()
|
||
{
|
||
TLocalisamfile IndBil (LF_INDLIB);
|
||
TTable TabVid ("%VID");
|
||
TString16 codreg;
|
||
TString16 vid;
|
||
long ditta, pagfin, pagfinut;
|
||
int mese;
|
||
TPrintrow row;
|
||
|
||
_ok_vidi = false;
|
||
|
||
if (!printer().isopen())
|
||
printer().open();
|
||
|
||
IndBil.zero();
|
||
IndBil.put("ANNO", _annoes);
|
||
IndBil.put("CODLIB", _codlib);
|
||
TRectype rec (IndBil.curr());
|
||
IndBil.read (_isgteq);
|
||
for (; !IndBil.eof(); IndBil.next())
|
||
{
|
||
if (IndBil.curr() != rec) break;
|
||
ditta = IndBil.get_long("CODDITTA");
|
||
codreg = IndBil.get("CODREG");
|
||
if (ditta == _ditta && codreg == _codreg)
|
||
{
|
||
if (!_ok_vidi)
|
||
{
|
||
++_u_stampata;
|
||
++_pagine_stampate;
|
||
_ok_vidi = true;
|
||
}
|
||
mese = IndBil.get_int("MESEREG");
|
||
pagfin = IndBil.get_long("PAGFIN");
|
||
pagfinut = IndBil.get_long("PAGFINUT");
|
||
if (mese == 12)
|
||
{
|
||
++pagfin;
|
||
++pagfinut;
|
||
TRectype nuovo (IndBil.curr());
|
||
nuovo.put("PAGFIN", pagfin);
|
||
nuovo.put("PAGFINUT", pagfinut);
|
||
IndBil.rewrite(nuovo);
|
||
}
|
||
row.reset();
|
||
row.put(format("%s", itom(mese)), 0);
|
||
row.put(format("%5ld", IndBil.get_long("PAGINI")), 10);
|
||
row.put(format("%5ld", pagfin), 17);
|
||
row.put(format("%5ld", IndBil.get_long("PAGINIUT")), 25);
|
||
row.put(format("%5ld", pagfinut), 32);
|
||
vid = IndBil.get("CODVID");
|
||
TabVid.zero();
|
||
TabVid.put("CODTAB", vid);
|
||
if (TabVid.read() == NOERR)
|
||
{
|
||
row.put(format("%-.32s", (const char*)TabVid.get("S0")), 39);
|
||
row.put(format("%7d",TabVid.get_long("I0")), 71);
|
||
row.put(format("%7d",TabVid.get_long("I1")), 79);
|
||
row.put(format("%7d",TabVid.get_long("I2")), 87);
|
||
TDate d(TabVid.get_long("D0"));
|
||
row.put(format("%s", (const char*)d.string()), 95);
|
||
row.put(format("%-.26s", (const char*)TabVid.get("S1")), 106);
|
||
}
|
||
printer().print(row);
|
||
}
|
||
}
|
||
printer().close();
|
||
}
|
||
|
||
//------ dopo la stampa devo aggiornare i registri, ecc. ------//
|
||
|
||
void TStampa_registri_app::scrivi_reg(const TDate& data)
|
||
{
|
||
TString16 codtab;
|
||
TTable Tabreg ("REG");
|
||
|
||
codtab << _annoes << _codreg;
|
||
Tabreg.zero();
|
||
Tabreg.put("CODTAB", codtab);
|
||
if (Tabreg.read() == NOERR)
|
||
{
|
||
const TDate d = Tabreg.get_date("D3");
|
||
if (!_mov_empty) //cioe' se e' stata stampata almeno una pagina
|
||
{
|
||
TDate ultima_data(data);
|
||
ultima_data.set_end_month(); // Meglio cosi'
|
||
|
||
if (ultima_data > d)
|
||
Tabreg.put("D3", ultima_data);
|
||
}
|
||
else if (_data_a > d)
|
||
Tabreg.put("D3", _data_a);
|
||
|
||
if (_tipo_reg == acquisto && _stampa_cred_pre)
|
||
if (_mese_credito == 0 && _credito > ZERO)
|
||
if (_mov_empty)
|
||
Tabreg.put("I8", (long)_fino_a_mese);
|
||
else Tabreg.put("I8", (long)_datareg.month());
|
||
|
||
Tabreg.rewrite();
|
||
}
|
||
|
||
if (_tipo_stampa == libro_unico)
|
||
{
|
||
TString16 cod = "";
|
||
TTable lbu ("%LBU");
|
||
|
||
cod << _annoes << _codlib;
|
||
lbu.zero();
|
||
lbu.put("CODTAB", cod);
|
||
if (lbu.read() == NOERR)
|
||
{
|
||
lbu.put("I0", (long) _fino_a_mese);
|
||
lbu.rewrite();
|
||
}
|
||
}
|
||
}
|
||
|
||
void TStampa_registri_app::aggiorna_reg(const bool aggiorna_vidi)
|
||
{
|
||
TString16 codtab;
|
||
TTable Tabreg ("REG");
|
||
TLocalisamfile IndBil (LF_INDLIB);
|
||
|
||
codtab << _annoes << _codreg;
|
||
Tabreg.zero();
|
||
Tabreg.put("CODTAB", codtab);
|
||
if (Tabreg.read() == NOERR)
|
||
{
|
||
TDate d = Tabreg.get_date("D3");
|
||
if (!_mov_empty) //cioe' se e' stata stampata almeno una pagina
|
||
{ //controllo inutile visto che e' chiamata nella
|
||
//preprocess_header
|
||
TDate ultima_data(_datareg);
|
||
ultima_data.set_end_month();
|
||
|
||
if (ultima_data > d)
|
||
Tabreg.put("D3", ultima_data);
|
||
}
|
||
else if (_data_a > d)
|
||
Tabreg.put("D3", _data_a);
|
||
|
||
Tabreg.put("I1", _pagine_stampate);
|
||
|
||
if (_intesta_liq)
|
||
if (_tipo_riepilogativo == 'A')
|
||
Tabreg.put("I4", 13L);
|
||
else Tabreg.put("I4", (long)_datareg.month());
|
||
|
||
if (_tipo_reg == acquisto && _stampa_cred_pre)
|
||
if (_mese_credito == 0 && _credito > ZERO)
|
||
if (_mov_empty)
|
||
Tabreg.put("I8", (long)_fino_a_mese);
|
||
else Tabreg.put("I8", (long)_datareg.month());
|
||
|
||
Tabreg.rewrite();
|
||
}
|
||
|
||
if (_tipo_stampa == libro_unico) //stampa su libro unico
|
||
|
||
// sul file indlib (indice libro unico) devo generare una riga per ogni
|
||
// registro stampato (ricordarsi che la stampa su libro unico deve
|
||
// avvenire mese per mese!)
|
||
// inoltre non posso stampare due volte lo stesso mese perche' la stampa
|
||
// avviene a fine mese
|
||
{
|
||
long numero_riga = 1L;
|
||
if (!aggiorna_vidi)
|
||
{
|
||
bool trovato = false;
|
||
|
||
IndBil.zero();
|
||
|
||
TRectype nuovo(IndBil.curr());
|
||
|
||
IndBil.put("ANNO", _annoes);
|
||
IndBil.put("CODLIB", _codlib);
|
||
TRectype rec (IndBil.curr());
|
||
|
||
for (IndBil.read(_isgteq); !IndBil.eof(); IndBil.next())
|
||
{
|
||
if (IndBil.curr() != rec) break;
|
||
|
||
int annoreg = IndBil.get_int("ANNOREG");
|
||
int mesereg = IndBil.get_int("MESEREG");
|
||
long cditta = IndBil.get_long("CODDITTA");
|
||
TString16 codreg = IndBil.get("CODREG");
|
||
TString16 codvid = IndBil.get("CODVID");
|
||
if (_annoes == annoreg && _fino_a_mese == mesereg
|
||
&& _ditta == cditta && codreg == _codreg && _codice_vidi == codvid)
|
||
{
|
||
trovato = true;
|
||
numero_riga = IndBil.get_long("NUMREG");
|
||
break;
|
||
}
|
||
else numero_riga = IndBil.get_long("NUMREG") + 1;
|
||
// cosi' mi posiziono su quel mese (altrimenti rischio di generare
|
||
// due righe per lo stesso mese e registro => la stampa di vidimazione
|
||
// mi sballa!!!,
|
||
}
|
||
nuovo.put("ANNO", _annoes);
|
||
nuovo.put("CODLIB", _codlib);
|
||
nuovo.put("NUMREG", numero_riga);
|
||
|
||
nuovo.put("ANNOREG", _annoes);
|
||
nuovo.put("MESEREG", _fino_a_mese); // su libro unico ho un solo mese in gioco!
|
||
nuovo.put("PAGINI", _primast + 1); // numero iniziale pagina libro unico
|
||
nuovo.put("PAGFIN", _u_stampata); // numero finale pagina libro unico
|
||
nuovo.put("CODDITTA", _ditta);
|
||
nuovo.put("CODREG", _codreg);
|
||
nuovo.put("CODVID", _codice_vidi);
|
||
nuovo.put("PAGINIUT", _numini + 1);
|
||
nuovo.put("PAGFINUT", _pagine_stampate);
|
||
|
||
if (!trovato)
|
||
IndBil.write(nuovo);
|
||
else IndBil.rewrite(nuovo);
|
||
}
|
||
aggiorna_lib();
|
||
}
|
||
}
|
||
|
||
void TStampa_registri_app::aggiorna_lib()
|
||
{
|
||
TString16 cod = "";
|
||
TTable lbu ("%LBU");
|
||
|
||
cod << _annoes << _codlib;
|
||
lbu.zero();
|
||
lbu.put("CODTAB", cod);
|
||
if (lbu.read() == NOERR)
|
||
{
|
||
lbu.put("I0", (long) _fino_a_mese);
|
||
lbu.put("I1", (long) _u_stampata);
|
||
lbu.rewrite();
|
||
}
|
||
}
|
||
|
||
void TStampa_registri_app::clear_stliq()
|
||
{
|
||
for (int i=0; i <= 12; i++)
|
||
_st_liq[i] = false;
|
||
}
|
||
|
||
bool TStampa_registri_app::setta_mask(long i)
|
||
{
|
||
if (_stampa_mese == 13) _stampa_mese = 0;
|
||
if (_tipo_stampa == bollato || _tipo_stampa == rif_giornale)
|
||
{
|
||
TMask mb("cg4400b");
|
||
mb.set(F_CODDITTA, _ditta);
|
||
mb.set(F_RAGSOC, _ditte->row(i).get(2));
|
||
mb.set(COD_LIB, _codreg);
|
||
const char* m = "";
|
||
m = format("%02d", _stampa_mese);
|
||
mb.set(U_MESE, m);
|
||
mb.set(U_PAGINA, _pagine_stampate);
|
||
if (_u_data.ok())
|
||
mb.set(U_DATA, _u_data.string());
|
||
KEY tasto = mb.run();
|
||
if (tasto != K_ENTER)
|
||
return false;
|
||
//MI3213
|
||
_pagine_stampate = mb.get_long(U_PAGINA);
|
||
_numini = _pagine_stampate;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
//In questa funzione veniva gestita la stampa della liquidazione
|
||
//(anche se in un mese non si hanno movimenti occorre comunque
|
||
//stampare la liquidazione (se sul registro che sto stampando
|
||
//c'e' il flag di stampa liquidazione e, in caso di bollato, non
|
||
//era gia' scesa precedentemente)).
|
||
//Viene anche gestita la stampa del registro
|
||
//RIEPILOGATIVO (essendo un registro su cui non vengono registrati
|
||
//movimenti)
|
||
void TStampa_registri_app::no_movimenti()
|
||
{
|
||
TRecnotype rec = _tabreg->recno();
|
||
_mov_empty = true;
|
||
int da = 1, a = _fino_a_mese;
|
||
if (_tipo_stampa == bollato || _tipo_stampa == rif_giornale)
|
||
{
|
||
if (_tipo_stampa == rif_giornale)
|
||
da = 1;
|
||
else
|
||
{
|
||
// da = _frequiva == 'M' ? _fino_a_mese : _fino_a_mese-2; // Mi sembra pi<70> sensato 19/06/2013
|
||
da = _data_da.month(); // Mi sembra ancora pi<70> sensato 18/12/2014
|
||
if (_frequiva == 'T')
|
||
{
|
||
da = ((da-1) / 3) * 3 + 1;
|
||
CHECKD(da < a, "Mese iniziale non valido per trimestrale ", da);
|
||
}
|
||
}
|
||
} else
|
||
if (_tipo_stampa == libro_unico)
|
||
da = _fino_a_mese; else
|
||
if (_tipo_stampa == prova)
|
||
{
|
||
da = _data_da.month();
|
||
a = _data_a.month();
|
||
}
|
||
|
||
//RICALCOLO PROGRESSIVI per registro riepilogativo
|
||
//il ricalcolo dei progressivi mensili viene sempre
|
||
//fatto, se B1 e' false, anche se poi il riepilogativo
|
||
//non verra' stampato (se il mese richiesto non e'
|
||
//in accordo con la frequenza di stampa del registro stesso)
|
||
//Il ricalcolo nel caso di riepilogativo avviene sempre,
|
||
//a causa della separazione dei progressivi per registri, ma
|
||
//solo se l'anno in questione e oltre il 1997, cio<69> prima della effettiva
|
||
//separazione dei progressivi.
|
||
const bool calc = _tipo_reg == riepilogativo && _annoes > 1997;
|
||
if (ricalcola(a) || calc)
|
||
{
|
||
TFilename app;
|
||
app.temp();
|
||
int mese = a;
|
||
// se la frequenza e' trimestrale aggiusta il mese al trimestre a cui appartiene
|
||
if (_frequiva == 'T')
|
||
{
|
||
mese += 2 - ((mese-1) % 3);
|
||
if (calc)
|
||
{
|
||
send_message('R', app, mese-2); // Guy!!!
|
||
send_message('R', app, mese-1); // Guy!!!
|
||
}
|
||
}
|
||
send_message(calc ? 'R' : 'C', app, calc ? a : mese);
|
||
}
|
||
|
||
if (some_IVAxCassa(da, a))
|
||
{
|
||
if (! printer().isopen())
|
||
printer().open();
|
||
print_IVAxCassa(da, a);
|
||
}
|
||
_riga_prospettoXcassa.destroy(); // Elimina comunque tracking movimenti
|
||
|
||
if (_tipo_reg == riepilogativo || _liquidazione || _stampa_plafonds)
|
||
{
|
||
for (int m = da; m <= a; m++)
|
||
{
|
||
if (_tipo_reg == riepilogativo)
|
||
{
|
||
bool stsbol = false;
|
||
if (_tipo_stampa != prova) //stampa su bollato
|
||
if (_u_data.ok())
|
||
if (m <= _u_data.month()) stsbol = true;
|
||
|
||
if (!stsbol) //cioe' se il mese che sto considerando e'
|
||
//maggiore dell'ultima data di stampa del registro
|
||
{
|
||
if (_freq_riepilogo == 'M' ||
|
||
(m == 3 || m == 6 || m == 9 || m == 12))
|
||
{
|
||
_datareg = TDate(1, m, _annoes);
|
||
if (stampa_riepilogo(m))
|
||
printer().formfeed();
|
||
}
|
||
}
|
||
}
|
||
|
||
// In prova va stampato per ogni mese (sia Mensile che Trimestrale);
|
||
// in bollato, solo per i mesi che ancora mancano)
|
||
const bool print_plafond_bollato = _tipo_stampa != prova && (m == 1 || m > _u_data.month());
|
||
if (_stampa_plafonds && (_tipo_stampa == prova || print_plafond_bollato))
|
||
{
|
||
if (! printer().isopen())
|
||
printer().open();
|
||
_datareg = TDate(1, m, _annoes);
|
||
if (stampa_plafonds(-1)) // Con -1 compone e stampa printrows all'istante
|
||
printer().formfeed();
|
||
}
|
||
|
||
//la funzione stampo_liquidazione non stampera' la liquidazione sul
|
||
//registro il cui mese di stampa ultima liq. e' > del mese in esame
|
||
//caso a parte il mese 12 (che posso ristampare 2 volte)
|
||
if (_liquidazione && stampo_liquidazione(m))
|
||
{
|
||
if (_tipo_reg == riepilogativo)
|
||
{
|
||
if (!(_freq_riepilogo == 'M' ||
|
||
(m == 3 || m == 6 || m == 9 || m == 12))) continue;
|
||
}
|
||
|
||
if (! printer().isopen())
|
||
printer().open();
|
||
|
||
TFilename f;
|
||
f.temp("rgp");
|
||
_datareg = TDate(1, m, _annoes); // serve alla preprocess_header
|
||
if (_scelta == B0_settato || _scelta == prosegui_stampa)
|
||
{
|
||
if (_tipo_stampa == prova)
|
||
send_message('S',f, m);
|
||
else
|
||
send_message('s',f, m);
|
||
}
|
||
else //_scelta == prosegui_cal_stampa
|
||
{
|
||
if (_tipo_stampa == prova)
|
||
send_message('L', f, m);
|
||
else
|
||
send_message('l', f, m);
|
||
}
|
||
if (f.exist())
|
||
{
|
||
_intesta_liq = true;
|
||
merge_export_file(f,false,true);
|
||
printer().formfeed();
|
||
_intesta_liq = false;
|
||
remove(f);
|
||
}
|
||
}
|
||
}//for
|
||
}
|
||
_tabreg->readat(rec);
|
||
|
||
if (printer().isopen()) printer().close();
|
||
|
||
//aggiorno il registro anche se non ho stampato proprio nulla per quel mese!
|
||
if (_tipo_stampa != prova)
|
||
scrivi_reg(_datareg);
|
||
}
|
||
|
||
void TStampa_registri_app::stampa_liq_mesi_succ()
|
||
{
|
||
int da = _datareg.month() + 1;
|
||
int a = _data_a.month();
|
||
for (int m = da; m <= a; m++)
|
||
{
|
||
_datareg = TDate(1, m, _annoes);
|
||
if (_stampa_plafonds && stampa_plafonds(-1, true))
|
||
{
|
||
printer().formfeed();
|
||
stampa_plafonds(-1);
|
||
}
|
||
|
||
if (stampo_liquidazione(m))
|
||
{
|
||
TFilename t;
|
||
t.temp("iva");
|
||
|
||
if (_scelta == B0_settato || _scelta == prosegui_stampa)
|
||
{
|
||
if (_tipo_stampa == prova)
|
||
send_message('S',t, m);
|
||
else
|
||
send_message('s',t, m);
|
||
}
|
||
else //_scelta == prosegui_cal_stampa
|
||
{
|
||
if (_tipo_stampa == prova)
|
||
send_message('L', t, m);
|
||
else
|
||
send_message('l', t, m);
|
||
}
|
||
|
||
if (fexist(t))
|
||
{
|
||
_intesta_liq = true;
|
||
printer().formfeed();
|
||
merge_export_file(t,false,true);
|
||
_intesta_liq = false;
|
||
remove(t);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void TStampa_registri_app::send_message(char tipo, const TFilename& nome, int mese)
|
||
{
|
||
const char* app = "cg4 -2";
|
||
|
||
if (tipo == 'S' || tipo == 's')
|
||
app = "cg4 -2 -S";
|
||
else if (tipo == 'C' || tipo == 'R')
|
||
app = "cg4 -2 -C";
|
||
else
|
||
app = "cg4 -2";
|
||
|
||
TToken_string ss(36);
|
||
ss.add(_annoes);
|
||
if (_tipo_riepilogativo == 'A' && mese == 12)
|
||
ss.add(13);
|
||
else
|
||
ss.add(mese);
|
||
ss.add(_ditta);
|
||
ss.add(tipo);
|
||
ss.add(_data_stampa.string());
|
||
ss.add(nome);
|
||
ss.add(_riep_liq ? 'X' : ' ');
|
||
ss.add(printer().formlen() - _size_header - RIGHE_FOOTER);
|
||
|
||
TMessage liq (app, "RCL", ss);
|
||
liq.send();
|
||
|
||
TExternal_app pn(app);
|
||
pn.run();
|
||
|
||
xvt_sys_sleep(1000);
|
||
}
|
||
|
||
bool TStampa_registri_app::set_print(int n)
|
||
{
|
||
TMask m ("cg4400a");
|
||
|
||
m.set_handler (TIPO_STAMPA, mask_tipo_stampa);
|
||
m.set_handler (DA_DATA, mask_data);
|
||
m.set_handler (A_DATA, mask_data);
|
||
m.set_handler (MESE, mask_mese);
|
||
m.set_handler (FINO_A_MESE, mask_mese);
|
||
m.set_handler (CODICE_LIB_UN, mask_cod);
|
||
m.set_handler (CODICE_LIBRO_IVA, mask_libun);
|
||
m.set_handler (F_ANNULLA, mask_azzera);
|
||
m.set_handler (A_CODICE, to_ditt_handler);
|
||
m.set_handler (DA_CODICE, fr_ditt_handler);
|
||
m.set_handler (ANNO, year_freq_handler);
|
||
m.set_handler (F_FREQUENZA, year_freq_handler);
|
||
|
||
m.set(DA_CODICE, get_firm());
|
||
m.set(A_CODICE, get_firm(), 0x3);
|
||
|
||
m.set(F_SELECT, _ditte->checked());
|
||
set_choice_limits(m);
|
||
|
||
set_real_picture("###.###.###.###");
|
||
set_magic_currency(true);
|
||
|
||
bool ok = true;
|
||
while (ok = set_ditte(m))
|
||
{
|
||
if (!_ditte->one_checked())
|
||
{
|
||
warning_box(TR("Nessuna ditta selezionata!"));
|
||
continue;
|
||
}
|
||
//*****azzeramento dei totali progressivi e dei flag di controllo della loro stampa
|
||
_totdoc_prog = 0;
|
||
_totimpn_prog = 0;
|
||
_totimps_prog = 0;
|
||
_rows_left = 69;
|
||
_riporti_stampati = false;
|
||
_totali_stampati = false;
|
||
|
||
_annoes = m.get_int(ANNO);//in realta' e' l'anno IVA !!!
|
||
_tipo_stampa = (tipo_stampa) m.get_int(TIPO_STAMPA);
|
||
_stampa_len = m.get_int(STAMPA_LEN);
|
||
_tabname = (_annoes > 1997) ? "PRM" : "PIM"; // Dal 1998 in poi utilizza i PRM e non i PIM
|
||
if (m.get_int(STAMPA_WIDTH) == 1)
|
||
_stampa_width = 132;
|
||
else
|
||
_stampa_width = 198;
|
||
if (_stampa_len != 0)
|
||
printer().formlen(_stampa_len);
|
||
printer().footerlen(RIGHE_FOOTER);
|
||
//Se stampa di prova l'utente indica data_da e data_a
|
||
if (_tipo_stampa == prova)
|
||
{
|
||
_data_stampa = m.get(DATA_STAMPA);
|
||
_data_da = m.get(DA_DATA);
|
||
_data_a = m.get(A_DATA);
|
||
|
||
if (!_data_da.ok())
|
||
_data_da = TDate(1, 1, _annoes); // Meglio cosi'
|
||
|
||
if (!_data_a.ok())
|
||
_data_a = TDate(31, 12, _annoes); // Meglio cosi'
|
||
|
||
const TDate d(31,12,_annoes);
|
||
if (_data_a == d)
|
||
_tipo_riepilogativo = m.get(TIPO_RIEPILOGATIVO)[0];
|
||
else
|
||
_tipo_riepilogativo = ' ';
|
||
printer().setdate(_data_stampa);
|
||
}
|
||
else //stampe definitive
|
||
{
|
||
if (_tipo_stampa == bollato || _tipo_stampa == rif_giornale)
|
||
{
|
||
_fino_a_mese = m.get_int(FINO_A_MESE);
|
||
_data_da = TDate(1, 1, _annoes); // Meglio cosi'
|
||
}
|
||
else //stampa su libro unico
|
||
{
|
||
_codlib = m.get(CODICE_LIB_UN);
|
||
_fino_a_mese = m.get_int(MESE);
|
||
_u_stampata = m.get_int(ULTIMA_PAGINA);
|
||
_rif_vid = m.get_bool(RIF_VID);
|
||
_primast = _u_stampata;
|
||
_data_da = TDate(1, _fino_a_mese, _annoes); // Meglio cosi'
|
||
}
|
||
|
||
int giorni_del_mese = 31;
|
||
if (_fino_a_mese == 12)
|
||
{
|
||
giorni_del_mese = 31;
|
||
_tipo_riepilogativo = m.get(TIPO_RIEPILOGATIVO)[0];
|
||
}
|
||
else
|
||
{
|
||
_tipo_riepilogativo = ' ';
|
||
TDate primo(1, _fino_a_mese, _annoes);
|
||
primo.set_end_month(); // Meglio cosi'
|
||
giorni_del_mese = primo.day();
|
||
}
|
||
_data_a = TDate(giorni_del_mese, _fino_a_mese, _annoes); // Meglio cosi'
|
||
}
|
||
_stampa_data_reg = stampa_datareg();
|
||
if (_tipo_stampa == libro_unico)
|
||
compila_lib();
|
||
stampa_registri_IVA(m);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//********* FUNZIONE PRINCIPALE *********//
|
||
|
||
bool TStampa_registri_app::stampa_registri_IVA(const TMask& m)
|
||
{
|
||
bool ok = false;
|
||
TRectype mov_from(LF_MOV), mov_to(LF_MOV);
|
||
|
||
FOR_EACH_CHECKED_ROW(*_ditte, i, riga)
|
||
{
|
||
bool msg = true;
|
||
_ditta = riga->get_long(1);
|
||
_frequiva = riga->get_char(3);
|
||
_intesta_liq = false;
|
||
_intesta_vidi = false;
|
||
_primast = _u_stampata;
|
||
_ok_vidi = false;
|
||
_stampa_mese = 13;
|
||
|
||
TApplication::set_firm(_ditta);
|
||
_st_tot_fin = stampa_totali_finali();
|
||
look_lia();
|
||
ok = compila_reg(m);
|
||
if (!ok) continue;
|
||
if (_tipo_stampa == bollato || _tipo_stampa == rif_giornale)
|
||
{
|
||
if (!controlla_mov())
|
||
{
|
||
TApplication::set_firm(__firm);
|
||
return error_box(TR("Finire di stampare registri anno precedente"));
|
||
}
|
||
}
|
||
if (!_stampa_tutti_i_registri)
|
||
{
|
||
_scelta = no_liquidazione;
|
||
mov_from.put(MOV_DATAREG, _data_da);
|
||
mov_to.put(MOV_DATAREG, _data_a);
|
||
_cur->setregion(mov_from, mov_to);
|
||
_cur->set_filterfunction(filter_func, true);
|
||
//la filter function viene chiamata quando posiziono il cursore
|
||
//e' lei che determina _stampa_mese da settare in setta_mask
|
||
(*_cur) = 0L;
|
||
ok = setta_mask(i);
|
||
if (!ok) continue;
|
||
if (_liquidazione)
|
||
{
|
||
_size_header = 3;
|
||
if ((_tipo_stampa == bollato || _tipo_stampa == rif_giornale) && !_stampa_ind_ditta) _size_header++;
|
||
clear_stliq();
|
||
//l'inizializzazione di _scelta vale per tutti
|
||
//i mesi da stampare di un certo registro (su
|
||
//cui c'e' la X di stampa liquidazione). Cio'
|
||
//e' molto importante (per capire vedi appunti)
|
||
_scelta = controlla_liquidazione();
|
||
if (_scelta == non_proseguire)
|
||
return false;
|
||
}
|
||
const long item = _cur->items();
|
||
|
||
// 17.5.95 Leggo parametri di stampa del registro
|
||
|
||
const long codditta = get_firm();
|
||
TString16 config; config.format("REG%05ld%s", codditta, (const char*)_codreg);
|
||
printer().read_configuration(config);
|
||
|
||
_mov_empty = true;
|
||
|
||
if (item > 0l)
|
||
{
|
||
print();
|
||
if (is_cancelled())
|
||
return false;
|
||
}
|
||
else //non ci sono movimenti da stampare nel periodo richiesto!
|
||
no_movimenti();
|
||
|
||
if (_tipo_stampa == libro_unico && _rif_vid)
|
||
{
|
||
_intesta_vidi = true;
|
||
stampa_vidi(); //stampa riferimenti vidimazione
|
||
}
|
||
}
|
||
else //stampa tutti i registri
|
||
{
|
||
_scelta = controlla_liquidazione();
|
||
if (_scelta == non_proseguire)
|
||
return false;
|
||
|
||
TDate sca_vid;
|
||
bool one_printed = false; // Flag per vedere se ha stampato almeno un registro (solo per rif. al libro giornale)
|
||
for (_tabreg->first(); !_tabreg->eof(); _tabreg->next())
|
||
{
|
||
_tipo_reg = (tiporeg)_tabreg->get_int("I0");
|
||
const TString16 codtab = _tabreg->get("CODTAB");
|
||
const int anno = atoi(codtab.left(4));
|
||
if (anno > _annoes)
|
||
break;
|
||
if (anno == _annoes)
|
||
//registro iva
|
||
if (_tipo_reg == vendita || _tipo_reg == acquisto || _tipo_reg == riepilogativo)
|
||
{
|
||
_codreg = codtab.mid(4,3);
|
||
const TString8 cod_lib_un = _tabreg->get("S6");
|
||
sca_vid = _tabreg->get_date("D1");
|
||
_stampa_plafonds = _tabreg->get_char ("S10") == 'X';
|
||
_stampa_num_pag = _tabreg->get_char ("S11") == 'X';
|
||
_stampa_ind_ditta = _tabreg->get_bool("B9");
|
||
_liquidazione = _tabreg->get_bool("B7");
|
||
if (_tipo_stampa != prova)
|
||
_u_data = _tabreg->get_date("D3");
|
||
if (_tipo_stampa == bollato || _tipo_stampa == rif_giornale)
|
||
{
|
||
if (cod_lib_un.not_empty())
|
||
continue;
|
||
if (sca_vid.ok())
|
||
if (sca_vid.month() < _fino_a_mese)
|
||
continue;
|
||
if (_u_data.ok())
|
||
if (_data_a < _u_data) //e' molto imp. che rimanga < e non <= !!!
|
||
{ //(per via del discorso liq. annuale)
|
||
message_box(FR("Ditta %ld: Il registro %s <20> gi<67> stato stampato come bollato di %s"),
|
||
_ditta, (const char*) _codreg, itom(_fino_a_mese));
|
||
continue;
|
||
}
|
||
}
|
||
if (_tipo_stampa == rif_giornale) //stampa con riferimenti al libro giornale
|
||
{
|
||
TDate d;
|
||
bool good;
|
||
bool trovato = cerca_libro_gio(d, good);
|
||
if (trovato)
|
||
one_printed = true;
|
||
else
|
||
continue;
|
||
} else
|
||
if (_tipo_stampa == libro_unico) //stampa su libro unico
|
||
{
|
||
if (cod_lib_un != _codlib)
|
||
continue;
|
||
if (sca_vid.ok())
|
||
if (sca_vid.month() < _fino_a_mese)
|
||
continue;
|
||
if (_u_data.ok())
|
||
if (_fino_a_mese < _u_data.month()) //significa che e' gia'
|
||
continue; //stato stampato
|
||
}
|
||
msg = false;
|
||
|
||
look_reg();
|
||
|
||
_intesta_liq = false;
|
||
_intesta_vidi = false;
|
||
_primast = _u_stampata; //per la numerazione dei registri successivi
|
||
_ok_vidi = false;
|
||
_stampa_mese = 13;
|
||
_scelta = no_liquidazione;
|
||
|
||
//modifica del 09/11/1995
|
||
mov_from.put(MOV_DATAREG, _data_da);
|
||
mov_to.put(MOV_DATAREG, _data_a);
|
||
_cur->setregion(mov_from, mov_to);
|
||
_cur->set_filterfunction(NULL);
|
||
_cur->set_filterfunction(filter_func, true);
|
||
(*_cur) = 0L;
|
||
ok = setta_mask(i);
|
||
if (!ok) continue;
|
||
|
||
if (_liquidazione)
|
||
{
|
||
_size_header = 3;
|
||
if ((_tipo_stampa == bollato || _tipo_stampa == rif_giornale) && !_stampa_ind_ditta)
|
||
_size_header++;
|
||
clear_stliq();
|
||
//N.B. E' fondamentale che _scelta venga ri-inizializzata ad ogni
|
||
//registro(cioe' dopo la stampa di ciascuno). Infatti il B0 di un
|
||
//certo mese puo' essere cambiato durante la stampa di un certo
|
||
//registro
|
||
_scelta = controlla_liquidazione();
|
||
if (_scelta == non_proseguire)
|
||
return false;
|
||
}
|
||
// Guardo se ci sono movimenti
|
||
const long items = _cur->items();
|
||
|
||
//Leggo parametri di stampa del registro
|
||
const long codditta = get_firm();
|
||
const char* reg = (const char*)_codreg;
|
||
TString16 config; config.format("REG%05ld%s", codditta, reg);
|
||
printer().read_configuration(config);
|
||
|
||
_mov_empty = true;
|
||
|
||
if (items > 0l)
|
||
{
|
||
print();
|
||
if (is_cancelled())
|
||
return false;
|
||
}
|
||
else
|
||
no_movimenti();
|
||
|
||
if (_tipo_stampa == libro_unico && _rif_vid)
|
||
{
|
||
_intesta_vidi = true;
|
||
stampa_vidi(); //stampa riferimenti vidimazione
|
||
}
|
||
}
|
||
} //for
|
||
|
||
if (_tipo_stampa == rif_giornale && !one_printed) // stampa con rif libro giornale
|
||
message_box(FR("Ditta %ld: nessun registro soddisfa i parametri indicati"), _ditta);
|
||
|
||
if (msg)
|
||
if(_tipo_stampa == libro_unico && _fino_a_mese == 1 && _ditte->checked() == 1L)
|
||
message_box(FR("Ditta %ld: nessun registro soddisfa i parametri indicati"), _ditta); //viene gia' dato nell'handler
|
||
} //da Gennaio)
|
||
}
|
||
printer().read_configuration();
|
||
TApplication::set_firm(__firm);
|
||
return true;
|
||
}
|
||
|
||
//Stampa registro riepilogativo
|
||
bool TStampa_registri_app::stampa_riepilogo(int m)
|
||
{
|
||
TRiga_array vect, vect_prec;
|
||
TRigaiva_array vect_det;
|
||
bool stampato = false;
|
||
if (!printer().isopen())
|
||
printer().open();
|
||
|
||
_tabreg->put("CODTAB", _annoes);
|
||
for (int err = _tabreg->read(_isgteq); err == NOERR; err = _tabreg->next()) // Scorre i registri
|
||
{
|
||
const TString8 codtab = _tabreg->get("CODTAB");
|
||
const int a = atoi(codtab.mid(0,4));
|
||
if (a > _annoes)
|
||
break;
|
||
|
||
const tiporeg tipo = (tiporeg)_tabreg->get_int("I0");
|
||
|
||
if (a == _annoes && (tipo == vendita || tipo == acquisto))
|
||
{
|
||
const TString4 codreg = codtab.mid(4,3);
|
||
const TString8 codatt = _tabreg->get("S8");
|
||
//devo stampare sul riepilogativo
|
||
//solo i registri movimentati!!!
|
||
vect.destroy();
|
||
vect_prec.destroy();
|
||
vect_det.destroy();
|
||
TString80 chiave; chiave << _annoes << _tabreg->get("S8");
|
||
|
||
// Calcolo riepilogo del periodo e progressivi in caso di stampa su bollato
|
||
for (int i=1; i<=m; i++)
|
||
{
|
||
int start = 0, stop = i==m ? 1 : 0; // Per il mese attuale si calcolano anche i progressivi precedenti a questo periodo (PRP)
|
||
for (int j = start; j <= stop; j++)
|
||
{
|
||
const bool calc_prp = j == 1;
|
||
|
||
TTable tab(calc_prp ? "PRP" : _tabname);
|
||
tab.put("CODTAB", chiave);
|
||
|
||
const TRectype r(tab.curr());
|
||
tab.read(_isgteq);
|
||
for (; !tab.eof() && tab.curr() == r; tab.next())
|
||
{
|
||
const TString80 ctab = tab.get("CODTAB");
|
||
TString4 creg = ctab.mid(10,3); creg.trim();
|
||
const int mese = atoi(ctab.mid(13,2));
|
||
if (codreg == creg && mese == i)
|
||
{
|
||
const TString4 codiva = ctab.mid(16,4);
|
||
const int tipodet = atoi(ctab.mid(20,1));
|
||
real impon = tab.get_real("R0");
|
||
real impos = tab.get_real("R1");
|
||
real impol = tab.get_real("R2");
|
||
if (_tabreg->get_bool("B0"))
|
||
{
|
||
TToken_string cs(tab.get("S2"),'!');
|
||
impon = cs.get(0);
|
||
impos = cs.get(1);
|
||
}
|
||
if (_tabreg->get_bool("B1"))
|
||
{
|
||
impon = tab.get_real("R11");
|
||
impos = tab.get_real("R12");
|
||
}
|
||
TToken_string fatt_rit(tab.get("S1"),'!');
|
||
real im(fatt_rit.get(0));
|
||
real is(fatt_rit.get(1));
|
||
impon += im;
|
||
impos += is;
|
||
impol += im+is;
|
||
if (impon != ZERO || impos != ZERO || impol != ZERO)
|
||
{
|
||
if (!calc_prp && _tipo_stampa != prova)
|
||
vect.add_riga(ZERO, ZERO, ZERO, impon,impos,impol,codiva);
|
||
|
||
if (mese == m || (_frequiva == 'T' && mese >= m-2 && mese <= m)) // Guy!!!
|
||
if (calc_prp)
|
||
vect_prec.add_riga(impon,impos,impol,ZERO,ZERO,ZERO,codiva);
|
||
else
|
||
vect.add_riga(impon,impos,impol,ZERO,ZERO,ZERO,codiva);
|
||
}
|
||
|
||
if (!calc_prp && tipo == acquisto) //registro acquisti
|
||
if (impon != ZERO || impos != ZERO)
|
||
{
|
||
if (_tipo_stampa != prova)
|
||
vect_det.add_riga(ZERO,ZERO,impon,impos,codiva,tipodet,0,true,0);
|
||
if (mese == m || (_frequiva == 'T' && mese >= m-2 && mese <= m)) // Guy!!!
|
||
vect_det.add_riga(impon,impos,ZERO,ZERO,codiva,tipodet,0,true,0);
|
||
}
|
||
}
|
||
} // for table
|
||
} // for start to stop
|
||
} // for i to m
|
||
|
||
if (vect.items() > 0)
|
||
{
|
||
stampato = true;
|
||
for (int i = 0; i < 2; i++) // Stampa i progressivi veri poi quelli da periodo prec
|
||
{
|
||
const bool print_prec = i != 0;
|
||
stampa_prospetto_riepilogo(tipo, codreg, codatt, print_prec);
|
||
stampa_progressivi(print_prec ? vect_prec : vect, vect_det, tipo, print_prec);
|
||
if (vect_prec.items() == 0)
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return stampato;
|
||
}
|
||
|
||
void TStampa_registri_app::stampa_prospetto_riepilogo(tiporeg tipo, const TString& codreg, const TString& codatt, const bool print_prec)
|
||
{
|
||
const TString80 desc(desc_attivita(codatt));
|
||
TPrinter& pr = printer();
|
||
TPrintrow row;
|
||
|
||
row.reset();
|
||
pr.print(row);
|
||
|
||
if (!print_prec)
|
||
{
|
||
row.put(TR("Registro IVA:"), 0);
|
||
row.put(codreg, 14);
|
||
row.put(format("%-.40s",(const char*)_tabreg->get("S0")), 18);
|
||
row.put(TR("Attivit<EFBFBD>"), 60);
|
||
|
||
if (_annoes > 2007)
|
||
{
|
||
TString16 key;
|
||
key.format("%ld|%s", _ditta, (const char*)codatt);
|
||
const TString& codateco = cache().get(LF_ATTIV, key, ATT_CODATECO);
|
||
row.put(codateco, 70);
|
||
}
|
||
else
|
||
row.put(codatt, 70);
|
||
row.put(desc, 77);
|
||
pr.print(row);
|
||
}
|
||
else
|
||
{
|
||
row.put(TR("DI CUI PERIODO PRECEDENTE"));
|
||
pr.print(row);
|
||
}
|
||
|
||
row.reset();
|
||
pr.print(row);
|
||
if (tipo == vendita && _tabreg->get_bool("B0"))
|
||
row.put(TR("------------------ P E R I O D O -------------------"), 30);
|
||
else
|
||
row.put(TR("---------- P E R I O D O -----------"), 30);
|
||
if (_tipo_stampa != prova && !print_prec)
|
||
{
|
||
if (tipo == vendita && _tabreg->get_bool("B0"))
|
||
row.put(TR("----------- P R O G R E S S I V I --------------"), 84);
|
||
else
|
||
row.put(TR("------ P R O G R E S S I V I ------"), 84);
|
||
}
|
||
pr.print(row);
|
||
row.reset();
|
||
row.put(TR("Cod."), 0);
|
||
if (tipo == acquisto)
|
||
{
|
||
row.put(TR("A C Q U I S T I"), 40);
|
||
if (_tipo_stampa != prova && !print_prec)
|
||
row.put(TR("A C Q U I S T I"), 94);
|
||
}
|
||
if (tipo == vendita)
|
||
{
|
||
row.put(TR("V E N D I T E"), 41);
|
||
if (_tabreg->get_bool("B0"))
|
||
row.put(TR("CORRISPETTIVI"), 67);
|
||
if (_tipo_stampa != prova && !print_prec)
|
||
{
|
||
if (_tabreg->get_bool("B0"))
|
||
{
|
||
row.put(TR("V E N D I T E"), 94);
|
||
row.put(TR("CORRISPETTIVI"), 118);
|
||
}
|
||
else
|
||
row.put(TR("V E N D I T E"), 95);
|
||
}
|
||
}
|
||
pr.print(row);
|
||
row.reset();
|
||
row.put(TR("iva Descrizione"), 0);
|
||
row.put(TR("Imponibile"), 34);
|
||
row.put(TR("Imposta"), 53);
|
||
if (tipo == vendita && _tabreg->get_bool("B0"))
|
||
row.put(TR("Importi lordi"), 67);
|
||
if (_tipo_stampa != prova && !print_prec)
|
||
{
|
||
row.put(TR("Imponibile"), 87);
|
||
row.put(TR("Imposta"), 107);
|
||
if (tipo == vendita && _tabreg->get_bool("B0"))
|
||
row.put(TR("Importi lordi"), 118);
|
||
}
|
||
pr.print(row);
|
||
row.reset();
|
||
pr.print(row);
|
||
}
|
||
|
||
void TStampa_registri_app::stampa_progressivi(TRiga_array& vect,
|
||
TRigaiva_array& vect_det, tiporeg treg, const bool print_prec)
|
||
{
|
||
real t_impon, t_impos, t_impol, t_imponp, t_imposp, t_impolp;
|
||
|
||
TPrintrow riga;
|
||
|
||
riga.reset();
|
||
//ordinamento per codice iva
|
||
vect.sort(compare_rows);
|
||
for (int k=0; k<vect.items(); k++)
|
||
{
|
||
const TRiga& r = (const TRiga&)vect[k];
|
||
riga.reset();
|
||
riga.put(format("%-4s",(const char*)r._codiva),0);
|
||
const TString& d = descr_iva(r._codiva);
|
||
riga.put(format("%-.23s",(const char*)d),5);
|
||
if (r._imponibile != ZERO)
|
||
print_real(riga, r._imponibile, 29);
|
||
if (r._imposta != ZERO)
|
||
print_real(riga, r._imposta, 45);
|
||
if (treg == vendita && _tabreg->get_bool("B0"))
|
||
if (r._implordo != ZERO)
|
||
print_real(riga, r._implordo, 65);
|
||
if (_tipo_stampa != prova && !print_prec)
|
||
{
|
||
if (r._imponibilep != ZERO)
|
||
print_real(riga, r._imponibilep, 82);
|
||
if (r._impostap != ZERO)
|
||
print_real(riga, r._impostap, 99);
|
||
if (treg == vendita && _tabreg->get_bool("B0"))
|
||
if (r._implordop != ZERO)
|
||
print_real(riga, r._implordop, 116);
|
||
}
|
||
printer().print(riga);
|
||
riga.reset();
|
||
t_impon += r._imponibile;
|
||
t_impos += r._imposta;
|
||
t_impol += r._implordo;
|
||
t_imponp += r._imponibilep;
|
||
t_imposp += r._impostap;
|
||
t_impolp += r._implordop;
|
||
}
|
||
|
||
printer().print(riga);
|
||
riga.put(TR("TOTALE"), 0);
|
||
if (t_impon != ZERO)
|
||
print_real(riga, t_impon, 29);
|
||
if (t_impos != ZERO)
|
||
print_real(riga, t_impos, 45);
|
||
if (treg == vendita && _tabreg->get_bool("B0"))
|
||
if (t_impol != ZERO)
|
||
print_real(riga, t_impol, 65);
|
||
if (_tipo_stampa != prova && !print_prec)
|
||
{
|
||
if (t_imponp != ZERO)
|
||
print_real(riga, t_imponp, 82);
|
||
if (t_imposp != ZERO)
|
||
print_real(riga, t_imposp, 99);
|
||
if (treg == vendita && _tabreg->get_bool("B0"))
|
||
if (t_impolp != ZERO)
|
||
print_real(riga, t_impolp, 116);
|
||
}
|
||
printer().print(riga);
|
||
|
||
//stampa tipi di indetraibilita' se registro acquisti
|
||
if (treg == acquisto && !print_prec)
|
||
{
|
||
real tot_imponib, tot_imposta, tot_imponibp, tot_impostap;
|
||
int tdetprec = -1;
|
||
tot_imponib = tot_imposta = tot_imponibp = tot_impostap = ZERO;
|
||
vect_det.sort(compare_righeiva);
|
||
for (int s=0; s<vect_det.items(); s++)
|
||
{
|
||
const TRigaiva& r = vect_det.riga(s);
|
||
const int tipodet = r._tipodet;
|
||
switch (tipodet)
|
||
{
|
||
case 1:
|
||
{
|
||
if (tdetprec == 3 || tdetprec == 9)
|
||
{
|
||
riga.reset();
|
||
printer().print(riga);
|
||
riga.put(TR("TOTALE"), 0);
|
||
if (tot_imponib != ZERO)
|
||
print_real(riga, tot_imponib, 29);
|
||
|
||
if (tot_imposta != ZERO)
|
||
print_real(riga, tot_imposta, 45);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (tot_imponibp != ZERO)
|
||
print_real(riga, tot_imponibp, 82);
|
||
if (tot_impostap != ZERO)
|
||
print_real(riga, tot_impostap, 99);
|
||
}
|
||
printer().print(riga);
|
||
tot_imponib = tot_imposta = tot_imponibp = tot_impostap = ZERO;
|
||
}
|
||
if (tipodet != tdetprec)
|
||
{
|
||
riga.reset();
|
||
printer().print(riga);
|
||
riga.put(TR("----- Indetraibile su op.es. -----"), 0);
|
||
printer().print(riga);
|
||
riga.reset();
|
||
riga.put(TR("Cod."), 0);
|
||
printer().print(riga);
|
||
riga.reset();
|
||
riga.put(TR("iva Descrizione"), 0);
|
||
riga.put(TR("Imponibile"), 34);
|
||
riga.put(TR("Imposta"), 53);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
riga.put(TR("Imponibile"), 87);
|
||
riga.put(TR("Imposta"), 107);
|
||
}
|
||
printer().print(riga);
|
||
riga.reset();
|
||
printer().print(riga);
|
||
}
|
||
riga.put(format("%-4s",(const char*)r._codiva),0);
|
||
const TString& descr = descr_iva(r._codiva);
|
||
riga.put(format("%-.23s",(const char*)descr),5);
|
||
if (r._imponibile != ZERO)
|
||
print_real(riga, r._imponibile, 29);
|
||
if (r._imposta != ZERO)
|
||
print_real(riga, r._imposta, 45);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (r._imponibilep != ZERO)
|
||
print_real(riga, r._imponibilep, 82);
|
||
if (r._impostap != ZERO)
|
||
print_real(riga, r._impostap, 99);
|
||
}
|
||
printer().print(riga);
|
||
tot_imponib += r._imponibile;
|
||
tot_imposta += r._imposta;
|
||
tot_imponibp += r._imponibilep;
|
||
tot_impostap += r._impostap;
|
||
tdetprec = tipodet;
|
||
}
|
||
break;
|
||
case 3:
|
||
{
|
||
if (tdetprec == 1 || tdetprec == 9)
|
||
{
|
||
riga.reset();
|
||
printer().print(riga);
|
||
riga.put(TR("TOTALE"), 0);
|
||
if (tot_imponib != ZERO)
|
||
print_real(riga, tot_imponib, 29);
|
||
|
||
if (tot_imposta != ZERO)
|
||
print_real(riga, tot_imposta, 45);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (tot_imponibp != ZERO)
|
||
print_real(riga, tot_imponibp, 82);
|
||
if (tot_impostap != ZERO)
|
||
print_real(riga, tot_impostap, 99);
|
||
}
|
||
printer().print(riga);
|
||
tot_imponib = tot_imposta = tot_imponibp = tot_impostap = ZERO;
|
||
}
|
||
if (tipodet != tdetprec)
|
||
{
|
||
riga.reset();
|
||
printer().print(riga);
|
||
riga.put(TR("----- Passaggi interni -----"),0);
|
||
printer().print(riga);
|
||
riga.reset();
|
||
riga.put(TR("Cod."), 0);
|
||
printer().print(riga);
|
||
riga.reset();
|
||
riga.put(TR("iva Descrizione"), 0);
|
||
riga.put(TR("Imponibile"), 34);
|
||
riga.put(TR("Imposta"), 53);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
riga.put(TR("Imponibile"), 87);
|
||
riga.put(TR("Imposta"), 107);
|
||
}
|
||
printer().print(riga);
|
||
riga.reset();
|
||
printer().print(riga);
|
||
}
|
||
riga.put(format("%-4s",(const char*)r._codiva),0);
|
||
const TString& descr = descr_iva(r._codiva);
|
||
riga.put(format("%-.23s",(const char*)descr),5);
|
||
if (r._imponibile != ZERO)
|
||
print_real(riga, r._imponibile, 29);
|
||
if (r._imposta != ZERO)
|
||
print_real(riga, r._imposta, 45);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (r._imponibilep != ZERO)
|
||
print_real(riga, r._imponibilep, 82);
|
||
|
||
if (r._impostap != ZERO)
|
||
print_real(riga, r._impostap, 99);
|
||
}
|
||
printer().print(riga);
|
||
tot_imponib += r._imponibile;
|
||
tot_imposta += r._imposta;
|
||
tot_imponibp += r._imponibilep;
|
||
tot_impostap += r._impostap;
|
||
tdetprec = tipodet;
|
||
}
|
||
break;
|
||
case 9:
|
||
{
|
||
if (tdetprec == 1 || tdetprec == 3)
|
||
{
|
||
riga.reset();
|
||
printer().print(riga);
|
||
riga.put(TR("TOTALE"), 0);
|
||
if (tot_imponib != ZERO)
|
||
print_real(riga, tot_imponib, 29);
|
||
|
||
if (tot_imposta != ZERO)
|
||
print_real(riga, tot_imposta, 45);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (tot_imponibp != ZERO)
|
||
print_real(riga, tot_imponibp, 82);
|
||
if (tot_impostap != ZERO)
|
||
print_real(riga, tot_impostap, 99);
|
||
}
|
||
printer().print(riga);
|
||
tot_imponib = tot_imposta = tot_imponibp = tot_impostap = ZERO;
|
||
}
|
||
if (tipodet != tdetprec)
|
||
{
|
||
riga.reset();
|
||
printer().print(riga);
|
||
riga.put(TR("----- N.D. 9 - acquisti indeducibili per ART.19 -----"), 0);
|
||
printer().print(riga);
|
||
riga.reset();
|
||
riga.put(TR("Cod."), 0);
|
||
printer().print(riga);
|
||
riga.reset();
|
||
riga.put(TR("iva Descrizione"), 0);
|
||
riga.put(TR("Imponibile"), 34);
|
||
riga.put(TR("Imposta"), 53);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
riga.put(TR("Imponibile"), 87);
|
||
riga.put(TR("Imposta"), 107);
|
||
}
|
||
printer().print(riga);
|
||
riga.reset();
|
||
printer().print(riga);
|
||
}
|
||
riga.put(format("%-4s",(const char*)r._codiva),0);
|
||
const TString& descr = descr_iva(r._codiva);
|
||
riga.put(format("%-.23s",(const char*)descr),5);
|
||
if (r._imponibile != ZERO)
|
||
print_real(riga, r._imponibile, 29);
|
||
|
||
if (r._imposta != ZERO)
|
||
print_real(riga, r._imposta, 45);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (r._imponibilep != ZERO)
|
||
print_real(riga, r._imponibilep, 82);
|
||
if (r._impostap != ZERO)
|
||
print_real(riga, r._impostap, 99);
|
||
}
|
||
printer().print(riga);
|
||
tot_imponib += r._imponibile;
|
||
tot_imposta += r._imposta;
|
||
tot_imponibp += r._imponibilep;
|
||
tot_impostap += r._impostap;
|
||
tdetprec = tipodet;
|
||
}
|
||
break;
|
||
default: break;
|
||
}
|
||
}
|
||
if (vect_det.items() > 0)
|
||
if (tdetprec == 1 || tdetprec == 3 || tdetprec == 9)
|
||
{
|
||
riga.reset();
|
||
printer().print(riga);
|
||
riga.put(TR("TOTALE"), 0);
|
||
if (tot_imponib != ZERO)
|
||
print_real(riga, tot_imponib, 29);
|
||
if (tot_imposta != ZERO)
|
||
print_real(riga, tot_imposta, 45);
|
||
if (_tipo_stampa != prova)
|
||
{
|
||
if (tot_imponibp != ZERO)
|
||
print_real(riga, tot_imponibp, 82);
|
||
if (tot_impostap != ZERO)
|
||
print_real(riga, tot_impostap, 99);
|
||
}
|
||
printer().print(riga);
|
||
}
|
||
}
|
||
}
|
||
|
||
int cg4400(int argc, char* argv[])
|
||
{
|
||
TStampa_registri_app a;
|
||
a.run(argc, argv, TR("Stampa registri IVA"));
|
||
return 0;
|
||
}
|