root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/src/cg/cg3100.cpp
AlexBonazzi 1ba75cc8f2 Patch level : 12.0 642 
Files correlati     : cg1.exe cg2.exe cg4.exe cg5.exe np0.exe
Commento            :

Aggiunto il conto utile IV direttiva ai parametri ditta (se non indicato vale 9 E 22) e gestito in stampa bilancio IV direttiva.

Impostato il valore della riga di saldaconto all importo se non indicato.

Contabilità separata letto correttamente dalla maschera il codice di contabilità separata.

Non stampava il riepigolo fatture per cassa  nella stampa definitiva.
2018-11-26 01:50:39 +01:00

2538 lines
75 KiB
C++
Executable File
Raw Blame History

//
//Lista movimenti
//
#include "cg3.h"
#include "cg3100.h"
#include "cglib01.h"
#include "cglib03.h"
#include <mask.h>
#include <modaut.h>
#include <printapp.h>
#include <recarray.h>
#include <attiv.h>
#include <causali.h>
#include <clifo.h>
#include <comuni.h>
#include <mov.h>
#include <nditte.h>
#include <pconti.h>
#include <rmov.h>
#include <rmoviva.h>
#include <saldi.h>
enum liste { movimenti=1, fatture=2, };
class TListaMov_application : public TPrintapp
{
static bool filter_func (const TRelation *);
static bool filter_func_fatture (const TRelation *);
static bool annoes_handler(TMask_field&, KEY);
static bool data_inizio (TMask_field&, KEY);
static bool data_fine (TMask_field&, KEY);
TRigaiva_array _c;
TRelation * _relmov1,* _relmov2,* _relmov3;
TCursor * _curr1, * _curr2, * _curr3;
TBit_array _err;
TDate _data_ini, _data_fin, _datareg, _data_prec, _datacomp;
TString _descr, _descr_doc, _descr_causale;
#ifdef CONT_SEP
TString _descr_cs;
TString _cont_sep;
#endif
TString _tipo_ini, _causale, _app;
TString4 _causale_ini, _causale_fin, _registro,_registro_ini, _registro_fin;
TString _tipoatt, _tipo_elenco,_tipo_clifo_prec,_tipoelsucc;
char _appoggio;
TString4 _tipodoc, _tipodocumento;
TString _ragsoc, _indcf, _civcf, _paiv, _codcaus, _dencom, _provcom, _cofi;
TString _capcf, _codval, _simbolo, _statocf, _comcf, _tipo_fin, _reg_causale;
long _documenti, _codice_ini, _codice_fin, _numero_reg, _codcf;
long _gen_documenti;
long _numreg, _numreg_fin, _numreg_ini, _codalleg, _numeroregp,_codclifosucc;
long _codcf_prec, _numr, _numero;
int _ae, _anno, _annoes, _annoeser;
bool _noseparator, _competence_only;
real _totdocumenti, _totdoc, _totimponibile, _totimposta, _importo;
real _totritenute, _ritenute, _gen_totritenute; // Aggiunte 11/02/2013
real _gen_totdocumenti, _gen_totimponibile, _gen_totimposta, _gen_op_esenti, _gen_op_non_imp;
real _op_esenti, _op_non_imp; //, _impo, _impos;
real _tot_dare, _tot_avere, _tot_avere_giornaliero;
real _tot_dare_giornaliero, _tot_dare_generale, _tot_avere_generale;
bool _no_preprocess_page, _salto_pagina, _stampa_anno_comp,_esiste_riga_iva,_nonesiste_riga_iva;
bool _stampa_parte_iva,_alleg_causale,_stampa_mess_alleg_iva,_allegb;
int _ricser;
bool _settata_prima_riga, _causale_gia_stampata,_mov_di_sola_iva;
int _cur1,_cur2,_cur2b,_cur3,_cur4,_decidi,/*_tipod,*/_controllo_mov_errati;
int _numero_riga, _alleg, _tiporegistro, _scelta_stampa, _nr, _n;
int _provvis;
liste _tipo_lista;
word _flags;
char _tipoc;
TString4 _dacodiva, _acodiva;
protected:
virtual void preprocess_header();
virtual bool preprocess_page(int,int);
virtual print_action postprocess_page(int,int);
virtual print_action postprocess_print(int,int);
virtual void set_page(int,int);
virtual bool set_print(int m);
void init_print(const TMask& m);
void print_intra(int& rr);
void filtra_cursore_provvisori(TCursor* cur) const;
void imposta_parametri_stampa(const TMask& msk);
bool codiva_filter(const TRelation* rel) const;
bool rmoviva_filter(const TRectype& rmoviva) const;
#ifdef CONT_SEP
virtual const char * extra_modules() const { return "CG"; }
#endif
public:
bool user_create();
bool user_destroy();
bool segnala_errori_primariga();
bool segnala_errori_ogniriga();
bool segnala_errori_iva();
bool contropartita(int, int, long, char);
void stampa_errori_rmov();
void stampa_errori_mov();
void stampa_errori_iva(int* r, const TRigaiva& riva);
void stampa_errori_contropartita(int, int, long, char);
void stampa_intestazione();
void incrementa_totali();
void compila_clifo();
void compila_comuni();
const char * get_error(int error) const;
bool RicercaDoc(const char* cod) const;
const TString& SimboloValuta (const char* cod) const;
const TString& DescrDoc(const char* cod) const;
const TString& AttivitaRegistro(const char * cod, int anno) const;
TListaMov_application(char tipost);
virtual ~TListaMov_application() {}
};
HIDDEN inline TListaMov_application& app()
{ return (TListaMov_application&)main_app();}
bool TListaMov_application::annoes_handler(TMask_field& f, KEY k)
{
if (k == K_TAB && f.focusdirty() && !f.empty())
{
const int anno = atoi(f.get());
TDate dataini, datafin;
TEsercizi_contabili esc;
if (esc.code2range(anno, dataini, datafin))
{
f.mask().set(F_DATAINI, dataini);
const int prossimo = esc.next(anno);
if (prossimo > 0)
datafin = esc[prossimo].fine();
f.mask().set(F_DATAFIN, datafin);
}
}
return true;
}
bool TListaMov_application::data_inizio(TMask_field& f, KEY k)
{
if (k == K_ENTER)
{
int decidi;
int anno = f.mask().get_int (F_ANNO);
TDate data = f.mask().get_date(F_DATAINI);
if (app()._tipo_lista == movimenti)
decidi = f.mask().get_int (F_DECIDI);
TEsercizi_contabili esc;
if (esc.exist(anno) && ( (app()._tipo_lista == fatture) ||
((app()._tipo_lista == movimenti ) && (decidi == 2)) ) )
{
const TDate inizio = esc[anno].inizio();
if (data.ok())
{
if (data < inizio)
{
f.error_box(TR("La data indicata non deve essere inferiore alla data di inizio esercizio"));
return FALSE;
}
}
else //se la data e' vuota
f.mask().field(F_DATAINI).set(inizio);
}
}
return TRUE;
}
bool TListaMov_application::data_fine(TMask_field& f, KEY k)
{
if (k == K_ENTER)
{
int decidi = 0;
int anno = f.mask().get_int (F_ANNO);
TDate dataini = f.mask().get_date(F_DATAINI);
TDate datafin = f.mask().get_date(F_DATAFIN);
if (app()._tipo_lista == movimenti)
decidi = f.mask().get_int (F_DECIDI);
if ( (app()._tipo_lista == fatture) ||
((app()._tipo_lista == movimenti) && (decidi == 2)) )
if ( dataini.ok() && datafin.ok() )
if (dataini > datafin)
{
f.error_box(TR("La data iniziale non deve essere superiore alla data finale"));
return FALSE;
}
TEsercizi_contabili esc;
if (esc.exist(anno) && ( (app()._tipo_lista == fatture) || ((app()._tipo_lista == movimenti) && (decidi == 2)) ) )
{
const int prossimo = esc.next(anno);
const TDate fine = esc[prossimo > 0 ? prossimo : anno].fine();
if (datafin.ok())
{
if (datafin > fine)
{
f.error_box(TR("La data indicata non deve essere superiore alla data di fine esercizio successivo, oppure, in caso questo non esista, dell'esercizio indicato"));
return FALSE;
}
}
else //se la data e' vuota
f.mask().set(F_DATAFIN, fine);
}
}
return TRUE;
}
bool TListaMov_application::RicercaDoc(const char* tipo) const
{
const TRectype& tab_tpd = cache().get(TAB_TPD, tipo);
return !tab_tpd.empty();
}
void TListaMov_application::compila_clifo()
{
TToken_string key;
key.add(_tipo_elenco);
key.add(_codcf);
const TRectype& clifo = cache().get(LF_CLIFO, key);
char tipoa = clifo.get_char(CLI_TIPOAPER);
_alleg = clifo.get_int(CLI_ALLEG);
_statocf = clifo.get(CLI_STATOCF);
_comcf = clifo.get(CLI_COMCF);
_ragsoc = clifo.get(CLI_RAGSOC);
if (tipoa == 'F')
{
TString80 cognome, nome;
cognome = _ragsoc.mid(0, 30); cognome.trim();
nome = _ragsoc.mid(30,20); nome.trim();
_ragsoc = cognome;
_ragsoc << ' ' << nome;
}
_indcf = clifo.get(CLI_INDCF);
_civcf = clifo.get(CLI_CIVCF);
_paiv = clifo.get(CLI_PAIV);
_capcf = clifo.get(CLI_CAPCF);
_dencom = clifo.get(CLI_LOCCF);
_cofi = clifo.get(CLI_COFI);
_codalleg = clifo.get_long(CLI_CODALLEG);
}
void TListaMov_application::compila_comuni()
{
TToken_string key;
key.add(_statocf);
key.add(_comcf);
const TRectype & comuni = cache().get(LF_COMUNI, key);
//modifica del 26/04/1995
_dencom = comuni.get(COM_DENCOM);
if (!_dencom.empty())
_app = "Com";
else _app = "Loc";
//fine modifica
_provcom = comuni.get(COM_PROVCOM);
}
const char * TListaMov_application::get_error(int err) const
{
switch (err)
{
case 0:
return TR("La data operazione non appartiene a nessun esercizio");
break;
case 1:
return TR("Anno IVA non compatibile con data operazione");
break;
case 2:
return TR("Data operazione successiva all'esercizio di competenza");
break;
case 3:
return TR("Movimento con competenza anno precedente");
break;
case 4:
return TR("La data di competenza non appartiene a nessun esercizio");
break;
case 5:
return TR("Data competenza incompatibile con data operazione");
break;
case 6:
return TR("Esercizio incompatibile con data competenza");
break;
case 7:
return TR("Codice causale non presente in tabella");
break;
case 8:
return TR("Codice causale sospeso");
break;
case 9:
return TR("Nella causale e' stato attivato il segnale non va in allegato");
break;
case 10:
return TR("Tipo documento non corrisponde a quello indicato in causale");
break;
case 11:
return TR("Tipo documento non presente in tabella");
break;
case 12:
return TR("Codice registro non corrisponde a quello indicato in causale");
break;
case 13:
return TR("Codice registro non presente in tabella");
break;
case 14:
return TR("Codice registro sospeso");
break;
case 15:
return TR("Tipo registro incompatibile con tipo documento");
break;
case 16:
return TR("Non indicato codice cliente/fornitore");
break;
case 17:
return TR("Tipo cliente/fornitore non compatibile con tipo registro");
break;
case 18:
return TR("Codice cliente/fornitore sospeso");
break;
case 19:
return TR("Nel cliente/fornitore e' stato attivato il segnale: non va in allegato");
break;
case 20:
return TR("Indicato codice C/F per allegato che richiama se stesso");
break;
case 21:
return TR("Indicato codice C/F per allegato sospeso");
break;
case 22:
return TR("C/F per allegato riporta un altro C/F per allegato");
break;
case 23:
return TR("Indicato codice C/F per allegato con segnale: non va in allegato");
break;
case 24:
return TR("Indicato codice C/F per allegato non presente in anagrafica");
break;
case 25:
return TR("Codice cliente/fornitore non presente in anagrafica");
break;
case 26:
return TR("Movimento con data competenza diversa da data operazione");
break;
default:
return "";
break;
}
}
const int AllegClifo (int gruppo, int conto, long sottoconto)
{
int alleg = 0;
TLocalisamfile clifo(LF_CLIFO);
clifo.setkey(3);
clifo.zero();
clifo.put(CLI_GRUPPO, gruppo);
clifo.put(CLI_CONTO, conto);
clifo.put(CLI_CODCF, sottoconto);
if (clifo.read() == NOERR)
alleg = clifo.get_int(CLI_ALLEG);
return alleg;
}
const char* DescrConto (int gruppo, int conto, long sottoconto, char tipocf)
{
TString& tmp = get_tmp_string(50);
/*
TString16 key;
key << gruppo;
if (conto != 0)
key << '|' << conto;
if (sottoconto != 0)
key << '|' << sottoconto;
tmp = cache().get(LF_PCON, key, PCN_DESCR);
if (tmp.empty())
{
key.format("%c|%ld", tipocf , sottoconto);
const TRectype & clifo = cache().get(LF_CLIFO, key);
if (!clifo.empty())
{
char tipoa = clifo.get_char("TIPOAPER");
if (tipoa == 'F') //persona fisica
{
const TString& ragsoc = clifo.get("RAGSOC");
tmp = ragsoc.mid(0,30);
tmp.trim();
tmp << ' ' << ragsoc.mid(30);
}
else
tmp = clifo.get("RAGSOC");
}
}
*/
const TBill bill(gruppo, conto, sottoconto, tipocf);
tmp = bill.descrizione();
return tmp;
}
bool CausAlleg (const char * cod)
{
const TRectype& caus = cache().get(LF_CAUSALI, cod);
const bool allegb = caus.get_bool(CAU_ALLEG);
return allegb;
}
const char* TipoAttivita (const char* attreg, long codice_ditta)
{
TString16 key; key.format("%ld|%s", codice_ditta, attreg);
return cache().get(LF_ATTIV, key, ATT_TIPOATT);
}
const TString& TListaMov_application::SimboloValuta(const char* cod) const
{ return cache().get(TAB_VAL, cod, "S7"); }
const TString& TListaMov_application::DescrDoc(const char* tipo) const
{ return cache().get(TAB_TPD, tipo, "S0"); }
const TString& TListaMov_application::AttivitaRegistro(const char* cod, int anno) const
{
TString8 key; key.format("%04d%-3s", anno, cod);
return cache().get("REG", key, "S8");
}
HIDDEN int tipo_registro(const char* cod, int anno)
{
TString8 codtab; codtab.format("%4d%-3s", anno, cod);
const TString& tipo_reg = cache().get("REG", codtab, "I0");
return atoi(tipo_reg);
}
static bool between(const TString& code, const TString& mini, const TString& maxi)
{
if (mini.full() && code < mini)
return false;
if (maxi.full() && code > maxi)
return false;
return true;
}
static bool between(const TDate& code, const TDate& mini, const TDate& maxi)
{
if (mini.ok() && code < mini)
return false;
if (maxi.ok() && code > maxi)
return false;
return true;
}
static bool between(long code, long mini, long maxi)
{
if (mini > 0 && code < mini)
return false;
if (maxi > 0 && code > maxi)
return false;
return true;
}
bool TListaMov_application::rmoviva_filter(const TRectype& rmoviva) const
{
const TString& codiva = rmoviva.get(RMI_CODIVA);
return between(codiva, _dacodiva, _acodiva);
}
bool TListaMov_application::codiva_filter(const TRelation* rel) const
{
bool ok = _dacodiva.empty() && _acodiva.empty(); // Test su range codici iva
if (!ok)
{
const TRectype& mov = rel->curr(LF_MOV);
TRectype rmoviva(LF_RMOVIVA);
rmoviva.put(RMI_NUMREG, mov.get(MOV_NUMREG));
TRecord_array righe(rmoviva, RMI_NUMRIG);
for (int i = 1; !ok && i <= righe.rows(); i++)
ok = rmoviva_filter(righe[i]);
}
return ok;
}
bool TListaMov_application::filter_func_fatture (const TRelation* rel)
{
const TRectype& mov = rel->curr(LF_MOV);
#ifdef CONT_SEP
if (app()._cont_sep.full() && (app()._cont_sep != mov.get(MOV_CONTSEP)))
return false;
#endif
// Altrimenti stampa anche i corrispettivi! Pseudo errore MI2396
const long codcf = mov.get_long(MOV_CODCF);
if (codcf <= 0)
return FALSE;
const TString& causale = mov.get(MOV_CODCAUS);
if (!between(causale, app()._causale_ini, app()._causale_fin))
return false;
const int ann_reg = mov.get_int(MOV_ANNOIVA);
const TString4 cod_reg = mov.get(MOV_REG);
const int tipo_reg = tipo_registro(cod_reg, ann_reg);
// Considera solo iva acquisti o vendite
if (tipo_reg != 1 && tipo_reg != 2)
return FALSE;
if (app()._annoes > 0) //anno esercizio specificato nella maschera
{
const int annoes = mov.get_int(MOV_ANNOES);
if (annoes != app()._annoes)
return false;
}
if (!between(mov.get_date(MOV_DATAREG), app()._data_ini, app()._data_fin))
return false;
if (!between(mov.get(MOV_TIPO), app()._tipo_ini, app()._tipo_fin))
return false;
if (!between(mov.get_long(MOV_CODCF), app()._codice_ini, app()._codice_fin))
return false;
return app().codiva_filter(rel);
}
bool TListaMov_application::filter_func (const TRelation * rel)
{
const TRectype& mov = rel->curr(LF_MOV);
if ( (app()._decidi == 2) && (app()._annoes != 0) )
{
const int annoes = mov.get_int(MOV_ANNOES);
if (annoes != app()._annoes)
return false;
}
#ifdef CONT_SEP
if (app()._cont_sep.full() && (app()._cont_sep != mov.get(MOV_CONTSEP)))
return false;
#endif
const TString& causale = mov.get(MOV_CODCAUS);
if (!between(causale, app()._causale_ini, app()._causale_fin))
return false;
if (app()._scelta_stampa == 0) // Lista movimenti
{
const TString& codreg = mov.get(MOV_REG);
if (!between(codreg, app()._registro_ini, app()._registro_fin))
return false;
}
else // Lista movimenti sola prima nota
{
const TString& cod_reg = mov.get(MOV_REG);
const int ann_reg = mov.get_int(MOV_ANNOIVA);
const int tipo_reg = tipo_registro(cod_reg, ann_reg);
if (tipo_reg == 1 || tipo_reg == 2)
return false;
}
if (app()._competence_only && app()._annoes == 0)
{
const TDate datareg = mov.get_date(MOV_DATAREG);
const int annoes = mov.get_int(MOV_ANNOES);
TEsercizi_contabili esc;
// La data di registrazione appartiene allo stesso esercizio della data di competenza
if (esc.date2esc(datareg) == annoes)
return false;
}
return true;
}
void TListaMov_application::stampa_errori_rmov()
{
const TRectype& rec = current_cursor()->curr(LF_RMOV);
int gruppo = rec.get_int(RMV_GRUPPO);
int conto = rec.get_int(RMV_CONTO);
long sottoconto = rec.get_long(RMV_SOTTOCONTO);
int anno = rec.get_int(RMV_ANNOES);
TDate datareg = rec.get_date(RMV_DATAREG);
char sez = rec.get_char(RMV_SEZIONE);
char tipo = rec.get_char(RMV_TIPOC);
int gruppoc = rec.get_int(RMV_GRUPPOC);
int contoc = rec.get_int(RMV_CONTOC);
long sottocontoc = rec.get_long(RMV_SOTTOCONTOC);
char tipoc = rec.get_char(RMV_TIPOCC);
bool g = FALSE;
TBill tc (gruppo,conto,sottoconto);
_nr++;
if (anno != _annoeser || datareg != _datareg)
set_row(_nr++, FR("@11gUno o piu' campi non sono costanti nella riga dell' operazione"));
if (sez != 'D' && sez != 'A')
set_row(_nr++, FR("@11gIndicato tipo movimento Dare/Avere errato"));
if (tc.empty())
set_row(_nr++, FR("@11gNon presente codice gruppo/conto/sottoconto"));
if (!tc.ok())
set_row(_nr++, FR("@11gCodice gruppo/conto/sottoconto non corrisponde ad un sottoconto"));
TRectype pc (LF_PCON);
tc.set(gruppo,0,0l);
if (!tc.read(pc))
g = TRUE;
tc.set(gruppo,conto,0l);
if (!tc.read(pc))
set_row(_nr++, FR("@11gCodice gruppo/conto/sottoconto non presente in Piano dei Conti"));
else
{
const char t = pc.get_char(PCN_TMCF);
if (t != tipo)
set_row(_nr++, FR("@11gIl tipo C/F indicato non corrisponde a quello presente su Piano dei Conti"));
else
{
tc.set(gruppo,conto,sottoconto);
if (t != 'C' && t != 'F')
{
if (!tc.read(pc) || g )
set_row(_nr++, FR("@11gCodice gruppo/conto/sottoconto non presente in Piano dei Conti"));
else
{
bool sosp = tc.sospeso();
if (sosp)
set_row(_nr++, FR("@11gCodice gruppo/conto/sottoconto sospeso in Piano dei Conti"));
}
}
else
{
TToken_string key;
key.add(t);
key.add(sottoconto);
const TRectype & clifo = cache().get(LF_CLIFO, key);
if (!clifo.empty())
{
bool sosp = clifo.get_bool(CLI_SOSPESO);
if (sosp)
set_row(_nr++, FR("@11gCodice C/F sospeso in Anagrafica"));
}
else set_row(_nr++, FR("@11gCodice C/F non presente in Anagrafica"));
if (_registro.not_empty()) //se su mov e' indicato il codice registro
{
TRegistro rg (_registro, _ae);
const int tiporeg = rg.tipo();
if ((tiporeg == 1 && t != 'C') || (tiporeg == 2 && t != 'F'))
set_row(_nr++, FR("@11gTipo C/F non compatibile con tipo registro"));
}
}
}
}
TString key(30);
key.format("%d||%d|%d|%ld", anno, gruppo, conto, sottoconto);
const TRectype & saldi = cache().get(LF_SALDI, key);
if (saldi.empty())
set_row(_nr++, FR("@11gCodice gruppo/conto/sottoconto non presente in Saldi p.d.c."));
if (gruppoc != 0 || contoc != 0 || sottocontoc != 0l)
stampa_errori_contropartita(gruppoc, contoc, sottocontoc, tipoc);
}
void TListaMov_application::stampa_errori_contropartita(int gruppo, int conto, long sottoconto, char t)
{
bool g = FALSE;
TBill tc;
TRectype pc (LF_PCON);
tc.set(gruppo,0,0l);
if (!tc.read(pc))
g = TRUE;
tc.set(gruppo,conto,0l);
if (!tc.read(pc))
set_row(_nr++, FR("@11gCodice gruppo/conto/sottoconto di contropartita non presente in Piano dei Conti"));
else
{
//t = pc.get_char(PCN_TMCF);
tc.set(gruppo,conto,sottoconto);
if (t != 'C' && t != 'F')
{
if (!tc.read(pc) || g )
set_row(_nr++, FR("@11gCodice gruppo/conto/sottoconto di contropartita non presente in Piano dei Conti"));
else
{
bool sosp = tc.sospeso();
if (sosp)
set_row(_nr++, FR("@11gCodice gruppo/conto/sottoconto di contropartita sospeso in Piano dei Conti"));
}
}
else if (sottoconto != 0l)
{
TToken_string key;
key.add(t);
key.add(sottoconto);
const TRectype & clifo = cache().get(LF_CLIFO, key);
if (!clifo.empty())
{
bool sosp = clifo.get_bool(CLI_SOSPESO);
if (sosp)
set_row(_nr++, FR("@11gCodice C/F di contropartita sospeso in Anagrafica"));
}
else set_row(_nr++, FR("@11gCodice C/F di contropartita non presente in Anagrafica"));
}
}
}
void TListaMov_application::stampa_errori_iva(int* nr, const TRigaiva& riva)
{
const TRectype& tab_iva = cache().get("%IVA", riva._codiva);
if (!tab_iva.empty())
{
const bool sosp = tab_iva.get_bool("B2");
if (sosp)
set_row(++(*nr), FR("@11gCodice IVA sospeso"));
if (_stampa_mess_alleg_iva)
{
const int allc = tab_iva.get_int("S7");
const int allf = tab_iva.get_int("S8");
if (allc == 0 || allf == 0)
set_row(++(*nr), FR("@11gSul Codice IVA non e' stato indicato un valore per allegato"));
}
}
else
set_row(++(*nr), FR("@11gCodice IVA non presente in tabella"));
const int tipodet = riva._tipodet;
const int tipocr = riva._tipocr;
if (tipodet == 1 || tipodet == 3 || tipodet == 5 || tipodet == 9)
if (_tiporegistro != 2)
set_row(++(*nr), FR("@11gCodice di indetraibilita' errato"));
if (_tiporegistro == 1)
if (tipocr != 0 && tipocr != 1 && tipocr != 4 && tipocr != 9)
set_row(++(*nr), FR("@11gTipo costo/ricavo non valido"));
if (_tiporegistro == 2)
if (tipocr != 0 && tipocr != 1 && tipocr != 2 && tipocr != 3 && tipocr != 5 && tipocr != 8 && tipocr != 9)
set_row(++(*nr), FR("@11gTipo costo/ricavo non valido"));
}
void TListaMov_application::stampa_errori_mov()
{
long i = _err.first_one();
if (i != -1)
{
for (; i <= _err.last_one(); i++)
if (_err[i])
set_row(++_n, "@11g%s", (const char*) get_error(i));
}
}
void TListaMov_application::set_page(int file, int count)
{
switch (_tipo_lista)
{
case movimenti:
if (file == LF_RMOVIVA)
break;
if (file == LF_RMOV)
{
_nr = 1;
const TRectype& rec = current_cursor()->curr(LF_RMOV);
set_row(_nr,"@3n",FLD(LF_RMOV,RMV_NUMRIG));
set_row(_nr,"@30g@22s",FLD(LF_RMOV,RMV_DESCR));
set_row(_nr,"@54g@3,rn",FLD(LF_RMOV,RMV_GRUPPO));
set_row(_nr,"@58g@3,rn",FLD(LF_RMOV,RMV_CONTO));
set_row(_nr,"@62g@6,rn",FLD(LF_RMOV,RMV_SOTTOCONTO));
set_row(_nr,"@69g#.20t",&_descr);
_appoggio = toupper(current_cursor()->curr(LF_RMOV).get_char(RMV_SEZIONE));
if (_appoggio=='D')
set_row(_nr,"@90g@n",FLD(LF_RMOV,RMV_IMPORTO));
else
set_row(_nr,"@110g@n",FLD(LF_RMOV,RMV_IMPORTO));
}
else if (file == LF_MOV)
{
_n = 1;
set_row (_n++,"");
set_row (_n, FR("Operazione n. @14g@7n"), FLD(LF_MOV,MOV_NUMREG));
set_row (_n, FR("@22gdel@26g@d"),FLD(LF_MOV,MOV_DATAREG));
set_row (_n, "@37g@36s",FLD(LF_MOV,MOV_DESCR));
set_row (_n, FR("@75gdoc. @7s"),FLD(LF_MOV,MOV_NUMDOC));
set_row (_n, FR("@88gdel@92g@d"), FLD(LF_MOV,MOV_DATADOC));
#ifdef CONT_SEP
set_row (++_n, "@37g#-36t", &_descr_cs);
#endif
current_cursor()->curr(LF_MOV).get_int(MOV_ANNOES); // qui verificare
TDate data = current_cursor()->curr(LF_MOV).get_date(MOV_DATAREG);
TDate dcomp = current_cursor()->curr(LF_MOV).get_date(MOV_DATACOMP);
TString16 reg = current_cursor()->curr(LF_MOV).get(MOV_REG);
int anno = current_cursor()->curr(LF_MOV).get_int(MOV_ANNOIVA);
char prov = current_cursor()->curr(LF_MOV).get_char(MOV_PROVVIS);
int tipo = tipo_registro(reg, anno);
TEsercizi_contabili esc;
esc.date2esc(data); // qui verificare
if ( (tipo == 1) || (tipo == 2) )
{
set_row (_n, FR("@103greg @3s"),FLD(LF_MOV,MOV_REG));
set_row (_n, FR("@111gpr @5n"),FLD(LF_MOV,MOV_PROTIVA));
}
else if (_provvis == 2 && prov >= ' ')
set_row (_n, FR("@103gMov.Provvisorio"));
if (data != dcomp)
set_row (_n, "@119gc.%s", (const char*)dcomp.string(brief, '-'));
//fine
set_row (_n, "@130g@f", FLD(LF_MOV,MOV_STAMPATO));
}
break;
default:
break;
}
}
void TListaMov_application::stampa_intestazione()
{
set_row (1,"");
if (_tipo_elenco == "C")
set_row (2, FR("@bCliente@8g@6n"), FLD(LF_MOV,MOV_CODCF));
else
set_row (2, FR("@bFornitore@10g@6n"), FLD(LF_MOV,MOV_CODCF));
set_row (2, "@b@18g#.35t", &_ragsoc);
set_row (2, FR("@b@54gInd #-.29t #-.10t"), &_indcf, &_civcf);
set_row (2, FR("@b@98gP.I. #11t"), &_paiv);
if (_alleg == 0)
set_row (2, FR("@b@121gAllegato SI"));
else
set_row (2, FR("@b@121gAllegato NO"));
set_row (3, FR("@b@54gCap #5t"), &_capcf);
set_row (3,"@b@64g%s #-.20t Pr #-.5t",
(const char*)_app, &_dencom, &_provcom);
set_row (3, FR("@b@98gC.F. #-16t"), &_cofi);
if (_alleg == 0)
set_row (3, FR("@b@120gRifer@126g#6d"), &_codalleg);
}
bool TListaMov_application::preprocess_page(int file,int counter)
{
if (counter)
return TRUE;
TCursor* cur = current_cursor();
switch (_tipo_lista)
{
case movimenti:
if (_scelta_stampa == 0)
{
if (file == LF_MOV)
{
const TRectype& curmov = cur->curr(LF_MOV);
_tot_avere = 0;
_tot_dare = 0;
_c.destroy();
_no_preprocess_page = FALSE;
_esiste_riga_iva = FALSE;
_nonesiste_riga_iva = FALSE;
_annoeser = curmov.get_int(MOV_ANNOES);
_datacomp = curmov.get_date(MOV_DATACOMP);
_causale = curmov.get(MOV_CODCAUS);
_registro = curmov.get(MOV_REG);
_anno = curmov.get_int(MOV_ANNOIVA);
_tipodoc = curmov.get(MOV_TIPODOC);
_datareg = curmov.get_date(MOV_DATAREG);
_tipo_elenco = curmov.get(MOV_TIPO);
_codcf = curmov.get_long(MOV_CODCF);
_numero = curmov.get_long(MOV_NUMREG);
_codval = curmov.get(MOV_CODVALI);
_tiporegistro = tipo_registro(_registro, _anno);
_causale_gia_stampata = FALSE;
TEsercizi_contabili esc;
_ae = esc.date2esc(_datareg);
if (_registro.not_empty()) //si tratta di fattura
_mov_di_sola_iva = !cur->is_first_match(LF_RMOV);
_descr_doc = DescrDoc(_tipodoc);
#ifdef CONT_SEP
_descr_cs = cache().get("&NPENT", curmov.get(MOV_CONTSEP), "S0");
#endif
TRectype da (LF_MOV);
TRectype a (LF_MOV);
if (_annoes != 0)
{
da.put(MOV_ANNOES, _annoes);
a.put(MOV_ANNOES, _annoes);
}
da.put(MOV_CODCAUS, _causale_ini);
da.put(MOV_REG, _registro_ini);
a.put(MOV_CODCAUS, _causale_fin);
a.put(MOV_REG, _registro_fin);
if ((curmov >= da) && (curmov <= a))
{
const TRectype& caus = cache().get(LF_CAUSALI, _causale);
_reg_causale = caus.get(CAU_REG);
_descr_causale = caus.get(CAU_DESCR);
_alleg_causale = caus.get_bool(CAU_ALLEG);
_tipodocumento = caus.get(CAU_TIPODOC);
if (_controllo_mov_errati == 1 || _controllo_mov_errati == 2)
{
bool controlla = segnala_errori_primariga();
bool verifica = (_stampa_parte_iva && segnala_errori_iva()) || segnala_errori_ogniriga();
if ((_controllo_mov_errati == 1 && controlla)
|| _controllo_mov_errati == 2 )
{
stampa_errori_mov();
return TRUE;
}
else if (_controllo_mov_errati == 1 && !verifica)
return FALSE;
else return TRUE;
}
else return TRUE;
}
}
else if (file == LF_RMOV)
{
if (!_causale_gia_stampata)
{
set_row(_nr,"@4g%3s", (const char*) _causale);
set_row(_nr,"@8g%-.20s", (const char*) _descr_causale);
_causale_gia_stampata = true;
}
const TRectype& currig = cur->curr(LF_RMOV);
const int gruppo = currig.get_int(RMV_GRUPPO);
const int conto = currig.get_int(RMV_CONTO);
const long sottoconto = currig.get_long(RMV_SOTTOCONTO);
const char tipoc = currig.get_char(RMV_TIPOC);
_descr = DescrConto(gruppo, conto, sottoconto, tipoc);
_alleg = AllegClifo(gruppo, conto, sottoconto);
_importo = currig.get_real(RMV_IMPORTO);
_appoggio = currig.get_char(RMV_SEZIONE);
if (!_no_preprocess_page)
{
if (_appoggio=='D')
{
_tot_dare_generale += _importo;
_tot_dare += _importo;
}
else
{
_tot_avere += _importo;
_tot_avere_generale += _importo;
}
if (_controllo_mov_errati != 3)
stampa_errori_rmov();
}
return TRUE;
}
else if ( _stampa_parte_iva && file == LF_RMOVIVA)
{
const TRectype& iva = cur->curr(LF_RMOVIVA);
_c.add_riga(iva);
return TRUE;
}
}
else //_scelta_stampa == 1
{
if (file == LF_MOV)
{
_tot_avere = 0;
_tot_dare = 0;
_no_preprocess_page = FALSE;
const TRectype& curmov = cur->curr(LF_MOV);
_causale = curmov.get(MOV_CODCAUS);
_registro = curmov.get(MOV_REG);
_anno = curmov.get_int(MOV_ANNOES);
_tipodoc = curmov.get(MOV_TIPODOC);
_causale_gia_stampata = FALSE;
TRectype da (LF_MOV);
TRectype a (LF_MOV);
if (_annoes != 0)
{
da.put(MOV_ANNOES, _annoes);
a.put(MOV_ANNOES, _annoes);
}
da.put(MOV_CODCAUS, _causale_ini);
a.put(MOV_CODCAUS, _causale_fin);
if ((curmov >= da) && (curmov <= a))
{
const TRectype & caus = cache().get(LF_CAUSALI, _causale);
_descr_causale = caus.get(CAU_DESCR);
_alleg_causale = caus.get_bool(CAU_ALLEG);
_tipodocumento = caus.get(CAU_TIPODOC);
_tiporegistro = tipo_registro (_registro, _anno);
if ((_tiporegistro != 1)&&(_tiporegistro != 2))//se si tratta di un movimento di sola prima nota
return TRUE;
}
}
else if (file == LF_RMOV)
{
if (!_causale_gia_stampata)
{
set_row(_nr,"@4g%3s", (const char*) _causale);
set_row(_nr,"@8g%-.20s", (const char*) _descr_causale);
_causale_gia_stampata = TRUE;
}
const TRectype& rmov = current_cursor()->curr(LF_RMOV);
const int gruppo = rmov.get_int(RMV_GRUPPO);
const int conto = rmov.get_int(RMV_CONTO);
const long sottoconto = rmov.get_long(RMV_SOTTOCONTO);
const char tipoc = rmov.get_char(RMV_TIPOC);
_descr = DescrConto(gruppo, conto, sottoconto, tipoc);
_importo = rmov.get_real(RMV_IMPORTO);
_appoggio = toupper(rmov.get_char(RMV_SEZIONE));
if (!_no_preprocess_page)
{
if (_appoggio=='D')
{
_tot_dare_generale += _importo;
_tot_dare += _importo;
}
else
{
_tot_avere += _importo;
_tot_avere_generale += _importo;
}
}
return TRUE;
}
}
break;
case fatture:
{
if (file == LF_MOV)
{
const TRectype& curmov = current_cursor()->curr(LF_MOV);
const int anno = curmov.get_int(MOV_ANNOIVA);
const TString4 codreg = curmov.get(MOV_REG);
_numr = curmov.get_long(MOV_NUMREG);
_tipo_elenco = curmov.get(MOV_TIPO);
_codcf = curmov.get_long(MOV_CODCF);
const int tiporeg = tipo_registro (codreg, anno);
const TString8 attreg = AttivitaRegistro (codreg, anno);
if (tiporeg == 1 || tiporeg == 2)//se si tratta di un movimento iva
{
_tipoatt = TipoAttivita(attreg, get_firm());
_tipo_elenco = curmov.get(MOV_TIPO);
_codcf = curmov.get_long(MOV_CODCF);
_codcaus = curmov.get(MOV_CODCAUS);
_tipodoc = curmov.get(MOV_TIPODOC);
_codval = curmov.get(MOV_CODVALI);
_totdoc = curmov.get_real(MOV_TOTDOC);
if (_numr == 97613l)
int i = 1;
_ritenute = curmov.get_real(MOV_RITFIS) + curmov.get_real(MOV_RITSOC);
const TString& tipodoc = curmov.get(MOV_TIPODOC);
if (tipodoc == "NC")
_ritenute = -_ritenute;
if (_tipo_elenco != _tipo_clifo_prec && _tipo_clifo_prec != "")
printer().formfeed();
TRectype da (LF_MOV);
TRectype a (LF_MOV);
if (_annoes != 0) //anno specificato nella maschera
{
da.put(MOV_ANNOES, _annoes);
a.put(MOV_ANNOES, _annoes);
}
da.put(MOV_CODCAUS, _causale_ini);
a.put(MOV_CODCAUS, _causale_fin);
if (_data_ini.ok())
da.put(MOV_DATAREG, _data_ini);
da.put(MOV_TIPO, _tipo_ini);
if (_codice_ini != 0)
da.put(MOV_CODCF, _codice_ini);
if (_data_fin.ok())
a.put(MOV_DATAREG, _data_fin);
a.put(MOV_TIPO, _tipo_fin);
if (_codice_fin != 0)
a.put(MOV_CODCF, _codice_fin);
if ((curmov >= da) && (curmov <= a))
{
compila_clifo();
compila_comuni();
if ((_tipo_clifo_prec == "")&&(_codcf_prec == 0l))
{
_tipo_clifo_prec = _tipo_elenco;
_codcf_prec = _codcf;
stampa_intestazione();
}
else
if (_tipo_clifo_prec == _tipo_elenco && _codcf_prec == _codcf)
_settata_prima_riga = FALSE;
else
{
if ( _salto_pagina && _tipo_clifo_prec == _tipo_elenco )
printer().formfeed();
stampa_intestazione();
_tipo_clifo_prec = _tipo_elenco;
_codcf_prec = _codcf;
_settata_prima_riga = FALSE;
}
return TRUE;
}
}
}
else if (file == LF_RMOVIVA)
{
const TRectype& rmov = current_cursor()->curr(LF_RMOV);
int gruppo = rmov.get_int(RMV_GRUPPO);
int conto = rmov.get_int(RMV_CONTO);
TToken_string key;
key.add(gruppo);
key.add(conto);
key.add("");
const TRectype & pcon = cache().get(LF_PCON, key);
_ricser = pcon.get_int(PCN_RICSER);
_simbolo = SimboloValuta(_codval);
_allegb = CausAlleg(_codcaus);
_descr_doc = DescrDoc(_tipodoc);
//_intra = cur->curr(LF_RMOVIVA).get_bool(RMI_INTRA);
if (!_settata_prima_riga)
{
reset_print();
set_row(1, "");
set_row(2,"@7,rn",FLD(LF_MOV,MOV_NUMREG));
set_row(2,"@8g@d",FLD(LF_MOV,MOV_DATAREG));
set_row(2,"@17g@3,rs",FLD(LF_MOV,MOV_REG));
set_row(2,"@20g@5,rn",FLD(LF_MOV,MOV_PROTIVA));
set_row(2,"@26g@2,rn",FLD(LF_MOV,MOV_MESELIQ));
const TString8 protiva = cur->curr(LF_MOV).get(MOV_PROTIVA);
TString8 uprotiva = cur->curr(LF_MOV).get(MOV_UPROTIVA);
if (uprotiva.full())
{
int i;
for (i = 0; protiva[i] && (protiva[i] == uprotiva[i]); i++);
uprotiva = uprotiva.mid(i);
set_row(2, "@24g/@25g%s", (const char*) uprotiva);
}
set_row(2, "@31g@d", FLD(LF_MOV,MOV_DATADOC));
set_row(2,"@40g@7,rs",FLD(LF_MOV,MOV_NUMDOC));
set_row(2,"@48g@3s",FLD(LF_MOV,MOV_CODCAUS));
set_row(2,"@52g@2s",FLD(LF_MOV,MOV_TIPODOC));
set_row(2,"@55g%-.12s", (const char *)_descr_doc);
set_row(2,"@67g@n",FLD(LF_MOV,MOV_TOTDOC));
set_row(2,"@84g@n",FLD(LF_RMOVIVA,RMI_IMPONIBILE));
set_row(2,"@101g@4s",FLD(LF_RMOVIVA,RMI_CODIVA));
set_row(2,"@105g@1s",FLD(LF_RMOVIVA,RMI_TIPODET));
if (_tipoatt == "E")
{
if (_ricser == 1)
set_row(2,"@109g1");
else if (_ricser == 2)
set_row(2,"@109g2");
}
set_row(2,"@111g@f",FLD(LF_RMOVIVA,RMI_INTRA));
set_row(2,"@114g@n",FLD(LF_RMOVIVA,RMI_IMPOSTA));
if (_allegb)
set_row(2,"@131g*");
incrementa_totali();
_settata_prima_riga = TRUE;
++_documenti;
}
else if (_settata_prima_riga)
{
reset_print();
set_row(1,"@84g@n", FLD(LF_RMOVIVA,RMI_IMPONIBILE));
set_row(1,"@101g@4s", FLD(LF_RMOVIVA,RMI_CODIVA));
set_row(1,"@105g@1s",FLD(LF_RMOVIVA,RMI_TIPODET));
set_row(1,"@114g@n", FLD(LF_RMOVIVA,RMI_IMPOSTA));
incrementa_totali();
}
return TRUE;
}
}
break;
default:
break;
}
return FALSE;
}
void TListaMov_application::print_intra(int& rr)
{
const TRectype& mov = current_cursor()->curr(LF_MOV);
const real corrval = mov.get_real(MOV_CORRVALUTA);
if (corrval != ZERO)
{
const TString16 codval = mov.get(MOV_CODVALI);
TString80 str;
rr++;
const TCurrency cl(mov.get_real(MOV_CORRLIRE));
str = cl.string(TRUE); str.right_just(19);
set_row(rr,FR("Corrispettivo@14g%s"), (const char*)str);
const TCurrency cv(corrval, codval);
str = cv.string(TRUE); str.right_just(19);
set_row(rr,FR("@34gCorr.in valuta@49g%s"), (const char*)str);
set_row(rr,"@70g%-3s", (const char*)codval);
}
}
print_action TListaMov_application::postprocess_page(int file,int count)
{
if (count)
{
reset_print();
return NEXT_PAGE;
}
switch (_tipo_lista)
{
case movimenti:
if (file == LF_RMOV)
{
force_setpage();
break;
}
if (file == LF_MOV)
{
reset_print();
_err.reset();
int n = 1;
int r = 0;
if (_scelta_stampa == 0)
if (_registro.not_empty() && _mov_di_sola_iva)
{
compila_clifo();
set_row(++r, "@1g%3s %-50s %6ld %-50s", (const char*)_causale, (const char*)_descr_causale, _codcf, (const char*)_ragsoc);
}
if ( _scelta_stampa == 0 && _stampa_parte_iva )
{
for (int j = 0; j < _c.items(); j++)
{
const TRigaiva& riga = (const TRigaiva&)_c[j];
//r = j+1;
r++;
set_row(r, FR("Imponibile@11g%r"), &riga._imponibile);
set_row(r, FR("@31gImposta@38g%r"), &riga._imposta);
set_row(r, FR("@58gCodice Iva@69g%3s"), (const char*)riga._codiva);
set_row(r, "@76g%s", (const char*)riga.descr_det());
if (j == 0) // Se e' la prima riga che stampa
{
const int meseliq = current_cursor()->file(LF_MOV).get_int(MOV_MESELIQ);
if (meseliq > 0) // Stampa il mese liquidazione
set_row(r,FR(" Mese liq. %2d"), meseliq);
}
if (riga._intra)
set_row(r, FR("@111gOper.intrac."));
if (_controllo_mov_errati != 3)
if (!_esiste_riga_iva && ! _nonesiste_riga_iva)
stampa_errori_iva(&r, riga);
}
print_intra(r);
if (_esiste_riga_iva)
set_row(++r, FR("@11gPresenti righe IVA in una registrazione senza IVA"));
if (_nonesiste_riga_iva)
set_row(++r, FR("@11gNon presente alcuna riga IVA in una registrazione con IVA"));
_c.destroy();
} //if(_scelta_stampa==0...
if (r > 0)
n = ++r;
TRecnotype pos, items;
bool FINITO = FALSE;
if ((_scelta_stampa == 0)&&(_controllo_mov_errati != 3)&&(_tot_dare != _tot_avere))
set_row(n++, FR("@11gIl movimento risulta sbilanciato"));
pos = current_cursor()->pos();
items = current_cursor()->items();
FINITO = (pos == items-1);
_datareg = current_cursor()->file(LF_MOV).get_date(MOV_DATAREG);
_numreg = current_cursor()->file(LF_MOV).get_long(MOV_NUMREG);
TDate datarec (_datareg);
if (!FINITO)
{
TCursor * cur = current_cursor();
cur->save_status();
++(*cur);
datarec = cur->file(LF_MOV).get_date(MOV_DATAREG);
--(*cur);
cur->restore_status();
}
_tot_avere_giornaliero += _tot_avere;
_tot_dare_giornaliero += _tot_dare;
//stampa i totali giornalieri
if ( FINITO ||
(_datareg != datarec)||(_numreg == _numreg_fin))
{
if (( _scelta_stampa == 0 && _controllo_mov_errati != 1 && _decidi == 2) || (_scelta_stampa == 1 && _decidi == 2))
{
set_row(n, FR("@b@60gTotali del giorno %s"), _datareg.string());
set_row(n++, "@b@90g%r %r", &_tot_dare_giornaliero, &_tot_avere_giornaliero);
_tot_avere_giornaliero = 0;
_tot_dare_giornaliero = 0;
}
if ((_scelta_stampa == 0 && _controllo_mov_errati != 1 && FINITO) || (_scelta_stampa == 1 && FINITO))
{
set_row(n++,"");
set_row(n, FR("@b@60gTotale generale"));
set_row(n++, "@b@90g%r %r", &_tot_dare_generale, &_tot_avere_generale);
}
}
if (n == 1)
{
force_setpage(); //probabilmente e' inutile
return NEXT_PAGE;
}
else
{
_no_preprocess_page = TRUE;
force_setpage(FALSE);
return REPEAT_PAGE;
}
}
break;
case fatture:
if (file == LF_MOV)
{
reset_print();
TCursor* cur = current_cursor();
int rr = 1;
print_intra(rr);
_totdocumenti += _totdoc;
_totritenute += _ritenute;
TRecnotype pos, items;
bool FINITO = FALSE;
pos = current_cursor()->pos();
items = current_cursor()->items();
FINITO = (pos == items-1);
if (!FINITO)
{
cur->save_status();
++(*cur);
// long numrsucc = cur->file(LF_MOV).get_long(MOV_NUMREG);
_tipoelsucc = cur->curr(LF_MOV).get(MOV_TIPO);
_codclifosucc = cur->curr(LF_MOV).get_long(MOV_CODCF);
--(*cur);
cur->restore_status();
}
if (FINITO || (_tipo_elenco != _tipoelsucc)||(_codcf != _codclifosucc))
{
set_row(rr++,"");
if (_tipo_elenco == "C")
set_row(rr++, FR("@bTotali Cliente@18gDocumenti Totale documenti@45gRitenute/IVA CEE@68gImponibile@86gImposta@102gop. esenti@119gop. non imp."));
else
set_row(rr++, FR("@bTotali Fornitore@18gDocumenti Totale documenti@45gRitenute/IVA CEE@68gImponibile@86gImposta@102gop. esenti@119gop. non imp."));
set_row(rr, "@b@18g%9d", _documenti);
set_row(rr, "@b@28g%r", &_totdocumenti);
set_row(rr, "@b@45g%r", &_totritenute);
set_row(rr, "@b@62g%r", &_totimponibile);
set_row(rr, "@b@79g%r", &_totimposta);
set_row(rr, "@b@96g%r", &_op_esenti);
set_row(rr, "@b@113g%r", &_op_non_imp);
//incrementa i totali generali di stampa!!!
_gen_documenti += _documenti;
_gen_totdocumenti += _totdocumenti;
_gen_totritenute += _totritenute;
_gen_totimponibile += _totimponibile;
_gen_totimposta += _totimposta;
_gen_op_esenti += _op_esenti;
_gen_op_non_imp += _op_non_imp;
_totimposta = 0;
_totimponibile = 0;
_op_esenti = 0;
_op_non_imp = 0;
_documenti = 0;
_totdocumenti = 0;
_totritenute = 0;
//return REPEAT_PAGE;
}
if (FINITO) //ha veramente finito questa stupida stampa: stampa i totali generali!
{
const TString& blank = EMPTY_STRING;
set_row(rr++,(const char*)blank);
set_row(rr++,(const char*)blank);
set_row(rr++,(const char*)blank);
set_row(rr++, FR("@bTOTALI GENERALI @18gDocumenti Totale documenti@45gRitenute/IVA CEE@68gImponibile@88gImposta@102gop. esenti@119gop. non imp."));
set_row(rr, "@b@18g%9d", _gen_documenti);
set_row(rr, "@b@28g%r", &_gen_totdocumenti);
set_row(rr, "@b@45g%r", &_gen_totritenute);
set_row(rr, "@b@62g%r", &_gen_totimponibile);
set_row(rr, "@b@79g%r", &_gen_totimposta);
set_row(rr, "@b@96g%r", &_gen_op_esenti);
set_row(rr, "@b@113g%r", &_gen_op_non_imp);
//alla fine della stampa azzera i totali generali
_gen_documenti = 0;
_gen_totdocumenti = 0;
_gen_totritenute = 0;
_gen_totimponibile = 0;
_gen_totimposta = 0;
_gen_op_esenti = 0;
_gen_op_non_imp = 0;
}
if (rr > 1)
return REPEAT_PAGE;
}
break;
default:
break;
}
return NEXT_PAGE;
}
print_action TListaMov_application::postprocess_print(int file,int count)
{
if (count)
{
reset_print();
return NEXT_PAGE;
}
switch (_tipo_lista)
{
case movimenti:
break;
case fatture:
break;
default:
break;
}
return NEXT_PAGE;
}
//cerca errori sulla testata (MOV)
bool TListaMov_application::segnala_errori_primariga()
{
TEsercizi_contabili esc;
const int ae = esc.date2esc(_datacomp);
if (_ae == 0)
_err.set(0l);
if (_registro.not_empty()) //si tratta di fattura
if (_datareg.year() != _anno)
_err.set(1);
if ( _scelta_stampa == 0 && _stampa_anno_comp )
if (_ae != _annoeser)
{
if (_annoes) //specificato l'anno nella maschera
_err.set(2);
else _err.set(3);
}
else
if (_datacomp != _datareg) // altrimenti se gli esercizi corrispondono controlla datacomp e dataop
_err.set(26);
if (ae)
{
const int ar = esc.date2esc(_datareg); // Esercizio in corso
const int pr = esc.pred(ar); // Esercizio precedente
if (ae != ar && ae != pr)
_err.set(4);
}
else
_err.set(5);
if (_annoeser != ae)
_err.set(6);
if (_tipodoc != "")
if (!RicercaDoc(_tipodoc))
_err.set(11);
if (_causale.not_empty()) //se indicata la causale
{
const TRectype & caus = cache().get(LF_CAUSALI, _causale);
if (caus.empty())
_err.set(7);
else
{
bool sos = caus.get_bool(CAU_SOSPESO);
if (sos)
_err.set(8);
if (_stampa_mess_alleg_iva && _alleg_causale)
_err.set(9);
}
if (_tipodoc != _tipodocumento)
_err.set(10);
if (_registro != _reg_causale)
_err.set(12);
if (_registro.not_empty()) //movimento iva (fatture)
{
TRegistro rg (_registro, _datareg.year());
if (rg.name().empty())
_err.set(13);
else
{
const int tipo = rg.tipo();
// TipoIVA i = nessuna_iva;
const TRectype& tabtpd = cache().get("%TPD", _tipodoc);
if (!tabtpd.empty())
{
const bool cor = tabtpd.get_bool("B0");
const int i = tabtpd.get_int("I0");
if (i == 1 && tipo != 1)
_err.set(15);
if (i == 2 && tipo != 2)
_err.set(15);
if (i == 9 && (tipo != 1 && tipo != 2))
_err.set(15);
if (cor && !rg.corrispettivi())
_err.set(15);
if (!cor)
if (_codcf == 0l)
_err.set(16);
}
if (_codcf != 0l)
{
if ((tipo == 1 && _tipo_elenco != "C") || (tipo == 2 && _tipo_elenco != "F"))
_err.set(17);
TToken_string key;
key.add(_tipo_elenco);
key.add(_codcf);
const TRectype & clifo = cache().get(LF_CLIFO, key);
if (!clifo.empty())
{
bool sosp = clifo.get_bool(CLI_SOSPESO);
if (sosp)
_err.set(18);
bool occ = clifo.get_bool(CLI_OCCAS);
char alleg = clifo.get_char(CLI_ALLEG);
long calleg = clifo.get_long(CLI_CODALLEG);
if (!occ)
{
if (_stampa_mess_alleg_iva && alleg == '1')
_err.set(19);
if (calleg != 0l)
{
if (calleg == _codcf)
_err.set(20);
TToken_string key;
key.add(_tipo_elenco);
key.add(calleg);
const TRectype & clifo = cache().get(LF_CLIFO, key);
if (!clifo.empty())
{
bool sospall = clifo.get_bool(CLI_SOSPESO);
long codall = clifo.get_long(CLI_CODALLEG);
char alleg = clifo.get_char(CLI_ALLEG);
if (sospall)
_err.set(21);
if (codall != 0l)
_err.set(22);
if (_stampa_mess_alleg_iva && alleg == '1')
_err.set(23);
}
else _err.set(24);
}
}
}
else _err.set(25);
}
}
}
}
if (_err.ones())
return TRUE;
return FALSE;
}
//controlli sulla contropartita
bool TListaMov_application::contropartita(int gruppo, int conto, long sottoconto, char t)
{
TBill tc;
TRectype pc (LF_PCON);
tc.set(gruppo,0,0l);
if (!tc.read(pc))
return TRUE;
tc.set(gruppo,conto,0l);
if (!tc.read(pc))
return TRUE;
//else t = pc.get_char(PCN_TMCF);
tc.set(gruppo,conto,sottoconto);
if (t != 'C' && t != 'F')
{
if (!tc.read(pc))
return TRUE;
else
{
bool sosp = tc.sospeso();
if (sosp)
return TRUE;
}
}
else if (sottoconto != 0l)
{
TToken_string key;
key.add(t);
key.add(sottoconto);
const TRectype & clifo = cache().get(LF_CLIFO, key);
if (!clifo.empty())
{
bool sosp = clifo.get_bool(CLI_SOSPESO);
if (sosp)
return TRUE;
}
else
return TRUE;
}
return FALSE;
}
//guarda se c'e' almeno un errore su almeno una riga (rmov)
bool TListaMov_application::segnala_errori_ogniriga()
{
TLocalisamfile& rmov = current_cursor()->file(LF_RMOV);
int gruppo, conto, anno, gruppoc, contoc;
long sottoconto, sottocontoc;
TDate datareg;
char sez, tipo, t, tipoc;
real importo;
real dare, avere;
if (current_cursor()->is_first_match(LF_RMOV))
{
dare = avere = ZERO;
TRecnotype nrec = rmov.recno();
rmov.zero();
rmov.setkey(1);
rmov.put(RMV_NUMREG, _numero);
TRectype recc (rmov.curr());
for (rmov.read(_isgteq); !rmov.eof() ;rmov.next())
{
TRectype rec (rmov.curr());
if (rec > recc) break;
gruppo = rec.get_int(RMV_GRUPPO);
conto = rec.get_int(RMV_CONTO);
sottoconto = rec.get_long(RMV_SOTTOCONTO);
gruppoc = rec.get_int(RMV_GRUPPOC);
contoc = rec.get_int(RMV_CONTOC);
sottocontoc = rec.get_long(RMV_SOTTOCONTOC);
tipoc = rec.get_char(RMV_TIPOCC);
anno = rec.get_int(RMV_ANNOES);
datareg = rec.get_date(RMV_DATAREG);
sez = rec.get_char(RMV_SEZIONE);
tipo = rec.get_char(RMV_TIPOC);
importo = rec.get_real(RMV_IMPORTO);
if (sez == 'D')
dare += importo;
if (sez == 'A')
avere += importo;
TBill tc (gruppo,conto,sottoconto);
if (gruppoc != 0 || contoc != 0 || sottocontoc != 0l)
if (contropartita(gruppoc, contoc, sottocontoc, tipoc))
{
rmov.readat(nrec);
return true;
}
if (anno != _annoeser || datareg != _datareg)
{
rmov.readat(nrec);
return true;
}
if (sez != 'D' && sez != 'A')
{
rmov.readat(nrec);
return true;
}
if (tc.empty())
{
rmov.readat(nrec);
return true;
}
if (!tc.ok())
{
rmov.readat(nrec);
return true;
}
TRectype pc (LF_PCON);
tc.set(gruppo,0,0l);
if (!tc.read(pc))
{
rmov.readat(nrec);
return true;
}
tc.set(gruppo,conto,0l);
if (!tc.read(pc))
{
rmov.readat(nrec);
return true;
}
else t = pc.get_char(PCN_TMCF);
if (t != tipo)
{
rmov.readat(nrec);
return true;
}
tc.set(gruppo,conto,sottoconto);
if (t != 'C' && t != 'F')
{
if (!tc.read(pc))
{
rmov.readat(nrec);
return true;
}
else
{
bool sosp = tc.sospeso();
if (sosp)
{
rmov.readat(nrec);
return true;
}
}
}
else
{
TToken_string key;
key.add(t);
key.add(sottoconto);
const TRectype & clifo = cache().get(LF_CLIFO, key);
if (!clifo.empty())
{
bool sosp = clifo.get_bool(CLI_SOSPESO);
if (sosp)
{
rmov.readat(nrec);
return true;
}
}
else
{
rmov.readat(nrec);
return true;
}
if (_registro.not_empty()) //se su mov e' indicato il codice registro
{
TRegistro rg (_registro, _ae);
const int tiporeg = rg.tipo();
if ((tiporeg == 1 && t != 'C') || (tiporeg == 2 && t != 'F'))
{
rmov.readat(nrec);
return true;
}
}
}
TLocalisamfile saldi(LF_SALDI);
saldi.setkey(1);
saldi.zero();
saldi.put(SLD_ANNOES,anno);
saldi.put(SLD_GRUPPO,gruppo);
saldi.put(SLD_CONTO, conto);
saldi.put(SLD_SOTTOCONTO,sottoconto);
saldi.put(SLD_FLSCA, "");
if (saldi.read() != NOERR)
{
rmov.readat(nrec);
return true;
}
} //for
if (dare != avere)
{
rmov.readat(nrec);
return true;
}
rmov.readat(nrec);
}
return false;
}
bool TListaMov_application::segnala_errori_iva()
{
TLocalisamfile& rmoviva = current_cursor()->file(LF_RMOVIVA);
const TRectype& mv = current_cursor()->curr(LF_RMOV);
if (current_cursor()->is_first_match(LF_RMOVIVA))
{
const TRecnotype nrec = rmoviva.recno();
rmoviva.setkey(1);
rmoviva.zero();
rmoviva.put(RMI_NUMREG, _numero);
const TRectype& rec = rmoviva.curr();
const TRectype recc (rec);
for (rmoviva.read(_isgteq); !rmoviva.eof() ;rmoviva.next())
{
if (rec > recc)
break;
if (_registro.empty())
{
rmoviva.readat(nrec);
_esiste_riga_iva = true;
return true;
}
const TString4 cod = rec.get(RMI_CODIVA);
real percind;
const int tipodet = get_tipodet_from_rmi(rec, mv, percind);
const int tipocr = rec.get_int(RMI_TIPOCR);
const TRectype& tab_iva = cache().get("%IVA", cod);
if (!tab_iva.empty())
{
int allc = tab_iva.get_int("S7");
int allf = tab_iva.get_int("S8");
bool s = tab_iva.get_bool("B2");
if (s)
{
rmoviva.readat(nrec);
return true;
}
if (_stampa_mess_alleg_iva)
if (allc == 0 || allf == 0)
{
rmoviva.readat(nrec);
return true;
}
}
else
{
rmoviva.readat(nrec);
return true;
}
if (tipodet == 1 || tipodet == 3 || tipodet == 5 || tipodet == 9)
if (_tiporegistro != 2)
{
rmoviva.readat(nrec);
return true;
}
if (_tiporegistro == 1)
if (tipocr != 0 && tipocr != 1 && tipocr != 4 && tipocr != 9)
{
rmoviva.readat(nrec);
return true;
}
if (_tiporegistro == 2)
if (tipocr != 0 && tipocr != 1 && tipocr != 2 && tipocr != 3 && tipocr != 5 && tipocr != 8 && tipocr != 9)
{
rmoviva.readat(nrec);
return true;
}
}
rmoviva.readat(nrec);
}
else if (_registro.not_empty()) //cioe' si tratta di fattura
{
_nonesiste_riga_iva = true;
return true;
}
return false;
}
void TListaMov_application::incrementa_totali()
{
const TRectype& rmoviva = current_cursor()->curr(LF_RMOVIVA);
const real imponibile = rmoviva.get_real(RMI_IMPONIBILE);
const real imposta = rmoviva.get_real(RMI_IMPOSTA);
const TString4 codiva = rmoviva.get(RMI_CODIVA);
const TRectype& tabiva = cache().get("%IVA", codiva);
if (_tipo_elenco == "C")
{
const int colonna = tabiva.get_int("S7");
if ((colonna == 1)||(colonna == 3))
_totimposta += imposta;
if (colonna == 1)
_totimponibile += imponibile;
else
{
if (colonna == 3)
_op_esenti += imponibile;
else
{
TString msg; msg << TR("Codice IVA senza colonna allegato clienti '") << codiva << "' considerata non imponibile.";
xvtil_statbar_set(msg);
_op_non_imp += imponibile; // 14-02-2013 Il default <20> ora questo (Sile)
}
}
}
else
{
const int colonna = tabiva.get_int("S8");
if ((colonna == 1)||(colonna == 3)||(colonna == 4))
_totimposta += imposta;
switch (colonna)
{
case 1: _totimponibile += imponibile; break;
case 3: _op_esenti += imponibile; break;
case 4: _op_non_imp += imponibile; break;
default:
_op_non_imp += imponibile; // 14-02-2013 Il default <20> ora questo (Sile)
TString msg; msg << TR("Codice IVA senza colonna allegato fornitori '") << codiva << "' considerata non imponibile.";
xvtil_statbar_set(msg);
break;
}
}
}
void TListaMov_application::filtra_cursore_provvisori(TCursor* cur) const
{
TString filter;
switch (_provvis)
{
case 1: filter = "(PROVVIS=\"\")"; break; //normale
case 2: filter = ""; break; //globale
default: filter = "(PROVVIS!=\"\")"; break; //solo provvisori
}
cur->setfilter(filter);
}
void TListaMov_application::imposta_parametri_stampa(const TMask& msk)
{
set_magic_currency(TRUE);
reset_files();
_curr1->set_filterfunction (filter_func);
_curr2->set_filterfunction (filter_func);
_curr3->set_filterfunction (filter_func_fatture);
switch (_tipo_lista)
{
case movimenti:
{
_scelta_stampa = msk.get_int(F_MOVIMENTI);
_annoes = msk.get_int (F_ANNO);
_decidi = msk.get_int(F_DECIDI);
_causale_ini = msk.get(F_CAUSALEINI);
_causale_fin = msk.get(F_CAUSALEFIN);
if (_scelta_stampa == 0)
{
_registro_ini = msk.get(F_REGISTROINI);
_registro_fin = msk.get(F_REGISTROFIN);
}
_numreg_ini = msk.get_long(F_NUMEROINI);
_numreg_fin = msk.get_long(F_NUMEROFIN);
_data_ini = msk.get(F_DATAINI);
_data_fin = msk.get(F_DATAFIN);
_provvis = msk.get_int(F_STAMPAMOVP);
_competence_only = msk.get_bool(F_COMPETENZA);
#ifdef CONT_SEP
_cont_sep = msk.get(F_CONTSEP);
#endif
TRectype da (LF_MOV), a(LF_MOV);
if (_decidi == 1)
{
select_cursor(_cur1);
filtra_cursore_provvisori(_curr1);
da.put(MOV_NUMREG, _numreg_ini);
a.put(MOV_NUMREG, _numreg_fin);
}
else
{
select_cursor(_cur2);
filtra_cursore_provvisori(_curr2);
if (_data_ini.ok())
da.put(MOV_DATAREG, _data_ini);
if (_data_fin.ok())
a.put(MOV_DATAREG, _data_fin);
}
current_cursor()->setregion(da,a);
add_file(LF_MOV);
add_file(LF_RMOV,LF_MOV);
add_file(LF_RMOVIVA,LF_MOV);
}
break;
case fatture:
{
_noseparator = msk.get_bool(F_SEPARATOR);
TString tipo = msk.get(F_TIPOELENCO);
_data_ini = msk.get(F_DATAINI);
_data_fin = msk.get(F_DATAFIN);
_annoes = msk.get_int(F_ANNO);
_causale_ini = msk.get(F_DACODCAUS);
_causale_fin = msk.get(F_ACODCAUS);
_dacodiva = msk.get(F_DACODIVA);
_acodiva = msk.get(F_ACODIVA);
if (tipo=="C" || tipo=="F")
{
_codice_ini = atol(msk.get(F_CODICEINI));
_codice_fin = atol(msk.get(F_CODICEFIN));
}
else
{
_codice_ini = atol(msk.get(F_CODICEINI1));
_codice_fin = atol(msk.get(F_CODICEFIN1));
}
if (tipo == "E")
{
_tipo_ini = "C";
_tipo_fin = "F";
}
else
{
_tipo_ini = tipo;
_tipo_fin = tipo;
}
select_cursor(_cur3);
_curr3->setfilter("");
TRectype da(LF_MOV), a(LF_MOV);
if (_codice_ini != 0)
da.put(MOV_CODCF, _codice_ini);
a.put(MOV_TIPO, _tipo_fin);
if (_codice_fin != 0)
a.put(MOV_CODCF, _codice_fin);
da.put(MOV_TIPO, _tipo_ini);
current_cursor()->setregion(da,a);
add_file(LF_MOV);
add_file(LF_RMOVIVA,LF_MOV);
}
break;
default:
break;
}
init_print(msk);
}
bool TListaMov_application::set_print(int)
{
const char* masc;
switch(toupper(_tipoc))
{
case 'C':
#ifdef CONT_SEP
masc = "np0600b";
#else
masc = "cg3100b";
#endif
_tipo_lista = fatture;
break;
case 'M':
default :
#ifdef CONT_SEP
masc = "np0600a";
#else
masc = "cg3100a";
#endif
_tipo_lista = movimenti;
break;
}
TMask msk(masc);
if (main_app().has_module(CMAUT))
msk.show(-4);
else
{
msk.hide(-4);
msk.reset(-4);
}
msk.set_handler(F_ANNO, annoes_handler);
msk.set_handler(F_DATAINI, data_inizio);
msk.set_handler(F_DATAFIN, data_fine);
while (msk.run() == K_ENTER)
{
imposta_parametri_stampa(msk);
print();
msk.reset(-5);
}
return false;
}
bool TListaMov_application::user_create()
{
_relmov1 = new TRelation (LF_MOV);
_relmov1->add(LF_RMOV, "NUMREG=NUMREG",1);
_relmov1->add(LF_RMOVIVA, "NUMREG=NUMREG",1);
_curr1 = new TCursor (_relmov1, "", 1);
_cur1 = add_cursor (_curr1);
_relmov2 = new TRelation (LF_MOV);
_relmov2->add(LF_RMOV, "NUMREG=NUMREG",1);
_relmov2->add(LF_RMOVIVA, "NUMREG=NUMREG",1);
_curr2 = new TCursor (_relmov2, "", 2);
_cur2 = add_cursor (_curr2);
_relmov3 = new TRelation (LF_MOV);
_relmov3->add(LF_RMOVIVA, "NUMREG==NUMREG",1);
_relmov3->add(LF_RMOV, "NUMREG==NUMREG",1);
_curr3 = new TCursor (_relmov3, "", 3);
_cur3 = add_cursor (_curr3);
open_files(LF_TAB, LF_TABCOM, LF_CAUSALI, LF_CLIFO, LF_COMUNI, LF_ATTIV,
LF_PCON, LF_SALDI, LF_RMOVIVA, LF_NDITTE, 0);
return true;
}
bool TListaMov_application::user_destroy() // releasev e arrmask
{
delete _relmov1;
delete _relmov2;
delete _relmov3;
return true;
}
void TListaMov_application::init_print(const TMask& msk)
{
const TDate data (msk.get(F_DATASTAMPA));
printer().setdate(data);
printer().footerlen(5);
set_magic_currency(TRUE);
switch (_tipo_lista)
{
case movimenti:
{
set_real_picture("###.###.###.###.###");
reset_print();
_flags = 0;
_err.reset();
_tot_dare_giornaliero = 0;
_tot_avere_giornaliero = 0;
_tot_dare_generale = 0;
_tot_avere_generale = 0;
if (_scelta_stampa == 0)
{
_annoes = msk.get_int(F_ANNO);
_stampa_parte_iva = msk.get_bool(F_STAMPA);
if (_stampa_parte_iva)
_flags |= ST_DATI_IVA;
_stampa_mess_alleg_iva = msk.get_bool(F_ALLEGATO);
if (_stampa_mess_alleg_iva)
_flags |= ST_MESS_ALLEG;
_stampa_anno_comp = msk.get_bool(F_ANNOC);
if (_stampa_anno_comp)
_flags |= ST_ANNO_COMP;
_controllo_mov_errati = msk.get_int(F_CONTROLLO);
if (_controllo_mov_errati == 1)
_flags |= ST_SOLO_MOVERR;
else if (_controllo_mov_errati == 2)
_flags |= ST_CONTROLLO;
else _flags |= ST_SENZA_CONTR;
if ((_numreg_ini != 0)&&(_decidi == 1))
_flags |= ST_NUMERO;
if ((_data_ini.ok())&&(_decidi == 2))
_flags |= ST_DATA;
_causale_ini = msk.get(F_CAUSALEINI);
if (_causale_ini != "")
_flags |= ST_CAUSALE;
_registro_ini = msk.get(F_REGISTROINI);
if (_registro_ini != "")
_flags |= ST_REGISTRO;
if ((_data_fin.ok())&&(_decidi == 2))
_flags |= ST_DATA;
if ((_numreg_fin != 0)&&(_decidi == 2))
_flags |= ST_NUMERO;
_causale_fin = msk.get(F_CAUSALEFIN);
if (_causale_fin != "")
_flags |= ST_CAUSALE;
_registro_fin = msk.get(F_REGISTROFIN);
if (_registro_fin != "")
_flags |= ST_REGISTRO;
}
else //_scelta_stampa == 1
{
_annoes = msk.get_int(F_ANNO);
if (_numreg_ini != 0)
_flags |= ST_NUMERO;
if (_data_ini.ok())
_flags |= ST_DATA;
_causale_ini = msk.get(F_CAUSALEINI);
if (_causale_ini != "")
_flags |= ST_CAUSALE;
if (_data_fin.ok())
_flags |= ST_DATA;
if (_numreg_fin != 0)
_flags |= ST_NUMERO;
_causale_fin = msk.get(F_CAUSALEFIN);
if (_causale_fin != "")
_flags |= ST_CAUSALE;
}
}
break;
case fatture:
{
if (_noseparator)
set_real_picture("################");
else
set_real_picture("####.###.###.###");
//resettaggio di tutte le incasinatissime variabili membro...(membro stara' per cazzo?)
_flags = 0;
reset_print();
_settata_prima_riga = FALSE;
_tipo_clifo_prec = "";
_codcf_prec = 0l;
_numeroregp = 0;
_documenti = 0;
_totdocumenti = 0;
_totritenute = 0;
_totimponibile = 0;
_totimposta = 0;
_op_esenti = 0;
_op_non_imp = 0;
_gen_documenti = 0;
_gen_totdocumenti = 0;
_gen_totritenute = 0;
_gen_totimponibile = 0;
_gen_totimposta = 0;
_gen_op_esenti = 0;
_gen_op_non_imp = 0;
//caricamento dati dalla maschera
_annoes = msk.get_int(F_ANNO);
_salto_pagina = (bool)(msk.get(F_CAMBIO)=="X");
_data_ini = msk.get(F_DATAINI);
if (_data_ini.ok())
_flags |= ST_DATA;
_data_fin = msk.get(F_DATAFIN);
_causale_ini = msk.get(F_DACODCAUS);
if (_causale_ini != "")
_flags |= ST_CAUSALE;
if (_data_fin.ok())
_flags |= ST_DATA;
_causale_fin = msk.get(F_ACODCAUS);
if (_causale_fin != "")
_flags |= ST_CAUSALE;
TString tipo = msk.get(F_TIPOELENCO);
if ((tipo=="C")||(tipo=="F"))
{
_codice_ini = msk.get_long(F_CODICEINI);
_codice_fin = msk.get_long(F_CODICEFIN);
}
else
{
_codice_ini = msk.get_long(F_CODICEINI1);
_codice_fin = msk.get_long(F_CODICEFIN1);
}
if (_codice_ini != 0)
_flags |= ST_CODICE;
if (_codice_fin != 0)
_flags |= ST_CODICE;
if (tipo == "E")
{
_tipo_ini = "C";
_tipo_fin = "F";
}
else
{
_tipo_ini = tipo;
_tipo_fin = tipo;
}
}
break;
default:
break;
}
}
void TListaMov_application::preprocess_header()
{
int soh = 1; // riga d'inizio dell'intestazione
TString sep(132);
TString key; key.format("%d", get_firm());
const TString & ragsoc = cache().get(LF_NDITTE, key, NDT_RAGSOC);
reset_header();
sep << TR("Ditta ") << get_firm();
sep << " " << ragsoc;
sep.left_just(132);
set_header (soh++, (const char*) sep);
sep.cut(0) << FR("Data @> Pag. @#");
sep.right_just(122);
switch (_tipo_lista)
{
case movimenti:
if (_scelta_stampa == 0)
{
sep.overwrite (TR("Lista movimenti"));
set_header (soh++, (const char*)sep);
if (_decidi == 2) // se _decidi e' 1 _annoes e' sempre uguale a zero
{
if (_annoes != 0)
{
set_header (soh, FR("Cod. eserc.%d"), _annoes);
if (_flags & ST_DATA)
{
set_header (soh, FR("@16gda@19g%s"),_data_ini.string());
set_header (soh, FR("@30ga@32g%s"),_data_fin.string());
}
}
else // _annoes == 0
if (_flags & ST_DATA)
{
set_header (soh, FR("Dalla data@11g%s"),_data_ini.string());
if (_data_fin.ok())
set_header (soh, FR("@23galla data@33g%s"),_data_fin.string());
}
else
set_header (soh, TR("Completa in ordine di data"));
}
else
if (_flags & ST_NUMERO)
{
set_header (soh, FR("dal numero@12g%ld"), _numreg_ini);
if (_numreg_fin != 0)
set_header (soh, FR("@20gal numero@30g%ld"), _numreg_fin);
}
else
set_header (soh, TR("Completa in ordine di numero"));
if (_flags & ST_CAUSALE)
{
set_header (soh, FR("@46gdalla causale@60g%s"),(const char*)_causale_ini);
set_header (soh++, FR("@64galla causale@77g%s"),(const char*)_causale_fin);
}
else
set_header (soh++, TR(" tutte le causali"));
if (_flags & ST_REGISTRO)
{
set_header (soh, FR("dal registro %s"),(const char*)_registro_ini);
set_header (soh, FR("@17gal registro %s"),(const char*)_registro_fin);
}
else
set_header (soh, TR("tutti i registri"));
if (_flags & ST_DATI_IVA)
set_header (soh, FR("@34gstampa dati iva"));
if (_flags & ST_CONTROLLO)
set_header (soh, FR("@50g(controllo movimenti)"));
else if (_flags & ST_SOLO_MOVERR)
set_header (soh, FR("@50g(solo movimenti errati)"));
else set_header (soh, FR("@50g(senza controllo movimenti)"));
if (_flags & ST_MESS_ALLEG)
{
if (_flags & ST_ANNO_COMP)
set_header (soh, FR("@78gcon messaggi: data competenza, allegato iva"));
else
set_header (soh, FR("@78gcon messaggio: allegato iva"));
}
else if (_flags & ST_ANNO_COMP)
{
if (_flags & ST_MESS_ALLEG)
set_header (soh, FR("@78gcon messaggi: data competenza, allegato iva"));
else
set_header (soh, FR("@78gcon messaggio: data competenza"));
}
sep.fill('_');
set_header (++soh, (const char *) sep);
set_header (++soh, FR("Rg Cod Causale@30gDescrizione@56gCodice conto@71gDescrizione conto@103gDare@120gAvere@130gSB"));
}
else
{
sep.overwrite (TR("Lista movimenti di sola prima nota"));
set_header (soh++, (const char*)sep);
if (_decidi == 2)
{
if (_annoes != 0)
{
set_header (soh, FR("Cod. comp. %d"), _annoes);
if (_flags & ST_DATA)
{
set_header (soh, FR("@16gda@19g%s"), (const char*)_data_ini.string());
set_header (soh, FR("@30ga@32g%s"), (const char*)_data_fin.string());
}
}
else
if (_flags & ST_DATA)
{
set_header (soh, FR("Dalla data@11g%s"), (const char*)_data_ini.string());
set_header (soh, FR("@23galla data@33g%s"), (const char*)_data_fin.string());
}
else
set_header (soh, TR("Completa in ordine di data"));
}
else
if (_flags & ST_NUMERO)
{
set_header (soh, FR("@46gdal numero@57g%ld"), _numreg_ini);
set_header (soh, FR("@65gal numero@75g%ld"), _numreg_fin);
}
else
set_header (soh, FR("@46gCompleta in ordine di numero"));
if (_flags & ST_CAUSALE)
{
set_header(soh, FR("@86gdalla causale@100g%3s"),(const char*)_causale_ini);
set_header(soh,FR("@104galla causale@117g%3s"),(const char*)_causale_fin);
}
else
set_header (soh, TR("@86gtutte le causali"));
sep.fill('_');
set_header (++soh, (const char *) sep);
set_header (++soh, FR("Rg Cod Causale@30gDescrizione@56gCodice conto@71gDescrizione conto@103gDare@120gAvere@130gSB"));
}
break;
case fatture:
sep.overwrite (TR("Lista fatture"));
set_header (soh, (const char*)sep);
if (_annoes != 0)
{
set_header (soh, FR("@15gCod. comp %d"), _annoes);
if (_flags & ST_DATA)
{
set_header (soh, FR("@30gdalla data@41g%s"), (const char*)_data_ini.string());
set_header (soh, FR("@52galla data@62g%s"), (const char*)_data_fin.string());
}
}
else
if (_flags & ST_DATA)
{
set_header (soh, FR("@15gdalla data %s"), (const char*)_data_ini.string());
set_header (soh, FR("@37galla data %s"), (const char*)_data_fin.string());
}
else
set_header (soh, TR("@15gcompleta in ordine di data"));
if (_flags & ST_CODICE)
{
set_header (soh, FR("@74gdal codice %ld"), _codice_ini);
set_header (soh, FR("@92gal codice %ld"), _codice_fin);
}
sep.fill('_');
set_header (++soh, sep);
set_header (++soh, FR("Numero Data Cod Prot. M Documento@48gCod Tp @75gTotale@101gCd Tp T O@129gNo"));
set_header (++soh, FR("Regis. Operaz. Reg Num. L Data@41gNumero@48gCau Dc @55gDescrizione@75gDocumento@90gImponibile@101gIv Det A I@121gImposta@129gAll"));
break;
default:
break;
}
set_header (++soh, sep);
}
TListaMov_application::TListaMov_application(char tipost)
: _err(80),_tipoc(tipost)
{ }
#ifdef CONT_SEP
int np0600(int argc, char* argv[])
#else
int cg3100(int argc, char* argv[])
#endif
{
const char tipo = argc > 2 ? toupper(*argv[2]) : 'M';
TListaMov_application a(tipo);
const char* title = NULL;
switch (tipo)
{
case 'C': title = TR("Lista fatture clienti/fornitori"); break;
default : title = TR("Lista movimenti"); break;
}
a.run(argc, argv, title);
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink