root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ha/ha3800.cpp
guy 077cb844e9 Patch level : 10.0 
Files correlati     : ha0 ha3 ha3900a.msk hatbatt.msk
Ricompilazione Demo : [ ]
Commento            :
Correzioni varie su gestione attrezzature


git-svn-id: svn://10.65.10.50/branches/R_10_00@22587 c028cbd2-c16b-5b4b-a496-9718f37d4682
2012-02-24 14:57:04 +00:00

307 lines
10 KiB
C++
Executable File
Raw Blame History

#include <applicat.h>
#include <automask.h>
#include <config.h>
#include <recarray.h>
#include <reputils.h>
#include <tabmod.h>
#include <doc.h>
#include <rdoc.h>
#include <../ve/velib.h>
#include "halib.h"
#include "ha3800a.h"
//////////////////////////////////////////////
// Maschera
//////////////////////////////////////////////
class TInserimento_storico_mask : public TAutomask
{
protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
TInserimento_storico_mask();
};
bool TInserimento_storico_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
switch (o.dlg())
{
case F_ANNO:
if (e == fe_modify)
{
//cambiando l'anno propone in automatico il dadata adata
const int anno = o.get_long();
const TDate ini_anno(1, 1, anno);
set(F_DADATA, ini_anno);
const TDate fine_anno(31, 12, anno);
set(F_ADATA, fine_anno);
}
break;
case F_DADATA:
case F_ADATA:
if (e == fe_modify || e == fe_close)
{
//controlla che le date appartengano all'anno selezionato (e impedisce di lasciare date vuote!!!)
const TDate data = get_date(o.dlg());
const int anno = get_int(F_ANNO);
if (data.year() != anno)
return error_box("La data deve appartenere all'anno selezionato!");
}
break;
default:
break;
}
return true;
}
TInserimento_storico_mask::TInserimento_storico_mask() : TAutomask("ha3800a")
{
}
//////////////////////////////////////////////
// Applicazione
//////////////////////////////////////////////
class TInserimento_storico : public TSkeleton_application
{
protected:
void elabora(const TMask& mask);
public:
void main_loop();
};
void TInserimento_storico::elabora(const TMask& mask)
{
//1) legge la configurazione per avere i parametri di query
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");
//..e anche la maschera
const long anno = mask.get_long(F_ANNO);
const TDate da_data = mask.get_date(F_DADATA);
const TDate a_data = mask.get_date(F_ADATA);
//2) raccatta le numerazioni valide in base al tipo di documento in configurazione
TString_array num_doc;
const int num_del_tipo = numerazioni_documenti(num_doc, tipo2elab);
#ifdef DBG
ofstream numerazioni("c:/temp/numerazioni.txt", ios::app);
#endif
//vogliono pure il log! che rompicazzo
TLog_report log("Righe storico aggiunte");
log.kill_duplicates();
log.log(0, "");
log.log(0, "Anno-Num.-Ndoc--Art. Progres.--Matricola --Cliente");
log.log(0, "");
//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);
#ifdef DBG
if (codnum == "B009")
int cazzone = 1;
#endif
TString query;
query << "USE RDOC KEY 2";
query << "\nSELECT (DOC.STATO=#STATO)&&(BETWEEN(DOC.DATADOC,#DADATA,#ADATA))";
query << "\nJOIN DOC INTO PROVV==PROVV ANNO==ANNO CODNUM==CODNUM NDOC==NDOC";
query << "\nFROM CODNUM=#CODNUM ANNO=#ANNO PROVV=D";
query << "\nTO CODNUM=#CODNUM ANNO=#ANNO PROVV=D";
TISAM_recordset rdoc_recset(query);
rdoc_recset.set_var("#STATO", stato2elab);
rdoc_recset.set_var("#DADATA", da_data);
rdoc_recset.set_var("#ADATA", a_data);
rdoc_recset.set_var("#CODNUM", codnum);
rdoc_recset.set_var("#ANNO", anno);
const long rdoc_recset_items = rdoc_recset.items();
//date tutte le righedoc che soddisfano la query, deve tener conto solo di quelle..
//..non ancora registrate in precedenza e che, soprattutto, abbiano una causale sensata
for (bool ok = rdoc_recset.move_first(); ok; ok = rdoc_recset.move_next())
{
//controllo della causale
TString8 caus = rdoc_recset.get(RDOC_CAUSMAG).as_string();
//se la causale non <20> sulla riga controlla quella di testata
if (caus.empty())
caus = rdoc_recset.get(DOC_CAUSMAG).as_string();
//solo le righdoc con causale sensata proseguono
if (caus == caus_open || caus == caus_close)
{
//bool di scrimage
const bool bopen = caus == caus_open;
//3_A) tabella &ATT
//poich<63> documento apertura deve controllare se per caso la macchina <20> 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;
msg << "Articolo " << codart << " senza matricola sul documento " << doc_codnum << " " << doc_anno << "/" << doc_ndoc;
log.log(1, msg);
continue;
}
//comunque deve scrivere il cliente e la data perch<63> <20> un'apertura quindi la macchina <20> assegnata..
//..al cliente con questo documento
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..
if (bopen)
tab_att.put("I0", doc_clifo);
else //..senno' torna alla casa madre e sparisce il clifo
tab_att.put("I0", 0L);
tab_att.put("D0", doc_datadoc);
tab_att.put("I1", indsped);
tab_att.write_rewrite();
//3_B) tabella &HIS
//controllo sul ndoc se per caso questa riga l'ha gi<67> 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<67> nello storico e va solo aggiornata
for (bool ok = recset_his.move_last(); ok; ok = recset_his.move_prev())
{
long curr_anno;
if (bopen)
curr_anno = recset_his.get("S4[1,4]").as_int();
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[13,17]").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);
//se <20> il documento di chiusura fa segnalato
if (!bopen)
tab_his.put("B0", true);
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*)new_codtab, (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...
log.preview();
}
void TInserimento_storico::main_loop()
{
TInserimento_storico_mask mask;
while (mask.run() == K_ENTER)
{
elabora(mask);
}
}
int ha3800(int argc, char* argv[])
{
TInserimento_storico app;
app.run(argc, argv, TR("Inserimento storico attrezzature"));
return 0;
}
Reference in New Issue View Git Blame Copy Permalink