root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/tc/tc0701.cpp
alex 96f33c01ee Patch level : 4.0 979 
Files correlati     : ve6.exe
Ricompilazione Demo : [ ]
Commento            :

Riportata la versione 3.1 patch 979


git-svn-id: svn://10.65.10.50/trunk@15623 c028cbd2-c16b-5b4b-a496-9718f37d4682
2007-09-17 15:33:04 +00:00

1370 lines
41 KiB
C++
Executable File
Raw Blame History

#include "tc0.h"
#include "tc0701.h"
#include "tc0700a.h"
#include <automask.h>
#include <progind.h>
#include <reprint.h>
//#include <anagr.h>
//#include <anafis.h>
#include <clifo.h>
#include <comuni.h>
//#include <causali.h>
//#include <nditte.h>
#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>
#include <multirel.h>
#include "../cg/cglib01.h"
#define TSMAIALCONST 600
///////////////////////////////////////////////////////////
// TRiclassifica_cache
///////////////////////////////////////////////////////////
class TRiclassifica_cache : public TCache
{
TLocalisamfile _multirel;
protected:
virtual TObject* key2obj(const char* key);
public:
const char * sdecode(const char* tab, const TString& cod);
long decode(const char* tab, const TString& cod);
TRiclassifica_cache() : _multirel(LF_MULTIREL) { _multirel.setkey(2);}
};
TObject* TRiclassifica_cache::key2obj(const char* key)
{
TToken_string tok(key);
TString8 tab, cod;
tok.get(0,tab);
tok.get(1, cod);
_multirel.put(MULTI_COD, tab);
_multirel.put(MULTI_FIRST, "");
_multirel.put(MULTI_SECOND, cod);
int err = _multirel.read(_isgteq);
if (err == NOERR && _multirel.get(MULTI_SECOND) == cod)
return new TString(_multirel.get(MULTI_FIRST));
return NULL;
}
long TRiclassifica_cache::decode(const char* tab, const TString& cod)
{
TToken_string tok;
tok.add(tab);
tok.add(cod);
const TString* ric = (const TString*) objptr(tok);
return (ric ? atol(*ric) : 0);
}
const char * TRiclassifica_cache::sdecode(const char* tab, const TString& cod)
{
TToken_string tok;
tok.add(tab);
tok.add(cod);
const TString* ric = (const TString*) objptr(tok);
return ric ? (const char *) *ric : "";
}
TTS_sender& app() { return (TTS_sender&)main_app(); }
///////////////////////////////////////////////////////////
// TTS_textset
///////////////////////////////////////////////////////////
class TTS_textset : public TAS400_recordset
{
TAssoc_array _contatori;
protected:
long add_count(const char* tipo, long n = 1);
protected:
void add_field(const char* trc, const char* name = "Filler", int len = 0, char tipo = 'a',
int from = -1, const char* def = NULL);
public:
virtual bool destroy(TRecnotype r);
virtual const TString& rec_type(TRecnotype r = -1) const;
virtual bool set(const char* field, const TVariant& v);
TTS_textset(const char* query = "");
};
class TIVA_item : public TObject
{
int _row;
long _conto;
long _codiva;
long _codiva11;
real _imponibile;
real _imposta;
public:
int & row() { return _row;}
long & conto() { return _conto;}
long & codiva() { return _codiva;}
long & codiva11() { return _codiva11;}
real & imponibile() { return _imponibile;}
real & imposta() { return _imposta;}
TIVA_item(int row, long conto, long codiva, long codiva11) : _row(row), _conto(conto), _codiva(codiva), _codiva11(codiva11) {}
virtual ~TIVA_item() {}
};
long TTS_textset::add_count(const char* tipo, long i)
{
CHECK(strlen(tipo) == 1, "Tipo record non valido");
real* n = (real*)_contatori.objptr(tipo);
if (n == NULL)
{
n = new real;
_contatori.add(tipo, n);
}
*n += i;
return n->integer();
}
const TString& TTS_textset::rec_type(TRecnotype r) const
{
const TString& t = TAS400_recordset::rec_type(r);
return t;
}
bool TTS_textset::destroy(TRecnotype r)
{
bool ok;
if (r >= 0)
{
const TString4 t = TAS400_recordset::rec_type(r); // Igora subtipo record!
ok = TAS400_recordset::destroy(r);
if (ok)
add_count(t, -1);
}
else
{
ok = TAS400_recordset::destroy(r);
if (ok)
_contatori.destroy();
}
return ok;
}
void TTS_textset::add_field(const char* trc, const char* name, int len,
char tipo, int from, const char* def)
{
const bool required = false;
CHECK(trc && *trc, "Tracciato nullo");
TString80 fname; fname << trc << '.' << name;
const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
const int pos = from - 1;
if (def && *def)
{
CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
TVariant var(def); var.convert_to(t);
create_field(fname, pos, len, t, required, var);
}
else
create_field(fname, pos, len, t, required);
}
bool TTS_textset::set(const char* field, const TVariant& var)
{
const char* err = NULL;
int c = -1;
const TAS400_column_info* info = parse_field(field, c, false);
bool ok = info != NULL;
if (ok)
{
switch (var.type())
{
case _datefld:
if (var.is_zero())
ok = set_field(*info, NULL_VARIANT);
else
{
long ansi = 0;
const TDate d = var.as_date();
if (info->_width == 6)
ansi = d.day()*10000 + d.month()*100 + d.year()%100;
else
ansi = d.date2ansi();
ok = set_field(*info, TVariant(ansi));
}
break;
case _realfld:
if (var.is_zero())
ok = set_field(*info, NULL_VARIANT);
else
{
real v = var.as_real(); v *= CENTO;
ok = set_field(*info, TVariant(v.integer()));
}
break;
default:
ok = set_field(*info, var);
break;
}
if (!ok)
err = TR("Campo obbligatorio non compilato");
}
else
err = TR("Campo non riconosciuto");
if (err != NULL)
{
TString msg;
msg << field << ": " << err;
app().log(2, msg);
}
return ok;
}
TTS_textset::TTS_textset(const char* query)
: TAS400_recordset(TString("AS400(7001,1,6)\n") << query)
{
const char an = 'a';
const char n = 'n';
const bool o = true;
const bool f = false;
add_field("0", "TRF-DITTA", 5, n, 1); // codice ditta multi
add_field("0", "TRF-VERSIONE", 1, n, 6, "3"); // versione
add_field("0", "TRF-TARC", 1, n, 7, "0"); // tipo record
// dati cliente/fornitore
add_field("0", "TRF-COD-CLIFOR", 5, n, 8, "0"); // codice cliente/fornitore
add_field("0", "TRF-RASO", 32, an, 13); // ragione sociale
add_field("0", "TRF-IND", 30, an, 45); // indirizzo
add_field("0", "TRF-CAP", 5, n, 75); // cap
add_field("0", "TRF-CITTA", 25, an, 80); // citta
add_field("0", "TRF-PROV", 2, an, 105); // provincia
add_field("0", "TRF-COFI", 16, an, 107); // codice fiscale
add_field("0", "TRF-PIVA", 11, an, 123); // partita iva
add_field("0", "TRF-PF", 1, an, 134); // persona fisica S/N
add_field("0", "TRF-DIVIDE", 2, n, 135); // posizione spazio tra cognome e nome
add_field("0", "TRF-PAESE", 4, n, 137); // paese estero di residenza
add_field("0", "TRF-PIVA-ESTERO",12, an, 141); // partita iva estera
add_field("0", "TRF-COFI-ESTERO",20, an, 153); // codice fiscale estero
add_field("0", "TRF-SESSO", 1, an, 173); // sesso M/F
add_field("0", "TRF-DTNAS", 8, n, 174); // data di nascita
add_field("0", "TRF-COMNA", 25, an, 182); // comune di nascita
add_field("0", "TRF-PRVNA", 2, an, 207); // provincia di nascita
add_field("0", "TRF-PREF", 4, an, 209); // prefisso telefonico
add_field("0", "TRF-NTELENUM", 20, an, 213); // numero telefonico
add_field("0", "TRF-FAX-PREF", 4, an, 233); // prefisso fax
add_field("0", "TRF-FAX-NUM", 9, an, 237); // numero fax
add_field("0", "TRF-CFCONTO", 7, n, 246); // codice conto di costo abituale
add_field("0", "TRF-CFCODPAG", 4, n, 253); // codice condizioni pagamenti
add_field("0", "TRF-CFBANCA", 5, n, 257); // codice abi
add_field("0", "TRF-CFAGENZIA", 5, n, 262); // codice cab
add_field("0", "TRF-CFINTERM", 1, n, 267); // codice intermerdio clienti/fornitori
// dati fattura
add_field("0", "TRF-CAUSALE", 3, n, 268); // codice causale movimento
add_field("0", "TRF-CAU-DES", 15, an, 271); // descrizione causale
add_field("0", "TRF-CAU-AGG", 18, an, 286); // causale aggiuntiva
add_field("0", "TRF-CAU-AGG-1", 34, an, 304); // ulteriore causale aggiuntiva
add_field("0", "TRF-CAU-AGG-2", 34, an, 338); // ulteriore causale aggiuntiva
add_field("0", "TRF-DATA-REGISTRAZIONE", 8, n, 372); // data registrazione
add_field("0", "TRF-DATA-DOC", 8, n, 380); // data documento
add_field("0", "TRF-NUM-DOC-FOR", 8, n, 388); // numero documento fornitore compreso sezionale
add_field("0", "TRF-NDOC", 5, n, 396); // numero documento
add_field("0", "TRF-SERIE", 2, n, 401); // sezionale iva
add_field("0", "TRF-EC-PARTITA", 6, n, 403); // estratto conto numero partita
add_field("0", "TRF-EC-PARTITA-ANNO", 4, n, 409); // estratto conto anno partita
add_field("0", "TRF-EC-COD-VAL", 3, n, 413); // estratto conto in valuta codice valuta esetera
add_field("0", "TRF-EC-CAMBIO", 13, n, 416); // estratto conto in valuta cambio valuta estera
add_field("0", "TRF-EC-DATA-CAMBIO", 8, n, 429); // estratto conto in valuta data cambio
add_field("0", "TRF-EC-TOT-DOC-VAL", 16, n, 437); // estratto conto in valuta totale documento in valuta
add_field("0", "TRF-EC-TOT-IVA-VAL", 16, n, 453); // estratto conto in valuta totale iva in valuta
add_field("0", "TRF-PLAFOND", 6, n, 469); // mmaaaa riferimento plafond e fatture differite
TString80 field;
// dati iva
for (int i=0; i<8; i++)
{
field.format("TRF-IMPONIB_%d", i);
add_field("0", field, 12, n, 475+(31*i)); // imponibile
field.format("TRF-ALIQ_%d", i);
add_field("0", field, 3, n, 487+(31*i)); // aliquota iva o codice esenzione
field.format("TRF-ALIQ_AGRICOLA_%d", i);
add_field("0", field, 3, n, 490+(31*i)); // aliquota iva di compensazione agricola
field.format("TRF-IVA11_%d", i);
add_field("0", field, 2, n, 493+(31*i)); // codice di memorizzazione per iva11
field.format("TRF-IMPOSTA_%d", i);
add_field("0", field, 11, n, 495+(31*i)); // imposta
}
// totale fattura
add_field("0", "TRF-TOT-FATT", 12, n, 723); // totale fattura
// conti di ricavo/costo
for (i=0; i<8; i++)
{
field.format("TRF-CONTORIC_%d", i);
add_field("0", field, 7, n, 735+(19*i)); // codice conto di ricavo/costo
field.format("TRF-IMP-RIC_%d", i);
add_field("0", field, 12, n, 742+(19*i)); // importo ricavo/costo
}
// dati eventuale pagamentofattura o movimenti diversi
add_field("0", "TRF-CAU-PAGAM", 3, n, 887); // codice causale
add_field("0", "TRF-CAU-DES-PAGAM", 15, an, 890); // descrizione causale
add_field("0", "TRF-CAU-AGG-1-PAGAM", 34, an, 905); // ulteriore descrizione aggiuntiva
add_field("0", "TRF-CAU-AGG-2-PAGAM", 34, an, 939); // ulteriore descrizione aggiuntiva
// altri movimenti
for (i=0; i<80; i++)
{
field.format("TRF-CONTO_%d", i);
add_field("0", field, 7, n, 973+(64*i)); // codice conto
field.format("TRF-DA_%d", i);
add_field("0", field, 1, an, 980+(64*i)); // segno operazione D/A
field.format("TRF-IMPORTO_%d", i);
add_field("0", field, 12, n, 981+(64*i)); // importo
field.format("TRF-CAU-AGGIUNT_%d", i);
add_field("0", field, 18, an, 993+(64*i)); // causale aggiuntiva
field.format("TRF-EC-PARTITA-PAG_%d", i);
add_field("0", field, 6, n, 1011+(64*i)); // estratto conto numero partita
field.format("TRF-EC-PARTITA-ANNO-PAG_%d", i);
add_field("0", field, 4, n, 1017+(64*i)); // estratto conto anno partita
field.format("TRF-EC-IMP-VAL_%d", i);
add_field("0", field, 16, n, 1021+(64*i)); // estratto conto in valuta
}
// ratei e risconti
for (i=0; i<10; i++)
{
field.format("TRF-RIFER-TAB_%d", i);
add_field("0", field, 1, an, 6093+(19*i)); // tabella di riferimento
field.format("TRF-IND-RIGA_%d", i);
add_field("0", field, 2, n, 6094+(19*i)); // indice della tabella
field.format("TRF-DT-INI_%d", i);
add_field("0", field, 8, n, 6096+(19*i)); // data inizio
field.format("TRF-DT-INI_%d", i);
add_field("0", field, 8, n, 6104+(19*i)); // data fine
}
// ndoc a 6 cifre se non bastano le 5 di tf-ndoc
add_field("0", "TRF-DOC6", 6, n, 6283); // ndoc a 6 cifre se non bastano le 5 di trf-doc
// ulteriori dati cliente/fornitore
add_field("0", "TRF-AN-OMONIMI", 1, an, 6289); // considera omonimo
add_field("0", "TRF-AN-TIPO-SOGG", 1, n, 6290); // tipo soggetto ritenuta di acconto
// ulteriori dati ev. pagamento o movimenti diversi
for (i=0; i<80; i++)
{
field.format("TRF-EC-PARTITA-SEZ-PAG_%d", i);
add_field("0", field, 2, n, 6291+(2*i)); // numero sezionale partita estratto conto
}
// ulteriori dati gestione professionista per eventuale pagamento fattura o dati fattura
add_field("0", "TRF-NUM-DOC-PAG-PROF", 7, n, 6451); // numero doc. incasso/pagamento
add_field("0", "TRF-DATA-DOC-PAG-PROF", 8, n, 6458); // data doc. incasso/pagamento
add_field("0", "TRF-RIT-ACC", 12, n, 6466); // ritenuta d'acconto
add_field("0", "TRF-RIT-PREV", 12, n, 6478); // ritenuta previdenziale
add_field("0", "TRF-RIT-1", 12, n, 6490); // altre ritenute 1
add_field("0", "TRF-RIT-2", 12, n, 6502); // 2
add_field("0", "TRF-RIT-3", 12, n, 6514); // 3
add_field("0", "TRF-RIT-4", 12, n, 6526); // 4
// ulteriori dati per unita' produttive ricavi
for (i=0; i<8; i++)
{
field.format("TRF-UNITA-RICAVI_%d", i);
add_field("0", field, 2, n, 6538+(2*i)); //
}
// ulteriori dati per unita' produttive pagamenti
for (i=0; i<80; i++)
{
field.format("TRF-UNITA-PAGAM_%d", i);
add_field("0", field, 2, n, 6554+(2*i)); //
}
// ulteriori dati cliente/fornitore
add_field("0", "TRF-FAX-PREF-1", 4, an, 6714); // prefisso fax sostitutivo
add_field("0", "TRF-FAX-NUM-1", 20, an, 6718); // numero fax sositutivo
add_field("0", "TRF-SOLO-CLIFOR", 1, an, 6738); // C crea solo cliente F crea solo fornitore (non genera primanota)
add_field("0", "TRF-80-SEGUENTE", 1, an, 6739); // s=record successivo identico a quello attuale ma con tabella pag compilata (ultima=u)
// ulteriori dati gestione professionista per eventuale pagamento fattura o dati fattura
add_field("0", "TRF-CONTO-RIT-ACC", 7, n, 6740); // conto ritenuta d'acconto
add_field("0", "TRF-CONTO-RIT-PREV", 7, n, 6747); // conto ritenuta previdenziale
add_field("0", "TRF-CONTO-RIT-1", 7, n, 6754); // conto ritenuta 1
add_field("0", "TRF-CONTO-RIT-2", 7, n, 6761); // conto ritenuta 2
add_field("0", "TRF-CONTO-RIT-3", 7, n, 6768); // conto ritenuta 3
add_field("0", "TRF-CONTO-RIT-4", 7, n, 6775); // conto ritenuta 4
add_field("0", "TRF-DIFFERIMENTO-IVA", 1, an, 6782); // differimento registrazione iva per autotrasportatori S/N
add_field("0", "TRF-STORICO", 1, an, 6783); // aggiornamento storico anagrafica
add_field("0", "TRF-STORICO-DATA", 8, n, 6784); // data aggiornamento storico anagrafica
add_field("0", "TRF-CAUS-ORI", 3, n, 6792); // causale originaria
add_field("0", "TRF-PREV-TIPOMOV", 1, an, 6795); // previsionale
add_field("0", "TRF-PREV-RATRIS", 1, an, 6796); // rateo /risconto
add_field("0", "TRF-PREV-DTCOMP-INI", 8, n, 6797); // data iniziale competenza
add_field("0", "TRF-PREV-DTCOMP-FIN", 8, n, 6805); // data finale competenza
add_field("0", "TRF-PREV-FLAG-CONT", 1, an, 6813); // non contabilizza
add_field("0", "TRF-PREV-RIFERIMENTO",20, an, 6814); // riferimento record interno
add_field("0", "FILLER", 166, an, 6834); // spazio
add_field("0", "FINE-RECORD", 2, an, 7000, "\r\n"); // terminatore record
// Record opzionale
add_field("1", "TRF1-DITTA", 5, n, 1); // codice ditta multi
add_field("1", "TRF1-VERSIONE", 1, n, 6, "3"); // versione
add_field("1", "TRF1-TARC", 1, n, 7, "1"); // tipo record
// intra
add_field("1", "TRF-NUM-AUTOFATT", 5, n, 8); // Numero autofattura Solo per acquisti
add_field("1", "TRF-SERIE-AUTOFATT", 2, n, 13); // Sezionale iva
add_field("1", "TRF-COD-VAL", 3, an, 15); // Codice valuta
add_field("1", "TRF-TOTVAL", 14, n, 18); // Totale importo in valuta (2 dec)
// Movimenti INTRASTAT
add_field("1", "TRF-NOMENCLATURA", 8, an, 32); // Codice nomenclatura combinata
add_field("1", "TRF-IMP-LIRE", 12, n, 40); // Importo in lire
add_field("1", "TRF-IMP-VAL", 12, n, 52); // Importo in valuta (2 DEC)
add_field("1", "TRF-NATURA", 1, an, 64); // Natura della transazione
add_field("1", "TRF-MASSA", 12, n, 65); // Massa netta
add_field("1", "TRF-UN-SUPPL", 12, n, 77); // Unit<69> sostitutiva
add_field("1", "TRF-VAL-STAT", 12, n, 89); // Valore statistico
add_field("1", "TRF-REGIME", 1, an, 101); // Regime ( condizioni di consegna )
add_field("1", "TRF-TRASPORTO", 1, an, 102); // Trasporto
add_field("1", "TRF-PAESE-PROV", 3, n, 103); // Paese di provenienza
add_field("1", "TRF-PAESE-ORIG", 3, n, 106); // Paese di origine
add_field("1", "TRF-PAESE-DEST", 3, n, 109); // Paese di destinazione
add_field("1", "TRF-PROV-DEST", 2, an, 112); // Provincia di destinazione
add_field("1", "TRF-PROV-ORIG", 2, an, 114); // Provincia di origine
add_field("1", "TRF-SEGNO-RET", 1, an, 116); // Segno della rettifica (+/-)
add_field("1", "TRF-INTRA-TIPO", 1, an, 1732); // Tipo movimento INTRASTAT 1=Cessioni 2=Ret.cessioni 3=Acquisti 4=Ret.acq.
add_field("1", "TRF-MESE-ANNO-RIF", 6, n, 1733); // Mmaaaa competenza rettifiche
add_field("1", "FILLER", 173, an, 1739); // Filler
// Ritenuta d<>acconto
add_field("1", "TRF-RITA-TIPO", 1, n, 1912); // 1=Prestazioni e collaborazioni 2=Provvigioni
add_field("1", "TRF-RITA-IMPON", 11, n, 1913); // Imponibile
add_field("1", "TRF-RITA-ALIQ", 4, n, 1924); // Aliquota (2 dec)
add_field("1", "TRF-RITA-IMPRA", 10, n, 1928); // Ritenuta
add_field("1", "TRF-RITA-PRONS", 11, n, 1938); // Se TRF-RITA-TIPO = 1 Indicare l<>importo del contributo integrativo (2%) , se TRF-RITA-TIPO = 2 Indicare l<>importo delle provvigioni non soggette.
add_field("1", "TRF-RITA-MESE", 6, n, 1949); // MMAAAA competenza (pagamento fattura)
add_field("1", "TRF-RITA-CAUSA", 2, n, 1955); // Codice causale prestazione
add_field("1", "TRF-RITA-TRIBU", 4, n, 1957); // Codice tributo
add_field("1", "TRF-RITA-DTVERS", 8, n, 1961); // Data versamento
add_field("1", "TRF-RITA-IMPAG", 11, n, 1969); // Importo versato
add_field("1", "TRF-RITA-TPAG", 1, n, 1980); // Tipo versamento 1=Tesoreria 2=C/C postale 3=Banca
add_field("1", "TRF-RITA-SERIE", 4, an, 1981); // Serie
add_field("1", "TRF-RITA-QUIETANZA", 12, an, 1985); // Quietanza
add_field("1", "TRF-RITA-NUM-BOLL", 12, an, 1997); // Numero bollettino C/C
add_field("1", "TRF-RITA-ABI", 5, n, 2009); // Codice abi
add_field("1", "TRF-RITA-CAB", 5, n, 2014); // Codice cab
add_field("1", "TRF-RITA-AACOMP", 4, n, 2019); // Anno di competenza provvigioni se diverso da quello delle ritenute
add_field("1", "TRF-RITA-CRED", 11, n, 2023); // Credito d<>imposta utilizzato verticalmente per non versare
// Dati contributo INPS e modello GLA/D
add_field("1", "TRF-RITA-SOGG", 1, an, 2034); // Soggetto al contributo S=Si N=No
add_field("1", "TRF-RITA-BASEIMP", 11, n, 2035); // Base imponibile
add_field("1", "TRF-RITA-FRANCHIGIA", 11, n, 2046); // Importo gi<67> assoggettato
add_field("1", "TRF-RITA-CTO-PERC", 11, n, 2057); // Ritenuta conto percipiente
add_field("1", "TRF-RITA-CTO-DITT", 11, n, 2068); // Ritenuta conto ditta
add_field("1", "FILLER", 11, an, 2079); // Filler
add_field("1", "TRF-RITA-DATA", 8, n, 2090); // Data versamento
add_field("1", "TRF-RITA-TOTDOC", 11, n, 2098); // Totale documento
add_field("1", "TRF-RITA-IMPVERS", 11, n, 2109); // Importo versato
add_field("1", "TRF-RITA-DATA-I", 8, n, 2120); // Data inizio
add_field("1", "TRF-RITA-DATA-F", 8, n, 2128); // Data competenza
add_field("1", "TRF-EMENS-ATT", 2, n, 2136); // EMENS - Codice attivit<69>
add_field("1", "TRF-EMENS-RAP", 2, n, 2138); // EMENS - Tipo rapporto
add_field("1", "TRF-EMENS-ASS", 3, n, 2140); // EMENS - Altra assicurazione
add_field("1", "FILLER", 195, an, 2143); // Filler
// Dati portafoglio
add_field("1", "TRF-POR-CODPAG", 3, n, 2338); // Codice condizione di pagamento
add_field("1", "TRF-POR-BANCA", 5, n, 2341); // ABI
add_field("1", "TRF-POR-AGENZIA", 5, n, 2346); // CAB
add_field("1", "TRF-POR-DESAGENZIA", 30, an, 2351); // Descrizione agenzia
add_field("1", "TRF-POR-TOT-RATE", 2, n, 2381); // Numero totale rate
add_field("1", "TRF-POR-TOTDOC", 12, n, 2383); // Totale documenti
// Dettaglio effetti
// La tabella dettaglio effetti (lunghezza complessiva di 804 caratteri) <20> composta da 12 elementi i che comprendono i campi da TRF-POR-NUM-RATA a TRF-POR-TIPO-RD. Le posizioni indicate sono quindi relative al primo elemento
add_field("1", "TRF-POR-NUM-RATA", 2, n, 2395); // Numero rata
add_field("1", "TRF-POR-DATASCAD", 8, n, 2397); // Data scadenza
add_field("1", "TRF-POR-TIPOEFF", 1, n, 2405); // Tipo effetto 1=Tratta 2=Ricevuta bancaria 3=Rimessa diretta 4=Cessioni 5=Solo descrittivo 6=Contanti alla consegna
add_field("1", "TRF-POR-IMPORTO-EFF", 12, n, 2406); // Importo effetto
add_field("1", "TRF-POR-IMPORTO-EFFVAL", 15, n, 2418); // Portafoglio in valuta. Importo effetto in valuta (3 dec)
add_field("1", "TRF-POR-IMPORTO-BOLLI", 12, n, 2433); // Importo bolli
add_field("1", "TRF-POR-IMPORTO-BOLIVAL", 15, n, 2445); // Portafoglio in valuta. Importo bolli in valuta (3 dec)
add_field("1", "TRF-POR-FLAG", 1, an, 2460); // Stato effetto 0=Aperto 1=Chiuso 2=Insoluto 3=Personalizzato
add_field("1", "TRF-POR-TIPO-RD", 1, an, 2461); // Sottotipo rimessa diretta
add_field("1", "TRF-POR-CODAGE", 4, n, 3199); // Codice agente
add_field("1", "FILLER", 3797, an, 3203); // Filler
add_field("1", "FINE1-RECORD", 2, an, 7000, "\r\n"); // terminatore record 0D0A HEX 0D non obbligatorio )
}
///////////////////////////////////////////////////////////
// TTS_sender
///////////////////////////////////////////////////////////
bool TTS_sender::new_rec(const char* t)
{
CHECK(t && *t, "Tipo non valido");
return _tsfile->new_rec(t) >= 0;
}
void TTS_sender::log(int sev, const char* msg)
{
if (_log != NULL)
{
if (sev > 0 && _tsfile != NULL)
{
TString m;
m << TR("Record") << ' ' << _tsfile->rec_type() << ": " << msg;
_log->log(sev, m);
_errors_logged = true;
}
else
_log->log(sev, msg);
}
}
void TTS_sender::set(const char* field, const TVariant& var)
{
_tsfile->set(field, var);
}
const TVariant& TTS_sender::get(const char* field)
{
return _tsfile->get(field);
}
void TTS_sender::remove_last()
{
_tsfile->destroy(_tsfile->last());
_tsfile->move_last();
}
bool TTS_sender::add_optional_rec(bool rec_to_add)
{
if (rec_to_add)
{
new_rec("1");
set("TRF1-DITTA", _dittamulti);
}
return false;
}
bool TTS_sender::add_regol(TRecordset& mov, bool rec_to_add)
{
rec_to_add = add_optional_rec(rec_to_add);
TString4 codval = mov.get(MOV_CODVALI).as_string();
real corrvaluta = mov.get(MOV_CORRVALUTA).as_real();
if (codval.blank())
{
codval = TCurrency::get_firm_val();
corrvaluta = mov.get(MOV_TOTDOC).as_real();
}
codval = scod2ricl("TSVAL", codval);
set("TRF-COD-VAL", codval);
if (mov_intra(mov))
{
corrvaluta *= CENTO;
set("TRF-TOTVAL", corrvaluta);
}
const TRecnotype pos = mov.current_row();
if (find_regolarizzazione(mov))
{
set("TRF-NUM-AUTOFATT", mov.get(MOV_PROTIVA).as_int());
TString4 codice = scod2ricl("TSREG", mov.get(MOV_REG));
const long codreg = atol(codice.mid(1));
set("TRF-SERIE-AUTOFATT", codreg);
}
else
{
if (mov_intra(mov))
log(2, TR("Manca la regolarizzazion del movimento intra"));
else
log(2, TR("Manca la regolarizzazion del movimento reverse charge"));
}
mov.move_to(pos);
return rec_to_add;
}
void TTS_sender::add_ulteriori(TRecordset& mov)
{
bool rec_to_add = true;
if (mov_intra(mov) || mov_reverse_charge(mov))
add_regol(mov, rec_to_add);
}
void TTS_sender::add_ratei_risconti(const TRecordset& mov)
{
}
void TTS_sender::add_new_rec(const TRecordset& mov)
{
set("TRF-80-SEGUENTE", "S");
if (new_rec("0"))
{
add_header(mov, false);
set("TRF-80-SEGUENTE", "U");
}
}
void TTS_sender::add_diversi(const TRecordset& mov, const bool moviva)
{
const bool vendite = mov.get(MOV_TIPO).as_string()[0] != 'F';
long contoclifor = 0L;
char seznor = ' ';
if (moviva)
{
if (test_swap(mov))
seznor = vendite ? 'D' : 'A';
else
seznor = vendite ? 'A' : 'D';
}
const bool dont_send_clifo = _riclassifica.is_key("TSNOHCLI");
TRecordset & rmov = rmovrecset(mov);
int i = 0 , j = 0, k = 0;
bool added_rec = false, valid_rec = false;
bool first_cli = true;
TString80 field;
TString16 key;
const bool intra_rev = add_iva_to_mov(mov);
bool ok = rmov.move_first();
const bool as400 = moviva && (rmov.get(RMV_ROWTYPE).as_string()[0] <= ' ');
for (; ok; ok = rmov.move_next(), i++)
{
bool riga_ritenute = false;
const int gr = rmov.get(RMV_GRUPPO).as_int();
const int co = rmov.get(RMV_CONTO).as_int();
const long so = rmov.get(RMV_SOTTOCONTO).as_int();
char t = rmov.get(RMV_TIPOC).as_string()[0];
bool one_clifor =(dont_send_clifo && t > ' ');
const long contoricl = bill2ricl(t, gr, co, so, one_clifor);
bool add_rec = (j >= 80) || (dont_send_clifo && t > ' ');
if (moviva)
{
if (as400)
{
if (t > ' ' && first_cli)
{
first_cli = false;
contoclifor = contoricl;
continue;
}
key.format("%08ld", contoricl);
if (_contiiva.is_key(key))
continue;
if (_contirit.is_key(key))
riga_ritenute = true;
else
{
if (k < 8)
{
const real importo = rmov.get(RMV_IMPORTO).as_real();
const char sez = rmov.get(RMV_SEZIONE).as_string()[0];
TImporto i(sez, importo);
i.normalize(seznor);
field.format("TRF-CONTORIC_%d", k);
set(field, contoricl);
field.format("TRF-IMP-RIC_%d", k);
set(field, i.valore());
k++;
}
else
log(2, TR("Registrazione con pi<70> di 8 conti di costo/ricavo"));
continue;
}
}
else
{
const char tiporiga = rmov.get(RMV_ROWTYPE).as_string()[0];
switch (tiporiga)
{
case 'T':
first_cli = false;
contoclifor = contoricl;
case 'I':
case 'D':
case 'N':
continue;
case 'F':
case 'S':
riga_ritenute = true;
break;
default:
break;
}
}
}
if (add_rec)
{
if (!first_cli)
{
add_new_rec(mov);
j = 0;
added_rec = true;
valid_rec = false;
}
if (dont_send_clifo && get("TRF-RASO").as_string().blank() && t > ' ' && so > 0 )
add_clifor(t, so);
}
if (!moviva && t > ' ' && first_cli)
first_cli = false;
if (!(riga_ritenute && intra_rev))
{
field.format("TRF-CONTO_%d", j);
set(field, contoricl);
field.format("TRF-IMPORTO_%d", j);
set(field, rmov.get(RMV_IMPORTO));
field.format("TRF-DA_%d", j);
set(field, rmov.get(RMV_SEZIONE));
j++;
if (riga_ritenute)
{
if (contoclifor > 0L)
{
field.format("TRF-CONTO_%d", j);
set(field, contoclifor);
field.format("TRF-IMPORTO_%d", j);
set(field, rmov.get(RMV_IMPORTO));
field.format("TRF-DA_%d", j);
const TString4 sez = rmov.get(RMV_SEZIONE).as_string() == "D" ? "A" :"D";
set(field, sez);
j++;
}
else
log(2, "Conto cliente/formitore non trovato per giroconto ritenute o intra o reverse charge");
}
}
valid_rec = true;
}
if (added_rec && !valid_rec)
{
remove_last();
set("TRF-80-SEGUENTE", "U");
}
}
void TTS_sender::add_conti_ricavo_costo(const TRecordset& mov)
{
TRecordset & rmov = rmovrecset(mov);
rmov.move_first();
const char tiporiga = rmov.get(RMV_ROWTYPE).as_string()[0];
if (tiporiga <= ' ')
return;
TRecordset & riva = rivarecset(mov);
TString codice = scod2ricl("TSREG", mov.get(MOV_REG));
const bool corrispettivo = codice[0] == 'C';
int i = 0, j = 0;
real fattore = UNO;
TString16 key;
if (test_swap(mov))
fattore = -fattore;
_iva.destroy();
for (bool ok = riva.move_first(); ok; ok = riva.move_next(), i++)
{
const int gr = riva.get(RMI_GRUPPO).as_int();
const int co = riva.get(RMI_CONTO).as_int();
const long so = riva.get(RMI_SOTTOCONTO).as_int();
char t = riva.get(RMI_TIPOC).as_string()[0];
const long hcli = mov.get(MOV_CODCF).as_int();
const long contoricl = bill2ricl(t, gr, co, so, hcli == so);
real imponibile = riva.get(RMI_IMPONIBILE).as_real() * fattore;
if (corrispettivo)
{
if (riva.get(RMI_IMPOSTA).is_zero())
{
TCodiceIVA c(riva.get(RMI_CODIVA).as_string());
c.scorpora(imponibile);
}
}
else
{
//da modificare nella 3.1
const bool indetraibile = riva.get(RMI_TIPODET).as_int() > 0;
if (indetraibile)
imponibile += riva.get(RMI_IMPOSTA).as_real() * fattore;
}
key.format("%08ld", contoricl);
TIVA_item * item = (TIVA_item *) _iva.objptr(key);
if (item == NULL)
{
item = new TIVA_item(j++, contoricl, 0L, 0L);
_iva.add(key, item);
}
item->imponibile() += imponibile;
}
TString80 field;
if (_iva.items() > 8)
log(2, TR("Registrazione con pi<70> di 8 conti di costo/ricavo"));
FOR_EACH_ASSOC_OBJECT(_iva, o, k, it)
{
TIVA_item & item = (TIVA_item &) *it;
const int row = item.row();
if (row < 8)
{
field.format("TRF-CONTORIC_%d", row);
set(field, item.conto());
field.format("TRF-IMP-RIC_%d", row);
set(field, item.imponibile());
}
}
}
void TTS_sender::add_tot_fattura(const TRecordset& mov)
{
real totdoc = mov.get(MOV_TOTDOC).as_real();
const real ritfis = mov.get(MOV_RITFIS).as_real();
const real ritsoc = mov.get(MOV_RITSOC).as_real();
if (ritfis != ZERO)
totdoc += ritfis;
if (ritsoc != ZERO)
{
if (swap_ritsoc(mov)) // Somma ritenute sociali con segno
totdoc -= ritsoc;
else
totdoc += ritsoc;
}
if (test_swap(mov))
totdoc = -totdoc;
set("TRF-TOT-FATT", totdoc);
}
void TTS_sender::add_datiiva(const TRecordset& mov)
{
TRecordset & rmoviva = rivarecset(mov);
TString codice = scod2ricl("TSREG", mov.get(MOV_REG));
const bool corrispettivo = codice[0] == 'C';
int i = 0, j = 0;
real fattore = UNO;
TString16 key;
const int codiva11rev = mov_reverse_charge(mov) ? cod2ricl("TSI11", TVariant(iva11_reverse(mov))) : 0L;
if (test_swap(mov))
fattore = -fattore;
_iva.destroy();
for (bool ok = rmoviva.move_first(); ok; ok = rmoviva.move_next(), i++)
{
real imponibile = rmoviva.get(RMI_IMPONIBILE).as_real() * fattore;
real imposta = rmoviva.get(RMI_IMPOSTA).as_real() * fattore;
if (corrispettivo)
{
if (imposta == ZERO)
{
TCodiceIVA c(rmoviva.get(RMI_CODIVA).as_string());
imposta = c.scorpora(imponibile);
}
}
long codiva = cod2ricl("TSIVA", rmoviva.get(RMI_CODIVA));
long codiva11 = 0L;
//da modificare nella 3.1
const bool indetraibile = rmoviva.get(RMI_TIPODET).as_int() > 0;
if (indetraibile)
codiva += TSMAIALCONST; // maialata
if (codiva11rev > 0L)
codiva11 = codiva11rev;
else
if (rmoviva.get(RMI_TIPOCR).as_int() > 0)
codiva11 = cod2ricl("TSI11", rmoviva.get(RMI_TIPOCR));
key.format("%04ld%04ld", codiva, codiva11);
TIVA_item * item = (TIVA_item *) _iva.objptr(key);
if (item == NULL)
{
item = new TIVA_item(j++, 0L, codiva, codiva11);
_iva.add(key, item);
}
item->imponibile() += imponibile;
item->imposta() += imposta;
}
TString80 field;
if (_iva.items() > 8)
log(2, TR("Registrazione con piu di 8 righe IVA"));
FOR_EACH_ASSOC_OBJECT(_iva, o, k, it)
{
TIVA_item & item = (TIVA_item &) *it;
const int row = item.row();
if (row < 8)
{
field.format("TRF-IMPONIB_%d", row);
set(field, item.imponibile());
field.format("TRF-ALIQ_%d", row);
set(field, item.codiva());
field.format("TRF-ALIQ_AGRICOLA_%d", row);
//set(field,field // dato non presente CHIEDERE
field.format("TRF-IVA11_%d", row);
set(field, item.codiva11());
field.format("TRF-IMPOSTA_%d", row);
set(field, item.imposta());
}
}
}
void TTS_sender::add_header(const TRecordset& mov, const bool fullhesd)
{
const bool moviva = !mov.get(MOV_REG).is_empty();
const long codcaus = cod2ricl("TSCAU", mov.get(MOV_CODCAUS));
// dati obbligatori
set("TRF-DITTA", _dittamulti);
set("TRF-CAUSALE", codcaus);
TString descaus(decode_causale(mov));
set("TRF-CAU-DES", descaus.left(15));
const TDate datareg(mov.get(MOV_DATAREG).as_string());
set("TRF-DATA-REGISTRAZIONE", datareg.string(full, '\0'));
const TDate datadoc( mov.get(MOV_DATADOC).as_string());
set("TRF-DATA-DOC", datadoc.string(full, '\0'));
TString numdoc(mov.get(MOV_NUMDOC).as_string());
TString codice = moviva ? scod2ricl("TSREG", mov.get(MOV_REG)) : EMPTY_STRING;
numdoc.left(6);
if (numdoc.full())
numdoc << codice.mid(1);
set("TRF-NUM-DOC-FOR", numdoc);
set("TRF-NDOC", mov.get(MOV_PROTIVA));
const bool send_clifo = !_riclassifica.is_key("TSNOHCLI");
if (send_clifo)
set("TRF-COD-CLIFOR", mov.get(MOV_CODCF));
if (moviva)
{
const long codreg = atol(codice.mid(1));
set("TRF-SERIE", codreg);
}
}
void TTS_sender::get_citta_provincia(const TRecordset& cli, TString & dencom, TString & provcom, bool nascita)
{
TString16 key;
if (nascita)
{
key << cli.get(CLI_STATONASC);
key << '|' << cli.get(CLI_COMNASC);
}
else
{
key << cli.get(CLI_STATOCF);
key << '|' << cli.get(CLI_COMCF);
if (key.len() < 5)
{
key = "|";
key << cap2comune(cli.get(CLI_CAPCF).as_string(), cli.get(CLI_LOCCF).as_string());
}
}
const TRectype& com = cache().get(LF_COMUNI, key);
dencom = com.get(COM_DENCOM);
provcom = com.get(COM_PROVCOM);
if (!nascita)
{
const TString& localita = cli.get(CLI_LOCCF).as_string();
if (localita.full() && xvt_str_fuzzy_compare(localita, dencom) < 0.75)
{
dencom.insert(", ");
dencom.insert(localita);
}
}
}
void TTS_sender::add_clifor(char tipocf, long codcf)
{
// dati clienti/fornitore
if (codcf != 0)
{
const TRecordset& cli = clirecset(tipocf, codcf);
const char tipocf = cli.get(CLI_TIPOCF).as_string()[0];
TString80 indirizzo;
indirizzo << cli.get(CLI_INDCF) << ' '
<< cli.get(CLI_CIVCF) << ' '
<< cli.get(CLI_LOCCF);
TString ragsoc(cli.get(CLI_RAGSOC).as_string());
const char tipopers = cli.get(CLI_TIPOPERS).as_string()[0];
const bool fisica = tipopers=='F';
int divide = 0;
if (fisica)
{
TString80 r1(ragsoc.left(30));
TString80 r2(ragsoc.mid(30));
r1.trim();
r2.trim();
ragsoc = r1;
divide = ragsoc.len() + 1;
ragsoc << " " << r2;
}
set("TRF-RASO", ragsoc);
set("TRF-IND", indirizzo);
set("TRF-CAP", cli.get(CLI_CAPCF));
TString dencom;
TString4 provcom;
get_citta_provincia(cli, dencom, provcom);
set("TRF-CITTA", dencom.left(80));
set("TRF-PROV", provcom);
set("TRF-COFI", cli.get(CLI_COFI));
set("TRF-PIVA", cli.get(CLI_PAIV));
set("TRF-PF", fisica ? "S" : "N");
set("TRF-DIVIDE", divide);
const long stato = cod2ricl("TSNAZ", cli.get(CLI_STATOCF));
set("TRF-PAESE", stato);
//set("TRF-PIVA-ESTERO",); // partita iva estera
//set("TRF-COFI-ESTERO",); // codice fiscale estero
if (fisica)
{
//set("TRF-SESSO",); // sesso M/F
const TDate dnasc(cli.get(CLI_DATANASC).as_string());
set("TRF-DTNAS", dnasc.string(full, '\0'));
get_citta_provincia(cli, dencom, provcom, true);
set("TRF-COMNA", dencom.left(80));
set("TRF-PRVNA", provcom);
}
set("TRF-PREF", cli.get(CLI_PTEL));
set("TRF-NTELENUM", cli.get(CLI_TEL));
set("TRF-FAX-PREF", cli.get(CLI_PFAX));
set("TRF-FAX-NUM", cli.get(CLI_FAX));
if (tipocf == 'F')
{
const int gr = cli.get(CLI_GRUPPORIC).as_int();
const int co = cli.get(CLI_CONTORIC).as_int();
const int so = cli.get(CLI_SOTTOCRIC).as_int();
char t = ' ';
const long contoricl = bill2ricl(t, gr, co, so);
set("TRF-CFCONTO", contoricl);
}
const long codpag = cod2ricl("TSCDP", cli.get(CLI_CODPAG));
set("TRF-CFCODPAG", codpag);
set("TRF-CFBANCA", cli.get(CLI_CODABI));
set("TRF-CFAGENZIA", cli.get(CLI_CODCAB));
}
}
void TTS_sender::add_mov(TRecordset& mov)
{
TString msg; msg << TR("Registrazione n.") << ' ' << mov.get(MOV_NUMREG);
log(0, msg);
if (new_rec("0"))
{
char tipocf = mov.get(MOV_TIPO).as_string()[0];
long codcf = mov.get(MOV_CODCF).as_int();
add_clifor(tipocf, codcf);
add_header(mov);
const bool moviva = !mov.get(MOV_REG).is_empty();
if (moviva)
{
add_datiiva(mov);
add_tot_fattura(mov);
add_conti_ricavo_costo(mov);
}
add_ratei_risconti(mov); // Non ce li abbiamo micca!
add_diversi(mov, moviva);
add_ulteriori(mov);
}
}
const long TTS_sender::bill2ricl(char & t, int gr, int co, long so, const bool header_cli)
{
long codricl = 0;
if (gr > 0)
{
const char* const tiporic = "TSCONTI";
const bool ricl = _riclassifica.is_key(tiporic);
if (ricl)
{
TToken_string cod;
cod.add(tiporic);
cod.add(gr);
cod.add(co);
if (t <= ' ')
cod.add(so);
// Provo il sottoconto ma se non riesco provo con conto e poi anche gruppo
for (int c = 3; c > 0 && codricl <= 0; c--)
{
codricl = atol(_conti->get(cod, "CODICE"));
cod.add(0, c);
}
if (codricl <= 0)
{
TString msg;
msg << TR("Conto") << " " << gr << " " << co << " " << so << " :" << TR("Non presente in tabella");
log(2, msg);
}
else
{
if (codricl % 10000 > 0)
t = ' ';
if (t > ' ')
{
if (header_cli)
{
if (t == 'C')
codricl = 9999999L;
else
codricl = 9999998L;
}
else
codricl += so;
}
}
}
else
codricl = gr*100000+co*1000+so;
}
return codricl;
}
const TString & TTS_sender::scod2ricl(const char* tab, const TString& cod)
{
TString & codricl = get_tmp_string();
if (cod.full())
{
const bool ricl = _riclassifica.is_key(tab);
const char* err = NULL;
if (ricl)
{
codricl = _tabelle->sdecode(tab, cod);
if (codricl.blank())
err = TR("Non presente in tabella");
}
else
codricl = cod;
if (err)
{
TString msg;
msg << TR("Codice") << " " << cod << " " << TR("Tabella") << " " << tab << " :" << err;
log(2, msg);
}
}
return codricl;
}
const TString & TTS_sender::scod2ricl(const char* tab, const TVariant& cod)
{
return scod2ricl(tab, cod.as_string());
}
const long TTS_sender::cod2ricl(const char* tab, const TString& cod)
{
long codricl = 0;
if (cod.full())
{
const bool ricl = _riclassifica.is_key(tab);
const char* err = NULL;
if (ricl)
{
codricl = _tabelle->decode(tab, cod);
if (codricl <= 0)
err = TR("Non presente in tabella");
}
else
{
if (real::is_natural(cod))
codricl = atol(cod);
else
err = TR("Non e' un codice numerico");
}
if (err)
{
TString msg;
msg << TR("Codice") << " " << cod << " " << TR("Tabella") << " " << tab << " :" << err;
log(2, msg);
}
}
return codricl;
}
const long TTS_sender::cod2ricl(const char* tab, const TVariant& cod)
{
return cod2ricl(tab, cod.as_string());
}
void TTS_sender::set_parameters()
{
TConfig configtc(CONFIG_DITTA, "tc");
_dittamulti = configtc.get("TSDitta");
TAssoc_array& tab = configtc.list_variables();
FOR_EACH_ASSOC_STRING(tab, h, k, v)
{
TString16 var(k);
if (var.starts_with("TSR"))
{
const bool ric = (*v > ' ') && strchr("1SXY", *v) != NULL;
if (ric)
{
var.format("TS%s", (const char *)var.mid(3));
_riclassifica.add(var, NULL);
}
}
}
int i = 0, gr = 0;
for (i = 0, gr = configtc.get_int("TSGIVA", NULL, i); gr > 0; i++, gr = configtc.get_int("TSGIVA", NULL, i))
{
int co = configtc.get_int("TSCIVA", NULL, i);
long so = configtc.get_long("TSSIVA", NULL, i);
char t = ' ';
long contoricl = bill2ricl(t, gr, co, so);
TString16 key; key.format("%08ld", contoricl);
_contiiva.add(key, NULL);
}
for (i = 0, gr = configtc.get_int("TSGRIT", NULL, i); gr > 0; i++, gr = configtc.get_int("TSGRIT", NULL, i))
{
int co = configtc.get_int("TSCRIT", NULL, i);
long so = configtc.get_long("TSSRIT", NULL, i);
char t = ' ';
long contoricl = bill2ricl(t, gr, co, so);
TString16 key; key.format("%08ld", contoricl);
_contirit.add(key, NULL);
}
}
bool TTS_sender::create()
{
_tabelle = new TRiclassifica_cache;
_conti = new TRecord_cache(LF_RICLPDC, 3);
set_parameters();
return TSkeleton_application::create();
}
bool TTS_sender::destroy()
{
delete _conti;
delete _tabelle;
return TSkeleton_application::destroy();
}
void TTS_sender::main_loop()
{
TMask & m = get_mask();
while (m.run() != K_QUIT)
{
const char* const title = TR("Invio a TeamSystem");
_tsfile = new TTS_textset;
_log = new TLog_report(title);
_errors_logged = false;
TRecordset & mov = movrecset();
TProgind pi(mov.items(), TR("Scansione movimenti"), true, true);
for (bool ok = mov.move_first(); ok; ok = mov.move_next())
{
if (!pi.addstatus(1))
break;
if (!mov_regolarizzazione(mov))
add_mov(mov);
}
TReport_book book;
book.add(*_log);
#ifdef DBG
TAS400_report rep(*_tsfile);
book.add(rep);
#endif
book.preview();
bool save = true;
if (_errors_logged)
{
save = yesno_box(TR("Sono stati riscontrati uno o piu' errori:\n"
"Si desidera salvare il file ugualmente?"));
}
if (save)
{
TFilename name = m.get(F_PATH);
name.add(m.get(F_FILE));
_tsfile->save_as(name);
postprocess_movs(mov);
}
delete _log;
_log = NULL;
delete _tsfile;
_tsfile = NULL;
}
}
Reference in New Issue View Git Blame Copy Permalink