diff --git a/tc/ipconf.h b/tc/ipconf.h index 68329164f..a19bc71b0 100755 --- a/tc/ipconf.h +++ b/tc/ipconf.h @@ -8,9 +8,10 @@ #define F_RICLCAU 109 #define F_RICLCONTI 110 #define F_RICLVALUTE 111 +#define F_RICLCCONS 112 #define F_RIPRISTINO 121 #define F_ULTINVIO 122 -#define F_EMCAU 123 +#define F_ULTSCADID 123 #define F_LIVPC1 124 #define F_LIVPC2 125 #define F_LIVPC3 126 diff --git a/tc/tc2100.cpp b/tc/tc2100.cpp index ff551dfcd..5d49702dc 100755 --- a/tc/tc2100.cpp +++ b/tc/tc2100.cpp @@ -1,7 +1,7 @@ #include "tc2.h" #include "tctbico.h" -// gestione tabelle Zucchetti +// gestione tabelle IPSOA #include #include #include diff --git a/tc/tc2300a.uml b/tc/tc2300a.uml index 4fb799c5b..662377d1f 100755 --- a/tc/tc2300a.uml +++ b/tc/tc2300a.uml @@ -77,53 +77,66 @@ BEGIN FIELD IPRVAL END +BOOLEAN F_RICLCCONS +BEGIN + PROMPT 2 14 "Trascodifica condizioni di consegna" + FIELD IPRICC +END + NUMBER F_LIVPC1 2 BEGIN - PROMPT 2 14 "Lunghezza livelli piano dei conti : 1 " + PROMPT 2 16 "Lunghezza livelli piano dei conti : 1 " FIELD IPLIVPC[1] END NUMBER F_LIVPC2 2 BEGIN - PROMPT 46 14 "2 " + PROMPT 46 16 "2 " FIELD IPLIVPC[2] END NUMBER F_LIVPC3 2 BEGIN - PROMPT 52 14 "3 " + PROMPT 52 16 "3 " FIELD IPLIVPC[3] END NUMBER F_LIVPC4 2 BEGIN - PROMPT 58 14 "4 " + PROMPT 58 16 "4 " FIELD IPLIVPC[4] END NUMBER F_LIVPC5 2 BEGIN - PROMPT 64 14 "5 " + PROMPT 64 16 "5 " FIELD IPLIVPC[5] END NUMBER F_LIVPC6 2 BEGIN - PROMPT 70 14 "6 " + PROMPT 70 16 "6 " FIELD IPLIVPC[6] END BOOLEAN F_RIPRISTINO BEGIN - PROMPT 2 16 "Ripristina alla data" - MESSAGE FALSE DISABLE,F_ULTINVIO - MESSAGE TRUE ENABLE,F_ULTINVIO + PROMPT 2 18 "Ripristina alla data" + MESSAGE FALSE DISABLE,F_ULTINVIO|DISABLE,F_ULTSCADID + MESSAGE TRUE ENABLE,F_ULTINVIO|ENABLE,F_ULTSCADID END DATE F_ULTINVIO BEGIN - PROMPT 42 16 "Data ultimo invio " - FIELD TSULTINV + PROMPT 42 18 "Data ultimo invio " + FIELD IPULTINV + FLAGS "D" +END + +NUMBER F_ULTSCADID 10 +BEGIN + PROMPT 62 18 "Ultimo ID scadenze " + FIELD IPULTSCADID FLAGS "D" END diff --git a/tc/tc2500.cpp b/tc/tc2500.cpp index a7f410a29..a1cd0f5be 100755 --- a/tc/tc2500.cpp +++ b/tc/tc2500.cpp @@ -5,7 +5,6 @@ class TTeamSystem_multirel_app : public TMultirel_application { - bool _use_tab; protected: virtual void set_descr(TMask & m, const TString & desc); @@ -20,7 +19,7 @@ protected: public: - TTeamSystem_multirel_app() : _use_tab(true) {} + TTeamSystem_multirel_app() {} virtual ~TTeamSystem_multirel_app() {} }; @@ -32,7 +31,7 @@ void TTeamSystem_multirel_app::set_descr(TMask & m, const TString & desc) void TTeamSystem_multirel_app::get_mask_name(TString& tabname) const { TMultirel_application::get_mask_name(tabname); - tabname.overwrite("ts", 2); + tabname.overwrite("ip", 2); } void TTeamSystem_multirel_app::init_query_mode(TMask& m) @@ -40,15 +39,15 @@ void TTeamSystem_multirel_app::init_query_mode(TMask& m) TMultirel_application::init_query_mode(m); m.show(-1); m.hide(-2); - m.enable(-3, _use_tab); + m.enable(-3); } void TTeamSystem_multirel_app::init_query_insert_mode(TMask& m) { TMultirel_application::init_query_insert_mode(m); - m.show(-1, !_use_tab); - m.show(-2, _use_tab); - m.enable(-3, _use_tab); + m.hide(-1); + m.show(-2); + m.enable(-3); } void TTeamSystem_multirel_app::init_modify_mode(TMask& m) @@ -76,11 +75,8 @@ bool TTeamSystem_multirel_app::user_create() if (ok) { TConfig config(CONFIG_DITTA); - _use_tab = config.get_bool("TSUSECMTAB"); TMask & m = *get_mask(); - m.show(-10, _use_tab); - m.show(-20, !_use_tab); set_search_field(F_CODTAB); } return ok; diff --git a/tc/tc2700.cpp b/tc/tc2700.cpp index 432815be1..c932d4c8b 100755 --- a/tc/tc2700.cpp +++ b/tc/tc2700.cpp @@ -2,25 +2,43 @@ #include "tc2700.h" #include "tc2700a.h" +#include +#include #include #include -#include -#include #include +#include +#include #include #include -#include -#include -#include +#include "../in/intra.h" +#include "../in/rintra.h" #include -#include #include #include +#include +#include #include +#include #include "../cg/cglib01.h" -#include "../cg/cg2103.h" +#include "../cg/cglib03.h" + +#define CFLD "C" +#define INTFLD "INT" +#define NPFLD "NP" +#define NUFLD "NU" +#define FLFLD "FL" +#define DATEFLD "DATE" + +#define CAU "IPCAU" +#define CDP "IPCDP" +#define IVA "IPIVA" +#define ICC "IPICC" // aggiungere +#define NAZ "IPNAZ" +#define REG "IPREG" +#define VAL "IPVAL" bool TIP_mask::apply_filter(const TRecordset& righe) const { @@ -78,125 +96,548 @@ TIP_mask::~TIP_mask() serialize(true); } -bool TIP_campo_sender::destroy() +/////////////////////////////////////////////////////////// +// TCausali_cache +/////////////////////////////////////////////////////////// + +TObject* TCausali_cache::key2obj(const char* key) { - delete _mask; - return TIP_sender::destroy(); + // Metodo bastardo per evitare TToken_string temporanee "a randa" + // sfrutto chiave a lunghezza fissa + const int anno = atoi(key); + const char* codice = key+5; + TCausale* pcaus = new TCausale(codice, anno); + return pcaus; } -TRecordset & TIP_campo_sender::movrecset() +const TCausale& TCausali_cache::causale(const char* codice, int annoiva) { - const TMask & m = get_mask(); - const TDate from = m.get_date(F_DATA_DA); - const TDate to = m.get_date(F_DATA_AL); - TRecordset * mov = get_recset(LF_MOV); + // Metodo bastardo per evitare TToken_string temporanee "a randa" + // creo chiave a lunghezza fissa anno+codice = 9999|AAA + TString8 key; + key.format("%04d|%s", annoiva, codice); + return *(const TCausale*)objptr(key); +} - if (mov == NULL) +/////////////////////////////////////////////////////////// +// TRiclassifica_cache +/////////////////////////////////////////////////////////// + +HIDDEN const char* const __tiporicconti = "IPCONTI"; + +TObject* TIPRiclassifica_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, cod); + _multirel.zero(MULTI_SECOND); + if (_multirel.read() == NOERR) + return new TString(_multirel.get(MULTI_DATA)); + return NULL; +} + +long TIPRiclassifica_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 * TIPRiclassifica_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 : ""; +} + + +const long IPbill2ricl(char & t, int gr, int co, long so) +{ + TRecord_cache * __conti = NULL; + + if (__conti == NULL) + __conti = new TRecord_cache(LF_RICLPDC, 1); + + long codricl = 0; + if (gr > 0) { - TString query = "USE MOV KEY 2 SELECT INVIATO!=\"X\""; + TToken_string cod; + cod.add(__tiporicconti); + cod.add(gr); + cod.add(co); + if (t <= ' ') + cod.add(so); - query << "\nFROM DATAREG=#DATA_DA"; - query << "\nTO DATAREG=#DATA_AL"; - - mov = set_recset(LF_MOV, ::create_recordset(query)); - } - mov->set_var("#DATA_DA", TVariant(from)); - mov->set_var("#DATA_AL", TVariant(to)); - return *mov; -} - -TRecordset & TIP_campo_sender::rmovrecset(const TRecordset & mov) -{ - TRecordset * rmov = get_recset(LF_RMOV); - - if (rmov == NULL) - rmov = set_recset(LF_RMOV, ::create_recordset("USE RMOV\nFROM NUMREG=#NUMREG\nTO NUMREG=#NUMREG")); - - const TVariant & numreg = mov.get(MOV_NUMREG); - - if (numreg != rmov->get("#NUMREG")) - rmov->set_var("#NUMREG", numreg); - return *rmov; -} - -TRecordset & TIP_campo_sender::rivarecset(const TRecordset & mov) -{ - TRecordset * rmoviva = get_recset(LF_RMOVIVA); - - if (rmoviva == NULL) - rmoviva = set_recset(LF_RMOVIVA, ::create_recordset("USE RMOVIVA\nFROM NUMREG=#NUMREG\nTO NUMREG=#NUMREG")); - - const TVariant & numreg = mov.get(MOV_NUMREG); - - if (numreg != rmoviva->get("#NUMREG")) - rmoviva->set_var("#NUMREG", numreg); - return *rmoviva; -} - -const TRecordset& TIP_campo_sender::clirecset(const char tipocf, const long codcf) -{ - TRecordset * clifo = get_recset(LF_CLIFO); - - if (clifo == NULL) - clifo = set_recset(LF_CLIFO, ::create_recordset("USE CLIFO\nFROM TIPOCF=#TIPOCF CODCF=#CODCF\nTO TIPOCF=#TIPOCF CODCF=#CODCF")); - TString4 w; w << tipocf; - TVariant t(w); - - clifo->set_var("#TIPOCF", t); - clifo->set_var("#CODCF", codcf); - clifo->move_first(); - return *clifo; -} - -bool TIP_campo_sender::test_swap(const TRecordset& mov) -{ - TRecordset & rmov = rmovrecset(mov); - const int anno = mov.get(MOV_ANNOIVA).as_int(); - TCausale caus(mov.get(MOV_CODCAUS).as_string(), anno); - char sez = caus.sezione_clifo(); - const bool vendite = mov.get(MOV_TIPO).as_string()[0] != 'F'; - - const bool s = vendite ^ (sez == 'D'); - return s; -} - -bool TIP_campo_sender::swap_ritsoc(const TRecordset& mov) -{ - TRecordset & rmov = rmovrecset(mov); - bool ok = rmov.move_first(); - const char sez = rmov.get(RMV_SEZIONE).as_string()[0]; - char sezrit = sez; - - for (; ok; ok = rmov.move_next()) - { - const char tiporiga = rmov.get(RMV_ROWTYPE).as_string()[0]; - - if (tiporiga =='S') + // Provo il sottoconto ma se non riesco provo con conto e poi anche gruppo + for (int c = 3; c > 0 && codricl <= 0; c--) { - sezrit = rmov.get(RMV_SEZIONE).as_string()[0]; - break; + codricl = atol(__conti->get(cod, "CODICE")); + cod.add(0, c); } } - - const bool s = sez != sezrit; - return s; + return codricl; } -bool TIP_campo_sender::mov_regolarizzazione(const TRecordset& mov) +TIP_sender& app() { return (TIP_sender&)main_app(); } + +/////////////////////////////////////////////////////////// +// TIP_textset +/////////////////////////////////////////////////////////// + +class TInt : public TObject +{ +public: + int _int; + + TInt(int i) : _int(i) {} +}; + + +bool TIP_textset::destroy(TRecnotype r) +{ + bool ok; + ok = TCSV_recordset::destroy(r); + return ok; +} + +int TIP_textset::find_column(const char * name) +{ + const TString80 fname(name); + TInt * i = (TInt *) _colnames.objptr(fname); + + if (i != NULL) + return i->_int; + return -1; +} + +void TIP_textset::add_field(const char* name, int len, const char * tipo) +{ + const TString80 fname(name); + + const TString4 strtipo(tipo); + TFieldtypes t = _alfafld; + + if (strtipo == INTFLD || strtipo == NPFLD) + { + if (len > 10) + len = 10; + t = _longzerofld; + } + else + if (strtipo == NUFLD || strtipo == FLFLD) + { + if (len > 19) + len = 19; + t = _realfld; + } + else + if (strtipo == DATEFLD) + { + len = 8; + t = _datefld; + } + create_column(fname, t); + TRecordset_column_info& ci = (TRecordset_column_info&) column_info(columns() - 1); + ci._width = len; + _colnames.add(fname, new TInt(columns() - 1)); +} + +bool TIP_textset::set(const char* field, const TVariant& var) +{ + TString msg; + bool ok = true; + TString val; + int column = find_column(field); + + if (column < 0) + { + msg << field << ": " << TR("Campo sconosiuto"); + app().log(2, msg); + } + + TRecordset_column_info& ci = (TRecordset_column_info&) column_info(column); + const int len = ci._width; + + switch (var.type()) + { + case _datefld: + if (!var.is_zero()) + { + const TDate d = var.as_date(); + const long ansi = d.date2ansi(); + val.format("%8ld", ansi); + ok = true; + } + break; + case _realfld: + if (!var.is_zero()) + { + const real v = var.as_real(); + val = v.string(len, 2); + ok = val.len() <= len; + } + break; + case _longzerofld: + if (!var.is_zero()) + { + const long v = var.as_int(); + TString fmt; fmt.format("&%0%dld", len); + val.format(fmt, v ); + ok = val.len() <= len; + } + break; + default: + val = var.as_string().left(len); + break; + } + if (ok) + TCSV_recordset::set(column, TVariant(val)); + else + { + msg << field << TR(": Valore - ") << val<< TR(" - Lunghezza errata "); + app().log(2, msg); + } + return ok; +} + +/////////////////////////////////////////////////////////// +// TIP_clienti_textset +/////////////////////////////////////////////////////////// + +TIP_clienti_textset::TIP_clienti_textset(const char* query) : TIP_textset(query) +{ + add_field("ID_Cliente", 6); + add_field("Descrizione_1", 40); + add_field("Descrizione_2", 40); + add_field("Indirizzo", 40); + add_field("Citta", 62); + add_field("Cap", 9); + add_field("ID_Provincia", 2); + add_field("ID_Regione", 3); + add_field("ID_Nazione_Estera", 3); + add_field("Email", 40); + add_field("Telefono1_1", 5); + add_field("Telefono1_2", 5); + add_field("Telefono1_3", 10); + add_field("Telefono2_1", 5); + add_field("Telefono2_2", 5); + add_field("Telefono2_3", 10); + add_field("Fax_1", 5); + add_field("Fax_2", 5); + add_field("Fax_3", 10); + add_field("PersonaContattare", 30); + add_field("Chiave_Ricerca", 40); + add_field("Nota", 80); + add_field("Flag_Persona_Fisica", 1); + add_field("Sesso", 1); + add_field("Data_Nascita", 8); + add_field("Citta_Nascita", 62); + add_field("Cognome", 25); + add_field("Nome", 25); + add_field("Indirizzo_Legale", 40); + add_field("Citta_Legale", 62); + add_field("Cap_Legale", 9); + add_field("ID_Provincia_Legale", 2); + add_field("ID_Regione_Legale", 3); + add_field("ID_ISO_IVA", 2); + add_field("Partita_IVA", 12); + add_field("Codice_Fiscale", 16); + add_field("Codice_Fiscale_Estero", 16); + add_field("ID_Conto", 12); + add_field("ID_Conto_Fat", 12); + add_field("ID_Conto_Pag", 12); + add_field("ID_IVA", 12); + add_field("ID_Divisa", 3); + add_field("Bloccato", 1, INTFLD); + add_field("Data_Inizio_Rapporto", 8, DATEFLD); + add_field("ID_Tipo_Pagamento_Default", 1); + add_field("TitolareP_IVA", 1); +} + +/////////////////////////////////////////////////////////// +// TIP_fornitori_textset +/////////////////////////////////////////////////////////// + +TIP_fornitori_textset::TIP_fornitori_textset(const char* query) : TIP_textset(query) +{ + add_field("ID_Cliente", 6); + add_field("Descrizione_1", 40); + add_field("Descrizione_2", 40); + add_field("Indirizzo", 40); + add_field("Citta", 62); + add_field("Cap", 9); + add_field("ID_Provincia", 2); + add_field("ID_Regione", 3); + add_field("ID_Nazione_Estera", 3); + add_field("Email", 40); + add_field("Telefono1_1", 5); + add_field("Telefono1_2", 5); + add_field("Telefono1_3", 10); + add_field("Telefono2_1", 5); + add_field("Telefono2_2", 5); + add_field("Telefono2_3", 10); + add_field("Fax_1", 5); + add_field("Fax_2", 5); + add_field("Fax_3", 10); + add_field("PersonaContattare", 30); + add_field("Chiave_Ricerca", 40); + add_field("Nota", 80); + add_field("Flag_Persona_Fisica", 1); + add_field("Sesso", 1); + add_field("Data_Nascita", 8, DATEFLD); + add_field("Citta_Nascita", 62); + add_field("Cognome", 25); + add_field("Nome", 25); + add_field("Indirizzo_Legale", 40); + add_field("Citta_Legale", 62); + add_field("Cap_Legale", 9); + add_field("ID_Provincia_Legale", 2); + add_field("ID_Regione_Legale", 3); + add_field("ID_ISO_IVA", 2); + add_field("Partita_IVA", 12); + add_field("Codice_Fiscale", 16); + add_field("Codice_Fiscale_Estero", 16); + add_field("ID_Conto", 12); + add_field("ID_Conto_Fat", 12); + add_field("ID_Conto_Pag", 12); + add_field("ID_IVA", 12); + add_field("ID_Divisa", 3); + add_field("Flag_Enasarco", 1); + add_field("Data_Inizio_Rapporto", 8, DATEFLD); + add_field("Bloccato", 1, INTFLD); + add_field("ID_Tipo_Pagamento_Default", 1); +} + + +/////////////////////////////////////////////////////////// +// TIP_scadenze_textset +/////////////////////////////////////////////////////////// + +TIP_scadenze_textset::TIP_scadenze_textset(const char* query) : TIP_textset(query) +{ + add_field("ID_Scadenza", 10, NPFLD); + add_field("Data_Scadenza", 8, DATEFLD); + add_field("Importo_Scadenza", 19, NUFLD); + add_field("Importo_Divisa", 19, NUFLD); + add_field("ID_Divisa", 3); + add_field("ID_Tipo_Pagamento", 1); + add_field("ID_Movimento", 10, NPFLD); + add_field("Importo_IVASosp", 19, NUFLD); +} + +/////////////////////////////////////////////////////////// +// TIP_movimenti_textset +/////////////////////////////////////////////////////////// + +TIP_movimenti_textset::TIP_movimenti_textset(const char* query) + : TIP_textset(query) +{ + add_field("ID_Movimento", 10, NPFLD); + add_field("Data_Registrazione", 8, DATEFLD); + add_field("Data_Comp_Esercizio", 8, DATEFLD); + add_field("Data_Comp_LiqIVA", 8, DATEFLD); + add_field("Data_Documento", 8, DATEFLD); + add_field("Num_Documento", 10); + add_field("ID_Causale", 4, CFLD); + add_field("Descrizione", 40); + add_field("ID_Provvisorio", 2); + add_field("ID_RegIVA", 2); + add_field("Prot_IVA", 10); + add_field("ID_Conto", 12, CFLD); + add_field("ID_ContoCompetenza", 12); + add_field("ID_SubConto", 6); + add_field("Descrizione_Riga", 40); + add_field("Importo_Lire", 19, NUFLD); + add_field("Imponibile_IVA", 19, NUFLD); + add_field("ID_IVA", 3); + add_field("Importo_IVA", 19, NUFLD); + add_field("Indetraibilità", 3, INTFLD); // quanto lunghi gli interi + add_field("Importo_Divisa", 19, NUFLD); + add_field("ID_Divisa", 3); + add_field("Cambio", 19, NUFLD); + add_field("ID_Partita", 10); + add_field("Anno_Partita", 4, INTFLD); + add_field("Data_Inizio_Comp", 8, DATEFLD); + add_field("Data_Fine_Comp", 8, DATEFLD); + add_field("ID_Forfait", 1); + add_field("Tipo_Riga", 1, CFLD); + add_field("ID_CauRiga", 2); + add_field("ID_RegIVA_Vendite", 2); + add_field("Prot_IVA_Vendite", 10); + add_field("ID_Scadenza", 10, NUFLD); + add_field("TitolareP_IVA", 1); +} + +/////////////////////////////////////////////////////////// +// TIP_cespiti_textset +/////////////////////////////////////////////////////////// + +TIP_cespiti_textset::TIP_cespiti_textset(const char* query) + : TIP_textset(query) +{ + add_field("ID_Cespite", 6); + add_field("ID_CategoriaCespite", 10); + add_field("Descrizione", 40); + add_field("ID_Attivita", 2); + add_field("Ubicazione", 20); + add_field("ID_Fornitore", 6); + add_field("Data_Documento", 8, DATEFLD); + add_field("Num_Documento", 10); + add_field("Prot_IVA", 10); + add_field("TitoloAcquisto", 1); + add_field("Data_Inizio_Utilizzazione", 8, DATEFLD); + add_field("Costo", 19, NUFLD); + add_field("Flag_IndeducibilitaFiscale", 1); + add_field("PercIndeducibilita", 6, FLFLD); // quanto lunghi i float + add_field("Limite_Deducibilita", 10, NPFLD); + add_field("ValoreMassimoDeducibile", 19, NUFLD); + add_field("Flag_Autotrasportatori", 1); + add_field("Flag_Manutenzione", 1); + add_field("Flag_PubblicoRegistro", 1); + add_field("Flag_TecnoTremonti", 1); + add_field("CostoAgevolabile", 19, NUFLD); + add_field("StatoCespite", 1); + add_field("Flag_AmmTecnico", 1); + add_field("AliquotaAmmOrdinario", 4, NUFLD); + add_field("AliquotaAmmAnticipato", 4, NUFLD); + add_field("FondoAmmOrdinario", 19, NUFLD); + add_field("FondoAmmAnticipato", 19, NUFLD); + add_field("ValoreAmmortizzato", 19, NUFLD); + add_field("QuotaNonAmmortizzabile", 19, NUFLD); + add_field("Rivalutazioni", 19, NUFLD); + add_field("Svalutazioni", 19, NUFLD); + add_field("FondoSvalutazione", 19, NUFLD); + add_field("EccedenzaPregressa", 19, NUFLD); + add_field("SommatoriaDecrementi", 19, NUFLD); + add_field("Flag_NonCalcolare", 1); + add_field("DecrementoPeriodo", 19, NUFLD); + add_field("Flag_RecuperoCivilistico", 1); + add_field("Flag_IndeducibileRetroattiva", 1); + add_field("Flag_CalcoloPregressiFiscali", 1); +} + +/////////////////////////////////////////////////////////// +// TIP_categorie_textset +/////////////////////////////////////////////////////////// + +TIP_categorie_textset::TIP_categorie_textset(const char* query) : TIP_textset(query) +{ + add_field("ID_CategoriaCespite", 10); + add_field("Descrizione", 40); + add_field("TipoBene", 1); + add_field("Flag_StampaLibroImmateriale", 1); + add_field("AliquotaAmmOrdinario", 6, FLFLD); // lunghezza + add_field("Flag_AmmAnticipato", 1); + add_field("AliquotaAmmAnticipato", 6, FLFLD); // lunghezza + add_field("ID_ContoAmmAnticipato", 12); + add_field("ID_ContoFondoAmmAnticipato", 12); + add_field("ID_ContoAmmOrdinario", 12); + add_field("ID_ContoFondoAmmOrdinario", 12); + add_field("ID_ContoCespite", 12); + add_field("Flag_AmmIndiretto", 1); + add_field("ID_ContoMinusValenza", 12); + add_field("ID_ContoPlusValenza", 12); + add_field("Flag_PubblicoRegistro", 1); + add_field("ID_ContoSvalutazioni", 12); + add_field("ID_ContoRivalutazioni", 12); + add_field("ID_ContoFondoSvalutazioni", 12); + add_field("ID_ContoSopravvenienzePassive", 12); + add_field("Flag_Ammortizzabile", 1); + add_field("Flag_StampaLibroNonAmmort", 1); + add_field("ID_ContoRiservaRivalutazione", 12); + add_field("Flag_CategoriaMinisteriale", 1); + add_field("ID_ContoAmmAnticipatoNonDed", 12); + add_field("ID_ContoFdoAmmAnticipatoNonDed", 12); + add_field("ID_ContoAmmOrdinarioNonDed", 12); + add_field("ID_ContoFdoAmmOrdinarioNonDed", 12); + add_field("ID_ContoSvalutazioniNonDed", 12); + add_field("ID_ContoFdoSvalutazioniNonDed", 12); + add_field("ID_ContoRivalutazioniNonTassabile", 12); + add_field("ID_ContoRiservaRivalutazioniNonTassabile", 12); + add_field("ID_ContoMinusvalenzaNonDed", 12); + add_field("ID_ContoPlusvalenzaNonTassabile", 12); + add_field("ID_ContoSopravvenienzePassiveNonDed", 12); + add_field("ID_TipoCategoria", 1); + add_field("ID_VoceBilancio", 1); +} + +/////////////////////////////////////////////////////////// +// TIP_intra_textset +/////////////////////////////////////////////////////////// + +TIP_intra_textset::TIP_intra_textset(const char* query) : TIP_textset(query) +{ + add_field("ID_Subconto", 6, CFLD); + add_field("ID_Movim_CG", 10, NPFLD); + add_field("Data_Riferimento", 8, DATEFLD); + add_field("TipoMovimento", 1, NPFLD); // verificare + add_field("Importo", 19, NUFLD); + add_field("Importo_Divisa", 19, NUFLD); // Importo divisa movimento Intra + add_field("SezioneIntra", 1, INTFLD); //Sezione Intra. 0 = non definito, 1=Bis, 2= Ter, 3=Quater, 4=Quinquies + add_field("ID_NaturaTransazione", 1); // Codice della natura transazione + add_field("ID_NomenclaturaCombinata", 9); // Codice della nomenclatura combinata + add_field("ID_CondizioniConsegna", 1); // Condizioni Consegna „C?, „D?, „E? o „F? + add_field("ID_ModalitaTrasporto", 1); // Codice della modalità di trasporto + add_field("ID_SezioneDoganale", 6); // Sezione Doganale + add_field("ID_ProvinciaDest", 2); // Provincia destinazione + add_field("ID_NazioneProvenienza", 3); // Codice della nazione di provenienza + add_field("ID_NazioneOrigine", 3); // Codice della nazione di origine + add_field("MassaNetta", 19, NUFLD); // Massa netta + add_field("UnitaSupplementari", 10, NPFLD); // Unità supplementare + add_field("ValoreStatistico", 19, NUFLD); // Valore statistico + add_field("PeriodoRettifica", 2, INTFLD); // Periodo rettifica (mese o trimestre) (*) + add_field("AnnoRettifica", 4, INTFLD); //Anno relativo al periodo di rettifica + add_field("Num_Documento", 10); // Alfanumerico: numero documento (Quater/Quinquies) + add_field("Data_Documento", 8, DATEFLD); // Data documento: data documento (Quater/Quinqies) + add_field("Codice_Servizio", 6); // Codice servizio + add_field("Mod_Erogazione", 1); // I = Istantanea, R = A più riprese + add_field("Mod_Incasso",1); // Modalità incasso + add_field("Num_Protocollo", 10, NPFLD); // Numero protocollo da indicare nelle righe di rettifica del Quinquies + add_field("Prog_Riga", 10, NPFLD); // Progressivo riga (univoco) da indicare nelle righe di rettifica del Quinquies +} + +/////////////////////////////////////////////////////////// +// TIP_sender +/////////////////////////////////////////////////////////// + +void TIP_sender::log(int sev, const char* msg) +{ + if (_log != NULL) + { + if (sev > 0) + { + TString m; + m << TR("Record") << ": " << msg; + _log->log(sev, m); + _errors_logged = true; + } + else + _log->log(sev, msg); + } +} + +bool TIP_sender::mov_regolarizzazione(const TRecordset& mov) { const TString& codcaus = mov.get(MOV_CODCAUS).as_string(); return _caus_regolarizzazione.objptr(codcaus) != NULL; } -bool TIP_campo_sender::mov_intra(const TRecordset& mov) +bool TIP_sender::mov_intra(const TRecordset& mov) { const TRectype& caus = cache().get(LF_CAUSALI, mov.get(MOV_CODCAUS).as_string()); return caus.get_bool(CAU_INTRACOM); } -bool TIP_campo_sender::mov_reverse_charge(const TRecordset& mov) +bool TIP_sender::mov_reverse_charge(const TRecordset& mov) { const TRectype& caus = cache().get(LF_CAUSALI, mov.get(MOV_CODCAUS).as_string()); const int regsp = caus.get_int(CAU_REGSPIVA); @@ -204,46 +645,18 @@ bool TIP_campo_sender::mov_reverse_charge(const TRecordset& mov) return regsp == 13 || regsp == 50 || regsp == 51; } -bool TIP_campo_sender::regime_agricolo(const TRecordset& mov) const +bool TIP_sender::test_swap(const TRecordset& mov) { - TToken_string key; - - key.format("%04d%s", mov.get(MOV_ANNOIVA).as_int(), (const char *) mov.get(MOV_REG).as_string()); - - const TRectype& reg = cache().get("REG", key); - - key.cut(0); - key.add(prefix().get_codditta()); - key.add(reg.get("S8")); - const TRectype& attiv = cache().get(LF_ATTIV, key); - return attiv.get_bool(ATT_REGAGR); + const int anno = mov.get(MOV_ANNOIVA).as_int(); + const TCausale & caus = _causali->causale(mov.get(MOV_CODCAUS).as_string(), anno); + char sez = caus.sezione_clifo(); + const bool vendite = mov.get(MOV_TIPO).as_string()[0] != 'F'; + + const bool s = vendite ^ (sez == 'D'); + return s; } -TMask & TIP_campo_sender::get_mask() -{ - if (_mask == NULL) - { - _mask = new TIP_mask(mask_name()); - TDate to(TODAY); - TConfig configtc(CONFIG_DITTA, "tc"); - const TDate from(configtc.get("TSULTINV")); - - if (from.ok()) - to.addmonth(-1); - to.set_end_month(); - if (to <= from) - { - to = from; - to.addmonth(1); - to.set_end_month(); - } - _mask->set(F_DATA_DA, from); - _mask->set(F_DATA_AL, to); - } - return * _mask; -} - -bool TIP_campo_sender::find_regolarizzazione(TRecordset& mov) +bool TIP_sender::find_regolarizzazione(TRecordset& mov) { bool found = false; @@ -256,12 +669,7 @@ bool TIP_campo_sender::find_regolarizzazione(TRecordset& mov) 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; @@ -299,28 +707,806 @@ bool TIP_campo_sender::find_regolarizzazione(TRecordset& mov) return found; } -long TIP_campo_sender::iva11_reverse(const TRecordset & mov) +const long TIP_sender::bill2ricl(char t, int gr, int co, long so) { - const TRectype& caus = cache().get(LF_CAUSALI, mov.get(MOV_CODCAUS).as_string()); + long codricl = 0; + if (gr > 0) + { + const bool ricl = _riclassifica.is_key(__tiporicconti); - return caus.get_int(CAU_REGSPIVA); + if (ricl) + { + codricl = ::IPbill2ricl(t, gr, co, so); + + if (codricl <= 0) + { + TString msg; + msg << TR("Conto") << " " << gr << " " << co << " " << so << " :" << TR("Non presente in tabella"); + log(2, msg); + } + } + } + return codricl; } -const char * TIP_campo_sender::decode_causale(const TRecordset& mov) +const TString & TIP_sender::scod2ricl(const char* tab, const TString& cod) { - const TRectype& caus = cache().get(LF_CAUSALI, mov.get(MOV_CODCAUS).as_string()); + 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 & TIP_sender::scod2ricl(const char* tab, const TVariant& cod) +{ + return scod2ricl(tab, cod.as_string()); +} + +const long TIP_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 TIP_sender::cod2ricl(const char* tab, const TVariant& cod) +{ + return cod2ricl(tab, cod.as_string()); +} + +const TString & TIP_sender::pag2tipo(const TVariant & codpag) +{ + TString & str = get_tmp_string(4); + const int tipopag = atoi(cache().get("CPG", codpag.as_string(), "S4")); + + str = ""; + if (tipopag < 2) + str = "D"; + else + if (tipopag == 2) + str = "T"; + else + if (tipopag == 3) + str = "B"; + else + if (tipopag == 5) + str = "G"; + else + if (tipopag == 7) + str = "T"; + else + if (tipopag == 9) + str = "O"; + return str; +} + +const TString & TIP_sender::row2cauriga(TISAM_recordset& rmov, const TCausale & caus) +{ + TString & str = get_tmp_string(4); + const char tipo = rmov.get(RMV_ROWTYPE).as_string()[0]; + if (tipo == 'F') + str = "P5"; + else + if (tipo == 'S') + str = "P6"; + else + if (caus.tipomov() > 2) + { + TBill c; + + caus.bill(0, c); + if (c.tipo() == 'F') + str = "P7"; + else + if (c.tipo() == 'C') + str = "P8"; + } + return str; +} +void TIP_sender::get_pref(const TVariant & pref, TVariant & pint, TVariant & pnaz) +{ + if (pref.as_string()[0] == '+') + { + pint = pref.as_string().left(3); + pnaz = pref.as_string().mid(3); + } + else + if (pref.as_string().starts_with("00")) + { + pint = pref.as_string().left(4); + pnaz = pref.as_string().mid(4); + } + else + { + pint.set_null(); + pnaz = pref; + } +} + +const real TIP_sender::ind2perc(const TVariant & tipodet) +{ + return real(cache().get("%DET", tipodet.as_string(), "R0")); //verificare +} + +void TIP_sender::add_cli(TISAM_recordset & cli, TIP_clienti_textset & ipcli) +{ + TVariant val; + TVariant val1; + TToken_string key; + + ipcli.new_rec(); + ipcli.set("ID_Cliente", cli.get(CLI_CODCF)); + ipcli.set("Descrizione_1", cli.get(CLI_CODCF).as_string().left(40)); + ipcli.set("Descrizione_2", cli.get(CLI_CODCF).as_string().mid(40)); + val = cli.get(CLI_INDCF); + if (!cli.get(CLI_CIVCF).is_empty()) + { + if (!val.is_empty()) + val += ", "; + val += cli.get(CLI_CIVCF); + } + ipcli.set("Indirizzo", val); + val = cli.get(CLI_LOCCF); + if (!val.is_empty()) + val += " "; + key.add(cli.get(CLI_STATOCF).as_string()); + key.add(cli.get(CLI_COMCF).as_string()); - return caus.get(CAU_DESCR); + const TRectype & comune = cache().get(LF_COMUNI, key); + val += comune.get(COM_DENCOM); + ipcli.set("Citta", val); + ipcli.set("Cap", cli.get(CLI_CAPCF)); + ipcli.set("ID_Provincia", comune.get(COM_PROVCOM)); + ipcli.set("ID_Regione", comune.get(COM_CODREG)); + ipcli.set("ID_Nazione_Estera", scod2ricl(NAZ, cli.get(CLI_STATOCF))); + ipcli.set("Email", cli.get(CLI_DOCMAIL)); + get_pref(cli.get(CLI_PTEL), val, val1); + ipcli.set("Telefono1_1", val); + ipcli.set("Telefono1_2", val1); + ipcli.set("Telefono1_3", cli.get(CLI_TEL)); + get_pref(cli.get(CLI_PTEL2), val, val1); + ipcli.set("Telefono2_1", val); + ipcli.set("Telefono2_2", val1); + ipcli.set("Telefono2_3", cli.get(CLI_TEL2)); + get_pref(cli.get(CLI_PFAX), val, val1); + ipcli.set("Fax_1", val); + ipcli.set("Fax_2", val1); + ipcli.set("Fax_3", cli.get(CLI_FAX)); + ipcli.set("Chiave_Ricerca", cli.get(CLI_RICALT)); + const bool persona_fisica = cli.get(CLI_TIPOAPER).as_string() == "F"; + ipcli.set("Flag_Persona_Fisica", persona_fisica ? "S" : "N"); + if (persona_fisica) + { + key.cut(0); + key.add(cli.get(CLI_TIPOAPER).as_string()); + key.add(cli.get(CLI_CODANAGPER).as_string()); + const TRectype & recanag = cache().get(LF_ANAG, key); + const TRectype & recpf = cache().get(LF_ANAGFIS, cli.get(CLI_CODANAGPER).as_string()); + + ipcli.set("Sesso", recpf.get(ANF_SESSO)); + ipcli.set("Data_Nascita", recpf.get(ANF_DATANASC)); + key.cut(0); + key.add(recpf.get(ANF_STATONASC)); + key.add(recpf.get(ANF_COMNASC)); + + const TRectype & comunenasc = cache().get(LF_COMUNI, key); + + ipcli.set("Citta_Nascita", comunenasc.get(COM_DENCOM)); + ipcli.set("Cognome", recanag.get(ANA_RAGSOC).left(25)); + ipcli.set("Nome", recanag.get(ANA_RAGSOC).mid(25)); + } + ipcli.set("ID_ISO_IVA", cli.get(CLI_STATOPAIV)); + ipcli.set("Partita_IVA", cli.get(CLI_PAIV)); + const int alleg = cli.get(CLI_ALLEG).as_int(); + if (alleg != 5) + ipcli.set("Codice_Fiscale", cli.get(CLI_COFI)); + else + ipcli.set("Codice_Fiscale_Estero", cli.get(CLI_COFI)); + ipcli.set("ID_Conto", bill2ricl(' ', cli.get(CLI_GRUPPO).as_int(), cli.get(CLI_CONTO).as_int(), 0L)); + ipcli.set("ID_Conto_Fat", bill2ricl(' ', cli.get(CLI_GRUPPORIC).as_int(), cli.get(CLI_CONTORIC).as_int(), cli.get(CLI_SOTTOCRIC).as_int())); + ipcli.set("ID_Divisa", scod2ricl(VAL, cli.get(CLI_CODVAL))); + ipcli.set("Bloccato", cli.get(CLI_SOSPESO).as_bool() ? "0" : "9"); + ipcli.set("ID_Tipo_Pagamento_Default", pag2tipo(cli.get(CLI_CODPAG))); + ipcli.set("TitolareP_IVA", alleg != 6 ? "S" : "N"); } -void TIP_campo_sender::postprocess_movs(TRecordset & mov) +void TIP_sender::transfer_cli(const char * path) +{ + + TIP_clienti_textset ipcli; + TString query; + + query << "USE " << LF_CLIFO << '\n' << "FROM " << CLI_TIPOCF << "=\"C\"\n" << "TO " << CLI_TIPOCF << "=\"C\"\n"; + + TISAM_recordset cli(query); + log(0, "Clienti"); + _errors_logged = false; + TProgind pi(cli.items(), TR("Scansione clienti"), true, true); + + for (bool ok = cli.move_first(); ok && pi.addstatus(1); ok = cli.move_next()) + add_cli(cli, ipcli); + + bool save = true; + _errors |= _errors_logged; + 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(path); + + name.add("clienti.txt"); + ipcli.save_as(name); + } +} +void TIP_sender::add_forn(TISAM_recordset & forn, TIP_fornitori_textset & ipforn) +{ + TVariant val; + TVariant val1; + TToken_string key; + + ipforn.new_rec(); + ipforn.set("ID_Cliente", forn.get(CLI_CODCF)); + ipforn.set("Descrizione_1", forn.get(CLI_CODCF).as_string().left(40)); + ipforn.set("Descrizione_2", forn.get(CLI_CODCF).as_string().mid(40)); + val = forn.get(CLI_INDCF); + if (!forn.get(CLI_CIVCF).is_empty()) + { + if (!val.is_empty()) + val += ", "; + val += forn.get(CLI_CIVCF); + } + ipforn.set("Indirizzo", val); + val = forn.get(CLI_LOCCF); + if (!val.is_empty()) + val += " "; + key.add(forn.get(CLI_STATOCF).as_string()); + key.add(forn.get(CLI_COMCF).as_string()); + + const TRectype & comune = cache().get(LF_COMUNI, key); + val += comune.get(COM_DENCOM); + ipforn.set("Citta", val); + ipforn.set("Cap", forn.get(CLI_CAPCF)); + ipforn.set("ID_Provincia", comune.get(COM_PROVCOM)); + ipforn.set("ID_Regione", comune.get(COM_CODREG)); + ipforn.set("ID_Nazione_Estera", scod2ricl(NAZ, forn.get(CLI_STATOCF))); + ipforn.set("Email", forn.get(CLI_DOCMAIL)); + get_pref(forn.get(CLI_PTEL), val, val1); + ipforn.set("Telefono1_1", val); + ipforn.set("Telefono1_2", val1); + ipforn.set("Telefono1_3", forn.get(CLI_TEL)); + get_pref(forn.get(CLI_PTEL2), val, val1); + ipforn.set("Telefono2_1", val); + ipforn.set("Telefono2_2", val1); + ipforn.set("Telefono2_3", forn.get(CLI_TEL2)); + get_pref(forn.get(CLI_PFAX), val, val1); + ipforn.set("Fax_1", val); + ipforn.set("Fax_2", val1); + ipforn.set("Fax_3", forn.get(CLI_FAX)); + ipforn.set("Chiave_Ricerca", forn.get(CLI_RICALT)); + const bool persona_fisica = forn.get(CLI_TIPOAPER).as_string() == "F"; + ipforn.set("Flag_Persona_Fisica", persona_fisica ? "S" : "N"); + if (persona_fisica) + { + key.cut(0); + key.add(forn.get(CLI_TIPOAPER).as_string()); + key.add(forn.get(CLI_CODANAGPER).as_string()); + const TRectype & recanag = cache().get(LF_ANAG, key); + const TRectype & recpf = cache().get(LF_ANAGFIS, forn.get(CLI_CODANAGPER).as_string()); + + ipforn.set("Sesso", recpf.get(ANF_SESSO)); + ipforn.set("Data_Nascita", recpf.get(ANF_DATANASC)); + key.cut(0); + key.add(recpf.get(ANF_STATONASC)); + key.add(recpf.get(ANF_COMNASC)); + + const TRectype & comunenasc = cache().get(LF_COMUNI, key); + + ipforn.set("Citta_Nascita", comunenasc.get(COM_DENCOM)); + ipforn.set("Cognome", recanag.get(ANA_RAGSOC).left(25)); + ipforn.set("Nome", recanag.get(ANA_RAGSOC).mid(25)); + } + ipforn.set("ID_ISO_IVA", forn.get(CLI_STATOPAIV)); + ipforn.set("Partita_IVA", forn.get(CLI_PAIV)); + const int alleg = forn.get(CLI_ALLEG).as_int(); + if (alleg != 5) + ipforn.set("Codice_Fiscale", forn.get(CLI_COFI)); + else + ipforn.set("Codice_Fiscale_Estero", forn.get(CLI_COFI)); + ipforn.set("ID_Conto", bill2ricl(' ', forn.get(CLI_GRUPPO).as_int(), forn.get(CLI_CONTO).as_int(), 0L)); + ipforn.set("ID_Conto_Fat", bill2ricl(' ', forn.get(CLI_GRUPPORIC).as_int(), forn.get(CLI_CONTORIC).as_int(), forn.get(CLI_SOTTOCRIC).as_int())); + ipforn.set("ID_Divisa", scod2ricl(VAL, forn.get(CLI_CODVAL))); + ipforn.set("Bloccato", forn.get(CLI_SOSPESO).as_bool() ? "0" : "9"); + ipforn.set("ID_Tipo_Pagamento_Default", pag2tipo(forn.get(CLI_CODPAG))); +} + +void TIP_sender::transfer_forn(const char * path) +{ + log(0, "Fornitori"); + + TIP_fornitori_textset ipforn; + TString query; + + query << "USE " << LF_CLIFO << '\n' << "FROM " << CLI_TIPOCF << "=\"F\"\n" << "TO " << CLI_TIPOCF << "=\"F\"\n"; + + TISAM_recordset forn(query); + _errors_logged = false; + TProgind pi(forn.items(), TR("Scansione fornitori"), true, true); + + for (bool ok = forn.move_first(); ok && pi.addstatus(1); ok = forn.move_next()) + add_forn(forn, ipforn); + + bool save = true; + _errors |= _errors_logged; + 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(path); + + name.add("fornitori.txt"); + ipforn.save_as(name); + } +} + +void TIP_sender::add_mov_cg(TISAM_recordset & mov, TIP_movimenti_textset & ipmov, const TVariant & reg_regol, const TVariant & prot_regol, const char tipo) +{ + TVariant val; + TToken_string key; + TString query; + const int anno = mov.get(MOV_ANNOIVA).as_int(); + const TCausale & caus = _causali->causale(mov.get(MOV_CODCAUS).as_string(), anno); + char tipocf = mov.get(MOV_TIPO).as_string()[0]; + long codcf = mov.get(MOV_CODCF).as_int(); + key.cut(0); + key.add(tipocf); + key.add(codcf); + const int alleg = atoi(cache().get(LF_CLIFO, key, CLI_ALLEG)); + const TVariant & numreg = mov.get(MOV_NUMREG); + + + query << "USE " << LF_RMOV << "\nFROM " << RMV_NUMREG << "=" << numreg << "\nTO " << RMV_NUMREG << "=" << numreg << "\n"; + + TISAM_recordset rmov(query); + + for (bool ok = rmov.move_first(); ok; ok = rmov.move_next()) + { + TString tiporiga = rmov.get(RMV_ROWTYPE).as_string(); + + if (tipo == ' ' || tipo == tiporiga[0]) + { + ipmov.new_rec(); + ipmov.set("ID_Movimento", mov.get(MOV_NUMREG)); + ipmov.set("Data_Registrazione", mov.get(MOV_DATAREG)); + ipmov.set("Data_Comp_Esercizio", mov.get(MOV_DATACOMP)); + ipmov.set("Data_Documento", mov.get(MOV_DATADOC)); + ipmov.set("Num_Documento", mov.get(MOV_NUMDOC)); + ipmov.set("ID_Causale", scod2ricl(CAU, mov.get(MOV_CODCAUS))); + ipmov.set("Descrizione", mov.get(MOV_DESCR).as_string().left(40)); + // ipmov.set("ID_Provvisorio", 2); // da ferificare??? + ipmov.set("ID_RegIVA", scod2ricl(REG, mov.get(MOV_REG))); + ipmov.set("Prot_IVA", mov.get(MOV_PROTIVA)); + val = bill2ricl(rmov.get(RMV_TIPOC).as_string()[0], + rmov.get(RMV_GRUPPO).as_int(), + rmov.get(RMV_CONTO).as_int(), + rmov.get(RMV_SOTTOCONTO).as_int()); + ipmov.set("ID_Conto", val); + if (tiporiga != "T") + ipmov.set("ID_SubConto", mov.get(MOV_CODCF)); + ipmov.set("Descrizione_Riga", rmov.get(RMV_DESCR).as_string().left(40)); + ipmov.set("Importo_Lire", rmov.get(RMV_SEZIONE).as_string() == "D" ? rmov.get(RMV_IMPORTO).as_real() : -rmov.get(RMV_IMPORTO).as_real()); + key = numreg.as_string(); + key.add(rmov.get(RMV_NUMRIG).as_string()); + const TRectype & partrec = _part->get(key); + ipmov.set("ID_Partita", partrec.get(PART_NUMPART)); + ipmov.set("Anno_Partita", partrec.get(PART_ANNO)); + val = ""; + if (tiporiga == "T") + val = "S"; + else + if (tiporiga == "N" || tiporiga == "D") + val = "I"; + ipmov.set("Tipo_Riga", val); + ipmov.set("ID_CauRiga", row2cauriga(rmov, caus)); + ipmov.set("ID_RegIVA_Vendite", reg_regol); + ipmov.set("Prot_IVA_Vendite", prot_regol); + ipmov.set("TitolareP_IVA", alleg != 6 ? "S" : "N"); + } + } +} + +void TIP_sender::add_mov_iva(TISAM_recordset & mov, TIP_movimenti_textset & ipmov, const TVariant & reg_regol, const TVariant & prot_regol) +{ + add_mov_cg(mov, ipmov, reg_regol, prot_regol, 'T'); + const int anno = mov.get(MOV_ANNOIVA).as_int(); + const TCausale & caus = _causali->causale(mov.get(MOV_CODCAUS).as_string(), anno); + const real fattore = caus.sezione_clifo() == 'D' ? -UNO : UNO; + char tipocf = mov.get(MOV_TIPO).as_string()[0]; + long codcf = mov.get(MOV_CODCF).as_int(); + TToken_string key; + key.add(tipocf); + key.add(codcf); + const int alleg = atoi(cache().get(LF_CLIFO, key, CLI_ALLEG)); + const TVariant & numreg = mov.get(MOV_NUMREG); + TString query; + TVariant val; + + query << "USE " << LF_RMOVIVA << "\nFROM " << RMI_NUMREG << "=" << numreg << "\nTO " << RMI_NUMREG << "=" << numreg << "\n"; + + TISAM_recordset rivamov(query); + + for (bool ok = rivamov.move_first(); ok; ok = rivamov.move_next()) + { + ipmov.new_rec(); + ipmov.set("ID_Movimento", mov.get(MOV_NUMREG)); + ipmov.set("Data_Registrazione", mov.get(MOV_DATAREG)); + ipmov.set("Data_Comp_Esercizio", mov.get(MOV_DATACOMP)); + ipmov.set("Data_Documento", mov.get(MOV_DATADOC)); + ipmov.set("Num_Documento", mov.get(MOV_NUMDOC)); + ipmov.set("ID_Causale", scod2ricl(CAU, mov.get(MOV_CODCAUS))); + ipmov.set("Descrizione", mov.get(MOV_DESCR).as_string().left(40)); +// ipmov.set("ID_Provvisorio", 2); da chiarire + ipmov.set("ID_RegIVA", scod2ricl(REG, mov.get(MOV_REG))); + ipmov.set("Prot_IVA", mov.get(MOV_PROTIVA)); + val = bill2ricl(rivamov.get(RMI_TIPOC).as_string()[0], + rivamov.get(RMI_GRUPPO).as_int(), + rivamov.get(RMI_CONTO).as_int(), + rivamov.get(RMI_SOTTOCONTO).as_int()); + ipmov.set("ID_Conto", val); + const real imponibile = rivamov.get(RMI_IMPONIBILE).as_real(); + const real imposta = rivamov.get(RMI_IMPOSTA).as_real(); + real impind; + real impdet; + real ivaind; + real ivadet; + int tipodet; + const real perc = indetraibile_al(rivamov.get(RMI_TIPODET).as_string(), caus, anno, tipodet); + + analizza_IVA(imponibile, imposta, perc, false, true, rivamov.get(RMI_CODIVA).as_string(), + impdet, ivadet, impind, ivaind); // attenzione ai corrispettivi + ipmov.set("Importo_Lire", (impdet + impind) * fattore); + ipmov.set("Imponibile_IVA", imponibile * fattore); + ipmov.set("ID_IVA", scod2ricl(IVA, rivamov.get(RMI_CODIVA))); + ipmov.set("Importo_IVA", imposta * fattore); + ipmov.set("Indetraibilità", ind2perc(rivamov.get(RMI_TIPODET))); + ipmov.set("ID_CauRiga", "" ); // finire + ipmov.set("ID_RegIVA_Vendite", reg_regol); + ipmov.set("Prot_IVA_Vendite", prot_regol); +// ipmov.set("ID_Scadenza", numreg); // verificare + ipmov.set("TitolareP_IVA", alleg != 6 ? "S" : "N"); + } + add_mov_cg(mov, ipmov, reg_regol, prot_regol, 'D'); +} + +void TIP_sender::add_mov(TISAM_recordset & mov, TIP_movimenti_textset & ipmov) +{ + TString msg; msg << TR("Registrazione n.") << ' ' << mov.get(MOV_NUMREG); + log(0, msg); + + const TRecnotype pos = mov.current_row(); // Salva la posizione + const bool is_intra = mov_intra(mov); + TVariant reg_regol; + TVariant prot_regol; + + if (is_intra || mov_reverse_charge(mov)) + { + if (find_regolarizzazione(mov)) + { + prot_regol = mov.get(MOV_PROTIVA).as_int(); + reg_regol = scod2ricl(REG, mov.get(MOV_REG)); + } + else + { + if (is_intra) + log(2, TR("Manca la regolarizzazione del movimento intra")); + else + log(2, TR("Manca la regolarizzazione del movimento reverse charge")); + } + mov.move_to(pos); // Ripristina posizione + } + + const bool moviva = !mov.get(MOV_REG).is_empty(); + + if (moviva) + add_mov_iva(mov, ipmov, reg_regol, prot_regol); + else + add_mov_cg(mov,ipmov, reg_regol, prot_regol); +} + +void TIP_sender::transfer_mov(const char * path) +{ + log(0, "Movimenti"); + + TIP_movimenti_textset ipmov; + TString query; + + query << "USE " << LF_MOV << " KEY 2 SELECT " << MOV_INVIATO << "!=\"X\"\n" + << "FROM " << MOV_DATAREG << "=" << _mask->get_date(F_DATA_DA) << "\n" + << "TO " << MOV_DATAREG << "=" << _mask->get_date(F_DATA_AL) << "\n"; + + TISAM_recordset mov(query); + _errors_logged = false; + TProgind pi(mov.items(), TR("Scansione movimenti"), true, true); + + for (bool ok = mov.move_first(); ok && pi.addstatus(1); ok = mov.move_next()) + if (!mov_regolarizzazione(mov)) + add_mov(mov, ipmov); + + bool save = true; + _errors |= _errors_logged; + 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(path); + + name.add("movimenti.txt"); + ipmov.save_as(name); + } +} + +void TIP_sender::add_scad(TISAM_recordset & mov, TIP_scadenze_textset & ipscad) +{ + TToken_string key; + const TVariant & numreg = mov.get(MOV_NUMREG); + TString msg; msg << TR("Registrazione n.") << ' ' << numreg.as_string(); + log(0, msg); + + key = numreg.as_string(); + key.add(1); + const TRectype & partrec = _part->get(key); + TString query; + + query << "USE " << LF_SCADENZE << "\n" + << "FROM " << SCAD_TIPOCF << "=" << mov.get(MOV_TIPO).as_string() << " " << SCAD_GRUPPO << "=\"\"" << " " << SCAD_CONTO << "=\"\"" + << " " << SCAD_SOTTOCONTO << "=" << mov.get(MOV_CODCF).as_string() << " " << SCAD_ANNO << "=" << _part->get(PART_ANNO) + << " " << SCAD_NUMPART << "=" << _part->get(PART_NUMPART) << " " << SCAD_NRIGA << "=" << _part->get(PART_NRIGA) << "\n" + << "TO " << SCAD_TIPOCF << "=" << mov.get(MOV_TIPO).as_string() << " " << SCAD_GRUPPO << "=\"\"" << " " << SCAD_CONTO << "=\"\"" + << " " << SCAD_SOTTOCONTO << "=" << mov.get(MOV_CODCF).as_string() << " " << SCAD_ANNO << "=" << _part->get(PART_ANNO) + << " " << SCAD_NUMPART << "=" << _part->get(PART_NUMPART) << " " << SCAD_NRIGA << "=" << _part->get(PART_NRIGA) << "\n"; + + TISAM_recordset scad(query); + + for (bool ok = scad.move_first(); ok; ok = scad.move_next()) + { + ipscad.new_rec(); + ipscad.set("ID_Scadenza", ++_ultscadid); + ipscad.set("Data_Scadenza", scad.get(SCAD_DATASCAD)); + ipscad.set("Importo_Scadenza", scad.get(SCAD_IMPORTO)); + ipscad.set("Importo_Divisa", scad.get(SCAD_IMPORTOVAL)); + ipscad.set("ID_Divisa", scod2ricl(VAL, mov.get(MOV_CODVAL))); + ipscad.set("ID_Tipo_Pagamento", pag2tipo(mov.get(MOV_CODPAG))); + ipscad.set("ID_Movimento", numreg); + } +} + +void TIP_sender::transfer_scad(const char * path) +{ + log(0, "Scadenze"); + + TIP_scadenze_textset ipscad; + TString query; + + query << "USE " << LF_MOV << " KEY 2 SELECT (" << MOV_INVIATO << "!=\"X\")&&(" << MOV_REG << "!=\"\")\n" + << "FROM " << MOV_DATAREG << "=" << _mask->get_date(F_DATA_DA) << "\n" + << "TO " << MOV_DATAREG << "=" << _mask->get_date(F_DATA_AL) << "\n"; + + TISAM_recordset mov(query); + _errors_logged = false; + TProgind pi(mov.items(), TR("Scansione scadenze"), true, true); + + for (bool ok = mov.move_first(); ok && pi.addstatus(1); ok = mov.move_next()) + { + const int anno = mov.get(MOV_ANNOIVA).as_int(); + const TCausale & caus = _causali->causale(mov.get(MOV_CODCAUS).as_string(), anno); + if (caus.tipomov() > 0 && caus.tipomov() <= 2) + add_scad(mov, ipscad); + } + + bool save = true; + _errors |= _errors_logged; + 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(path); + + name.add("scadenze.txt"); + ipscad.save_as(name); + } +} + +void TIP_sender::transfer_cesp(const char * path) +{ +} + +void TIP_sender::transfer_cat(const char * path) +{ +} + +void TIP_sender::add_intra(TISAM_recordset & mov, TIP_intra_textset & ipintra) +{ + TToken_string key; + const TVariant & numreg = mov.get(MOV_NUMREG); + TString msg; msg << TR("Registrazione n.") << ' ' << numreg.as_string(); + log(0, msg); + + TString query; + + query << "USE " << LF_RINTRA << "\n" + << "JOIN " << LF_INTRA << "INTO " << INTRA_NUMREG << "==" << RINTRA_NUMREG << "\n" + << "FROM " << INTRA_NUMREG << "==" << numreg << "\n" + << "TO " << INTRA_NUMREG << "==" << numreg << "\n"; + + TISAM_recordset intra(query); + + for (bool ok = intra.move_first(); ok; ok = intra.move_next()) + { + ipintra.new_rec(); + const bool cess = intra.get(INTRA_TIPOCF).as_string() == "C"; + + ipintra.set("ID_Subconto", intra.get(LF_INTRA, INTRA_CODCF)); + ipintra.set("ID_Movim_CG", numreg); + ipintra.set("Data_Riferimento", intra.get(LF_INTRA, INTRA_DATAREG)); + ipintra.set("TipoMovimento", cess ? "C" : "A"); // verificare + ipintra.set("Importo", intra.get(RINTRA_AMMLIRE)); + ipintra.set("Importo_Divisa", intra.get(RINTRA_AMMVALUTA)); + ipintra.set("ID_NaturaTransazione", intra.get(RINTRA_NATURA)); + ipintra.set("ID_NomenclaturaCombinata", intra.get(RINTRA_NOMENCL)); + ipintra.set("ID_CondizioniConsegna", scod2ricl(ICC, intra.get(RINTRA_CONSEGNA))); + ipintra.set("ID_ModalitaTrasporto", intra.get(RINTRA_TRASPORTO)); + ipintra.set("ID_ProvinciaDest", intra.get(RINTRA_PROV)); + ipintra.set("ID_NazioneProvenienza", intra.get(RINTRA_PAESE)); + ipintra.set("ID_NazioneOrigine", intra.get(RINTRA_PAESEORIG)); + ipintra.set("MassaNetta", intra.get(RINTRA_MASSAKG)); + ipintra.set("UnitaSupplementari", intra.get(RINTRA_MASSAUMS)); + ipintra.set("ValoreStatistico", intra.get(RINTRA_VALSTAT)); + } +} + +void TIP_sender::transfer_intra(const char * path) +{ + log(0, "Intra"); + + TIP_intra_textset ipintra; + TString query; + + query << "USE " << LF_MOV << " KEY 2 SELECT (" << MOV_INVIATO << "!=\"X\")&&(" << MOV_REG << "!=\"\")\n" + << "FROM " << MOV_DATAREG << "=" << _mask->get_date(F_DATA_DA) << "\n" + << "TO " << MOV_DATAREG << "=" << _mask->get_date(F_DATA_AL) << "\n"; + + TISAM_recordset mov(query); + _errors_logged = false; + TProgind pi(mov.items(), TR("Scansione scadenze"), true, true); + + for (bool ok = mov.move_first(); ok && pi.addstatus(1); ok = mov.move_next()) + add_intra(mov, ipintra); + + bool save = true; + _errors |= _errors_logged; + 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(path); + + name.add("intra.txt"); + ipintra.save_as(name); + } +} + +void TIP_sender::set_parameters() +{ + TConfig configtc(CONFIG_DITTA, "tc"); + TAssoc_array& tab = configtc.list_variables(); + + FOR_EACH_ASSOC_STRING(tab, h, k, v) + { + TString16 var(k); + + if (var.starts_with("IPR")) + { + const bool ric = (*v > ' ') && strchr("1SXY", *v) != NULL; + + if (ric) + { + var.format("IP%s", (const char *)var.mid(3)); + _riclassifica.add(var, NULL); + } + } + } + _ultscadid = configtc.get_long("IPULTSCADID"); +} + +TMask & TIP_sender::get_mask() +{ + if (_mask == NULL) + { + _mask = new TIP_mask("tc2700a"); + TDate to(TODAY); + TConfig configtc(CONFIG_DITTA, "tc"); + const TDate from(configtc.get("IPULTINV")); + + if (from.ok()) + to.addmonth(-1); + to.set_end_month(); + if (to <= from) + { + to = from; + to.addmonth(1); + to.set_end_month(); + } + _mask->set(F_DATA_DA, from); + _mask->set(F_DATA_AL, to); + } + return * _mask; +} + +bool search_reg(const TRelation& rel, void* pJolly) +{ + TAssoc_array * _caus_regolarizzazione = (TAssoc_array *) pJolly; + const bool solaiva = rel.lfile().get_bool(CAU_SOLOIVA); + const TString codcaus = rel.lfile().get(CAU_CODCAUREG); + + if (codcaus.full()) + _caus_regolarizzazione->add(codcaus, codcaus); + + return true; +} + +void TIP_sender::postprocess_movs(TRecordset & mov) { if (yesno_box(TR("Confermare il traferimento"))) { TConfig configtc(CONFIG_DITTA); TMask & m = get_mask(); - configtc.set("TSULTINV", m.get_date(F_DATA_AL)); + configtc.set("IPULTINV", m.get_date(F_DATA_AL)); + configtc.set("IPULTSCADID", _ultscadid); if (mov.items() > 0L) { @@ -345,49 +1531,72 @@ void TIP_campo_sender::postprocess_movs(TRecordset & mov) } } -bool search_reg(const TRelation& rel, void* pJolly) -{ - TAssoc_array * _caus_regolarizzazione = (TAssoc_array *) pJolly; - const bool solaiva = rel.lfile().get_bool(CAU_SOLOIVA); - const TString codcaus = rel.lfile().get(CAU_CODCAUREG); - - if (codcaus.full()) - _caus_regolarizzazione->add(codcaus, codcaus); - - return true; -} - - -bool TIP_campo_sender::create() +bool TIP_sender::create() { TRelation rel(LF_CAUSALI); TCursor c(&rel); bool ok = c.scan(search_reg, &_caus_regolarizzazione, "Ricerca causali di regolarizzazione"); - TLocalisamfile clifo(LF_CLIFO); - bool big_cli_code = false; - - clifo.put(CLI_TIPOCF, "C"); - clifo.put(CLI_CODCF, 100000L); - if (!((clifo.read(_isgteq) == _iseof) || (clifo.get(CLI_TIPOCF) == "F"))) - big_cli_code = true; - if (!big_cli_code) - { - clifo.put(CLI_TIPOCF, "F"); - clifo.put(CLI_CODCF, 100000L);; - - if (clifo.read(_isgteq) != _iseof) - big_cli_code = true; - } - if (big_cli_code) - riclassifica().add("TSNOHCLI", EMPTY_STRING); - - return ok && TIP_sender::create(); + _tabelle = new TIPRiclassifica_cache; + _part = new TRecord_cache(LF_PARTITE, 2); + _causali = new TCausali_cache; + set_parameters(); + return TSkeleton_application::create(); } +bool TIP_sender::destroy() +{ + delete _tabelle; + delete _part; + delete _causali; + delete _mask; + return TSkeleton_application::destroy(); +} + +void TIP_sender::main_loop() +{ + TMask & m = get_mask(); + while (m.run() != K_QUIT) + { + TFilename path = m.get(F_PATH); + + _book = new TReport_book; + const char* const title = TR("Invio a IPSOA"); + _log = new TLog_report(title); + _errors = false; + if (m.get_bool(F_CLIENTI)) + transfer_cli(path); + if (m.get_bool(F_FORNITORI)) + transfer_forn(path); + if (m.get_bool(F_MOVIMENTI)) + transfer_mov(path); + if (m.get_bool(F_SCADENZE)) + transfer_scad(path); + if (m.get_bool(F_CESPITI)) + transfer_cesp(path); + if (m.get_bool(F_CATEGORIE)) + transfer_cat(path); + if (m.get_bool(F_INTRASTAT)) + transfer_intra(path); + + _book->add(*_log); + _book->preview(); + if (!_errors) + { + TString query; + + query << "USE " << LF_MOV << " KEY 2 SELECT " << MOV_INVIATO << "!=\"X\"\n" << "FROM " << MOV_DATAREG << "=#DATA_DA\n" << "TO " << MOV_DATAREG << "=#DATA_AL"; + + TISAM_recordset mov(query); + postprocess_movs(mov); + } + delete _book; + delete _log; + } +} int tc2700(int argc, char* argv[]) { - TIP_campo_sender app; + TIP_sender app; app.run(argc, argv, TR("Invio a IPSOA")); return 0; } diff --git a/tc/tc2700.h b/tc/tc2700.h index 5b3aea16b..f036f8176 100755 --- a/tc/tc2700.h +++ b/tc/tc2700.h @@ -1,5 +1,11 @@ #include -#include "tc2701.h" +#include +#include +#include +#include +#include +#include +#include "../cg/cg2103.h" /////////////////////////////////////////////////////////// // TIP_mask @@ -23,41 +29,164 @@ public: }; /////////////////////////////////////////////////////////// -// TIP_campo_sender +// TCausali_cache /////////////////////////////////////////////////////////// -class TIP_campo_sender : public TIP_sender +class TCausali_cache : public TCache +{ +protected: + virtual TObject* key2obj(const char* key); + +public: + const TCausale& causale(const char* codice, int annoiva); +}; + +/////////////////////////////////////////////////////////// +// TRiclassifica_cache +/////////////////////////////////////////////////////////// + +class TIPRiclassifica_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); + TIPRiclassifica_cache() : _multirel(LF_MULTIREL) { _multirel.setkey(2);} +}; + +/////////////////////////////////////////////////////////// +// TIP_sender +/////////////////////////////////////////////////////////// +const long TSbill2ricl(char & t, int gr, int co, long so); + +/////////////////////////////////////////////////////////// +// TIP_sender +/////////////////////////////////////////////////////////// +class TIP_textset : public TCSV_recordset +{ + + TAssoc_array _colnames; + +protected: + void add_field(const char* name = "Filler", int len = 0, const char * tipo = "C"); + +public: + virtual bool destroy(TRecnotype r); + virtual bool set(const char* field, const TVariant& v); + void set(const char* field, const TString & str) { set(field, TVariant(str)); } + void set(const char* field, const int n) { set(field, TVariant((long)n)); } + void set(const char* field, const char* s) { set(field, TVariant(s)); } + void set(const char* field, const TDate& d) { set(field, TVariant(d)); } + void set(const char* field, const real& v) { set(field, TVariant(v)); } + int find_column(const char * name); + + TIP_textset(const char* query = "") : TCSV_recordset(TString("CSV(\"\t\")\n") << query) {} +}; + +class TIP_clienti_textset : public TIP_textset +{ + public: + TIP_clienti_textset(const char* query = ""); +}; + +class TIP_fornitori_textset : public TIP_textset +{ + public: + TIP_fornitori_textset(const char* query = ""); +}; + +class TIP_movimenti_textset : public TIP_textset +{ + public: + TIP_movimenti_textset(const char* query = ""); +}; + +class TIP_scadenze_textset : public TIP_textset +{ + public: + TIP_scadenze_textset(const char* query = ""); +}; + +class TIP_cespiti_textset : public TIP_textset +{ + public: + TIP_cespiti_textset(const char* query = ""); +}; + +class TIP_categorie_textset : public TIP_textset +{ + public: + TIP_categorie_textset(const char* query = ""); +}; + +class TIP_intra_textset : public TIP_textset +{ + public: + TIP_intra_textset(const char* query = ""); +}; + +class TIP_sender : public TSkeleton_application { TIP_mask * _mask; TAssoc_array _caus_regolarizzazione; + TIPRiclassifica_cache* _tabelle; + TCausali_cache * _causali; + TAssoc_array _riclassifica; + bool _errors_logged; + bool _errors; + TLog_report* _log; + TReport_book * _book; + TRecord_cache * _part; + long _ultscadid; -protected: - virtual TRecordset & movrecset(); - virtual TRecordset & rmovrecset(const TRecordset & mov); - virtual TRecordset & rivarecset(const TRecordset & mov); - virtual const TRecordset & clirecset(const char tipocf, const long codcf); - virtual TMask & get_mask(); - virtual const char * mask_name() const {return "tc0700a"; } + bool test_swap(const TRecordset& mov); + bool mov_regolarizzazione(const TRecordset& mov); + bool mov_intra(const TRecordset& mov); + bool mov_reverse_charge(const TRecordset& mov); + const TString & scod2ricl(const char* tab, const TString& cod); + const TString & scod2ricl(const char* tab, const TVariant& cod); + const long cod2ricl(const char* tab, const TString& cod); + const long cod2ricl(const char* tab, const TVariant& cod); + const long bill2ricl(char t, int gr, int co, long so); + + const TString & pag2tipo(const TVariant & codpag); + const TString & row2cauriga(TISAM_recordset& rmov, const TCausale & caus); + void get_pref(const TVariant & pref, TVariant & pint, TVariant & pnaz); + const real ind2perc(const TVariant & tipodet); + void add_cli(TISAM_recordset & cli, TIP_clienti_textset & ipcli); + void add_forn(TISAM_recordset & forn, TIP_fornitori_textset & ipforn); + void add_mov_cg(TISAM_recordset & mov, TIP_movimenti_textset & ipmov, const TVariant & reg_regol, const TVariant & prot_regol, const char tipo = ' '); + void add_mov_iva(TISAM_recordset & mov, TIP_movimenti_textset & ipmov, const TVariant & reg_regol, const TVariant & prot_regol); + void add_mov(TISAM_recordset & mov, TIP_movimenti_textset & ipmov); + void add_scad(TISAM_recordset & mov, TIP_scadenze_textset & ipscad); + void add_intra(TISAM_recordset & mov, TIP_intra_textset & ipintra); + void transfer_cli(const char * path); + void transfer_forn(const char * path); + void transfer_mov(const char * path); + void transfer_scad(const char * path); + void transfer_cesp(const char * path); + void transfer_cat(const char * path); + void transfer_intra(const char * path); protected: virtual bool find_regolarizzazione(TRecordset& mov); - virtual const char * decode_causale(const TRecordset& mov); - virtual bool test_swap(const TRecordset& mov); - virtual bool swap_ritsoc(const TRecordset& mov); - virtual bool mov_regolarizzazione(const TRecordset& mov); - virtual bool mov_intra(const TRecordset& mov); - virtual bool mov_reverse_charge(const TRecordset& mov); - virtual long iva11_reverse(const TRecordset & mov); - virtual bool regime_agricolo(const TRecordset& mov) const; - + virtual TMask & get_mask(); public: + virtual bool multi_activity() const { return true; } + TAssoc_array & riclassifica() {return _riclassifica;} + virtual void postprocess_movs(TRecordset & mov); + virtual void set_parameters(); + +// qui + void log(int sev, const char* msg); + virtual bool create(); + virtual void main_loop(); virtual bool destroy(); - TIP_campo_sender() : TIP_sender(), _mask(NULL) {} - ~TIP_campo_sender() {} + TIP_sender() : _tabelle(NULL) {} }; - - diff --git a/tc/tc2700a.h b/tc/tc2700a.h index ffc643992..5e8e11a69 100755 --- a/tc/tc2700a.h +++ b/tc/tc2700a.h @@ -2,9 +2,13 @@ #define F_CODDITTA 101 #define F_RAGSOC 102 -#define F_MOVIMENTI 103 -#define F_INTRASTAT 104 -#define F_PATH 105 -#define F_FILE 106 -#define F_DATA_DA 107 -#define F_DATA_AL 108 +#define F_CLIENTI 103 +#define F_FORNITORI 104 +#define F_MOVIMENTI 106 +#define F_SCADENZE 107 +#define F_CESPITI 108 +#define F_CATEGORIE 109 +#define F_INTRASTAT 110 +#define F_PATH 111 +#define F_DATA_DA 112 +#define F_DATA_AL 113 diff --git a/tc/tc2700a.uml b/tc/tc2700a.uml index c896e7abd..ca3ced71a 100755 --- a/tc/tc2700a.uml +++ b/tc/tc2700a.uml @@ -36,44 +36,64 @@ BEGIN FLAGS "D" END -GROUPBOX DLG_NULL 76 4 +GROUPBOX DLG_NULL 76 5 BEGIN - PROMPT 2 4 "Dati da inviare" + PROMPT 2 5 "Dati da inviare" +END + +BOOLEAN F_CLIENTI +BEGIN + PROMPT 3 6 "Clienti" +END + +BOOLEAN F_FORNITORI +BEGIN + PROMPT 3 7 "Fornitori" END BOOLEAN F_MOVIMENTI BEGIN - PROMPT 3 5 "Movimenti contabili" + PROMPT 3 8 "Movimenti contabili" +END + +BOOLEAN F_SCADENZE +BEGIN + PROMPT 25 6 "Scadenze" +END + +BOOLEAN F_CESPITI +BEGIN + PROMPT 25 7 "Cespiti" + FLAGS "D" +END + +BOOLEAN F_CATEGORIE +BEGIN + PROMPT 25 8 "Categorie" + FLAGS "D" END BOOLEAN F_INTRASTAT BEGIN - PROMPT 3 6 "Intrastat" + PROMPT 50 6 "Intrastat" END STRING F_PATH 256 39 BEGIN - PROMPT 2 8 "Cartella " + PROMPT 2 11 "Cartella " DSELECT CHECKTYPE REQUIRED FIELD TSDestPath END -STRING F_FILE 18 -BEGIN - PROMPT 54 8 "File " - FIELD TSDestFile -END - - DATE F_DATA_DA BEGIN - PROMPT 2 10 "Data iniz. " + PROMPT 2 13 "Data iniz. " END DATE F_DATA_AL BEGIN - PROMPT 30 10 "Data fin. " + PROMPT 30 13 "Data fin. " END diff --git a/tc/tc2701.cpp b/tc/tc2701.cpp deleted file mode 100755 index 0db5ebc3f..000000000 --- a/tc/tc2701.cpp +++ /dev/null @@ -1,1529 +0,0 @@ -#include "tc2.h" -#include "tc2701.h" -#include "tc2700a.h" - -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include - -#include "../cg/cglib01.h" - -#define TSINDETR 600 // e pensare che ne vendono migliaia -#define TSACQDESTRIV 200 - -/////////////////////////////////////////////////////////// -// TRiclassifica_cache -/////////////////////////////////////////////////////////// - -HIDDEN const char* const __tiporicconti = "TSCONTI"; - -TObject* TIPRiclassifica_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, cod); - _multirel.zero(MULTI_SECOND); - if (_multirel.read() == NOERR) - return new TString(_multirel.get(MULTI_DATA)); - return NULL; -} - -long TIPRiclassifica_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 * TIPRiclassifica_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 : ""; -} - - -const long TSbill2ricl(char & t, int gr, int co, long so) -{ - TRecord_cache * __conti = NULL; - - if (__conti == NULL) - __conti = new TRecord_cache(LF_RICLPDC, 1); - - long codricl = 0; - if (gr > 0) - { - TToken_string cod; - cod.add(__tiporicconti); - 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); - } - } - return codricl; -} - -TIP_sender& app() { return (TIP_sender&)main_app(); } - -/////////////////////////////////////////////////////////// -// TIP_textset -/////////////////////////////////////////////////////////// - -class TIP_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); - - TIP_textset(const char* query = ""); -}; - -class TIVA_item : public TObject -{ - int _row; - long _conto; - long _codiva; - long _codiva11; - real _imponibile; - real _imposta; - TString4 _codcomp; - -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;} - const TString & codcomp() { return _codcomp;} - TIVA_item(int row, long conto, long codiva, long codiva11, const char * codcomp) : _row(row), _conto(conto), _codiva(codiva), _codiva11(codiva11), _codcomp(codcomp) {} - virtual ~TIVA_item() {} -}; - -long TIP_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& TIP_textset::rec_type(TRecnotype r) const -{ - const TString& t = TAS400_recordset::rec_type(r); - return t; -} - -bool TIP_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 TIP_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 TIP_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; -} - -TIP_textset::TIP_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 - - int i; - // 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à 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à 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à - 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) è 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 ) -} - -/////////////////////////////////////////////////////////// -// TIP_sender -/////////////////////////////////////////////////////////// - -const TString & TIP_sender::descr2agg(const char* d) -{ - TString & descr = get_tmp_string(128); - - descr = d; - int p = descr.find("Inc. ft. "); - - if (p < 0) - p = descr.find("Pag. ft. "); - if (p < 0) - p = descr.find("Nota cr. "); - if (p >= 0) - descr.ltrim(p + 9); - descr = descr.left(18); - - return descr; -} - -bool TIP_sender::new_rec(const char* t) -{ - CHECK(t && *t, "Tipo non valido"); - return _tsfile->new_rec(t) >= 0; -} - -void TIP_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 TIP_sender::set(const char* field, const TVariant& var) -{ - _tsfile->set(field, var); -} - -const TVariant& TIP_sender::get(const char* field) -{ - return _tsfile->get(field); -} - - -void TIP_sender::remove_last() -{ - _tsfile->destroy(_tsfile->last()); - _tsfile->move_last(); -} - -bool TIP_sender::add_optional_rec(TRecordset& mov, bool rec_to_add) -{ - if (rec_to_add) - { - new_rec("1"); - set("TRF1-DITTA", dittamulti(mov)); - } - return false; -} - -bool TIP_sender::add_regol(TRecordset& mov, bool rec_to_add) -{ - rec_to_add = add_optional_rec(mov, rec_to_add); - - TString16 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); - - const bool is_intra = mov_intra(mov); - if (is_intra) - { - corrvaluta *= CENTO; - set("TRF-TOTVAL", corrvaluta); - } - - const TRecnotype pos = mov.current_row(); // Salva la posizione - - if (find_regolarizzazione(mov)) - { - set("TRF-NUM-AUTOFATT", mov.get(MOV_PROTIVA).as_int()); - - const TString16 codice = scod2ricl("TSREG", mov.get(MOV_REG)); - const long codreg = atol(codice.mid(1)); - set("TRF-SERIE-AUTOFATT", codreg); - } - else - { - if (is_intra) - log(2, TR("Manca la regolarizzazione del movimento intra")); - else - log(2, TR("Manca la regolarizzazione del movimento reverse charge")); - } - - mov.move_to(pos); // Ripristina posizione - - return rec_to_add; -} - -void TIP_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 TIP_sender::add_ratei_risconti(const TRecordset& mov) -{ -} - -const TString & TIP_sender::dittamulti(const TRecordset& mov) const -{ - if (multi_activity()) - { - const TString4 codice(mov.get(MOV_REG).as_string()); - - if (codice.full()) - { - int annoiva = mov.get(MOV_DATAREG).as_date().year(); - TString16 key; - - key.format("%04d%s", annoiva, (const char *) codice); - const TString8 attivita = cache().get("REG", key, "S8"); - const TString * ditta = (const TString * )_dittemulti.objptr(attivita); - - if (ditta != NULL) - return *ditta; - } - } - return _dittamulti; -} - -void TIP_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 TIP_sender::add_diversi(const TRecordset& mov, const bool moviva) -{ - const bool vendite = mov.get(MOV_TIPO).as_string()[0] != 'F'; - const TString16 codice = scod2ricl("TSREG", mov.get(MOV_REG)); - const bool corrispettivo = codice[0] == 'C'; - - 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, !moviva); //, one_clifor); -// bool add_rec = (j >= 80) || (dont_send_clifo && t > ' '); - bool add_rec = (j >= 80) || t > ' '; - if (moviva) - { - if (as400) - { - if (t > ' ' && !corrispettivo && 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; - if (_professionista && vendite) - _rit_acc += rmov.get(RMV_IMPORTO).as_real(); - } - else - { - const char sez = rmov.get(RMV_SEZIONE).as_string()[0]; - if (as400 && corrispettivo && sez == 'D') - { - 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)); - field.format("TRF-CAU-AGGIUNT_%d", j); - set(field, descr2agg(rmov.get(RMV_DESCR).as_string())); - j++; - } - 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ù 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 ) - if (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)) - { - if (!_professionista || !vendite) - { - 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)); - field.format("TRF-CAU-AGGIUNT_%d", j); - set(field, descr2agg(rmov.get(RMV_DESCR).as_string())); - 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); - field.format("TRF-CAU-AGGIUNT_%d", j); - set(field, descr2agg(rmov.get(RMV_DESCR).as_string())); - j++; - } - else - log(2, "Conto cliente/formitore non trovato per giroconto ritenute o intra o reverse charge"); - } - } - else - set("TRF-RIT-ACC", _rit_acc); - - } - valid_rec = true; - } - if (added_rec && !valid_rec) - { - remove_last(); - set("TRF-80-SEGUENTE", "U"); - } -} - -void TIP_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); - TString16 codice = scod2ricl("TSREG", mov.get(MOV_REG)); - const bool corrispettivo = codice[0] == 'C'; - const bool acquisto = mov.get(MOV_TIPO).as_string()[0] == 'F'; - 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); // ok - - 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 TString4 tipodet = riva.get(RMI_TIPODET).as_string(); - const bool indetraibile = tipodet.full(); - - if (acquisto && 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ù 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 TIP_sender::add_tot_fattura(const TRecordset& mov) -{ - const bool vendite = mov.get(MOV_TIPO).as_string()[0] != 'F'; - 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); - - if (_professionista && vendite) - set("TRF-RIT-ACC", ritfis); - _rit_acc = ZERO; -} - -void TIP_sender::add_datiiva(const TRecordset& mov) -{ - TRecordset & rmoviva = rivarecset(mov); - TString16 codice = scod2ricl("TSREG", mov.get(MOV_REG)); - const bool corrispettivo = codice[0] == 'C'; - const bool acquisto = mov.get(MOV_TIPO).as_string()[0] == 'F'; - 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; - TCodiceIVA c(rmoviva.get(RMI_CODIVA).as_string()); - bool agricolo = c.get_int("S4") == 1; - TString16 codcomp; - - if (corrispettivo) - if (imposta == ZERO) - imposta = c.scorpora(imponibile); - if (regime_agricolo(mov) && agricolo) - { - TString key; - key.format("%03ld|%03ld|%06ld", rmoviva.get(RMI_GRUPPO).as_int(), rmoviva.get(RMI_CONTO).as_int(), rmoviva.get(RMI_SOTTOCONTO).as_int()); - const TRectype & pcon = cache().get(LF_PCON, key); - codcomp = pcon.get(PCN_IVACOMP); - } - long codiva = cod2ricl("TSIVA", rmoviva.get(RMI_CODIVA)); - long codiva11 = 0L; - //da modificare nella 3.1 - const TString4 tipodet = rmoviva.get(RMI_TIPODET).as_string(); - const bool indetraibile = tipodet.full(); - const TString4 tipocr = rmoviva.get(RMI_TIPOCR).as_string(); - const bool acqvent = _ventilazione && (imposta != ZERO) && tipocr == "1"; - - if (acquisto && indetraibile) - codiva += TSINDETR; // maialata - if (acquisto && acqvent) - codiva += TSACQDESTRIV; // maialata 2 - if (codiva11rev > 0L) - codiva11 = codiva11rev; - else - if (rmoviva.get(RMI_TIPOCR).as_int() > 0) - codiva11 = cod2ricl("TSI11", 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, codcomp); - _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, item.codcomp()); - field.format("TRF-IVA11_%d", row); - set(field, item.codiva11()); - field.format("TRF-IMPOSTA_%d", row); - set(field, item.imposta()); - } - } -} - -void TIP_sender::add_header(const TRecordset& mov, const bool fullhesd) -{ - const bool moviva = !mov.get(MOV_REG).is_empty(); - const TString8 src_caus(mov.get(MOV_CODCAUS).as_string()); - const long codcaus = src_caus.full() ? cod2ricl("TSCAU", src_caus) : _empty_caus; - - // dati obbligatori - set("TRF-DITTA", dittamulti(mov)); - set("TRF-CAUSALE", codcaus); - - const TString descaus(decode_causale(mov)); - const TString & desc = mov.get(MOV_DESCR).as_string(); - - set("TRF-CAU-DES", descaus.left(15)); - if (!moviva) - { - set("TRF-CAU-AGG", descaus.mid(15)); - set("TRF-CAU-AGG-1", desc.left(34)); - set("TRF-CAU-AGG-2", desc.mid(34)); - } - else - { - set("TRF-CAU-AGG", desc.left(18)); - set("TRF-CAU-AGG-1", desc.mid(18)); - } - - 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()); - TString16 codice = moviva ? scod2ricl("TSREG", mov.get(MOV_REG)) : "000"; - - numdoc.left(6); - if (numdoc.full()) - { - TString s; - - for (int i = 0; i < numdoc.len(); i++) - if (isdigit(numdoc[i])) - s << numdoc[i]; - numdoc.lpad(6, '0'); - 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 TIP_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) - { - if (dencom.full()) - dencom.insert(", "); - dencom.insert(localita); - } - } -} - -void TIP_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; - } - const bool send_clifo = !_riclassifica.is_key("TSNOHCLI"); - - if (send_clifo) - set("TRF-COD-CLIFOR", codcf); - 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); //ok - - 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)); - if (_riclassifica.is_key("TSSTOCLI")) - { - set("TRF-STORICO", "S"); - TDate datalim = get_mask().get_date(F_DATA_AL); - set("TRF-STORICO-DATA", datalim.date2ansi()); - } - } -} - -void TIP_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 TIP_sender::bill2ricl(char & t, int gr, int co, long so, const bool header_cli) -{ - long codricl = 0; - if (gr > 0) - { - const bool ricl = _riclassifica.is_key(__tiporicconti); - - if (ricl) - { - codricl = ::TSbill2ricl(t, gr, co, so); - - 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 - { - if (t > ' ') - { - if (header_cli) - { - if (t == 'C') - codricl = 9999999L; - else - codricl = 9999998L; - } - else - codricl = gr*100000+so; - - } - else - codricl = gr*100000+co*1000+so; - } - } - return codricl; -} - -const TString & TIP_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 & TIP_sender::scod2ricl(const char* tab, const TVariant& cod) -{ - return scod2ricl(tab, cod.as_string()); -} - -const long TIP_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 TIP_sender::cod2ricl(const char* tab, const TVariant& cod) -{ - return cod2ricl(tab, cod.as_string()); -} - -void TIP_sender::set_parameters() -{ - TConfig configtc(CONFIG_DITTA, "tc"); - - _dittamulti = configtc.get("TSDitta"); - _professionista = configtc.get_bool("TSPROFESS"); - _ventilazione = configtc.get_bool("TSVENT"); - - for (int j = 0; configtc.exist("TSDATT", j); j++) - { - const TString8 att(configtc.get("TSDATT", NULL, j)); - const TString8 ditta(configtc.get("TSDDITTA", NULL, j)); - - if (att.full()) - _dittemulti.add(att, ditta); - } - - _empty_caus = configtc.get_long("TSREMCAU"); - - 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); // ok - 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); // ok - TString16 key; key.format("%08ld", contoricl); - _contirit.add(key, NULL); - } -} - -bool TIP_sender::create() -{ - _tabelle = new TIPRiclassifica_cache; - set_parameters(); - return TSkeleton_application::create(); -} - -bool TIP_sender::destroy() -{ - delete _tabelle; - return TSkeleton_application::destroy(); -} - -void TIP_sender::main_loop() -{ - TMask & m = get_mask(); - while (m.run() != K_QUIT) - { - const char* const title = TR("Invio a TeamSystem"); - _tsfile = new TIP_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; - } -} diff --git a/tc/tc2701.h b/tc/tc2701.h deleted file mode 100755 index 2f02a7f51..000000000 --- a/tc/tc2701.h +++ /dev/null @@ -1,114 +0,0 @@ -#include -#include -#include -#include -#include - -/////////////////////////////////////////////////////////// -// TRiclassifica_cache -/////////////////////////////////////////////////////////// - -class TIPRiclassifica_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); - TIPRiclassifica_cache() : _multirel(LF_MULTIREL) { _multirel.setkey(2);} -}; - -/////////////////////////////////////////////////////////// -// TIP_sender -/////////////////////////////////////////////////////////// -const long TSbill2ricl(char & t, int gr, int co, long so); - -/////////////////////////////////////////////////////////// -// TIP_sender -/////////////////////////////////////////////////////////// -class TIP_textset; - -class TIP_sender : public TSkeleton_application -{ - TIPRiclassifica_cache* _tabelle; - TAssoc_array _riclassifica; - TIP_textset* _tsfile; - TLog_report* _log; - bool _errors_logged; - TString8 _dittamulti; - TAssoc_array _dittemulti; - long _empty_caus; - TArray _recsets; - TAssoc_array _iva; - TAssoc_array _contiiva; - TAssoc_array _contirit; - bool _professionista; - bool _ventilazione; - real _rit_acc; - -protected: - TRecordset * get_recset(const int logicnum) const { return (TRecordset *) _recsets.objptr(logicnum);} - TRecordset * set_recset(const int logicnum, TRecordset * r) { _recsets.add(r, logicnum); return r;} - TArray & recsets() { return _recsets;} - const TString & descr2agg(const char* d); - bool new_rec(const char* t); - void remove_last(); - void set(const char* field, const TVariant& var); - void set(const char* field, const TString & str) { set(field, TVariant(str)); } - void set(const char* field, const int n) { set(field, TVariant((long)n)); } - void set(const char* field, const char* s) { set(field, TVariant(s)); } - void set(const char* field, const TDate& d) { set(field, TVariant(d)); } - void set(const char* field, const real& v) { set(field, TVariant(v)); } - - const TVariant& get(const char* field); - void add_mov(TRecordset& mov); - void add_clifor(char tipocf, long codcf); - void add_header(const TRecordset& mov, const bool fullhead = true); - void add_datiiva(const TRecordset& mov); - void add_tot_fattura(const TRecordset& mov); - void add_conti_ricavo_costo(const TRecordset& mov); - void add_new_rec(const TRecordset& mov); - void add_diversi(const TRecordset& mov, const bool moviva); - void add_ratei_risconti(const TRecordset& mov); - void add_ulteriori(TRecordset& mov); - bool add_regol(TRecordset& mov, bool rec_to_add); - bool add_optional_rec(TRecordset& mov, bool rec_to_add); - const TString & scod2ricl(const char* tab, const TString& cod); - const TString & scod2ricl(const char* tab, const TVariant& cod); - const long cod2ricl(const char* tab, const TString& cod); - const long cod2ricl(const char* tab, const TVariant& cod); - const long bill2ricl(char & t, int gr, int co, long so, const bool header_cli = true); - - virtual void get_citta_provincia(const TRecordset& cli, TString & dencom, TString & provcom, bool nascita = false); - virtual const char * decode_causale(const TRecordset& mov) { return EMPTY_STRING; } - virtual bool test_swap(const TRecordset& mov) { return false;} - virtual bool swap_ritsoc(const TRecordset& mov) { return false;} - virtual bool mov_regolarizzazione(const TRecordset& mov) { return false;} - virtual bool mov_intra(const TRecordset& mov) { return false;} - virtual bool mov_reverse_charge(const TRecordset& mov) { return false;} - virtual long iva11_reverse(const TRecordset & mov) { return 0L;} - bool add_iva_to_mov(const TRecordset& mov) { return mov_intra(mov) || mov_reverse_charge(mov);} - -protected: - virtual bool find_regolarizzazione(TRecordset& mov) {return false;} - virtual TRecordset & movrecset() pure; - virtual TRecordset & rmovrecset(const TRecordset & mov) pure; - virtual TRecordset & rivarecset(const TRecordset & mov) pure; - virtual const TRecordset & clirecset(const char tipocf, const long codcf) pure; - virtual bool regime_agricolo(const TRecordset& mov) const { return false; } - virtual TMask & get_mask() pure ; - -public: - void log(int sev, const char* msg); - virtual bool multi_activity() const { return true; } - virtual const TString & dittamulti(const TRecordset& mov) const ; - TAssoc_array & riclassifica() {return _riclassifica;} - - virtual void postprocess_movs(TRecordset & mov) {} - virtual void set_parameters(); - virtual bool create(); - virtual void main_loop(); - virtual bool destroy(); - TIP_sender() : _tabelle(NULL), _tsfile(NULL), _log(NULL) {} -}; diff --git a/tc/tc2800a.uml b/tc/tc2800a.uml index 539a3ee1c..96c91b885 100755 --- a/tc/tc2800a.uml +++ b/tc/tc2800a.uml @@ -1,4 +1,4 @@ -#include "tc0800a.h" +#include "tc2800a.h" TOOLBAR "topbar" 0 0 0 2 #include @@ -94,7 +94,7 @@ BEGIN WARNING "Manca il conto" END -NUMBER F_CONTO 12 +NUMBER F_CONTO 3 BEGIN PROMPT 2 4 "Conto " HELP "Codice dell'eventuale conto" @@ -200,6 +200,7 @@ BEGIN OUTPUT F_IPCONTO CODTAB OUTPUT F_IPDESCR S0 FIELD CODICE + ADD RUN "TC2 -0" END STRING F_IPDESCR 50 @@ -211,6 +212,7 @@ BEGIN DISPLAY "Conto IPSOA" CODTAB COPY OUTPUT F_IPCONTO CHECKTYPE SEARCH + ADD RUN "TC2 -0" END ENDPAGE diff --git a/tc/tcipcau.uml b/tc/tcipcau.uml index 39aa29279..f396ca02d 100755 --- a/tc/tcipcau.uml +++ b/tc/tcipcau.uml @@ -20,7 +20,7 @@ BEGIN KEY 1 END -NUMBER F_CODTAB 3 +STRING F_CODTAB 3 BEGIN PROMPT 2 2 "" USE LF_MULTIREL @@ -34,7 +34,6 @@ BEGIN DISPLAY "Descrizione@50" &ICA->S0 OUTPUT F_CODTAB FIRST OUTPUT F_CODTAB1 FIRST - OUTPUT F_COD_CAMPO DATA FIELD FIRST FLAGS "UZG" KEY 1 @@ -42,12 +41,12 @@ BEGIN CHECKTYPE REQUIRED END -NUMBER F_CODTAB1 3 +STRING F_CODTAB1 3 BEGIN PROMPT 2 2 "" USE LF_CAUSALI JOIN LF_MULTIREL INTO COD=="IPCAU" FIRST==CODCAUS - JOIN &TCA TO LF_MULTIREL INTO CODTAB==DATA + JOIN &ICA TO LF_MULTIREL INTO CODTAB==DATA INPUT CODCAUS F_CODTAB1 DISPLAY "Cod." CODCAUS DISPLAY "Descrizione@50" DESCR @@ -74,7 +73,7 @@ BEGIN PROMPT 10 2 "Descrizione " USE LF_CAUSALI KEY 2 JOIN LF_MULTIREL INTO COD=="TSCAU" FIRST==CODCAUS - JOIN &TCA TO LF_MULTIREL INTO CODTAB==DATA + JOIN &ICA TO LF_MULTIREL INTO CODTAB==DATA INPUT DESCR F_DESC DISPLAY "Descrizione@60" DESCR DISPLAY "Codice" CODCAUS @@ -86,7 +85,7 @@ BEGIN CHECKTYPE REQUIRED END -NUMBER F_COD_CAMPO 4 +STRING F_COD_CAMPO 4 BEGIN PROMPT 2 4 "Causale IPSOA " FIELD DATA @@ -97,7 +96,7 @@ BEGIN OUTPUT F_COD_CAMPO CODTAB OUTPUT F_DESC1 S0 CHECKTYPE REQUIRED - FLAGS "Z" + FLAGS "ZU" END STRING F_DESC1 50 45 diff --git a/tc/tcipcdp.uml b/tc/tcipcdp.uml index d306da2c3..4e8fdae72 100755 --- a/tc/tcipcdp.uml +++ b/tc/tcipcdp.uml @@ -81,7 +81,7 @@ BEGIN CHECKTYPE REQUIRED END -NUMBER F_COD_CAMPO 4 +NUMBER F_COD_CAMPO 3 BEGIN PROMPT 2 4 "Pagamento IPSOA " FIELD DATA diff --git a/tc/tcipicc.uml b/tc/tcipicc.uml new file mode 100755 index 000000000..8f1616d0b --- /dev/null +++ b/tc/tcipicc.uml @@ -0,0 +1,110 @@ +#include "tcts.h" + +TOOLBAR "topbar" 0 0 0 2 +#include +ENDPAGE + +PAGE "Condizioni di consegna" 0 2 0 0 + +GROUPBOX DLG_NULL 78 3 +BEGIN + PROMPT 1 1 "Condizioni di consegna Campo" +END + +LIST F_COD 5 +BEGIN + PROMPT 50 50 "" + ITEM "IPICC|IPICC" + FIELD COD + FLAGS "D" + KEY 1 +END + +STRING F_CODTAB 3 +BEGIN + PROMPT 2 2 "" + USE LF_MULTIREL + JOIN %ICC INTO CODTAB==FIRST + JOIN &IIC ALIAS 100 INTO CODTAB==DATA + INPUT COD F_COD SELECT + INPUT FIRST F_CODTAB + DISPLAY "Codice" FIRST + DISPLAY "Descrizione@60" %ICC->S0 + DISPLAY "Condizione di consegna IPSOA" DATA + DISPLAY "Descrizione@50" 100@->S0 + OUTPUT F_CODTAB FIRST + OUTPUT F_CODTAB1 FIRST + OUTPUT F_COD_CAMPO DATA + FIELD FIRST + FLAGS "UZG" + KEY 1 + GROUP 1 + CHECKTYPE REQUIRED +END + +STRING F_CODTAB1 3 +BEGIN + PROMPT 2 2 "" + USE %ICC + JOIN LF_MULTIREL INTO COD=="IPICC" FIRST==CODTAB + JOIN &IIC TO LF_MULTIREL INTO CODTAB==DATA + INPUT CODTAB F_CODTAB1 + DISPLAY "Cod." CODTAB + DISPLAY "Descrizione@50" S0 + DISPLAY "Causale IPSOA" LF_MULTIREL->DATA + DISPLAY "Descrizione@50" &IIC->S0 + OUTPUT F_CODTAB CODTAB + OUTPUT F_CODTAB1 CODTAB + OUTPUT F_DESC %ICC->S0 + KEY 1 + FIELD FIRST + FLAGS "UZ" + CHECKTYPE REQUIRED + GROUP 2 +END + +STRING F_DESC 50 +BEGIN + PROMPT 10 2 "Descrizione " + USE %ICC KEY 2 + JOIN LF_MULTIREL INTO COD=="TSICC" FIRST==CODTAB + JOIN &IIC TO LF_MULTIREL INTO CODTAB==DATA + INPUT S0 F_DESC + DISPLAY "Descrizione@60" S0 + DISPLAY "Codice" CODTAB + DISPLAY "Causale IPSOA" LF_MULTIREL->DATA + DISPLAY "Descrizione@50" &IIC->S0 + COPY OUTPUT F_CODTAB1 + KEY 2 + GROUP 3 + CHECKTYPE REQUIRED +END + +STRING F_COD_CAMPO 1 +BEGIN + PROMPT 2 4 "C.consegna IPSOA " + USE &IIC + FLAGS "U" + FIELD DATA + INPUT CODTAB F_COD_CAMPO + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@60" S0 + OUTPUT F_COD_CAMPO CODTAB + OUTPUT F_DESC1 S0 + CHECKTYPE REQUIRED + FLAGS "U" +END + +STRING F_DESC1 50 45 +BEGIN + PROMPT 27 4 "" + USE &IIC KEY 2 + INPUT S0 F_DESC1 + DISPLAY "Descrizione@60" S0 + DISPLAY "Codice" CODTAB + COPY OUTPUT F_COD_CAMPO +END + +ENDPAGE + +ENDMASK diff --git a/tc/tcipnaz.uml b/tc/tcipnaz.uml index 2504942d9..9c155f1c1 100755 --- a/tc/tcipnaz.uml +++ b/tc/tcipnaz.uml @@ -79,12 +79,12 @@ BEGIN CHECKTYPE REQUIRED END -NUMBER F_COD_CAMPO 4 +STRING F_COD_CAMPO 4 BEGIN PROMPT 2 4 "Nazione IPSOA " FIELD DATA - FLAGS "Z" - USE &TNA + FLAGS "U" + USE &INA INPUT CODTAB F_COD_CAMPO DISPLAY "Cod." CODTAB DISPLAY "Descrizione@50" S0 diff --git a/tc/tcipreg.uml b/tc/tcipreg.uml index fdb21abca..46b3ebb69 100755 --- a/tc/tcipreg.uml +++ b/tc/tcipreg.uml @@ -92,7 +92,9 @@ BEGIN INPUT CODTAB F_COD_CAMPO DISPLAY "Codice" CODTAB DISPLAY "Descrizione@50" S0 + OUTPUT F_COD_CAMPO CODTAB OUTPUT F_DESC1 S0 + FLAGS "Z" CHECKTYPE REQUIRED END diff --git a/tc/tcmenu.men b/tc/tcmenu.men index 32399d709..e08a2667b 100755 --- a/tc/tcmenu.men +++ b/tc/tcmenu.men @@ -5,11 +5,12 @@ Module = 27 Flags = "" Item_01 = "TeamSystem", [TCMENU_002] Item_02 = "Zucchetti", [TCMENU_006] -Item_03 = "Proforma", "tc9 -0", "" -Item_04 = "Sispac", "tc9 -2", "" -Item_05 = "Tabella IVA Sispac", "tc9 -3 IVA", "" -Item_06 = "Tabella causali Sispac", "tc9 -3 CAU", "" -Item_07 = "Semetra", "tc8 -0", "" +Item_03 = "IPSOA", [TCMENU_010] +Item_04 = "Proforma", "tc9 -0", "" +Item_05 = "Sispac", "tc9 -2", "" +Item_06 = "Tabella IVA Sispac", "tc9 -3 IVA", "" +Item_07 = "Tabella causali Sispac", "tc9 -3 CAU", "" +Item_08 = "Semetra", "tc8 -0", "" [TCMENU_002] Caption = "TeamSystem" @@ -101,7 +102,7 @@ Module = 27 Flags = "" Item_01 = "Trasferimento", "tc2 -6", "" Item_02 = "Tabelle di riclassificazione", [TCMENU_011] -Item_03 = "Tabelle TeamSystem", [TCMENU_012] +Item_03 = "Tabelle IPSOA", [TCMENU_012] Item_04 = "Configurazione modulo", [TCMENU_013] [TCMENU_011] @@ -116,7 +117,8 @@ Item_04 = "Registri", "tc2 -4 REG", "" Item_05 = "Codici IVA", "tc2 -4 IVA", "" Item_06 = "Valute", "tc2 -4 VAL", "" Item_07 = "Attività", "tc2 -4 ATT", "" -Item_08 = "Piano dei conti", "tc2 -7", "" +Item_08 = "Condizioni di consegna", "tc2 -4 ICC", "" +Item_09 = "Piano dei conti", "tc2 -7", "" [TCMENU_012] Caption = "Tabelle IPSOA" @@ -131,6 +133,7 @@ Item_05 = "Codici IVA", "tc2 -0 &IIV", "" Item_06 = "Valute", "tc2 -0 &IVL", "" Item_07 = "Attività", "tc2 -0 &IAT", "" Item_08 = "Piano dei conti", "tc2 -0 &ICO", "" +Item_09 = "Condizioni di consegna", "tc2 -0 &IIC", "" [TCMENU_013] Caption = "Configurazione modulo" diff --git a/tc/tctbica.uml b/tc/tctbica.uml index a03681a41..23de6594f 100755 --- a/tc/tctbica.uml +++ b/tc/tctbica.uml @@ -11,7 +11,7 @@ BEGIN PROMPT 1 1 "Codice Causale IPSOA" END -NUMBER F_CODTAB 4 +STRING F_CODTAB 4 BEGIN PROMPT 2 2 "Codice " USE &ICA @@ -22,8 +22,7 @@ BEGIN OUTPUT F_DESC S0 CHECKTYPE REQUIRED FIELD CODTAB - FLAGS "Z" - VALIDATE FIXLEN_FUNC 4 + FLAGS "ZU" KEY 1 END diff --git a/tc/tctbiic.h b/tc/tctbiic.h new file mode 100755 index 000000000..f795e3ac6 --- /dev/null +++ b/tc/tctbiic.h @@ -0,0 +1,2 @@ +#define F_CODTAB 100 +#define F_DESC 101 diff --git a/tc/tctbiic.uml b/tc/tctbiic.uml new file mode 100755 index 000000000..60b5531e2 --- /dev/null +++ b/tc/tctbiic.uml @@ -0,0 +1,45 @@ +#include "tctbiic.h" + +TOOLBAR "topbar" 0 0 0 2 +#include +ENDPAGE + +PAGE "Condizioni di consegna" 0 2 0 0 + +GROUPBOX DLG_NULL 78 3 +BEGIN + PROMPT 1 1 "Condizione di consegna IPSOA" +END + +STRING F_CODTAB 1 +BEGIN + PROMPT 2 2 "Codice " + USE &IIC + INPUT CODTAB F_CODTAB + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@60" S0 + OUTPUT F_CODTAB CODTAB + OUTPUT F_DESC S0 + CHECKTYPE REQUIRED + FLAGS "U" + FIELD CODTAB + KEY 1 +END + + +STRING F_DESC 50 +BEGIN + PROMPT 2 5 "Descrizione " + USE &IIC KEY 2 + INPUT S0 F_DESC + DISPLAY "Descrizione@60" S0 + DISPLAY "Codice" CODTAB + COPY OUTPUT F_CODTAB + FIELD S0 + KEY 2 + CHECKTYPE NORMMAL +END + +ENDPAGE + +ENDMASK diff --git a/tc/tctbina.uml b/tc/tctbina.uml index 0d8700c1d..c77db337b 100755 --- a/tc/tctbina.uml +++ b/tc/tctbina.uml @@ -11,7 +11,7 @@ BEGIN PROMPT 1 1 "Codice Nazione IPSOA" END -NUMBER F_CODTAB 4 +STRING F_CODTAB 4 BEGIN PROMPT 2 2 "Codice " USE &INA @@ -22,7 +22,7 @@ BEGIN OUTPUT F_DESC S0 CHECKTYPE REQUIRED FIELD CODTAB - FLAGS "Z" + FLAGS "ZU" KEY 1 END diff --git a/tc/tctbire.uml b/tc/tctbire.uml index 9f39b14fc..adbbc4e05 100755 --- a/tc/tctbire.uml +++ b/tc/tctbire.uml @@ -23,6 +23,7 @@ BEGIN CHECKTYPE REQUIRED FIELD CODTAB VALIDATE FIXLEN_FUNC 2 + FLAGS "Z" KEY 1 END diff --git a/tc/tctbivl.uml b/tc/tctbivl.uml index cdc20ca5f..7582a0efa 100755 --- a/tc/tctbivl.uml +++ b/tc/tctbivl.uml @@ -22,6 +22,7 @@ BEGIN OUTPUT F_DESC S0 CHECKTYPE REQUIRED FIELD CODTAB + FLAGS "U" VALIDATE FIXLEN_FUNC 3 KEY 1 END diff --git a/tc/tctscau.uml b/tc/tctscau.uml index 8508d0795..664ceb06d 100755 --- a/tc/tctscau.uml +++ b/tc/tctscau.uml @@ -20,7 +20,7 @@ BEGIN KEY 1 END -NUMBER F_CODTAB 3 +STRING F_CODTAB 3 BEGIN PROMPT 2 2 "" USE LF_MULTIREL @@ -42,7 +42,7 @@ BEGIN CHECKTYPE REQUIRED END -NUMBER F_CODTAB1 3 +STRING F_CODTAB1 3 BEGIN PROMPT 2 2 "" USE LF_CAUSALI