28ae493183
git-svn-id: svn://10.65.10.50/branches/R_10_00@22648 c028cbd2-c16b-5b4b-a496-9718f37d4682
769 lines
22 KiB
C++
Executable File
769 lines
22 KiB
C++
Executable File
#include "tp0100.h"
|
|
|
|
#include <recarray.h>
|
|
#include <tabutil.h>
|
|
|
|
#include <cfven.h>
|
|
#include <clifo.h>
|
|
#include <comuni.h>
|
|
#include <doc.h>
|
|
#include <indsp.h>
|
|
#include <mov.h>
|
|
|
|
#include "..\cg\cfban.h"
|
|
#include "..\pr\agenti.h"
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Cache banche
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TCache_ban : public TCache_tp
|
|
{
|
|
TTable _ban;
|
|
|
|
protected:
|
|
virtual TObject* key2obj(const char* key);
|
|
|
|
public:
|
|
virtual const TString& decode(const TToken_string& tok);
|
|
TCache_ban(TPack_transfer* pt) : TCache_tp(pt), _ban("%BAN") {}
|
|
};
|
|
|
|
TObject* TCache_ban::key2obj(const char* key)
|
|
{
|
|
TToken_string code(key);
|
|
TString8 abi; code.get(0, abi);
|
|
TString8 cab; code.get(1, cab);
|
|
_ban.put("CODTAB", abi);
|
|
if (_ban.read() != NOERR)
|
|
{
|
|
const TString& desc = get_str("BankName");
|
|
_ban.put("CODTAB", abi);
|
|
_ban.put("S0", desc);
|
|
test_write(_ban);
|
|
}
|
|
TString16 str;
|
|
str << abi; str << cab;
|
|
_ban.put("CODTAB", str);
|
|
if (_ban.read() != NOERR)
|
|
{
|
|
const TString& desc = get_str("BankName");
|
|
_ban.put("CODTAB", str);
|
|
_ban.put("S0", desc);
|
|
test_write(_ban);
|
|
}
|
|
return _ban.get("S0").dup();
|
|
}
|
|
|
|
const TString& TCache_ban::decode(const TToken_string& tok)
|
|
{
|
|
return *(const TString*)objptr(tok);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TPack_conti
|
|
///////////////////////////////////////////////////////////
|
|
|
|
bool TPack_conti::trasferisci()
|
|
{
|
|
log(TR("Azzeramento piano dei conti PACK"));
|
|
if (odbc_exec("DELETE FROM AccountPlan") >= 0)
|
|
{
|
|
TRecordset& pcon = create_recordset("USE PCON");
|
|
TPack_iterator pi(this);
|
|
while (++pi)
|
|
{
|
|
const int gruppo = pcon.get("GRUPPO").as_int();
|
|
const int conto = pcon.get("CONTO").as_int();
|
|
const long sottoc = pcon.get("SOTTOCONTO").as_int();
|
|
const long gruconto = gruppo*1000+conto;
|
|
|
|
TToken_string values;
|
|
values.add(gruconto);
|
|
values.add(sottoc);
|
|
values.add(pcon.get("DESCR").as_string());
|
|
odbc_exec(build_insert_query("AccountPlan", "AccountCode,AccountSubCode,DescAccount", values));
|
|
}
|
|
}
|
|
return write_enabled();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TPack_pag
|
|
///////////////////////////////////////////////////////////
|
|
|
|
bool TPack_pag::trasferisci()
|
|
{
|
|
log(TR("Azzeramento tabella pagamenti PACK"));
|
|
odbc_exec("DELETE FROM General_Data WHERE TablesType='P'");
|
|
|
|
TRecordset& pag = create_recordset("USE %CPG");
|
|
TPack_iterator pi(this);
|
|
while (++pi)
|
|
{
|
|
TToken_string values;
|
|
values.add("P");
|
|
values.add(pag.get("CODTAB").as_string());
|
|
values.add(pag.get("S0").as_string());
|
|
const TString& query = build_insert_query("General_Data", "TablesType,Code,Description1", values);
|
|
odbc_exec(query);
|
|
}
|
|
return write_enabled();
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Cache agenti
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TCache_agenti : public TCache_tp
|
|
{
|
|
protected:
|
|
virtual TObject* key2obj(const char* key);
|
|
|
|
public:
|
|
const TString& decode(const TToken_string& tok);
|
|
TCache_agenti(TPack_transfer* pt) : TCache_tp(pt) {}
|
|
};
|
|
|
|
TObject* TCache_agenti::key2obj(const char* key)
|
|
{
|
|
TLocalisamfile agenti(LF_AGENTI);
|
|
agenti.setkey(3);
|
|
agenti.put(AGE_CODFORN, key);
|
|
if (agenti.read() == NOERR)
|
|
return agenti.get(AGE_CODAGE).dup();
|
|
|
|
long cod = 1;
|
|
int err = agenti.last();
|
|
if (err == NOERR)
|
|
{
|
|
const char* codage = agenti.get(AGE_CODAGE);
|
|
if (codage[0] == 'Z')
|
|
cod += atoi(codage+1);
|
|
}
|
|
|
|
TString8 codage; codage.format("Z%04d", cod);
|
|
TString msg; msg.format(FR("Agente %s"), (const char*)codage);
|
|
|
|
agenti.put(AGE_CODAGE, codage);
|
|
agenti.put(AGE_RAGSOC, msg);
|
|
agenti.put(AGE_CODFORN, key);
|
|
test_write(agenti);
|
|
return codage.dup();
|
|
}
|
|
|
|
const TString& TCache_agenti::decode(const TToken_string& tok)
|
|
{
|
|
return *(TString*)objptr(tok);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TPack_clifo
|
|
///////////////////////////////////////////////////////////
|
|
|
|
const TString& TPack_clifo::decode_agente(const long codforn)
|
|
{
|
|
if (_agenti == NULL)
|
|
_agenti = new TCache_agenti(this);
|
|
TToken_string key;
|
|
key << codforn;
|
|
return _agenti->decode(key);
|
|
}
|
|
|
|
const TString& TPack_clifo::get_agente()
|
|
{
|
|
const TString& code = get_str("AgentCode");
|
|
if (code.full())
|
|
{
|
|
TString query = query_header();
|
|
query << "SELECT CodContab FROM Customers_Suppliers WHERE (FlagCustSupp='A') AND (CustSuppCode=#CODCF)";
|
|
TODBC_recordset clifo(query);
|
|
clifo.set_var("#CODCF", TVariant(code));
|
|
if (clifo.move_first())
|
|
{
|
|
TToken_string codice(clifo.get(0u).as_string());
|
|
return get_tmp_string() = codice.get(1);
|
|
}
|
|
else
|
|
{
|
|
TString msg;
|
|
msg << TR("Impossibile determinare il codice dell'agente")
|
|
<< " '" << code << '\'';
|
|
log_error(msg);
|
|
}
|
|
}
|
|
return EMPTY_STRING;
|
|
}
|
|
|
|
int TPack_clifo::cancella_clifo(TBaseisamfile& clifo) const
|
|
{
|
|
// verificare prima che il cliente sia cancellabile (MOV e DOC)
|
|
TRectype& rec_clifo = clifo.curr();
|
|
const char tipocf = rec_clifo.get(CLI_TIPOCF)[0];
|
|
const long codcf = rec_clifo.get_long(CLI_CODCF);
|
|
// verifico MOV
|
|
TLocalisamfile mov(LF_MOV);
|
|
mov.setkey(3);
|
|
mov.curr().put(MOV_TIPO, tipocf);
|
|
mov.curr().put(MOV_CODCF, codcf);
|
|
mov.read();
|
|
bool noncancellare = (tipocf == mov.get(MOV_TIPO)[0] && codcf == atol(mov.get(MOV_CODCF)));
|
|
if (!noncancellare)
|
|
{
|
|
// verifico DOC
|
|
TLocalisamfile doc(LF_DOC);
|
|
doc.setkey(2);
|
|
doc.curr().put(DOC_TIPOCF, tipocf);
|
|
doc.curr().put(DOC_CODCF, codcf);
|
|
doc.read();
|
|
noncancellare = (tipocf == doc.get(DOC_TIPOCF)[0] && codcf == atol(doc.get(DOC_CODCF)));
|
|
}
|
|
if (!noncancellare)
|
|
{
|
|
if (clifo.remove() == NOERR)
|
|
{
|
|
TLocalisamfile cfven(LF_CFVEN);
|
|
cfven.put(CFV_TIPOCF, tipocf);
|
|
cfven.put(CFV_CODCF, codcf);
|
|
cfven.remove();
|
|
|
|
TString msg; msg << TR("Cancellato cliente") << ' ' << codcf;
|
|
log(msg, 1); // 0 = messaggio 1 = warning 2 = errore
|
|
}
|
|
else
|
|
{
|
|
TString msg; msg << TR("Errore di cancellazione del cliente") << ' ' << codcf;
|
|
log(msg, 1); // 0 = messaggio 1 = warning 2 = errore
|
|
}
|
|
}
|
|
return ((noncancellare) ? 3 : 9);
|
|
}
|
|
|
|
long TPack_clifo::get_next_key(const char tipocf) const
|
|
{
|
|
TLocalisamfile clifo(LF_CLIFO);
|
|
long codcf = 1L;
|
|
if (!clifo.empty())
|
|
{
|
|
if (tipocf == 'C')
|
|
{
|
|
clifo.put(CLI_TIPOCF, 'F');
|
|
clifo.read(_isgteq);
|
|
if (clifo.good())
|
|
clifo.prev();
|
|
clifo.setstatus(NOERR);
|
|
}
|
|
else
|
|
clifo.last();
|
|
if (clifo.good())
|
|
{
|
|
const char tipo = clifo.get(CLI_TIPOCF)[0];
|
|
if (tipocf == tipo)
|
|
codcf += clifo.get_long(CLI_CODCF);
|
|
}
|
|
}
|
|
return codcf;
|
|
}
|
|
|
|
void TPack_clifo::aggiorna_banca()
|
|
{
|
|
TToken_string abicab;
|
|
abicab = get_str("ABICode");
|
|
abicab.add(get_str("CABCode"));
|
|
if (!abicab.empty_items())
|
|
{
|
|
if (_banche == NULL)
|
|
_banche = new TCache_ban(this);
|
|
_banche->decode(abicab);
|
|
}
|
|
}
|
|
|
|
void TPack_clifo::trasferisci_conai(TRectype& rec)
|
|
{
|
|
const long applyenvtax = get_long("ApplyEnvTax");
|
|
rec.put(CFV_ADDCONAI, applyenvtax > 0 ? "X" : "");
|
|
|
|
// Azzera tutte le esenzioni CONAI
|
|
rec.zero(CFV_ESACC); rec.zero(CFV_ESALL); rec.zero(CFV_ESCAR);
|
|
rec.zero(CFV_ESLEG); rec.zero(CFV_ESPLA); rec.zero(CFV_ESVET);
|
|
|
|
// Imposta le eventuali esenzioni CONAI
|
|
if (applyenvtax == 2)
|
|
{
|
|
TString query(128);
|
|
query << query_header();
|
|
query << "SELECT ClassCode, ApplyPercent FROM Customers_EnvironmentTax WHERE (CustCode=#CODCF)";
|
|
TODBC_recordset conai(query);
|
|
const TVariant& code = recordset().get("CustSuppCode");
|
|
conai.set_var("#CODCF", code);
|
|
for (bool ok = conai.move_first(); ok; ok = conai.move_next())
|
|
{
|
|
const TString& conai_class = conai.get("ClassCode").as_string();
|
|
if (conai_class.not_empty())
|
|
{
|
|
const TString& conai_field = config().get(conai_class, "CFV_CONAI");
|
|
if (conai_field.not_empty())
|
|
{
|
|
const real applypercent = conai.get("ApplyPercent").as_real();
|
|
rec.put(conai_field, applypercent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool TPack_clifo::trasferisci()
|
|
{
|
|
TString query =
|
|
"SELECT Customers_Suppliers.*, Unit_Measure.UMDesc "
|
|
"FROM Customers_Suppliers LEFT JOIN Unit_Measure "
|
|
"ON (CurrencyCode = Unit_Measure.UMCode AND Unit_Measure.UMType='9') "
|
|
"WHERE (StatusFlag=1 OR StatusFlag=2 OR StatusFlag=3) AND ";
|
|
if (_only_agenti)
|
|
query << "(FlagCustSupp='A')";
|
|
else
|
|
query << "(FlagCustSupp='C' OR FlagCustSupp='S')";
|
|
TRecordset& recset = create_recordset(query);
|
|
|
|
TString str;
|
|
|
|
TConfig& ini = config();
|
|
TString_array lista_clifo, lista_cfven, lista_agenti;
|
|
ini.list_variables(lista_clifo, true, "CLIFO", true);
|
|
ini.list_variables(lista_cfven, true, "CFVEN", true);
|
|
ini.list_variables(lista_agenti,true, "AGENTI",true);
|
|
|
|
TFast_isamfile clifo(LF_CLIFO);
|
|
TFast_isamfile cfven(LF_CFVEN);
|
|
TFast_isamfile cfban(LF_CFBAN);
|
|
|
|
TRectype& rec_clifo = clifo.curr();
|
|
TRectype& rec_cfven = cfven.curr();
|
|
TRectype& rec_cfban = cfban.curr();
|
|
|
|
TRecord_cache cache_comuni(LF_COMUNI, 2);
|
|
|
|
TPack_iterator pi(this);
|
|
while (++pi)
|
|
{
|
|
const TString& custsuppcode = get_str("CustSuppCode");
|
|
const int statusflag = get_long("StatusFlag");
|
|
const char flagcustsupp = get_str("FlagCustSupp")[0];
|
|
const char tipocf = (flagcustsupp == 'C' ? 'C': 'F'); // C -> C (S,A) -> F
|
|
long codcf = get_long("CodContab");
|
|
|
|
bool needs_creation = codcf <= 0;
|
|
bool good = true;
|
|
if (!needs_creation)
|
|
{
|
|
// il cliente/fornitore va aggiornato
|
|
cfven.zero();
|
|
rec_cfven.put(CFV_TIPOCF, tipocf);
|
|
rec_cfven.put(CFV_CODCF, codcf);
|
|
cfven.read();
|
|
|
|
clifo.zero();
|
|
rec_clifo.put(CLI_TIPOCF, tipocf);
|
|
rec_clifo.put(CLI_CODCF, codcf);
|
|
good = clifo.read() == NOERR;
|
|
if (!good)
|
|
needs_creation = true;
|
|
}
|
|
|
|
if (needs_creation && statusflag != 3)
|
|
{
|
|
// il cliente/fornitore va inserito in campo previo controllo piva
|
|
if (codcf <= 0)
|
|
codcf = get_next_key(tipocf);
|
|
rec_cfven.zero();
|
|
rec_cfven.put(CFV_TIPOCF, tipocf);
|
|
rec_cfven.put(CFV_CODCF, codcf);
|
|
// dati standard solo se sono in inserimento
|
|
ini.set_paragraph("STANDARD");
|
|
rec_cfven.put(CFV_RAGGDOC, ini.get(CFV_RAGGDOC));
|
|
rec_cfven.put(CFV_RAGGEFF, ini.get(CFV_RAGGEFF));
|
|
rec_cfven.put(CFV_ADDBOLLI, ini.get(CFV_ADDBOLLI));
|
|
rec_cfven.put(CFV_PERCSPINC, ini.get(CFV_PERCSPINC));
|
|
// scrivo
|
|
good = test_write(cfven);
|
|
rec_clifo.zero();
|
|
rec_clifo.put(CLI_TIPOCF, tipocf);
|
|
rec_clifo.put(CLI_CODCF, codcf);
|
|
good &= test_write(clifo);
|
|
}
|
|
|
|
if (good)
|
|
{
|
|
if (statusflag == 3)
|
|
{
|
|
const int flag = cancella_clifo(clifo);
|
|
str = "";
|
|
update_statusflag_codcontab(custsuppcode, flag, str);
|
|
// forse occorrera' cancellare anche l'agente se lo e'
|
|
}
|
|
else
|
|
{
|
|
// aggiorna i file clifo, cfven, agenti se necessario
|
|
aggiorna_banca();
|
|
// aggiorna dati conai
|
|
trasferisci_conai(rec_cfven);
|
|
// aggiormento comune
|
|
TString80 dencom = get_str("Locality");
|
|
dencom.trim(); dencom.upper();
|
|
const TRectype& reccom = cache_comuni.get(dencom);
|
|
if (dencom == reccom.get(COM_DENCOM))
|
|
rec_clifo.put(CLI_COMCF, reccom.get(COM_COM));
|
|
else
|
|
{
|
|
rec_clifo.zero(CLI_COMCF);
|
|
rec_clifo.put(CLI_LOCCF, dencom);
|
|
|
|
log("");
|
|
str.format(FR("Cliente/Fornitore %c %ld: comune non trovato %s"), tipocf, codcf, (const char*)dencom);
|
|
log(str);
|
|
}
|
|
// iban
|
|
bool ibanok = false;
|
|
const bool ibanflag = get_long("IbanFlag") != 0;
|
|
if (ibanflag)
|
|
{
|
|
const TString& iban = get_str("IbanCode");
|
|
if (iban.len() >= 15) // A volte ci sono dei valori non validi come "IT46"
|
|
{
|
|
rec_clifo.put(CLI_IBAN, iban);
|
|
cfban.zero();
|
|
rec_cfban.put(CFBAN_TIPOCF, tipocf);
|
|
rec_cfban.put(CFBAN_CODCF, codcf);
|
|
rec_cfban.put(CFBAN_TIPOBAN, 'V');
|
|
rec_cfban.put(CFBAN_NRIGA, 1);
|
|
rec_cfban.put(CFBAN_ABI, iban.mid( 5,5));
|
|
rec_cfban.put(CFBAN_CAB, iban.mid(10,5));
|
|
rec_cfban.put(CFBAN_NUMCC, iban.mid(15));
|
|
rec_cfban.put(CFBAN_IBAN, iban);
|
|
ibanok = test_write(cfban, !needs_creation);
|
|
}
|
|
}
|
|
if (!ibanok)
|
|
{
|
|
cfban.zero();
|
|
rec_cfban.put(CFBAN_TIPOCF, tipocf);
|
|
rec_cfban.put(CFBAN_CODCF, codcf);
|
|
rec_cfban.put(CFBAN_TIPOBAN, 'V');
|
|
rec_cfban.put(CFBAN_NRIGA, 1);
|
|
rec_cfban.put(CFBAN_ABI, get_str("ABICode"));
|
|
rec_cfban.put(CFBAN_CAB, get_str("CABCode"));
|
|
rec_cfban.put(CFBAN_NUMCC, get_str("CC"));
|
|
ibanok = test_write(cfban, !needs_creation);
|
|
}
|
|
|
|
// agente
|
|
rec_cfven.put(CFV_CODAG, get_agente());
|
|
|
|
// Gestione periodo non accettazione effetti (18-01-2012)
|
|
TString80 field;
|
|
TToken_string nonacceff(80, ';'), nonscadeff(80, ';');
|
|
for (int p = 1; p <= 3; p++)
|
|
{
|
|
field.format("DayExpEffFrom%02d", p);
|
|
const int day_from = get_long(field);
|
|
if (day_from <= 0)
|
|
break;
|
|
field.format("MonthExpEffFrom%02d", p);
|
|
const int month_from = get_long(field);
|
|
|
|
field.format("DayExpEffTo%02d", p);
|
|
const int day_to = get_long(field);
|
|
|
|
field.format("MonthExpEffTo%02d", p);
|
|
const int month_to = get_long(field);
|
|
|
|
field.format("DayNewEffect%02d", p);
|
|
const int day_new = get_long(field);
|
|
|
|
field.format("MonthNewEffect%02d", p);
|
|
const int month_new = get_long(field);
|
|
|
|
field.format("%02d-%02d,%02d-%02d", day_from, month_from, day_to, month_to);
|
|
nonacceff.add(field);
|
|
|
|
field.format("%02d-%02d", day_new, month_new);
|
|
nonscadeff.add(field);
|
|
}
|
|
if (nonacceff.full())
|
|
{
|
|
cfven.put(CFV_NONACCEFF, nonacceff);
|
|
cfven.put(CFV_NONSCADEFF, nonscadeff);
|
|
}
|
|
|
|
if (get_str("CodIvaNI") == "0") // Caso speciale: significa NON esenti
|
|
cfven.zero(CFV_ASSFIS); // Azzero il codice di assogettamento fiscale
|
|
|
|
aggiorna_record(clifo, lista_clifo);
|
|
aggiorna_record(cfven, lista_cfven);
|
|
|
|
// aggiorna anche record agenti se e' una spia
|
|
if (flagcustsupp == 'A')
|
|
{
|
|
const TString8 codage = decode_agente(codcf);
|
|
TLocalisamfile agenti(LF_AGENTI);
|
|
agenti.put(AGE_CODAGE, codage);
|
|
agenti.read();
|
|
agenti.put(AGE_CODFORN, codcf);
|
|
aggiorna_record(agenti, lista_agenti);
|
|
str.format("%ld|%s", codcf, (const char*) codage);
|
|
update_statusflag_codcontab(custsuppcode, 0, str);
|
|
}
|
|
else
|
|
{
|
|
// aggiorno codcontab
|
|
str.format("%ld", codcf);
|
|
update_statusflag_codcontab(custsuppcode, 0, str);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return write_enabled();
|
|
}
|
|
|
|
void TPack_clifo::update_statusflag_codcontab(const TString& custsuppcode, const int statusflag, const TString& codcontab)
|
|
{
|
|
TString query;
|
|
query.format("UPDATE Customers_Suppliers SET StatusFlag=%d, CodContab='%s' WHERE CustSuppCode='%s'",
|
|
statusflag, (const char*)codcontab, (const char*)custsuppcode);
|
|
odbc_exec(query);
|
|
}
|
|
|
|
bool TPack_clifo::aggiorna_record(TBaseisamfile& file, const TString_array& lista_campi)
|
|
{
|
|
TRectype& rec = file.curr();
|
|
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())
|
|
{
|
|
if (campo_orig[0] == '_')
|
|
{
|
|
if (campo_orig.starts_with("_FISSO")) // valore fisso indicato in configurazione
|
|
{
|
|
valore = campo_orig.after(',');
|
|
valore.trim();
|
|
} else
|
|
if (campo_orig.starts_with("_STREXPR")) // formato _STREXPR, espressione
|
|
{
|
|
TExpression expr(campo_orig.after(','), _strexpr);
|
|
for (int v = 0; v < expr.numvar(); v++)
|
|
{
|
|
const char* varname = expr.varname(v);
|
|
expr.setvar(v, get_str(varname));
|
|
}
|
|
valore = expr.as_string();
|
|
valore.trim();
|
|
} else
|
|
if (campo_orig.starts_with("_TAB")) // formato _TAB,<tabella da leggere>,<valore CODTAB>, <campo da leggere>
|
|
{
|
|
TToken_string elabora(campo_orig, ',');
|
|
const TString4 tab = elabora.get(1); // tabella da leggere
|
|
const TString16 codtab = get_str(elabora.get());
|
|
const TString16 campotab = elabora.get();
|
|
valore = cache().get(tab, codtab, campotab);
|
|
}
|
|
else
|
|
valore.cut(0);
|
|
}
|
|
else
|
|
valore = get_str(campo_orig);
|
|
rec.put(campo_dest, valore);
|
|
}
|
|
}
|
|
return test_rewrite(file);
|
|
}
|
|
|
|
TPack_clifo::TPack_clifo(bool only_agenti) : _agenti(NULL), _banche(NULL), _only_agenti(only_agenti)
|
|
{
|
|
}
|
|
|
|
TPack_clifo::~TPack_clifo()
|
|
{
|
|
if (_agenti != NULL)
|
|
delete _agenti;
|
|
if (_banche != NULL)
|
|
delete _banche;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TPack_indsped
|
|
///////////////////////////////////////////////////////////
|
|
|
|
bool TPack_indsped::get_clifo(char& tipocf, long& codcf)
|
|
{
|
|
const TVariant& code = recordset().get("CustSuppRefCode");
|
|
bool ok = !code.is_empty();
|
|
|
|
if (ok)
|
|
{
|
|
TString query = query_header();
|
|
query << "SELECT CodContab,FlagCustSupp FROM Customers_Suppliers WHERE CustSuppCode=#CODCF";
|
|
TODBC_recordset clifo(query);
|
|
|
|
clifo.set_var("#CODCF", code);
|
|
ok = clifo.move_first();
|
|
|
|
if (ok)
|
|
{
|
|
codcf = clifo.get(0u).as_int();
|
|
tipocf = clifo.get(1u).as_string()[0];
|
|
|
|
if (tipocf == 'T')
|
|
return false; // Ignora clienti temporanei senza dare segnalazioni
|
|
}
|
|
}
|
|
|
|
|
|
if (!ok || codcf <= 0)
|
|
{
|
|
TString msg;
|
|
msg << TR("Impossibile determinare il codice contabile dell'anagrafica");
|
|
msg << " Customers_Suppliers.CustSuppRefCode=" << code.as_string();
|
|
ok = log_error(msg);
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
int TPack_indsped::get_next_key(const char tipocf, const long codcf) const
|
|
{
|
|
TISAM_recordset indsped("USE INDSPED\nFROM TIPOCF=#TIPO CODCF=#CODE\nTO TIPOCF=#TIPO CODCF=#CODE");
|
|
TString4 str; str << tipocf;
|
|
indsped.set_var("#TIPO", TVariant(str));
|
|
indsped.set_var("#CODE", TVariant(codcf));
|
|
int codind = 1;
|
|
if (indsped.items() > 0) // La move_last da errore fatale su recordset vuoti!
|
|
{
|
|
indsped.move_last();
|
|
codind += indsped.get("CODIND").as_int();
|
|
}
|
|
return codind;
|
|
}
|
|
|
|
bool TPack_indsped::trasferisci()
|
|
{
|
|
const char* const query =
|
|
"SELECT * FROM Customers_Suppliers "
|
|
"WHERE (FlagCustSupp='D' OR FlagCustSupp='N') AND (StatusFlag=1 OR StatusFlag=2 OR StatusFlag=3)";
|
|
TRecordset& recset = create_recordset(query);
|
|
|
|
TConfig& ini = config();
|
|
TString_array lista_indsped;
|
|
ini.list_variables(lista_indsped, true, "INDSPED", true);
|
|
|
|
TLocalisamfile clifo(LF_CLIFO);
|
|
TLocalisamfile indsped(LF_INDSP);
|
|
TRectype& rec_clifo = clifo.curr();
|
|
TRectype& rec_indsped = indsped.curr();
|
|
TString str;
|
|
|
|
TRecord_cache cache_comuni(LF_COMUNI, 2);
|
|
|
|
TPack_iterator pi(this);
|
|
while (++pi)
|
|
{
|
|
const TString& custsuppcode = get_str("CustSuppCode");
|
|
const int statusflag = recset.get("StatusFlag").as_int();
|
|
const char flagcustsupp = get_str("FlagCustSupp")[0];
|
|
const char tipocf = flagcustsupp == 'D' ? 'C': 'F'; // D -> C N -> F
|
|
// in codcontab di una destinazione diversa ci mettiamo codcf|codind per ritrovarlo subito su indsped
|
|
TToken_string codcontab = get_str("CodContab");
|
|
codcontab.trim();
|
|
long codcf = -1;
|
|
int codind = 0;
|
|
if (codcontab.full())
|
|
{
|
|
codcf = codcontab.get_long(0);
|
|
codind = codcontab.get_int();
|
|
}
|
|
|
|
bool needs_creation = codcf <= 0; // Devo creare un nuovo indirizzo?
|
|
bool good = true; // Suppongo che il cliente esista in campo
|
|
if (codcf > 0) // Il campo cliente e' gia' stato inserito in CodContab?
|
|
{
|
|
rec_clifo.zero();
|
|
rec_clifo.put(CLI_TIPOCF, tipocf);
|
|
rec_clifo.put(CLI_CODCF, codcf);
|
|
good = clifo.read() == NOERR;
|
|
if (good)
|
|
{
|
|
rec_indsped.zero();
|
|
rec_indsped.put(IND_TIPOCF, tipocf);
|
|
rec_indsped.put(IND_CODCF, codcf);
|
|
rec_indsped.put(IND_CODIND, codind);
|
|
needs_creation = indsped.read() != NOERR;
|
|
}
|
|
else
|
|
{
|
|
// custsupprefcode e' il cliente/fornitore a cui si riferisce l'indirizzo di spedizione
|
|
const char* custsupprefcode = get_str("CustSuppRefCode");
|
|
str.format(FR("Non esiste il %s %d corrispondente a %s"),
|
|
tipocf == 'C' ? TR("cliente") : TR("fornitore"), codcf, custsupprefcode);
|
|
log(str, 1);
|
|
}
|
|
}
|
|
|
|
if (needs_creation && statusflag != 3 && good)
|
|
{
|
|
// inserisco indirizzo di spedizione
|
|
char tipo = ' ';
|
|
if (get_clifo(tipo, codcf))
|
|
{
|
|
codind = get_next_key(tipocf, codcf);
|
|
rec_indsped.zero();
|
|
rec_indsped.put(IND_TIPOCF, tipocf);
|
|
rec_indsped.put(IND_CODCF, codcf);
|
|
rec_indsped.put(IND_CODIND, codind);
|
|
codcontab.cut(0);
|
|
codcontab.add(codcf);
|
|
codcontab.add(codind);
|
|
good = test_write(indsped);
|
|
}
|
|
else
|
|
good = false;
|
|
}
|
|
if (good)
|
|
{
|
|
if (statusflag == 3)
|
|
{
|
|
// NON cancellare il cliente in quanto potrebbe avere dei movimenti associati
|
|
//const int flag = cancella_clifo(clifo);
|
|
//update_statusflag_codcontab(custsuppcode, flag, "0");
|
|
}
|
|
else
|
|
{
|
|
// aggiormento comune
|
|
TString80 dencom = get_str("Locality");
|
|
dencom.trim(); dencom.upper();
|
|
const TRectype& reccom = cache_comuni.get(dencom);
|
|
TString256 str = reccom.get(COM_DENCOM);
|
|
str.trim(); str.upper();
|
|
if (str == dencom)
|
|
rec_indsped.put(IND_COM, reccom.get(COM_COM));
|
|
else
|
|
{
|
|
rec_indsped.zero(IND_COM);
|
|
rec_indsped.put(IND_LOCALITA, dencom);
|
|
|
|
log("");
|
|
str.format(FR("Destinazioni diverse %ld: comune non trovato %s"), codcf, (const char*) dencom);
|
|
log(str);
|
|
}
|
|
aggiorna_record(indsped, lista_indsped);
|
|
// in codcontab ci metto codcf|indsped
|
|
update_statusflag_codcontab(custsuppcode, 0, codcontab);
|
|
}
|
|
}
|
|
}
|
|
return write_enabled();
|
|
}
|
|
|