#include #include #include #include #include #include #include #include #include #include #include #include "conto.h" #include "cglib03.h" #include #include #include #include #include #include #include #include #include // 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() { static bool st = 2; if (st == 2) { TConfig conf(CONFIG_DITTA); st = conf.get_bool("StTfFr"); } return st; } bool CG4400_application::stampa_datareg() { static bool sd = 2; if (sd == 2) { TConfig conf(CONFIG_STUDIO); sd = !conf.get_bool("NoDtRg"); } return sd; } 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; isave_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; iget_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 = ' '; giorni_del_mese = TDate::last_day(_fino_a_mese, _annoes); } _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; 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()) { 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"; 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 (app, "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; }