root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg6700.cpp
guy 69a6fa10f6 cg6400.cpp Corretto errore MI 3685 
cg6700.cpp     Corretto errore MI 3697
cg6700a.uml    Aggiunto titolo alla maschera
cg6900.cpp     Corretta chiusura file temporanei
cg6902.cpp     Aggiunto test del valore di ritorno di una fcopy


git-svn-id: svn://10.65.10.50/trunk@6364 c028cbd2-c16b-5b4b-a496-9718f37d4682
1998-03-16 13:51:30 +00:00

3341 lines
95 KiB
C++
Executable File
Raw Blame History

//
// Ricezione dati: lista controllo movimenti
//
#include <config.h>
#include <mask.h>
#include <prefix.h>
#include <printapp.h>
#include <progind.h>
#include <tabutil.h>
#include <utility.h>
#include <mailbox.h>
#include <nditte.h>
#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>
#include <causali.h>
#include <clifo.h>
#include <nditte.h>
#include <pconti.h>
#include <partite.h>
#include <scadenze.h>
#include <pagsca.h>
#include "cglib01.h"
#include "cglib04.h"
#include "cg6700.h"
HIDDEN const char* err_msg[] = {"*** Data operazione non valida",
"*** Data operazione non compresa in alcun esercizio",
"*** Data competenza non valida",
"*** Data competenza non compresa in alcun esercizio",
"--- Data competenza incompatibile con data operazione",
"*** Data operazione antecedente ad ultima stampa giornale",
"--- Data documento non valida",
"*** Codice causale non valido o non presente in archivio",
"--- Codice pagamento non valido o non presente in tabella",
"*** Codice registro IVA non valido o non presente in tabella",
"*** Codice cliente/fornitore non valido o non presente in anagrafica",
"--- Data 74 ter non valida",
"*** Data operazione antecedente ad ultima stampa registro IVA",
"*** Tipo anagrafico C/F errato",
"*** Codice anagrafico C/F/Piano Conti errato",
"*** Rif. partite saldaconto errato",
"--- Codice valuta errato",
"*** Data cambio non valida",
"*** Data pagamento/incasso non valida",
"*** Tipo pagamento errato",
"*** Segno D/A errato",
"*** Cambio mancante",
"*** Gruppo/Conto errato",
"*** Rif. rata partite saldaconto errato",
"*** Data scadenza non valida",
"--- Ulteriore classificazione non valida o non presente in archivio",
"*** Importo rata in lire mancante",
"*** Importo rata in valuta mancante",
"--- Codice Nostra banca non valido o non presente in archivio",
"--- Codice Vostra banca non valido o non presente in archivio",
"--- Codice agente non valido o non presente in archivio",
"--- Data sollecito non valida",
"*** Rif. fattura errato",
"*** Rif. rata fattura errato",
"*** In acconto/a saldo errato",
"*** Importo inc./pag. in lire mancante",
"*** Importo inc./pag. in valuta mancante",
"*** Flag abbuono attivo/passivo errato",
"*** Codice valuta errato",
"*** Tipo movimento causale non congruo con tipo movimento saldaconto",
"*** Tipo pagamento del codice di pagamento non congruo con tipo pagamento del saldaconto"};
class TRic_ListaMov : public TPrintapp
{
TTable* _tab_tra,* _tab_pag,* _tab_tpd,* _tab_iva, *_tab_ese;
TIsamtempfile* _tmov,* _trmov,* _tiva,* _tpart,* _tscad,* _tpagsca;
TLocalisamfile* _caus,* _ditte,* _clifo,* _pcon, *_mov, *_rmov, *_rmoviva;
TLocalisamfile* _part,* _scad,* _pagsca;
TRelation* _rel, *_relSC;
//TCursor* _cur, *_curSC;
int _cur, _curSC;
TTransfer_file* _trasfer;
TLibro_giornale* _giornale;
TEsercizi_contabili _ec;
char _ric_auto,_tipo_lista;
TFilename _pathfile;
TString _descr_causale, _descr_conto;
TString16 _causale, _registro, _numdoc, _tipodoc, _codval;
TString16 _codpag, _codiva, _tipo_conto;
TString _record, _numpart, _descr_anag, _descr_pag, _tipom_cau, _codval_part, _codpag_scad,_reg;
bool _mov_sez, _errore_grave, _esiste_conto, _seconda_volta, _errore_grave_SC;
bool _is_iva, _is_salda, _risposta, _continua, _intestaSC, _errore_grave_totale;
bool _prima_volta,_calcola,_prima_rata_pag,_ho_stampato;
char _sdt, _sezione, _tipocf, _sez, _tipocf_p;
int _ae, _anno, _gruppo, _conto, _tipocr, _tipod, _tiporeg, _tipomov, _tipopag, _nriga;
int _gruppoc, _contoc, _gruppocr, _contocr, _annoiva, _gruppocl, _contocl, _numrig, _annoese;
int _gruppo_p, _conto_p, _anno_prec;
TDate _datacomp, _datadoc, _datareg, _data74tr, _datacam, _datacam_part,_datapag;
real _importo, _impo, _impos, _tot_dare, _tot_avere, _tot_doc, _tot_val;
real _cambio, _cambio_part, _impo_print, _impos_print;
long _codcf, _numero, _protiva, _sottoconto, _numreg;
long _sottocontoc, _sottocontocr, _codcf_p;
TBit_array _err;
byte _controllo;
real _imp,_impval;
TString _numpart_prec;
int _tipopag_pag;
public:
virtual bool set_print(int m);
virtual bool user_create() ;
virtual bool user_destroy();
virtual bool preprocess_page(int,int);
virtual bool preprocess_print(int,int);
virtual print_action postprocess_page(int,int);
virtual print_action postprocess_print(int file, int counter);
virtual void postclose_print();
const char* look_sdt();
const char* get_codiva_des(const char*);
bool DescrConto(int,int,long);
bool check_archivi(TProgind*);
bool look_pag();
bool errori_partita(int,int,long);
bool controlla_mov();
bool controlla_rmov();
bool controlla_riva();
void stampa_errori_mov(int);
void stampa_errori_rmov(int);
void stampa_errori_riva(int);
void aggiorna_mov();
void aggiorna_rmov(char tipoc, char tipocc);
void aggiorna_iva(char tipo);
void setta_parametri(const TString&, const TString&);
void setta_intestazione();
char TipoConto(int g, int c);
// Funzioni per lista controllo movimenti saldaconto
bool controlla_partite();
void stampa_errori_partite(int riga);
bool controlla_scadenze();
void stampa_errori_scadenze(int riga);
bool controlla_pagsca();
void stampa_errori_pagsca(int riga);
bool controlla_anaCF_Pcon(char tipocf,int gruppo,int conto,long codcf);
bool controlla_anagrafica(char tipo, int gruppo, int conto);
bool cerca_codpag(TString& codpag);
bool cerca_tipopag_codpag(TString& codpag, int tipopag);
bool ulteriore_classificazione(int tipopag, TString& ultclass);
bool banca(long abi,long cab);
bool agente(TString& codag);
bool record_partite(int nriga);
bool record_scadenze(int nriga,int nrata);
void descrizione_pagamento(TString& descr,int tipopag,TString& ultclass,TString& codpag);
void esamina_partite();
void aggiorna_partite();
bool solo_SC(long numreg);
void calcola_imposta(long numreg, real& imposta);
bool calcola_impdocval(long nreg,int nrig,char tipo,int g,int c, long s,int anno,TString& numpart,int nriga,real& doc,real& val);
void calcola_importo(char tipo,int g,int c,long s,int anno,TString& numpart,int nriga);
void aggiorna_partita(real& importo,real& importoval,real& abbuoni,real& diffcam,real& ritenute,TString& sez,TString& sezabb,TString& sezdc);
void azzera_impdocval();
int cerca_anno_solare_esercizio(int codice_esercizio);
bool esiste_rata();
void apri_file_SC();
void chiudi_file_SC();
TLibro_giornale& giornale() { return *_giornale; }
TTransfer_file& trasfer() { return *_trasfer; }
TRic_ListaMov(char ric_auto = '\0',char tipo_lista = '\0');
virtual ~TRic_ListaMov() {}
};
HIDDEN inline TRic_ListaMov& app() { return (TRic_ListaMov&)main_app();}
TRic_ListaMov::TRic_ListaMov(char ric_auto,char tipo_lista):
_ric_auto(toupper(ric_auto)), _tipo_lista(toupper(tipo_lista)), _err(80)
{}
const char* TRic_ListaMov::look_sdt()
{
TConfig conf(CONFIG_DITTA);
return conf.get("FlStTra");
}
bool TRic_ListaMov::look_pag()
{
TTable t ("%CPG");
t.zero();
t.put("CODTAB",_codpag);
if (t.read() != NOERR) return FALSE;
return TRUE;
}
const char* TRic_ListaMov::get_codiva_des(const char* codiva)
{
TTable iva ("%IVA");
iva.zero();
iva.put("CODTAB", codiva);
if (iva.read() == NOERR)
return iva.get("S0");
else
return NULL;
}
bool TRic_ListaMov::DescrConto(int g, int c, long s)
{
TString80 ragsoc;
const char* descr = NULL;
TLocalisamfile pconti (LF_PCON);
pconti.setkey(1);
pconti.zero();
pconti.put(PCN_GRUPPO, g);
pconti.put(PCN_CONTO, c);
pconti.put(PCN_SOTTOCONTO, 0L);
if (pconti.read() == NOERR)
{
_tipo_conto = pconti.get(PCN_TMCF);
if (_tipo_conto == "C" || _tipo_conto == "F")
{
TLocalisamfile clifo (LF_CLIFO);
clifo.setkey(1);
clifo.zero();
clifo.put(CLI_TIPOCF, _tipo_conto);
clifo.put(CLI_CODCF, s);
if (clifo.read() != NOERR)
{
_descr_conto = "";
return FALSE;
}
else
{
char tipoa = clifo.get_char("TIPOAPER");
if (tipoa == 'F') //persona fisica
{
TString80 cognome, nome;
ragsoc = clifo.get("RAGSOC");
cognome = ragsoc.mid(0,30);
nome = ragsoc.mid(30,20);
cognome.trim(); nome.trim();
ragsoc = cognome;
ragsoc << " " << nome;
_descr_conto = ragsoc;
}
else _descr_conto = clifo.get("RAGSOC");
}
}
else
{
pconti.zero();
pconti.put(PCN_GRUPPO, g);
pconti.put(PCN_CONTO, c);
pconti.put(PCN_SOTTOCONTO, s);
if (pconti.read() != NOERR)
{
_descr_conto = "";
return FALSE;
}
else _descr_conto = pconti.get(PCN_DESCR);
}
}
else
{
_descr_conto = "";
return FALSE;
}
return TRUE;
}
bool TRic_ListaMov::user_create()
{
TToken_string exp;
TToken_string exp1;
_trasfer = new TTransfer_file();
_tab_tra = new TTable ("%TRA");
_tab_tpd = new TTable ("%TPD");
_tab_pag = new TTable ("%CPG");
_tab_iva = new TTable ("%IVA");
_tab_ese = new TTable ("ESC");
_caus = new TLocalisamfile (LF_CAUSALI);
_ditte = new TLocalisamfile (LF_NDITTE);
_clifo = new TLocalisamfile (LF_CLIFO);
_pcon = new TLocalisamfile (LF_PCON);
_mov = new TLocalisamfile (LF_MOV);
_rmov = new TLocalisamfile (LF_RMOV);
_rmoviva = new TLocalisamfile (LF_RMOVIVA);
// _part = new TLocalisamfile (LF_PARTITE);
// _scad = new TLocalisamfile (LF_SCADENZE);
// _pagsca = new TLocalisamfile (LF_PAGSCA);
if (_ric_auto != 'A')
{
TProgind* pnd = NULL;
pnd = new TProgind (3,"Controllo archivi\nPrego attendere",FALSE, TRUE, 30);
if (pnd) pnd->addstatus(1);
if (!check_archivi(pnd))
{
delete pnd;
return FALSE;
}
if (pnd) pnd->addstatus(1);
delete pnd;
}
TString80 tmpmov = "%";
tmpmov << get_firm_dir();
tmpmov << "\\" << TEMP_MOV;
TString80 tmprmov = "%";
tmprmov << get_firm_dir();
tmprmov << "\\" << TEMP_RMOV;
TString80 tmprmoviva = "%";
tmprmoviva << get_firm_dir();
tmprmoviva << "\\" << TEMP_RMOVIVA;
_tmov = new TIsamtempfile(LF_MOV, tmpmov, 0);
_trmov = new TIsamtempfile(LF_RMOV, tmprmov, 0);
_is_iva = FALSE;
TString tmp = tmprmoviva.mid(1);
tmp << ".dbf";
if (fexist(tmp))
{
_tiva = new TIsamtempfile(LF_RMOVIVA, tmprmoviva, 0);
_is_iva = TRUE;
}
_rel = new TRelation(_tmov);
_rel->add(_trmov,"NUMREG=NUMREG",1,0,0,FALSE);
if (_is_iva)
_rel->add(_tiva, "NUMREG=NUMREG",1,0,0,FALSE);
_cur = add_cursor(new TCursor (_rel, "", 1)); // Cursore definito sui file dei movimenti contabili e iva
// *************************************************
// *** Parte riguardante il Saldaconto se esiste ***
// *************************************************
TString80 tmppart = "%";
tmppart << get_firm_dir();
tmppart << "\\" << TEMP_PART;
/* TString80 tmpscad = "%";
tmpscad << get_firm_dir();
tmpscad << "\\" << TEMP_SCAD;
TString80 tmppagsca = "%";
tmppagsca << get_firm_dir();
tmppagsca << "\\" << TEMP_PAGSCA;
*/
_is_salda = FALSE;
tmp = tmppart.mid(1);
tmp << ".dbf";
if (fexist(tmp))
{
/* _part = new TLocalisamfile (LF_PARTITE);
_scad = new TLocalisamfile (LF_SCADENZE);
_pagsca = new TLocalisamfile (LF_PAGSCA);
_tpart = new TIsamtempfile(LF_PARTITE, tmppart, 0);
_tscad = new TIsamtempfile(LF_SCADENZE, tmpscad, 0);
_tpagsca = new TIsamtempfile(LF_PAGSCA,tmppagsca, 0); */
_is_salda = TRUE;
/*
_relSC = new TRelation(_tpart);
exp.add("TIPOC=TIPOC");
exp.add("GRUPPO=GRUPPO");
exp.add("CONTO=CONTO");
exp.add("SOTTOCONTO=SOTTOCONTO");
exp.add("ANNO=ANNO");
exp.add("NUMPART=NUMPART");
exp.add("NRIGA=NRIGA");
_relSC->add(_tscad,exp,1,0,0,FALSE);
exp1.add("TIPOC=TIPOC");
exp1.add("GRUPPO=GRUPPO");
exp1.add("CONTO=CONTO");
exp1.add("SOTTOCONTO=SOTTOCONTO");
exp1.add("ANNO=ANNO");
exp1.add("NUMPART=NUMPART");
_relSC->add(_tpagsca,exp1,1,0,0,FALSE);
_curSC = add_cursor(new TCursor (_relSC, "", 1)); // Cursore definito sui movimenti del saldaconto
*/
}
_giornale = new TLibro_giornale();
printer().footerlen(5);
_tipom_cau = "";
_codpag_scad = "";
_risposta = FALSE;
_continua = TRUE;
_intestaSC = FALSE;
_seconda_volta = FALSE;
_errore_grave_SC = FALSE;
_prima_volta = TRUE;
_gruppo_p = -1;
_conto_p = -1;
_codcf_p = -1;
_prima_rata_pag = FALSE;
_numpart_prec = "";
_ho_stampato = FALSE;
return TRUE;
}
void TRic_ListaMov::apri_file_SC()
{
TToken_string exp;
TToken_string exp1;
TString tmp;
// *************************************************
// *** Parte riguardante il Saldaconto se esiste ***
// *************************************************
TString80 tmppart = "%";
tmppart << get_firm_dir();
tmppart << "\\" << TEMP_PART;
TString80 tmpscad = "%";
tmpscad << get_firm_dir();
tmpscad << "\\" << TEMP_SCAD;
TString80 tmppagsca = "%";
tmppagsca << get_firm_dir();
tmppagsca << "\\" << TEMP_PAGSCA;
_is_salda = FALSE;
tmp = tmppart.mid(1);
tmp << ".dbf";
if (fexist(tmp))
{
_part = new TLocalisamfile (LF_PARTITE);
_scad = new TLocalisamfile (LF_SCADENZE);
_pagsca = new TLocalisamfile (LF_PAGSCA);
_tpart = new TIsamtempfile(LF_PARTITE, tmppart, 0);
_tscad = new TIsamtempfile(LF_SCADENZE, tmpscad, 0);
_tpagsca = new TIsamtempfile(LF_PAGSCA,tmppagsca, 0);
_is_salda = TRUE;
_relSC = new TRelation(_tpart);
exp.add("TIPOC=TIPOC");
exp.add("GRUPPO=GRUPPO");
exp.add("CONTO=CONTO");
exp.add("SOTTOCONTO=SOTTOCONTO");
exp.add("ANNO=ANNO");
exp.add("NUMPART==NUMPART");
exp.add("NRIGA=NRIGA");
_relSC->add(_tscad,exp,1,0,0,FALSE);
exp1.add("TIPOC=TIPOC");
exp1.add("GRUPPO=GRUPPO");
exp1.add("CONTO=CONTO");
exp1.add("SOTTOCONTO=SOTTOCONTO");
exp1.add("ANNO=ANNO");
exp1.add("NUMPART==NUMPART");
_relSC->add(_tpagsca,exp1,1,0,0,FALSE);
_curSC = add_cursor(new TCursor (_relSC, "", 1)); // Cursore definito sui movimenti del saldaconto
}
}
bool TRic_ListaMov::check_archivi(TProgind* pnd)
{
TString80 nome;
long ditta_ric = get_firm();
if (!prefix().exist(ditta_ric))
return error_box("Rilevati errori gravi negli archivi: procedura interrotta");
TTransfer_file& tr = trasfer();
_pathfile = tr.path();
_pathfile = _pathfile << HEADER;
if (!tr.open(_pathfile))
return error_box("Al momento non presenti trasferimenti attivi sulla ditta selezionata");
if (!tr.read_control_rec())
return error_box("Rilevati errori gravi negli archivi: procedura interrotta");
else _record = tr.record();
TString16 sd = look_sdt();
if (sd.not_empty())
_sdt = sd[0];
else return error_box("Ricezione tabelle non effettuata: richiamare il programma relativo");
if (_sdt == 'T')
return error_box("Ricezione tabelle non effettuata: richiamare il programma relativo");
if (_sdt == 'M')
return yesno_box("Controllo gia' effettuato: si desidera ripeterlo ?");
if (_sdt != '*' && _sdt != 'C')
return error_box("Rilevati errori gravi negli archivi: procedura interrotta");
TString16 ult = tr.ult_file();
TString16 key = tr.key();
ult.strip_spaces();
key.strip_spaces();
if (_sdt == 'C')
if ( ult.not_empty() || key.not_empty() )
return error_box("Rilevati errori gravi negli archivi: procedura interrotta");
if (_sdt == '*')
{
tr.remove_all();
return warning_box("Trasferimento interamente completato: proseguire per cancellare i file");
}
if (pnd) pnd->addstatus(1);
return TRUE;
}
void TRic_ListaMov::stampa_errori_mov(int riga)
{
long i = _err.first_one();
if (i != -1)
{
for (; i <= _err.last_one(); i++)
if (_err[i])
set_row(++riga, "@8g%s", (const char*) err_msg[i]);
}
}
int TRic_ListaMov::cerca_anno_solare_esercizio(int codice)
{
TTable ese ("ESC");
TDate datafine;
int anno = 0;
TString dep (format("%04d", codice));
ese.zero();
ese.put("CODTAB", dep);
if (ese.read() == NOERR)
datafine = ese.get_date("D1");
if (datafine != botime)
anno = datafine.year();
return anno;
}
bool TRic_ListaMov::controlla_mov()
{
bool check_reg = TRUE;
TString16 causreg;
TDate udata;
char tipocf = ' ';
TTransfer_file& tr = trasfer();
_tiporeg = 0;
if ( !TDate::isdate(_datareg.string()) )
{
_errore_grave = TRUE;
_err.set(0L);
}
TString app (_datacomp.string());
if (app.empty())
tr.datafine_esprec(_anno,_datacomp);
if ( TDate::isdate(_datareg.string()) )
{
int pr;
const int ar = date2esc(_datareg); // Esercizio in corso
pr = _ec.pred(ar); // Esercizio precedente
if (ar == 0)
{
_err.set(1);
_errore_grave = TRUE;
}
if ( TDate::isdate(_datacomp.string()) )
{
const int ae = date2esc(_datacomp);
if (ae == 0)
{
_err.set(3);
_errore_grave = TRUE;
}
else if (ae != ar && ae != pr && ar)
_err.set(4);
}
}
int pp;
_annoese = date2esc(_datacomp); // Esercizio in corso
pp = _ec.pred(_annoese);
if ( !TDate::isdate(_datacomp.string()) )
{
_errore_grave = TRUE;
_err.set(2);
}
TLibro_giornale& gio = giornale();
bool ok = gio.read(_ae); //se _ae e' zero la read considera come anno quello corrente
if (_datareg < gio.last_print())
{
_errore_grave = TRUE;
_err.set(5);
}
TString16 dd = _datadoc.string();
if (dd.not_empty())
if ( !TDate::isdate(_datadoc.string()) )
_err.set(6);
//if (_causale.not_empty())
//{
TLocalisamfile caus(LF_CAUSALI);
caus.setkey(1);
caus.zero();
caus.put(CAU_CODCAUS,_causale);
if (caus.read() == NOERR)
{
_tipodoc = caus.get(CAU_TIPODOC);
if (_is_salda)
_tipom_cau = caus.get(CAU_TIPOMOV);
}
else
{
caus.zero();
if (_causale.not_empty()) //se la causale e' significativa
{
_errore_grave = TRUE;
_err.set(7);
}
}
//_tipodoc = caus.get(CAU_TIPODOC); ho sempre quello letto sul movimento!
causreg = caus.get(CAU_REG);
_descr_causale = caus.get(CAU_DESCR);
_mov_sez = caus.get_bool(CAU_MOVSEZ);
//}
if (!_codpag.blank())
{
bool ok = look_pag();
if (!ok)
_err.set(8);
}
if (!_registro.blank()) //movimento iva (fattura)
{
if (_causale.empty()) //se la causale non e' significativa
{
_errore_grave = TRUE;
check_reg = FALSE;
_err.set(9);
}
if (check_reg && _ae)
{
int anno = cerca_anno_solare_esercizio(_ae);
TRegistro rg (_registro, anno);
if (rg.name().empty())
{
_errore_grave = TRUE;
check_reg = FALSE;
_err.set(9);
}
else
{
_tiporeg = rg.tipo();
udata = rg.last_print();
}
}
}
else if (!causreg.blank() && _ae)
{
int anno = cerca_anno_solare_esercizio(_ae);
TRegistro rg (causreg, anno);
if (rg.name().empty())
{
_errore_grave = TRUE;
check_reg = FALSE;
_err.set(9);
}
else
{
_tiporeg = rg.tipo();
udata = rg.last_print();
}
_registro = causreg;
}
/*
if (!_registro.blank())
{
if (_tiporeg == 1) _tipocf = tipocf = 'C';
else if (_tiporeg == 2) _tipocf = tipocf = 'F';
// if (_tiporeg != 0) //se esiste, uso quello della causale!!!
// {
TTable tabtpd("%TPD");
tabtpd.put("CODTAB", _tipodoc);
if (tabtpd.read() == NOERR)
{
bool cor = tabtpd.get_bool("B0");
if (!cor)
if (_codcf != 0l)
{
TLocalisamfile clifo(LF_CLIFO);
clifo.zero();
clifo.put(CLI_CODCF, _codcf);
clifo.put(CLI_TIPOCF,tipocf);
if (clifo.read() != NOERR)
{
_errore_grave = TRUE;
_err.set(10);
}
}
else
{
_errore_grave = TRUE;
_err.set(10);
}
}
else
{
if (_codcf != 0l)
{
TLocalisamfile clifo(LF_CLIFO);
clifo.zero();
clifo.put(CLI_CODCF, _codcf);
clifo.put(CLI_TIPOCF,tipocf);
if (clifo.read() != NOERR)
{
_errore_grave = TRUE;
_err.set(10);
}
}
else
{
_errore_grave = TRUE;
_err.set(10);
}
}
// }
}
*/
TString16 d74 = _data74tr.string();
if (d74.not_empty())
if ( !TDate::isdate(_data74tr.string()) )
_err.set(11);
if (!_registro.blank() && check_reg)
if (_datareg < udata)
{
_errore_grave = TRUE;
_err.set(12);
}
if (_err.ones())
return TRUE;
return FALSE;
}
bool TRic_ListaMov::errori_partita(int g, int c, long s)
{
TLocalisamfile pconti (LF_PCON);
pconti.setkey(1);
pconti.zero();
pconti.put(PCN_GRUPPO, g);
pconti.put(PCN_CONTO, c);
pconti.put(PCN_SOTTOCONTO, 0L);
if (pconti.read() == NOERR)
{
char tipo = pconti.get(PCN_TMCF)[0];
if (tipo == 'C' || tipo == 'F')
{
TLocalisamfile clifo (LF_CLIFO);
clifo.setkey(1);
clifo.zero();
clifo.put(CLI_TIPOCF, tipo);
clifo.put(CLI_CODCF, s);
if (clifo.read() != NOERR)
return FALSE;
}
else
{
pconti.zero();
pconti.put(PCN_GRUPPO, g);
pconti.put(PCN_CONTO, c);
pconti.put(PCN_SOTTOCONTO, s);
if (pconti.read() != NOERR)
return FALSE;
}
}
else return FALSE;
return TRUE;
}
void TRic_ListaMov::stampa_errori_partite(int riga)
{
long i = _err.first_one();
if (i != -1)
{
for (; i <= _err.last_one(); i++)
if (_err[i])
set_row(++riga, "@22g%s", (const char*) err_msg[i]);
}
}
char TRic_ListaMov::TipoConto(int g, int c)
{
TLocalisamfile pcon (LF_PCON);
char tipo = ' ';
pcon.setkey(1);
pcon.zero();
pcon.put(PCN_GRUPPO, g);
pcon.put(PCN_CONTO, c);
pcon.put(PCN_SOTTOCONTO, 0l);
if (pcon.read() == NOERR)
tipo = pcon.get_char(PCN_TMCF);
return tipo;
}
bool TRic_ListaMov::controlla_rmov()
{
TLocalisamfile& rmov = current_cursor()->file(LF_RMOV);
int gruppo, conto, gruppoc, contoc;
long sottoconto, sottocontoc;
char sezione;
real importo, 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);
sezione = rec.get_char(RMV_SEZIONE);
importo = rec.get_real(RMV_IMPORTO);
_tipo_conto = "";
char tipo = TipoConto(gruppo,conto);
char tipoc = TipoConto(gruppoc,contoc);
aggiorna_rmov(tipo,tipoc);
if (gruppo != 0 && conto != 0 && sottoconto != 0l)
_esiste_conto = DescrConto(gruppo,conto,sottoconto);
else
{
_esiste_conto = FALSE;
_descr_conto = "";
}
//_num_rec = rec.get_long(RMV_ANNOES);
if (sezione == 'D')
dare += importo;
if (sezione == 'A')
avere += importo;
if (gruppo == 0 || conto == 0 || sottoconto == 0l)
{
rmov.readat(nrec);
return TRUE;
}
else
{
bool ok = errori_partita(gruppo,conto,sottoconto);
if (!ok)
{
rmov.readat(nrec);
return TRUE;
}
}
if ( (importo != ZERO && sezione == '\0') ||
(sezione != 'D' && sezione != 'A' && sezione != '\0') )
{
rmov.readat(nrec);
return TRUE;
}
if (gruppoc != 0 || contoc != 0 || sottocontoc != 0l)
{
bool ok = errori_partita(gruppoc,contoc,sottocontoc);
if (!ok)
{
rmov.readat(nrec);
return TRUE;
}
}
if (!_mov_sez && importo == ZERO)
{
rmov.readat(nrec);
return TRUE;
}
}
if (dare != avere)
{
rmov.readat(nrec);
return TRUE;
}
rmov.readat(nrec);
}
return FALSE;
}
void TRic_ListaMov::stampa_errori_rmov(int riga)
{
if (_gruppo == 0 || _conto == 0 || _sottoconto == 0l)
{
_errore_grave = TRUE;
set_row(++riga, "@8g*** Sottoconto partita non valido o non presente in archivio");
}
else
{
if (!_esiste_conto)
{
_errore_grave = TRUE;
set_row(++riga, "@8g*** Sottoconto partita non valido o non presente in archivio");
}
}
if ( (_importo != ZERO && _sezione == '\0') ||
(_sezione != 'D' && _sezione != 'A' && _sezione != '\0') )
{
_errore_grave = TRUE;
set_row(++riga, "@8g*** Segnale dare/avere non valido");
}
if (_sezione == 'D')
_tot_dare += _importo;
if (_sezione == 'A')
_tot_avere += _importo;
if (_gruppoc != 0 || _contoc != 0 || _sottocontoc != 0l)
// set_row(++riga, "@8g*** Sottoconto contropartita non valido o non presente in archivio");
// else
{
bool ok = errori_partita(_gruppoc,_contoc,_sottocontoc);
if (!ok)
set_row(++riga, "@8g--- Sottoconto contropartita non valido o non presente in archivio");
}
if (!_mov_sez && _importo == ZERO)
set_row(++riga, "@8g--- Importo riga uguale a zero");
}
bool TRic_ListaMov::controlla_riva()
{
TLocalisamfile& rmoviva = current_cursor()->file(LF_RMOVIVA);
TTable tab_iva("%IVA");
TString16 codiva;
int tipodet, tipocr, gruppocr, contocr;
long sottocontocr;
real impo, impos;
bool testata = TRUE;
bool no_grave = FALSE;
if (current_cursor()->is_first_match(LF_RMOVIVA))
{
TRecnotype nrec = rmoviva.recno();
rmoviva.setkey(1);
rmoviva.zero();
rmoviva.put(RMI_NUMREG, _numero);
TRectype recc (rmoviva.curr());
for (rmoviva.read(_isgteq); !rmoviva.eof() ;rmoviva.next())
{
TRectype rec (rmoviva.curr());
if (rec > recc) break;
//_n_rec = rec.get_int(RMI_ANNOES);
codiva = rec.get(RMI_CODIVA);
tipodet = rec.get_int(RMI_TIPODET);
tipocr = rec.get_int(RMI_TIPOCR);
gruppocr = rec.get_int(RMI_GRUPPO);
contocr = rec.get_int(RMI_CONTO);
sottocontocr = rec.get_long(RMI_SOTTOCONTO);
impo = rec.get_real(RMI_IMPONIBILE);
impos = rec.get_real(RMI_IMPOSTA);
if (testata)
{
char tipocf = ' ';
if (!_registro.blank())
{
if (_tiporeg == 1) _tipocf = tipocf = 'C';
else if (_tiporeg == 2) _tipocf = tipocf = 'F';
TTable tabtpd("%TPD");
tabtpd.put("CODTAB", _tipodoc);
if (tabtpd.read() == NOERR)
{
bool cor = tabtpd.get_bool("B0");
if (!cor)
if (_codcf != 0l)
{
TLocalisamfile clifo(LF_CLIFO);
clifo.zero();
clifo.put(CLI_CODCF, _codcf);
clifo.put(CLI_TIPOCF,tipocf);
if (clifo.read() != NOERR)
{
_errore_grave = TRUE;
_err.set(10);
}
}
else
{
_errore_grave = TRUE;
_err.set(10);
}
}
else
{
if (_codcf != 0l)
{
TLocalisamfile clifo(LF_CLIFO);
clifo.zero();
clifo.put(CLI_CODCF, _codcf);
clifo.put(CLI_TIPOCF,tipocf);
if (clifo.read() != NOERR)
{
_errore_grave = TRUE;
_err.set(10);
}
}
else
{
_errore_grave = TRUE;
_err.set(10);
}
}
}
testata = FALSE;
}
TString impostr = impo.string();
TString impostastr = impos.string();
_tot_doc += impo + impos;
TString totdocstr = _tot_doc.string();
_impo = impo;
_impos = impos;
char tipo = TipoConto(gruppocr,contocr);
aggiorna_iva(tipo);
if (!_tipodoc.blank())
{
TTable tabtpd("%TPD");
tabtpd.put("CODTAB", _tipodoc);
if (tabtpd.read() == NOERR)
{
bool cor = tabtpd.get_bool("B0");
if (cor)
{
_impo = impo + impos;
_impos = ZERO;
}
}
}
TTable iva ("%IVA");
iva.zero();
iva.put("CODTAB", codiva);
if (iva.read() != NOERR)
{
no_grave = TRUE;
// rmoviva.readat(nrec);
// return TRUE;
}
if ( tipocr != 0 && tipocr != 1 && tipocr != 2 && tipocr != 3 &&
tipocr != 4 && tipocr != 5 && tipocr != 8 && tipocr != 9 )
{
no_grave = TRUE;
// rmoviva.readat(nrec);
// return TRUE;
}
if (gruppocr == 0 || contocr == 0 || sottocontocr == 0l)
{
no_grave = TRUE;
// rmoviva.readat(nrec);
// return TRUE;
}
else if (gruppocr != 0 && contocr != 0 && sottocontocr != 0l)
{
bool ok = errori_partita(gruppocr,contocr,sottocontocr);
if (!ok)
{
no_grave = TRUE;
// rmoviva.readat(nrec);
// return TRUE;
}
}
if (tipodet != 0 && tipodet != 1 && tipodet != 3 && tipodet != 9)
{
no_grave = TRUE;
// rmoviva.readat(nrec);
// return TRUE;
}
}
if (no_grave)
{
rmoviva.readat(nrec);
return TRUE;
}
rmoviva.readat(nrec);
}
return FALSE;
}
void TRic_ListaMov::stampa_errori_riva(int riga)
{
TTable iva ("%IVA");
iva.zero();
iva.put("CODTAB", _codiva);
if (iva.read() != NOERR)
set_row(++riga, "@8g--- Codice IVA non valido o non presente in tabella");
if ( _tipocr != 0 && _tipocr != 1 && _tipocr != 2 && _tipocr != 3 &&
_tipocr != 4 && _tipocr != 5 && _tipocr != 8 && _tipocr != 9 )
set_row(++riga, "@8g--- Tipo costo/ricavo non valido");
if (_gruppocr == 0 || _contocr == 0 || _sottocontocr == 0l)
set_row(++riga, "@8g--- Sottoconto costo/ricavo non valido o non presente in archivio");
else if (_gruppocr != 0 && _contocr != 0 && _sottocontocr != 0l)
{
bool ok = errori_partita(_gruppocr,_contocr,_sottocontocr);
if (!ok)
set_row(++riga, "@8g--- Sottoconto costo/ricavo non valido o non presente in archivio");
}
if (_tipod != 0 && _tipod != 1 && _tipod != 3 && _tipod != 9)
set_row(++riga, "@8g--- Tipo indetraibilita' non valido");
}
bool TRic_ListaMov::controlla_anaCF_Pcon(char tipocf,int gruppo,int conto,long codcf)
{
if (codcf == 0)
return TRUE;
if (tipocf == 'C' || tipocf == 'F')
{
TLocalisamfile clifo (LF_CLIFO);
clifo.setkey(1);
clifo.zero();
clifo.put(CLI_TIPOCF, tipocf);
clifo.put(CLI_CODCF, codcf);
if (clifo.read() == NOERR)
{
TString descr = clifo.get(CLI_RAGSOC);
TString app1 = descr.mid(0,30);
app1.trim();
TString app2 = descr.mid(30,20);
app2.trim();
_descr_anag = app1 << " " << app2;
return TRUE;
}
else
{
_descr_anag = "";
return FALSE;
}
}
else
{
TLocalisamfile pcon (LF_PCON);
pcon.setkey(1);
pcon.zero();
pcon.put(PCN_GRUPPO, gruppo);
pcon.put(PCN_CONTO, conto);
pcon.put(PCN_SOTTOCONTO, codcf);
if (pcon.read() == NOERR)
{
_descr_anag = pcon.get(PCN_DESCR);
return TRUE;
}
else
{
_descr_anag = "";
return FALSE;
}
}
return TRUE;
}
bool TRic_ListaMov::controlla_anagrafica(char tipo, int gruppo, int conto)
{
TLocalisamfile pcon (LF_PCON);
pcon.setkey(1);
pcon.zero();
pcon.put(PCN_GRUPPO, gruppo);
pcon.put(PCN_CONTO, conto);
pcon.read();
if (pcon.get_int(PCN_GRUPPO) == gruppo && pcon.get_int(PCN_CONTO) == conto)
if (pcon.get_char(PCN_TMCF) == tipo)
return TRUE;
return FALSE;
}
bool TRic_ListaMov::esiste_rata()
{
TLocalisamfile& scad = current_cursor()->file(LF_SCADENZE);
TRecnotype record = scad.recno();
scad.zero();
scad.put(SCAD_TIPOCF, _tipocf);
if (_gruppo != 0)
scad.put(SCAD_GRUPPO, _gruppo);
if (_conto != 0)
scad.put(SCAD_CONTO, _conto);
if (_codcf != 0)
scad.put(SCAD_SOTTOCONTO, _codcf);
scad.put(SCAD_ANNO, _anno);
scad.put(SCAD_NUMPART, _numpart);
scad.put(SCAD_NRIGA, _nriga);
TRectype recscad (scad.curr());
for (scad.read(_isgteq); !scad.eof(); scad.next())
{
TString rec = recscad.get(SCAD_NUMPART);
TString file = scad.get(SCAD_NUMPART);
if (scad.curr() != recscad || file != rec) break;
return TRUE;
}
scad.readat(record);
return FALSE;
}
bool TRic_ListaMov::controlla_partite()
{
if (_tipocf != 'C' && _tipocf != 'F' && _tipocf != '\0')
{
_errore_grave_SC = TRUE;
_err.set(13);
}
if (!controlla_anaCF_Pcon(_tipocf,_gruppo,_conto,_codcf))
{
_errore_grave_SC = TRUE;
_err.set(14);
}
if (_anno == 0 || _numpart.empty() || _nriga == 0)
{
_errore_grave_SC = TRUE;
_err.set(15);
}
if ( !TDate::isdate(_datareg.string()) )
{
_errore_grave_SC = TRUE;
_err.set(0L);
}
TString16 dd = _datadoc.string();
if (dd.not_empty())
if ( !TDate::isdate(_datadoc.string()) )
_err.set(6);
if (_causale.empty())
{
_descr_causale = "";
if (_numreg != 0)
{
_errore_grave_SC = TRUE;
_err.set(7);
}
}
else
{
TLocalisamfile caus(LF_CAUSALI);
caus.setkey(1);
caus.zero();
caus.put(CAU_CODCAUS,_causale);
if (caus.read() != NOERR)
{
caus.zero();
_errore_grave_SC = TRUE;
_err.set(7);
}
_descr_causale = caus.get(CAU_DESCR);
int tipomov_caus = caus.get_int(CAU_TIPOMOV);
if (_tipomov != tipomov_caus)
{
_errore_grave_SC = TRUE;
_err.set(39);
}
}
if (_codval.not_empty())
{
TTable val ("%VAL");
TString dep (format("%-3s", (const char*) _codval));
val.zero();
val.put("CODTAB", dep);
if (val.read() != NOERR)
{
_errore_grave_SC = TRUE;
_err.set(38);
}
if (_cambio == ZERO)
{
_errore_grave_SC = TRUE;
_err.set(21);
}
TString16 dcam = _datacam.string();
if (dcam.empty() || !TDate::isdate(_datacam.string()) )
_err.set(17);
}
if (_tipomov != 1)
{
if (esiste_rata())
{
if (_tipopag < 1 || _tipopag > 9)
{
_errore_grave_SC = TRUE;
_err.set(19);
}
TString datapag_str = _datapag.string();
if ( datapag_str.empty() || !TDate::isdate(_datapag.string()) )
{
_errore_grave_SC = TRUE;
_err.set(18);
}
}
}
if (_gruppocl != 0 && _contocl != 0)
{
if (!controlla_anagrafica(_tipocf,_gruppocl,_contocl))
{
_errore_grave_SC = TRUE;
_err.set(22);
}
}
if (_sez != 'D' && _sez != 'A')
{
_errore_grave_SC = TRUE;
_err.set(20);
}
if (_err.ones())
return TRUE;
return FALSE;
}
bool TRic_ListaMov::cerca_codpag(TString& codpag)
{
TTable cpg ("%CPG");
_descr_pag = "";
cpg.zero();
cpg.put("CODTAB", codpag);
if (cpg.read() == NOERR)
{
_descr_pag = cpg.get("S0");
// _tipopag_pag = atoi(cpg.get("S4"));
return TRUE;
}
return FALSE;
}
bool TRic_ListaMov::cerca_tipopag_codpag(TString& codpag, int tipopag)
{
TTable rpg ("%RPG");
TString dep;
for (int i = 0; !rpg.eof(); rpg.next(), i++)
{
dep.format("%-s%3d", (const char*) codpag, i);
rpg.zero();
rpg.put("CODTAB", dep);
if (rpg.read() == NOERR)
{
int tipo = rpg.get_int("I1");
if (tipo == tipopag)
{
_tipopag_pag = tipo;
return TRUE;
}
}
else
return FALSE;
}
return FALSE;
}
bool TRic_ListaMov::ulteriore_classificazione(int tipopag, TString& ultclass)
{
TTable clr ("%CLR");
TString dep (format("%d%s", tipopag, (const char*) ultclass));
clr.zero();
clr.put("CODTAB", dep);
if (clr.read() == NOERR)
return TRUE;
return FALSE;
}
bool TRic_ListaMov::banca(long abi,long cab)
{
if (abi == 0 && cab == 0)
return TRUE;
TTable ban ("%BAN");
TString dep;
if (abi != 0 && cab != 0)
dep.format("%05ld%05ld", abi,cab);
if (abi != 0 && cab == 0)
dep.format("%05ld", abi);
ban.zero();
ban.put("CODTAB", dep);
if (ban.read() == NOERR)
return TRUE;
return FALSE;
}
bool TRic_ListaMov::agente(TString& codag)
{
if (codag == "")
return TRUE;
TTable ag ("%AGE");
TString dep;
dep.format("%5s", (const char*) codag);
ag.zero();
ag.put("CODTAB", dep);
if (ag.read() == NOERR)
return TRUE;
return FALSE;
}
bool TRic_ListaMov::controlla_scadenze()
{
int tipopag,nrata;
TString codpag,ultclass,codag;
TDate datascad,datasoll;
real importo,importoval;
long abins,cabns,abivs,cabvs;
importo = ZERO;
importoval = ZERO;
TLocalisamfile& scad = current_cursor()->file(LF_SCADENZE);
if (current_cursor()->is_first_match(LF_SCADENZE))
{
TRecnotype nrec = scad.recno();
scad.zero();
scad.setkey(1);
scad.put(SCAD_TIPOCF, _tipocf);
if (_gruppo != 0)
scad.put(SCAD_GRUPPO, _gruppo);
if (_conto != 0)
scad.put(SCAD_CONTO, _conto);
if (_codcf != 0)
scad.put(SCAD_SOTTOCONTO, _codcf);
scad.put(SCAD_ANNO, _anno);
scad.put(SCAD_NUMPART, _numpart);
scad.put(SCAD_NRIGA, _nriga);
TRectype recc (scad.curr());
for (scad.read(_isgteq); !scad.eof() ;scad.next())
{
TRectype rec (scad.curr());
TString filea = recc.get(SCAD_NUMPART);
TString file = rec.get(SCAD_NUMPART);
if (rec != recc || file != filea) break;
nrata = rec.get_int (SCAD_NRATA);
tipopag = rec.get_int (SCAD_TIPOPAG);
codpag = rec.get (SCAD_CODPAG);
ultclass = rec.get (SCAD_ULTCLASS);
datascad = rec.get_date(SCAD_DATASCAD);
datasoll = rec.get_date(SCAD_DATASOLL);
importo = rec.get_real(SCAD_IMPORTO);
importoval = rec.get_real(SCAD_IMPORTOVAL);
abins = rec.get_long(SCAD_CODABIPR);
cabns = rec.get_long(SCAD_CODCABPR);
abivs = rec.get_long(SCAD_CODABI);
cabvs = rec.get_long(SCAD_CODCAB);
codag = rec.get (SCAD_CODAG);
if (nrata == 0)
{
scad.readat(nrec);
return TRUE;
}
if ( !TDate::isdate(datascad.string()) )
{
scad.readat(nrec);
return TRUE;
}
if (codpag.not_empty()) // Modifica 01-10-96 chiesta da Patrizia: se il codice di
{ // pagamento non e' significativo non va controllato,
if (!cerca_codpag(codpag)) // altrimenti si presenta l'errore su quelle partite
{ // generate in automatico dove non e' possibile indicare
scad.readat(nrec); // il codice di pagamento.
return TRUE;
}
if (tipopag < 1 || tipopag > 9)
{
scad.readat(nrec);
return TRUE;
}
cerca_tipopag_codpag(codpag,tipopag);
if (tipopag != _tipopag_pag)
{
scad.readat(nrec);
return TRUE;
}
}
if (ultclass.not_empty())
{
if (!ulteriore_classificazione(tipopag,ultclass))
{
scad.readat(nrec);
return TRUE;
}
}
if (importo == ZERO)
{
scad.readat(nrec);
return TRUE;
}
if (_codval.not_empty() && importoval == ZERO)
{
scad.readat(nrec);
return TRUE;
}
if (!banca(abins,cabns))
{
scad.readat(nrec);
return TRUE;
}
if (!banca(abivs,cabvs))
{
scad.readat(nrec);
return TRUE;
}
if (!agente(codag))
{
scad.readat(nrec);
return TRUE;
}
TString datasoll_str = datasoll.string();
if ( datasoll_str.not_empty() && !TDate::isdate(datasoll.string()) )
{
scad.readat(nrec);
return TRUE;
}
}
scad.readat(nrec);
}
return FALSE;
}
void TRic_ListaMov::descrizione_pagamento(TString& descr,int tipopag,TString& ultclass,TString& codpag)
{
TString dep;
if (ultclass.not_empty())
{
TTable clr ("%CLR");
dep.format("%d%s", tipopag,(const char*) ultclass);
clr.zero();
clr.put("CODTAB", dep);
if (clr.read() == NOERR)
descr = clr.get("S0");
else
descr = "";
}
else
{
TTable rpg ("%RPG");
int tipo;
for (int i = 0; !rpg.eof(); rpg.next(), i++)
{
dep.format("%-s%3d", (const char*) codpag, i);
rpg.zero();
rpg.put("CODTAB", dep);
if (rpg.read() == NOERR)
{
tipo = rpg.get_int("I1");
if (tipo == tipopag)
{
switch(tipo)
{
case 1: descr = "Rimessa diretta";
break;
case 2: descr = "Tratta";
break;
case 3: descr = "Ricevuta bancaria";
break;
case 4: descr = "Cessione";
break;
case 5: descr = "Paghero'";
break;
case 6: descr = "Lettera di credito";
break;
case 7: descr = "Tratta accettata";
break;
case 8: descr = "Rapporti interbancari diretti";
break;
case 9: descr = "Bonifico";
break;
case 10: descr = "Altro";
break;
default: break;
};
break;
}
}
else
{
descr = "";
break;
}
}
}
}
void TRic_ListaMov::stampa_errori_scadenze(int riga)
{
TCursor* cur = current_cursor();
TString numpart = cur->curr(LF_SCADENZE).get (SCAD_NUMPART);
int nriga = cur->curr(LF_SCADENZE).get_int (SCAD_NRIGA);
int nrata = cur->curr(LF_SCADENZE).get_int (SCAD_NRATA);
int tipopag = cur->curr(LF_SCADENZE).get_int (SCAD_TIPOPAG);
TString codpag = cur->curr(LF_SCADENZE).get (SCAD_CODPAG);
TString ultclass = cur->curr(LF_SCADENZE).get (SCAD_ULTCLASS);
TDate datascad = cur->curr(LF_SCADENZE).get_date(SCAD_DATASCAD);
TDate datasoll = cur->curr(LF_SCADENZE).get_date(SCAD_DATASOLL);
real importo = cur->curr(LF_SCADENZE).get_real(SCAD_IMPORTO);
real importoval = cur->curr(LF_SCADENZE).get_real(SCAD_IMPORTOVAL);
long abins = cur->curr(LF_SCADENZE).get_long(SCAD_CODABIPR);
long cabns = cur->curr(LF_SCADENZE).get_long(SCAD_CODCABPR);
long abivs = cur->curr(LF_SCADENZE).get_long(SCAD_CODABI);
long cabvs = cur->curr(LF_SCADENZE).get_long(SCAD_CODCAB);
TString codag = cur->curr(LF_SCADENZE).get (SCAD_CODAG);
TString descr_pagamento;
descrizione_pagamento(descr_pagamento,tipopag,ultclass,codpag);
if (_prima_rata_pag)
{
set_row(riga,"@26gN.rata Data scad. Sez Importo Importo valuta");
set_row(riga++,"@88gCond.pagamento Nostra banca Vostra banca Agente");
_prima_rata_pag = FALSE;
}
set_row(riga,"@27g%4d", nrata);
set_row(riga,"@38g%10s", (const char*) datascad.string());
set_row(riga,"@51g%c", _sez);
set_row(riga,"@55g%r", &importo);
if (importoval != ZERO)
set_row(riga,"@71g%15s", importoval.string("###.###.###,@@@"));
set_row(riga,"@88g%-4s", (const char*) codpag);
set_row(riga,"@92g/@93g%d", tipopag);
set_row(riga,"@94g/@95g%s", (const char*) ultclass);
set_row(riga,"@100g%-50s", (const char*) descr_pagamento);
if (abins != 0)
set_row(riga,"@158g%ld", abins);
if (cabns != 0)
set_row(riga,"@165g%ld", cabns);
if (abivs != 0)
set_row(riga,"@172g%ld", abivs);
if (cabvs != 0)
set_row(riga,"@179g%ld", cabvs);
set_row(riga,"@189g%-5s", (const char*) codag);
if (nrata == 0)
{
_errore_grave_SC = TRUE;
set_row(++riga, "@30g%s", (const char*) err_msg[23]);
}
if ( !TDate::isdate(datascad.string()) )
{
_errore_grave_SC = TRUE;
set_row(++riga, "@30g%s", (const char*) err_msg[24]);
}
if (codpag.not_empty()) // Modifica 01-10-96 chiesta da Patrizia: per spiegazione vedi
{ // funzione controlla_scadenze();
if (!cerca_codpag(codpag))
{
_errore_grave_SC = TRUE;
set_row(++riga, "@30g*** Codice pagamento non valido o non presente in tabella");
}
if (tipopag < 1 || tipopag > 9)
{
_errore_grave_SC = TRUE;
set_row(++riga, "@30g%s", (const char*) err_msg[19]);
}
cerca_tipopag_codpag(codpag,tipopag);
if (tipopag != _tipopag_pag)
{
_errore_grave_SC = TRUE;
set_row(++riga, "@30g%s", (const char*) err_msg[40]);
}
}
if (ultclass.not_empty())
{
if (!ulteriore_classificazione(tipopag,ultclass))
set_row(++riga, "@30g%s", (const char*) err_msg[25]);
}
if (importo == ZERO)
{
_errore_grave_SC = TRUE;
set_row(++riga, "@30g%s", (const char*) err_msg[26]);
}
if (_codval.not_empty() && importoval == ZERO)
{
_errore_grave_SC = TRUE;
set_row(++riga, "@30g%s", (const char*) err_msg[27]);
}
if (!banca(abins,cabns))
set_row(++riga, "@30g%s", (const char*) err_msg[28]);
if (!banca(abivs,cabvs))
set_row(++riga, "@30g%s", (const char*) err_msg[29]);
if (!agente(codag))
set_row(++riga, "@30g%s", (const char*) err_msg[30]);
TString datasoll_str = datasoll.string();
if ( datasoll_str.not_empty() && !TDate::isdate(datasoll.string()) )
set_row(++riga, "@30g%s", (const char*) err_msg[31]);
}
bool TRic_ListaMov::record_partite(int nriga)
{
bool ok = FALSE;
for (int p = 0; p < 2 && !ok; p++)
{
TLocalisamfile* fpart = p == 0 ? _tpart : _part;
TLocalisamfile& part = *fpart;
const TRecnotype nrec = part.recno();
part.zero();
part.put(PART_TIPOCF, _tipocf);
part.put(PART_GRUPPO, _gruppo);
part.put(PART_CONTO, _conto);
part.put(PART_SOTTOCONTO, _codcf);
part.put(PART_ANNO, _anno);
part.put(PART_NUMPART, _numpart);
part.put(PART_NRIGA, nriga);
ok = part.read() == NOERR;
part.readat(nrec);
}
return ok;
}
bool TRic_ListaMov::record_scadenze(int nrigp,int nrata)
{
bool ok = FALSE;
for (int p = 0; p < 2 && !ok; p++)
{
TLocalisamfile* fscad = p == 0 ? _tscad : _scad;
TLocalisamfile& scad = *fscad;
const TRecnotype nrec = scad.recno();
scad.zero();
scad.put(SCAD_TIPOCF, _tipocf);
scad.put(SCAD_GRUPPO, _gruppo);
scad.put(SCAD_CONTO, _conto);
scad.put(SCAD_SOTTOCONTO, _codcf);
scad.put(SCAD_ANNO, _anno);
scad.put(SCAD_NUMPART, _numpart);
scad.put(SCAD_NRIGA, nrigp);
scad.put(SCAD_NRATA, nrata);
ok = scad.read() == NOERR;
scad.readat(nrec);
}
return ok;
}
bool TRic_ListaMov::controlla_pagsca()
{
char tipoc,accsaldo,passat;
int nriga,nrata,gruppoc,contoc;
TString codag;
real importo,importoval,abbuoni;
long abins,cabns,abivs,cabvs,sottocc;
bool errore_non_grave = FALSE;
importo = ZERO;
importoval = ZERO;
TLocalisamfile& pagsca = current_cursor()->file(LF_PAGSCA);
if (current_cursor()->is_first_match(LF_PAGSCA))
{
TRecnotype nrec = pagsca.recno();
pagsca.zero();
pagsca.setkey(1);
pagsca.put(PAGSCA_TIPOC, _tipocf);
if (_gruppo != 0)
pagsca.put(PAGSCA_GRUPPO, _gruppo);
if (_conto != 0)
pagsca.put(PAGSCA_CONTO, _conto);
if (_codcf != 0)
pagsca.put(PAGSCA_SOTTOCONTO, _codcf);
pagsca.put(PAGSCA_ANNO, _anno);
pagsca.put(PAGSCA_NUMPART, _numpart);
TRectype recc (pagsca.curr());
for (pagsca.read(_isgteq); !pagsca.eof() ;pagsca.next())
{
int nrigp = pagsca.get_int(PAGSCA_NRIGP);
TRectype rec (pagsca.curr());
TString filea = recc.get(PAGSCA_NUMPART);
TString file = rec.get(PAGSCA_NUMPART);
if (rec != recc || file != filea) break;
if (nrigp != _nriga) continue;
nriga = rec.get_int (PAGSCA_NRIGA);
nrata = rec.get_int (PAGSCA_NRATA);
accsaldo = rec.get_char(PAGSCA_ACCSAL);
importo = rec.get_real(PAGSCA_IMPORTO);
importoval = rec.get_real(PAGSCA_IMPORTOVAL);
abbuoni = rec.get_real(PAGSCA_ABBUONI);
passat = rec.get_char(PAGSCA_PASSATT);
abins = rec.get_long(PAGSCA_CODABIPR);
cabns = rec.get_long(PAGSCA_CODCABPR);
abivs = rec.get_long(PAGSCA_CODABI);
cabvs = rec.get_long(PAGSCA_CODCAB);
codag = rec.get (PAGSCA_CODAG);
tipoc = rec.get_char(PAGSCA_TIPOCC);
gruppoc = rec.get_int (PAGSCA_GRUPPOC);
contoc = rec.get_int (PAGSCA_CONTOC);
sottocc = rec.get_long(PAGSCA_SOTTOCONTC);
if (nriga != 9999)
{
if (!record_partite(nriga))
{
pagsca.readat(nrec);
return TRUE;
}
}
if (nrata != 9999)
{
if (!record_scadenze(nriga,nrata))
{
pagsca.readat(nrec);
return TRUE;
}
}
if (accsaldo != 'A' && accsaldo != 'S')
{
pagsca.readat(nrec);
return TRUE;
}
if (importo == ZERO)
{
pagsca.readat(nrec);
return TRUE;
}
if (_codval.not_empty() && importoval == ZERO)
{
pagsca.readat(nrec);
return TRUE;
}
if (abbuoni != ZERO && (passat != 'A' && passat != 'P') )
{
pagsca.readat(nrec);
return TRUE;
}
if (!banca(abins,cabns))
errore_non_grave = TRUE;
if (!banca(abivs,cabvs))
errore_non_grave = TRUE;
if (!agente(codag))
errore_non_grave = TRUE;
if (!controlla_anaCF_Pcon(tipoc,gruppoc,contoc,sottocc))
errore_non_grave = TRUE;
}
pagsca.readat(nrec);
if (errore_non_grave )
return TRUE;
}
return FALSE;
}
void TRic_ListaMov::stampa_errori_pagsca(int riga)
{
TCursor* cur = current_cursor();
int nrigp = cur->curr(LF_PAGSCA).get_int (PAGSCA_NRIGP);
if (nrigp == _nriga)
{
int nriga = cur->curr(LF_PAGSCA).get_int (PAGSCA_NRIGA);
int nrata = cur->curr(LF_PAGSCA).get_int (PAGSCA_NRATA);
char accsaldo = cur->curr(LF_PAGSCA).get_char(PAGSCA_ACCSAL);
real importo = cur->curr(LF_PAGSCA).get_real(PAGSCA_IMPORTO);
real importoval = cur->curr(LF_PAGSCA).get_real(PAGSCA_IMPORTOVAL);
real abbuoni = cur->curr(LF_PAGSCA).get_real(PAGSCA_ABBUONI);
real ritenute = cur->curr(LF_PAGSCA).get_real(PAGSCA_RITENUTE);
real diffcam = cur->curr(LF_PAGSCA).get_real(PAGSCA_DIFFCAM);
char passat = cur->curr(LF_PAGSCA).get_char(PAGSCA_PASSATT);
long abins = cur->curr(LF_PAGSCA).get_long(PAGSCA_CODABIPR);
long cabns = cur->curr(LF_PAGSCA).get_long(PAGSCA_CODCABPR);
long abivs = cur->curr(LF_PAGSCA).get_long(PAGSCA_CODABI);
long cabvs = cur->curr(LF_PAGSCA).get_long(PAGSCA_CODCAB);
TString codag = cur->curr(LF_PAGSCA).get (PAGSCA_CODAG);
char tipoc = cur->curr(LF_PAGSCA).get_char(PAGSCA_TIPOCC);
int gruppoc = cur->curr(LF_PAGSCA).get_int (PAGSCA_GRUPPOC);
int contoc = cur->curr(LF_PAGSCA).get_int (PAGSCA_CONTOC);
long sottocc = cur->curr(LF_PAGSCA).get_long(PAGSCA_SOTTOCONTC);
controlla_anaCF_Pcon(tipoc,gruppoc,contoc,sottocc);
if (_prima_rata_pag)
{
set_row(riga,"@22gRif. rata acc./saldo Sez Importo Importo valuta Contropartita");
set_row(riga++,"@158gNostra banca Vostra banca Agente");
_prima_rata_pag = FALSE;
}
else
set_row(riga++, "");
set_row(riga,"@22g%4d", nriga);
set_row(riga,"@26g/@27g%4d", nrata);
set_row(riga,"@42g%c", accsaldo);
set_row(riga,"@51g%c", _sez);
set_row(riga,"@55g%r", &importo);
if (importoval != ZERO)
set_row(riga,"@71g%15s", (const char*) importoval.string("###.###.###,@@@"));
set_row(riga,"@88g%c", tipoc);
if (gruppoc != 0)
set_row(riga,"@90g%3d", gruppoc);
if (contoc != 0)
set_row(riga,"@94g%3d", contoc);
if (sottocc != 0)
{
set_row(riga,"@98g%6ld", sottocc);
set_row(riga,"@105g%-50s", (const char*) _descr_anag);
}
if (abins != 0)
set_row(riga,"@158g%ld", abins);
if (cabns != 0)
set_row(riga,"@165g%ld", cabns);
if (abivs != 0)
set_row(riga,"@172g%ld", abivs);
if (cabvs != 0)
set_row(riga,"@179g%ld", cabvs);
set_row(riga,"@189g%-5s", (const char*) codag);
if (ritenute != ZERO)
{
riga++;
set_row(riga,"@51g%c", _sez);
set_row(riga,"@55g%r", &ritenute);
set_row(riga,"@88gRitenute professionali");
}
if (abbuoni != ZERO)
{
riga++;
char sezione;
if (passat == 'A')
sezione = 'D';
else
if (passat == 'P')
sezione = 'A';
if (sezione != _sez)
abbuoni = abbuoni * -1;
set_row(riga,"@51g%c", sezione);
if (_codval.not_empty())
set_row(riga,"@71g%15s", (const char*) abbuoni.string("###.###.###,@@@"));
else
set_row(riga,"@55g%r", &abbuoni);
if (passat == 'A')
set_row(riga,"@88gAbbuoni attivi");
else
if (passat == 'P')
set_row(riga,"@88gAbbuoni passivi");
}
if (diffcam != ZERO)
{
riga++;
char sezione = _sez;
if (diffcam < ZERO)
{
diffcam = diffcam * -1;
if (_sez == 'D')
sezione = 'A';
else
if (_sez == 'A')
sezione = 'D';
}
set_row(riga,"@51g%c", sezione);
set_row(riga,"@55g%r", &diffcam);
set_row(riga,"@88gDifferenza cambio");
}
if (nriga != 9999)
{
if (!record_partite(nriga))
{
_errore_grave_SC = TRUE;
set_row(++riga, "@30g%s", (const char*)err_msg[32]);
}
}
if (nrata != 9999)
{
if (!record_scadenze(nriga,nrata))
{
_errore_grave_SC = TRUE;
set_row(++riga, "@30g%s", (const char*)err_msg[33]);
}
}
if (accsaldo != 'A' && accsaldo != 'S')
{
_errore_grave_SC = TRUE;
set_row(++riga, "@30g%s", (const char*) err_msg[34]);
}
if (importo == ZERO)
{
_errore_grave_SC = TRUE;
set_row(++riga, "@30g%s", (const char*) err_msg[35]);
}
if (_codval.not_empty() && importoval == ZERO)
{
_errore_grave_SC = TRUE;
set_row(++riga, "@30g%s", (const char*) err_msg[36]);
}
if (abbuoni != ZERO && (passat != 'A' && passat != 'P') )
{
_errore_grave_SC = TRUE;
set_row(++riga, "@30g%s", (const char*) err_msg[37]);
}
if (!banca(abins,cabns))
set_row(++riga, "@30g%s", (const char*) err_msg[28]);
if (!banca(abivs,cabvs))
set_row(++riga, "@30g%s", (const char*) err_msg[29]);
if (!agente(codag))
set_row(++riga, "@30g%s", (const char*) err_msg[30]);
if (!controlla_anaCF_Pcon(tipoc,gruppoc,contoc,sottocc))
set_row(++riga, "@30g--- Codice contropartita errato");
}
}
void TRic_ListaMov::azzera_impdocval()
{
TRecnotype recn = _tpart->recno();
TIsamtempfile& part = *_tpart;
part.setkey(1);
part.zero();
for (part.first(); !part.eof(); part.next())
{
int tipomov = part.get_int(PART_TIPOMOV);
if (tipomov != 1 && tipomov != 4)
{
part.zero(PART_IMPTOTDOC);
part.zero(PART_IMPTOTVAL);
part.rewrite();
}
}
_tpart->readat(recn);
}
bool TRic_ListaMov::preprocess_print(int file, int counter)
{
if (file == LF_PARTITE)
azzera_impdocval();
return TRUE;
}
bool TRic_ListaMov::preprocess_page(int file,int counter)
{
TCursor* cur = current_cursor();
if (counter) return TRUE;
reset_print();
if (file == LF_MOV)
{
_anno = cur->curr(LF_MOV).get_int(MOV_ANNOES);
_datacomp = cur->curr(LF_MOV).get_date(MOV_DATACOMP);
_datadoc = cur->curr(LF_MOV).get_date(MOV_DATADOC);
_data74tr = cur->curr(LF_MOV).get_date(MOV_DATA74TER);
_causale = cur->curr(LF_MOV).get(MOV_CODCAUS);
_registro = cur->curr(LF_MOV).get(MOV_REG);
format_if_zero(_registro, 3);
_tipodoc = cur->curr(LF_MOV).get(MOV_TIPODOC);
_numdoc = cur->curr(LF_MOV).get(MOV_NUMDOC);
_datareg = cur->curr(LF_MOV).get_date(MOV_DATAREG);
_codcf = cur->curr(LF_MOV).get_long(MOV_CODCF);
_numero = cur->curr(LF_MOV).get_long(MOV_NUMREG);
_protiva = cur->curr(LF_MOV).get_long(MOV_PROTIVA);
_codval = cur->curr(LF_MOV).get(MOV_CODVALI);
_codpag = cur->curr(LF_MOV).get(MOV_CODPAG);
_annoiva = _datareg.year();
_tot_dare = _tot_avere = ZERO;
_tot_doc = ZERO;
_tipodoc = "";
_tipocf = ' ';
_ae = date2esc(_datareg);
//_num_rec = cur->curr(LF_MOV).get_long(MOV_NUMGIO);
bool controlla = controlla_mov(); //se TRUE => ci sono errori nella testata
bool veriva = FALSE;
if (_is_iva) //Va fatto solo se ho ricevuto anche l'iva
veriva = controlla_riva();
bool verrmov = controlla_rmov();
bool verifica = (veriva || verrmov);
aggiorna_mov();
if ( (_controllo == 1 && controlla) || _controllo == 2 ||
(_controllo == 1 && verifica) )
{
TString16 datareg_str = _datareg.string();
// "Fai vedere lo stesso ..-..-.... anche se non c'e' la data..."
if (datareg_str.empty())
datareg_str = " - - ";
TString16 datadoc_str = _datadoc.string();
if (datadoc_str.empty())
datadoc_str = " - - ";
int r = 1;
set_row(r++, "");
set_row(r,"Operazione n. %-7ld", _numero);
set_row(r," del %s", (const char*)datareg_str);
set_row(r," doc. n. %-7s", (const char*)_numdoc);
set_row(r," del %s", (const char*)datadoc_str);
if (!_registro.blank()) //e' una fattura
{
set_row(r," registro IVA %-3s", (const char*)_registro);
set_row(r," protocollo n. %-5ld", _protiva);
}
set_row(r, " comp. %d", _anno);
stampa_errori_mov(r);
_ho_stampato = TRUE;
return TRUE;
}
return FALSE;
}
else if (file == LF_RMOV)
{
_gruppo = cur->curr(LF_RMOV).get_int(RMV_GRUPPO);
_conto = cur->curr(LF_RMOV).get_int(RMV_CONTO);
_sottoconto = cur->curr(LF_RMOV).get_long(RMV_SOTTOCONTO);
_gruppoc = cur->curr(LF_RMOV).get_int(RMV_GRUPPOC);
_contoc = cur->curr(LF_RMOV).get_int(RMV_CONTOC);
_sottocontoc = cur->curr(LF_RMOV).get_long(RMV_SOTTOCONTOC);
_importo = cur->curr(LF_RMOV).get_real(RMV_IMPORTO);
_sezione = cur->curr(LF_RMOV).get(RMV_SEZIONE)[0];
TString80 descr = cur->curr(LF_RMOV).get(RMV_DESCR);
int numrig = cur->curr(LF_RMOV).get_int(RMV_NUMRIG);
_tipo_conto = "";
if (_gruppo != 0 && _conto != 0 && _sottoconto != 0l)
_esiste_conto = DescrConto(_gruppo,_conto,_sottoconto);
else
{
_esiste_conto = FALSE;
_descr_conto = "";
}
int r = 1;
set_row(r, "P%d", numrig);
set_row(r, "@5g%3s %-.20s @30g%-.24s @56g%03d %03d %06ld @71g%-.28s", (const char*) _causale,
(const char*) _descr_causale, (const char*) descr, _gruppo, _conto, _sottoconto,
(const char*) _descr_conto);
if (_sezione == 'D')
set_row(r, "@99g%r", &_importo);
else if (_sezione == 'A')
set_row(r, "@116g%r", &_importo);
else set_row(r, "@107g%r", &_importo);
stampa_errori_rmov(r);
// TLocalisamfile& rmov = current_cursor()->file(LF_RMOV);
// rmov.put(RMV_ANNOES, _annoese);
// rmov.rewrite();
}
else if (file == LF_RMOVIVA)
{
real impo = cur->curr(LF_RMOVIVA).get_real(RMI_IMPONIBILE);
real impos = cur->curr(LF_RMOVIVA).get_real(RMI_IMPOSTA);
int numrig = cur->curr(LF_RMOVIVA).get_int(RMI_NUMRIG);
_tipocr = cur->curr(LF_RMOVIVA).get_int(RMI_TIPOCR);
_tipod = cur->curr(LF_RMOVIVA).get_int(RMI_TIPODET);
_codiva = cur->curr(LF_RMOVIVA).get(RMI_CODIVA);
//_n_rec = cur->curr(LF_RMOVIVA).get_int(RMI_ANNOES);
_gruppocr = cur->curr(LF_RMOVIVA).get_int(RMI_GRUPPO);
_contocr = cur->curr(LF_RMOVIVA).get_int(RMI_CONTO);
_sottocontocr = cur->curr(LF_RMOVIVA).get_long(RMI_SOTTOCONTO);
TString80 codiva_des(get_codiva_des(_codiva));
//_tot_doc += impo + impos;
_impo = impo;
_impos = impos;
if (!_tipodoc.blank())
{
TTable tabtpd("%TPD");
tabtpd.put("CODTAB", _tipodoc);
if (tabtpd.read() == NOERR)
{
bool cor = tabtpd.get_bool("B0");
if (cor)
{
_impo = impo + impos;
_impos = ZERO;
}
}
}
int r = 1;
// Cambia segno se si tratta di note di credito o storni
if (_tipodoc == "NC" || _tipodoc == "ST")
{
_impo_print = _impo * (-1);
_impos_print = _impos * (-1);
}
else
{
_impo_print = _impo;
_impos_print = _impos;
}
set_row(r, "I%d", numrig);
set_row(r, "@5gImponibile@16g%r",&_impo_print);
set_row(r, "@32gImposta@40g%r", &_impos_print);
set_row(r, "@56gCodice@63g%4s", (const char*) _codiva);
set_row(r, "@68g%s", (const char*) codiva_des);
if (_tipod != 0)
set_row(r," %d", _tipod);
stampa_errori_riva(r);
}
if (file == LF_PARTITE)
{
_err.reset();
_tipomov = cur->curr(LF_PARTITE).get_int (PART_TIPOMOV);
_tipocf = cur->curr(LF_PARTITE).get_char(PART_TIPOCF);
_gruppo = cur->curr(LF_PARTITE).get_int (PART_GRUPPO);
_conto = cur->curr(LF_PARTITE).get_int (PART_CONTO);
_codcf = cur->curr(LF_PARTITE).get_long(PART_SOTTOCONTO);
_anno = cur->curr(LF_PARTITE).get_int (PART_ANNO);
_numpart = cur->curr(LF_PARTITE).get (PART_NUMPART);
_nriga = cur->curr(LF_PARTITE).get_int (PART_NRIGA);
_numreg = cur->curr(LF_PARTITE).get_long(PART_NREG);
_numrig = cur->curr(LF_PARTITE).get_int (PART_NUMRIG);
_datareg = cur->curr(LF_PARTITE).get_date(PART_DATAREG);
_datadoc = cur->curr(LF_PARTITE).get_date(PART_DATADOC);
_numdoc = cur->curr(LF_PARTITE).get (PART_NUMDOC);
_reg = cur->curr(LF_PARTITE).get (PART_REG);
_protiva = cur->curr(LF_PARTITE).get_long(PART_PROTIVA);
_causale = cur->curr(LF_PARTITE).get (PART_CODCAUS);
_tipopag = cur->curr(LF_PARTITE).get_int (PART_TIPOPAG);
_datapag = cur->curr(LF_PARTITE).get_date(PART_DATAPAG);
_codval = cur->curr(LF_PARTITE).get (PART_CODVAL);
_cambio = cur->curr(LF_PARTITE).get_real(PART_CAMBIO);
_datacam = cur->curr(LF_PARTITE).get (PART_DATACAM);
_sez = cur->curr(LF_PARTITE).get_char(PART_SEZ);
_gruppocl = cur->curr(LF_PARTITE).get_int (PART_GRUPPOCL);
_contocl = cur->curr(LF_PARTITE).get_int (PART_CONTOCL);
aggiorna_partite();
bool controlla = controlla_partite(); //se TRUE => ci sono errori nella testata
bool verpagsca = controlla_pagsca();
bool verscad = controlla_scadenze();
bool verifica = (verpagsca || verscad);
if ( (_controllo == 1 && controlla) || _controllo == 2 ||
(_controllo == 1 && verifica) )
{
TString16 datareg_str = _datareg.string();
// "Fai vedere lo stesso ..-..-.... anche se non c'e' la data..."
if (datareg_str.empty())
datareg_str = " - - ";
TString16 datadoc_str = _datadoc.string();
if (datadoc_str.empty())
datadoc_str = " - - ";
TString16 datapag_str = _datapag.string();
if (datapag_str.empty())
datapag_str = " - - ";
TString16 datacam_str = _datacam.string();
if (datacam_str.empty())
datacam_str = " - - ";
TString ccf;
if (_tipocf == 'C')
ccf = "Cliente: ";
else
if (_tipocf == 'F')
ccf = "Fornitore:";
else
ccf = "Conto: ";
// I riga di testata
int r = 1;
set_row(r++, "");
if (_tipocf != _tipocf_p || _gruppo != _gruppo_p || _conto != _conto_p || _codcf != _codcf_p)
{
set_row(r++, "");
set_row(r,"@b%s", (const char*) ccf);
if (_gruppo != 0)
set_row(r,"@b%3d", _gruppo);
if (_conto != 0)
set_row(r,"@b%3d", _conto);
set_row(r,"@b%6ld", _codcf);
set_row(r++," @b%-50s", (const char*) _descr_anag);
}
// II riga di testata (L'intestazione viene stampata solo a rottura di partita)
if (_tipocf != _tipocf_p || _gruppo != _gruppo_p || _conto != _conto_p ||
_codcf != _codcf_p || _numpart != _numpart_prec || _anno != _anno_prec)
set_row(r,"@0g@rRif. partita");
set_row(r,"@14gN.riga@22gN.operaz./riga Data oper. Data doc. N.doc. Reg Prot. Causale");
set_row(r++,"@142gTipo/Data pag. Cod.val Cambio Data cambio Sez");
if (_tipocf != _tipocf_p || _gruppo != _gruppo_p || _conto != _conto_p ||
_codcf != _codcf_p || _numpart != _numpart_prec || _anno != _anno_prec)
{
set_row(r,"%4d", _anno);
set_row(r,"@4g/%-7s", (const char*) _numpart);
}
set_row(r,"@15g%4d", _nriga);
if (_numreg != 0)
set_row(r,"@23g%7ld", _numreg);
else
set_row(r,"@23g-");
if (_numrig != 0)
set_row(r,"@32g%4d", _numrig);
else
set_row(r,"@32g-");
set_row(r,"@38g%10s", (const char*) datareg_str);
set_row(r,"@50g%10s", (const char*) datadoc_str);
set_row(r,"@62g%-7s", (const char*) _numdoc);
if (_tipomov == 1 || _tipomov == 2)
{
set_row(r,"@71g%-3s", (const char*) _reg);
if (_protiva != 0)
set_row(r,"@76g%05ld", _protiva);
}
set_row(r,"@83g%-3s", (const char*) _causale);
set_row(r,"@88g%-50s", (const char*) _descr_causale);
if (_tipopag != 0)
set_row(r,"@144g%d", _tipopag);
set_row(r,"@147g%10s", (const char*) datapag_str);
set_row(r,"@160g%-3s", (const char*) _codval);
if (_cambio != ZERO)
set_row(r,"@166g%15s",(const char*) _cambio.string("#.###.###,@@@@@"));
set_row(r,"@183g%10s", (const char*) datacam_str);
set_row(r,"@196g%c", _sez);
_tipocf_p = _tipocf;
_gruppo_p = _gruppo;
_conto_p = _conto;
_codcf_p = _codcf;
stampa_errori_partite(r);
_prima_rata_pag = TRUE;
_numpart_prec = _numpart;
_anno_prec = _anno;
_ho_stampato = TRUE;
return TRUE;
}
return FALSE;
}
if (file == LF_SCADENZE)
{
int r = 1;
stampa_errori_scadenze(r);
}
if (file == LF_PAGSCA)
{
int r = 1;
stampa_errori_pagsca(r);
}
return TRUE;
}
print_action TRic_ListaMov::postprocess_page(int file,int count)
{
if (count) return NEXT_PAGE;
if (file == LF_MOV)
{
reset_print();
_err.reset();
int n = 1;
if (_tot_dare != _tot_avere)
{
_errore_grave = TRUE;
set_row(n++, "@8g*** Il movimento risulta sbilanciato. Totali rilevati:@99g%r@116g%r",
&_tot_dare, &_tot_avere);
return REPEAT_PAGE;
}
}
if (file == LF_PARTITE)
{
reset_print();
_err.reset();
}
return NEXT_PAGE;
}
print_action TRic_ListaMov::postprocess_print(int file, int counter)
{
if (file == LF_MOV || file == LF_PARTITE)
if (_ho_stampato)
printer().formfeed();
return NEXT_PAGE;
}
void TRic_ListaMov::postclose_print()
{
bool esegui; // La variabile esegui mi permette di visualizzare il messaggio se non c'e il
// saldaconto, oppure se c'e' il saldaconto ma e' gia' stato eseguito il controllo
// su quest'ultimo
if ( (_is_salda && _seconda_volta) || !_is_salda)
esegui = TRUE;
else
esegui = FALSE;
if (_is_salda)
if (_seconda_volta)
_seconda_volta = FALSE;
else
_seconda_volta = TRUE;
_errore_grave_totale = _errore_grave || _errore_grave_SC;
if (esegui)
{
if (_errore_grave_totale)
{
if (_ric_auto == 'A')
{
_risposta = TRUE;
_continua = yesno_box("Rilevati ERRORI GRAVI durante il controllo movimenti: \n Controllare gli errori sulla lista dei movimenti stampata per eseguire le correzioni. \n Continuare ugualmente?");
TTransfer_file& tr = trasfer();
if (!_continua)
_record.overwrite(" ",240); //_record e' letto nella read_control_rec()
else
{
TConfig conf (CONFIG_DITTA);
conf.set("FlStTra", "M");
_record.overwrite("Z",240);
}
const int size = 1024;
tr.write_control_rec(_record, size);
tr.read_control_rec();
}
else
{
message_box("Rilevati errori gravi durante il controllo movimenti: \n trasferimento interrotto");
TTransfer_file& tr = trasfer();
_record.overwrite(" ",240); //_record e' letto nella read_control_rec()
const int size = 1024;
tr.write_control_rec(_record, size);
tr.read_control_rec();
chiudi_file_SC();
}
}
else
{
if (_ric_auto == 'A')
_risposta = TRUE;
else
message_box("CONTROLLO MOVIMENTI terminato: \n proseguire con RICEZIONE movimenti");
TConfig conf (CONFIG_DITTA);
conf.set("FlStTra", "M");
TTransfer_file& tr = trasfer();
_record.overwrite("Z",240); //_record e' letto nella read_control_rec()
const int size = 1024;
tr.write_control_rec(_record, size);
tr.read_control_rec();
chiudi_file_SC();
}
} // if (esegui)
}
void TRic_ListaMov::esamina_partite()
{
bool prima_volta = TRUE;
int numrigp = -1;
TRecnotype recp = _tpart->recno();
TIsamtempfile& part = *_tpart;
part.setkey(2);
part.zero();
part.put(PART_NREG, _numero);
TRectype partita (part.curr());
for (part.read(_isgteq); !part.eof(); part.next())
{
if (part.curr() != partita) break;
int tipomov = part.get_int(PART_TIPOMOV);
int numrig = part.get_int(PART_NUMRIG);
// if (numrig != numrigp)
// {
real doc = ZERO;
real val = ZERO;
if (tipomov != 1 && tipomov != 2)
{
TIsamtempfile& pagsca = *_tpagsca;
pagsca.zero();
pagsca.put(PAGSCA_TIPOC, part.get_char(PART_TIPOCF));
pagsca.put(PAGSCA_GRUPPO, part.get_int (PART_GRUPPO));
pagsca.put(PAGSCA_CONTO, part.get_int (PART_CONTO));
pagsca.put(PAGSCA_SOTTOCONTO, part.get_long(PART_SOTTOCONTO));
pagsca.put(PAGSCA_ANNO, part.get_int (PART_ANNO));
pagsca.put(PAGSCA_NUMPART, part.get (PART_NUMPART));
int nriga = part.get_int(PART_NRIGA);
TRectype pagamenti (pagsca.curr());
for (pagsca.read(_isgteq); !pagsca.eof(); pagsca.next())
{
TString rec = pagamenti.get(PAGSCA_NUMPART);
TString file = pagsca.get(PAGSCA_NUMPART);
if (pagsca.curr() != pagamenti || file != rec) break;
int nrigp = pagsca.get_int(PAGSCA_NRIGP);
if (nrigp != nriga) continue;
doc += pagsca.get_real(PAGSCA_IMPORTO) + pagsca.get_real(PAGSCA_RITENUTE);
val += pagsca.get_real(PAGSCA_IMPORTOVAL);
}
if (prima_volta)
_tot_doc = ZERO;
_tot_doc += doc;
}
if (tipomov == 1)
{
TRecnotype recs = _tscad->recno();
TIsamtempfile& scad = *_tscad;
scad.zero();
scad.put(SCAD_TIPOCF, part.get_char(PART_TIPOCF));
scad.put(SCAD_GRUPPO, part.get_int (PART_GRUPPO));
scad.put(SCAD_CONTO, part.get_int (PART_CONTO));
scad.put(SCAD_SOTTOCONTO, part.get_long(PART_SOTTOCONTO));
scad.put(SCAD_ANNO, part.get_int (PART_ANNO));
scad.put(SCAD_NUMPART, part.get (PART_NUMPART));
scad.put(SCAD_NRIGA, part.get_int (PART_NRIGA));
TRectype scadenze (scad.curr());
for (scad.read(_isgteq); !scad.eof(); scad.next())
{
TString rec = scadenze.get(SCAD_NUMPART);
TString file = scad.get(SCAD_NUMPART);
if (scad.curr() != scadenze || file != rec) break;
val += scad.get_real(SCAD_IMPORTOVAL);
}
_tscad->readat(recs);
}
if (prima_volta)
_tot_val = ZERO;
_tot_val += val;
// }
// numrigp = numrig;
if (prima_volta)
{
_codval_part = part.get (PART_CODVAL);
_datacam_part = part.get_date(PART_DATACAM);
_cambio_part = part.get_real(PART_CAMBIO);
if (tipomov == 1)
{
TRecnotype recs = _tscad->recno();
TIsamtempfile& scad = *_tscad;
char tipo = part.get_char(PART_TIPOCF);
int gruppo = part.get_int (PART_GRUPPO);
int conto = part.get_int (PART_CONTO);
long sottoc = part.get_long(PART_SOTTOCONTO);
int anno = part.get_int (PART_ANNO);
TString numpart = part.get (PART_NUMPART);
int nriga = part.get_int (PART_NRIGA);
scad.setkey(1);
scad.zero();
scad.put(SCAD_TIPOCF, tipo);
scad.put(SCAD_GRUPPO, gruppo);
scad.put(SCAD_CONTO, conto);
scad.put(SCAD_SOTTOCONTO, sottoc);
scad.put(SCAD_ANNO, anno);
scad.put(SCAD_NUMPART, numpart);
scad.put(SCAD_NRIGA, nriga);
TRectype scadenza (scad.curr());
_codpag_scad = "";
for (scad.read(_isgteq); !scad.eof(); scad.next())
{
TString rec = scadenza.get(SCAD_NUMPART);
TString file = scad.get(SCAD_NUMPART);
if (scad.curr() != scadenza || file != rec) break;
_codpag_scad = scad.get(SCAD_CODPAG);
break;
}
_tscad->readat(recs);
}
prima_volta = FALSE;
}
}
_tpart->readat(recp);
}
void TRic_ListaMov::aggiorna_mov()
{
TLocalisamfile& mov = current_cursor()->file(LF_MOV);
if (_is_salda)
esamina_partite();
if (_anno == 0)
mov.put(MOV_ANNOES, _annoese);
mov.put(MOV_DATACOMP, _datacomp);
mov.put(MOV_ANNOIVA, _annoiva);
mov.put(MOV_REG, _registro);
mov.put(MOV_TIPODOC, _tipodoc);
mov.put(MOV_TIPO, _tipocf);
if (mov.get(MOV_TIPOMOV).empty())
mov.put(MOV_TIPOMOV, _tipom_cau);
mov.put(MOV_CODPAG, _codpag_scad);
const bool first_time = mov.get("TOCFP")!="X";
if ((_tipodoc == "NC" || _tipodoc == "ST") && first_time) // swap sign only if it's first time
{
_tot_doc = _tot_doc * -1;
mov.put("TOCFP","X");
}
// NB In caso di ricezione da sistema ritsoc e ritfis valgono sempre 0
// quindi in caso di ricezione da PC ripristina il totale documento corretto.
real ritsoc = mov.get(MOV_RITSOC);
real ritfis = mov.get(MOV_RITFIS);
_tot_doc = _tot_doc - ritsoc - ritfis;
mov.put(MOV_TOTDOC, _tot_doc);
if (_is_salda)
{
if (mov.get_real(MOV_TOTDOCVAL) == ZERO)
mov.put(MOV_TOTDOCVAL, _tot_val);
if (mov.get(MOV_CODVAL).empty())
mov.put(MOV_CODVAL, _codval_part);
if (mov.get(MOV_DATACAM).empty())
mov.put(MOV_DATACAM, _datacam_part);
if (mov.get_real(MOV_CAMBIO) == ZERO)
mov.put(MOV_CAMBIO, _cambio_part);
}
mov.rewrite();
}
void TRic_ListaMov::aggiorna_rmov(char tipoc, char tipocc)
{
TLocalisamfile& rmov = current_cursor()->file(LF_RMOV);
if (_anno == 0)
rmov.put(RMV_ANNOES, _annoese);
rmov.put(RMV_TIPOC, tipoc);
rmov.put(RMV_TIPOCC, tipocc);
rmov.rewrite();
}
void TRic_ListaMov::aggiorna_iva(char tipo)
{
TLocalisamfile& riva = current_cursor()->file(LF_RMOVIVA);
TLocalisamfile& mov = current_cursor()->file(LF_MOV);
if (_anno == 0)
riva.put(RMI_ANNOES, _annoese);
const bool first_time = mov.get("TOCFP") != "X";
if ((_tipodoc == "NC" || _tipodoc == "ST") && first_time) // swap sign only if it is the first time
{
_impo = _impo * -1;
_impos = _impos * -1;
}
riva.put(RMI_IMPONIBILE, _impo);
riva.put(RMI_IMPOSTA, _impos);
riva.put(RMI_TIPOC, tipo);
riva.rewrite();
}
bool TRic_ListaMov::solo_SC(long numreg)
{
TIsamtempfile& tmov = *_tmov;
tmov.setkey(1);
tmov.zero();
tmov.put(MOV_NUMREG, numreg);
if (tmov.read() == NOERR)
return FALSE;
return TRUE;
}
void TRic_ListaMov::calcola_imposta(long nreg, real& imposta)
{
TRecnotype recn = _tiva->recno();
TIsamtempfile& riva = *_tiva;
riva.zero();
riva.put(RMI_NUMREG, nreg);
TRectype recriva (riva.curr());
for (riva.read(_isgteq); !riva.eof(); riva.next())
{
if (riva.curr() > recriva) break;
real imp (riva.get_real(RMI_IMPOSTA));
imposta += imp;
}
_tiva->readat(recn);
}
bool TRic_ListaMov::calcola_impdocval(long nreg,int nrig,char tipoc,int gruppo,int conto,long sottoc,
int anno,TString& numpart,int nriga,real& doc,real& val)
{
TRecnotype recn = _tpagsca->recno();
TIsamtempfile& pagsca = *_tpagsca;
bool prima_volta = TRUE;
doc = ZERO;
val = ZERO;
pagsca.zero();
pagsca.put(PAGSCA_TIPOC, tipoc);
pagsca.put(PAGSCA_GRUPPO, gruppo);
pagsca.put(PAGSCA_CONTO, conto);
pagsca.put(PAGSCA_SOTTOCONTO, sottoc);
pagsca.put(PAGSCA_ANNO, anno);
pagsca.put(PAGSCA_NUMPART, numpart);
// pagsca.put(PAGSCA_NRIGA, nriga);
TRectype pagamenti (pagsca.curr());
for (pagsca.read(_isgteq); !pagsca.eof(); pagsca.next())
{
TString rec = pagamenti.get(PAGSCA_NUMPART);
TString file = pagsca.get(PAGSCA_NUMPART);
if (pagsca.curr() != pagamenti || file != rec) break;
int nrigp = pagsca.get_int(PAGSCA_NRIGP);
if (nrigp != nriga) continue;
doc += pagsca.get_real(PAGSCA_IMPORTO) + pagsca.get_real(PAGSCA_RITENUTE);
val += pagsca.get_real(PAGSCA_IMPORTOVAL);
}
_tpagsca->readat(recn);
if (nreg != 0 && nrig != 0)
{
int key = _tpart->getkey();
TRecnotype rec = _tpart->recno();
TIsamtempfile& part = *_tpart;
part.setkey(2);
part.zero();
part.put(PART_NREG, nreg);
part.put(PART_NUMRIG, nrig);
TRectype partita (part.curr());
for (part.read(); !part.eof(); part.next())
{
if (part.curr() > partita) break;
real imp = part.get_real(PART_IMPTOTDOC) + doc;
real impval = part.get_real(PART_IMPTOTVAL) + val;
part.put(PART_IMPTOTDOC, imp);
part.put(PART_IMPTOTVAL, impval);
part.setkey(1);
part.rewrite();
part.setkey(2);
}
_tpart->readat(rec);
_tpart->setkey(key);
}
else
return TRUE;
return FALSE;
}
void TRic_ListaMov::calcola_importo(char tipoc,int gruppo,int conto,long sottoc,
int anno,TString& numpart,int nriga)
{
TRecnotype recn = _tscad->recno();
TIsamtempfile& scad = *_tscad;
scad.setkey(1);
scad.zero();
scad.put(SCAD_TIPOCF, tipoc);
scad.put(SCAD_GRUPPO, gruppo);
scad.put(SCAD_CONTO, conto);
scad.put(SCAD_SOTTOCONTO, sottoc);
scad.put(SCAD_ANNO, anno);
scad.put(SCAD_NUMPART, numpart);
scad.put(SCAD_NRIGA, nriga);
TRectype scadenza (scad.curr());
for (scad.read(_isgteq); !scad.eof(); scad.next())
{
TString rec = scadenza.get(SCAD_NUMPART);
TString file = scad.get(SCAD_NUMPART);
if (scad.curr() != scadenza || file != rec) break;
_imp += scad.get_real(SCAD_IMPORTO);
_impval += scad.get_real(SCAD_IMPORTOVAL);
}
_tscad->readat(recn);
}
void TRic_ListaMov::aggiorna_partita(real& importo,real& importoval,real& abbuoni,real& diffcam,
real& ritenute,TString& sez,TString& sezabb,TString& sezdc)
{
TRecnotype recn = _tpagsca->recno();
TIsamtempfile& pagsca = *_tpagsca;
real abb,diff;
abb = ZERO;
diff = ZERO;
pagsca.setkey(1);
pagsca.zero();
pagsca.put(PAGSCA_TIPOC, _tipocf);
pagsca.put(PAGSCA_GRUPPO, _gruppo);
pagsca.put(PAGSCA_CONTO, _conto);
pagsca.put(PAGSCA_SOTTOCONTO, _codcf);
pagsca.put(PAGSCA_ANNO, _anno);
pagsca.put(PAGSCA_NUMPART, _numpart);
TRectype pagamento (pagsca.curr());
for (pagsca.read(_isgteq); !pagsca.eof(); pagsca.next())
{
TString rec = pagamento.get(PAGSCA_NUMPART);
TString file = pagsca.get(PAGSCA_NUMPART);
if (pagsca.curr() != pagamento || file != rec) break;
int nrigp = pagsca.get_int(PAGSCA_NRIGP);
if (_nriga != nrigp) continue;
importo += pagsca.get_real(PAGSCA_IMPORTO);
importoval += pagsca.get_real(PAGSCA_IMPORTOVAL);
ritenute += pagsca.get_real(PAGSCA_RITENUTE);
abb = pagsca.get_real(PAGSCA_ABBUONI);
if (abb != ZERO)
{
if (sezabb.empty())
{
abbuoni += abb;
sezabb = sez;
}
else
if (sez == sezabb)
abbuoni += abb;
else
abbuoni -= abb;
}
diff = pagsca.get_real(PAGSCA_DIFFCAM);
if (diff != ZERO)
{
if (sezdc.empty())
{
diffcam += diff;
sezdc = sez;
}
else
if (sez == sezdc)
diffcam += diff;
else
diffcam -= diff;
}
}
if (abbuoni < ZERO)
{
abbuoni = abbuoni * -1;
if (sezabb == "D")
sezabb = "A";
else
if (sezabb == "A")
sezabb = "D";
}
if (diffcam < ZERO)
{
diffcam = diffcam * -1;
if (sezdc == "D")
sezdc = "A";
else
if (sezdc == "A")
sezdc = "D";
}
_tpagsca->readat(recn);
}
void TRic_ListaMov::aggiorna_partite()
{
TLocalisamfile& part = current_cursor()->file(LF_PARTITE);
real imposta = ZERO;
if (!solo_SC(_numreg) && _tipomov == 1) // && (part.get_real(PART_IMPOSTA) == ZERO) )
{
if (_is_iva)
{
calcola_imposta(_numreg,imposta);
part.put(PART_IMPOSTA, imposta);
}
}
if (_tipomov != 1 && _tipomov != 4)
{
/* if (_prima_volta)
{
_prima_volta = FALSE;
if (part.get_real(PART_IMPTOTDOC) == ZERO)
_calcola = TRUE;
else
_calcola = FALSE;
} */
// if (_calcola)
// {
real doc;
real val;
if (calcola_impdocval(_numreg,_numrig,_tipocf,_gruppo,_conto,_codcf,_anno,_numpart,_nriga,doc,val))
{
part.put(PART_IMPTOTDOC, doc);
part.put(PART_IMPTOTVAL, val);
}
// }
}
if (_tipomov == 1 ) //&& (part.get_real(PART_IMPORTO) == ZERO) )
{
calcola_importo(_tipocf,_gruppo,_conto,_codcf,_anno,_numpart,_nriga);
part.put(PART_IMPORTO, _imp);
part.put(PART_IMPORTOVAL, _impval);
_imp = ZERO;
_impval = ZERO;
}
if (_tipomov != 1) // && (part.get_real(PART_IMPORTO) == ZERO) )
{
real importo = ZERO;
real importoval = ZERO;
real ritenute = ZERO;
real abbuoni = ZERO;
real diffcam = ZERO;
TString sez = part.get(PART_SEZ);
TString sezabb = part.get(PART_SEZABB);
TString sezdc = part.get(PART_SEZDIFCAM);
aggiorna_partita(importo,importoval,abbuoni,diffcam,ritenute,sez,sezabb,sezdc);
part.put(PART_IMPORTO, importo);
part.put(PART_IMPORTOVAL, importoval);
part.put(PART_RITENUTE, ritenute);
part.put(PART_SEZABB, sezabb);
part.put(PART_ABBUONI, abbuoni);
part.put(PART_SEZDIFCAM, sezdc);
part.put(PART_DIFFCAM, diffcam);
}
part.rewrite();
}
bool TRic_ListaMov::user_destroy()
{
delete _giornale;
delete _trasfer;
delete _rel;
// delete _relSC;
// delete _cur;
delete _tmov;
delete _trmov;
if (_is_iva)
delete _tiva;
delete _caus;
delete _ditte;
delete _clifo;
delete _pcon;
delete _mov;
delete _rmov;
delete _rmoviva;
delete _part;
delete _scad;
delete _pagsca;
delete _tab_pag;
delete _tab_tpd;
delete _tab_iva;
delete _tab_ese;
delete _tab_tra;
return TRUE;
}
void TRic_ListaMov::chiudi_file_SC()
{
if (_is_salda)
{
delete _relSC; _relSC = NULL;
delete _tpart; _tpart = NULL;
delete _tscad; _tscad = NULL;
delete _tpagsca; _tpagsca = NULL;
delete _part; _part = NULL;
delete _scad; _scad = NULL;
delete _pagsca; _pagsca = NULL;
}
}
bool TRic_ListaMov::set_print(int m)
{
if (_ric_auto == 'A')
{
if (_risposta) // Metto questa variabile booleana per uscire, altrimenti
{ // il programma andrebbe in loop andando ancora in stampa
TString appname = "cg6 -0";
TString body = "";
if (_continua)
body = "1";
else
body = "0";
TMessage msg (appname,"",(const char*)body);
TMailbox mb;
mb.send(msg);
return FALSE;
}
if (_seconda_volta && _is_salda)
{
reset_files(); // Resetta l'albero di stampa precedente relativo ai movimenti contabili e iva
select_cursor(_curSC); // Seleziona il cursore relativo ai movimenti del saldaconto
add_file (LF_PARTITE);
add_file (LF_SCADENZE, LF_PARTITE);
add_file (LF_PAGSCA, LF_PARTITE);
_errore_grave_SC = FALSE;
_intestaSC = TRUE;
_prima_volta = TRUE;
_ho_stampato = FALSE;
}
else
{
TString80 nome;
long ditta_ric = get_firm();
TTransfer_file& tr = trasfer(); // Nella lista controllo movimenti lanciata da menu il record di
// controllo dell'header viene letto nella funzione check_archivi
// Nella ricezione in automatico devo leggerlo in questo punto
_pathfile = tr.path();
_pathfile = _pathfile << HEADER;
if (!tr.open(_pathfile))
return error_box("Al momento non presenti trasferimenti attivi sulla ditta selezionata");
if (!tr.read_control_rec())
return error_box("Rilevati errori gravi negli archivi: procedura interrotta");
else _record = tr.record();
if (_tipo_lista == 'A')
_controllo = 2;
else
_controllo = 1;
apri_file_SC();
reset_files(); // Resetta l'albero di stampa precedente relativo ai movimenti del saldaconto
select_cursor(_cur); // Seleziona il cursore relativo ai movimenti contabili e iva
add_file (LF_MOV);
add_file (LF_RMOV, LF_MOV);
if (_is_iva)
add_file (LF_RMOVIVA, LF_MOV);
_errore_grave = FALSE;
_errore_grave_totale = FALSE;
_intestaSC = FALSE;
_err.reset();
}
setta_parametri(" ", "C");
set_real_picture("###.###.###.###");
printer().footerlen(5);
setta_intestazione();
_err.reset();
}
else
{
if (_seconda_volta && _is_salda)
{
reset_files(); // Resetta l'albero di stampa precedente relativo ai movimenti contabili e iva
select_cursor(_curSC); // Seleziona il cursore relativo ai movimenti del saldaconto
add_file (LF_PARTITE);
add_file (LF_SCADENZE, LF_PARTITE);
add_file (LF_PAGSCA, LF_PARTITE);
_errore_grave_SC = FALSE;
_intestaSC = TRUE;
_prima_volta = TRUE;
_ho_stampato = FALSE;
}
else
{
TMask msk ("cg6700a");
TTransfer_file& tr = trasfer();
apri_file_SC();
msk.set(F_NUMERO, tr.nultras());
msk.set(F_DATALIMITE, tr.dataultras());
msk.set(F_SDT, look_sdt());
msk.set(F_SIGLA, tr.ult_file());
msk.set(F_CHIAVE, tr.key());
if (msk.run() != K_ENTER) return FALSE;
_controllo = msk.get_int(F_LISTA);
reset_files(); // Resetta l'albero di stampa precedente relativo ai movimenti del saldaconto
select_cursor(_cur); // Seleziona il cursore relativo ai movimenti contabili e iva
add_file (LF_MOV);
add_file (LF_RMOV, LF_MOV);
if (_is_iva)
add_file (LF_RMOVIVA, LF_MOV);
_errore_grave = FALSE;
_errore_grave_totale = FALSE;
_intestaSC = FALSE;
}
if (_sdt == '*')
::remove(_pathfile);
setta_parametri(" ", "C");
set_real_picture("###.###.###.###");
printer().footerlen(5);
setta_intestazione();
_err.reset();
}
return TRUE;
}
void TRic_ListaMov::setta_intestazione()
{
int soh = 1;
TString sep(132);
TString sep1(198);
TString ragsoc(50);
TLocalisamfile nditte(LF_NDITTE);
nditte.zero();
nditte.put(NDT_CODDITTA, get_firm());
if (nditte.read() == NOERR)
ragsoc = nditte.get(NDT_RAGSOC);
reset_header();
if (_intestaSC)
{
sep1 << "Ditta " << get_firm();
sep1 << " " << ragsoc;
sep1.left_just(198);
set_header (soh++, (const char*) sep1);
sep1 = "";
sep1 << "Data @< Pag. @#";
sep1.right_just(193);
sep1.overwrite ("LISTA DI CONTROLLO MOVIMENTI DI SALDACONTO");
set_header (soh++, (const char*)sep1);
sep1.fill('-');
set_header (soh++, (const char *) sep1);
}
else
{
sep << "Ditta " << get_firm();
sep << " " << ragsoc;
sep.left_just(132);
set_header (soh++, (const char*) sep);
sep = "";
sep << "Data @< Pag. @#";
sep.right_just(127);
sep.overwrite ("LISTA DI CONTROLLO MOVIMENTI IN TRASFERIMENTO");
set_header (soh++, (const char*)sep);
sep.fill('-');
set_header (soh++, (const char *) sep);
set_header (soh++, "Rig Cod.causale @30gDescriz.aggiuntiva @56gCod.conto @71gDescriz.conto @99gDare @116gAvere");
set_header (soh, (const char *) sep);
}
}
void TRic_ListaMov::setta_parametri(const TString& sigla, const TString& flag)
{
TTransfer_file& tr = trasfer();
TConfig conf (CONFIG_DITTA);
conf.set("FlStTra", flag);
TString rec = tr.record();
rec.overwrite(sigla,240);
const int size = 1024;
tr.write_control_rec(rec, size);
}
int cg6700 (int argc, char* argv[])
{
char p1 = '\0';
char p2 = '\0';
if (argc >= 4)
p1 = *argv[2];
if (argc >= 5)
p2 = *argv[3];
TRic_ListaMov* a = new TRic_ListaMov(p1,p2);
a->run(argc, argv,"Lista controllo movimenti");
delete a;
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink