Alessandro Bonazzi
2ecadc5c4a
Files correlati : cf4.exe Commento : Nella stampa registri la variabile agenzie di viagio non ere inizializzata per cui poteva considerare agenzie di viaggio per l'IVA per cassa anche ditte che non lo erano. Nella liquidazione IVA la restore status non funzionava più. Questo aveva efftto per i trimestrali che cacolano 3 mesi e stampano sul terzo che non veniva mai esaminato.
4558 lines
140 KiB
C++
Executable File
4558 lines
140 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 "cglib.h"
|
||
|
||
#include <defmask.h>
|
||
#include <execp.h>
|
||
#include <mailbox.h>
|
||
#include <modaut.h>
|
||
#include <progind.h>
|
||
#include <recarray.h>
|
||
#include <recset.h>
|
||
#include <sheet.h>
|
||
#include <utility.h>
|
||
|
||
#include <anagr.h>
|
||
#include <attiv.h>
|
||
#include <causali.h>
|
||
#include <clifo.h>
|
||
#include <comuni.h>
|
||
#include "ivadiff.h"
|
||
#include <mov.h>
|
||
#include <nditte.h>
|
||
#include <rmoviva.h>
|
||
#include <occas.h>
|
||
#include <unloc.h>
|
||
|
||
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 4
|
||
|
||
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()._annoIVA))
|
||
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 TRegistro & reg = cached_registro(codreg, annoiva);
|
||
const tipo_sospensione ts = reg.sospensione();
|
||
|
||
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);
|
||
|
||
TToken_string key; key.format("%ld|%s", get_firm(), (const char*) _codatt);
|
||
const TRectype& ndt_att = cache().get(LF_ATTIV, key);
|
||
|
||
_isviaggio = ndt_att.get_bool("REG74TER");
|
||
|
||
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, _annoIVA);
|
||
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", _annoIVA, m);
|
||
lim.put("CODTAB", key);
|
||
if (lim.read() != NOERR)
|
||
return true;
|
||
}
|
||
}
|
||
//controllo il mese passato
|
||
if (_frequiva == 'M')
|
||
{
|
||
TString8 key; key.format("%04d%02d", _annoIVA, mese);
|
||
lim.put("CODTAB", key);
|
||
if (lim.read() != NOERR)
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
//aggiusta il mese al trimestre a cui appartiene
|
||
mese += 2 - ((mese-1) % 3);
|
||
TString8 key; key.format("%04d%02d", _annoIVA, mese);
|
||
lim.put("CODTAB", key);
|
||
if (lim.read() != NOERR)
|
||
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 TString& codtab = _tabreg->get("CODTAB");
|
||
const int anno = atoi(codtab.mid(0,4));
|
||
if (anno > _annoIVA)
|
||
{
|
||
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, _annoIVA);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
else // stampa un solo registro
|
||
{
|
||
_stampa_tutti_i_registri = false;
|
||
TString8 codtab; codtab << _annoIVA << _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 << _annoIVA << _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", _annoIVA);
|
||
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 (mese == 20)
|
||
mese = 12;
|
||
if (mese == 12)
|
||
m.show(TIPO_RIEPILOGATIVO);
|
||
else m.hide(TIPO_RIEPILOGATIVO);
|
||
}
|
||
if (id == MESE)
|
||
{
|
||
if (mese == 12)
|
||
{
|
||
m.show (TIPO_RIEPILOGATIVO);
|
||
m.show (RIF_VID);
|
||
}
|
||
else
|
||
{
|
||
m.hide (TIPO_RIEPILOGATIVO);
|
||
m.hide (RIF_VID);
|
||
}
|
||
mese = m.get_int(FINO_A_MESE); //Per stampa su bollato
|
||
if (mese == 20)
|
||
mese = 12;
|
||
}
|
||
}
|
||
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);
|
||
|
||
const TString& cod = f.mask().get(CODICE_LIBRO_IVA);
|
||
int fino_a_mese = f.mask().get_int(MESE);
|
||
|
||
if (fino_a_mese == 12)
|
||
f.mask().show(TIPO_RIEPILOGATIVO);
|
||
else f.mask().hide(TIPO_RIEPILOGATIVO);
|
||
|
||
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)
|
||
TString4 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");
|
||
TString8 codtab;
|
||
|
||
TString16 codlib(f.get());
|
||
int 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();
|
||
_stampa_acconto = false;
|
||
|
||
const TDate oggi(TODAY);
|
||
_annoIVA = 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 << _annoIVA << _codatt;
|
||
|
||
//calcolo i totali del periodo; calcola anche i totali da Periodo Precedente (se _annoIVA > 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(const bool fattrit)
|
||
{
|
||
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);
|
||
const bool splitpay = mov.get_char(MOV_TIPO) == 'C' && is_split_payment(mov);
|
||
const bool liqdiff = !splitpay && mov.get_bool(MOV_LIQDIFF) && is_IVA_diff(mov);
|
||
const tipo_movimento tm = (tipo_movimento) mov.get_int(MOV_TIPOMOV);
|
||
const bool IVAxcassa = !splitpay && !liqdiff && !_isviaggio && tm > tm_nessuno && is_IVAxCassa(mov);
|
||
const bool indetr = iva.get_int(RMI_TIPODET) != 0;
|
||
|
||
if (!IVAxcassa && !indetr)
|
||
_riga_prospettoXcassa.add_riga(impo, impos, codiva);
|
||
|
||
if (is_split_payment(mov))
|
||
_riga_split.add_riga(impo, impos, codiva);
|
||
if (_tipo_reg == acquisto && fattrit)
|
||
_riga_competenza.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", _annoIVA, i);
|
||
lim.put("CODTAB", chiave);
|
||
if (lim.read() != NOERR || lim.get_bool("B0"))
|
||
{
|
||
if (lim.get_bool("B1"))
|
||
mesi_cal ="";
|
||
else
|
||
mesi_cal << itom(i) << '\n';
|
||
}
|
||
}
|
||
} else
|
||
if (_frequiva == 'M')
|
||
{
|
||
for (int i=1; i<=mese; i++)
|
||
{
|
||
chiave.format("%04d%02d", _annoIVA, i);
|
||
lim.put("CODTAB", chiave);
|
||
if (lim.read() != NOERR || lim.get_bool("B0"))
|
||
{
|
||
if (lim.get_bool("B1"))
|
||
mesi_cal ="";
|
||
else
|
||
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;
|
||
*/
|
||
|
||
return prosegui_stampa;
|
||
}
|
||
}
|
||
else if (_tipo_riepilogativo == 'A')
|
||
{
|
||
chiave.format("%04d%02d", _annoIVA, 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; */
|
||
return prosegui_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", _annoIVA, m);
|
||
lim.put("CODTAB", chiave);
|
||
if (lim.read() != NOERR || lim.get_bool("B0"))
|
||
need_refresh |= !lim.get_bool("B1");
|
||
}
|
||
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 prosegui_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;
|
||
|
||
TRecnotype rec = _tabreg->recno();
|
||
for (mov.first(); ok && !mov.eof(); mov.next())
|
||
{
|
||
const TString4 codreg = mov.get(MOV_REG);
|
||
|
||
if (codreg.full())
|
||
{
|
||
const TDate datareg = mov.get_date(MOV_DATAREG);
|
||
const tiporeg tipo = cached_registro(codreg, datareg.year()).tipo_registro();
|
||
|
||
if (( _stampa_tutti_i_registri && (tipo == vendita || tipo == acquisto || tipo == riepilogativo)) ||
|
||
(!_stampa_tutti_i_registri && codreg == _codreg))
|
||
{
|
||
const bool stampato = mov.get_bool(MOV_REGST);
|
||
|
||
if (datareg.year() < _annoIVA)
|
||
{
|
||
// const long numreg = mov.get_long(MOV_NUMREG);
|
||
if (!stampato)
|
||
ok = false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
_tabreg->readat(rec);
|
||
return ok;
|
||
}
|
||
|
||
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();
|
||
|
||
|
||
if (_st_tot_fin)
|
||
{
|
||
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 (_st_tot_fin && _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)
|
||
{
|
||
if (_tipo_reg == vendita)
|
||
set_row(++rr, FR("@30g---- DI CUI SCISSIONE PAGAMENTI ----"));
|
||
else
|
||
set_row(++rr, format(FR("@30g---- DI CUI COMPETENZA %04d ----"), _annoIVA - 1));
|
||
}
|
||
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;
|
||
bool printed = false;
|
||
|
||
//*****deve azzerare i totali progressivi dei riporti e segnalare all'header di non stampare
|
||
//la riga di riporto
|
||
reset_print();
|
||
|
||
if (_esiste_riga_iva && _stampa)
|
||
{
|
||
_totali_finali = true; //siamo in stampa totali, quindi...
|
||
for (int tipo_prosp = 0; tipo_prosp <= 2/* (_tipo_reg == vendita ? 2 : 1) */; tipo_prosp++)
|
||
{
|
||
TRiga_array& arriva = tipo_prosp == 0 ? _tot_iva_array : (tipo_prosp == 1 ? _tot_prec_iva_array : (_tipo_reg == vendita ? _riga_split : _riga_competenza));
|
||
if (arriva.empty())
|
||
continue;
|
||
if (!printed)
|
||
{
|
||
printer().formfeed();
|
||
_totali_stampati = true; //siamo in stampa totali, quindi...
|
||
_riporti = false; //inoltre non deve stapare riporti mentre stampa i totali
|
||
_totdoc_prog = _totimpn_prog = _totimps_prog = ZERO;
|
||
rr = stampa_prospetto_IVA(rr, 0); // Intestazione prospetto IVA per aliquota
|
||
printed = true;
|
||
}
|
||
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 (printed)
|
||
flush();
|
||
fine_mese();
|
||
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 << _annoIVA << _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 << _annoIVA << _codatt << "1" << nm << "1";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri = ppa.get_real("R0");
|
||
pre = ppa.get_real("R1");
|
||
}
|
||
chiave = "";
|
||
chiave << _annoIVA << _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 << _annoIVA << _codatt << "1" << nm << "2";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri = ppa.get_real("R0");
|
||
pre = ppa.get_real("R1");
|
||
}
|
||
chiave = "";
|
||
chiave << _annoIVA << _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 << _annoIVA << _codatt << "1" << nm << "3";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri = ppa.get_real("R0");
|
||
pre = ppa.get_real("R1");
|
||
}
|
||
chiave = "";
|
||
chiave << _annoIVA << _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 << _annoIVA << _codatt << "1" << m << tipo;
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
si8 += ppa.get_real("R0");
|
||
se8 += ppa.get_real("R1");
|
||
}
|
||
chiave = "";
|
||
chiave << _annoIVA << _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 = "USE IVADIFF SELECT (BETWEEN(DATAREGP,#DAL,#AL))&&(MOV.REG=#REG)&&(STR((MESELIQ<13)&&(TIPOMOV>2)&&(MOV.TOTDOC!=0)&&(IMPOSTA!=0)&&NUM(INDETR!='X')))"; // 17-11-2015 trasformato in 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(ID_CODIVA);
|
||
const real importo = rec.get(ID_IMPORTO);
|
||
const real imponibile = rec.get(ID_IMPONIBILE);
|
||
const real imposta = rec.get(ID_IMPOSTA);
|
||
const int tipodiff = rec.get_int(ID_TIPODIFF);
|
||
|
||
TString80 rs = id.get("CLIFO.RAGSOC").as_string();
|
||
rs.strip_double_spaces();
|
||
TParagraph_string clifo(rs, 27);
|
||
|
||
riga.reset();
|
||
riga.put(rec.get_date(ID_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(ID_CODIVA), 102);
|
||
print_real(riga, imposta, 107);
|
||
riga.put(rec.get_int(ID_NUMPRO) >= 999 ? "X" : "", 123);
|
||
if (_tipo_stampa == prova)
|
||
riga.put(format("%6ld", rec.get_long(MOV_NUMREG)), 125);
|
||
pr.print(riga);
|
||
|
||
if(!id.get(ID_INDETR).as_bool())
|
||
{
|
||
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;
|
||
get_dati_ditta();
|
||
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, _annoIVA); // 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();
|
||
t.fremove();
|
||
}
|
||
}
|
||
_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
|
||
_totali_finali = false;
|
||
_riporti = false;//e pure quello dei riporti,visto che "A Riporto" non va nella prima pagina del mese
|
||
}
|
||
|
||
_dataregp = _datareg;
|
||
|
||
const TDate datadoc = mov.get_date(MOV_DATADOC);
|
||
const long numreg = mov.get_long(MOV_NUMREG);
|
||
const long protiva = mov.get_long(MOV_PROTIVA);
|
||
const long uprotiva = mov.get_long(MOV_UPROTIVA);
|
||
const TString16 numdoc = mov.get(MOV_NUMDOC);
|
||
const int meseliq = mov.get_int(MOV_MESELIQ);
|
||
const 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 tiporeg tipomov = (tiporeg)_tabreg->get_int("I0"); // 1=Vendite; 2=Acquisti
|
||
const bool fatt_rit_2018 = _datareg.year() >= 2018 && mov.get_bool(MOV_RITFATT);
|
||
const int year_diff = _datareg.year() - datadoc.year();
|
||
const bool dataritind = ((tipomov == acquisto) && fatt_rit_2018) &&
|
||
((year_diff > 2) || ((year_diff >= 1) && _datareg.month() >= 5));
|
||
const bool fattrit = ((tipomov == acquisto) && !dataritind && fatt_rit_2018) && (year_diff >= 1);
|
||
const bool fattritind = (_annoIVA < 2018 && caus.get_bool(CAU_RITFATT)) || dataritind;
|
||
const bool splitpay = tipocf == 'C' && is_split_payment(mov.curr());
|
||
|
||
const bool liqdiff = !splitpay && mov.get_bool(MOV_LIQDIFF) && is_IVA_diff(mov.curr());
|
||
const tipo_movimento tm = (tipo_movimento)mov.get_int(MOV_TIPOMOV);
|
||
const bool IVAxcassa = !splitpay && !liqdiff && !_isviaggio && tm > tm_nessuno && is_IVAxCassa(mov.curr());
|
||
|
||
const TString80 descrcau = caus.get(CAU_DESCR);
|
||
|
||
real totdoc = mov.get(MOV_TOTDOC);
|
||
real ritsoc = mov.get(MOV_RITSOC);
|
||
real ritfis = mov.get(MOV_RITFIS);
|
||
real revcha = is_reverse_charge(mov.curr()) ? mov.get_real(MOV_REVCHARGE) : ZERO;
|
||
if (totdoc < ZERO) // Controlla il segno corretto da assegnare alle ritenute
|
||
{
|
||
ritsoc = -ritsoc;
|
||
ritfis = -ritfis;
|
||
revcha = -revcha;
|
||
}
|
||
|
||
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+revcha;
|
||
|
||
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, "@67g%2s", (const char*) _tipodoc);
|
||
if (fattrit)
|
||
set_row(_r, "@69gD");
|
||
else
|
||
if (fattritind)
|
||
set_row(_r, "@69gI");
|
||
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 (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(fattrit);
|
||
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, "@65g%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;
|
||
}
|
||
|
||
void TStampa_registri_app::fine_mese()
|
||
{
|
||
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, _annoIVA);
|
||
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, _annoIVA);
|
||
data.set_end_month();
|
||
scrivi_reg(data);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
print_action TStampa_registri_app::postprocess_page (int file, int counter)
|
||
{
|
||
if (file == LF_MOV)
|
||
{
|
||
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 NEXT_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 NEXT_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 = _annoIVA;
|
||
}
|
||
|
||
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", _annoIVA, _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 (_annoIVA > 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 Attivit<69> %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 Attivit<69> %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@65gT Tipo@102gCod %c@123gT %c@128gNum"), nd1, tipo);
|
||
r++;
|
||
set_header(r, FR("Data reg. prot.@17gData@24gNumero Codice Ragione sociale/descr. liq.@65gO 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@65gT Tipo@110gCod %c@132g%c T@139gNum."), nd1, tipo, cor);
|
||
r++;
|
||
set_header(r, FR("Data Protocollo Data@24gNumero Codice Ragione sociale/descr. liq.@65gO 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@67gT 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@67gT 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("@38gGeneralit<69>"));
|
||
|
||
set_header(r++, riga);
|
||
|
||
//*****valori della riga Riporto
|
||
if (_riporti)
|
||
{
|
||
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);
|
||
set_header(r++, "");
|
||
_totali_stampati = false;
|
||
_totali_finali = 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 (!_totali_finali)
|
||
{
|
||
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"));
|
||
else
|
||
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"));
|
||
}
|
||
else
|
||
{
|
||
if (_stampa_width == 132)
|
||
set_footer(r++, FR("@0gTotale @70g%15s@85g%15s@107g%15s"),
|
||
_totdoc_prog.string(".2"), _totimpn_prog.string(".2"), _totimps_prog.string(".2"));
|
||
else
|
||
if (_stampa_width == 198)
|
||
set_footer(r++, FR("@0gTotale @78g%15s@93g%15s@116g%15s"),
|
||
_totdoc_prog.string(".2"), _totimpn_prog.string(".2"), _totimps_prog.string(".2"));
|
||
}
|
||
set_footer(r++, 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");
|
||
if (_annoIVA >= 2015)
|
||
riga << TR("; 6=Scissione pagamenti art.17 ter");
|
||
set_footer(r++, riga);
|
||
}
|
||
_riporti = !_totali_finali;
|
||
}
|
||
|
||
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;
|
||
f.fremove();
|
||
}
|
||
}
|
||
|
||
void TStampa_registri_app::liq_other_case()
|
||
{
|
||
const bool calc_reg = _annoIVA > 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", _annoIVA);
|
||
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 << _annoIVA << _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 << _annoIVA << _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 << _annoIVA << _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);
|
||
|
||
if (_stampa_acconto)
|
||
{
|
||
TInteressi_IVA_table i; i.read(_annoIVA, _fino_a_mese);
|
||
|
||
ultima_data.set_day(i.giorno_acc());
|
||
}
|
||
else
|
||
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 (!_stampa_acconto && _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", _annoIVA);
|
||
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 (_annoIVA == 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", _annoIVA);
|
||
nuovo.put("CODLIB", _codlib);
|
||
nuovo.put("NUMREG", numero_riga);
|
||
|
||
nuovo.put("ANNOREG", _annoIVA);
|
||
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 << _annoIVA << _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 && _annoIVA > 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 (_tipo_reg == riepilogativo)
|
||
_totali_stampati = true;
|
||
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, _annoIVA);
|
||
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, _annoIVA);
|
||
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, _annoIVA); // 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;
|
||
f.fremove();
|
||
}
|
||
}
|
||
}//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, _annoIVA);
|
||
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;
|
||
t.fremove();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
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(_annoIVA);
|
||
if (_tipo_riepilogativo == 'A' && mese == 12)
|
||
ss.add(13);
|
||
else
|
||
{
|
||
if (mese == 12 && _stampa_acconto)
|
||
ss.add(20);
|
||
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 = false;
|
||
_totali_stampati = false;
|
||
_totali_finali = false;
|
||
|
||
_annoIVA = 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 = (_annoIVA > 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);
|
||
_stampa_acconto = false;
|
||
|
||
if (!_data_da.ok())
|
||
_data_da = TDate(1, 1, _annoIVA); // Meglio cosi'
|
||
|
||
if (!_data_a.ok())
|
||
_data_a = TDate(31, 12, _annoIVA); // Meglio cosi'
|
||
|
||
const TDate d(31,12,_annoIVA);
|
||
if (_data_a == d)
|
||
_tipo_riepilogativo = m.get(TIPO_RIEPILOGATIVO)[0];
|
||
else
|
||
_tipo_riepilogativo = ' ';
|
||
printer().setdate(_data_stampa);
|
||
}
|
||
else //stampe definitive
|
||
{
|
||
_fino_a_mese = m.get_int(FINO_A_MESE);
|
||
_stampa_acconto = (_fino_a_mese == 20);
|
||
|
||
if (_stampa_acconto)
|
||
_fino_a_mese = 12;
|
||
if (_tipo_stampa == bollato || _tipo_stampa == rif_giornale)
|
||
{
|
||
|
||
_data_da = TDate(1, 1, _annoIVA); // 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, _annoIVA); // Meglio cosi'
|
||
}
|
||
|
||
int giorni_del_mese = 31;
|
||
if (_fino_a_mese == 12)
|
||
{
|
||
TInteressi_IVA_table i; i.read(_annoIVA, _fino_a_mese);
|
||
|
||
if (_stampa_acconto)
|
||
giorni_del_mese = i.giorno_acc();
|
||
|
||
_tipo_riepilogativo = m.get(TIPO_RIEPILOGATIVO)[0];
|
||
}
|
||
else
|
||
{
|
||
_tipo_riepilogativo = ' ';
|
||
TDate primo(1, _fino_a_mese, _annoIVA);
|
||
primo.set_end_month(); // Meglio cosi'
|
||
giorni_del_mese = primo.day();
|
||
}
|
||
_data_a = TDate(giorni_del_mese, _fino_a_mese, _annoIVA); // 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;
|
||
_stampa = true;
|
||
_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())
|
||
{
|
||
_stampa = true;
|
||
_tipo_reg = (tiporeg)_tabreg->get_int("I0");
|
||
const TString16 codtab = _tabreg->get("CODTAB");
|
||
const int anno = atoi(codtab.left(4));
|
||
if (anno > _annoIVA)
|
||
break;
|
||
if (anno == _annoIVA)
|
||
//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", _annoIVA);
|
||
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 > _annoIVA)
|
||
break;
|
||
|
||
const tiporeg tipo = (tiporeg)_tabreg->get_int("I0");
|
||
|
||
if (a == _annoIVA && (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 << _annoIVA << _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 (_annoIVA > 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;
|
||
}
|