d8010f2998
Files correlati : tp0100.cpp, tp0100a.h, tp0100a.uml Commento: Aggiunto alla maschera di estrazione da PACK a CAMPO il flag "Indirizzi di spedizione". Ora gli Indirizzi di spedizione vengono trasferiti solo in caso di flag attivo (precedentemente venivano trasferiti ogni volta che si faceva il trasferimento dei Clienti/Fornitori)
561 lines
13 KiB
C++
Executable File
561 lines
13 KiB
C++
Executable File
#include "tp0100.h"
|
||
#include "tp0100a.h"
|
||
|
||
#include <applicat.h>
|
||
#include <automask.h>
|
||
#include <defmask.h>
|
||
#include <progind.h>
|
||
#include <reprint.h>
|
||
#include <reputils.h>
|
||
#include <tabutil.h>
|
||
|
||
const char* const APPNAME = TR("Trasferimento PACK");
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TPack_log
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class TPack_log : public TLog_report
|
||
{
|
||
public:
|
||
TPack_log() : TLog_report(APPNAME) {}
|
||
};
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TPack_iterator
|
||
///////////////////////////////////////////////////////////
|
||
|
||
bool TPack_iterator::cancelled() const
|
||
{
|
||
return _pi != NULL && _pi->iscancelled();
|
||
}
|
||
|
||
bool TPack_iterator::ok() const
|
||
{
|
||
if (cancelled())
|
||
return _pt->log_cancelled();
|
||
return _rec >= 0 && _rec < _pt->recordset().items();
|
||
}
|
||
|
||
TPack_iterator& TPack_iterator::operator=(TRecnotype n)
|
||
{
|
||
if (_pi != NULL)
|
||
_pi->setstatus(n+1);
|
||
_pt->recordset().move_to(_rec = n);
|
||
return *this;
|
||
}
|
||
|
||
TPack_iterator& TPack_iterator::operator++()
|
||
{
|
||
return *this = ++_rec;
|
||
}
|
||
|
||
TPack_iterator::TPack_iterator(TPack_transfer* pt) : _pt(pt), _pi(NULL)
|
||
{
|
||
const TRecnotype tot = _pt->recordset().items();
|
||
|
||
TString title; title << _pt->title() << ": " << tot << ' ' << TR("righe");
|
||
_pi = new TProgind(tot, title, true, true);
|
||
|
||
if (tot > 0)
|
||
_pt->log(title);
|
||
|
||
_rec = -1;
|
||
}
|
||
|
||
TPack_iterator::~TPack_iterator()
|
||
{
|
||
if (_pi != NULL)
|
||
delete _pi;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// Cache tabelle
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class TCache_tab : public TCache_tp
|
||
{
|
||
protected:
|
||
virtual TObject* key2obj(const char* key);
|
||
|
||
public:
|
||
virtual const TString& decode(const TToken_string& cod_codtab);
|
||
TCache_tab(TPack_transfer* pt) : TCache_tp(pt) {}
|
||
};
|
||
|
||
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();
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TPack_transfer
|
||
///////////////////////////////////////////////////////////
|
||
|
||
void TPack_transfer::init(const char* title, const char* qry_hdr, TPack_log& log)
|
||
{
|
||
_log = &log;
|
||
_log->reset();
|
||
_log->set_title(title);
|
||
_query_header = qry_hdr;
|
||
_write_enabled = true;
|
||
}
|
||
|
||
const TString& TPack_transfer::title() const
|
||
{ return _log->title(); }
|
||
|
||
void TPack_transfer::log(const char* msg, int sev) const
|
||
{
|
||
_log->log(sev, msg);
|
||
}
|
||
|
||
TRecordset& TPack_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& TPack_transfer::recordset() const
|
||
{
|
||
CHECK(_recset != NULL, "NULL recordset");
|
||
return *_recset;
|
||
}
|
||
|
||
TRecordset& TPack_transfer::recordset()
|
||
{
|
||
CHECK(_recset != NULL, "NULL recordset");
|
||
return *_recset;
|
||
}
|
||
|
||
long TPack_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
|
||
|
||
msg.cut(0);
|
||
msg << TR("Errore n: ") << abs(err) << TR(" in esecuzione della query.");
|
||
log_error(msg);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TString msg;
|
||
msg << TR("ERRORE di connessione a ") << _outset->dsn() << " : BEGIN TRANS";
|
||
log_error(msg);
|
||
}
|
||
}
|
||
return err;
|
||
}
|
||
|
||
bool TPack_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 TPack_transfer::log_cancelled()
|
||
{
|
||
return log_error(TR("Procedura interrotta dall'utente"));
|
||
}
|
||
|
||
bool TPack_transfer::test_write(TBaseisamfile& file, bool re)
|
||
{
|
||
int err = NOERR;
|
||
if (_write_enabled)
|
||
{
|
||
if (re)
|
||
err = file.rewrite_write();
|
||
else
|
||
{
|
||
TString80 code, desc;
|
||
if (file.num() == LF_TAB || file.num() == LF_TABCOM || file.num() == LF_TABMOD)
|
||
{
|
||
code = file.get("CODTAB");
|
||
desc = file.get("S0");
|
||
}
|
||
else
|
||
{
|
||
code = file.curr().build_key(1);
|
||
desc = file.curr().build_key(2);
|
||
}
|
||
TString msg;
|
||
msg << TR("Inserimento ") << code << " (" << desc << ')'
|
||
<< TR(" nel file ") << ' ' << file.num() << " (" << file.description() << ')';
|
||
log(msg, 1);
|
||
|
||
err = file.write();
|
||
if (err == _isreinsert)
|
||
{
|
||
msg.format(FR("Errore %d durante la scrittura sul file"), err);
|
||
log(msg, 1);
|
||
err = NOERR;
|
||
}
|
||
}
|
||
if (err != NOERR)
|
||
{
|
||
TString msg;
|
||
msg.format(FR("Errore %d durante la scrittura sul file %d (%s)"),
|
||
err, file.num(), file.description());
|
||
log_error(msg);
|
||
}
|
||
}
|
||
return err == NOERR;
|
||
}
|
||
|
||
const TString& TPack_transfer::get_str(const char* field) const
|
||
{
|
||
return recordset().get(field).as_string();
|
||
}
|
||
|
||
const TString& TPack_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 TPack_transfer::get_long(const char* field) const
|
||
{
|
||
return recordset().get(field).as_int();
|
||
}
|
||
|
||
const real TPack_transfer::get_real(const char* campo) const
|
||
{
|
||
return recordset().get(campo).as_real();
|
||
}
|
||
const TString& TPack_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& TPack_transfer::decode_field(const char* tab, const char* field)
|
||
{
|
||
const TString& cod = get_str(field);
|
||
return decode_value(tab, cod);
|
||
}
|
||
|
||
const TString& TPack_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;
|
||
}
|
||
|
||
TPack_transfer::TPack_transfer()
|
||
: _log(NULL), _config("tp0101a.ini"), _recset(NULL), _outset(NULL), _tab(NULL)
|
||
{}
|
||
|
||
TPack_transfer::~TPack_transfer()
|
||
{
|
||
if (_tab != NULL)
|
||
delete _tab;
|
||
if (_outset != NULL)
|
||
{
|
||
_outset->exec("COMMIT TRANS");
|
||
delete _outset;
|
||
}
|
||
if (_recset != NULL)
|
||
delete _recset;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TTrasferimentoPack_mask
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class TTrasferimentoPack_mask : public TAutomask
|
||
{
|
||
protected:
|
||
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
|
||
void serialize(bool bSave);
|
||
|
||
public:
|
||
void trasferisci();
|
||
|
||
TTrasferimentoPack_mask();
|
||
virtual ~TTrasferimentoPack_mask();
|
||
};
|
||
|
||
// Funzione di tarsferimento dati da/verso file .ini con lo stesso nome della maschera
|
||
// Andrebbe messo in libreria
|
||
void TTrasferimentoPack_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 TTrasferimentoPack_mask::trasferisci()
|
||
{
|
||
TString query_header;
|
||
query_header << "ODBC(" << get(F_DSN) << ',' << get(F_USR) << ',' << get(F_PWD) << ")\n";
|
||
|
||
TReport_book book;
|
||
TPack_log log;
|
||
|
||
bool rep_to_print = false;
|
||
bool go_on = true;
|
||
|
||
if (go_on && get_bool(F_CONTI))
|
||
{
|
||
TPack_conti pc;
|
||
pc.init(TR("Piano dei conti"), query_header, log);
|
||
go_on = pc.trasferisci();
|
||
book.add(log);
|
||
rep_to_print = true;
|
||
}
|
||
|
||
if (go_on && get_bool(F_PAG))
|
||
{
|
||
TPack_pag pc;
|
||
pc.init(TR("Pagamenti"), query_header, log);
|
||
go_on = pc.trasferisci();
|
||
book.add(log);
|
||
rep_to_print = true;
|
||
}
|
||
|
||
if (go_on && get_bool(F_CLIFO))
|
||
{
|
||
if (go_on)
|
||
{
|
||
TPack_clifo pa(true);
|
||
pa.init(TR("Agenti"), query_header, log);
|
||
go_on = pa.trasferisci();
|
||
book.add(log);
|
||
}
|
||
|
||
if (go_on)
|
||
{
|
||
TPack_clifo pc(false);
|
||
pc.init(TR("Clienti/Fornitori"), query_header, log);
|
||
go_on = pc.trasferisci();
|
||
book.add(log);
|
||
}
|
||
|
||
if (go_on && get_bool(F_INDTRASP))
|
||
{
|
||
if (go_on)
|
||
{
|
||
TPack_indsped is;
|
||
is.init(TR("Indirizzi di spedizione"), query_header, log);
|
||
go_on = is.trasferisci();
|
||
book.add(log);
|
||
}
|
||
}
|
||
rep_to_print = true;
|
||
}
|
||
|
||
if (go_on && get_bool(F_BOLLE))
|
||
{
|
||
TPack_ddt pc;
|
||
|
||
pc.activate_custref(get_bool(F_CUSTREF));
|
||
pc.activate_paper_info(get_bool(F_PAPER));
|
||
pc.activate_paper_size(get_bool(F_SIZE));
|
||
pc.activate_customer_code(get_bool(F_CUSTCODE));
|
||
pc.activate_ref_info(get_bool(F_REFINFO));
|
||
pc.activate_cmsref(get_bool(F_CMSREF));
|
||
pc.set_data_limite(get_date(F_DATABOLLE));
|
||
pc.activate_order_paper_info(get_bool(F_ORDPAPER));
|
||
pc.activate_extended_discount(get_bool(F_DISCOUNT));
|
||
pc.set_custrif(get(F_RIF));
|
||
pc.set_ordrif(get(F_ORD));
|
||
pc.activate_order_date(get_bool(F_ORDDATE));
|
||
pc.activate_conai(get_int(F_SCHEMA));
|
||
pc.init(TR("Documenti di trasporto"), query_header, log);
|
||
go_on = pc.trasferisci();
|
||
book.add(log);
|
||
rep_to_print = true;
|
||
}
|
||
|
||
if (rep_to_print && book.pages() > 0)
|
||
book.preview();
|
||
}
|
||
|
||
bool TTrasferimentoPack_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
|
||
{
|
||
switch (o.dlg())
|
||
{
|
||
case F_CONTI:
|
||
if (e == fe_close && o.get_bool())
|
||
return noyes_box(TR("ATTENZIONE!! Si <20> scelto di cancellare il piano dei conti di packway, i dati esportati da campo a packway dovranno essere completati"));
|
||
break;
|
||
case F_PAG:
|
||
if (e == fe_close && o.get_bool())
|
||
return noyes_box(TR("ATTENZIONE!! Si <20> scelto di cancellare la tabella dei pagamenti di packway, i dati esportati da campo a packway dovranno essere completati"));
|
||
break;
|
||
case DLG_OK:
|
||
if (e == fe_button)
|
||
serialize(true);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
TTrasferimentoPack_mask::TTrasferimentoPack_mask() : TAutomask("tp0100a")
|
||
{
|
||
serialize(false);
|
||
}
|
||
|
||
TTrasferimentoPack_mask::~TTrasferimentoPack_mask()
|
||
{ }
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TTrasferimentoPack
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class TTrasferimentoPack : public TSkeleton_application
|
||
{
|
||
protected:
|
||
virtual void main_loop();
|
||
};
|
||
|
||
void TTrasferimentoPack::main_loop()
|
||
{
|
||
TTrasferimentoPack_mask mask;
|
||
while (mask.run() == K_ENTER)
|
||
mask.trasferisci();
|
||
}
|
||
|
||
int tp0100(int argc, char* argv[])
|
||
{
|
||
TTrasferimentoPack tp;
|
||
tp.run(argc, argv, APPNAME);
|
||
return 0;
|
||
}
|