root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ve/ve6200.cpp
alex e68afa141a correzione prima serie di errori 
git-svn-id: svn://10.65.10.50/trunk@2684 c028cbd2-c16b-5b4b-a496-9718f37d4682
1996-03-20 16:15:18 +00:00

1072 lines
43 KiB
C++
Executable File
Raw Blame History

// ve6200.cpp: modulo per la generazione dei documenti in modo BATCH.
#include <config.h>
#include <applicat.h>
#include <mask.h>
#include <maskfld.h>
#include <urldefid.h>
#include <utility.h>
#include <validate.h>
#include <progind.h>
#include <extcdecl.h>
#include <execp.h>
#include <lffiles.h>
#include <rectypes.h>
#include <isam.h>
#include <tabutil.h>
#include <date.h>
#include <checks.h>
#include <relation.h>
#include <sheet.h>
#include "ve6000.h"
#include "ve6retv.h" // valori di ritorno dalle varie funzioni
#include "ve6gen.h" // dichiarazione della classe base
#define TOKEN_QTA 5
#define TOKEN_QTAEVASA 7
#define TOKEN_QTA_DA_EVADERE 9
#define CAMPO_DAEVADERE 101
// è stata derivata la classe TSheet, perchè in alcuni documenti (es. Ordini)
// l'utente (tramite Ve6 -3, applicazione derivata dalla presente)
// può specificare di evadere una sola parte della quantità di merci indicate
// nella riga, così è stato necessario chiedere all'utente la quantità da evadere
// e riportarla nell'ultima colonna dello sheet: prima non era possibile, in quanto
// tale quantità non era un campo del record del file righedoc
/***********************************/
/**** Classe TInterattivo_sheet ****/
/***********************************/
// funzione quasi uguale a quella del TSheet
void TInterattivo_sheet::page_build(long first, byte rows)
{
TToken_string l(256);
*cursor() = (TRecnotype)first;
for (int r = 0; r < rows; r++, ++(*cursor()))
{
l.cut(0);
const int last = fields().last();
for (int i = 0; i <= last; i++)
{
const TRecfield* rf = (TRecfield*)fields().objptr(i);
const char* s = rf ? (const char*)*rf : "";
l.add(s);
}
// cambiamenti dalla routine TSheet::page_build :
// stabilisce per default che la quantità da evadere è quella non ancora evasa
const long qta = l.get_long(TOKEN_QTA);
const long qtaevasa = l.get_long(TOKEN_QTAEVASA);
// char buffer[16];
// _ltoa(qta-qtaevasa,buffer,10);
// TString daevadere(buffer);
real n(qta-qtaevasa);
l.add((const char *)n.string(11,3),TOKEN_QTA_DA_EVADERE);
set_row(l, r);
}
}
// quando l'utente fa doppio click o preme selezione, la on_key riceve un K_ENTER
// e qui apro una mascherina in cui chiedo la qta da evadere, CONFERMA o ANNULLA
bool TInterattivo_sheet::on_key (KEY k)
{
// K_ENTER e' E_MOUSE_DBL, mentre K_SPACE e' E_MOUSE_DOWN
if (k==K_ENTER)
{
// maschera per l'inserimento del valore
TMask m("Modifica", 1, 33, 7);
m.add_number (CAMPO_DAEVADERE, 0, "Quantità da evadere", 1, 3, 11);
m.add_button (DLG_OK, 0, "", 1, 4);
m.add_button (DLG_CANCEL, 0, "", 1, 5);
if (m.run()==K_ENTER)
{
// aggiorna il campo "quantita' evasa della riga selezionata
// TOKEN_QTAEVASA = posizione del campo QTAEVASA nel file ve0300b.dat,
// file gestito da Matteo e coincidente con i campi di righedoc,
// da lui utilizzato per lo spreadsheet delle righe nel suo Motore
long n = selected();
TToken_string temp = row(n); // riga selezionata
real qtaev (temp.get(TOKEN_QTAEVASA)); // valore di qtaevasa
real qtaspec (m.get(CAMPO_DAEVADERE)); // quantita' da evadere specificata
qtaev += real (qtaspec); // aggiorna il campo
real qtatot (temp.get(TOKEN_QTA)); // quantità totale della merce della riga
// controlla che qta_evasa + qta_da_evadere < qta_totale
if (qtaev>qtatot) error_box("Qtà da evadere superiore alla Qta non ancora evasa");
else {
// se corretto, setta la riga dello sheet
temp.add (qtaspec.string(), TOKEN_QTA_DA_EVADERE); // aggiunge il campo aggiornato nella stessa posizione
set_row (temp, (byte)n); // aggiorna lo sheet
}
check(n, TRUE);
}
return FALSE;
}
return TCursor_sheet::on_key(k);
}
/******************************/
/*** Classe TBatch_crea_doc ***/
/******************************/
// L'applicazione TBatch_crea_doc crea n documenti finali partendo da m doc. iniziali,
// individuati tramite una maschera attivata prima dell'elaborazione, ve6000a.uml, che chiede:
// Data elaborazione (del documento da creare)
// Da Codice cli/for a Codice cli/for (doc. originale)
// Da Data documento a Data documento (doc. originale)
// Da Codice agente a Codice agente (doc. originale)
// Da Codice zona a Codice zona (doc. originale)
// Ordinamento della sequenza dei documenti creati per ognuna delle voci precedenti
// Raggruppa più documenti sorgente in un solo doc. destinazione quando possibile
// Raggruppa articoli : quando possibile raggruppa più righe dello stesso articolo,
// accumulandone le quantità
// Stampa immediata (non gestito)
inline TBatch_crea_doc& app() { return (TBatch_crea_doc&) main_app(); } // per accedere ai data members della TElaborazioni dalla filterfunct()
bool TBatch_crea_doc::create()
{
// BATCH --> non interattivo; questo serve perché le routines di TBatch_crea_doc
// sono usate anche da TInterattivo_crea_doc, classe figlia di "
_interattivo = FALSE;
_crea_doc = TRUE;
dispatch_e_menu(BAR_ITEM(1)); // chiama il metodo menu
return TRUE;
}
bool TBatch_crea_doc::destroy()
{
return TRUE;
}
bool TBatch_crea_doc::menu(MENU_TAG)
{
int err;
// contengono i limiti Da - a per l'individuazione dei documenti originali
TRectype first(LF_DOC), last(LF_DOC);
if (errore_fatale (run_mask(first, last))) // richiede e setta i parametri, tramite maschera
return FALSE;
switch (_ordinamento) // in base all'ordinamento, lancia la procedura con diversi parametri
{
case CLIFO :
// crea documenti ordinando per cli./for.
err = per_cliente(first, last, "TIPOCF|CODCF");
break;
case AGENTE:
// crea documenti ordinando per agente
err = per_cliente(first, last, "TIPOCF|CODAG");
break;
case ZONA:
// crea documenti ordinando per zona
err = per_cliente(first, last, "TIPOCF|ZONA");
break;
case DATA:
// crea documenti ordinando per data
err = per_cliente(first, last, "TIPOCF|DATADOC");
break;
default:
break;
}
if (errore_fatale(err))
fatal_box ("A fatal error has occured!");
return FALSE;
}
// run_mask():
// imposta i records first e last con gli estremi Da - a
// per individuare i documenti originali da elaborare
int TBatch_crea_doc::run_mask(TRectype& first, TRectype& last)
{
// int err;
first.zero();
last.zero();
TMask *_msk = new TMask ("ve6000");
// --- parte di Marcello, già disabilitata: a cosa serviva ?
// Imposta il flag di autorizzazione agente
/* TTable t("%TIP");
t.zero();
t.put ("CODTAB", _tipo_doc_org); // tipo del documento originale
if (err = t.read (_isgteq)) // si posiziona sul record relativo al documento del tipo specificato
{
error_box ("TElaborazioni::run_mask() : errore di lettura %d da tab(TIP)", err);
return READ_ERROR;
}
if (t.get ("CODTAB") != _tipo_doc_org) // verifica che il tipo di documento trovato sia quello richiesto
{
error_box ("TElaborazioni::run_mask() : non esiste il tipo documento %s in tab(TIP)", (const char *)_tipo_doc_org);
return DOC_TYPE_NOT_FOUND;
}
TFilename profilo(t.get ("S4")); // nome del profilo documento (nome del .ini associato al tipo documento originale)
profilo.ext("ini");
TConfig profilo_doc(profilo); // file di configurazione (ini) del documento
*/
TConfig p(CONFIG_DITTA);
// gestione agente abilitata <==> abilitata in profilo documento e nel .ini della ditta
// int agente = (profilo_doc.get_int ("CODAG", "PROFILO") && p.get_int("AGENTE", "VE"));
int agente = (p.get_int("AGENTE", "VE"));
/* se il flag per la gestione agenti è != 0, allora visualizza i campi agente ed
adotta la stessa convenzione usata per CODICE CLIENTE e ZONA per gestire l'eventualita' che
l'utente non specifichi nulla.
Se è disabilitata, allora lascia vuoti i campi CODICE AGENTE DA e CODICE AGENTE A, in modo
da eliminare una condizione durante il filtraggio dei records.
*/
// nasconde i campi se la gestione agenti è disabilitata
if (!agente)
{
_msk->show (F_CODICE_AGENTE_DA, FALSE);
_msk->show (F_CODICE_AGENTE_A, FALSE);
}
// nasconde il codice elaborazione: ?
_msk->show (F_CODICE_ELAB, FALSE);
if (_msk->run() == K_ESC) // runna la maschera: se premuto esc, esci
{
delete _msk;
return ESC_PRESSED;
}
_ordinamento = _msk->get_int (F_ORDINAMENTO_EMISSIONE); // ordinamento (RadioButton)
_raggruppa = _msk->get_bool (F_RAGGRUPPA); // raggruppa più doc. originali ?
_per_articolo = _msk->get_bool (F_RAGGR_ARTICOLI); // raggruppa linee con lo stesso articolo
TDate d((const char*) _msk->get(F_DATA_ELAB)); // Data documenti finali
_datadoc = d;
_anno = d.year(); // anno è una componente della chiave
TString temps; // temporanea per rilevare i valori dei campi della maschera
TLocalisamfile f(LF_DOC);
// i due seguenti campi non sono discriminanti, in quanto due documenti diversi
// (es.: BollaC e Fattura Acc.) sono raggruppabili nella stessa fattura
// e lo stato in cui devono essere dipende solo dal .ini di quel tipo di documento originale
// first.put ("TIPODOC", _tipo_doc_org); // tipo documento (da tab. ELD)
// last.put ("TIPODOC", _tipo_doc_org);
// first.put ("STATO", _stato_i_doc_i); // stato documento originale
// last.put ("STATO", _stato_i_doc_i);
temps = _msk->get(F_CODICE_CLIFO_DA);
if (temps.not_empty())
first.put ("CODCF", temps); // codice cliente (v. filterfunct)
temps = _msk->get(F_CODICE_CLIFO_A);
if (temps.not_empty())
last.put ("CODCF", temps); // codice cliente (v. filterfunct)
// data
first.put ("DATADOC", _msk->get(F_DATA_DOCUMENTO_DA)); // nessun controllo perché data doc. da e data doc. a sono checktype required
last.put ("DATADOC", _msk->get(F_DATA_DOCUMENTO_A));
// codice zona
temps = _msk->get (F_CODICE_ZONA_DA); // mette in temps il valore del campo codice zona da
if (temps.not_empty()) // se è stato inserito un valore...
first.put("ZONA", temps); // mettilo nel campo zona
temps = _msk->get (F_CODICE_ZONA_A);
if (temps.not_empty())
last.put ("ZONA", temps);
// codice agente: imposta i campi solo se ne è abilitata la gestione
// se agente è disabilitato, i campi agente rimangono vuoti
if (agente)
{
temps = _msk->get (F_CODICE_AGENTE_DA);
if (temps.not_empty())
first.put("CODAG", temps);
temps = _msk->get (F_CODICE_AGENTE_A);
if (temps.not_empty())
last.put ("CODAG", temps);
}
delete _msk;
return 0;
}
// crea fatture ordinate tramite la elab_princ()
// first e last sono 2 rectype che contengono i dati da a per filtrare i documenti originali
// campo_ordinamento è una stringa contenente la chiave di ordinamento (per cliente o per altro)
// da specificare nel TCursor usato per individuare i documenti originali
int TBatch_crea_doc::per_cliente(TRectype& first, TRectype& last, const char* campo_ordinamento)
{
TRelation rel (LF_DOC); // relazione sul file dei documenti
// filtro per il TCursor:
// DATADOC è obbligatoria, ma TIPOCF non dovrebbe essere per forza "C"
TString filter("(ANSI(DATADOC)>=\""); // include nel filtro i tests sui campo obbligatori
filter << first.get_date("DATADOC").string(ANSI) << "\")&&(ANSI(DATADOC)<=\"";
filter << last.get_date("DATADOC").string(ANSI) << "\")&&(TIPOCF==\"C\")";
// se per i campi opzionali sono stati specificati dei valori, include i tests nel filtro:
// CODICE AGENTE
if (!first.get("CODAG").empty())
filter << "&&(CODAG>=\"" << first.get("CODAG") << "\")";
if (!last.get("CODAG").empty())
filter << "&&(CODAG<=\"" << last.get("CODAG") << "\")";
// CODICE ZONA
if (!first.get("ZONA").empty())
filter << "&&(ZONA>=\"" << first.get("ZONA") << "\")";
if (!last.get("ZONA").empty())
filter << "&&(ZONA<=\"" << last.get("ZONA") << "\")";
// setta i limiti dei codici CLIENTI/FORNITORI per la funzione filterfunct del TCursor
_first_codcf = first.get_long ("CODCF");
_last_codcf = last.get_long ("CODCF");
#ifdef _TDD_IN_FILTER
// filtro costruito in base a tutti i tipi di doc. che hanno un record ELABORAZIONE DIFFERITA (ELD)
// che li trasforma in _tipo_doc_des
TString tdfilter(1024);
tdfilter = td_ELD_to_filter(_tipo_doc_des);
// se non è vuoto, lo aggiunge al filtro già creato
if (!tdfilter.empty())
filter << "&&(" << tdfilter << ")";
#endif
// crea, tramite un TCursor, un elenco dei documenti sorgente che rispondono alle caratteristiche
TSorted_cursor curs(&rel, campo_ordinamento, filter, _chiave, &first, &last);
// la filterfunct limita i documenti a quelli con un codice CLI/FO fra _first_codcf e _last_codcf
// (cioé quelli indicati nella maschera richiesta in precedenza)
curs.set_filterfunction(filterfunct);
return elab_princ(curs);
}
// esegue tutta l'elaborazione in modo BATCH, sui documenti individuati nel TCursor curs
int TBatch_crea_doc::elab_princ(TSorted_cursor &curs)
{
int err; // errori ritornati dalle funzioni
long n; // numero della fattura nella numerazione corrente
bool no_select = TRUE; // TRUE se non sono stati selezionati documenti dallo sheet
bool no_elab = TRUE; // TRUE se non ha ancora elaborato nessun documento
TLocalisamfile f(LF_DOC); // per gestire la testata dei documenti
TLocalisamfile rdoc(LF_RIGHEDOC); // per gestire le righe dei documenti
int current = 0; // chiave corrente
TRectype pilota (LF_DOC); // record per il documento pilota
TTable t("NUM"); // tabella numerazioni documenti
TRectype tempr(LF_DOC); // record del documento originale che si sta elaborando
TRectype temprdoc (LF_RIGHEDOC); // record per le righe dei documenti originali
int nrdoc; // numero di righe scritte nel doc finale
bool altri; // TRUE se ci sono altri documenti da includere nello stesso doc. finale
if (curs.items() == 0) // se non ha individuato doc. originali, indica errore
{
error_box ("Nessun documento da elaborare.");
return NO_ORG_DOCS;
}
curs.freeze(); // non perdere tempo a riaggiornarti
// curs=0; // comincia dal primo documento della lista
// _processed è un array di flag che indica se il documento relativo a ciascun flag
// sia da processare (FALSE) o da ignorare/già processato (TRUE).
// le prossime sono righe fossili, rimaste da quanto BATCH e INTERATTIVO erano ancora assieme
//*********************
// Inizio righe fossili
//*********************
TString80 Titolo("documenti elaborabili che possono diventare");
Titolo << _tipo_doc_des;
TCursor_sheet docs_sheet(&curs,
" |NDOC|TIPODOC|DATADOC|TIPOCF|CODCF|OCFPI",
Titolo,
"@1|Numero@7|Tipo@4|Data@10|C/F|Cod. cliente|CF o P.IVA@16");
docs_sheet.enable_check();
if (_interattivo)
{
if (docs_sheet.run()==K_ESC) return ESC_PRESSED;
for (int i=0; i<docs_sheet.items(); i++)
if (!docs_sheet.checked(i))_processed.set(i);
else no_select = FALSE;
if (no_select)
{
error_box ("Nessun documento selezionato.");
return NO_ORG_DOCS;
}
}
//*********************
// Fine righe fossili
//*********************
// Scandaglia tutto curs e setta _processed in tutti i doc. originali che non hanno il
// relativo record di ELABORAZIONE DIFFERITA (ELD) per essere trasformati in doc. destinazione
for (int i=0; i<curs.items();i++) if (!_processed[i]) esiste_ELD(curs,i,SET_PROCESSED);
// ciclo di generazione fattura: finchè vi è ancora un documento da elaborare,...
while (next_pilota(curs,pilota)) // locka automaticamente il documento (pilota) che sta elaborando
{
get_info(pilota); // setta un mare di variabili che dipendono dal documento originale
//*****************************************************
//* questa sezione serve a CREARE il documento finale *
//*****************************************************
// le prossime sono righe fossili, rimaste da quanto BATCH e INTERATTIVO erano ancora assieme
//*********************
// Inizio righe fossili
//*********************
if (_interattivo)
{
TDate d(TODAY);
_datadoc = d;
_anno = d.year();
// inserisce il record di testata della fattura che va a creare
f.put ("CODNUM", _codnum); // la fattura va numerata in base alla codnum specificata in ELD
f.put ("ANNO", _anno); // imposta l'anno del documento
f.put ("PROVV", _provv); // imposta provv./def. del documento
f.put ("NDOC", _ndoc); // imposta il numero del documento
if (!_crea_doc)
{
err = f.read(_isgteq); // cerca il documento
if (err) // guarda se si è verificato un errore
{
error_box ("Errore di lettura %d in doc, cercando il documento", err);
return READ_ERROR;
}
} else f.curr() = pilota; // tutti i campi della fattura sono uguali al documento pilota, tranne alcuni (impostati più sotto)
_tipo_doc_des = f.get ("TIPODOC"); // imposta il tipo di documento
_stato_f_doc_f = f.get ("STATO"); // stato della fattura appena creata
}
else
//*********************
// Fine righe fossili
//*********************
{
// dovendo creare un nuovo documento TIPODOCDES, prende il primo numero disponibile nella numerazione
// relativa, aggiornando il record della numerazione
// (chiedi a Matteo se vuoi delle spiegazioni, oppure a me, se credi di non riuscire a capire Matteo)
t.zero(); // azzera il record della tabella NUMerazioni
t.put ("CODTAB", _codnum); // cerca NUMerazione del documento destinazione
// (codice preso dalla get_info)
if (err = t.read (_isgteq, _lock)) // legge lockando il record per evitare conflitti
{
error_box ("TBatch_crea_doc::per_cliente : errore %d di lettura su tab(NUM)", err);
return READ_ERROR;
}
if (t.get("CODTAB") == _codnum) // controlla che il codice numerazione sia effettivamente quello cercato (?)
{
n = t.get_long("I1"); // legge l'ultimo numero di documento utilizzato
n++; // ora n è il numero della mia fattura (da mettere in NDOC);
}
else
n = 1; // se non esiste alcun documento con il codice numerazione specificato, allora la fattura corrente è la n° 1
// inserisce il record di testata del doc_destinazione che va a creare
f.curr() = pilota; // tutti i campi del doc_destinazione sono uguali al documento pilota,
// tranne quelli impostati qui sotto:
f.put ("NDOC", n); // imposta il numero del documento
f.put ("TIPODOC", _tipo_doc_des); // imposta il tipo di documento
f.put ("STATO", _stato_f_doc_f); // stato del documento appena creato
f.put ("DATADOC", _datadoc); // data di creazione del documento (indicata nella maschera)
f.put ("CODNUM", _codnum); // la fattura va numerata in base alla codnum specificata
if ((err = f.write()) == NOERR) // scrive il record in doc. Se non ci sono errori...
{
t.put ("I1", n); // imposta nuovo numero del documento
t.rewrite(); // aggiorna il numero del documento nella tabella NUMerazioni
t.read (_isequal, _unlock); // unlocka il record
}
else // se vi e' stato un errore nello scrivere il doc_destinazione,...
{
t.read (_isequal, _unlock); // unlocka il record in anche in caso di errore
switch (err)
{
case _isreinsert:
fatal_box ("ve6100: Errore fatale: il record con la chiave specificata esiste già: impossibile sovrascrivere");
break;
default:
fatal_box ("ve6100: Errore fatale: %d scrivendo sulla tabella NDOC", err);
break;
}
return RECORD_WRITE_ERROR; // indica al chiamante un errore nella scrittura di un record
}
}
tempr = pilota; // il primo documento originale da elaborare è quello pilota
// qui inizia il ciclo per la creazione della fattura
// N.B.: appende ogni documento originale nella fattura
nrdoc = 0; // numero riga documento
bool endsearch = FALSE; // true quando non ci sono piu' doc_originali per questo doc_destinazione
TRecord_array doc_destinazione (LF_RIGHEDOC, "NRIGA"); // array contenente le righe della fattura
// costruisce ed imposta il record filtro per trovare le righe di doc_destinazione
TRectype r (LF_RIGHEDOC);
r.zero();
_ndoc = "";
_ndoc << n;
// imposta i dati della chiave
r.put ("CODNUM", _codnum);
r.put ("ANNO", _anno);
r.put ("PROVV", _provv);
r.put ("NDOC", _ndoc);
// _crea_doc = FALSE <==> interattivo = TRUE: nel BATCH, _crea_doc = TRUE, sempre
if (!_crea_doc) doc_destinazione.read(r); // se non deve crearlo, legge le righe gia' presenti
// doc_destinazione.set_key(&r);
// legge tutti i doc_originali che vanno nel doc_destinazione
do
{
/* TRecord_array doc_originale (LF_RIGHEDOC, "NRIGA"); // array per leggere le righe del doc. org. da elaborare
// carica il documento corrente da rdoc:
// imposta i campi della chiave
temprdoc.zero();
temprdoc.put ("CODNUM", tempr.get("CODNUM")); // tempr = record del documento originale da inserire
temprdoc.put ("ANNO", tempr.get ("ANNO"));
temprdoc.put ("PROVV", tempr.get("PROVV"));
temprdoc.put ("NDOC", tempr.get("NDOC"));
// lascia il campo "NRDOC" come campo per il conteggio
// legge le righe del documento originale, distruggendo quelle precedentemente memorizzate
// legge solo i records che corrispondono alla chiave (temprdoc)
int err = doc_originale.read(temprdoc);
CHECK (err==NOERR, "read da rdoc fallita");
*/
// appende il documento originale al documento di destinazione
// per ogni doc_originale legge i dati (per il primo non e' necessario)
get_info(tempr);
// legge dal .ini del doc_originale tempr. il flag che dice se le righe di tempr
// possono essere evase parzialmente o devono essere evase per intero: controllo fossile,
// dal momento che in modo BATCH i documenti vengono evasi completamente
bool raggr_parz = get_raggr_parz(tempr,err);
// legge il metodo (es. B01F01) di elaborazione (trasformazione) delle righe
TString met = metodo(tempr);
// elabora le righe, scrivendole nel doc_destinazione tramite l'omonimo TRecord_array
elab_righe(met,raggr_parz,tempr,doc_destinazione,temprdoc);
_processed.set(curs.pos()); // indica che il documento e' stato processato
// aggiorna lo stato del documento originale e lo scrive
curs.file(LF_DOC).put ("STATO", _stato_f_doc_i);
curs.file(LF_DOC).setkey(1);
if (err = curs.file(LF_DOC).rewrite())
{
error_box ("ve6200: Errore fatale: %d scrivendo sul file DOC", err);
return RECORD_WRITE_ERROR;
}
curs.file(LF_DOC).setkey(2);
curs.unlock(); // unlocka il record del documento processato
// cerca il prossimo doc_originale da inserire. Se non ce ne sono piu', termina la generazione del doc_destinazione
// se ce ne sono ancora, mette nel TRectype tempr il record del prossimo doc_originale da aggiungere
if (_raggruppa) // se deve raggruppare piu' doc_originali in uno solo, ne cerca altri
altri = search(pilota, tempr, curs);
else // altrimenti passa al prossimo doc_destinazione
altri = FALSE;
}
while (altri); // fine del ciclo che raggruppa i doc_originali in un solo doc_destinazione
// controlla se deve raggruppare le righe per codice articolo:
// se vi sono piu' righe con lo stesso codice articolo e altre caratteristiche in comune,
// le riunisce in una sola riga
if (_per_articolo && (doc_destinazione.rows() > 1)) // se deve raggr. e ci sono almeno 2 righe
raggruppa_righe (doc_destinazione);
// salva le righe del doc_destinazione creato
if (err = doc_destinazione.write())
{
error_box ("Errore nella scrittura del doc. destinazione. err = %d", err);
return RECORD_WRITE_ERROR;
}
no_elab = FALSE; // ha elaborato almeno un documento
// cerca il prossimo documeto pilota per il prossimo doc_destinazione
}; // finche' i doc_originali non finiscono
if (no_elab) // se non ha elaborato (trovato)doc_originali da elaborare, indica errore
{
error_box ("Nessun documento elaborato.");
return NO_ORG_DOCS;
}
return 0;
}//*** fino a qua ***//
int TBatch_crea_doc::get_info(TRectype &doc)
{
int err;
// informazioni dalla tabella elaborazioni differite
TRectype reld(LF_TAB); // reld e' un record di tipo tabella
leggi_da_ELD(reld,doc.get("TIPODOC"));
// Imposta i dati relativi all'elaborazione differita corrente
_tipo_doc_org = reld.get ("S6"); // tipo documento originale
_tipo_doc_des = reld.get ("S8"); // tipo documento destinazione
TConfig doc_config (getini(doc,err), "RAGGRUPPA"); // prende il .ini di doc
_stati_validi_doc_i = doc_config.get ("STATIVALIDI"); // stato iniziale del documento originale
_stato_f_doc_i = doc_config.get ("STATOFINALE"); // stato finale (dopo l'elaborazione) del documento originale
// ha qualche senso che _stato_f_doc_f e _codnum siano indicati nel record ELD di ciascun documento iniziale ?
if (!_interattivo)
{
_stato_f_doc_f = reld.get ("S9"); // stato finale (dopo l'elaborazione) del documento finale
_codnum = reld.get ("S5"); // codice numerazione per il documento finale
}
// il flag di sospensione imposta da controllare va preso dal registro a cui
// la numerazione del documento e' collegata
_sosp_imposta = getflag(doc, SOSPENSIONE_IMPOSTA); // T/F sospensione imposta
_cod_sconto = getflag(doc, CODICE_SCONTO); // T/F codice sconto
_stesso_anno = stesso_anno_fiscale(doc); // T/F per STESSOANNOFISCALE in [RAGGR.] del .ini di reld
return 0;
}
bool TBatch_crea_doc::stesso_anno_fiscale(TRectype& rec)
{
bool stesso = FALSE;
// bool stesso = _stesso_anno_fiscale;
int err;
// if (!stesso)
// {
TString name(getini(rec, err));
if (!err){
TConfig config (name, "RAGGRUPPA"); // prende il .ini di rec
stesso = (config.get("STESSOANNOFISCALE")[0] == '1'); // trova se si possono evadere parzialmente le righe
}
// }
return stesso;
}
// ritorna la stringa metodo di trasf. dal record ELD per rec->_tipo_destinazione
TString TBatch_crea_doc::metodo(TRectype &rec)
{
TString metodo;
TString _tipo_pilota = rec.get("TIPODOC");
TRectype reld(LF_TAB); // = rec solo per inizializzarlo
leggi_da_ELD(reld,_tipo_pilota);
metodo = reld.get("S1");
return metodo;
}
// trova il .ini di rec e lo restituisce
TString TBatch_crea_doc::getini(TRectype& rec, int &err)
{
// aggiustare con una new ad un TConfig
TTable teld("%TIP"); // nella tabella %TIP
teld.zero();
teld.put ("CODTAB", rec.get("TIPODOC")); // tipo del documento pilota
err = teld.read (_isgteq); // legge il record
if (err)
{
error_box("Non riesco a leggere nella tabella %s il tipo documento %s",teld.name(),(const char *)rec.get("TIPODOC"));
return err;
}
TRectype& rtip = teld.curr(); // e lo mette in dest
TFilename inifile (rtip.get("S4")); // il nome del .ini e' nel campo S4
inifile.ext("ini");
return (TString)inifile;
}
// prende i dati della sezione [RAGGRUPPA]
bool TBatch_crea_doc::get_raggr_parz(TRectype& rec, int &err)
{
bool raggr_parz = FALSE;
err = FALSE;
TString name(getini(rec, err));
// if (err) return err;
// _stati_validi = config.get("STATIVALIDI"); // trova gli stati validi
if (!err) {
TConfig config (name,"RAGGRUPPA"); // prende il .ini di rec
raggr_parz = (config.get("RAGGRPARZ")[0] == '1'); // trova se si possono evadere parzialmente le righe
}
return raggr_parz;
}
// controlla che il documento rec sia in uno degli stati validi indicati nella sezione [RAGGRUPPA] del suo .ini
int TBatch_crea_doc::statovalido(TRectype& rec)
{
int err;
// TConfig config (getini(rec, err), "RAGGRUPPA"); // prende il .ini di rec
// if (err) return err;
// TString80 _stati_validi;
// _stati_validi = config.get("STATIVALIDI"); // trova gli stati validi
err = _stati_validi_doc_i.find((rec.get("STATO"))[0]); // cerca lo stato (-1 e' non trovato)
if (err == -1) err = STATO_NON_VALIDO;
else err = STATO_VALIDO;
return err;
}
// ritorna TRUE se esiste una ELD che passa dal tipo documento di pilota a _tipo_doc_des
int TBatch_crea_doc::esiste_ELD(TSorted_cursor &curs,int i,bool set_proc)
{
//*************
// bisognerebbe affidarsi ad un decoder
//*************
curs = i;
TRectype &pilota = curs.curr(); // imposta il primo documento da verificare : pilota
TString _tipo_pilota = pilota.get("TIPODOC");
TRectype dummy(LF_TAB); // = pilota solo per inizializzarlo
int err = leggi_da_ELD(dummy,_tipo_pilota);
if (err == ELAB_NOT_FOUND)
if (set_proc==SET_PROCESSED) _processed.set(curs.pos());
else error_box ("TElaborazioni::per_cliente() : non esiste il tipo di elaborazione %s -> %s in tab(ELD)", (const char *)_tipo_pilota, (const char *)_tipo_doc_des);
return err;
}
// ritorna ELAB_FOUND se esiste una ELD che passa dal tipo documento di pilota a _tipo_dest
// (o _tipo_doc_dest, se _tipo_dest non viene specificato) e riempie eventualmente dest con la prima ELD
int TBatch_crea_doc::leggi_da_ELD(TRectype &dest,TString _tipo_pilota,TString _tipo_dest)
{
TRelation rel("ELD");
TString80 filter;
filter << "((S6==\"" << _tipo_pilota << "\")";
if (!_tipo_dest.empty()) filter << "&&(S8==\"" << _tipo_doc_des << "\")";
else if (!_tipo_doc_des.empty()) filter << "&&(S8==\"" << _tipo_doc_des << "\")";
filter << ")";
TCursor curs(&rel, filter);
if (curs.items() == 0) return ELAB_NOT_FOUND;
curs = 0;
dest = curs.curr();
return ELAB_FOUND;
/*
int err;
TTable teld("ELD");
teld.zero();
teld.put ("S6", _tipo_pilota); // tipo del documento pilota
teld.put ("S8", _tipo_doc_des); // tipo del documento finale
err = teld.read (_isgteq); // legge il record
dest = teld.curr(); // e lo mette in dest
if (err) // guarda se si è verificato un errore
{
error_box ("TElaborazioni::per_cliente() : errore di lettura %d da tab(ELD)", err);
return READ_ERROR;
}
if ((teld.get ("S6") != _tipo_pilota)||(teld.get ("S8") != _tipo_doc_des)) // verifica che il tipo di documento trovato sia quello richiesto
{
// error_box ("TElaborazioni::per_cliente() : non esiste il tipo di elaborazione %s -> %s in tab(ELD)", (const char *)_tipo_pilota, (const char *)_tipo_doc_des);
// se non esiste una ELD, setta processed (set_proc permettendo),
// in modo da ignorare questo documento nei controlli successivi
return ELAB_NOT_FOUND;
}
teld.read (_isequal, _unlock); // unlocka il record in ogni caso
return ELAB_FOUND;
*/
}
const char *TBatch_crea_doc::td_ELD_to_filter(TString &_tipo_doc_des)
{
bool first = TRUE;
TString td_filter(1024);
TRelation rel("ELD");
TString80 filter;
if (_tipo_doc_des.empty()) return "";
filter << "(S8==\"" << _tipo_doc_des << "\")";
TCursor curs(&rel, filter);
if (curs.items() == 0) return "";
for (int i=0; i<curs.items();i++)
{
if (first) first=FALSE;
else td_filter << "||";
td_filter << "(TIPODOC==\"" << curs.curr().get("S6") << "\")";
}
return (const char *)td_filter;
}
// cerca il prossimo documeto pilota in cursor
bool TBatch_crea_doc::next_pilota(TSorted_cursor &curs,TRectype &pilota)
{
bool cont = TRUE;
TRecnotype temp = curs.items();
int err = FALSE;
for (int i=0; i < temp && cont && (_processed[i] || ((err = esiste_ELD(curs,i)) != READ_ERROR)); i++) // prossimo documento non processato
switch (err)
{
case ELAB_FOUND: // se ne ha trovato uno
curs=i;
if (statovalido(curs.curr()))
{
pilota = curs.curr(); // nuovo documento pilota
curs.lock();
cont = FALSE;
}
break;
default:;
};
if (i>=temp) return FALSE; // se sono stati tutti processati --> termina
return TRUE; // altrimenti continua a processare
}
// elabora le righe di doc_originale in doc_destinazione, sul TRectype temprdoc, col metodo metodo
bool TBatch_crea_doc::elab_righe(TString metodo,bool raggr_parz,TRectype &tempr,TRecord_array &doc_destinazione,TRectype &temprdoc)
{
bool tutte_le_righe_elab = TRUE;
// switch (metodo)
// {
// case "B01F01":
TRecord_array righe_tmp (LF_RIGHEDOC, "NRIGA"); // array contenente le righe della fattura
TRelation rel(LF_RIGHEDOC);
// rel.lfile().zero();
TString80 ndoc_filter = "(";
ndoc_filter << "(CODNUM==\"" << tempr.get("CODNUM") << "\")&&";
ndoc_filter << "(ANNO==\"" << tempr.get("ANNO") << "\")&&";
ndoc_filter << "(PROVV==\"" << tempr.get("PROVV") << "\")&&";
ndoc_filter << "(NDOC==\"" << tempr.get("NDOC") << "\")";
ndoc_filter << ")";
TSorted_cursor curs_righe(&rel, "NRIGA", ndoc_filter);
curs_righe.read(); // legge le righe del documento originale corrente
// qui sostituisci le costanti stringa per testata e fields col tuo frammento di
// codice che interpreta l'apposita sezione del profilo documento.
TTable t("%TIP");
t.zero();
t.put ("CODTAB", tempr.get("TIPODOC"));
t.read (_isgteq);
TString _descr_tipodocorg (t.get("S4"));
TInterattivo_sheet righe_sheet(&curs_righe,"|NRIGA|CODART|DESCR|PREZZO|QTA|UMQTA|QTAEVASA|UMQTA|QTA",
_descr_tipodocorg << " - righe",
"@1|N.riga|Codice articolo@20|Descrizione@50|Prezzo@18|Quantità@11|um|Q.tà evasa@11|um|Q.tà da evadere");
righe_sheet.add_button(DLG_OK, "Conferma", K_YES);
/* if (_raggruppa_intero)
{
righe_sheet.enable(); // seleziona tutte le righe
righe_sheet.disable_check(); // impedisce di toglierne alcune
}
*/
KEY key=0;
int _rdoc = 1;
bool batch = !((raggr_parz)&&(_interattivo));
if (!batch)
key = righe_sheet.run();
if (batch||(key==K_YES))
for (int i=0; i<righe_sheet.items(); i++) // copia le righe selezionate nel documento finale
if (batch||righe_sheet.checked(i))
{
curs_righe = i;
righe_tmp.row (_rdoc++, TRUE) = curs_righe.file(LF_RIGHEDOC).curr();
}
else tutte_le_righe_elab = FALSE;
if (metodo == "B01F01")
{
for (int i=1; i<=righe_tmp.rows(); i++) // per tutte le righe del documento originale
{
temprdoc = righe_tmp.row (i); // prende la riga del documento originale
temprdoc.put ("CODNUM", _codnum); // chiave per la fattura (indicata nella tabella ELD)
temprdoc.put ("ANNO", _anno); //
temprdoc.put ("PROVV", _provv); //
temprdoc.put ("NDOC", _ndoc); //
int nrdoc = doc_destinazione.last_row()+1;
TRectype& r = doc_destinazione.row(nrdoc, TRUE); // il parametro TRUE indica di creare la riga se non esiste già
temprdoc.put ("NRIGA", r.get("NRIGA")); // imposta il numero di riga
temprdoc.put("DESCEST",""); // azzera i campi memo
temprdoc.put("G1",""); //
r = temprdoc; // imposta la i-esima riga (perché r è una reference)
}
}
// }
return tutte_le_righe_elab;
}
// Ritorna due flag a seconda del parametro.
bool TBatch_crea_doc::getflag (TRectype& rec, int n)
{
/*
TTable t("%TIP");
t.zero();
t.put ("CODTAB", rec.get("TIPODOC"));
t.read (_isgteq);
TFilename filename(t.get("S4"));
filename.ext ("ini");
TConfig conf(filename);
*/
int err;
TConfig conf(getini(rec,err));
if (err) return READ_ERROR;
switch (n) // determina quale flag leggere
{
case SOSPENSIONE_IMPOSTA: return TRUE;
/*
return conf.get_bool (" ", " "); // sezione, nome flag
// il flag da controllare va preso dal registro a cui la numerazione del documento
// e' collegata
*/
case CODICE_SCONTO:
return conf.get_bool ("CAMBIO" , "PROFILO"); // sezione, nome flag
}
error_box ("getflag: Errore: parametro 2 = %d, non valido .", n);
return READ_ERROR;
}
/* Cerca tra i documenti selezionati da curs il prossimo, a partire da curs.curr() che puo' essere
raggruppato con il documento pilota. Il record eventualmente trovato e' ritornato in tempr.
La ricerca e' effettuata tra i documenti di curs.
Ritorna FALSE se non trova documenti da raggruppare, TRUE altrimenti. */
bool TBatch_crea_doc::search (TRectype& pilota, TRectype& tempr, TSorted_cursor& curs)
{
// static bool csi = controlla_sosp_imp(); // determina se controllare il flag di sospensione d'imposta
TRectype campi_pilota (LF_DOC); // usato per settare solo i campi importanti.
campi_pilota.zero();
// campi_pilota.put ("CODNUM", pilota.get ("CODNUM"));
// campi_pilota.put ("STATO", pilota.get ("STATO"));
campi_pilota.put ("CODCF", pilota.get ("CODCF"));
campi_pilota.put ("TIPOCF", pilota.get ("TIPOCF"));
// se pilota ha settato STESSOANNOFISCALE, cerca solo i doc. dello stesso anno
// bool stesso_anno = stesso_anno_fiscale(pilota);
if (_stesso_anno)
campi_pilota.put ("ANNO", _anno);
// campi_pilota.put ("ANNO", pilota.get ("ANNO"));
// campi_pilota.put ("TIPODOC", _tipo_doc_org);
//?? campi_pilota.put ("PROVV", pilota.get ("PROVV"));
campi_pilota.put ("RAGGR", pilota.get ("RAGGR"));
campi_pilota.put ("CODVAL", pilota.get ("CODVAL"));
campi_pilota.put ("CAMBIO", pilota.get ("CAMBIO"));
campi_pilota.put ("CODLIN", pilota.get ("CODLIN"));
campi_pilota.put ("SCONTOPERC", pilota.get ("SCONTOPERC"));
//?? campi_pilota.put ("NUMDOCRIF", pilota.get ("NUMDOCRIF"));
// controllo sul codice sconto
bool found = FALSE;
TRecnotype items = curs.items();
for (int i = 0; i<items && !found; i++)
if (!_processed[i])
{
curs = i;
TRectype& temp = curs.curr();
if ((esiste_ELD(curs,i)==ELAB_FOUND) // se esiste la ELD
&&(statovalido(temp)==STATO_VALIDO) // e lo stato del documento e' valido (vedi il .ini)
&&(temp == campi_pilota)) // campi_pilota a destra per ignorare il confronto dei campi vuoti
found = doc_i_compatibili(campi_pilota,temp);
// il codice sconto non e' da leggere nell'ini ma in nel record di ogni documento
}
curs.lock();
tempr = curs.curr();
return found;
}
// guarda se i documenti pil e pil2 sono compatibili per essere uniti nello stesso documento finale
bool TBatch_crea_doc::doc_i_compatibili(TRectype &pil,TRectype &pil2)
{
bool _sosp_imposta; // T/F sospensione imposta
bool _cod_sconto; // T/F codice sconto
if (!(getflag(pil2, SOSPENSIONE_IMPOSTA) == _sosp_imposta)) return FALSE;
if (!(getflag(pil2, CODICE_SCONTO) == _cod_sconto)) return FALSE;
/* if (!_stesso_anno) // if (_stesso_anno) -> search() ha gia' settato la ricerca sull'anno
if (!(pil.get("ANNO") == pil2.get("ANNO")))
if (stesso_anno_fiscale(pil2)) return FALSE;
*/
// _stesso_anno si riferisce solo a pil2, dato che lo STESSOANNOFISCALE che conta e' quello
// dei doc originali e l'_anno e' quello di oggi (TODAY)
if ((_stesso_anno) && (pil2.get("ANNO")!=_anno)) return FALSE;
TRectype dest(LF_TAB); // reld e' un record di tipo tabella
leggi_da_ELD(dest,pil2.get("TIPODOC"));
// if (!(_stato_f_doc_f == dest.get("S9"))) return FALSE;
if (!(_codnum == dest.get("S5"))) return FALSE;
return TRUE;
}
// filterfunction per il campo numerico CODCF (la TExpression::eval() sbaglia perche' considera tutti i dati come stringhe)
bool TBatch_crea_doc::filterfunct(const TRelation* r)
{
TRectype& temp = r->curr(); // per accedere al record corrente senza dover sempre chiamare la funzione curr() della relazione
bool result = TRUE;
long l;
long firstcodcf, lastcodcf; // per non chiamare sempre app()
#ifndef _TDD_IN_FILTER
if (!_tipo_doc_dest.empty())
{
TRectype dummy(LF_TAB); // = pilota solo per inizializzarlo
result = result && ((leggi_da_ELD(dummy,_temp.get("TIPODOC"),_tipo_doc_des) == ELAB_FOUND);
}
#endif
l = temp.get_long("CODCF");
if ((firstcodcf = app()._first_codcf) > 0)
result = result && (l >= firstcodcf);
if ((lastcodcf = app()._last_codcf) > 0)
result = result && (l <= lastcodcf);
return result;
}
/* Raggruppa tutte le righe del documento doc che hanno uguali i seguenti campi:
- codice articolo (deve essere non blank)
- unita' di misura
- prezzo
- IVA
*/
void TBatch_crea_doc::raggruppa_righe (TRecord_array& doc)
{
TRectype pilota (LF_RIGHEDOC); // record corrente di raggruppamento
TRectype tempr (LF_RIGHEDOC); // prossimo record da raggruppare
TBit_array processed; // array per indicare quali righe sono gia' state processate
TBit_array tocopy(doc.rows()); // array che indica quali righe debbono essere copiate in doc2
tocopy.set(); // indica che tutte le righe sono da copiare
// si posiziona sul primo record che ha il codice articolo non vuoto
int i;
// salta le righe senza codice articolo (con CODART vuoto)
for (i=1; i<=doc.rows() && doc.row(i).get("CODART").empty() ; i++);
if (i>doc.rows())
{
message_box ("Tutti gli articoli sono privi di codice. Nessuna riga raggruppata.");
return;
}
TRectype confronto(LF_RIGHEDOC); // record per il confronto dei campi significativi
int current; // posizione dell'ultimo record valido trovato (per non ripetere sempre la ricerca dall'inizio)
do
{
current = i;
pilota = doc.row(i);
confronto.zero(); // imposta i campi significativi per il raggruppamento delle righe
confronto.put ("CODART", pilota.get ("CODART"));
confronto.put ("CODIVA", pilota.get ("CODIVA"));
confronto.put ("PREZZO", pilota.get ("PREZZO"));
confronto.put ("UMQTA", pilota.get ("UMQTA"));
processed.set(i); // la riga trovata e' processata (e' la riga pilota)
int prox; // numero della prossima riga da raggruppare
while (prox_riga (prox, doc, processed, confronto))
{
pilota.put("QTA", pilota.get_real("QTA") + doc.row(prox).get_real("QTA")); // aggiorna il contenuto della riga pilota
doc.row(current, FALSE) = pilota;
processed.set(prox); // indica che la riga e' stata processata
tocopy.reset(prox); // indica che la riga non e' da copiare, perche' inglobata nella riga pilota
}
// cerca la prossima riga pilota
bool skip = TRUE;
for (i=current+1; i<=doc.rows() && skip; i++)
skip = doc.row(i).get("CODART").empty() || processed[i];
i--;
}
while (i<=doc.rows()); // finche' ci sono righe da elaborare
// necessario usare questa var. nel ciclo for seguente perche'doc.rows viene valutata ad ogni ciclo,
// e diminuisce di una unita' ogni volta che viene cancellata una riga. Cio' provocherebbe la mancata cancellazione
// delle ultime righe della fattura.
int drows = doc.rows();
for (i=1; i<=drows; i++) // cancella le righe raggruppate
if (!tocopy[i])
doc.destroy_row (i, FALSE);
}
bool TBatch_crea_doc::prox_riga (int& prox, TRecord_array& doc, TBit_array& processed, TRectype& confronto)
{
bool found = FALSE;
for (int i=1; !found && i<=doc.rows(); i++)
if (!processed[i] && !doc.row(i).get("CODART").empty())
found = (doc.row(i) == confronto);
prox = i-1;
return found;
}
int ve6200 (int argc, char **argv)
{
TBatch_crea_doc a;
a.run (argc, argv, "Fatturazione");
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink