2925 lines
86 KiB
C++
Executable File
2925 lines
86 KiB
C++
Executable File
#include <config.h>
|
||
#include <execp.h>
|
||
#include <isam.h>
|
||
#include <mailbox.h>
|
||
#include <mask.h>
|
||
#include <prefix.h>
|
||
#include <printapp.h>
|
||
#include <sheet.h>
|
||
#include <tabutil.h>
|
||
#include <text.h>
|
||
#include <utility.h>
|
||
#include <urldefid.h>
|
||
|
||
#include "conto.h"
|
||
#include "cglib03.h"
|
||
|
||
#include <nditte.h>
|
||
#include <anagr.h>
|
||
#include <comuni.h>
|
||
#include <unloc.h>
|
||
#include <mov.h>
|
||
#include <rmoviva.h>
|
||
#include <clifo.h>
|
||
#include <occas.h>
|
||
#include <causali.h>
|
||
|
||
|
||
// cg4400.cpp
|
||
// Stampa registri IVA
|
||
#include "cg4.h"
|
||
#include "cg4400a.h"
|
||
#include "cg4400b.h"
|
||
|
||
const int TABREG = (int)TTable::name2log("REG");
|
||
|
||
class CG4400_application : public TPrintapp
|
||
{
|
||
TCursor * _cur;
|
||
TRelation *_rel;
|
||
TLocalisamfile *_clifo, *_nditte, *_occas, *_tab, *_tabcom, *_com, *_anag, *_unloc, *_attiv;
|
||
TTable *_tabreg, *_tablbu, *_tabinl, *_tablim, *_tabpim, *_tablia, *_tabiva;
|
||
TTable *_tabpla, *_tabppa, *_tabvid;
|
||
TRigaiva_array _iva_array, _riga_rmi;
|
||
TTipodoc_array _doc_array;
|
||
TRiga_array _tot_iva_array;
|
||
|
||
TBit_array _selected;
|
||
TArray_sheet *_ditte;
|
||
bool _st_liq[12];
|
||
TRecnotype _nrec;
|
||
bool _mov_empty, _stampa_ind_ditta, _stampa_tutti_i_registri, _auto_intraf, _stampa;
|
||
bool _corrispettivi, _liquidazione, _riep_liq, _stampa_ind_comp, _esiste_riga_iva, _stampa_cred_pre;
|
||
bool _rif_vid, _intesta_vidi, _intesta_liq, _stampa_data_reg, _ok_vidi;
|
||
char _frequiva, _tipo_riepilogativo;
|
||
TDate _data_da, _data_a, _data_stampa, _dataregp, _dataregs, _datareg;
|
||
TDate _u_data;
|
||
long _n_ditte, _u_stampata, _primast, __firm, _uprotivap;
|
||
long _numini, _pagine_stampate;
|
||
int _fino_a_mese, _tipo_reg, _tipo_stampa, _cod_un_loc;
|
||
int _annoes, _r, _stampa_width, _mese_ultima_liq, _mese_credito;
|
||
int _stampa_len, _stampa_mese;
|
||
real _totale_doc, _credito;
|
||
TString _codreg, _desc_lib, _codatt, _attivita, _tipoatt;
|
||
TString _tipodoc, _descr_doc, _codlib, _codice_vidi;
|
||
TString _cofi,_cap,_paiva,_ragsoc,_comunefis,_provfis,_viafis;
|
||
|
||
protected:
|
||
const char* desc_attivita ();
|
||
const char* tipo_attivita ();
|
||
const char* descr_doc ();
|
||
const char* descr_iva (const char *);
|
||
TRectype& ricerca_occ(const char*);
|
||
TRectype& ricerca_cf (char, long);
|
||
TRectype& look_comuni(const char*);
|
||
int setta_riga (int, const TRigaiva&, real&, real&, real&, real&);
|
||
int riga_rmoviva();
|
||
bool set_print(int);
|
||
bool set_ditte(TMask&);
|
||
bool compila_reg(const TMask&);
|
||
bool compila_lib();
|
||
bool controlla_liquidazione();
|
||
bool controlla_mov();
|
||
bool stampo_liquidazione(int);
|
||
bool ventilazione(const char*);
|
||
bool cerca_libro_gio(TString&);
|
||
bool look_reg (long, int, TString&, int, const char*, int*);
|
||
bool look_regs(int, TString&, int, int*);
|
||
bool stampa_totali_finali();
|
||
bool stampa_datareg();
|
||
bool stampa_registri_IVA(const TMask&);
|
||
void cerca_reg(const TString&, byte*);
|
||
void set_page_tot_reg();
|
||
void send_message(char, const TFilename&,int);
|
||
void aggiorna_reg();
|
||
void aggiorna_lib();
|
||
void calcola_progressivi();
|
||
bool user_create();
|
||
bool user_destroy();
|
||
bool preprocess_page(int, int);
|
||
int stampa_intestazione();
|
||
int stampa_prospetto();
|
||
void stampa_plafonds(int);
|
||
void get_dati_ditta();
|
||
void stampa_vidi();
|
||
int stampa_acquisti(int);
|
||
real stampa_valori_plafonds(const real&, const int, TTable&);
|
||
bool preprocess_print(int, int);
|
||
//print_action postprocess_print(int, int);
|
||
print_action postprocess_page (int, int);
|
||
void preprocess_header();
|
||
|
||
static bool filter_func (const TRelation * r);
|
||
|
||
static bool mask_tipo_stampa (TMask_field&, KEY);
|
||
static bool mask_firm_to (TMask_field&, KEY);
|
||
static bool mask_cod (TMask_field&, KEY);
|
||
static bool mask_libun (TMask_field&, KEY);
|
||
static bool mask_data (TMask_field&, KEY);
|
||
static bool mask_mese (TMask_field&, KEY);
|
||
static bool mask_fino_a_mese (TMask_field&, KEY);
|
||
static bool mask_select (TMask_field&, KEY);
|
||
static bool mask_azzera (TMask_field&, KEY);
|
||
|
||
public:
|
||
|
||
CG4400_application() : TPrintapp(), _ditte(NULL) {}
|
||
virtual ~CG4400_application() {}
|
||
};
|
||
|
||
static TString256 TMP;
|
||
|
||
inline CG4400_application& app() { return (CG4400_application&)main_app(); }
|
||
|
||
bool CG4400_application::filter_func (const TRelation * r)
|
||
{
|
||
TLocalisamfile& mov = r->lfile(LF_MOV);
|
||
TString16 codreg = mov.get(MOV_REG);
|
||
TDate datareg = mov.get_date(MOV_DATAREG);
|
||
int annoiva = mov.get_int(MOV_ANNOIVA);
|
||
bool regst = mov.get_bool(MOV_REGST);
|
||
|
||
if (codreg != (app()._codreg) || annoiva != (app()._annoes))
|
||
return FALSE;
|
||
|
||
if (app()._data_da.string() != "" && app()._data_a.string() != "")
|
||
if ( (datareg < app()._data_da || datareg > app()._data_a ) || (!datareg.ok()) )
|
||
return FALSE;
|
||
|
||
if (app()._tipo_stampa == 2 || app()._tipo_stampa == 4) //stampa di bollato
|
||
if (regst) //il movimento e' gia' stato stampato in forma definitiva
|
||
return FALSE;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
HIDDEN int compare_rows(const TObject** o1, const TObject** o2)
|
||
{
|
||
TRiga* r1 = (TRiga*)*o1;
|
||
TRiga* r2 = (TRiga*)*o2;
|
||
|
||
return (strcmp((const char*)r1->_codiva, (const char*)r2->_codiva));
|
||
}
|
||
|
||
HIDDEN int compare_fields(const TObject** o1, const TObject** o2)
|
||
{
|
||
TRigaiva* r1 = (TRigaiva*)*o1;
|
||
TRigaiva* r2 = (TRigaiva*)*o2;
|
||
TString16 campo1;
|
||
TString16 campo2;
|
||
|
||
campo1.format("%d%4s", r1->_tipodet, (const char*)r1->_codiva);
|
||
campo2.format("%d%4s", r2->_tipodet, (const char*)r2->_codiva);
|
||
return strcmp(campo1, campo2);
|
||
}
|
||
|
||
bool CG4400_application::stampa_totali_finali()
|
||
{
|
||
TConfig conf(CONFIG_DITTA);
|
||
return conf.get_bool("StTfFr");
|
||
}
|
||
|
||
bool CG4400_application::stampa_datareg()
|
||
{
|
||
TConfig conf(CONFIG_STUDIO);
|
||
return conf.get_bool("NoDtRg");
|
||
}
|
||
|
||
bool CG4400_application::mask_select (TMask_field& f, KEY k)
|
||
{
|
||
if (k == K_SPACE)
|
||
{
|
||
TBit_array& sel = app()._selected;
|
||
TArray_sheet& dit = *app()._ditte;
|
||
|
||
for (int j = 0; j < dit.items(); j++)
|
||
dit.check(j, sel[j]);
|
||
|
||
// seleziona e aggiungi alle gia' selezionate
|
||
if (dit.run() == K_ENTER)
|
||
{
|
||
for (int j = 0; j < dit.items(); j++)
|
||
sel.set(j, dit.checked(j));
|
||
}
|
||
const long numd = sel.ones();
|
||
f.mask().set(F_SELECT, numd);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool CG4400_application::mask_azzera (TMask_field& f, KEY k)
|
||
{
|
||
if (k == K_SPACE)
|
||
{
|
||
app()._selected.reset();
|
||
app()._ditte->uncheck(-1);
|
||
f.mask().reset(F_SELECT);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool CG4400_application::mask_firm_to (TMask_field& f, KEY k)
|
||
{
|
||
if (k == K_TAB && f.focusdirty())
|
||
{
|
||
TMask& m = f.mask();
|
||
const long from = m.get_long(DA_CODICE);
|
||
long to = m.get_long(A_CODICE);
|
||
if (from != 0 || to != 0)
|
||
{
|
||
TBit_array& sel = app()._selected;
|
||
if (to == 0) to = 99999;
|
||
for (int i = 0; i < app()._ditte->items(); i++)
|
||
{
|
||
TToken_string& d = app()._ditte->row(i);
|
||
const long cod = d.get_long(1);
|
||
if (cod >= from && cod <= to)
|
||
sel.set(i);
|
||
}
|
||
// m.reset(DA_CODICE);
|
||
// m.reset(A_CODICE);
|
||
const long numd = sel.ones();
|
||
f.mask().set(F_SELECT, numd);
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool CG4400_application::mask_tipo_stampa(TMask_field& f, KEY k)
|
||
{
|
||
TMask& m = f.mask();
|
||
|
||
if (k == K_SPACE)
|
||
{
|
||
int tipo_stampa = m.get_int(TIPO_STAMPA);
|
||
if (tipo_stampa == 3) //stampa su libro unico
|
||
m.enable_page(1);
|
||
else
|
||
m.disable_page(1);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool CG4400_application::mask_mese (TMask_field& f, KEY k)
|
||
{
|
||
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 = f.mask().get_int(FINO_A_MESE); //Per stampa su bollato
|
||
|
||
/*
|
||
if (k == K_ENTER)
|
||
{
|
||
if (id == MESE) //Per stampa su libro unico
|
||
{
|
||
int umese = f.mask().get_int(ULTIMO_MESE);
|
||
if (mese != umese+1)
|
||
return f.warning_box ("Le stampe devono essere richieste mese per mese!\n"
|
||
"I mesi successivi a %s non sono ancora stati stampati.", itom(umese));
|
||
}
|
||
}
|
||
*/
|
||
if (k == K_SPACE)
|
||
{
|
||
if (id == MESE)
|
||
if (mese == 12)
|
||
{
|
||
f.mask().show (TIPO_RIEPILOGATIVO);
|
||
f.mask().show (RIF_VID);
|
||
}
|
||
else
|
||
{
|
||
f.mask().hide (TIPO_RIEPILOGATIVO);
|
||
f.mask().hide (RIF_VID);
|
||
}
|
||
if (id == FINO_A_MESE)
|
||
{
|
||
if (mese == 12)
|
||
f.mask().show (TIPO_RIEPILOGATIVO);
|
||
else f.mask().hide (TIPO_RIEPILOGATIVO);
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool CG4400_application::look_reg(long l, int anno, TString& codlib, int m, const char* cod, int* umese)
|
||
{
|
||
TString16 y;
|
||
|
||
y << anno << cod;
|
||
_tabreg->zero();
|
||
_tabreg->put("CODTAB", y);
|
||
|
||
if (_tabreg->read() == NOERR)
|
||
{
|
||
int tipo = _tabreg->get_int("I0");
|
||
if (tipo == 1 || tipo == 2)
|
||
{
|
||
TString16 cod_lib_un = _tabreg->get("S6");
|
||
TDate u_data = _tabreg->get_date("D3");
|
||
TDate sca_vid = _tabreg->get_date("D0");
|
||
*umese = u_data.month();
|
||
if (_selected[l])
|
||
{
|
||
if (codlib != cod_lib_un)
|
||
{
|
||
message_box("Ditta %ld: il codice libro unico del registro non e' uguale al codice libro unico indicato", _nditte->get_long("CODDITTA"));
|
||
return FALSE;
|
||
}
|
||
if (m < *umese)
|
||
{
|
||
message_box("Ditta %ld: il mese indicato e' inferiore al mese dell'ultima data di stampa del registro", _nditte->get_long("CODDITTA"));
|
||
return FALSE;
|
||
}
|
||
if (sca_vid.month() < m)
|
||
{
|
||
message_box("Ditta %ld: la data scadenza di vidimazione del registro non deve essere inferiore al mese indicato", _nditte->get_long("CODDITTA"));
|
||
return FALSE;
|
||
}
|
||
}
|
||
/*
|
||
if (*umese < m - 1)
|
||
{
|
||
app().TApplication::set_firm(__firm);
|
||
return error_box("Ditta %ld: Stampare i registri dei mesi precedenti", _nditte->get_long("CODDITTA"));
|
||
}
|
||
*/
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
bool CG4400_application::look_regs(int anno, TString& codlib, int m, int* umese)
|
||
{
|
||
int a, tipo;
|
||
TString16 codtab;
|
||
*umese = 13;
|
||
|
||
for (_tabreg->first(); !_tabreg->eof(); _tabreg->next())
|
||
{
|
||
tipo = _tabreg->get_int("I0");
|
||
codtab = _tabreg->get("CODTAB");
|
||
a = atoi(codtab.mid(0,4));
|
||
if (a > anno)
|
||
{
|
||
// message_box("Non esistono registri IVA della Ditta %ld per l'anno %d", _nditte->get_long("CODDITTA"), anno);
|
||
// break;
|
||
return FALSE;
|
||
}
|
||
if (a == anno)
|
||
if ( tipo == 1 || tipo == 2 ) //registro iva
|
||
{
|
||
TString16 cod_lib_un = _tabreg->get("S6");
|
||
TDate sca_vid = _tabreg->get_date("D0");
|
||
TDate u_data = _tabreg->get_date("D3");
|
||
if (codlib != cod_lib_un)
|
||
continue;
|
||
if (m < u_data.month())
|
||
continue;
|
||
if (sca_vid.month() < m)
|
||
continue;
|
||
if (u_data.month() < m - 1)
|
||
{
|
||
app().TApplication::set_firm(__firm);
|
||
return error_box("Ditta %ld: Stampare i registri dei mesi precedenti", _nditte->get_long("CODDITTA"));
|
||
}
|
||
*umese = (*umese < u_data.month()) ? *umese : u_data.month();
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool CG4400_application::mask_libun (TMask_field& f, KEY k)
|
||
{
|
||
//TString16 cod(f.mask().get(CODICE_LIBRO_IVA));
|
||
|
||
//if ( (k == K_TAB && f.mask().is_running()) || (k == K_ENTER && cod.not_empty()) )
|
||
if ( k == K_ENTER )
|
||
{
|
||
TString16 cod(f.mask().get(CODICE_LIBRO_IVA));
|
||
TString16 codlib(f.mask().get(CODICE_LIB_UN));
|
||
int fino_a_mese = f.mask().get_int(MESE);
|
||
int anno = f.mask().get_int(ANNO);
|
||
bool ok = FALSE;
|
||
long l;
|
||
int last_mese = 13;
|
||
int mese;
|
||
|
||
app().__firm = app().TApplication::get_firm();
|
||
|
||
for (l = 0l, app()._nditte->first(); !app()._nditte->eof(); l++, app()._nditte->next())
|
||
{
|
||
if (!prefhndl->exist(app()._nditte->get_long("CODDITTA")))
|
||
continue;
|
||
app().TApplication::set_firm(app()._nditte->get_long("CODDITTA"));
|
||
|
||
if (cod.not_empty())
|
||
{
|
||
ok = app().look_reg(l,anno,codlib,fino_a_mese,cod,&mese);
|
||
if ( app()._selected[l] && !ok)
|
||
{
|
||
f.message_box("Ditta %ld: il registro %s non soddisfa i parametri indicati",app()._nditte->get_long("CODDITTA"), (const char*)cod);
|
||
continue;
|
||
}
|
||
if (mese < fino_a_mese - 1) //indipendentemente se si tratta di una ditta selezionata oppure no
|
||
{
|
||
app().TApplication::set_firm(app().__firm);
|
||
return error_box("Ditta %ld: Stampare i registri dei mesi precedenti", app()._nditte->get_long("CODDITTA"));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ok = app().look_regs(anno,codlib,fino_a_mese,&mese);
|
||
|
||
if ( app()._selected[l] && (!ok || mese == 13) )
|
||
{
|
||
f.message_box("Ditta %ld: nessun registro soddisfa i parametri indicati", app()._nditte->get_long("CODDITTA"));
|
||
continue;
|
||
}
|
||
}
|
||
if (app()._selected[l])
|
||
last_mese = (last_mese < mese) ? last_mese : mese;
|
||
}
|
||
app().TApplication::set_firm(app().__firm);
|
||
if (last_mese == 13)
|
||
return FALSE;
|
||
const char* me = "";
|
||
me = format("%02d", last_mese);
|
||
f.mask().set(ULTIMO_MESE, me);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool CG4400_application::mask_cod (TMask_field& f, KEY k)
|
||
{
|
||
TTable TabLbu ("%LBU");
|
||
TString codtab;
|
||
int anno;
|
||
|
||
if (k == K_TAB || f.focusdirty())
|
||
{
|
||
TString codlib = f.mask().get(CODICE_LIB_UN);
|
||
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(ULTIMO_MESE,TabLbu.get_long("I0"));
|
||
f.mask().set(ULTIMA_PAGINA,TabLbu.get_long("I1"));
|
||
app()._codice_vidi = TabLbu.get("S4");
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool CG4400_application::mask_data (TMask_field& f, KEY k)
|
||
{
|
||
if (k == K_TAB)
|
||
{
|
||
const int anno = f.mask().get_int(ANNO);
|
||
TDate data(f.get());
|
||
if (data.ok())
|
||
if (data.year() != anno)
|
||
{
|
||
f.warning_box("L'anno delle date limite deve essere uguale all'anno iva specificato");
|
||
return FALSE;
|
||
}
|
||
if (f.dlg() == A_DATA)
|
||
if (data.ok)
|
||
if ( data.day() == 31 && data.month() == 12 )
|
||
f.mask().show (TIPO_RIEPILOGATIVO);
|
||
else f.mask().hide (TIPO_RIEPILOGATIVO);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
const char * CG4400_application::descr_doc()
|
||
{
|
||
TTable tab_tpd("%TPD");
|
||
TString codtab(format("%-2s",(const char*) _tipodoc));
|
||
|
||
tab_tpd.zero();
|
||
tab_tpd.put("CODTAB", codtab);
|
||
if (tab_tpd.read()==NOERR)
|
||
TMP = tab_tpd.get("S0");
|
||
else
|
||
TMP = "";
|
||
|
||
return TMP;
|
||
}
|
||
|
||
const char * CG4400_application::descr_iva(const char * cod)
|
||
{
|
||
TTable tab_iva("%IVA");
|
||
TString codtab(format ("%-4s", cod));
|
||
|
||
tab_iva.zero();
|
||
tab_iva.put("CODTAB", codtab);
|
||
if (tab_iva.read()==NOERR)
|
||
TMP = tab_iva.get("S0");
|
||
else
|
||
TMP = "";
|
||
|
||
return TMP;
|
||
}
|
||
|
||
const char * CG4400_application::tipo_attivita()
|
||
{
|
||
TLocalisamfile attiv (LF_ATTIV);
|
||
|
||
attiv.zero();
|
||
attiv.put("CODDITTA", get_firm());
|
||
attiv.put("CODATT", _codatt);
|
||
if (attiv.read() == NOERR)
|
||
TMP = attiv.get("TIPOATT");
|
||
else TMP = "";
|
||
return TMP;
|
||
}
|
||
|
||
const char * CG4400_application::desc_attivita()
|
||
{
|
||
TTable attiv ("%AIS");
|
||
|
||
attiv.zero();
|
||
attiv.put("CODTAB", _codatt);
|
||
if (attiv.read()==NOERR)
|
||
TMP = attiv.get("S0");
|
||
else
|
||
TMP = "";
|
||
return TMP;
|
||
}
|
||
|
||
TRectype& CG4400_application::ricerca_cf(char tipocf, long codcf)
|
||
{
|
||
_clifo->zero();
|
||
_clifo->put(CLI_TIPOCF, tipocf);
|
||
_clifo->put(CLI_CODCF, codcf);
|
||
_clifo->read();
|
||
if (_clifo->bad())
|
||
_clifo->zero();
|
||
|
||
return _clifo->curr();
|
||
}
|
||
|
||
TRectype& CG4400_application::ricerca_occ(const char * occ)
|
||
{
|
||
TLocalisamfile occas (LF_OCCAS);
|
||
occas.zero();
|
||
occas.put(OCC_CFPI, occ);
|
||
occas.read();
|
||
if (occas.bad())
|
||
occas.zero();
|
||
|
||
return occas.curr();
|
||
}
|
||
|
||
bool CG4400_application::user_create()
|
||
{
|
||
_nditte = new TLocalisamfile(LF_NDITTE);
|
||
_com = new TLocalisamfile(LF_COMUNI);
|
||
_anag = new TLocalisamfile(LF_ANAG);
|
||
_unloc = new TLocalisamfile(LF_UNLOC);
|
||
_attiv = new TLocalisamfile(LF_ATTIV);
|
||
_tab = new TLocalisamfile(LF_TAB);
|
||
_tabcom = new TLocalisamfile(LF_TABCOM);
|
||
_tabreg = new TTable("REG");
|
||
_tabiva = new TTable("%IVA");
|
||
_tablbu = new TTable("%LBU");
|
||
_tabinl = new TTable("%INL");
|
||
_tablim = new TTable("LIM");
|
||
_tabpim = new TTable("PIM");
|
||
_tablia = new TTable("LIA");
|
||
_tabpla = new TTable("PLA");
|
||
_tabppa = new TTable("PPA");
|
||
_tabvid = new TTable("VID");
|
||
_clifo = new TLocalisamfile(LF_CLIFO);
|
||
_occas = new TLocalisamfile(LF_OCCAS);
|
||
_rel = new TRelation (LF_MOV);
|
||
|
||
_rel->add(LF_CAUSALI,"CODCAUS=CODCAUS",1,LF_MOV);
|
||
_rel->add(LF_RMOVIVA,"NUMREG=NUMREG",1,LF_MOV);
|
||
|
||
_cur = new TCursor(_rel, "", 2);
|
||
|
||
_ditte = new TArray_sheet(-1, -1, 0, 0, "Selezione Ditte",
|
||
"@1|Cod.@5|Ragione Sociale@50");
|
||
|
||
long firm = TApplication::get_firm();
|
||
|
||
for (_nditte->first(); !_nditte->eof(); _nditte->next())
|
||
{
|
||
if (!prefhndl->exist(_nditte->get_long("CODDITTA")))
|
||
continue;
|
||
TToken_string* d = new TToken_string(64);
|
||
d->add(" ");
|
||
d->add(_nditte->get("CODDITTA"));
|
||
d->add(_nditte->get("RAGSOC"));
|
||
_ditte->add(*d);
|
||
}
|
||
_n_ditte = _ditte->items();
|
||
|
||
TApplication::set_firm(firm);
|
||
|
||
add_cursor(_cur);
|
||
add_file(LF_MOV);
|
||
add_file(LF_RMOVIVA);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
bool CG4400_application::user_destroy()
|
||
{
|
||
delete _ditte;
|
||
delete _nditte;
|
||
delete _com;
|
||
delete _unloc;
|
||
delete _anag;
|
||
delete _attiv;
|
||
delete _tab;
|
||
delete _tabcom;
|
||
delete _tabreg;
|
||
delete _tabiva;
|
||
delete _tablbu;
|
||
delete _tabinl;
|
||
delete _tablim;
|
||
delete _tabpim;
|
||
delete _tablia;
|
||
delete _tabpla;
|
||
delete _tabppa;
|
||
delete _tabvid;
|
||
delete _clifo;
|
||
delete _occas;
|
||
delete _cur;
|
||
delete _rel;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/*
|
||
void CG4400_application::calcola_progressivi(real& r0, real& r1, real& r2, const char* codiva, const int tipocr)
|
||
{
|
||
TTable pim ("PIM");
|
||
TString chiave;
|
||
int i, num=0;
|
||
|
||
if (_tipo_stampa == 2)
|
||
num = _datareg.month();
|
||
if ( (_tipo_stampa == 3) || (_tipo_stampa == 4) )
|
||
num = _fino_a_mese;
|
||
|
||
if (_frequiva == 'T')
|
||
for (i=3; i<num+3; i+=3)
|
||
{
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << _codreg << i << tipocr << codiva;
|
||
pim.put("CODTAB", chiave);
|
||
if (pim.read()==NOERR)
|
||
{
|
||
r0 += pim.get_real("R0");
|
||
r1 += pim.get_real("R1");
|
||
r2 += pim.get_real("R2");
|
||
}
|
||
}
|
||
else //frequenza mensile
|
||
for (i=1; i<=num; i++)
|
||
{
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << _codreg << i << tipocr <<codiva;
|
||
pim.put("CODTAB", chiave);
|
||
if (pim.read()==NOERR)
|
||
{
|
||
r0 += pim.get_real("R0");
|
||
r1 += pim.get_real("R1");
|
||
r2 += pim.get_real("R2");
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
|
||
void CG4400_application::calcola_progressivi()
|
||
{
|
||
TTable pim ("PIM");
|
||
TString chiave;
|
||
int i, num=0;
|
||
|
||
if (_tipo_stampa == 3)
|
||
num = _fino_a_mese;
|
||
if ( _tipo_stampa == 2 || _tipo_stampa == 4 )
|
||
num = _datareg.month();
|
||
|
||
//calcolo i totali del periodo
|
||
if (_frequiva == 'T')
|
||
if (num%3 != 0)
|
||
num = num - (num%3);
|
||
|
||
chiave = "";
|
||
chiave << _annoes << _codatt;
|
||
pim.zero();
|
||
pim.put ("CODTAB", chiave);
|
||
TRectype r (pim.curr());
|
||
pim.read(_isgteq);
|
||
for (; !pim.eof(); pim.next())
|
||
{
|
||
if (pim.curr() != r) break;
|
||
|
||
TString80 codtab = pim.get("CODTAB");
|
||
TString16 codreg = codtab.mid(10,3);
|
||
int mese = atoi(codtab.mid(13,2));
|
||
if (_codreg == codreg && mese == num)
|
||
{
|
||
TString16 codiva = codtab.mid(16,4);
|
||
int tipodet = atoi(codtab.mid(20,1));
|
||
real impo = pim.get_real("R0");
|
||
real impos = pim.get_real("R1");
|
||
real implo = pim.get_real("R2");
|
||
_tot_iva_array.add_riga(impo,impos,implo,ZERO,ZERO,ZERO,codiva);
|
||
if (_tipo_reg == 2) //registro acquisti
|
||
_iva_array.add_riga(impo,impos,ZERO,ZERO,codiva,tipodet,0,TRUE);
|
||
}
|
||
}
|
||
|
||
if (_tipo_stampa == 3)
|
||
num = _fino_a_mese;
|
||
if ( _tipo_stampa == 2 || _tipo_stampa == 4 )
|
||
num = _datareg.month();
|
||
|
||
//calcolo i totali progressivi
|
||
if (_frequiva == 'T')
|
||
for (i=3; i<num+3; i+=3)
|
||
{
|
||
chiave = "";
|
||
chiave << _annoes << _codatt;
|
||
pim.zero();
|
||
pim.put ("CODTAB", chiave);
|
||
TRectype r (pim.curr());
|
||
pim.read(_isgteq);
|
||
for (; !pim.eof(); pim.next())
|
||
{
|
||
if (pim.curr() != r) break;
|
||
|
||
TString80 codtab = pim.get("CODTAB");
|
||
TString16 codreg = codtab.mid(10,3);
|
||
int mese = atoi(codtab.mid(13,2));
|
||
if (_codreg == codreg && mese == i)
|
||
{
|
||
TString16 codiva = codtab.mid(16,4);
|
||
int tipodet = atoi(codtab.mid(20,1));
|
||
real impo = pim.get_real("R0");
|
||
real impos = pim.get_real("R1");
|
||
real implo = pim.get_real("R2");
|
||
_tot_iva_array.add_riga(ZERO,ZERO,ZERO,impo,impos,implo,codiva);
|
||
if (_tipo_reg == 2) //registro acquisti
|
||
_iva_array.add_riga(ZERO,ZERO,impo,impos,codiva,tipodet,0,TRUE);
|
||
}
|
||
}
|
||
}
|
||
else //frequenza mensile
|
||
for (i=1; i<=num; i++)
|
||
{
|
||
chiave = "";
|
||
chiave << _annoes << _codatt;
|
||
pim.zero();
|
||
pim.put("CODTAB", chiave);
|
||
TRectype r (pim.curr());
|
||
pim.read(_isgteq);
|
||
for (; !pim.eof(); pim.next())
|
||
{
|
||
if (pim.curr() != r) break;
|
||
|
||
TString80 codtab = pim.get("CODTAB");
|
||
TString16 codreg = codtab.mid(10,3);
|
||
int mese = atoi(codtab.mid(13,2));
|
||
if (_codreg == codreg && mese == i)
|
||
{
|
||
TString16 codiva = codtab.mid(16,4);
|
||
int tipodet = atoi(codtab.mid(20,1));
|
||
real impo = pim.get_real("R0");
|
||
real impos = pim.get_real("R1");
|
||
real implo = pim.get_real("R2");
|
||
|
||
_tot_iva_array.add_riga(ZERO,ZERO,ZERO,impo,impos,implo,codiva);
|
||
if (_tipo_reg == 2) //registro acquisti
|
||
_iva_array.add_riga(ZERO,ZERO,impo,impos,codiva,tipodet,0,TRUE);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
int CG4400_application::riga_rmoviva()
|
||
{
|
||
TString codiva;
|
||
real impo, impos;
|
||
int tipodet, tipocr, tipoatt;
|
||
bool intra;
|
||
|
||
//_cur->save_status();
|
||
TLocalisamfile& rmoviva = _cur->file(LF_RMOVIVA);
|
||
bool ok = _cur->is_first_match(LF_RMOVIVA);
|
||
int nrec = 0;
|
||
|
||
TRecnotype nr = rmoviva.recno();
|
||
|
||
while (ok)
|
||
{
|
||
nrec++;
|
||
TRectype iva (rmoviva.curr());
|
||
tipodet = iva.get_int (RMI_TIPODET);
|
||
tipocr = iva.get_int (RMI_TIPOCR);
|
||
impo = iva.get_real(RMI_IMPONIBILE);
|
||
impos = iva.get_real(RMI_IMPOSTA);
|
||
codiva = iva.get(RMI_CODIVA);
|
||
intra = iva.get_bool(RMI_INTRA);
|
||
tipoatt = iva.get_int("TIPOATT");
|
||
|
||
_riga_rmi.add_riga(impo,impos,ZERO,ZERO,codiva,tipodet,tipocr,intra,tipoatt);
|
||
|
||
if (_tipo_stampa == 1) //stampa di prova
|
||
{
|
||
if (_tipodoc == "FS")
|
||
{
|
||
real somma = -(impo + impos);
|
||
_tot_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 (_tipodoc != "CR" && _tipodoc != "SC" && _tipodoc != "RF")
|
||
_tot_iva_array.add_riga(impo,impos,ZERO,ZERO,ZERO,ZERO,codiva);
|
||
|
||
if (_tipo_reg == 2) //registro acquisti (non ha senso parlare di importi lordi)
|
||
_iva_array.add_riga(impo,impos,ZERO,ZERO,codiva,tipodet,0,TRUE);
|
||
}
|
||
|
||
ok = _cur->next_match(LF_RMOVIVA);
|
||
}
|
||
//_cur->restore_status();
|
||
rmoviva.readat(nr);
|
||
|
||
return nrec;
|
||
}
|
||
|
||
int CG4400_application::setta_riga(int r, const TRigaiva& riga, real& tot1,
|
||
real& tot2, real& tot3, real& tot4)
|
||
{
|
||
set_row(r, "%3s", (const char*)riga._codiva);
|
||
TString descr = descr_iva(riga._codiva);
|
||
set_row(r, "@5g%s",(const char*)descr);
|
||
set_row(r, "@25g%r", &riga._imponibile);
|
||
set_row(r, "@41g%r", &riga._imposta);
|
||
if (_tipo_stampa != 1)
|
||
{
|
||
set_row(r, "@81g%r", &riga._imponibilep);
|
||
set_row(r++, "@98g%r", &riga._impostap);
|
||
}
|
||
else r++;
|
||
tot1 += riga._imponibile;
|
||
tot2 += riga._imposta;
|
||
tot3 += riga._imponibilep;
|
||
tot4 += riga._impostap;
|
||
|
||
return r;
|
||
}
|
||
|
||
bool CG4400_application::controlla_liquidazione()
|
||
{
|
||
TTable lim ("LIM");
|
||
TTable pim ("PIM");
|
||
TString mesi_ric = "";
|
||
TString mesi_cal = "";
|
||
TString16 chiave = "";
|
||
TString16 ditta = "";
|
||
int i, mese;
|
||
|
||
ditta << get_firm();
|
||
|
||
if (lim.empty())
|
||
return yesno_box("Ditta %s: non esiste la tabella liquidazione iva mensile! Vuoi ugualmente continuare la stampa?", (const char*) ditta);
|
||
if (pim.empty())
|
||
return yesno_box("Ditta %s: non esiste la tabella progressivi iva mensile! Vuoi ugualmente continuare la stampa?", (const char*) ditta);
|
||
|
||
if (_tipo_stampa == 1) //stampa di prova
|
||
mese = _data_a.month();
|
||
else
|
||
mese = _fino_a_mese;
|
||
|
||
if (_tipo_riepilogativo == ' ' || _tipo_riepilogativo == 'P')
|
||
{
|
||
if (_frequiva == 'T') //nella tabella LIM ho solo i mesi 3, 6, 9, 12
|
||
{
|
||
for (i=3; i<=mese; i+=3)
|
||
{
|
||
chiave = "";
|
||
chiave << _annoes << i;
|
||
lim.put("CODTAB", chiave);
|
||
if (lim.read() == NOERR)
|
||
{
|
||
bool calcolato = lim.get_bool("B0");
|
||
if (!calcolato)
|
||
mesi_ric << itom(i) << "\n";
|
||
}
|
||
else
|
||
mesi_cal << itom(i) << "\n";
|
||
}
|
||
}
|
||
if (_frequiva == 'M')
|
||
{
|
||
for (i=1 ; i<=mese; i++)
|
||
{
|
||
chiave = "";
|
||
chiave << _annoes << i;
|
||
lim.put("CODTAB", chiave);
|
||
if (lim.read() == NOERR)
|
||
{
|
||
bool calcolato = lim.get_bool("B0");
|
||
if (!calcolato)
|
||
mesi_ric << itom(i) << "\n";
|
||
}
|
||
else
|
||
mesi_cal << itom(i) << "\n";
|
||
}
|
||
}
|
||
if (mesi_ric.not_empty())
|
||
{
|
||
_liquidazione = FALSE;
|
||
warning_box ("Ditta %s: deve essere ricalcolata la liquidazione relativa ai mesi di:\n %s ", (const char*)ditta, (const char *)mesi_ric);
|
||
return yesno_box("Vuoi ugualmente continuare la stampa?");
|
||
}
|
||
if (mesi_cal.not_empty())
|
||
{
|
||
_liquidazione = FALSE;
|
||
warning_box ("Ditta %s: la liquidazione relativa ai mesi di \n %s non e' stata ancora calcolata", (const char*)ditta, (const char *)mesi_cal);
|
||
return yesno_box("Vuoi ugualmente continuare la stampa?");
|
||
}
|
||
}
|
||
else if (_tipo_riepilogativo == 'A')
|
||
if (_riep_liq)
|
||
{
|
||
chiave = "";
|
||
chiave << _annoes << 13;
|
||
lim.put("CODTAB", chiave);
|
||
if (lim.read() == NOERR)
|
||
{
|
||
bool calcolato = lim.get_bool("B0");
|
||
if (!calcolato)
|
||
{
|
||
_liquidazione = FALSE;
|
||
return yesno_box("Ditta %s: non eseguito calcolo liquidazione. Vuoi ugualmente continuare la stampa?", (const char*)ditta);
|
||
}
|
||
}
|
||
//else ?
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
//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 CG4400_application::controlla_mov()
|
||
{
|
||
TLocalisamfile mov (LF_MOV);
|
||
bool ok = TRUE;
|
||
bool first = TRUE;
|
||
byte tipo;
|
||
TString16 ditta = "";
|
||
TRecnotype rec = _tabreg->recno();
|
||
_stampa_mese = 0;
|
||
for (mov.first(); !mov.eof(); mov.next())
|
||
{
|
||
TString16 reg = mov.get(MOV_REG);
|
||
if (reg.empty()) continue; //non e' un movimento iva
|
||
TDate datareg = mov.get_date(MOV_DATAREG);
|
||
if (_stampa_tutti_i_registri)
|
||
cerca_reg (reg, &tipo);
|
||
if ( (_stampa_tutti_i_registri && (tipo == 1 || tipo == 2))
|
||
|| (!_stampa_tutti_i_registri && reg == _codreg) )
|
||
{
|
||
bool stampato = mov.get_bool(MOV_REGST);
|
||
if ( datareg.year() < _annoes )
|
||
{
|
||
long numreg = mov.get_long(MOV_NUMREG);
|
||
if (!stampato)
|
||
{
|
||
ditta = "";
|
||
ditta << get_firm();
|
||
warning_box("Ditta %s : il movimento con numero di registrazione %ld non e' ancora stato stampato in forma definitiva!", (const char*)ditta, numreg);
|
||
ok = FALSE;
|
||
}
|
||
}
|
||
if ( datareg.year() == _annoes && first)
|
||
if (!stampato)
|
||
{
|
||
_stampa_mese = datareg.month();
|
||
first = FALSE;
|
||
}
|
||
}
|
||
}
|
||
_tabreg->readat(rec);
|
||
return ok;
|
||
}
|
||
|
||
bool CG4400_application::cerca_libro_gio(TString& datas)
|
||
{
|
||
TString app(4);
|
||
app = format("%04d", _annoes);
|
||
|
||
TRecnotype rec = _tabreg->recno();
|
||
_tabreg->zero();
|
||
_tabreg->put ("CODTAB", app);
|
||
TRectype r (_tabreg->curr());
|
||
_tabreg->read(_isgteq);
|
||
for (; !_tabreg->eof(); _tabreg->next())
|
||
{
|
||
if (_tabreg->curr() != r) break;
|
||
|
||
int tiporeg = _tabreg->get_int("I0");
|
||
if (tiporeg == 5) //libro giornale
|
||
{
|
||
TDate data = _tabreg->get_date("D3");
|
||
if (_data_a > data)
|
||
{
|
||
datas = format("%02/%02d/%4d", data.day(), data.month(), data.year());
|
||
return FALSE;
|
||
}
|
||
}
|
||
}
|
||
_tabreg->readat(rec);
|
||
return TRUE;
|
||
}
|
||
|
||
void CG4400_application::cerca_reg(const TString& c, byte* t)
|
||
{
|
||
TString16 cod = "";
|
||
|
||
cod << _annoes << c;
|
||
_tabreg->zero();
|
||
_tabreg->put("CODTAB", cod);
|
||
if (_tabreg->read() == NOERR)
|
||
*t = _tabreg->get_int ("I0");
|
||
}
|
||
|
||
bool CG4400_application::ventilazione(const char* iva)
|
||
{
|
||
TTable tabiva ("%IVA");
|
||
TString16 chiave = "";
|
||
chiave << iva;
|
||
tabiva.put("CODTAB", chiave);
|
||
if (tabiva.read()==NOERR)
|
||
{
|
||
TString16 vent = tabiva.get("S1");
|
||
if (vent == "VE")
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
int CG4400_application::stampa_prospetto()
|
||
{
|
||
TString riga(_stampa_width);
|
||
int r=1, rr=0;
|
||
|
||
reset_print();
|
||
riga.fill('-');
|
||
set_row(r, "%s", (const char*)riga);
|
||
r++;
|
||
set_row(r, "Legenda Tipo Operazione: 1=operazione intracomunitaria 2=AF art.34 comma 3");
|
||
if (_auto_intraf)
|
||
set_row(r, "@78g3=operazione intracomunitaria e AF art.34 comma 3");
|
||
r++;
|
||
|
||
_stampa = stampa_totali_finali();
|
||
if (_stampa)
|
||
{
|
||
set_row(++r, "Tipo documento@30gTotale documento");
|
||
r+=2;
|
||
for (int j = 0; j < _doc_array.items(); j++)
|
||
{
|
||
TTipodoc& doc = (TTipodoc&)_doc_array[j];
|
||
rr = r+j;
|
||
set_row(rr, "%2s", (const char*) doc._tipodoc);
|
||
set_row(rr, "@3g%.25s", (const char*) doc._descrdoc);
|
||
set_row(rr, "@29g%r", &doc._totdoc);
|
||
}
|
||
_doc_array.destroy();
|
||
}
|
||
|
||
if (rr > 0)
|
||
rr++;
|
||
else
|
||
rr = r;
|
||
|
||
if (_stampa && _tipo_reg == 2)
|
||
if (_stampa_cred_pre && _mese_credito==0 && _credito > ZERO)
|
||
{
|
||
set_row (++rr, "** CREDITO INIZIO ANNO %r = credito iva anno precedente", &_credito);
|
||
rr++;
|
||
}
|
||
|
||
if (_esiste_riga_iva && _stampa)
|
||
{
|
||
if (_tipo_reg == 1 && _corrispettivi)
|
||
set_row(++rr, "@26g------------------ P E R I O D O -------------------");
|
||
else
|
||
set_row(++rr, "@26g---------- P E R I O D O -----------");
|
||
if (_tipo_stampa != 1)
|
||
{
|
||
if (_tipo_reg == 1 && _corrispettivi)
|
||
set_row(rr,"@84g----------- P R O G R E S S I V I --------------");
|
||
else
|
||
set_row(rr,"@82g------ P R O G R E S S I V I ------");
|
||
}
|
||
rr++;
|
||
set_row(rr, "Cod.");
|
||
if (_tipo_reg == 2)
|
||
{
|
||
set_row(rr, "@36gA C Q U I S T I");
|
||
if (_tipo_stampa != 1)
|
||
set_row(rr, "@92gA C Q U I S T I");
|
||
}
|
||
if (_tipo_reg == 1) //un registro corrispettivi puo' solo essere un registro vendite
|
||
{
|
||
set_row(rr, "@37gV E N D I T E");
|
||
if (_corrispettivi)
|
||
set_row(rr, "@63gCORRISPETTIVI");
|
||
if (_tipo_stampa != 1)
|
||
{
|
||
if (_corrispettivi)
|
||
set_row(rr, "@94gV E N D I T E@118gCORRISPETTIVI");
|
||
else
|
||
set_row(rr, "@93gV E N D I T E");
|
||
}
|
||
}
|
||
rr++;
|
||
set_row(rr, "iva Descrizione@30gImponibile@49gImposta");
|
||
if (_tipo_reg == 1 && _corrispettivi)
|
||
set_row(rr, "@63gImporti lordi");
|
||
if (_tipo_stampa != 1)
|
||
{
|
||
if (_tipo_reg == 1 && _corrispettivi)
|
||
set_row(rr++, "@87gImponibile@107gImposta@118gImporti Lordi");
|
||
else
|
||
set_row(rr++, "@86gImponibile@106gImposta");
|
||
}
|
||
else rr++;
|
||
rr++;
|
||
}
|
||
return rr;
|
||
}
|
||
|
||
//la stampa "tipi di indetraibilita'" viene fatta solo per gli acquisti
|
||
int CG4400_application::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 = 0.00;
|
||
|
||
_iva_array.sort(compare_fields);
|
||
for (int s = 0; s < _iva_array.items(); s++)
|
||
{
|
||
TRigaiva& riga = (TRigaiva&)_iva_array[s];
|
||
switch (riga._tipodet)
|
||
{
|
||
case 1: if (riga._tipodet != tdetprec)
|
||
{
|
||
set_row(rw++, "----- Indetraibile su op.es. -----");
|
||
set_row(rw, "Cod.");
|
||
rw++;
|
||
set_row(rw, "iva Descrizione@30gImponibile@49gImposta");
|
||
if (_tipo_stampa != 1)
|
||
set_row(rw++, "@86gImponibile@106gImposta");
|
||
else rw++;
|
||
rw++;
|
||
}
|
||
rw = setta_riga(rw, riga, tot_imponib, tot_imposta, tot_imponibp, tot_impostap);
|
||
tdetprec = riga._tipodet;
|
||
break;
|
||
case 3: if (tdetprec == 1)
|
||
{
|
||
set_row(++rw, "TOTALE@25g%r@41g%r", &tot_imponib, &tot_imposta);
|
||
if (_tipo_stampa != 1)
|
||
set_row(rw, "@81g%r@98g%r", &tot_imponibp, &tot_impostap);
|
||
tot_imponib = tot_imposta = tot_imponibp = tot_impostap = 0.00;
|
||
rw+=2;
|
||
}
|
||
if (riga._tipodet != tdetprec)
|
||
{
|
||
set_row(rw++, "----- Passaggi interni -----");
|
||
set_row(rw, "Cod.");
|
||
rw++;
|
||
set_row(rw, "iva Descrizione@30gImponibile@49gImposta");
|
||
if (_tipo_stampa != 1)
|
||
set_row(rw++, "@86gImponibile@106gImposta");
|
||
else rw++;
|
||
rw++;
|
||
}
|
||
rw = setta_riga(rw, riga, tot_imponib, tot_imposta, tot_imponibp, tot_impostap);
|
||
tdetprec = riga._tipodet;
|
||
break;
|
||
case 9: if ( (tdetprec == 1) || (tdetprec == 3) )
|
||
{
|
||
set_row(++rw, "TOTALE@25g%r@41g%r", &tot_imponib, &tot_imposta);
|
||
if (_tipo_stampa != 1)
|
||
set_row(rw, "@81g%r@98g%r", &tot_imponibp, &tot_impostap);
|
||
tot_imponib = tot_imposta = tot_imponibp = tot_impostap = 0.00;
|
||
rw+=2;
|
||
}
|
||
if (riga._tipodet != tdetprec)
|
||
{
|
||
set_row(rw++, "----- N.D. 9 - acquisti indeducibili per ART.19 -----");
|
||
set_row(rw, "Cod.");
|
||
rw++;
|
||
set_row(rw, "iva Descrizione@30gImponibile@49gImposta");
|
||
if (_tipo_stampa != 1)
|
||
set_row(rw++, "@86gImponibile@106gImposta");
|
||
else rw++;
|
||
rw++;
|
||
}
|
||
rw = setta_riga(rw, riga, tot_imponib, tot_imposta, tot_imponibp, tot_impostap);
|
||
tdetprec = riga._tipodet;
|
||
break;
|
||
default: break;
|
||
}
|
||
}
|
||
if (_iva_array.items() > 0)
|
||
if (tdetprec == 9)
|
||
{
|
||
set_row(++rw, "TOTALE@25g%r@41g%r", &tot_imponib, &tot_imposta);
|
||
if (_tipo_stampa != 1)
|
||
set_row(rw, "@81g%r@98g%r", &tot_imponibp, &tot_impostap);
|
||
}
|
||
_iva_array.destroy();
|
||
rw++;
|
||
return rw;
|
||
}
|
||
|
||
/*
|
||
void CG4400_application::set_page_tot_reg()
|
||
{
|
||
TString16 codivaprec = "";
|
||
int row=0, rr=0;
|
||
|
||
rr = stampa_prospetto();
|
||
|
||
//if (_nrec > 0) //numero di records di rmoviva
|
||
if (_esiste_riga_iva && _stampa)
|
||
{
|
||
real tot_imponib, tot_imposta, tot_imponibp, tot_impostap, tot_lordo;
|
||
real dep_imponib, dep_imposta, dep_lordo;
|
||
tot_imponib = tot_imposta = tot_imponibp = tot_impostap = tot_lordo = ZERO;
|
||
dep_imponib = dep_imposta = dep_lordo = ZERO;
|
||
|
||
_tot_iva_array.sort(compare_rows); //viene ordinato per codice iva
|
||
|
||
for (int k = 0; k < _tot_iva_array.items(); k++)
|
||
{
|
||
TRiga& riga = (TRiga&)_tot_iva_array[k];
|
||
//row = rr+k;
|
||
if (codivaprec == "")
|
||
codivaprec = riga._codiva;
|
||
if (codivaprec != riga._codiva)
|
||
{
|
||
set_row(rr, "%3s", (const char*)codivaprec);
|
||
TString descr = descr_iva(codivaprec);
|
||
set_row(rr, "@5g%s",(const char*)descr);
|
||
if (dep_imponib != ZERO)
|
||
set_row(rr, "@25g%r", &dep_imponib);
|
||
if (dep_imposta != ZERO)
|
||
set_row(rr, "@41g%r", &dep_imposta);
|
||
if (dep_lordo != ZERO)
|
||
set_row(rr, "@61g%r", &dep_lordo);
|
||
}
|
||
rr++;
|
||
codivaprec = riga._codiva;
|
||
dep_imponib = dep_imposta = dep_lordo = ZERO;
|
||
}
|
||
if (riga._tipodoc == "FS")
|
||
{
|
||
real somma = -(riga._imponibile + riga._imposta);
|
||
dep_lordo += somma;
|
||
}
|
||
else if (riga._tipodoc == "CR" || riga._tipodoc == "RF" || riga._tipodoc == "SC")
|
||
{
|
||
dep_lordo += riga._imponibile + riga._imposta;
|
||
tot_lordo += riga._imponibile + riga._imposta;
|
||
}
|
||
|
||
if (riga._tipodoc != "CR" && riga._tipodoc != "SC" && riga._tipodoc == "RF")
|
||
{
|
||
dep_imponib += riga._imponibile;
|
||
dep_imposta += riga._imposta;
|
||
tot_imponib += riga._imponibile;
|
||
tot_imposta += riga._imposta;
|
||
}
|
||
|
||
if (k == (_tot_iva_array.items()-1))
|
||
{
|
||
set_row(rr, "%3s", (const char*)riga._codiva);
|
||
TString descr = descr_iva(riga._codiva);
|
||
set_row(rr, "@5g%s", (const char*)descr);
|
||
if (dep_imponib != ZERO)
|
||
set_row(rr, "@25g%r", &dep_imponib);
|
||
if (dep_imposta != ZERO)
|
||
set_row(rr, "@41g%r", &dep_imposta);
|
||
if (dep_lordo != ZERO)
|
||
set_row(rr, "@61g%r", &dep_lordo);
|
||
}
|
||
}
|
||
_tot_iva_array.destroy();
|
||
rr++;
|
||
set_row(++rr, "TOTALE@25g%r@41g%r", &tot_imponib, &tot_imposta);
|
||
if (_corrispettivi)
|
||
if (tot_lordo != ZERO)
|
||
set_row(rr, "@61g%r", &tot_lordo);
|
||
|
||
if (_tipo_reg == 2) rr = stampa_acquisti(rr);
|
||
|
||
if (_tipo_reg == 2 && _tipo_stampa != 1)
|
||
stampa_plafonds(rr);
|
||
}
|
||
}
|
||
*/
|
||
|
||
void CG4400_application::set_page_tot_reg()
|
||
{
|
||
int rr=0;
|
||
|
||
rr = stampa_prospetto();
|
||
|
||
//if (_nrec > 0) //numero di records di rmoviva
|
||
if (_esiste_riga_iva && _stampa)
|
||
{
|
||
real tot_imponib, tot_imposta, tot_lordo, tot_imponibp, tot_impostap, tot_lordop;
|
||
tot_imponib = tot_imposta = tot_lordo = tot_imponibp = tot_impostap = tot_lordop = ZERO;
|
||
|
||
_tot_iva_array.sort(compare_rows); //viene ordinato per codice iva
|
||
|
||
for (int k = 0; k < _tot_iva_array.items(); k++)
|
||
{
|
||
TRiga& riga = (TRiga&)_tot_iva_array[k];
|
||
//row = rr+k;
|
||
set_row(rr, "%3s", (const char*)riga._codiva);
|
||
TString80 descr = descr_iva(riga._codiva);
|
||
set_row(rr, "@5g%s",(const char*)descr);
|
||
if (riga._imponibile != ZERO)
|
||
set_row(rr, "@25g%r", &riga._imponibile);
|
||
if (riga._imposta != ZERO)
|
||
set_row(rr, "@41g%r", &riga._imposta);
|
||
if (_tipo_reg == 1 && _corrispettivi)
|
||
if (riga._implordo != ZERO)
|
||
set_row(rr, "@61g%r", &riga._implordo);
|
||
if (_tipo_stampa != 1)
|
||
{
|
||
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 == 1 && _corrispettivi)
|
||
if (riga._implordop != ZERO)
|
||
set_row(rr, "@115g%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;
|
||
}
|
||
_tot_iva_array.destroy();
|
||
rr++;
|
||
set_row(++rr, "TOTALE@25g%r@41g%r", &tot_imponib, &tot_imposta);
|
||
if (_tipo_reg == 1 && _corrispettivi)
|
||
set_row(rr, "@61g%r", &tot_lordo);
|
||
if (_tipo_stampa != 1)
|
||
{
|
||
set_row(rr, "@81g%r@98g%r", &tot_imponibp, &tot_impostap);
|
||
if (_tipo_reg == 1 && _corrispettivi)
|
||
set_row(rr, "@115g%r", &tot_lordop);
|
||
}
|
||
|
||
if (_tipo_reg == 2) rr = stampa_acquisti(rr);
|
||
|
||
if (_tipo_reg == 2 && _tipo_stampa != 1)
|
||
stampa_plafonds(rr);
|
||
}
|
||
}
|
||
|
||
void CG4400_application::stampa_plafonds(int r)
|
||
{
|
||
TTable pla ("PLA");
|
||
TTable ppa ("PPA");
|
||
TString80 chiave;
|
||
int num;
|
||
real r1, r2, r3;
|
||
|
||
r1 = r2 = r3 = ZERO;
|
||
|
||
if (_tipo_stampa == 3)
|
||
num = _fino_a_mese;
|
||
if ( _tipo_stampa == 2 || _tipo_stampa == 4 )
|
||
num = _datareg.month();
|
||
|
||
// forza il tipoatt a 1
|
||
char buf[10]; strcpy(buf,_codatt);
|
||
buf[strlen(buf) - 1] = '1';
|
||
|
||
chiave = "";
|
||
chiave << _annoes << buf;
|
||
pla.put("CODTAB", chiave);
|
||
|
||
if (pla.read() == NOERR)
|
||
{
|
||
r1 = pla.get_real("R1"); //totali esp. art.8
|
||
r2 = pla.get_real("R2"); //totali esp. art.8 bis
|
||
r3 = pla.get_real("R3"); //totali esp. art 9
|
||
}
|
||
|
||
if (r1 > ZERO || r2 > ZERO || r3 > ZERO)
|
||
{
|
||
set_row(++r, "QUADRO RELATIVO ALLA DISPONIBILITA' E UTILIZZAZIONE MENSILE DEI PLAFONDS");
|
||
r++;
|
||
TString mese(9);
|
||
mese = itom(num);
|
||
mese.right_just();
|
||
set_row(++r, "%s", (const char*) mese);
|
||
r++;
|
||
}
|
||
else return;
|
||
|
||
if (r1 > ZERO)
|
||
{
|
||
real r8 = ZERO;
|
||
r8 = stampa_valori_plafonds(r1, num, ppa);
|
||
if (r8 > ZERO)
|
||
{
|
||
real pri = ZERO;
|
||
real pre = ZERO;
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "1" << num << "1";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri = ppa.get_real("R0");
|
||
pre = ppa.get_real("R1");
|
||
}
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "2" << num << "1";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri += ppa.get_real("R0");
|
||
pre += ppa.get_real("R1");
|
||
}
|
||
real x = r8 - pri - pre;
|
||
set_row(r++, "ART. 8 1<> comma lettere a-b Disponibile %r", &r8);
|
||
set_row(r++, "Utilizzato all'interno@33g%r", &pri);
|
||
set_row(r++, "Utilizzato per l'importazione@33g%r riporto %r", &pre, &x);
|
||
}
|
||
}
|
||
|
||
if (r2 > ZERO)
|
||
{
|
||
real r8b = ZERO;
|
||
r8b = stampa_valori_plafonds(r2, num, ppa);
|
||
if (r8b > ZERO)
|
||
{
|
||
real pri = ZERO;
|
||
real pre = ZERO;
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "1" << num << "2";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri = ppa.get_real("R0");
|
||
pre = ppa.get_real("R1");
|
||
}
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "2" << num << "2";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri += ppa.get_real("R0");
|
||
pre += ppa.get_real("R1");
|
||
}
|
||
real x = r8b - pri - pre;
|
||
r++;
|
||
set_row(r++, "ART. 8 bis 1<> comma Disponibile %r", &r8b);
|
||
set_row(r++, "Utilizzato all'interno@33g%r", &pri);
|
||
set_row(r++, "Utilizzato per l'importazione@33g%r riporto %r", &pre, &x);
|
||
}
|
||
}
|
||
|
||
if (r3 > ZERO)
|
||
{
|
||
real r9 = ZERO;
|
||
r9 = stampa_valori_plafonds(r3, num, ppa);
|
||
if (r9 > ZERO)
|
||
{
|
||
real pri = ZERO;
|
||
real pre = ZERO;
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "1" << num << "3";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri = ppa.get_real("R0");
|
||
pre = ppa.get_real("R1");
|
||
}
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "2" << num << "3";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
pri += ppa.get_real("R0");
|
||
pre += ppa.get_real("R1");
|
||
}
|
||
real x = r9 - pri - pre;
|
||
r++;
|
||
set_row(r++, "ART. 8 bis 1<> comma Disponibile %r", &r9);
|
||
set_row(r++, "Utilizzato all'interno@33g%r", &pri);
|
||
set_row(r++, "Utilizzato per l'importazione@33g%r riporto %r", &pre, &x);
|
||
}
|
||
}
|
||
}
|
||
|
||
real CG4400_application::stampa_valori_plafonds(const real& r1, const int mese, TTable& ppa)
|
||
{
|
||
real r, si8, se8;
|
||
TString80 chiave;
|
||
int i;
|
||
|
||
r = r1;
|
||
si8 = se8 = ZERO;
|
||
if (mese > 1)
|
||
{
|
||
for (i=1; i<mese; i++)
|
||
{
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "1" << i << "1";
|
||
ppa.put("CODTAB", chiave);
|
||
if (ppa.read() == NOERR)
|
||
{
|
||
si8 += ppa.get_real("R0");
|
||
se8 += ppa.get_real("R1");
|
||
}
|
||
chiave = "";
|
||
chiave << _annoes << _codatt << "2" << i << "1";
|
||
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 CG4400_application::compila_reg(const TMask& m)
|
||
{
|
||
int anno;
|
||
long codditta = _nditte->get_long("CODDITTA");
|
||
TString16 codtab = "";
|
||
TString16 cod_lib_un;
|
||
TDate sca_vid;
|
||
|
||
_tipo_stampa = m.get_int(TIPO_STAMPA);
|
||
if (_tipo_stampa == 3) //stampa su libro unico di studio
|
||
_codreg = m.get(CODICE_LIBRO_IVA);
|
||
else if (_tipo_stampa == 1) //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())
|
||
{
|
||
codtab = _tabreg->get("CODTAB");
|
||
anno = atoi(codtab.mid(0,4));
|
||
if (anno > _annoes)
|
||
{
|
||
if (_tipo_stampa != 3) //per il libro unico e' gia' stato controllato
|
||
warning_box("Non esistono registri IVA della Ditta %ld per l'anno %d",
|
||
codditta, _annoes);
|
||
return FALSE;
|
||
}
|
||
}
|
||
}
|
||
else // stampa un solo registro
|
||
{
|
||
_stampa_tutti_i_registri = FALSE;
|
||
codtab << _annoes << _codreg;
|
||
_tabreg->zero();
|
||
_tabreg->put("CODTAB", codtab);
|
||
if (_tabreg->read() == NOERR)
|
||
{
|
||
_tipo_reg = _tabreg->get_int("I0");
|
||
if (_tipo_reg == 1 || _tipo_reg == 2) //registro iva
|
||
{
|
||
cod_lib_un = _tabreg->get("S6");
|
||
sca_vid = _tabreg->get_date("D0");
|
||
if (_tipo_stampa != 1)
|
||
{
|
||
_u_data = _tabreg->get_date ("D3");
|
||
if (!_u_data.ok())
|
||
_u_data = format("01/01/%4d", _annoes);
|
||
}
|
||
if ( _tipo_stampa == 2 || _tipo_stampa == 4 )
|
||
{
|
||
if (_data_a < _u_data)
|
||
{
|
||
TString16 datas = format("%02d/%02d/%4d", _u_data.day(), _u_data.month(), _u_data.year());
|
||
warning_box ("Ditta %ld: la data specificata non deve essere inferiore al %s (ultima data di stampa specificata sul registro)", codditta, (const char*)datas);
|
||
return FALSE;
|
||
}
|
||
if (cod_lib_un.not_empty())
|
||
{
|
||
warning_box ("Ditta %ld: sul registro non deve essere indicato il codice del libro unico", codditta);
|
||
return FALSE;
|
||
}
|
||
if (sca_vid.month() < _fino_a_mese)
|
||
{
|
||
warning_box ("Ditta %ld: il mese della data scadenza vidimazione riportata sul registro non deve essere inferiore al mese indicato", codditta);
|
||
return FALSE;
|
||
}
|
||
if (_tipo_stampa == 4) //stampa con riferimenti al libro giornale
|
||
{
|
||
TString16 datas;
|
||
bool ok = cerca_libro_gio(datas);
|
||
if (!ok)
|
||
{
|
||
warning_box ("Ditta %ld: la data indicata non deve essere superiore al %s (ultima data di stampa del libro giornale)", codditta, (const char*)datas);
|
||
return FALSE;
|
||
}
|
||
}
|
||
}
|
||
_pagine_stampate = _tabreg->get_long("I1");
|
||
_numini = _pagine_stampate;
|
||
_corrispettivi = _tabreg->get_bool("B0");
|
||
_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");
|
||
_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();
|
||
_desc_lib = _tabreg->get ("S0");
|
||
}
|
||
}
|
||
else if (_tipo_stampa != 3)
|
||
{
|
||
warning_box("Il registro IVA specificato non esiste nella \n Ditta %ld", codditta);
|
||
return FALSE;
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool CG4400_application::compila_lib()
|
||
{
|
||
TTable tab_lib ("%LBU");
|
||
TString16 cod;
|
||
|
||
cod << _annoes << _codlib;
|
||
tab_lib.zero();
|
||
tab_lib.put("CODTAB", cod);
|
||
|
||
if (tab_lib.read() == NOERR)
|
||
{
|
||
_stampa_ind_ditta = tab_lib.get_bool("B1");
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
bool CG4400_application::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();
|
||
_doc_array.destroy();
|
||
_dataregp = "";
|
||
_esiste_riga_iva = FALSE;
|
||
_auto_intraf = FALSE;
|
||
_intesta_liq = FALSE;
|
||
set_print_zero();
|
||
if (_tipo_stampa == 3)
|
||
calcola_progressivi();
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool CG4400_application::preprocess_page(int file, int counter)
|
||
{
|
||
if (file == LF_MOV)
|
||
{
|
||
if (counter) return TRUE;
|
||
|
||
reset_print();
|
||
int rr = 0, riga = 0;
|
||
TString80 comune, prov, comcf, capcf, civcf;
|
||
TString80 viacf;
|
||
TString ragsoc;
|
||
TString tipo_op = "";
|
||
|
||
TLocalisamfile& mov = _cur->file(LF_MOV);
|
||
TLocalisamfile& caus = _cur->file(LF_CAUSALI);
|
||
|
||
_datareg = mov.get_date(MOV_DATAREG);
|
||
|
||
if (_tipo_stampa == 2 || _tipo_stampa == 4)
|
||
for (int m = _stampa_mese; m > 0 && m < _datareg.month(); m++)
|
||
{
|
||
if (!_st_liq[m])
|
||
if (stampo_liquidazione(m))
|
||
{
|
||
_datareg = format("01/%02d/%4d", m, _annoes); //serve per la preprocess_header
|
||
_intesta_liq = TRUE;
|
||
TFilename t;
|
||
t.temp();
|
||
send_message('L',t, m);
|
||
if (m > 1) printer().formfeed();
|
||
merge_export_file(t,FALSE,TRUE);
|
||
_intesta_liq = FALSE;
|
||
_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();
|
||
}
|
||
|
||
_dataregp = _datareg;
|
||
|
||
TDate datadoc = mov.get_date(MOV_DATADOC);
|
||
long numreg = mov.get_long(MOV_NUMREG);
|
||
long protiva = mov.get_long(MOV_PROTIVA);
|
||
long uprotiva = mov.get_long(MOV_UPROTIVA);
|
||
real totdoc = mov.get_real(MOV_TOTDOC);
|
||
TString16 numdoc = mov.get(MOV_NUMDOC);
|
||
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);
|
||
TString16 codval = mov.get(MOV_CODVALI);
|
||
real corrval = mov.get_real(MOV_CORRVALUTA);
|
||
bool intra = caus.get_bool(CAU_INTRACOM); //da prendere sul movimento ?
|
||
bool autof = caus.get_bool(CAU_AUTOFATT);
|
||
TString80 descrcau = caus.get(CAU_DESCR);
|
||
|
||
if (_cur->pos() == 0)
|
||
_uprotivap = uprotiva ? uprotiva : protiva;
|
||
|
||
//aggiornamento di mov
|
||
if (_tipo_stampa != 1)
|
||
if (!stampato)
|
||
{
|
||
mov.put(MOV_REGST,TRUE);
|
||
mov.rewrite();
|
||
}
|
||
|
||
if ( intra && autof)
|
||
{
|
||
_auto_intraf = TRUE;
|
||
tipo_op = "3";
|
||
}
|
||
else if (intra)
|
||
tipo_op = "1";
|
||
else if (autof)
|
||
tipo_op = "2";
|
||
|
||
if (codcf == 0l)
|
||
ragsoc = descrcau;
|
||
else
|
||
{
|
||
if (ocfpi.trim().empty())
|
||
{
|
||
TRectype dep = ricerca_cf(tipocf, codcf);
|
||
ragsoc = dep.get (CLI_RAGSOC);
|
||
viacf = dep.get (CLI_INDCF);
|
||
civcf = dep.get (CLI_CIVCF);
|
||
capcf = dep.get (CLI_CAPCF);
|
||
comcf = dep.get (CLI_COMCF);
|
||
}
|
||
else
|
||
{
|
||
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);
|
||
}
|
||
TRectype com = look_comuni(comcf);
|
||
comune = com.get(COM_DENCOM);
|
||
prov = com.get(COM_PROVCOM);
|
||
}
|
||
|
||
_tipodoc = mov.get(MOV_TIPODOC);
|
||
_descr_doc = descr_doc();
|
||
TString app = datadoc.string(2, '/');
|
||
|
||
if (stampa_totali_finali())
|
||
_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(2, '/'));
|
||
set_row(_r, "@9g%5d", protiva);
|
||
if (datadoc.ok())
|
||
set_row(_r, "@15g%s", (const char*) app);
|
||
set_row(_r, "@24g%s", (const char*) numdoc);
|
||
set_row(_r, "@32g%ld", codcf);
|
||
set_row(_r, "@39g%.28s",(const char*) ragsoc);
|
||
set_row(_r, "@68g%s", (const char*) tipo_op);
|
||
set_row(_r, "@70g%2s", (const char*) _tipodoc);
|
||
if (_stampa_width == 132)
|
||
set_row(_r, "@72g%r", &totdoc);
|
||
else set_row(_r, "@78g%r", &totdoc);
|
||
|
||
if (_tipo_stampa == 1) //in caso di stampa di prova
|
||
if (! (_tipo_reg == 1 && _corrispettivi)) //e se non si tratta di registro vendite corrispettivi
|
||
if (! (_cur->pos()==0)) //il primo movimento non va controllato
|
||
{
|
||
if (protiva != _uprotivap + 1)
|
||
{
|
||
set_row(_r+1, "@5g*** NUM.PROT.FUORI SEQUENZA");
|
||
riga = _r+2;
|
||
}
|
||
_uprotivap = uprotiva ? uprotiva : protiva;
|
||
}
|
||
|
||
if (codcf != 0l && _stampa_ind_comp)
|
||
{
|
||
set_row (_r+1, "@39g%.24s %.3s",(const char *)viacf, (const char *)civcf);
|
||
set_row (_r+2, "@39g%s %.22s", (const char *)capcf, (const char *)comune);
|
||
riga = _r+3;
|
||
}
|
||
_nrec = riga_rmoviva();
|
||
if (_nrec > 0)
|
||
{
|
||
_esiste_riga_iva = TRUE;
|
||
for (int j = 0; j < _riga_rmi.items(); j++)
|
||
{
|
||
TRigaiva& riga = (TRigaiva&)_riga_rmi[j];
|
||
rr = _r+j;
|
||
if (_stampa_width == 132)
|
||
{
|
||
set_row(rr, "@87g%r", &riga._imponibile);
|
||
set_row(rr, "@102g%4s",(const char*)riga._codiva);
|
||
if (_tipo_reg == 2)
|
||
set_row(rr, "@107g%d", riga._tipodet);
|
||
set_row(rr, "@108g%r", &riga._imposta);
|
||
set_row(rr, "@124g%d", riga._tipocr);
|
||
if (_tipoatt == "E")
|
||
set_row(rr, "@126g%d", riga._tipoatt);
|
||
if (_tipo_stampa == 4) //stampa con riferimento al libro giornale
|
||
set_row(rr, "@127g%4ld", numgio);
|
||
}
|
||
else //stampa a 198
|
||
{
|
||
set_row(rr, "@93g%r", &riga._imponibile);
|
||
set_row(rr, "@109g%4s",(const char*)riga._codiva);
|
||
if (_tipo_reg == 2)
|
||
set_row(rr, "@114g%d", riga._tipodet);
|
||
set_row(rr, "@116g%r", &riga._imposta);
|
||
if (_tipoatt == "E")
|
||
set_row(rr, "@132g%d", riga._tipoatt);
|
||
set_row(rr, "@134g%d", riga._tipocr);
|
||
if (_tipo_stampa == 4) //stampa con riferimento al libro giornale
|
||
set_row(rr, "@136g%7ld", numgio);
|
||
}
|
||
}
|
||
_riga_rmi.destroy();
|
||
}
|
||
if (_tipo_stampa == 1) //stampa di prova
|
||
{
|
||
if (_stampa_width == 132)
|
||
{
|
||
set_row(_r, "@127g%4ld", 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 == 4 && _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");
|
||
TConto tc (gruppo,conto,sottoc);
|
||
TString80 descr = tc.descrizione();
|
||
set_row(_r, "@144g%3d %3d %6d", gruppo, conto, sottoc);
|
||
set_row(_r, "@160g%s", (const char*) descr);
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (riga == 0) riga = ++rr;
|
||
|
||
if (corrval != ZERO)
|
||
set_row(riga, "@30gCodice valuta %s Corrispettivo in valuta %r", (const char*) codval, &corrval);
|
||
|
||
//int tipocr = _cur->file(LF_RMOVIVA)->get_int(RMI_TIPOCR);
|
||
//set_row(_r, "@124g%d", tipocr);
|
||
|
||
//if (_tipo_stampa == 4)
|
||
// set_row(_r, "@125g%ld", numgio);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
void CG4400_application::aggiorna_reg()
|
||
{
|
||
TString16 codtab;
|
||
TTable Tabreg ("REG");
|
||
TTable TabInl ("%INL");
|
||
int mese;
|
||
//long pag;
|
||
//long stampate;
|
||
|
||
word ultimast = get_page_number();
|
||
if (_stampa_tutti_i_registri) //ho fatto un salto pagina dopo avere stampato un registro
|
||
--ultimast;
|
||
|
||
codtab << _annoes << _codreg;
|
||
Tabreg.zero();
|
||
Tabreg.put("CODTAB", codtab);
|
||
if (Tabreg.read() == NOERR)
|
||
{
|
||
TDate d = Tabreg.get_date("D3");
|
||
//stampate = ultimast + 1;
|
||
if (!_mov_empty) //cioe' se e' stata stampata almeno una pagina
|
||
{
|
||
TDate ultima_data = format("%02d/%02d/%4d", _datareg.last_day(_datareg.month(), _annoes), _datareg.month(), _annoes);
|
||
if (ultima_data > d)
|
||
Tabreg.put("D3", ultima_data);
|
||
//pag = _pagine_stampate + ultimast;
|
||
//Tabreg.put("I1", pag);
|
||
}
|
||
else if (_data_a > d)
|
||
Tabreg.put("D3", _data_a);
|
||
|
||
Tabreg.put("I1", _pagine_stampate);
|
||
if (_tipo_reg == 2 && _stampa_cred_pre)
|
||
if (_mese_credito == 0 && _credito > ZERO)
|
||
if (_mov_empty)
|
||
Tabreg.put("I8", (long)_fino_a_mese);
|
||
else Tabreg.put("I8", _datareg.month());
|
||
|
||
Tabreg.rewrite();
|
||
}
|
||
if (_tipo_stampa == 3) //stampa su libro unico
|
||
//sulla tabella %inl (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
|
||
if (!_mov_empty || _ok_vidi) //se ho stampato almeno un movimento oppure ho stampato la vidimazione
|
||
{
|
||
bool trovato = FALSE;
|
||
codtab = "";
|
||
codtab << _annoes << _codlib;
|
||
TabInl.zero();
|
||
TRectype nuovo (TabInl.curr());
|
||
TRectype recprec (TabInl.curr());
|
||
TabInl.put("CODTAB", codtab);
|
||
|
||
TRectype rec (TabInl.curr());
|
||
TabInl.read (_isgteq);
|
||
for (; !TabInl.eof(); TabInl.next())
|
||
{
|
||
if (TabInl.curr() != rec) break;
|
||
|
||
mese = TabInl.get_int("I1");
|
||
trovato = TRUE;
|
||
recprec = TabInl.curr();
|
||
if (mese == _fino_a_mese) break; //cosi' mi posiziono su quel mese (altrimenti rischio di generare due righe per lo stesso mese e registro => la stampa di vidimazione mi sballa tutta!!!
|
||
}
|
||
TString cod = "";
|
||
if (trovato && mese != _fino_a_mese)
|
||
{
|
||
TString16 cod_inl = recprec.get("CODTAB");
|
||
long numero_riga = atol(cod_inl.mid(7,6)) + 1;
|
||
TString16 num_riga (format("%6d", numero_riga));
|
||
cod_inl = cod_inl.mid(0,7);
|
||
nuovo = recprec;
|
||
cod << cod_inl << num_riga;
|
||
}
|
||
else if (mese != _fino_a_mese)
|
||
{
|
||
TString16 num_riga ( format("%6d", 0L) );
|
||
cod << codtab << num_riga;
|
||
}
|
||
else
|
||
{
|
||
TString16 cod_inl = recprec.get("CODTAB");
|
||
TString16 numero_riga = cod_inl.mid(7,6);
|
||
cod << codtab << numero_riga;
|
||
}
|
||
//long numini = _pagine_stampate + 1;
|
||
nuovo.put("CODTAB", cod);
|
||
nuovo.put("I0", (long)_annoes);
|
||
nuovo.put("I1", (long)_fino_a_mese); // su libro unico ho un solo mese in gioco!
|
||
nuovo.put("I2", (long)(_primast + 1)); // numero iniziale pagina libro unico
|
||
//nuovo.put("I3", (long)(_primast + ultimast)); // numero finale pagina libro unico
|
||
nuovo.put("I3", (long)(_u_stampata)); // numero finale pagina libro unico
|
||
nuovo.put("I4", get_firm());
|
||
nuovo.put("S0", _codreg);
|
||
nuovo.put("S1", _codice_vidi);
|
||
//nuovo.put("I5", (long)numini); //numero iniziale pagina registro utente
|
||
//nuovo.put("I6", (long)(numini + ultimast - 1)); //numero finale pagina registro utente
|
||
nuovo.put("I5", _numini + 1);
|
||
nuovo.put("I6", _pagine_stampate);
|
||
|
||
if (mese == _fino_a_mese)
|
||
TabInl.rewrite(nuovo);
|
||
else
|
||
TabInl.write(nuovo);
|
||
|
||
//_u_stampata += ultimast; //ultima pagina stampata sul libro unico
|
||
aggiorna_lib();
|
||
}
|
||
}
|
||
|
||
void CG4400_application::aggiorna_lib()
|
||
{
|
||
TString16 cod = "";
|
||
TTable lbu ("%LBU");
|
||
|
||
cod << _annoes << _codlib;
|
||
lbu.zero();
|
||
lbu.put("CODTAB", cod);
|
||
if (lbu.read() == NOERR)
|
||
{
|
||
lbu.put("I0", (long) _fino_a_mese);
|
||
lbu.put("I1", (long) _u_stampata);
|
||
lbu.rewrite();
|
||
}
|
||
}
|
||
|
||
bool CG4400_application::stampo_liquidazione(int mese)
|
||
{
|
||
if (_liquidazione)
|
||
if ( (_frequiva == 'T' && (mese == 3 || mese == 6 || mese == 9 || mese == 12))
|
||
|| _frequiva != 'T' || (mese == 12 && _tipo_riepilogativo == 'A') )
|
||
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 CG4400_application::stampa_vidi()
|
||
{
|
||
TTable TabInl ("%INL");
|
||
TTable TabVid ("VID");
|
||
TString16 codtab = "";
|
||
TString16 codreg;
|
||
TString16 vid;
|
||
long ditta;
|
||
int mese;
|
||
_ok_vidi = FALSE;
|
||
TPrintrow row;
|
||
|
||
printer().open();
|
||
|
||
codtab << _annoes << _codlib;
|
||
TabInl.zero();
|
||
TabInl.put("CODTAB", codtab);
|
||
|
||
TRectype rec (TabInl.curr());
|
||
TabInl.read (_isgteq);
|
||
for (; !TabInl.eof(); TabInl.next())
|
||
{
|
||
if (TabInl.curr() != rec) break;
|
||
ditta = TabInl.get_long("I4");
|
||
codreg = TabInl.get("S0");
|
||
if (ditta == get_firm() && codreg == _codreg)
|
||
{
|
||
if (!_ok_vidi)
|
||
{
|
||
++_u_stampata;
|
||
++_pagine_stampate;
|
||
_ok_vidi = TRUE;
|
||
}
|
||
mese = TabInl.get_int("I1");
|
||
row.reset();
|
||
row.put(format("%s", itom(mese)), 0);
|
||
row.put(format("%6ld", TabInl.get_long("I2")), 10);
|
||
row.put(format("%6ld", _u_stampata), 17);
|
||
row.put(format("%6ld", TabInl.get_long("I5")), 25);
|
||
row.put(format("%6ld", _pagine_stampate), 32);
|
||
vid = TabInl.get("S1");
|
||
TabVid.zero();
|
||
TabVid.put("CODTAB", vid);
|
||
if (TabVid.read() == NOERR)
|
||
{
|
||
row.put(format("%s", (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("%s", (const char*)TabVid.get("S1")), 106);
|
||
}
|
||
printer().print(row);
|
||
}
|
||
}
|
||
printer().close();
|
||
}
|
||
|
||
print_action CG4400_application::postprocess_page (int file, int counter)
|
||
{
|
||
if (file == LF_MOV)
|
||
{
|
||
if (counter) //dopo aver fatto un REPEAT_PAGE (cioe' dopo aver stampato le righe settate in set_page_tot_reg()), in pratica a rottura di mese o alla fine
|
||
{
|
||
//if (_tipo_stampa != 1) aggiorna_reg(); // => l'aggiornamento viene fatto o a rottura di mese o alla fine
|
||
|
||
reset_print();
|
||
if (_tipo_stampa != 1)
|
||
if (stampo_liquidazione(_datareg.month()))
|
||
{
|
||
_st_liq[_datareg.month()] = TRUE;
|
||
_intesta_liq = TRUE;
|
||
printer().formfeed();
|
||
TFilename t;
|
||
t.temp();
|
||
send_message('L',t, _datareg.month()); //stampa liquidazione
|
||
merge_export_file(t,FALSE,TRUE);
|
||
_intesta_liq = FALSE;
|
||
//if (_tipo_stampa != 1) aggiorna_reg();
|
||
}
|
||
}
|
||
if (!counter)
|
||
{
|
||
bool FINITO = FALSE;
|
||
TRecnotype pos = _cur->pos();
|
||
long items = _cur->items();
|
||
|
||
FINITO = (pos == items-1);
|
||
|
||
if ( FINITO )
|
||
{
|
||
if (_tipo_stampa == 2 || _tipo_stampa == 4)
|
||
calcola_progressivi();
|
||
set_page_tot_reg();
|
||
return REPEAT_PAGE;
|
||
}
|
||
else
|
||
{
|
||
TLocalisamfile& mov = _cur->file(LF_MOV);
|
||
_cur->save_status();
|
||
++(*_cur);
|
||
_dataregs = mov.get_date(MOV_DATAREG);
|
||
--(*_cur);
|
||
_cur->restore_status();
|
||
|
||
if (_dataregs.month() != _dataregp.month())
|
||
{
|
||
if (_tipo_stampa == 2 || _tipo_stampa == 4)
|
||
calcola_progressivi();
|
||
set_page_tot_reg();
|
||
return REPEAT_PAGE;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return NEXT_PAGE;
|
||
}
|
||
|
||
/*
|
||
print_action CG4400_application::postprocess_print(int file, int counter)
|
||
{
|
||
if (file == LF_MOV)
|
||
{
|
||
if (_stampa_tutti_i_registri)
|
||
//if (!_mov_empty )
|
||
{
|
||
if (_tipo_stampa == 3)
|
||
++ _u_stampata;
|
||
}
|
||
}
|
||
return NEXT_PAGE;
|
||
}
|
||
*/
|
||
|
||
bool CG4400_application::set_print(int n)
|
||
{
|
||
TMask m("cg4400a");
|
||
int giorni_del_mese;
|
||
bool ok;
|
||
|
||
m.set_handler (TIPO_STAMPA, mask_tipo_stampa);
|
||
m.set_handler (A_CODICE, mask_firm_to);
|
||
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 (DLG_SELECT, mask_select);
|
||
m.set_handler (F_ANNULLA, mask_azzera);
|
||
|
||
set_real_picture("###.###.###.###");
|
||
|
||
while (ok = set_ditte(m))
|
||
{
|
||
if (_selected.ones() > 0l)
|
||
{
|
||
_annoes = m.get_int(ANNO);//in realta' e' l'anno IVA !!!
|
||
_tipo_stampa = m.get_int(TIPO_STAMPA);
|
||
_intesta_vidi = FALSE;
|
||
_stampa_width = m.get_int(STAMPA_WIDTH);
|
||
_stampa_len = m.get_int(STAMPA_LEN);
|
||
if (_stampa_width == 1)
|
||
_stampa_width = 132;
|
||
else _stampa_width = 198;
|
||
if (_stampa_len != 0)
|
||
printer().formlen(_stampa_len);
|
||
else printer().formlen(66);
|
||
//Se stampa di prova l'utente indica data_da e data_a
|
||
if (_tipo_stampa == 1)
|
||
{
|
||
_data_stampa = m.get(DATA_STAMPA);
|
||
_data_da = m.get(DA_DATA);
|
||
_data_a = m.get(A_DATA);
|
||
if (!_data_da.ok())
|
||
_data_da = format("01/01/%4d", _annoes);
|
||
if (!_data_a.ok())
|
||
_data_a = format("31/12/%4d", _annoes);
|
||
TDate d(31,12,_annoes);
|
||
if (_data_a == d)
|
||
_tipo_riepilogativo = m.get(TIPO_RIEPILOGATIVO)[0];
|
||
else _tipo_riepilogativo = ' ';
|
||
printer().setdate(_data_stampa);
|
||
}
|
||
else //stampe definitive
|
||
{
|
||
if ( (_tipo_stampa == 2) || (_tipo_stampa == 4) )
|
||
{
|
||
_fino_a_mese = m.get_int(FINO_A_MESE);
|
||
_data_da = format("01/01/%4d", _annoes); //e non ultima data di stampa del registro (come invece verrebbe spontaneo di pensare)
|
||
}
|
||
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 = format("01/%02d/%04d", _fino_a_mese, _annoes);
|
||
//set_page_number(_u_stampata + 1);
|
||
}
|
||
if (_fino_a_mese == 12)
|
||
{
|
||
giorni_del_mese = 31;
|
||
_tipo_riepilogativo = m.get(TIPO_RIEPILOGATIVO)[0];
|
||
}
|
||
else
|
||
{
|
||
_tipo_riepilogativo = ' ';
|
||
TDate primo = format("01/%02d/%4d", _fino_a_mese+1, _annoes);
|
||
--primo;
|
||
giorni_del_mese = primo.day();
|
||
}
|
||
_data_a=format("%02d/%02d/%4d",giorni_del_mese,_fino_a_mese,_annoes);
|
||
}
|
||
_stampa_data_reg = stampa_datareg();
|
||
if (_tipo_stampa == 3)
|
||
compila_lib();
|
||
stampa_registri_IVA(m);
|
||
}
|
||
else
|
||
{
|
||
warning_box("Nessuna ditta selezionata!");
|
||
continue;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
bool CG4400_application::stampa_registri_IVA(const TMask& m)
|
||
{
|
||
long l;
|
||
__firm = TApplication::get_firm();
|
||
bool ok = FALSE;
|
||
|
||
for (l = 0l, _nditte->first(); !_nditte->eof(); l++, _nditte->next())
|
||
{
|
||
if (_selected[l])
|
||
{
|
||
bool msg = TRUE;
|
||
TApplication::set_firm(_nditte->get_long("CODDITTA"));
|
||
TString16 y; y << _annoes;
|
||
_tablia->zero();
|
||
_tablia->put("CODTAB", y);
|
||
if (_tablia->read() == NOERR)
|
||
{
|
||
_frequiva = _tablia->get("S7")[0];
|
||
_credito = _tablia->get_real("R0"); //credito iva anno precedente
|
||
}
|
||
else
|
||
{
|
||
warning_box("Ditta %ld: non esiste sulla tabella di liquidazione IVA annuale il record relativo all'anno %d", _nditte->get_long("CODDITTA"), _annoes);
|
||
continue; //passa alla ditta successiva, se selezionata
|
||
}
|
||
ok = compila_reg(m);
|
||
if (!ok) continue;
|
||
if (_tipo_stampa == 2 || _tipo_stampa == 4)
|
||
if (!controlla_mov())
|
||
{
|
||
TApplication::set_firm(__firm);
|
||
return fatal_box("Finire di stampare registri anno precedente");
|
||
}
|
||
if (!_stampa_tutti_i_registri)
|
||
_cur->set_filterfunction(filter_func);
|
||
//_frequiva = _nditte->get("FREQVIVA")[0];
|
||
if (!_stampa_tutti_i_registri)
|
||
{
|
||
if (_liquidazione)
|
||
{
|
||
ok = controlla_liquidazione();
|
||
if (!ok) continue;
|
||
}
|
||
for (int i=0; i < 12; i++)
|
||
_st_liq[i] = FALSE;
|
||
|
||
(*_cur) = 0L;
|
||
const long item = _cur->items();
|
||
if (item > 0) //cioe' se ci sono dei movimenti da stampare
|
||
{
|
||
if (_tipo_stampa == 2 || _tipo_stampa == 4)
|
||
{
|
||
TMask mb("cg4400b");
|
||
mb.set(COD_LIB, _codreg);
|
||
const char* m = "";
|
||
m = format("%02d", _stampa_mese);
|
||
mb.set(U_MESE, m);
|
||
mb.set(U_PAGINA, _pagine_stampate);
|
||
mb.set(U_DATA, _u_data.string());
|
||
KEY tasto = mb.run();
|
||
if (tasto != K_ENTER) continue;
|
||
}
|
||
if (_tipo_stampa != 1)
|
||
{
|
||
TFilename t;
|
||
t.temp();
|
||
send_message('C',t, _fino_a_mese);
|
||
}
|
||
print();
|
||
}
|
||
else
|
||
{
|
||
_mov_empty = TRUE;
|
||
int limite;
|
||
//stampo la liquidazione per tutti i mesi fino a _fino_a_mese (in caso di stampa = 2/3/4)
|
||
if (_tipo_stampa == 2 || _tipo_stampa == 4)
|
||
limite = _stampa_mese;
|
||
if (_tipo_stampa == 3)
|
||
limite = _fino_a_mese;
|
||
printer().open();
|
||
for (int m = limite; m > 0 && m <= _fino_a_mese; m++)
|
||
{
|
||
if (stampo_liquidazione(m))
|
||
{
|
||
_datareg = format("01/%02d/%4d", m, _annoes); //serve per la preprocess_header
|
||
_intesta_liq = TRUE;
|
||
TFilename t;
|
||
t.temp();
|
||
send_message('L',t, m);
|
||
if (m > 1) printer().formfeed();
|
||
merge_export_file(t,FALSE,TRUE);
|
||
_intesta_liq = FALSE;
|
||
}
|
||
}
|
||
printer().close();
|
||
}
|
||
if (_tipo_stampa == 3 && _rif_vid)
|
||
{
|
||
_intesta_vidi = TRUE;
|
||
stampa_vidi(); //stampa riferimenti vidimazione
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TString16 codtab, cod_lib_un;
|
||
int anno;
|
||
TDate sca_vid;
|
||
for (_tabreg->first(); !_tabreg->eof(); _tabreg->next())
|
||
{
|
||
_tipo_reg = _tabreg->get_int("I0");
|
||
codtab = _tabreg->get("CODTAB");
|
||
anno = atoi(codtab.mid(0,4));
|
||
if (anno > _annoes)
|
||
break;
|
||
if (anno == _annoes)
|
||
if ( _tipo_reg == 1 || _tipo_reg == 2 ) //registro iva
|
||
{
|
||
_codreg = codtab.mid(4,3);
|
||
cod_lib_un = _tabreg->get("S6");
|
||
sca_vid = _tabreg->get_date("D0");
|
||
if (_tipo_stampa != 1)
|
||
{
|
||
_u_data = _tabreg->get_date("D3");
|
||
if (!_u_data.ok()) //e' la prima volta che stampo
|
||
_u_data = format("01/01/%4d", _annoes);
|
||
}
|
||
if (_tipo_stampa == 2 || _tipo_stampa == 4)
|
||
{
|
||
if (_data_a < _u_data)
|
||
{
|
||
message_box("Ditta %ld: Il registro %s e' gia' stato stampato come bollato di %s", _nditte->get_long("CODDITTA"), (const char*) _codreg, itom(_fino_a_mese));
|
||
continue;
|
||
}
|
||
if (cod_lib_un.not_empty())
|
||
continue;
|
||
if (sca_vid.month() < _fino_a_mese)
|
||
continue;
|
||
}
|
||
if (_tipo_stampa == 4) //stampa con riferimenti al libro giornale
|
||
{
|
||
long codditta = _nditte->get_long("CODDITTA");
|
||
TString16 d;
|
||
TRecnotype rec = _tabreg->recno();
|
||
bool trovato = cerca_libro_gio(d);
|
||
_tabreg->readat(rec);
|
||
if (!trovato)
|
||
continue;
|
||
}
|
||
if (_tipo_stampa == 3) //stampa su libro unico
|
||
{
|
||
if (cod_lib_un != _codlib)
|
||
continue;
|
||
if (_fino_a_mese < _u_data.month())
|
||
continue;
|
||
if (sca_vid.month() < _fino_a_mese)
|
||
continue;
|
||
}
|
||
msg = FALSE;
|
||
_liquidazione = _tabreg->get_bool("B7");
|
||
|
||
if (_liquidazione) //per i registri "validi" eseguo il controllo liquidazione
|
||
{
|
||
ok = controlla_liquidazione();
|
||
if (!ok) continue;
|
||
}
|
||
_riep_liq = _tabreg->get_bool("B6");
|
||
_corrispettivi = _tabreg->get_bool("B0");
|
||
_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();
|
||
_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");
|
||
_cur->set_filterfunction(NULL);
|
||
_cur->set_filterfunction(filter_func);
|
||
|
||
for (int i=0; i < 12; i++)
|
||
_st_liq[i] = FALSE;
|
||
// Vado a vedere se ci sono movimenti
|
||
(*_cur) = 0L;
|
||
const long items = _cur->items();
|
||
if (items > 0)
|
||
{
|
||
if (_tipo_stampa == 2 || _tipo_stampa == 4)
|
||
{
|
||
TMask mb("cg4400b");
|
||
mb.set(COD_LIB, _codreg);
|
||
const char* m = "";
|
||
m = format("%02d", _stampa_mese);
|
||
mb.set(U_MESE, m);
|
||
mb.set(U_PAGINA, _pagine_stampate);
|
||
mb.set(U_DATA, _u_data.string());
|
||
KEY tasto = mb.run();
|
||
if (tasto != K_ENTER) continue;
|
||
}
|
||
if (_tipo_stampa != 1)
|
||
{
|
||
TFilename t;
|
||
t.temp();
|
||
send_message('C',t, _fino_a_mese);
|
||
}
|
||
print();
|
||
}
|
||
else
|
||
{
|
||
int limite;
|
||
_mov_empty = TRUE;
|
||
//stampo la liquidazione per tutti i mesi fino a _fino_a_mese (in caso di stampa = 2/3/4)
|
||
if (_tipo_stampa == 2 || _tipo_stampa == 4)
|
||
limite = _stampa_mese;
|
||
if (_tipo_stampa == 3)
|
||
limite = _fino_a_mese;
|
||
printer().open();
|
||
for (int m = limite; m > 0 && m <= _fino_a_mese; m++)
|
||
{
|
||
if (stampo_liquidazione(m))
|
||
{
|
||
_datareg = format("01/%02d/%4d", m, _annoes); //serve per la preprocess_header
|
||
_intesta_liq = TRUE;
|
||
TFilename t;
|
||
t.temp();
|
||
send_message('L',t, m);
|
||
if (m > 1) printer().formfeed();
|
||
merge_export_file(t,FALSE,TRUE);
|
||
_intesta_liq = FALSE;
|
||
}
|
||
}
|
||
printer().close();
|
||
//if (_tipo_stampa != 1) aggiorna_reg();
|
||
}
|
||
if (_tipo_stampa == 3 && _rif_vid)
|
||
{
|
||
_intesta_vidi = TRUE;
|
||
stampa_vidi(); //stampa riferimenti vidimazione
|
||
}
|
||
}
|
||
} //for
|
||
if (msg)
|
||
message_box("Ditta %ld: Nessun registro soddisfa i parametri indicati", _nditte->get_long("CODDITTA"));
|
||
}
|
||
//if (_tipo_stampa == 3)
|
||
// aggiorna_lib();
|
||
}
|
||
}
|
||
TApplication::set_firm(__firm);
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
void CG4400_application::send_message(char tipo, const TFilename& nome, int mese)
|
||
{
|
||
//const char* const app = "cg4a -2 -icon";
|
||
const char* const app = "cg4a -2";
|
||
TToken_string ss(10);
|
||
//int mese ;
|
||
|
||
/*
|
||
if (tipo == 'L')
|
||
{
|
||
if (_tipo_stampa == 3) //stampa su libro unico
|
||
mese = _fino_a_mese;
|
||
if (_tipo_stampa == 2 || _tipo_stampa == 4)
|
||
mese = _datareg.month();
|
||
}
|
||
else mese = _fino_a_mese;
|
||
*/
|
||
|
||
ss.add(_annoes);
|
||
ss.add(mese);
|
||
ss.add(_nditte->get_long("CODDITTA"));
|
||
ss.add(tipo);
|
||
|
||
//if (tipo == 'L')
|
||
//{
|
||
ss.add(_data_stampa.string());
|
||
ss.add(nome);
|
||
ss.add("x");
|
||
//}
|
||
|
||
TMessage liq ("cg4a -2", "RCL", ss);
|
||
liq.send();
|
||
|
||
TExternal_app pn(app);
|
||
pn.run();
|
||
}
|
||
|
||
bool CG4400_application::set_ditte(TMask& m)
|
||
{
|
||
_selected.reset();
|
||
|
||
m.field(F_SELECT).set("0");
|
||
m.field(DA_CODICE).set("");
|
||
m.field(A_CODICE).set("");
|
||
m.field(TIPO_STAMPA).set("1");
|
||
|
||
KEY tasto;
|
||
tasto = m.run();
|
||
// m.first_focus(tasto);
|
||
return tasto == K_ENTER;
|
||
}
|
||
|
||
TRectype& CG4400_application::look_comuni (const char * cod)
|
||
{
|
||
_com->zero();
|
||
_com->put(COM_COM, cod);
|
||
_com->read();
|
||
if (_com->bad())
|
||
_com->zero();
|
||
|
||
return _com->curr();
|
||
}
|
||
|
||
void CG4400_application::get_dati_ditta()
|
||
{
|
||
TLocalisamfile nditte(LF_NDITTE);
|
||
TLocalisamfile anag(LF_ANAG);
|
||
TLocalisamfile unloc(LF_UNLOC);
|
||
TString codanagr;
|
||
TString tipoa;
|
||
|
||
nditte.zero();
|
||
nditte.put(NDT_CODDITTA, get_firm());
|
||
nditte.read();
|
||
|
||
if (nditte.bad()) nditte.zero();
|
||
|
||
codanagr = nditte.get(NDT_CODANAGR);
|
||
tipoa = nditte.get(NDT_TIPOA);
|
||
_ragsoc = nditte.get(NDT_RAGSOC);
|
||
|
||
anag.setkey(1);
|
||
anag.zero();
|
||
anag.put (ANA_TIPOA, tipoa);
|
||
anag.put (ANA_CODANAGR, codanagr);
|
||
anag.read();
|
||
if (anag.bad()) anag.zero();
|
||
|
||
_cofi = anag.get(ANA_COFI);
|
||
_paiva = anag.get(ANA_PAIV);
|
||
_comunefis = anag.get(ANA_COMRF);
|
||
|
||
if (_comunefis.empty())
|
||
_comunefis = anag.get(ANA_COMRES);
|
||
|
||
TRectype dep = look_comuni (_comunefis);
|
||
|
||
_comunefis = dep.get(COM_DENCOM);
|
||
_provfis = dep.get(COM_PROVCOM);
|
||
_cap = dep.get(COM_CAPCOM);
|
||
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)
|
||
{
|
||
unloc.zero();
|
||
unloc.put(ULC_CODDITTA, get_firm());
|
||
unloc.put(ULC_CODULC, _cod_un_loc);
|
||
unloc.read();
|
||
if (unloc.read() == NOERR)
|
||
{
|
||
TRectype dep = look_comuni (unloc.get(ULC_COMULC));
|
||
_comunefis = dep.get(COM_DENCOM);
|
||
_provfis = dep.get(COM_PROVCOM);
|
||
_cap = dep.get(COM_CAPCOM);
|
||
_viafis = unloc.get(ULC_INDULC);
|
||
_viafis.rtrim();
|
||
_viafis << " " << unloc.get(ULC_CIVULC);
|
||
}
|
||
}
|
||
}
|
||
|
||
int CG4400_application::stampa_intestazione()
|
||
{
|
||
int r = 1;
|
||
TString codice_ditta;
|
||
TString riga(_stampa_width);
|
||
|
||
get_dati_ditta();
|
||
codice_ditta << get_firm();
|
||
|
||
set_header (r, "Ditta %s %s %s %s %s %s", (const char*)codice_ditta,
|
||
(const char*)_ragsoc, (const char*)_viafis,
|
||
(const char*)_cap, (const char*)_comunefis,
|
||
(const char*)_provfis);
|
||
r++;
|
||
//printer().setdate(_data);
|
||
if (_tipo_stampa == 1)
|
||
{
|
||
riga = "REGISTRO DI PROVA Data @<";
|
||
riga.right_just(_stampa_width-6);
|
||
}
|
||
riga.overwrite (format("Partita iva %s Codice fiscale %s", (const char*)_paiva, (const char*)_cofi));
|
||
set_header (r, riga);
|
||
|
||
return r;
|
||
}
|
||
|
||
void CG4400_application::preprocess_header()
|
||
{
|
||
int r=1;
|
||
char cor, nd1, nd2;
|
||
char tipo = ' ';
|
||
char type = ' ';
|
||
int mese, anno;
|
||
TString riga(_stampa_width);
|
||
TString data(30);
|
||
|
||
riga.fill('-');
|
||
|
||
if (_tipo_stampa != 3)
|
||
{
|
||
mese = _datareg.month();
|
||
anno = _datareg.year();
|
||
}
|
||
else
|
||
{
|
||
mese = _fino_a_mese;
|
||
anno = _annoes;
|
||
}
|
||
|
||
data.format("%s %s %d", "mese di", itom(mese), anno);
|
||
|
||
reset_header();
|
||
|
||
if (_tipo_stampa == 2 || _tipo_stampa == 4)
|
||
{
|
||
if (_stampa_ind_ditta)
|
||
r = stampa_intestazione();
|
||
}
|
||
else //se stampa di prova o su libro unico l'intestazione della ditta va sempre stampata
|
||
r = stampa_intestazione();
|
||
|
||
if (_tipo_stampa == 3 && !_intesta_vidi)
|
||
{
|
||
++_u_stampata;
|
||
++_pagine_stampate;
|
||
}
|
||
|
||
if (_tipo_stampa == 3)
|
||
//set_header(r, "@94gProgr.Studio %ld@114gProgr.Utente @#", _u_stampata);
|
||
set_header(r, "@94gProgr.Studio %ld@114gProgr.Utente %ld", _u_stampata, _pagine_stampate);
|
||
|
||
if (_tipo_stampa != 1) aggiorna_reg(); //cosi' sono sicura che l'aggiornamento viene fatto ad ogni salto pagina (cioe' a rottura di mese)
|
||
|
||
r++;
|
||
|
||
if (!_intesta_vidi)
|
||
set_header(r, "Registro IVA: %s %s %s Attivita\' %s %s",
|
||
(const char *) _codreg, (const char *) _desc_lib,
|
||
(const char *) data, (const char *) _codatt,
|
||
(const char *) _attivita);
|
||
else
|
||
{
|
||
set_header(r++, "Registro IVA: %s %s", (const char *) _codreg, (const char *) _desc_lib);
|
||
set_header(r, "RIFERIMENTI VIDIMAZIONE");
|
||
}
|
||
|
||
if (_intesta_liq)
|
||
{
|
||
r++;
|
||
set_header(r++, "CALCOLO LIQUIDAZIONE IVA");
|
||
set_header(r++,riga);
|
||
TString title (80);
|
||
title << "Liquidazione IVA del periodo: ";
|
||
title << format(" %s %d", itom(mese), anno);
|
||
set_header(r++, "%s@102g Frequenza %s", (const char*) title, _frequiva == 'T' ? "T" : "M");
|
||
set_header(r++,riga);
|
||
set_header(r,"");
|
||
}
|
||
else
|
||
{
|
||
r++;
|
||
set_header(r, riga);
|
||
r++;
|
||
if (_tipo_reg == 1) //registro vendite
|
||
{
|
||
cor = 'R';
|
||
nd1 = NULL;
|
||
nd2 = NULL;
|
||
}
|
||
if (_tipo_reg == 2)
|
||
{
|
||
cor = 'C';
|
||
nd1 = 'N';
|
||
nd2 = 'D';
|
||
}
|
||
if (_tipoatt == "E") //attivita' mista
|
||
{
|
||
tipo = 'A';
|
||
type = 'T';
|
||
}
|
||
if (_stampa_data_reg && _stampa_width == 132)
|
||
set_header(r,"Data I/P");
|
||
if (_tipo_stampa == 1) //stampa di prova (_intesta_vidi e' di sicuro FALSE)
|
||
{
|
||
if (_stampa_width == 132)
|
||
{
|
||
set_header(r,"@10gNum.@19gDocumento@68gT Tipo@76gIncassi/Pag.@103gCod %c@124gT %c@128gNum", nd1, tipo);
|
||
r++;
|
||
set_header(r, "Data reg. prot.@17gData@25gNumero Codice Ragione sociale/descrizione@68gO Doc.@76gTotale doc.@91gImponibile Iva %c@112gImposta@124g%c %c@128gReg", nd2, cor, type);
|
||
r++;
|
||
}
|
||
else //stampa a 198
|
||
{
|
||
set_header(r,"Registrazione Documento@68gT Tipo@80gTot.Inc./Pag.@110gCod %c@132g%c T@139gNum.", nd1, tipo, cor);
|
||
r++;
|
||
set_header(r, "Data Protocollo Data@25gNumero Codice Ragione sociale/descrizione@68gO Documento@80gTot.Documento@99gImponibile Iva %c@124gImposta@132g%c %c@139gReg.", nd2, type, cor);
|
||
r++;
|
||
}
|
||
}
|
||
else if (!_intesta_vidi)
|
||
{
|
||
if (_stampa_width == 132)
|
||
{
|
||
set_header(r,"@10gNum.@19gDocumento@68gT Tipo@76gIncassi/Pag.@103gCod %c@124gT %c", nd1, tipo);
|
||
if (_tipo_stampa == 4) //stampa definitiva con rif. al libro giornale
|
||
set_header(r, "@128gNum.");
|
||
r++;
|
||
set_header(r, "Data reg. prot.@17gData@25gNumero Codice Ragione sociale/descrizione@68gO Doc.@76gTotale doc.@91gImponibile Iva %c@112gImposta@124g%c %c",
|
||
nd2, cor, type);
|
||
if (_tipo_stampa == 4)
|
||
set_header(r, "@128gop.");
|
||
r++;
|
||
}
|
||
else //stampa a 198
|
||
{
|
||
set_header(r,"Registrazione Documento@68gT Tipo@80gTot.Inc./Pag.@110gCod %c@132g%c T", nd1, tipo);
|
||
if (_tipo_stampa == 4)
|
||
set_header(r, "@139gNum.");
|
||
r++;
|
||
set_header(r, "Data Protocollo Data@25gNumero Codice Ragione sociale/descrizione@68gO Documento@80gTot.Documento@99gImponibile Iva %c@124gImposta@132g%c %c", nd2, type, cor);
|
||
if (_tipo_stampa == 4)
|
||
set_header(r, "@139gop. @144gCodice conto @160gDescrizione sottoconto");
|
||
r++;
|
||
}
|
||
}
|
||
else if (_tipo_stampa == 3 && _intesta_vidi)
|
||
{
|
||
TString tr(52);
|
||
tr.fill('-');
|
||
set_header(r++,"@10gPagine studio Pagine utente ---------------- V I D I M A Z I O N E %s", (const char*)tr);
|
||
set_header(r++,"Mese@12gda@20ga@27gda@35ga Intestatario@71gN.fogli Pag.in. Pag.fin. Data Ufficio");
|
||
}
|
||
if (_stampa_ind_comp && !_intesta_vidi)
|
||
set_header(r++, "@39gGeneralita'");
|
||
|
||
set_header(r, riga);
|
||
}
|
||
}
|
||
|
||
int cg4400 (int argc, char * argv[])
|
||
{
|
||
CG4400_application a;
|
||
a.run(argc, argv, "Stampa registri IVA");
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|