From 463b3a5010f3b6676b0b9c026565942714e242ff Mon Sep 17 00:00:00 2001 From: bonazzi Date: Tue, 21 Mar 2017 15:43:11 +0000 Subject: [PATCH] Patch level : 12.0 370 Files correlati : tc3.exe tcmenu.men tc3100a.uml tc3800a.uml tctbrca.uml tctbrco.uml tctbriv.uml tctbrpg.uml tctbrre.uml tctbrvl.uml POrgramma di ricezione da Ericsoft versione 0 git-svn-id: svn://10.65.10.50/branches/R_10_00@23695 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- src/tc/tc0600.cpp | 1 + src/tc/tc0900.cpp | 1 + src/tc/tc3.cpp | 20 + src/tc/tc3.h | 24 + src/tc/tc3100.cpp | 1067 ++++++++++++++++++++++++++++++++++++++++++++ src/tc/tc3100a.h | 8 + src/tc/tc3100a.uml | 84 ++++ src/tc/tc3200.cpp | 54 +++ src/tc/tc3800.cpp | 160 +++++++ src/tc/tc3800a.h | 12 + src/tc/tc3800a.uml | 171 +++++++ src/tc/tc8100.cpp | 1 + src/tc/tcmenu.men | 31 +- src/tc/tctbrca.h | 5 + src/tc/tctbrca.uml | 101 +++++ src/tc/tctbrco.h | 2 + src/tc/tctbrco.uml | 45 ++ src/tc/tctbriv.h | 4 + src/tc/tctbriv.uml | 78 ++++ src/tc/tctbrpg.h | 4 + src/tc/tctbrpg.uml | 69 +++ src/tc/tctbrre.h | 6 + src/tc/tctbrre.uml | 97 ++++ src/tc/tctbrvl.h | 4 + src/tc/tctbrvl.uml | 72 +++ 25 files changed, 2120 insertions(+), 1 deletion(-) create mode 100644 src/tc/tc3.cpp create mode 100644 src/tc/tc3.h create mode 100644 src/tc/tc3100.cpp create mode 100644 src/tc/tc3100a.h create mode 100644 src/tc/tc3100a.uml create mode 100644 src/tc/tc3200.cpp create mode 100644 src/tc/tc3800.cpp create mode 100644 src/tc/tc3800a.h create mode 100644 src/tc/tc3800a.uml create mode 100644 src/tc/tctbrca.h create mode 100644 src/tc/tctbrca.uml create mode 100644 src/tc/tctbrco.h create mode 100644 src/tc/tctbrco.uml create mode 100644 src/tc/tctbriv.h create mode 100644 src/tc/tctbriv.uml create mode 100644 src/tc/tctbrpg.h create mode 100644 src/tc/tctbrpg.uml create mode 100644 src/tc/tctbrre.h create mode 100644 src/tc/tctbrre.uml create mode 100644 src/tc/tctbrvl.h create mode 100644 src/tc/tctbrvl.uml diff --git a/src/tc/tc0600.cpp b/src/tc/tc0600.cpp index 40df58192..04f00b304 100755 --- a/src/tc/tc0600.cpp +++ b/src/tc/tc0600.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include "tc0.h" diff --git a/src/tc/tc0900.cpp b/src/tc/tc0900.cpp index d5c92d7ed..122638667 100755 --- a/src/tc/tc0900.cpp +++ b/src/tc/tc0900.cpp @@ -17,6 +17,7 @@ #include #include #include +#include #include #include diff --git a/src/tc/tc3.cpp b/src/tc/tc3.cpp new file mode 100644 index 000000000..5dc3d580b --- /dev/null +++ b/src/tc/tc3.cpp @@ -0,0 +1,20 @@ +#include + +#include "tc3.h" + +int main(int argc, char** argv) +{ + const int op = argc < 2 ? 0 : argv[1][1]-'0'; + switch (op) + { + case 7: tc3800(argc,argv); break; // riclassificazione conti zucchetti + case 1: tc3200(argc,argv); break; // Tabelle + default: tc3100(argc,argv); break; // trasferimento zucchetti + } + return 0; +} + + + + + diff --git a/src/tc/tc3.h b/src/tc/tc3.h new file mode 100644 index 000000000..c3d68a82d --- /dev/null +++ b/src/tc/tc3.h @@ -0,0 +1,24 @@ +#ifndef __TC3_H +#define __TC3_H + +int tc3100(int argc, char** argv); +int tc3200(int argc, char** argv); +int tc3300(int argc, char** argv); +int tc3700(int argc, char** argv); +int tc3800(int argc, char** argv); + +#endif // __TC3_H + + + + + + + + + + + + + + diff --git a/src/tc/tc3100.cpp b/src/tc/tc3100.cpp new file mode 100644 index 000000000..ab6ad7cd5 --- /dev/null +++ b/src/tc/tc3100.cpp @@ -0,0 +1,1067 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "tc3.h" +#include "tc3100a.h" + +#include "../ve/velib.h" +#include "../cg/cg2103.h" + +#include "comuni.h" +#include +#include +#include +#include + +#define TAB_RICCONTI "RECONTI" +#define TAB_REGISTRI "&RRE" +#define TAB_CAUSALI "&RCA" +#define TAB_CODIVA "&RIV" +#define TAB_PAGAMENTI "&RPG" +#define TAB_VALUTE "&RVL" + +class TRiclassifica_cache : public TCache +{ + TLocalisamfile _ricl; +protected: + virtual TObject* key2obj(const char* key); + +public: + void decode(const char* tab, const TString& cod, int & gruppo, int & conto, long & sottoconto); + TRiclassifica_cache() : _ricl(LF_RICLPDC) { _ricl.setkey(3);} +}; + + +TObject* TRiclassifica_cache::key2obj(const char* key) +{ + TToken_string tok(key); + TString8 tab, cod; + tok.get(0,tab); + tok.get(1, cod); + _ricl.put(RICLPDC_TIPORIC, tab); + _ricl.put(RICLPDC_CODICE, cod); + int err = _ricl.read(_isgteq); + if (err == NOERR && _ricl.get(RICLPDC_CODICE) == cod) + { + TToken_string * s = new TToken_string; + + s->add(_ricl.get(RICLPDC_GRUPPO)); + s->add(_ricl.get(RICLPDC_CONTO)); + s->add(_ricl.get(RICLPDC_SOTTOCONTO)); + return s; + } + return NULL; +} + +void TRiclassifica_cache::decode(const char* tab, const TString& cod, int & gruppo, int & conto, long & sottoconto) +{ + TToken_string tok; + + gruppo = atoi(cod.left(2)); + conto = atoi(cod.mid(2,2)); + sottoconto = atol(cod.right(3)); + tok.add(tab); + tok.add(cod); + + TToken_string* ric = (TToken_string*) objptr(tok); + + if (ric != NULL) + { + gruppo = ric->get_int(); + conto = ric->get_int(); + sottoconto = ric->get_long(); + } + return; +} + +/////////////////////////////////////////////////////////// +// TClient_textset +/////////////////////////////////////////////////////////// + +class TClifo_recset : public TCSV_recordset +{ + TAssoc_array _index; + +protected: + virtual TRecnotype new_rec(const char* buf = NULL); + +public: + const TString& rag_sociale() const; + TToken_string& indirizzo(); + const TString& add_stato(TLog_report& log) const; + TClifo_recset(const char * query); +}; + +TRecnotype TClifo_recset::new_rec(const char* buf) +{ + TToken_string str(256,'|'); //nuovo record tab separator + + if(buf && *buf) + { + bool apici=false; + + for (const char* c = buf; *c ; c++) + { + if (*c == '"') + { + apici = !apici; + } + else + { + if (*c == '|') + { + str.trim(); + if (!apici) + { + str << str.separator(); + while (isspace(*++c)); + --c; + } + else + str << *c; + } + else + str << *c; + + } + } + } + + const TRecnotype n = TText_recordset::new_rec(str); + + if (n >= 0) + row(n).separator(str.separator()); + + return n; +} + +//funzione che crea il campo ragione sociale dai campi opportuni del file csv +const TString& TClifo_recset::rag_sociale() const +{ + const TString& nome = get(2).as_string(); + TString ragsoc = get(1).as_string(); + + ragsoc << " " << nome; + ragsoc.cut(50); + return get_tmp_string() = ragsoc; +} + +//funzione che cerca o aggiunge lo stato alla tabella stati e ne ritorna il codice +const TString& TClifo_recset::add_stato(TLog_report& log) const +{ + TString80 stato = get(7).as_string(); // stato + TTable stati("%STA"); + + if (stato.full() && stato != "Italia") + { + stati.setkey(2); + stati.put("S0", stato); + + if (stati.read(_isequal) != NOERR) + { + stati.last(); + + const int codice = stati.get_int("CODTAB") + 1; + + stati.zero(); + stati.put("CODTAB", format("%03d", codice)); + + const int err = stati.write(); + + if (err != NOERR) + log.log(2, format(FR("Impossibile creare lo stato %s - errore %d"), (const char *) stato, codice)); + } + return get_tmp_string() = stati.get("CODTAB"); + } + return EMPTY_STRING; +} + +//funzione che costruisce l'indirizzo dai campi opportuni del file csv +TToken_string & TClifo_recset::indirizzo() +{ + TToken_string & via = get_tmp_string(); + + via.separator(','); + via = get(3).as_string(); + + return via; +} + +TClifo_recset::TClifo_recset(const char * fileName) + : TCSV_recordset("CSV(|)\n") +{ + load_file(fileName); +} + +/////////////////////////////////////////////////////////// +// TPNota_textset +/////////////////////////////////////////////////////////// + +class TPNota_recset : public TCSV_recordset +{ + TAssoc_array _index; + +protected: + virtual TRecnotype new_rec(const char* buf = NULL); + +public: + TPNota_recset(const char * query); +}; + +TRecnotype TPNota_recset::new_rec(const char* buf) +{ + TToken_string str(256,'|'); //nuovo record tab separator + + if(buf && *buf) + { + bool apici=false; + + for (const char* c = buf; *c ; c++) + { + if (*c == '"') + { + apici = !apici; + } + else + { + if (*c == '|') + { + str.trim(); + if (!apici) + { + str << str.separator(); + while (isspace(*++c)); + --c; + } + else + str << *c; + } + else + str << *c; + + } + } + } + + const TRecnotype n = TText_recordset::new_rec(str); + + if (n >= 0) + row(n).separator(str.separator()); + + return n; +} + +TPNota_recset::TPNota_recset(const char * fileName) + : TCSV_recordset("CSV(|)\n") +{ + load_file(fileName); +} + +/////////////////////////////////////////////////////////// +// TAutomask +/////////////////////////////////////////////////////////// + +class TImportaEricsoft_mask : public TAutomask +{ +protected: + virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); + +public: + TImportaEricsoft_mask(); +}; + +TImportaEricsoft_mask::TImportaEricsoft_mask() :TAutomask ("tc3100a") +{ +} + +bool TImportaEricsoft_mask::on_field_event(TOperable_field& f, TField_event e, long jolly) +{ + switch (f.dlg()) // qui 00 + { + //giochetto per avere la lista dei files validi nella directory di trasferimento! + case F_CLIFOR: + if (e == fe_button) + { + TArray_sheet as(-1, -1, 72, 20, TR("Selezione file"), + "File@32"); + TFilename path = get(F_PATH); + path.add("*.txt"); //files delle anagrafiche + list_files(path, as.rows_array()); + TFilename name; + FOR_EACH_ARRAY_ROW(as.rows_array(), i, row) + { + name = *row; + *row = name.name(); + } + if (as.run() == K_ENTER) + { + f.set(as.row(as.selected())); + } + } + break; + case F_MOV: + if (e == fe_button) + { + TArray_sheet as(-1, -1, 72, 20, TR("Selezione file"), + "File@32"); + TFilename path = get(F_PATH); + path.add("*.txt"); //files dei movimenti + list_files(path, as.rows_array()); + TFilename name; + FOR_EACH_ARRAY_ROW(as.rows_array(), i, row) + { + name = *row; + *row = name.name(); + } + if (as.run() == K_ENTER) + { + f.set(as.row(as.selected())); + } + } + break; + default: + break; + } + return true; +} + +/////////////////////////////////////// +// TSkeleton_application +/////////////////////////////////////// +class TImportaEricsoft : public TSkeleton_application +{ + virtual bool check_autorization() const {return false;} + + TImportaEricsoft_mask * _msk; + TRiclassifica_cache * _ricl; + TEsercizi_contabili _esc; + TAssoc_array _indetr; + TString4 _last; + +protected: + //metodi per la ricerca dei clienti / fornitori + bool find_cli(const long cod) const; + + //metodi per la gestione dei dati dell'anagrafica + void pulisci_cap(TString& cap) const; + void estrai_numero(TString& telefono, TString& pref, TString& num) const; + const TString comune2cap(TString& comune) const; + void gest_localita(TString& comune, TString& cap, TString& codcom, const TString& prov, const TString& stato = EMPTY_STRING) const; + const TString & find_indetr(const real & imponibile, const real & imponibile_tot); + + //metodi per l'inserimento dei dati sulle tabelle corrette + void save_mov(TLog_report& log, TFilename& ini_file, bool skip); + void upload_cli(const TFilename& file, TLog_report& log); + void upload_mov(const TFilename& file, TLog_report& log); + + const TString & decode_codreg(int tiporeg, int numreg); + const TString & decode_codcaus(int tipocaus, const TString & codcaus); + const TString & decode_codiva(const TString & codiva); + const TString & decode_codpag(const TString & codpag); + const TString & decode_codval(const TString & codval); + +public: + virtual bool create(); + virtual bool destroy(); + virtual void main_loop(); + bool transfer(); + + TImportaEricsoft() {}; +}; + +TImportaEricsoft& app() { return (TImportaEricsoft&) main_app(); } + + + ///////////////////////////////// + // GESTIONE ANAGRAFICHE // + ///////////////////////////////// + +///////////////////////////////// +// ricerca clifo +///////////////////////////////// + +//funzione che ricerca un cliente o un fornitore nel file clifo di campo in base al CODCF +bool TImportaEricsoft::find_cli(const long cod) const +{ + TString16 key; key.format("C|%ld", cod); + return !cache().get(LF_CLIFO, key).empty(); +} + + +///////////////////////////////// +// gestione dati anagrafici +///////////////////////////////// + +//funzione che elimina eventuali caratteri non numerici dalla stringa del CAP +void TImportaEricsoft::pulisci_cap(TString& cap) const +{ + TString8 str; + for (int i = 0; cap[i] && str.len() < 5; i++) + if (isdigit(cap[i])) + str << cap[i]; + cap = str; +} + +//funzione che separa il prefisso dal numero di telefono +void TImportaEricsoft::estrai_numero(TString& telefono, TString& pref, TString& num) const +{ + bool pre = true; + + TString str1; + TString str2; + + telefono.trim(); + + for (int i = 0; telefono[i]; i++) + { + if(isdigit(telefono[i])) //se il carattere letto č una cifra numerica, allora concatenalo alla stringa corretta + { + if (pre) + str1 << telefono[i]; + else + str2 << telefono[i]; + } + else + { + if (pre) + pre = i<=1; //considero il prefisso finito se č composto da almeno 2 caratteri + else + { + if (str2.len() >= 6) //considero il numero finito se č composto da alemno 6 cifre + break; + } + } + } + + if (str2.full()) + { + pref = str1; + num = str2; + } + else + { + pref.cut(0); + num = str1; + } +} + +//funzione che estrae il cap dalla tabella comuni dato il nome del comune +const TString TImportaEricsoft::comune2cap(TString& comune) const +{ + TLocalisamfile comuni(LF_COMUNI); + TRectype& rec = comuni.curr(); + TString up_comune = comune; + up_comune.upper(); + + TString cap; + + comuni.setkey(2); + + rec.put(COM_DENCOM,up_comune); + comuni.read(); + + cap = rec.get(COM_CAPCOM); + + return get_tmp_string() = cap; +} + +//funzione che gestisce le localitā +void TImportaEricsoft::gest_localita(TString& comune, TString& cap, TString& codcom, const TString& prov, const TString& stato) const +{ + comune.trim(); + + //se stato č settato vuol dire stato estero, e lo scrivo cosė com'č nella localitā + if (stato.full()) + { + comune << " - " << stato; + return; + } + + //se sto inserendo una cittā italiana, cerco di riempire il CAP se č vuoto + if (cap.empty()) + cap = comune2cap(comune); + + //se sono riuscito a riempirlo, o era giā pieno, ricerca il codice comune + if (cap.full()) + { + pulisci_cap(cap); + codcom = cap2comune(cap,comune); + } + + //se non sono riuscito a trovare il codice comune, prepara aggiungi al comune la provincia (dove esiste) + if (codcom.blank()) + { + if (prov.full()) + comune << " (" << prov << ")"; + } + return; +} + +///////////////////////////////// +// inserimento clifo +///////////////////////////////// + +//funzione che effettua l'inserimento delle persone fisiche sulla tabella CLIFO +void TImportaEricsoft::upload_cli(const TFilename& file, TLog_report& log) +{ + char tipo = 'C'; + + TClifo_recset s(file); + + TLocalisamfile clifo(LF_CLIFO); + + TProgind pi(s.items(),"Importazione Clienti in corso...",true,true); + + for (bool ok=s.move_first();ok;ok=s.move_next()) + { + if (!pi.addstatus(1)) + break; + + const long cod = s.get(0).as_int(); + const TString ragsoc = s.rag_sociale(); + + //salto la prima riga del file, che contiene le intestazioni delle colonne + //salto tutte le righe dei fornitori (inserisco solo clienti) + //eseguo tutto SOLO se riesco a riempire la ragione sociale + if (ragsoc.full()) + { + + const bool var = find_cli(cod); //controllo se il clifo esiste giā + + clifo.zero(); + clifo.put(CLI_TIPOCF, "C"); + + clifo.put(CLI_CODCF,cod); + + if (var) + clifo.read(); + + clifo.put(CLI_RAGSOC, ragsoc); //ragsoc + TToken_string & indirizzo = s.indirizzo(); + clifo.put(CLI_INDCF, indirizzo.get()); //indirizzo + clifo.put(CLI_CIVCF, indirizzo.get()); //indirizzo + + //inserisci di dati della residenza + + TString cap = s.get(4).as_string(); + TString80 comune = s.get(5).as_string(); //comune o localita' + TString prov = s.get(6).as_string(); + TString codcom; + + gest_localita(comune, cap, codcom, prov); + + //se cap č pieno, allora inseriscilo + if (cap.full()) + clifo.put(CLI_CAPCF, cap); //cap + + //se codcom č vuoto, allora o il cap č rimasto vuoto, oppure č una frazione; + //in entrambi i casi bisogna inserire tutto in localitā + if (codcom.blank()) + clifo.put(CLI_LOCCF, comune); + else + { + clifo.put(CLI_COMCF, codcom); //inserisci il codice del comune, recuperato tramite il cap + clifo.put(CLI_LOCCF, s.get(20).as_string()); //inserisci la frazione se č indicata + } + s.add_stato(log); + clifo.put(CLI_REFERENTE, s.get(8).as_string()); + //inserisci i numeri di telefono (telefono, altro telefono, fax) + for (int i = 9; i < 10; i++) + { + TString telefono = s.get(i).as_string(); + + //esegui le operazioni sul numero solo se č presente sul file da importare + if (telefono.full()) + { + TString pref; + TString num; + + estrai_numero(telefono, pref, num); + + switch (i) + { + case 8: clifo.put(CLI_PTEL,pref); clifo.put(CLI_TEL,num); break; //inserisci il numero di telefono + case 9: clifo.put(CLI_PTEL2,pref); clifo.put(CLI_TEL2,num); break; //inserisci il secondo numero di telefono + default: break; + } + } + } + + + //inserisci l'indrizzo e-mail + const TString16 paiv = s.get(11).as_string(); + clifo.put(CLI_PAIV, paiv); //p.iva + const TString codpag = s.get(12).as_string(); // clifo.put(CLI_, riferimento); + const TString ricavo = s.get(13).as_string(); + int gruppo; + int conto; + long sottoconto; + + _ricl->decode(TAB_RICCONTI, ricavo, gruppo, conto, sottoconto); + clifo.put(CLI_GRUPPORIC, gruppo); + clifo.put(CLI_CONTORIC, conto); + clifo.put(CLI_SOTTOCRIC, sottoconto); + const TString40 cofi = s.get(14).as_string(); + clifo.put(CLI_COFI, cofi); //cod. fisc. + + TString str; + str << "Il Cliente codice (" << clifo.get(CLI_CODCF) <<") " << ragsoc << " "; + + if (var) + { + const int err = clifo.rewrite(); + if (err == NOERR) + { + str << "č stato aggiornato"; + log.log(0, str); + } + else + { + str << "NON č stato aggiornato. Errore " << err; + log.log(2, str); + } + } + else + { + const int err = clifo.write(); + if (err == NOERR) + { + str << "č stato inserito"; + log.log(0, str); + } + else + { + str << "NON č stato inserito. Errore " << err; + log.log(2, str); + } + } + + if (cofi.empty() && paiv.empty()) + { + TString str; + str << "Il " << cod << ' ' << ragsoc << " non ha nč CODICE FISCALE nč PARTITA IVA"; + log.log(1, str); + } + } + + } + return; +} + +const TString & TImportaEricsoft::decode_codreg(int tiporeg, int numreg) +{ + const TString8 cod = format("%1d%02d", tiporeg, numreg); + TString8 codreg = cache().get(TAB_REGISTRI, cod, "S1"); + + if (codreg.blank() && tiporeg > 0) + codreg = cod; + return get_tmp_string() = codreg; +} + +const TString & TImportaEricsoft::decode_codcaus(int tipocaus, const TString & codcaus) +{ + const TString8 cod = format("%1d%s", tipocaus, (const char *) codcaus); + TString8 codc = cache().get(TAB_CAUSALI, cod, "S1"); + + if (codc.blank()) + codc = cod; + return get_tmp_string() = codc; +} + +const TString & TImportaEricsoft::decode_codiva(const TString & codiva) +{ + TString8 codi = cache().get(TAB_CODIVA, (const char *) codiva, "S1"); + + if (codi.blank()) + codi = codiva; + return get_tmp_string() = codi; +} + +const TString & TImportaEricsoft::decode_codpag(const TString & codpag) +{ + TString8 codp = cache().get(TAB_PAGAMENTI, (const char *) codpag, "S1"); + + if (codp.blank()) + codp = codpag; + return get_tmp_string() = codp; +} + +const TString & TImportaEricsoft::decode_codval(const TString & codval) +{ + TString8 codv = cache().get(TAB_VALUTE, (const char *) codval, "S1"); + + if (codv.blank()) + codv = codval; + return get_tmp_string() = codv; +} + +void TImportaEricsoft::save_mov(TLog_report& log, TFilename& ini_file, bool skip) +{ + TString command = format(FR("cg2 -0 -i%s -u%s"), (const char *)ini_file, (const char *) user()); + TExternal_app a(command) ; + a.run(); + + { + TConfig ini(ini_file); + int errs, warns; + TString s; + TString_array vars; + const long nreg = ini.get_long(MOV_NUMREG, TOSTRING(LF_MOV)); + + if (nreg > 0) + { + TLocalisamfile movf(LF_MOV); + const long tnreg = ini.get_long(MOV_TNUMREG, TOSTRING(LF_MOV)); + TRectype & mov = (TRectype &) cache().get(LF_MOV, nreg); + + mov.put(MOV_TNUMREG, tnreg); + mov.rewrite(movf); + } + ini.list_variables(vars, false, "Transaction"); + log.log(0, TR("[Transaction]")); + FOR_EACH_ARRAY_ROW(vars, j, var) + log.log(0, format(FR("%s = %s"), (const char *) *var, (const char *) ini.get((const char *) *var))); + if (_msk->get_bool(F_VERBOSE)) + { + TString_array pars; + + ini.list_paragraphs(pars); + FOR_EACH_ARRAY_ROW(pars, i, parname) + { + if (*parname != "Transaction" && *parname != "Main") + { + ini.list_variables(vars, false, (const char *) *parname); + log.log(0, format(TR("[%s]"), (const char *) *parname)); + FOR_EACH_ARRAY_ROW(vars, j, var) + log.log(0, format(FR("%s = %s"), (const char *) *var, (const char *) ini.get((const char *) *var))); + } + } + + } + for (errs = 0; (s = ini.get("ErrMsg", "Main", errs, "")).full(); errs++) + log.log(2, s); + for (warns = 0; (s = ini.get("ErrMsg", "Main", warns, "")).full(); warns++) + log.log(1, s); + if (errs > 0) + log.log(0, TR("Non elaborato")); + } +#ifndef _DBG + remove(ini_file); +#endif +} + +const TString & TImportaEricsoft::find_indetr(const real & imponibile, const real & imponibile_tot) +{ + real perc_ind = imponibile * CENTO / imponibile_tot; + + perc_ind.round(0); + + if (_indetr.items() == 0) + { + TISAM_recordset ind("USE %IND"); + + _last = "@"; + for (bool ok = ind.move_first(); ok; ok= ind.move_next()) + { + const real perc = ind.get("R0").as_real(); + const TString4 cod = ind.get("CODTAB").as_string(); + + _indetr.add(perc.string(), cod); + if (cod > _last) + _last = cod; + } + } + if (_indetr.objptr(perc_ind.string()) == NULL) + { + TTable ind("%IND"); + + _last[0]++; + ind.put("CODTAB", _last); + ind.put("I0", 9); + ind.put("R0", perc_ind); + ind.write(); + _indetr.add(perc_ind.string(), _last); + } + + return get_tmp_string() = (const TString &)_indetr[perc_ind.string()]; +} + +void TImportaEricsoft::upload_mov(const TFilename& file, TLog_report& log) +{ + TPNota_recset s(file); + long numreg = -1L; + int gruppo; + int conto; + int nrigaIVA = 0; + int nriga = 0; + bool skip = false; + long sottoconto; + TFilename ini_file; + TConfig * ini; + TArray cods_iva; + TISAM_recordset daily_movs("USE " TOSTRING(LF_MOV) " KEY 2\nFROM " MOV_DATAREG "=#DATE"); + TProgind pi(s.items(),"Importazione Movimenti in corso...",true,true); + + for (bool ok=s.move_first();ok;ok=s.move_next()) + { + if (!pi.addstatus(1)) + break; + + const TDate datareg = s.get(0).as_date(); + const long numreg_eric = s.get(1).as_int(); + const char sezione = s.get(2).as_int() == 0 ? 'D' : 'A'; + _ricl->decode(TAB_RICCONTI, s.get(3).as_string(), gruppo, conto, sottoconto); + const long codcf = s.get(5).as_int(); + char tipocf= ' '; + + switch (s.get(4).as_int()) + { + case 1: + tipocf = 'C'; + break; + case 2: + tipocf = 'F'; + break; + default: + break; + } + + const TDate datacomp = s.get(6).as_date(); + const int tiporeg = s.get(7).as_int(); + const int numregs = s.get(8).as_int(); + const TString8 codreg = decode_codreg(tiporeg, numregs); + const long numprot = s.get(9).as_int(); + const TDate datadoc = s.get(10).as_date(); + TString20 numdoc = s.get(11).as_string(); numdoc << "/" << s.get(12).as_string(); + TString8 codcaus = s.get(13).as_string(); + const int tipocau = s.get(14).as_int(); + + codcaus = decode_codcaus(tipocau, codcaus); + + const int oper = s.get(15).as_int(); + const TString80 descr = s.get(16).as_string(); + const real importo = s.get(17).as_real(); // valuta conto ??? + const real imponibile = s.get(18).as_real(); // valuta conto ??? + const real imposta = s.get(17).as_real(); // valuta conto ??? + const real totdoc = s.get(24).as_real(); // valuta conto ??? + const TString8 codiva = decode_codiva(s.get(19).as_string()); // + const bool annullato = s.get(30).as_int() == 1; + const TString8 codpag = decode_codpag(s.get(33).as_string()); + const TDate datainsca = s.get(34).as_date(); + const TString8 codval = decode_codval(s.get(36).as_string()); + const real impval = s.get(37).as_real(); + const real cambio = s.get(38).as_real(); // valuta conto ??? + const TDate datacam = s.get(39).as_date(); + const bool riga_iva = s.get(40).as_int() == 1; + const bool riga_cont = !riga_iva; + const bool riga_storno_iva = riga_iva && s.get(20).as_int() == 1; + const int nriga_eric = s.get(41).as_int(); + + if (numreg_eric != numreg) + { + if (numreg > 0L) + { + delete ini; + ini = NULL; + skip |= (nriga == 0) && (nrigaIVA == 0); + save_mov(log, ini_file, skip); + } + if (!datareg.ok() || numreg_eric == 0) + continue; + log.log(0, format("Movimento Ericsoft n.ro %ld", numreg_eric)); + cods_iva.destroy(); + numreg = numreg_eric; + nriga = 0; + nrigaIVA = 0; + ini_file.temp("eric", "ini"); + ini = new TConfig(ini_file, "Transaction"); + + char mode[2] = { TM_INTERACTIVE, '\0' }; + long nreg = 0; + + daily_movs.set_var("#DATE", datareg.stringa()); + for (bool ok = daily_movs.move_first(); ok; ok = daily_movs.move_next()) + if (numreg == daily_movs.get(MOV_TNUMREG).as_int()) + nreg = daily_movs.get(MOV_NUMREG).as_int(); + if (nreg == 0L) + ini->set("Action", TRANSACTION_INSERT); + else + { + ini->set("Action", TRANSACTION_MODIFY); + ini->set(MOV_NUMREG, nreg); + } + ini->set("Mode", mode); + ini->set_paragraph(LF_MOV); + ini->set(MOV_DATAREG, datareg); + ini->set(MOV_ANNOIVA, datareg.year()); + ini->set(MOV_ANNOES, _esc.esercizio(datacomp).codice()); + ini->set(MOV_TIPO, tipocf); + ini->set(MOV_CODCF, codcf); + ini->set(MOV_DATADOC, datadoc); + ini->set(MOV_NUMDOC, numdoc); + ini->set(MOV_TNUMREG, numreg); + + ini->set(MOV_TOTDOC, totdoc.string()); + ini->set(MOV_TOTDOCVAL, impval.string()); + ini->set(MOV_CAMBIO, cambio.string()); + ini->set(MOV_DATACAM, datacam); + ini->set(MOV_CODVAL, codval); + ini->set(MOV_CODCAUS, codcaus); + ini->set(MOV_DESCR, descr); + ini->set(MOV_REG, codreg); + ini->set(MOV_PROTIVA, numprot); + ini->set(MOV_CODPAG, codpag); + ini->set(MOV_IVAXCASSA, tipocau == 8 || tipocau == 9 ? "X" : "" ); + ini->set(MOV_LIQDIFF, tipocau == 8 || tipocau == 9 ? "X" : "" ); + ini->set(MOV_DATACOMP, datacomp); + } + + const TCausale & caus = cached_causale(codcaus, datacomp.year()); + bool mov_iva = caus.iva() > nessuna_iva; + + if (!mov_iva && riga_cont) + { + ini->set_paragraph(format("%d,%d",LF_RMOV, ++nriga)); + + ini->set(RMV_ANNOES, _esc.esercizio(datacomp).codice()); + ini->set(RMV_DATAREG, datareg); + ini->set(RMV_NUMRIG, nriga); + ini->set(RMV_SEZIONE, sezione); + ini->set(RMV_DESCR, sezione); + ini->set(RMV_IMPORTO, importo.string()); + ini->set(RMV_TIPOC, tipocf); + ini->set(RMV_GRUPPO, gruppo); + ini->set(RMV_CONTO, conto); + ini->set(RMV_SOTTOCONTO, sottoconto); + } + else + if (riga_iva) + { + if (riga_storno_iva) + { + bool found = false; + for (int riga = 1 ; !found && cods_iva.objptr(riga) != NULL; riga++) + if (codiva == (TString &) cods_iva[riga] && ini->get(RMI_TIPODET).blank()) + { + found = true; + ini->set_paragraph(format("%d,%d",LF_RMOVIVA, ++nriga)); + real imponibile_tot = ini->get(RMI_IMPONIBILE); + ini->set(RMI_TIPODET, find_indetr(imponibile, imponibile_tot)); + } + if (!found) + log.log(2, format(FR("Codice IVA %s di storno indetraibilitā non trovato"), (const char *) codiva)); + + } + else + { + ini->set_paragraph(format("%d,%d",LF_RMOVIVA, ++nrigaIVA)); + ini->set(RMI_ANNOES, _esc.esercizio(datacomp).codice()); + ini->set(RMI_NUMRIG, nrigaIVA); + ini->set(RMI_CODIVA, codiva); + ini->set(RMI_IMPONIBILE, imponibile.string()); + ini->set(RMI_IMPOSTA, imposta.string()); + ini->set(RMI_TIPOC, tipocf); + ini->set(RMI_GRUPPO, gruppo); + ini->set(RMI_CONTO, conto); + ini->set(RMI_SOTTOCONTO, sottoconto); + cods_iva.add(codiva, nrigaIVA); + ini->set_paragraph(LF_MOV); + ini->set(MOV_TOTDOC, totdoc.string()); + ini->set(MOV_TOTDOCVAL, impval.string()); + ini->set(MOV_CAMBIO, cambio.string()); + } + } + } +} + +bool TImportaEricsoft::transfer() +{ + TLog_report log("Trasferimento Anagrafiche"); + TLog_report log1("Trasferimento Prima Nota"); + + //prelevo il path dei file da caricare dalla maschera + TFilename path = _msk->get(F_PATH); + + const short ids [] = {F_CLIFOR,F_MOV,0}; + + //eseguo tutte le importazioni (una alla volta) + for (int i = 0; ids[i]; i++) + { + //prelevo di volta in volta il nome del file giusto dalla maschera: + //prima il file Anagrafiche, poi quello delle fatture e poi quello delle ricevute + TFilename name = _msk->get(ids[i]); + + //se sono riuscito a prelevare un nome di file, allora: + if (name.full()) + { + //costruisco il nome del file + TFilename full = path; + full.add(name); + + //se eiste il file, esegui l'elaborazione corretta + if (full.exist()) + { + switch (i) + { + case 0: upload_cli(full, log); break; + case 1: upload_mov(full, log1); break; + default: break; + } + } + } + } + + TReport_book buc; + TReport_book buc1; + + buc.add(log); + if (buc.pages()>0) + buc.preview(); //visualizzo il log di importazione delle anagrafiche + + buc1.add(log1); + if (buc1.pages()>0) + buc1.preview(); //visualizzo il log di importazione dei documenti + + return true; +} + +bool TImportaEricsoft::create() +{ + _msk = new TImportaEricsoft_mask(); + _ricl = new TRiclassifica_cache(); + return TSkeleton_application::create(); +} + +bool TImportaEricsoft::destroy() +{ + delete _msk; + delete _ricl; + return TApplication::destroy(); +} + +void TImportaEricsoft::main_loop() +{ + KEY tasto; + tasto = _msk->run(); + if (tasto == K_ENTER) + if (transfer()) + message_box(TR("Importazione completata")); +} + +int tc3100 (int argc, char* argv[]) +{ + TImportaEricsoft main_app; + main_app.run(argc, argv, TR("Importazione da ericsoft")); + return true; +} diff --git a/src/tc/tc3100a.h b/src/tc/tc3100a.h new file mode 100644 index 000000000..dbed4795e --- /dev/null +++ b/src/tc/tc3100a.h @@ -0,0 +1,8 @@ +// campi della maschera tc3100a Importazione da Ericsoft + +#define F_CODDITTA 101 +#define F_RAGSOC 102 +#define F_PATH 103 +#define F_CLIFOR 104 +#define F_MOV 105 +#define F_VERBOSE 106 diff --git a/src/tc/tc3100a.uml b/src/tc/tc3100a.uml new file mode 100644 index 000000000..110af7633 --- /dev/null +++ b/src/tc/tc3100a.uml @@ -0,0 +1,84 @@ +#include "tc3100a.h" + +TOOLBAR "topbar" 0 0 0 2 + +BUTTON DLG_ELABORA 10 2 +BEGIN + PROMPT -12 -11 "~Elabora" + PICTURE BMP_ELABORA + MESSAGE EXIT,K_ENTER +END + +#include + +ENDPAGE + +TOOLBAR "" 0 -2 0 2 + +STRING DLG_PROFILE 50 +BEGIN + PROMPT 9 0 "Profilo " + PSELECT +END + +ENDPAGE + +PAGE "Importazione da Ericsoft" 0 0 0 -3 + +GROUPBOX DLG_NULL 76 3 +BEGIN + PROMPT 2 1 "@bDitta corrente" +END + +NUMBER F_CODDITTA 5 +BEGIN + PROMPT 3 2 "Codice " + FLAGS "FD" + USE LF_NDITTE + INPUT CODDITTA F_CODDITTA + OUTPUT F_RAGSOC RAGSOC + CHECKTYPE REQUIRED +END + +STRING F_RAGSOC 50 +BEGIN + PROMPT 23 2 "" + FLAGS "D" + //FIELD RAGSOC +END + +GROUPBOX DLG_NULL 76 6 +BEGIN + PROMPT 2 4 "@bSorgente" +END + +STRING F_PATH 256 50 +BEGIN + PROMPT 3 5 "Cartella " + DSELECT + CHECKTYPE REQUIRED + FIELD Path +END + +STRING F_CLIFOR 18 +BEGIN + PROMPT 3 6 "Clienti " + FLAGS "B" + FIELD ReCFInFile +END + +STRING F_MOV 18 +BEGIN + PROMPT 3 7 "Movimenti " + FLAGS "B" + FIELD ReMovInFile +END + +BOOLEAN F_VERBOSE +BEGIN + PROMPT 3 11 "Output Dettagliato" +END + +ENDPAGE + +ENDMASK \ No newline at end of file diff --git a/src/tc/tc3200.cpp b/src/tc/tc3200.cpp new file mode 100644 index 000000000..f3644afa9 --- /dev/null +++ b/src/tc/tc3200.cpp @@ -0,0 +1,54 @@ +// gestione tabelle ericsoft +#include +#include +#include + + +// applicazione per la gestione delle tabelle di magazzino +class Tab_app_eric : public TTable_module_application +{ + +protected: // TRelation_application + virtual bool user_create() ; + +public: + Tab_app_eric() {} + virtual ~Tab_app_eric() {} +}; + +HIDDEN inline Tab_app_eric& app() { return (Tab_app_eric&)main_app(); } + + +bool Tab_app_eric::user_create() +{ + /* + la Tab_application::user_create() apre la maschera TMask in modo automatico + basandosi sul parametro passato sulla linea di comando e sulla convenzione + nome = "BATB"+parametro; + ORA: + - questa convenzione cambierā per separare i programmi (e le maschere) + dei vari pacchetti + In tal caso ridefinire il metodo virtual mask_name() + - secondo il nuovo stile, gli handler vanno posti in maschere derivate + dalla TMask (TMask_taberic, TMask_tabcau, ecc), pertanto occorre che + la maschera aperta sia del tipo corretto + per questo motivo la maschera viene creata dalla user_create() + */ + + bool ok = TTable_module_application::user_create(); + + if (ok) + { + //TMask& mask = *set_mask(); + } + + return ok; +} + +int tc3200(int argc, char** argv) +{ + Tab_app_eric a; + a.run(argc, argv, TR("Tabella")); + return 0; +} + diff --git a/src/tc/tc3800.cpp b/src/tc/tc3800.cpp new file mode 100644 index 000000000..6618086f9 --- /dev/null +++ b/src/tc/tc3800.cpp @@ -0,0 +1,160 @@ +#include +#include +#include +#include +#include + +#include "tc3800a.h" + +//////////////////////////////////////////////////////////////////////// +//MASCHERA +//////////////////////////////////////////////////////////////////////// +class TRC_ricl_msk : public TAutomask +{ + virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); + +public: + TRC_ricl_msk() : TAutomask("tc3800a") {} +}; + +bool TRC_ricl_msk::on_field_event(TOperable_field& o, TField_event e, long jolly) +{ + switch (o.dlg()) + { + case F_CONTO: + break; + default: + break; + } + return true; +} + +class TRCRiclass_application : public TRelation_application + +// @author:(INTERNAL) Vari +// @access:(INTERNAL) Private Member +{ + // @cmember:(INTERNAL) Maschera corrente dell'applicazione + TMask* _msk; + // @cmember:(INTERNAL) Relazione corrente dell'applicazione + TRelation* _rel; + // @cmember:(INTERNAL) valori iniziale dei gruppo conto sottoconto + int _gruppo; + int _conto; + long _sottoconto; + +// @access Protected Member +protected: + virtual TMask* get_mask(int mode = MODE_QUERY) { CHECK(_msk, "Null mask"); return _msk; } + // @cmember Indica se la futura ritornera' una maschera diversa + // dalla corrente. + virtual bool changing_mask(int mode) { return false; } + // @cmember Ritorna la relazione da modificare + virtual TRelation* get_relation() const { CHECK(_rel, "Null relation"); return _rel; } + // @cmember Inizializza la maschera per il modo inserimento + // @cmember Inizializzazione dei dati dell'utente + virtual void init_query_mode(TMask& m) ; + // @cmember Inizializza la maschera per il modo ricerca ed inserimento (chiama ) + virtual void init_query_insert_mode(TMask& m) ; + virtual void init_insert_mode(TMask& m); + // @cmember Inizializza la maschera per il modo modifica + virtual void init_modify_mode(TMask& m); + virtual bool user_create() ; + // @cmember Distruzione dei dati dell'utente + virtual bool user_destroy() ; + // @cmember Chiama il programma di stampa + virtual void print(); + +// @access Public Member +public: + // @cmember Costruttore + TRCRiclass_application() : _msk(NULL), _rel(NULL) { } + + + // @cmember Distruttore + virtual ~TRCRiclass_application() {} +}; + + +void TRCRiclass_application::print() +{ + TFilename rep("tcscricl.rep"); //qui + TString cmd; + rep.custom_path(); + cmd << "ba8 -4 "<< rep; + TExternal_app stampa(cmd); + stampa.run(); +} + +void TRCRiclass_application::init_insert_mode(TMask& m) +{ + m.show(-1); + m.disable(-1); + m.hide(-2); + m.disable(-3); +} +void TRCRiclass_application::init_query_mode(TMask& m) +{ + m.show(-1); + m.hide(-2); + m.enable(-3); +} + +void TRCRiclass_application::init_query_insert_mode(TMask& m) +{ + m.hide(-1); + m.show(-2); + m.enable(-3); +} + +void TRCRiclass_application::init_modify_mode(TMask& m) +{ + TRelation_application::init_modify_mode(m); + _gruppo = m.get_int(F_GRUPPO); + _conto = m.get_int(F_CONTO); + _sottoconto = m.get_long(F_SOTTOCONTO); + m.show(-1); + m.disable(-1); + m.hide(-2); + m.disable(-3); +} + +bool TRCRiclass_application::user_create() +{ + _rel = new TRelation(LF_RICLPDC); + _msk = new TRC_ricl_msk; + + set_search_field(F_SOTTOCONTO); + + TFilename rep("tczcricl.rep"); + + if (rep.custom_path()) + enable_menu_item(M_FILE_PRINT); + + TString title; + _msk->get_caption(title); + set_title(title); + + return true; +} + +bool TRCRiclass_application::user_destroy() +{ + if (_msk) + delete _msk; + if (_rel) + delete _rel; + + return true; +} + + + +int tc3800(int argc, char **argv) +{ + TRCRiclass_application a; + + a.run(argc, argv, TR("Riclassificazione piano dei conti Ericsoft")); + return 0; +} + diff --git a/src/tc/tc3800a.h b/src/tc/tc3800a.h new file mode 100644 index 000000000..f6c1f74e8 --- /dev/null +++ b/src/tc/tc3800a.h @@ -0,0 +1,12 @@ +//id campi maschera tc3800a (file piano dei conti Ericsoft) +//campi normali +#define F_COD 101 +#define F_GRUPPO 102 +#define F_CONTO 103 +#define F_SOTTOCONTO 104 +#define F_SOTTOCONTO1 105 +#define F_DESCG 106 +#define F_DESCC 107 +#define F_DESC 108 +#define F_CONTORE 109 +#define F_DESCRIZ 110 diff --git a/src/tc/tc3800a.uml b/src/tc/tc3800a.uml new file mode 100644 index 000000000..d2112390f --- /dev/null +++ b/src/tc/tc3800a.uml @@ -0,0 +1,171 @@ +#include "tc3800a.h" + +TOOLBAR "topbar" 0 0 0 2 +#include +ENDPAGE + +PAGE "Riclassificazione conti" 0 2 0 0 + +LIST F_COD 7 +BEGIN + PROMPT 50 50 "" + ITEM "RECONTI|RECONTI" + FIELD TIPORIC + FLAGS "D" + KEY 1 +END + +GROUPBOX DLG_NULL 78 5 +BEGIN + PROMPT 1 1 "Conto Campo" +END + +NUMBER F_GRUPPO 3 +BEGIN + PROMPT 2 2 "Gruppo " + HELP "Codice del gruppo" + FIELD GRUPPO + KEY 1 + USE LF_PCON KEY 1 SELECT CONTO="" + INPUT GRUPPO F_GRUPPO + DISPLAY "Gruppo" GRUPPO + DISPLAY "Descrizione@50" DESCR + OUTPUT F_GRUPPO GRUPPO + OUTPUT F_DESCG DESCR + CHECKTYPE FORCED + ADD RUN cg0 -0 +END + +STRING F_DESCG 50 +BEGIN + PROMPT 25 2 "" + FLAGS "D" +END + +NUMBER F_CONTO 3 +BEGIN + PROMPT 2 3 "Conto " + HELP "Codice dell'eventuale conto" + FIELD CONTO + KEY 1 + USE LF_PCON KEY 1 SELECT ((CONTO!="")&&(SOTTOCONTO="")) + COPY INPUT F_GRUPPO + INPUT CONTO F_CONTO + DISPLAY "Gruppo" GRUPPO + DISPLAY "Conto" CONTO + DISPLAY "Descrizione@50" DESCR + OUTPUT F_GRUPPO GRUPPO + OUTPUT F_CONTO CONTO + OUTPUT F_DESCC DESCR + CHECKTYPE FORCED + WARNING "Manca il conto" + ADD RUN cg0 -0 +END + +STRING F_DESCC 50 +BEGIN + PROMPT 25 3 "" + FLAGS "D" +END + +NUMBER F_SOTTOCONTO 6 +BEGIN + PROMPT 2 4 "Sottoconto" + HELP "Codice dell'eventuale sottoconto" + FIELD SOTTOCONTO + KEY 1 + USE LF_RICLPDC + JOIN LF_PCON INTO GRUPPO==GRUPPO CONTO==CONTO SOTTOCONTO==SOTTOCONTO + INPUT TIPORIC F_COD + INPUT GRUPPO F_GRUPPO + INPUT CONTO F_CONTO + INPUT SOTTOCONTO F_SOTTOCONTO + DISPLAY "Gruppo" GRUPPO + DISPLAY "Conto" CONTO + DISPLAY "Sottoconto" SOTTOCONTO + DISPLAY "Descrizione@50" LF_PCON->DESCR + OUTPUT F_GRUPPO GRUPPO + OUTPUT F_CONTO CONTO + OUTPUT F_SOTTOCONTO SOTTOCONTO + OUTPUT F_DESC LF_PCON->DESCR + CHECKTYPE FORCED + GROUP 1 +END + +NUMBER F_SOTTOCONTO1 6 +BEGIN + PROMPT 2 4 "Sottoconto" + HELP "Codice dell'eventuale sottoconto" + FIELD SOTTOCONTO + KEY 1 + USE LF_PCON KEY 1 SELECT SOTTOCONTO!="" + COPY INPUT F_CONTO + INPUT SOTTOCONTO F_SOTTOCONTO1 + DISPLAY "Gruppo" GRUPPO + DISPLAY "Conto" CONTO + DISPLAY "Sottoconto" SOTTOCONTO + DISPLAY "Sosp." SOSPESO + DISPLAY "Descrizione@50" DESCR + OUTPUT F_GRUPPO GRUPPO + OUTPUT F_CONTO CONTO + OUTPUT F_SOTTOCONTO1 SOTTOCONTO + OUTPUT F_DESC DESCR + MESSAGE COPY F_SOTTOCONTO + CHECKTYPE FORCED + GROUP 2 + FLAGS "HG" + ADD RUN cg0 -0 +END + +STRING F_DESC 50 +BEGIN + PROMPT 25 4 "" + USE LF_PCON KEY 2 + KEY 2 + INPUT DESCR F_DESC + DISPLAY "Descrizione@50" DESCR + DISPLAY "Sosp." SOSPESO + DISPLAY "Gruppo" GRUPPO + DISPLAY "Conto" CONTO + DISPLAY "Sottoconto" SOTTOCONTO + COPY OUTPUT F_SOTTOCONTO1 + CHECKTYPE NORMAL + HELP "Descrizione del gruppo o del conto o del sottoconto" + WARNING "Descrizione mancante" + GROUP 3 +END + +GROUPBOX DLG_NULL 78 4 +BEGIN + PROMPT 1 6 "Conto Ericsoft" +END + +STRING F_CONTORE 7 +BEGIN + PROMPT 2 7 "Conto " + USE &RCO + INPUT CODTAB F_CONTORE + DISPLAY "Conto Ericsoft" CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT F_CONTORE CODTAB + OUTPUT F_DESCRIZ S0 + CHECKTYPE REQUIRED + VALIDATE FIXLEN_FUNC 7 + FIELD CODICE +END + +STRING F_DESCRIZ 50 +BEGIN + PROMPT 25 7 "" + USE &RCO KEY 2 + INPUT S0 F_DESCRIZ + DISPLAY "Descrizione@50" S0 + DISPLAY "Conto Ericsoft" CODTAB + COPY OUTPUT F_CONTORE + CHECKTYPE NORMAL +END + + +ENDPAGE + +ENDMASK \ No newline at end of file diff --git a/src/tc/tc8100.cpp b/src/tc/tc8100.cpp index 9dd60403d..61fe7fdef 100755 --- a/src/tc/tc8100.cpp +++ b/src/tc/tc8100.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include "tc8.h" #include "tc8100a.h" diff --git a/src/tc/tcmenu.men b/src/tc/tcmenu.men index e67a5c640..86c07c3c7 100755 --- a/src/tc/tcmenu.men +++ b/src/tc/tcmenu.men @@ -7,7 +7,8 @@ Item_01 = "TeamSystem", [TCMENU_002] Item_02 = "Zucchetti", [TCMENU_006] Item_03 = "IPSOA", [TCMENU_010] Item_04 = "Sispac", [TCMENU_014] -Item_05 = "Altri", [TCMENU_015] +Item_04 = "Ericsoft", [TCMENU_015] +Item_05 = "Altri", [TCMENU_018] [TCMENU_002] Caption = "TeamSystem" @@ -150,6 +151,34 @@ Item_02 = "Tabella IVA Sispac", "tc9 -3 IVA", "" Item_03 = "Tabella causali Sispac", "tc9 -3 CAU", "" [TCMENU_015] +Caption = "Ericsoft" +Picture = +Module = 27 +Flags = "" +Item_01 = "Trasferimento", "tc3 -0", "" +Item_02 = "Tabelle", [TCMENU_016] +Item_03 = "Tabelle di riclassificazione", [TCMENU_017] + +[TCMENU_016] +Caption = "Tabelle Ericsoft" +Picture = +Module = 27 +Flags = "" +Item_01 = "Registri", "tc3 -1 &RRE", "" +Item_02 = "Causali", "tc3 -1 &RCA", "" +Item_03 = "Codici IVA", "tc3 -1 &RIV", "" +Item_04 = "Condizioni di pagamento", "tc3 -1 &RPG", "" +Item_05 = "Valute", "tc3 -1 &RVL", "" +Item_06 = "Conti", "tc3 -1 &RCO", "" + +[TCMENU_017] +Caption = "Tabelle di riclassificazione Ericsoft" +Picture = +Module = 27 +Flags = "" +Item_01 = "Piano dei conti", "tc3 -7", "" + +[TCMENU_018] Caption = "Altri" Picture = Module = 27 diff --git a/src/tc/tctbrca.h b/src/tc/tctbrca.h new file mode 100644 index 000000000..2c07f8630 --- /dev/null +++ b/src/tc/tctbrca.h @@ -0,0 +1,5 @@ +#define F_TIPO 101 +#define F_CODTAB 102 +#define F_DESC 103 +#define F_CODICE 104 +#define F_DESCR 105 diff --git a/src/tc/tctbrca.uml b/src/tc/tctbrca.uml new file mode 100644 index 000000000..b2e5bc932 --- /dev/null +++ b/src/tc/tctbrca.uml @@ -0,0 +1,101 @@ +#include "tctbrca.h" + +TOOLBAR "topbar" 0 0 0 2 +#include +ENDPAGE + +PAGE "Conti" 0 2 0 0 + +GROUPBOX DLG_NULL 78 4 +BEGIN + PROMPT 1 1 "Causale Ericsoft" +END + +LIST F_TIPO 1 30 +BEGIN + PROMPT 2 2 "Tipo " + ITEM "0|Non IVA" + ITEM "1|Fattura" + ITEM "2|Nota di accredito" + ITEM "3|Corrispettivo/Costo" + ITEM "4|Storno Corrispettivo/Costo" + ITEM "5|Incasso fattura sospesa" + ITEM "1|Fattura" + ITEM "2|Nota di accredito" + FIELD CODTAB[1,1] + KEY 1 +END + +STRING F_CODTAB 3 +BEGIN + PROMPT 54 2 "Codice " + USE &RCA + INPUT CODTAB[2,4] F_TIPO + INPUT CODTAB[2,4] F_CODTAB + DISPLAY "Tipo" CODTAB[1,1] + DISPLAY "Codice" CODTAB[2,4] + DISPLAY "Descrizione@60" S0 + OUTPUT F_TIPO CODTAB[1,1] + OUTPUT F_CODTAB CODTAB[2,4] + OUTPUT F_DESC S0 + CHECKTYPE REQUIRED + FIELD CODTAB[2,4] + FLAGS "UZ" + KEY 1 +END + +STRING F_DESC 50 +BEGIN + PROMPT 2 3 "Descrizione " + USE &RCA KEY 2 + INPUT S0 F_DESC + DISPLAY "Descrizione@60" S0 + DISPLAY "Tipo" CODTAB[1,1] + DISPLAY "Codice" CODTAB[2,4] + COPY OUTPUT F_CODTAB + FIELD S0 + KEY 2 + CHECKTYPE REQUIRED +END + +STRING F_CODICE 3 +BEGIN + PROMPT 2 6 "Cod.Causale " + FIELD S1 + FLAGS "UZ" + USE LF_CAUSALI + INPUT CODCAUS F_CODICE + DISPLAY "Cod." CODCAUS + DISPLAY "Descrizione@50" DESCR + DISPLAY "Documento" TIPODOC + DISPLAY "Registro" REG + DISPLAY "Tipo movimento" TIPOMOV + DISPLAY "Colleg." CODCAUSIM + DISPLAY "770" M770 + DISPLAY "Cespiti" COLLCESP + OUTPUT F_CODICE CODCAUS + OUTPUT F_DESCR DESCR + CHECKTYPE REQUIRED +END + +STRING F_DESCR 50 +BEGIN + PROMPT 20 6 "" + USE LF_CAUSALI KEY 2 + INPUT DESCR F_DESCR + DISPLAY "Descrizione @50" DESCR + DISPLAY "Cod." CODCAUS + DISPLAY "Documento" TIPODOC + DISPLAY "Registro" REG + DISPLAY "Movimento" TIPOMOV + DISPLAY "Colleg." CODCAUSIM + DISPLAY "770" M770 + DISPLAY "Cespiti" COLLCESP + COPY OUTPUT F_CODICE + CHECKTYPE SEARCH +END + + +ENDPAGE + +ENDMASK diff --git a/src/tc/tctbrco.h b/src/tc/tctbrco.h new file mode 100644 index 000000000..d49c45c66 --- /dev/null +++ b/src/tc/tctbrco.h @@ -0,0 +1,2 @@ +#define F_CODTAB 101 +#define F_DESC 102 \ No newline at end of file diff --git a/src/tc/tctbrco.uml b/src/tc/tctbrco.uml new file mode 100644 index 000000000..451d1c2c6 --- /dev/null +++ b/src/tc/tctbrco.uml @@ -0,0 +1,45 @@ +#include "tctbrco.h" + +TOOLBAR "topbar" 0 0 0 2 +#include +ENDPAGE + +PAGE "Conti" 0 2 0 0 + +GROUPBOX DLG_NULL 78 3 +BEGIN + PROMPT 1 1 "Conto Ericsoft" +END + +STRING F_CODTAB 7 +BEGIN + PROMPT 2 2 "Codice " + USE &RCO + INPUT CODTAB F_CODTAB + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@60" S0 + OUTPUT F_CODTAB CODTAB + OUTPUT F_DESC S0 + CHECKTYPE REQUIRED + FIELD CODTAB + VALIDATE FIXLEN_FUNC 7 + FLAGS "Z" + KEY 1 +END + +STRING F_DESC 50 +BEGIN + PROMPT 2 5 "Descrizione " + USE &RCO KEY 2 + INPUT S0 F_DESC + DISPLAY "Descrizione@60" S0 + DISPLAY "Codice" CODTAB + COPY OUTPUT F_CODTAB + FIELD S0 + KEY 2 + CHECKTYPE REQUIRED +END + +ENDPAGE + +ENDMASK diff --git a/src/tc/tctbriv.h b/src/tc/tctbriv.h new file mode 100644 index 000000000..fc1a6ea42 --- /dev/null +++ b/src/tc/tctbriv.h @@ -0,0 +1,4 @@ +#define F_CODTAB 102 +#define F_DESC 103 +#define F_CODICE 104 +#define F_DESCR 105 \ No newline at end of file diff --git a/src/tc/tctbriv.uml b/src/tc/tctbriv.uml new file mode 100644 index 000000000..439a44a07 --- /dev/null +++ b/src/tc/tctbriv.uml @@ -0,0 +1,78 @@ +#include "tctbriv.h" + +TOOLBAR "topbar" 0 0 0 2 +#include +ENDPAGE + +PAGE "Codici IVA" 0 2 0 0 + +GROUPBOX DLG_NULL 78 4 +BEGIN + PROMPT 1 1 "Codice IVA Ericsoft" +END + +NUMBER F_CODTAB 3 +BEGIN + PROMPT 2 2 "Codice " + USE &RIV + INPUT CODTAB F_CODTAB + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@60" S0 + OUTPUT F_CODTAB CODTAB + OUTPUT F_DESC S0 + CHECKTYPE REQUIRED + FIELD CODTAB + FLAGS "Z" + KEY 1 +END + +STRING F_DESC 50 +BEGIN + PROMPT 2 3 "Descrizione " + USE &RIV KEY 2 + INPUT S0 F_DESC + DISPLAY "Descrizione@60" S0 + DISPLAY "Codice" CODTAB + COPY OUTPUT F_CODTAB + FIELD S0 + KEY 2 + CHECKTYPE REQUIRED +END + +STRING F_CODICE 4 +BEGIN + PROMPT 2 6 "Codice IVA " + FIELD S1 + USE %IVA + FLAGS "U" + INPUT CODTAB F_CODICE + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@50" S0 + DISPLAY "Tipo" S1 + DISPLAY "%@5" R0 + DISPLAY "Vent." S6 + DISPLAY "Sospeso" B2 + OUTPUT F_CODICE CODTAB + OUTPUT F_DESCR S0 + CHECKTYPE REQUIRED +END + +STRING F_DESCR 50 +BEGIN + PROMPT 20 6 "" + USE %IVA KEY 2 + INPUT S0 F_DESCR + DISPLAY "Descrizione@50" S0 + DISPLAY "Codice" CODTAB + DISPLAY "Tipo" S1 + DISPLAY "%@5" R0 + DISPLAY "Vent." S6 + DISPLAY "Sospeso" B2 + COPY OUTPUT F_CODICE + CHECKTYPE SEARCH +END + + +ENDPAGE + +ENDMASK diff --git a/src/tc/tctbrpg.h b/src/tc/tctbrpg.h new file mode 100644 index 000000000..824b4ce73 --- /dev/null +++ b/src/tc/tctbrpg.h @@ -0,0 +1,4 @@ +#define F_CODTAB 102 +#define F_DESC 103 +#define F_CODICE 104 +#define F_DESCR 105 diff --git a/src/tc/tctbrpg.uml b/src/tc/tctbrpg.uml new file mode 100644 index 000000000..80542ee5f --- /dev/null +++ b/src/tc/tctbrpg.uml @@ -0,0 +1,69 @@ +#include "tctbrpg.h" + +TOOLBAR "topbar" 0 0 0 2 +#include +ENDPAGE + +PAGE "Condizioni di pagamento" 0 2 0 0 + +GROUPBOX DLG_NULL 78 4 +BEGIN + PROMPT 1 1 "Codice Pagamento Ericsoft" +END + +NUMBER F_CODTAB 4 +BEGIN + PROMPT 2 2 "Codice " + USE &RPG + INPUT CODTAB F_CODTAB + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@60" S0 + OUTPUT F_CODTAB CODTAB + OUTPUT F_DESC S0 + CHECKTYPE REQUIRED + FIELD CODTAB + FLAGS "Z" + KEY 1 +END + +STRING F_DESC 50 +BEGIN + PROMPT 2 3 "Descrizione " + USE &RPG KEY 2 + INPUT S0 F_DESC + DISPLAY "Descrizione@60" S0 + DISPLAY "Codice" CODTAB + COPY OUTPUT F_CODTAB + FIELD S0 + KEY 2 + CHECKTYPE REQUIRED +END + +STRING F_CODICE 4 +BEGIN + PROMPT 2 6 "Cod.Pagamento " + FLAGS "U#" + FIELD S1 + USE %CPG KEY 1 + INPUT CODTAB F_CODICE + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT F_CODICE CODTAB + OUTPUT F_DESCR S0 + CHECKTYPE REQUIRED +END + +STRING F_DESCR 50 +BEGIN + PROMPT 23 6 "" + USE %CPG KEY 2 + INPUT S0 F_DESC + DISPLAY "Descrizione@50" S0 + DISPLAY "Codice@10" CODTAB + COPY OUTPUT F_CODICE + CHECKTYPE SEARCH +END + +ENDPAGE + +ENDMASK diff --git a/src/tc/tctbrre.h b/src/tc/tctbrre.h new file mode 100644 index 000000000..65970ce16 --- /dev/null +++ b/src/tc/tctbrre.h @@ -0,0 +1,6 @@ +#define F_TIPO 101 +#define F_CODTAB 102 +#define F_DESC 103 +#define F_ANNO 104 +#define F_CODICE 105 +#define F_DESCR 106 diff --git a/src/tc/tctbrre.uml b/src/tc/tctbrre.uml new file mode 100644 index 000000000..a2ada83a5 --- /dev/null +++ b/src/tc/tctbrre.uml @@ -0,0 +1,97 @@ +#include "tctbrre.h" + +TOOLBAR "topbar" 0 0 0 2 +#include +ENDPAGE + +PAGE "Registri" 0 2 0 0 + +GROUPBOX DLG_NULL 78 5 +BEGIN + PROMPT 1 1 "Codice Registro Ericsoft" +END + +LIST F_TIPO 1 30 +BEGIN + PROMPT 2 2 "Tipo " + ITEM "1|Vendite" + ITEM "2|Acquisti" + ITEM "3|Corrispettivi in scorporo" + ITEM "4|Corrispettivi in ventilazione" + FIELD CODTAB[1,1] +END + +NUMBER F_CODTAB 2 +BEGIN + PROMPT 56 2 "Codice " + USE &RRE + INPUT CODTAB[1,1] F_TIPO + INPUT CODTAB[2,3] F_CODTAB + DISPLAY "Tipo" CODTAB[1,1] + DISPLAY "Codice" CODTAB[2,3] + DISPLAY "Descrizione@60" S0 + OUTPUT F_TIPO CODTAB[1,1] + OUTPUT F_CODTAB CODTAB[2,3] + OUTPUT F_DESC S0 + CHECKTYPE REQUIRED + FIELD CODTAB[2,3] + VALIDATE FIXLEN_FUNC 2 + FLAGS "Z" + KEY 1 +END + +STRING F_DESC 50 +BEGIN + PROMPT 2 3 "Descrizione " + USE &RRE KEY 2 + INPUT S0 F_DESC + DISPLAY "Descrizione@60" S0 + DISPLAY "Codice" CODTAB + COPY OUTPUT F_CODTAB + FIELD S0 + KEY 2 + CHECKTYPE REQUIRED +END + +STRING F_CODICE 3 +BEGIN + PROMPT 2 6 "Registro " + Help "Codice del registro" + USE REG + INPUT CODTAB[1,4] F_ANNO SELECT + INPUT CODTAB[5,7] F_CODICE + DISPLAY "Codice" CODTAB[5,7] + DISPLAY "Descrizione @50" S0 + DISPLAY "Tipo" I0 + OUTPUT F_CODICE CODTAB[5,7] + OUTPUT F_DESCR S0 + FLAGS "GUZ" + FIELD S1 + CHECKTYPE REQUIRED +END + +STRING F_DESCR 50 43 +BEGIN + PROMPT 22 6 "" + USE REG KEY 2 SELECT (CODTAB[1,4]==#F_ANNO) + INPUT S0 F_DESCR + DISPLAY "Descrizione @50" S0 + DISPLAY "Anno" CODTAB[1,4] + DISPLAY "Codice" CODTAB[5,7] + DISPLAY "Tipo" I0 + COPY OUTPUT F_CODICE + CHECKTYPE SEARCH + MESSAGE COPY,22@ + HELP "Descrizione del registro" + WARNING "La descrizione e' obbligatoria" +END + +NUMBER F_ANNO 4 +BEGIN + PROMPT 68 6 "Anno " + FLAGS "DAZ" +END + +ENDPAGE + +ENDMASK diff --git a/src/tc/tctbrvl.h b/src/tc/tctbrvl.h new file mode 100644 index 000000000..9490d8b8a --- /dev/null +++ b/src/tc/tctbrvl.h @@ -0,0 +1,4 @@ +#define F_CODTAB 102 +#define F_DESC 103 +#define F_CODVAL 104 +#define F_DESVAL 105 diff --git a/src/tc/tctbrvl.uml b/src/tc/tctbrvl.uml new file mode 100644 index 000000000..7b313dc4e --- /dev/null +++ b/src/tc/tctbrvl.uml @@ -0,0 +1,72 @@ +#include "tctbrvl.h" + +TOOLBAR "topbar" 0 0 0 2 +#include +ENDPAGE + +PAGE "Valute" 0 2 0 0 + +GROUPBOX DLG_NULL 78 4 +BEGIN + PROMPT 1 1 "Codice Valuta Ericsoft" +END + +STRING F_CODTAB 3 +BEGIN + PROMPT 2 2 "Codice " + USE &RVL + INPUT CODTAB F_CODTAB + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@60" S0 + OUTPUT F_CODTAB CODTAB + OUTPUT F_DESC S0 + CHECKTYPE REQUIRED + FIELD CODTAB + FLAGS "U" + VALIDATE FIXLEN_FUNC 3 + KEY 1 +END + +STRING F_DESC 50 +BEGIN + PROMPT 2 3 "Descrizione " + USE &RVL KEY 2 + INPUT S0 F_DESC + DISPLAY "Descrizione@60" S0 + DISPLAY "Codice" CODTAB + COPY OUTPUT F_CODTAB + FIELD S0 + KEY 2 + CHECKTYPE REQUIRED +END + +STRING F_CODVAL 3 +BEGIN + PROMPT 2 6 "Codice " + FIELD S1 + FLAGS "UZ" + USE %VAL + INPUT CODTAB F_CODVAL + DISPLAY "Codice" CODTAB + DISPLAY "Valuta@50" S0 + OUTPUT F_CODVAL CODTAB + OUTPUT F_DESVAL S0 + HELP "Codice della valuta" + CHECKTYPE REQUIRED +END + +STRING F_DESVAL 50 +BEGIN + PROMPT 21 6 "" + USE %VAL KEY 2 + INPUT S0 F_DESC + DISPLAY "Valuta@60" S0 + DISPLAY "Codice@10" CODTAB + COPY OUTPUT F_CODVAL + HELP "Descrizione della valuta" + CHECKTYPE SEARCH +END + +ENDPAGE + +ENDMASK