diff --git a/ha/hacnv.cpp b/ha/hacnv.cpp new file mode 100755 index 000000000..348ff2c75 --- /dev/null +++ b/ha/hacnv.cpp @@ -0,0 +1,15 @@ +#include +#include "hacnv.h" + +int main(int argc, char** argv) +{ + const int n = argc > 1 ? argv[1][1]-'0' : 0; + switch (n) + { + case 0: + default: + hacnv100(argc, argv); //importazione Hardy + break; + } + return 0; +} \ No newline at end of file diff --git a/ha/hacnv.h b/ha/hacnv.h new file mode 100755 index 000000000..7963a0f88 --- /dev/null +++ b/ha/hacnv.h @@ -0,0 +1 @@ +int hacnv100(int argc, char* argv[]); diff --git a/ha/hacnv100.cpp b/ha/hacnv100.cpp new file mode 100755 index 000000000..fcbe11673 --- /dev/null +++ b/ha/hacnv100.cpp @@ -0,0 +1,801 @@ +#include "hacnv100.h" +#include "hacnv100a.h" + +#include +#include +#include +#include +#include +#include +#include + +const char* const APPNAME = TR("Importazione anagrafiche HARDY"); + +/////////////////////////////////////////////////////////// +// THardy_log +/////////////////////////////////////////////////////////// + +class THardy_log : public TLog_report +{ +public: + THardy_log() : TLog_report(APPNAME) {} +}; + +/////////////////////////////////////////////////////////// +// THardy_iterator +/////////////////////////////////////////////////////////// + +bool THardy_iterator::cancelled() const +{ + return _pi != NULL && _pi->iscancelled(); +} + +bool THardy_iterator::ok() const +{ + if (cancelled()) + return _ht->log_cancelled(); + return _rec >= 0 && _rec < _ht->recordset().items(); +} + +THardy_iterator& THardy_iterator::operator=(TRecnotype n) +{ + if (_pi != NULL) + _pi->setstatus(n+1); + _ht->recordset().move_to(_rec = n); + return *this; +} + +THardy_iterator& THardy_iterator::operator++() +{ + return *this = ++_rec; +} + +THardy_iterator::THardy_iterator(THardy_transfer* ht) : _ht(ht), _pi(NULL) +{ + const TRecnotype tot = _ht->recordset().items(); + TString title; + title << _ht->title() << ": " << tot << ' ' << TR("righe"); + if (tot > 1) + _pi = new TProgind(tot, title, true, true); + else + ::begin_wait(); + + if (tot > 0) + _ht->log(title); + + _rec = -1; +} + +THardy_iterator::~THardy_iterator() +{ + if (_pi != NULL) + delete _pi; + else + ::end_wait(); +} + +/////////////////////////////////////////////////////////// +// Cache tabelle +/////////////////////////////////////////////////////////// + +class TCache_tab : public TCache_th +{ +protected: + virtual TObject* key2obj(const char* key); + +public: + virtual const TString& decode(const TToken_string& cod_codtab); + TCache_tab(THardy_transfer* ht) : TCache_th(ht) {} +}; + +const TString& TCache_tab::decode(const TToken_string& cod_codtab) +{ + TString4 cod; cod_codtab.get(0, cod); + if (cod.full()) + { + const TRectype& rec = *(const TRectype*)objptr(cod_codtab); + if (!rec.empty()) + { + const char* field = "CODTAB"; + if (cod == "%TPM" || cod == "%TPP" || cod == "%TPI") // Tipo trasporto e porto + field = "S6"; + return rec.get(field); + } + } + return EMPTY_STRING; +} + +TObject* TCache_tab::key2obj(const char* key) +{ + TToken_string tok(key); + TString4 tab = tok.get(); tab.upper(); + TString80 cod = tok.get(); cod.upper(); + + if (tab == "%IVA") + { + // Campo non digerisce i codici IVA numerici di un solo carattere + if (cod.len() < 2 && isdigit(cod[0])) + cod.right_just(2, '0'); // per cui aggiungo uno 0 iniziale + } + + TTable table(tab); + table.put("CODTAB", cod); + if (table.read() != NOERR) + { + table.zero(); + table.put("CODTAB", cod); + table.put("S0", cod); + test_write(table); + } + return table.curr().dup(); +} + + +/////////////////////////////////////////////////////////// +// THardy_transfer +/////////////////////////////////////////////////////////// + +void THardy_transfer::init(const char* title, const char* qry_hdr, THardy_log& log) +{ + _log = &log; + _log->reset(); + _log->set_title(title); + _query_header = qry_hdr; + _write_enabled = true; +} + +const TString& THardy_transfer::title() const +{ return _log->title(); } + +void THardy_transfer::log(const char* msg, int sev) const +{ + _log->log(sev, msg); +} + +TRecordset& THardy_transfer::create_recordset(const char* query) +{ + if (_recset != NULL) + { + delete _recset; + _recset = NULL; + } + if (_outset != NULL) + { + _outset->exec("COMMIT TRANS"); + delete _outset; + _outset = NULL; + } + + TString qry = query; + if (!qry.starts_with("US") && !qry.starts_with("ODBC")) + qry.insert(query_header()); + _recset = ::create_recordset(qry); + return *_recset; +} + +const TRecordset& THardy_transfer::recordset() const +{ + CHECK(_recset != NULL, "NULL recordset"); + return *_recset; +} + +TRecordset& THardy_transfer::recordset() +{ + CHECK(_recset != NULL, "NULL recordset"); + return *_recset; +} + +long THardy_transfer::odbc_exec(const char* cmd) +{ + long err = 0; + if (_write_enabled) + { + if (_outset == NULL) + { + _outset = new TODBC_recordset(query_header()); + err = _outset->exec("BEGIN TRANS"); + } + if (err >= 0) + { + err = _outset->exec(cmd); + if (err < 0) + { + log("", 0); // Salto una riga + TParagraph_string msg(cmd, 100); + FOR_EACH_TOKEN(msg, str) + log(str, 0); // Riporto tutta la query + log_error(TR("ERRORE in esecuzione della query.")); + } + } + else + { + TString msg; + msg << TR("ERRORE di connessione a ") << _outset->dsn() << " : BEGIN TRANS"; + log_error(msg); + } + } + return err; +} + +bool THardy_transfer::log_error(const char* msg) +{ + log(msg, 2); + if (_write_enabled) + { + _write_enabled = false; + log(""); + log(TR("LA SCRITTURA SUGLI ARCHIVI VIENE DISABILITATA DA QUESTO MOMENTO IN POI"), 2); + log(""); + } + return false; +} + +bool THardy_transfer::log_cancelled() +{ + return log_error(TR("Procedura interrotta dall'utente")); +} + +bool THardy_transfer::test_write(TBaseisamfile& file) +{ + int err = NOERR; + if (_write_enabled) + { + err = file.write_rewrite(); + if (err != NOERR) + { + TString msg; + TString80 code, desc; + const int logic = file.num(); + if (logic == LF_TAB || logic == LF_TABCOM || logic == LF_TABMOD) + { + code = file.get("CODTAB"); + desc = file.get("S0"); + } + else + { + code = file.curr().build_key(1); + desc = file.curr().build_key(2); + } + msg.format(FR("Errore %d durante la scrittura sul file %d: %s - %s"), + err, logic, (const char*)code, (const char*)desc); + log_error(msg); + } + } + return err == NOERR; +} + + +const TString& THardy_transfer::get_str(const char* field) const +{ + return recordset().get(field).as_string(); +} + +const TString& THardy_transfer::get_real_str(const char* campo) const +{ + const TVariant& var = recordset().get(campo); + if (var.is_zero()) + return EMPTY_STRING; + return var.as_string(); +} + +long THardy_transfer::get_long(const char* field) const +{ + return recordset().get(field).as_int(); +} + +const TString& THardy_transfer::decode_value(const char* tab, const TString& cod) +{ + if (cod.full()) + { + if (_tab == NULL) + _tab = new TCache_tab(this); + TToken_string tok; tok.add(tab); tok.add(cod); + return _tab->decode(tok); + } + return EMPTY_STRING; +} + +const TString& THardy_transfer::decode_field(const char* tab, const char* field) +{ + const TString& cod = get_str(field); + return decode_value(tab, cod); +} + +const TString& THardy_transfer::build_insert_query(const char* table, const char* f, const char* v) const +{ + TString qry(255); + + qry << "INSERT INTO " << table; + + TAuto_token_string fields(f); + TToken_string values(v); + if (fields.items() > 0) + { + qry << " ("; + FOR_EACH_TOKEN(fields, tok) + qry << tok << ','; + qry.rtrim(1); + qry << ')'; + } + qry << " VALUES ("; + + TString tmp; + FOR_EACH_TOKEN(values, tok) + { + tmp = tok; + if (tmp.full() && !tmp.starts_with("0") && real::is_natural(tmp)) + qry << tok; + else + { + if (tmp[0] != '\'') + { + for (int i = tmp.len()-1; i >= 0; i--) + { + if (tmp[i] == '\'') + tmp.insert("'", i); + } + qry << '\'' << tmp << '\''; + } + else + qry << tmp; + } + qry << ','; + } + qry.rtrim(1); + qry << ')'; + + return get_tmp_string() = qry; +} + +THardy_transfer::THardy_transfer() + : _log(NULL), _config("hacnv100a.ini"), _recset(NULL), _outset(NULL), _tab(NULL) +{} + +THardy_transfer::~THardy_transfer() +{ + if (_tab != NULL) + delete _tab; + if (_outset != NULL) + { + _outset->exec("COMMIT TRANS"); + delete _outset; + } + if (_recset != NULL) + delete _recset; +} + +/////////////////////////////////////////////////////////// +// THardy_pag +/////////////////////////////////////////////////////////// + +void THardy_pag::aggiorna_record(TRectype& rec, const TString_array& lista_campi) +{ + TString campo_dest, campo_orig, valore, str; + + FOR_EACH_ARRAY_ROW(lista_campi,i,row) + { + row->get(0, campo_dest); + row->get(1, campo_orig); + if (campo_orig.full()) + { + valore = get_str(campo_orig); + rec.put(campo_dest, valore); + } + } +} + +bool THardy_pag::trasferisci() +{ + TString query = + "SELECT * " + "FROM dbo.Pagamenti "; + + TRecordset& recset = create_recordset(query); + + TString str; + + TConfig& ini = config(); + TString_array lista_campi; + ini.list_variables(lista_campi, true, "CPG", true); + + TTable table("%CPG"); + TRectype& rec = table.curr(); + + THardy_iterator hi(this); + while (++hi) + { + const TString& codtab = get_str("IdPagamento"); + rec.zero(); + rec.put("CODTAB", codtab); + aggiorna_record(rec, lista_campi); + + test_write(table); + } + return write_enabled(); +} + +/////////////////////////////////////////////////////////// +// THardy_iva +/////////////////////////////////////////////////////////// + +void THardy_iva::aggiorna_record(TRectype& rec, const TString_array& lista_campi) +{ + TString campo_dest, campo_orig, valore, str; + + FOR_EACH_ARRAY_ROW(lista_campi,i,row) + { + row->get(0, campo_dest); + row->get(1, campo_orig); + if (campo_orig.full()) + { + valore = get_str(campo_orig); + rec.put(campo_dest, valore); + } + } +} + +bool THardy_iva::trasferisci() +{ + TString query = + "SELECT * " + "FROM dbo.AliquoteIVA "; + + TRecordset& recset = create_recordset(query); + + TString str; + + TConfig& ini = config(); + TString_array lista_campi; + ini.list_variables(lista_campi, true, "IVA", true); + + TTable table("%IVA"); + TRectype& rec = table.curr(); + + THardy_iterator hi(this); + while (++hi) + { + const TString& codtab = get_str("IdIva"); + rec.zero(); + rec.put("CODTAB", codtab); + aggiorna_record(rec, lista_campi); + test_write(table); + } + return write_enabled(); +} + +/////////////////////////////////////////////////////////// +// THardy_catmerc +/////////////////////////////////////////////////////////// + +void THardy_catmerc::aggiorna_record(TRectype& rec, const TString_array& lista_campi) +{ + TString campo_dest, campo_orig, valore, str; + + FOR_EACH_ARRAY_ROW(lista_campi,i,row) + { + row->get(0, campo_dest); + row->get(1, campo_orig); + if (campo_orig.full()) + { + valore = get_str(campo_orig); + rec.put(campo_dest, valore); + } + } +} + +bool THardy_catmerc::trasferisci() +{ + TString query = + "SELECT * " + "FROM dbo.CategorieMerc "; + + TRecordset& recset = create_recordset(query); + + TString str; + + TConfig& ini = config(); + TString_array lista_campi; + ini.list_variables(lista_campi, true, "GMC", true); + + TTable table("%GMC"); + TRectype& rec = table.curr(); + + THardy_iterator hi(this); + while (++hi) + { + const TString& codtab = get_str("IdCategoria"); + rec.zero(); + rec.put("CODTAB", codtab); + aggiorna_record(rec, lista_campi); + test_write(table); + } + return write_enabled(); +} + +/////////////////////////////////////////////////////////// +// THardy_catfisc +/////////////////////////////////////////////////////////// + +void THardy_catfisc::aggiorna_record(TRectype& rec, const TString_array& lista_campi) +{ + TString campo_dest, campo_orig, valore, str; + + FOR_EACH_ARRAY_ROW(lista_campi,i,row) + { + row->get(0, campo_dest); + row->get(1, campo_orig); + if (campo_orig.full()) + { + valore = get_str(campo_orig); + rec.put(campo_dest, valore); + } + } +} + +bool THardy_catfisc::trasferisci() +{ + TString query = + "SELECT * " + "FROM dbo.CategorieFisc "; + + TRecordset& recset = create_recordset(query); + + TString str; + + TConfig& ini = config(); + TString_array lista_campi; + ini.list_variables(lista_campi, true, "ASF", true); + + TTable table("%ASF"); + TRectype& rec = table.curr(); + + THardy_iterator hi(this); + while (++hi) + { + const TString& codtab = get_str("IdCategoria"); + rec.zero(); + rec.put("CODTAB", codtab); + aggiorna_record(rec, lista_campi); + test_write(table); + } + return write_enabled(); +} + +/////////////////////////////////////////////////////////// +// THardy_ban +/////////////////////////////////////////////////////////// + +void THardy_ban::aggiorna_record(TRectype& rec, const TString_array& lista_campi) +{ + TString campo_dest, campo_orig, valore, str; + + FOR_EACH_ARRAY_ROW(lista_campi,i,row) + { + row->get(0, campo_dest); + row->get(1, campo_orig); + if (campo_orig.full()) + { + valore = get_str(campo_orig); + rec.put(campo_dest, valore); + } + } +} + +bool THardy_ban::trasferisci() +{ + bool ok = trasferisci_abi(); + if (ok) + ok = trasferisci_cab(); + return ok; +} + +bool THardy_ban::trasferisci_abi() +{ + TString query = + "SELECT * " + "FROM dbo.Banche "; + + TRecordset& recset = create_recordset(query); + + TString str; + + TConfig& ini = config(); + TString_array lista_campi; + ini.list_variables(lista_campi, true, "ABI", true); + + TSystemisamfile table(LF_TABCOM); + table.open(_lock); + + TRectype& rec = table.curr(); + + THardy_iterator hi(this); + while (++hi) + { + TString16 codtab = get_str("IdBanca"); + codtab.lpad(5,'0'); + rec.zero(); + rec.put("CODTAB", codtab); + aggiorna_record(rec, lista_campi); + test_write(table); + } + table.close(); + return write_enabled(); +} + +bool THardy_ban::trasferisci_cab() +{ + TString query = + "SELECT * " + "FROM dbo.Agenzie "; + + TRecordset& recset = create_recordset(query); + + TString str; + + TConfig& ini = config(); + TString_array lista_campi; + ini.list_variables(lista_campi, true, "CAB", true); + + TSystemisamfile table(LF_TABCOM); + table.open(_lock); + + TRectype& rec = table.curr(); + + THardy_iterator hi(this); + while (++hi) + { + TString16 codtab = get_str("IdBanca"); + codtab.lpad(5,'0'); + codtab << get_str("Cab"); + rec.zero(); + rec.put("COD", "BAN"); + rec.put("CODTAB", codtab); + aggiorna_record(rec, lista_campi); + test_write(table); + } + table.close(); + return write_enabled(); +} + +/////////////////////////////////////////////////////////// +// TImportazioneHardy_mask +/////////////////////////////////////////////////////////// + +class TImportazioneHardy_mask : public TAutomask +{ +protected: + virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); + void serialize(bool bSave); + +public: + void trasferisci(); + + TImportazioneHardy_mask(); + virtual ~TImportazioneHardy_mask(); +}; + + +// Funzione di tarsferimento dati da/verso file .ini con lo stesso nome della maschera +// Andrebbe messo in libreria +void TImportazioneHardy_mask::serialize(bool bSave) +{ + TFilename n = source_file(); n.ext("ini"); // Construisce il nome del .ini in base al .msk + TConfig cfg(n, "Main"); // Crea il file di configurazione + TString4 id; + for (int i = fields()-1; i >= 0; i--) // Scandisce tutti i campi della maschera ... + { + TMask_field& f = fld(i); + if (f.active() && f.is_loadable()) // ... selezionando solo quelli editabili + { + id.format("%d", f.dlg()); + if (bSave) // A seconda del flag di scrittura ... + cfg.set(id, f.get()); // ... o scrive sul .ini + else + f.set(cfg.get(id)); // ... o legge dal .ini + } + } +} + +void TImportazioneHardy_mask::trasferisci() +{ + TString query_header; + query_header << "ODBC(" << get(F_DSN) << ',' << get(F_USR) << ',' << get(F_PWD) << ")\n"; + + TReport_book book; + THardy_log log; + + bool rep_to_print = false; + bool go_on = true; + + if (go_on && get_bool(F_PAG)) + { + THardy_pag pc; + pc.init(TR("Condizioni di pagamento"), query_header, log); + go_on = pc.trasferisci(); + book.add(log); + rep_to_print = true; + } + if (go_on && get_bool(F_IVA)) + { + THardy_iva pc; + pc.init(TR("Aliquote IVA"), query_header, log); + go_on = pc.trasferisci(); + book.add(log); + rep_to_print = true; + } + if (go_on && get_bool(F_CATMERC)) + { + THardy_catmerc pc; + pc.init(TR("Categorie merceologiche"), query_header, log); + go_on = pc.trasferisci(); + book.add(log); + rep_to_print = true; + } + if (go_on && get_bool(F_CATFISC)) + { + THardy_catfisc pc; + pc.init(TR("Categorie fiscali"), query_header, log); + go_on = pc.trasferisci(); + book.add(log); + rep_to_print = true; + } + if (go_on && get_bool(F_BAN)) + { + THardy_ban pc; + pc.init(TR("Banche"), query_header, log); + go_on = pc.trasferisci(); + book.add(log); + rep_to_print = true; + } + + if (rep_to_print && book.pages() > 0) + book.preview(); +} + +bool TImportazioneHardy_mask::on_field_event(TOperable_field& o, TField_event e, long jolly) +{ + switch (o.dlg()) + { + case DLG_OK: + if (e == fe_button) + serialize(true); + break; + default: + break; + } + + return true; +} + +TImportazioneHardy_mask::TImportazioneHardy_mask() : TAutomask("hacnv100a") +{ + serialize(false); +} + +TImportazioneHardy_mask::~TImportazioneHardy_mask() +{ } + + +/////////////////////////////////////////////////////////// +// TImportazioneHardy +/////////////////////////////////////////////////////////// + +class TImportazioneHardy : public TSkeleton_application +{ +protected: + virtual void main_loop(); +}; + +void TImportazioneHardy::main_loop() +{ + TImportazioneHardy_mask mask; + while (mask.run() == K_ENTER) + mask.trasferisci(); +} + +int hacnv100(int argc, char* argv[]) +{ + TImportazioneHardy ih; + ih.run(argc, argv, APPNAME); + return 0; +} diff --git a/ha/hacnv100.h b/ha/hacnv100.h new file mode 100755 index 000000000..84a542add --- /dev/null +++ b/ha/hacnv100.h @@ -0,0 +1,236 @@ +#ifndef __HACNV100_H +#define __HACNV100_H + +#ifndef __CONFIG_H +#include +#endif + +#ifndef __DICTION_H +#include +#endif + +#ifndef __ISAM_H +#include +#endif + +#ifndef __ODBCRECSET_H +#include +#endif + +#ifndef __PROGIND_H +class TProgind; +#endif + +#ifndef __MODAUT_H +#include +#endif + +#ifndef __CLIFOR_H +#include "../ve/clifor.h" +#endif + +#include "../ve/velib.h" + +class THardy_log; +class TCache_th; + +class THardy_transfer : public TObject +{ + TString _query_header; + THardy_log* _log; + TConfig _config; + + TRecordset* _recset; + bool _write_enabled; + TODBC_recordset* _outset; + TCache_th* _tab; + +protected: + const TString& build_insert_query(const char* table, const char* f, const char* v) const; + + TRecordset& create_recordset(const char* query); + long odbc_exec(const char* command); + + const TString& decode_value(const char* tab, const TString& field_value); + const TString& decode_field(const char* tab, const char* recset_field); + + THardy_transfer(); + virtual bool trasferisci() pure; + +public: + void init(const char* rh, const char* qh, THardy_log& log); + const TString& title() const; + TConfig& config() { return _config; } + const TString& query_header() const { return _query_header; } + + void log(const char* msg, int sev = 0) const; + bool log_error(const char* msg); + bool log_cancelled(); + const TRecordset& recordset() const; + TRecordset& recordset(); + + const TString& get_str(const char* campo) const; // Get string from current recordset + const TString& get_real_str(const char* campo) const; // Get eventually empty string from numeric field + long get_long(const char* campo) const; + + bool write_enabled() const { return _write_enabled; } + + bool test_write(TBaseisamfile& file); + + virtual ~THardy_transfer(); +}; + +class THardy_iterator +{ + THardy_transfer* _ht; + TProgind* _pi; + TRecnotype _rec; + +public: + bool ok() const; + bool cancelled() const; + THardy_iterator& operator=(TRecnotype n); + THardy_iterator& operator++(); + operator int() const { return ok(); } + + THardy_iterator(THardy_transfer* ht); + ~THardy_iterator(); +}; + +/////////////////////////////////////////////////////////// +// Cache generica per il trasferimento +/////////////////////////////////////////////////////////// + +class TCache_th : public TCache +{ + THardy_transfer* _ht; + +protected: + void log(const char* msg, int sev) const { _ht->log(msg, sev); } + bool test_write(TBaseisamfile& file) const { return _ht->test_write(file); } + const TRecordset& recordset() const { return _ht->recordset(); } + TConfig& config() const { return _ht->config(); } + const TString& query_header() const { return _ht->query_header(); } + +public: + const TString& get_str(const char* campo) const { return _ht->get_str(campo); } + const TString& get_real_str(const char* campo) const { return _ht->get_real_str(campo); } + long get_long(const char* campo) const { return _ht->get_long(campo); } + virtual const TString& decode(const TToken_string& tokens) pure; + + TCache_th(THardy_transfer* ht) : _ht(ht) {} +}; + +/////////////////////////////////////////////////////////// +// Trasferimenti veri e propri +/////////////////////////////////////////////////////////// + +class THardy_conti : public THardy_transfer +{ +public: + virtual bool trasferisci(); +}; + +class THardy_pag : public THardy_transfer +{ +protected: + void aggiorna_record(TRectype& rec, const TString_array& lista_campi); + +public: + virtual bool trasferisci(); +}; + +class THardy_iva : public THardy_transfer +{ +protected: + void aggiorna_record(TRectype& rec, const TString_array& lista_campi); + +public: + virtual bool trasferisci(); +}; + +class THardy_catmerc : public THardy_transfer +{ +protected: + void aggiorna_record(TRectype& rec, const TString_array& lista_campi); + +public: + virtual bool trasferisci(); +}; + +class THardy_catfisc : public THardy_transfer +{ +protected: + void aggiorna_record(TRectype& rec, const TString_array& lista_campi); + +public: + virtual bool trasferisci(); +}; + +class THardy_ban : public THardy_transfer +{ +protected: + void aggiorna_record(TRectype& rec, const TString_array& lista_campi); + bool trasferisci_abi(); + bool trasferisci_cab(); + +public: + virtual bool trasferisci(); +}; + + +/* +class THardy_clifo : public THardy_transfer +{ + TCache_th* _agenti; + TCache_th* _banche; + bool _only_agenti; + +protected: + int cancella_clifo(TLocalisamfile& clifo) const; + long get_next_key(const char tipocf) const; + void update_statusflag_codcontab(const TString& custsuppcode, const int statusflag, const TString& codcontab); + void aggiorna_record(TRectype& rec, const TString_array& lista_campi); + void aggiorna_banca(); + void trasferisci_conai(TRectype& rec); + const TString& decode_agente(const long codforn); + const TString& get_agente(); + +public: + virtual bool trasferisci(); + THardy_clifo(bool only_agenti); + ~THardy_clifo(); +}; +*/ + +class TCache_art; +class TCache_umart; +class TDocumento; + +////////////////////////////////////////////////////////// +// Cache articoli +/////////////////////////////////////////////////////////// + +class TArticolo_hardy : public TRectype +{ + TString _cust_code, _paper_comp; + + TString4 _conai_scat[CONAI_CLASSES]; + real _conai_peso[CONAI_CLASSES]; + +public: + void set_customer_code(const TString& cc) { _cust_code = cc; } + const TString& customer_code() const { return _cust_code; } + + void set_paper_composition(const TString& pc) { _paper_comp = pc; } + const TString& paper_composition() const { return _paper_comp; } + + const TString& conai_subclass(TCONAI_class cc) const { CHECK_CONAI(cc); return _conai_scat[cc]; } + const real& conai_weight(TCONAI_class cc) const { CHECK_CONAI(cc); return _conai_peso[cc]; } + bool set_conai(TCONAI_class cc, const TString& scat, const real& weight); + + TArticolo_hardy(const TRectype& anamag); + TArticolo_hardy(); +}; + +#endif diff --git a/ha/hacnv100a.h b/ha/hacnv100a.h new file mode 100755 index 000000000..b91bcb0f4 --- /dev/null +++ b/ha/hacnv100a.h @@ -0,0 +1,20 @@ +#ifndef __HACNV100A_H +#define __HACNV100A_H + +#define F_FIRM 101 +#define F_RAGSOC 102 + +#define F_PAG 111 +#define F_IVA 112 +#define F_CATMERC 113 +#define F_CATFISC 114 +#define F_BAN 115 +#define F_CAUCONT 116 +#define F_CAUMAG 117 +#define F_CAUCESP 118 + +#define F_DSN 201 +#define F_USR 202 +#define F_PWD 203 + +#endif diff --git a/ha/hacnv100a.ini b/ha/hacnv100a.ini new file mode 100755 index 000000000..a55737e69 --- /dev/null +++ b/ha/hacnv100a.ini @@ -0,0 +1,262 @@ +// tabella condizioni di pagamento = Pagamenti +[CPG] +S0=DsPagamento +S1= +S3= +S4=IdTipoMovimento +S5= +I0= +I1= +I2= +I3= +B0= +B1= + +[IdTipoMovimento] +BO=9 +RB=3 +RD=1 +RI=8 + +// tabella codici IVA = AliquoteIVA +[IVA] +S0=DsIvaEstesa +S1= +S2= +S3= +S5= +S6= +S7= +S8= +S9= +S10= +S11= +I0= +I1= +R0=Aliquota +B0= +B1= +B2= +B3= +B4= + +[RComunicazioneIvaVen] +1=CD11 +2=CD12 +3=CD13 +4=CD14 + +[RComunicazioneIvaAcq] +1=CD21 +2=CD22 +3=CD23 +4=CD24 + +// tabella gruppi merceologici = CategorieMerc +[GMC] +S0=DsCategoria + +// tabella classi fiscali = CategorieFisc +[ASF] +S0=DsCategoria + +// tabella Banche ABI = Banche +[ABI] +S0=DsBanca +// tabella Banche CAB = Agenzie +[CAB] +S0=DsDocumento + +[CAUCONT] +S0=DsCausaleEstesa + +[CLIFO] +RAGSOC = _STREXPR,LEFT(TradeName1+" "+TradeName2; 50) +INDCF = Address +CIVCF = +LOCALITACF = +STATOCF = _TAB,%TPS,State,S6 +COMCF = +CAPCF = ZipCode +COFI = CodiceFiscale +STATOPAIV = +PAIV = PartitaIVA +TIPOPERS = +ALLEG = +CODALLEG = +GRUPPO = +CONTO = +GRUPPORIC = +CONTORIC = +SOTTOCRIC = +TIPOAPER = +CODANAGPER = +PTEL = +TEL = TelNumber +PTEL2 = +TEL2 = +PTEL3 = +TEL3 = +PFAX = +FAX = FaxNumber +PTELEX = +TELEX = +MAIL = EMailAddress +DATANASC = +STATONASC = +COMNASC = +CODSTAT = +CODABI = ABICode +CODCAB = CABCode +NUMCC = CC +IBAN = +OCCAS = +STATO = +CODVAL = +CODLIN = +FIDO = +CODPAG = PaymentCode +RICALT = +OGGETTI = +SOSPESO = +DIRTY = +REFERENTE = Reference +VALINTRA = + +[CFVEN] +CODINDDOC = +CODNOTE = +CODLEG = +CODCATC = _TAB,TPC,CategoryCode,S6 +CODZONA = _TAB,TPZ,ZoneCode,S6 +CODAG = +PERCPROVV = +CAPZON = +LIQPAG = +CODPRCF = +CODINDSP = +CODNOTESP1 = +CODNOTESP2 = +CODSPMEZZO = _TAB,%TPM,TransportCode,S6 +CODPORTO = _TAB,%TPP,PortCode,S6 +CODVETT1 = +CODVETT2 = +CODVETT3 = +RAGGDOC = +CODCFASS = +ASSFIS = _TABCOM,%TPI,CodIvaNI,S6 +FATTSOSP = +VSNRPROT = ExportOrigNum +VSDATAREG = ExportOrigDate +NSNPROT = ExportProtNum +NSDATAREG = ExportProtDate +CATFIN = +CODABIPR = +CODCABPR = +CODINDEFF = +EMEFFRICH = +RAGGEFF = +IMPMINEFF = +NONACCEFF = +NONSCADEFF = +ADDBOLLI = +PERCSPINC = +IVARID = +CATVEN = +GESTCONTR = +CODLIST = +CODSCC = +CODMAG = +CODDEP = +CODSP1 = +CODSP2 = +CODSP3 = +CODSP4 = +PROFSOLL = +MAXSOLL = +DATAESC = +NUMESC = +DATASOLL = +SCONTO = Discount +TITOLO = +RAGGOR = +MINORD = +MAXORD = +PREVORD = +TIPOEVORD = +ESACC = +ESALL = +ESCAR = +ESPLA = +ESLEG = +ESVET = +CONAIASS = +TIPODOCFAT = +CODCAUS = + +[AGENTI] +RAGSOC = TradeName1 +TIPO = _FISSO,A +CODCAPO = +PERCAPO = +PERCFATT = +CAMPOPROVV = +PERCPROVV = ProvvAgent +SEQRIC = +CODRICPR1 = +CODRICPR2 = +CODRICPR3 = +CODRICPR4 = +SEQALT = +CODALTRPR1 = +CODALTRPR2 = +CODALTRPR3 = +CODALTRPR4 = +CODFISC = +MATRICOLA = +PLURIMAND = +DATACESS = + +[INDSPED] +RAGSOC = TradeName1 +INDIR = Address +CIV = +LOCALITA = +CAP = ZipCode +STATO = _TAB,%TPS,State,S6 +COM = +PTEL = +TEL = TelNumber +PFAX = +FAX = FaxNumber +IVARID = + +[CONAI] +AC = CONACC +AL = CONALL +CA = CONCAR +LE = CONLEG +PL = CONPLA +VE = CONVET + +[CFV_CONAI] +AC = ESACC +AL = ESALL +CA = ESCAR +LE = ESLEG +PL = ESPLA +VE = ESVET + +[STANDARD] +RAGGDOC=X +RAGGEFF=X +ADDBOLLI= +PERCSPINC= + +[CODNUM] +1 = B01 +2 = B01 + +[TIPODOC] +20 = B01 +DDT C/RIP = BOF diff --git a/ha/hacnv100a.uml b/ha/hacnv100a.uml new file mode 100755 index 000000000..d263b7cbd --- /dev/null +++ b/ha/hacnv100a.uml @@ -0,0 +1,105 @@ +#include "hacnv100a.h" + +TOOLBAR "topbar" 0 0 0 2 + +#include + +ENDPAGE + +PAGE "Trasferimenti" 0 2 0 0 + +GROUPBOX DLG_NULL 78 3 +BEGIN + PROMPT 1 1 "@bDitta" +END + +NUMBER F_FIRM 5 +BEGIN + PROMPT 2 2 "" + USE LF_NDITTE + INPUT CODDITTA F_FIRM + OUTPUT F_RAGSOC RAGSOC + CHECKTYPE REQUIRED + FLAGS "DF" +END + +STRING F_RAGSOC 60 +BEGIN + PROMPT 17 2 "" + FLAGS "D" +END + +GROUPBOX DLG_NULL 78 6 +BEGIN + PROMPT 1 4 "@bTabelle" +END + +BOOLEAN F_PAG +BEGIN + PROMPT 2 5 "Condizioni di pagamento" +END + +BOOLEAN F_IVA +BEGIN + PROMPT 2 6 "Aliquote IVA" +END + +BOOLEAN F_CATMERC +BEGIN + PROMPT 2 7 "Cat. merceologiche" +END + +BOOLEAN F_CATFISC +BEGIN + PROMPT 2 8 "Cat. fiscali" +END + +BOOLEAN F_BAN +BEGIN + PROMPT 32 5 "Banche" +END + +BOOLEAN F_CAUCONT +BEGIN + PROMPT 32 6 "Causali contabili" +END + +BOOLEAN F_CAUMAG +BEGIN + PROMPT 32 7 "Causali magazzino" +END + +BOOLEAN F_CAUCESP +BEGIN + PROMPT 32 8 "Causali cespiti" +END + +ENDPAGE + +PAGE "Configurazione" -1 -1 78 18 + +GROUPBOX DLG_NULL 78 5 +BEGIN + PROMPT 1 1 "@bDatabase" +END + +STRING F_DSN 30 +BEGIN + PROMPT 2 2 "DSN " + CHECKTYPE REQUIRED +END + +STRING F_USR 16 +BEGIN + PROMPT 2 3 "User " +END + +STRING F_PWD 16 +BEGIN + PROMPT 2 4 "Password " + FLAGS "*" +END + +ENDPAGE + +ENDMASK