root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

corretta generazione storico da magazzino

Browse Source 
git-svn-id: svn://10.65.10.50/branches/R_10_00@22711 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 2012-07-19 12:28:28 +00:00
parent f72e3cbb07
commit cdc3f0958d
1 changed files with 285 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

578
ha/ha3800.cpp
View File

@ -66,300 +66,257 @@ TInserimento_storico_mask::TInserimento_storico_mask() : TAutomask("ha3800a")
////////////////////////////////////////////// //////////////////////////////////////////////
// Applicazione // Applicazione
////////////////////////////////////////////// //////////////////////////////////////////////
class TInserimento_storico : public TSkeleton_application class TInserimento_storico : public TSkeleton_application
{ {
// bool ultimo_cliente_aperto(TRecordset& history, long& clifo, long& indsped) const;
protected: protected:
void elabora_aperture(const TMask& mask, TLog_report& log); void elabora_chiusura(const TRecordset& mov_recset, TLog_report& log) const;
void elabora_chiusure(const TMask& mask, TLog_report& log); void elabora_apertura(const TRecordset& mov_recset, TLog_report& log) const;
void elabora(const TMask& mask); void elabora(const TMask& mask);
public: public:
void main_loop(); virtual void main_loop();
}; };
void TInserimento_storico::elabora_aperture(const TMask& mask, TLog_report& log) void TInserimento_storico::elabora_apertura(const TRecordset& mov_recset, TLog_report& log) const
{ {
//1) legge la configurazione per avere i parametri di query const TString8 causape = mov_recset.get(MOVMAG_CODCAUS).as_string();
TConfig config(CONFIG_DITTA, "ha");
const TString4 tipo2elab = config.get("Doc2ElabTip");
const TString4 stato2elab = config.get("Doc2ElabSta");
const TString8 caus_open = config.get("CausOpen");
// const TString8 caus_close = config.get("CausClose"); Ignorata dal 19-06-2012
//..e anche la maschera //comunque deve scrivere il cliente e la data perchè è un'apertura quindi la macchina è assegnata..
const long anno = mask.get_long(F_ANNO); //..al cliente con questo documento
const TDate da_data = mask.get_date(F_DADATA); const long doc_ndoc = mov_recset.get(MOVMAG_NUMREG).as_int();
const TDate a_data = mask.get_date(F_ADATA); const TDate doc_datadoc = mov_recset.get(MOVMAG_DATAREG).as_date();
const long doc_anno = doc_datadoc.year();
const long doc_clifo = mov_recset.get(MOVMAG_CODCF).as_int();
const long indsped = mov_recset.get(MOVMAG_CODINDSP).as_int();
//2) raccatta le numerazioni valide in base al tipo di documento in configurazione TToken_string key; key << mov_recset.get(MOVMAG_NUMREG);
TString_array num_doc; TRecord_array rmovmag(key, LF_RMOVMAG);
const int num_del_tipo = numerazioni_documenti(num_doc, tipo2elab);
#ifdef DBG for (int r = 1; r > 0 && r <= rmovmag.last_row(); r++)
ofstream numerazioni("c:/temp/numerazioni.txt", ios::app);
#endif
//3) giro su ogni numerazione per trovare le righe che servono
for (int n = 0; n < num_del_tipo; n++)
{ {
const TString4 codnum = num_doc.row(n); const TRectype& row = rmovmag.row(r);
#ifdef DBG
if (codnum == "B009")
int cazzone = 1;
#endif
TString query; //controllo della causale
query << "USE RDOC KEY 2"; const TString8 caus = row.get(RMOVMAG_CODCAUS);
query << "\nSELECT (DOC.STATO=#STATO)&&(BETWEEN(DOC.DATADOC,#DADATA,#ADATA))"; //se la causale non è sulla riga controlla quella di testata
query << "\nJOIN DOC INTO PROVV==PROVV ANNO==ANNO CODNUM==CODNUM NDOC==NDOC"; if (caus.full() && caus != causape)
query << "\nFROM CODNUM=#CODNUM ANNO=#ANNO PROVV=D"; continue;
query << "\nTO CODNUM=#CODNUM ANNO=#ANNO PROVV=D";
TISAM_recordset rdoc_recset(query); //3_A) tabella &ATT
rdoc_recset.set_var("#STATO", stato2elab); //poichè documento apertura deve controllare se per caso la macchina è nuova
rdoc_recset.set_var("#DADATA", da_data); //dati del record corrente (vale anche per le chiusure in quanto esistono macchine..
rdoc_recset.set_var("#ADATA", a_data); //..di antica data senza registrazioni!)
rdoc_recset.set_var("#CODNUM", codnum); const TString80 codart = row.get(RMOVMAG_CODART);
rdoc_recset.set_var("#ANNO", anno); const TString16 matricola = row.get(RMOVMAG_LIVGIAC);
const long rdoc_recset_items = rdoc_recset.items(); TModule_table tab_att("&ATT");
tab_att.put("CODTAB", matricola);
//date tutte le righedoc che soddisfano la query, deve tener conto solo di quelle.. const int err = tab_att.read();
//..non ancora registrate in precedenza e che, soprattutto, abbiano una causale sensata //se l'attrezzatura (intesa come codart+matricola) non esiste -> la deve aggiungere (sara' sicuramente la prima)...
for (bool ok = rdoc_recset.move_first(); ok; ok = rdoc_recset.move_next()) //..per quanto riguarda il progressivo)
if (err != NOERR)
{ {
//controllo della causale TString msg;
TString8 caus = rdoc_recset.get(RDOC_CAUSMAG).as_string(); msg << "Articolo " << codart << " senza matricola sul movimento "
//se la causale non è sulla riga controlla quella di testata << mov_recset.get(MOVMAG_NUMREG) << " del " << mov_recset.get(MOVMAG_DATAREG);
if (caus.empty()) log.log(1, msg);
caus = rdoc_recset.get("33."DOC_CAUSMAG).as_string(); continue;
}
//solo le righdoc con causale sensata proseguono //se la macchina viene assegnata ad un cliente (movimento di apertura) -> va messo il clifo..
if (caus == caus_open /*|| caus == caus_close*/) tab_att.put("I0", doc_clifo);
tab_att.put("I1", indsped);
tab_att.put("D0", doc_datadoc);
tab_att.write_rewrite();
//3_B) tabella &HIS
//controllo sul ndoc se per caso questa riga l'ha già importata, senno' deve aggiungere un record
//query sulla storia di questa macchina
TString query_his;
query_his << "USE &HIS";
query_his << "\nFROM CODTAB=#CODTAB";
query_his << "\nTO CODTAB=#CODTAB";
TISAM_recordset recset_his(query_his);
recset_his.set_var("#CODTAB", matricola);
const long recset_his_items = recset_his.items();
TModule_table tab_his("&HIS");
int n_line_to_update = 0;
//cerca se la riga esiste già nello storico e va solo aggiornata
for (bool ok = recset_his.move_last(); ok; ok = recset_his.move_prev())
{
const long curr_anno = recset_his.get("S4[1,4]").as_int();
if (curr_anno == doc_anno)
{ {
//bool di scrimage long curr_ndoc = recset_his.get("S4[9,15]").as_int();
const bool bopen = caus == caus_open; if (curr_ndoc == doc_ndoc)
//3_A) tabella &ATT
//poichè documento apertura deve controllare se per caso la macchina è nuova
//dati del record corrente (vale anche per le chiusure in quanto esistono macchine..
//..di antica data senza registrazioni!)
const long doc_anno = rdoc_recset.get(RDOC_ANNO).as_int();
const TString4 doc_codnum = rdoc_recset.get(RDOC_CODNUM).as_string();
const long doc_ndoc = rdoc_recset.get(RDOC_NDOC).as_int();
const TString& codart = rdoc_recset.get(RDOC_CODART).as_string();
const TString& matricola = rdoc_recset.get(RDOC_LIVELLO).as_string();
TModule_table tab_att("&ATT");
tab_att.put("CODTAB", matricola);
const int err = tab_att.read();
//se l'attrezzatura (intesa come codart+matricola) non esiste -> la deve aggiungere (sara' sicuramente la prima)...
//..per quanto riguarda il progressivo)
if (err != NOERR)
{ {
TString msg; n_line_to_update = recset_his.get("CODTAB[9,13]").as_int();
msg << "Articolo " << codart << " senza matricola sul documento " << doc_codnum << " " << doc_anno << "/" << doc_ndoc; break;
log.log(1, msg);
continue;
} }
//comunque deve scrivere il cliente e la data perchè è un'apertura quindi la macchina è assegnata.. }
//..al cliente con questo documento } //for (bool ok = recset_his.move...
const long doc_clifo = rdoc_recset.get("33.CODCF").as_int();
const TDate doc_datadoc = rdoc_recset.get("33.DATADOC").as_date();
const int indsped = rdoc_recset.get("33.CODINDSP").as_int();
//se la macchina viene assegnata ad un cliente (movimento di apertura) -> va messo il clifo.. TString80 new_codtab;
if (bopen) //se la riga non c'era -> va aggiunta
tab_att.put("I0", doc_clifo); if (n_line_to_update <= 0)
else //..senno' torna alla casa madre e sparisce il clifo {
tab_att.put("I0", 0L); n_line_to_update = recset_his_items + 1;
tab_att.put("D0", doc_datadoc); //adesso ha il numero di riga da aggiornare e crea il nuovo record
tab_att.put("I1", indsped); new_codtab.format("%08s%05d", (const char*)matricola, n_line_to_update);
tab_his.put("CODTAB", new_codtab);
tab_his.write();
new_codtab.cut(0);
}
tab_att.write_rewrite(); //rimette il codtab per riposizionarsi sul record corretto
new_codtab.format("%08s%05d", (const char*)matricola, n_line_to_update);
tab_his.put("CODTAB", new_codtab);
//3_B) tabella &HIS //ed aggiunge tutti i campi
//controllo sul ndoc se per caso questa riga l'ha già importata, senno' deve aggiungere un record const TString& descr = mov_recset.get(MOVMAG_DESCR).as_string();
//query sulla storia di questa macchina tab_his.put("S0", descr);
TString query_his; //tab_his.put("S3", articolo_collegato);
query_his << "USE &HIS";
query_his << "\nFROM CODTAB=#CODTAB";
query_his << "\nTO CODTAB=#CODTAB";
TISAM_recordset recset_his(query_his);
recset_his.set_var("#CODTAB", matricola);
const long recset_his_items = recset_his.items(); TString16 str_key_doc;
str_key_doc.format("%4d%4s%7d", doc_anno, (const char*)causape, doc_ndoc);
tab_his.put("S4", str_key_doc);
tab_his.put("S6", row.get(RMOVMAG_UM));
const TString& codmag = row.get(RMOVMAG_CODMAG);
TString4 s7; //s7[1,1]=tipo s7[2,4]=codmag
s7 << "C" << codmag;
tab_his.put("S7", s7);
tab_his.put("I0", doc_clifo);
tab_his.put("I1", indsped);
tab_his.put("D0", doc_datadoc);
const real qta = row.get(RMOVMAG_QUANT);
tab_his.put("R0", qta);
const real prezzo = row.get(RMOVMAG_PREZZO);
const real importo = qta * prezzo;
tab_his.put("R1", importo);
tab_his.put("B0", false);
TModule_table tab_his("&HIS"); const int written = tab_his.write_rewrite();
int n_line_to_update = 0; //segna sul log la riga aggiunta alla tabella storico &HIS
if (written == NOERR)
//cerca se la riga esiste già nello storico e va solo aggiornata {
for (bool ok = recset_his.move_last(); ok; ok = recset_his.move_prev()) TString msg;
{ msg.format("%4d-%4s/%7d--%s--%s--%6d",
long curr_anno; doc_anno, (const char*)causape, doc_ndoc,
if (bopen) (const char*)codart, (const char*)matricola, doc_clifo);
curr_anno = recset_his.get("S4[1,4]").as_int(); log.log(0, msg);
else }
curr_anno = recset_his.get("S5[1,4]").as_int(); }
if (curr_anno == doc_anno)
{
TString4 curr_codnum;
if (bopen)
curr_codnum = recset_his.get("S4[5,8]").as_string();
else
curr_codnum = recset_his.get("S5[5,8]").as_string();
if (curr_codnum == doc_codnum)
{
long curr_ndoc;
if (bopen)
curr_ndoc = recset_his.get("S4[9,15]").as_int();
else
curr_ndoc = recset_his.get("S5[9,15]").as_int();
if (curr_ndoc == doc_ndoc)
{
n_line_to_update = recset_his.get("CODTAB[9,13]").as_int();
break;
}
}
}
} //for (bool ok = recset_his.move...
TString80 new_codtab;
//se la riga non c'era -> va aggiunta
if (n_line_to_update == 0)
{
n_line_to_update = recset_his_items + 1;
//adesso ha il numero di riga da aggiornare e crea il nuovo record
new_codtab.format("%08s%05d", (const char*)matricola, n_line_to_update);
tab_his.put("CODTAB", new_codtab);
tab_his.write();
new_codtab.cut(0);
}
//rimette il codtab per riposizionarsi sul record corretto
new_codtab.format("%08s%05d", (const char*)matricola, n_line_to_update);
tab_his.put("CODTAB", new_codtab);
//ed aggiunge tutti i campi
const TString& descr = rdoc_recset.get(RDOC_DESCR).as_string();
tab_his.put("S0", descr);
//tab_his.put("S3", articolo_collegato);
TString16 str_key_doc;
str_key_doc.format("%4d%4s%7d", doc_anno, (const char*)doc_codnum, doc_ndoc);
if (bopen)
tab_his.put("S4", str_key_doc);
else
tab_his.put("S5", str_key_doc);
tab_his.put("S6", rdoc_recset.get(RDOC_UMQTA).as_string());
const TString& codmag = rdoc_recset.get(RDOC_CODMAG).as_string();
TString4 s7; //s7[1,1]=tipo s7[2,4]=codmag
s7 << "C" << codmag;
tab_his.put("S7", s7);
tab_his.put("I0", doc_clifo);
tab_his.put("I1", indsped);
tab_his.put("D0", doc_datadoc);
const real qta = rdoc_recset.get(RDOC_QTA).as_real();
tab_his.put("R0", qta);
const real prezzo = rdoc_recset.get(RDOC_PREZZO).as_real();
const real importo = qta * prezzo;
tab_his.put("R1", importo);
tab_his.put("B0", !bopen); //se è il documento di chiusura va segnalato
const int written = tab_his.write_rewrite();
//segna sul log la riga aggiunta alla tabella storico &HIS
if (written == NOERR)
{
TString msg;
msg.format("%4d-%4s/%7d--%s--%s--%6d",
doc_anno, (const char*)doc_codnum, doc_ndoc,
(const char*)codart, (const char*)matricola, doc_clifo);
log.log(0, msg);
}
} //if (caus==caus_open || ..
} //for (bool ok = rdoc_recset.move_first()...
} //for (int n = 0; n < num_del_tipo...
} }
void TInserimento_storico::elabora_chiusure(const TMask& mask, TLog_report& log) /* Obsoleto
bool TInserimento_storico::ultimo_cliente_aperto(TRecordset& recset, long& clifo, long& indsped) const
{ {
TConfig config(CONFIG_DITTA, "ha"); clifo = indsped = 0;
const TString8 caus_close = config.get("CausClose");
//..e anche la maschera TString_array aperture;
const long anno = mask.get_long(F_ANNO); TString_array chiusure;
const TDate da_data = mask.get_date(F_DADATA); TString80 tok;
const TDate a_data = mask.get_date(F_ADATA); long cli, ind, dat;
TString query; for (bool ok = recset.move_first(); ok; ok = recset.move_next())
query << "USE MOVMAG KEY 3 SELECT CODCAUS=#CODCAUS";
query << "\nFROM DATAREG=#DADATA";
query << "\nTO DATAREG=#ADATA";
TISAM_recordset mov_recset(query);
mov_recset.set_var("#CODCAUS", caus_close);
mov_recset.set_var("#DADATA", da_data);
mov_recset.set_var("#ADATA", a_data);
for (bool ok = mov_recset.move_first(); ok; ok = mov_recset.move_next())
{ {
const TDate mov_datareg = mov_recset.get(MOVMAG_DATAREG).as_date(); const bool chiusura = recset.get("B0").as_bool();
const long mov_nreg = mov_recset.get(MOVMAG_NUMREG).as_int(); cli = recset.get("I0").as_int();
ind = recset.get("I1").as_int();
dat = recset.get("D0").as_date().date2ansi();
tok.format("%ld|%ld|%ld", cli, ind, dat);
if (chiusura)
chiusure.add(tok);
else
aperture.add(tok);
}
TToken_string key; key << mov_recset.get(MOVMAG_NUMREG); FOR_EACH_ARRAY_ROW(aperture, a, ape)
TRecord_array rmovmag(key, LF_RMOVMAG); {
for (int r = 1; r > 0 && r <= rmovmag.last_row(); r++) ape->get(0, cli);
ape->get(1, ind);
ape->get(2, dat);
bool found = false;
FOR_EACH_ARRAY_ROW(chiusure, c, chi)
{ {
const TRectype& row = rmovmag.row(r); long c, i, d;
//controllo della causale chi->get(0, c);
const TString& caus = row.get(RMOVMAG_CODCAUS); chi->get(1, i);
if (caus.full() && caus != caus_close) chi->get(2, d);
continue; if (cli == c && ind == i && d >= dat)
const TString80 codart = row.get(RMOVMAG_CODART);
const TString16 matricola = row.get(RMOVMAG_LIVGIAC);
TModule_table tab_att("&ATT");
tab_att.put("CODTAB", matricola);
const int err = tab_att.read();
if (err != NOERR)
{ {
TString msg; found = true;
msg << "Articolo " << codart << " senza matricola sul movimento " << mov_recset.get(MOVMAG_NUMREG) << " del " << mov_recset.get(MOVMAG_DATAREG); break;
log.log(1, msg);
continue;
} }
}
if (!found)
{
clifo = cli;
indsped = ind;
break;
}
}
const long clifo = tab_att.get_long("I0"); return clifo > 0;
const int indsped = tab_att.get_int("I1"); }
if (clifo <= 0) */
{
TString msg;
msg << "Matricola " << matricola << " senza cliente: probabilmente l'articolo " << codart << " è già rientrato";
log.log(1, msg);
continue;
}
tab_att.put("I0", ""); // Azzera cliente void TInserimento_storico::elabora_chiusura(const TRecordset& mov_recset, TLog_report& log) const
tab_att.put("I1", ""); // Azzera indsped {
tab_att.put("D0", mov_datareg); const TDate mov_datareg = mov_recset.get(MOVMAG_DATAREG).as_date();
tab_att.write_rewrite(); const int anno = mov_datareg.year();
const long mov_nreg = mov_recset.get(MOVMAG_NUMREG).as_int();
const TString8 caus_close = mov_recset.get(MOVMAG_CODCAUS).as_string();
TString query_his; TToken_string key; key << mov_recset.get(MOVMAG_NUMREG);
query_his << "USE &HIS"; TRecord_array rmovmag(key, LF_RMOVMAG);
query_his << "\nFROM CODTAB=#CODTAB"; for (int r = 1; r > 0 && r <= rmovmag.last_row(); r++)
query_his << "\nTO CODTAB=#CODTAB"; {
TISAM_recordset recset_his(query_his); const TRectype& row = rmovmag.row(r);
recset_his.set_var("#CODTAB", matricola); //controllo della causale di riga se diversa dalla testata
const TString& caus = row.get(RMOVMAG_CODCAUS);
if (caus.full() && caus != caus_close)
continue;
const long recset_his_items = recset_his.items(); const TString80 codart = row.get(RMOVMAG_CODART);
const TString16 matricola = row.get(RMOVMAG_LIVGIAC);
TModule_table tab_his("&HIS"); TModule_table tab_att("&ATT");
int n_line_to_update = 0; tab_att.put("CODTAB", matricola);
const int err = tab_att.read();
if (err != NOERR)
{
TString msg;
msg << "Articolo " << codart << " senza matricola sul movimento "
<< mov_nreg << " del " << mov_datareg;
log.log(1, msg);
continue;
}
long clifo = 0, indsped = 0;
if (tab_att.get_date("D0") <= mov_datareg)
{
clifo = tab_att.get_long("I0");
indsped = tab_att.get_int("I1");
}
TString query_his;
query_his << "USE &HIS SELECT S7[1,1]='C'";
query_his << "\nFROM CODTAB=#CODTAB";
query_his << "\nTO CODTAB=#CODTAB";
TISAM_recordset recset_his(query_his);
recset_his.set_var("#CODTAB", matricola);
int n_line_to_update = 0;
const long recset_his_items = recset_his.items();
if (recset_his_items > 0)
{
//cerca se la riga esiste già nello storico e va solo aggiornata //cerca se la riga esiste già nello storico e va solo aggiornata
for (bool ok = recset_his.move_last(); ok; ok = recset_his.move_prev()) for (bool ok = recset_his.move_last(); ok; ok = recset_his.move_prev())
{ {
@ -368,73 +325,98 @@ void TInserimento_storico::elabora_chiusure(const TMask& mask, TLog_report& log)
if (curr_anno == anno && curr_nreg == mov_nreg) if (curr_anno == anno && curr_nreg == mov_nreg)
{ {
n_line_to_update = recset_his.get("CODTAB[9,13]").as_int(); n_line_to_update = recset_his.get("CODTAB[9,13]").as_int();
clifo = recset_his.get("I0").as_int();
indsped = recset_his.get("I1").as_int();
break; break;
} }
} //for (bool ok = recset_his.move... } //for (bool ok = recset_his.move...
TString80 new_codtab;
//se la riga non c'era -> va aggiunta //se la riga non c'era -> va aggiunta
if (n_line_to_update == 0) }
{ if (n_line_to_update <= 0)
n_line_to_update = recset_his_items + 1; n_line_to_update = recset_his_items + 1;
//adesso ha il numero di riga da aggiornare e crea il nuovo record TModule_table tab_his("&HIS");
new_codtab.format("%08s%05d", (const char*)matricola, n_line_to_update);
tab_his.put("CODTAB", new_codtab);
tab_his.write();
}
//rimette il codtab per riposizionarsi sul record corretto TString16 new_codtab;
new_codtab.format("%08s%05d", (const char*)matricola, n_line_to_update); new_codtab.format("%08s%05d", (const char*)matricola, n_line_to_update);
tab_his.put("CODTAB", new_codtab); tab_his.put("CODTAB", new_codtab);
//ed aggiunge tutti i campi //ed aggiunge tutti i campi
const TString& descr = mov_recset.get(MOVMAG_DESCR).as_string(); const TString& descr = mov_recset.get(MOVMAG_DESCR).as_string();
tab_his.put("S0", descr); tab_his.put("S0", descr);
TString16 str_key_doc; TString16 str_key_doc;
str_key_doc.format("%4d%4s%7d", anno, "", mov_nreg); str_key_doc.format("%4d%4s%7d", anno, (const char*)caus_close, mov_nreg);
tab_his.put("S5", str_key_doc); tab_his.put("S5", str_key_doc);
tab_his.put("S6", row.get(RMOVMAG_UM)); tab_his.put("S6", row.get(RMOVMAG_UM));
const TString& codmag = row.get(RMOVMAG_CODMAG); const TString& codmag = row.get(RMOVMAG_CODMAG);
TString4 s7; //s7[1,1]=tipo s7[2,4]=codmag TString4 s7; //s7[1,1]=tipo s7[2,4]=codmag
s7 << "C" << codmag; s7 << "C" << codmag;
tab_his.put("S7", s7); tab_his.put("S7", s7);
tab_his.put("I0", clifo); tab_his.put("I0", clifo);
tab_his.put("I1", indsped); tab_his.put("I1", indsped);
tab_his.put("D0", mov_datareg); tab_his.put("D0", mov_datareg);
const real qta = row.get(RMOVMAG_QUANT); const real qta = row.get(RMOVMAG_QUANT);
tab_his.put("R0", qta); tab_his.put("R0", qta);
const real prezzo = row.get(RMOVMAG_PREZZO); const real prezzo = row.get(RMOVMAG_PREZZO);
const real importo = qta * prezzo; const real importo = qta * prezzo;
tab_his.put("R1", importo); tab_his.put("R1", importo);
tab_his.put("B0", true); // Chiusura tab_his.put("B0", true); // Chiusura
const int written = tab_his.write_rewrite(); const int written = tab_his.write_rewrite();
//segna sul log la riga aggiunta alla tabella storico &HIS //segna sul log la riga aggiunta alla tabella storico &HIS
if (written == NOERR) if (written == NOERR)
{ {
TString msg; TString msg;
msg.format("%4d-%4s/%7d--%s--%s--%6d", msg.format("%4d-%4s/%7d--%s--%s--%6d",
anno, (const char*)caus_close, mov_nreg, anno, (const char*)caus_close, mov_nreg,
(const char*)codart, (const char*)matricola, clifo); (const char*)codart, (const char*)matricola, clifo);
log.log(0, msg); log.log(0, msg);
} }
if (tab_att.get_long("I0") == clifo && tab_att.get_long("I1") == indsped && tab_att.get_date("D0") <= mov_datareg)
{
tab_att.put("I0", ""); // Azzera cliente
tab_att.put("I1", ""); // Azzera indsped
tab_att.put("D0", mov_datareg);
tab_att.write_rewrite();
} }
} }
} }
void TInserimento_storico::elabora(const TMask& mask) void TInserimento_storico::elabora(const TMask& mask)
{ {
//vogliono pure il log! che rompicazzo TConfig config(CONFIG_DITTA, "ha");
const TString8 caus_open = config.get("CausOpen");
const TString8 caus_close = config.get("CausClose");
// Vogliono pure il log!
TLog_report log(TR("Righe storico aggiunte")); TLog_report log(TR("Righe storico aggiunte"));
log.kill_duplicates(); log.kill_duplicates();
log.log(0, ""); log.log(0, "");
log.log(0, HR("Anno-Num.-Ndoc--Articolo --Matricola --Cliente")); log.log(0, HR("Anno-Num.-Ndoc--Articolo --Matricola --Cliente"));
log.log(0, ""); log.log(0, "");
elabora_aperture(mask, log); const long anno = mask.get_long(F_ANNO);
elabora_chiusure(mask, log); const TDate da_data = mask.get_date(F_DADATA);
const TDate a_data = mask.get_date(F_ADATA);
TString query;
query << "USE MOVMAG KEY 3"
<< "\nFROM DATAREG=#DADATA"
<< "\nTO DATAREG=#ADATA";
TISAM_recordset mov_recset(query);
mov_recset.set_var("#DADATA", da_data);
mov_recset.set_var("#ADATA", a_data);
for (bool ok = mov_recset.move_first(); ok; ok = mov_recset.move_next())
{
const TString& codcaus = mov_recset.get(MOVMAG_CODCAUS).as_string();
if (codcaus == caus_open)
elabora_apertura(mov_recset, log); else
if (codcaus == caus_close)
elabora_chiusura(mov_recset, log);
}
log.preview(); log.preview();
} }