424 lines
19 KiB
C++
Executable File
424 lines
19 KiB
C++
Executable File
#include <applicat.h>
|
|
#include <config.h>
|
|
#include <form.h>
|
|
#include <mask.h>
|
|
#include <printer.h>
|
|
#include <relation.h>
|
|
#include <strings.h>
|
|
#include <expr.h>
|
|
#include <tabutil.h>
|
|
#include <urldefid.h>
|
|
#include <utility.h>
|
|
|
|
// !! fatto (in ordine d'esecuzione):
|
|
// !! ------------------------------
|
|
// !! - lettura parametri linea di comando per eventuale esecuzione batch
|
|
// !! - impostazione di flag di interattività posto a true se non ci sono parametri sulla linea
|
|
// !! di comando; influisce su:
|
|
// !! - apertura maschera richiesta dati
|
|
// !! - richiesta di stampa definitiva
|
|
// !! - richiesta d'interruzione in caso di stato non valido durante stampa definitiva
|
|
// !! - interruzione forzata in caso di impossibilità di rinumerazione definitiva
|
|
// !! - impostazione di flag di stampa definitiva (da linea di comando o richiesta con box);
|
|
// !! influisce su:
|
|
// !! - controllo stati durante la stampa
|
|
// !! - lancio della procedura di rinumerazione definitiva
|
|
// !! - lettura tabelle codice numerazione e tipo documento
|
|
// !! - lancio batch della stampa se sono presenti i parametri sulla linea di comando
|
|
// !! - creazione e apertura della maschera e lettura dati
|
|
// !! - impostazione della regione del cursore del form
|
|
// !! - ciclo di lettura del form con stampa della posizione corrente e lancio (eventuale)
|
|
// !! della rinumerazione
|
|
// !! - intercettazione dei seguenti messaggi custom nel form:
|
|
// !! - _ISAMREAD per letture generiche dal database
|
|
// !! - _TABLEREAD per lettura generiche da tabelle del database
|
|
// !! - _DITTA per ottenere dati di configurazione sulla ditta in uso
|
|
// !! - _CIFRELETTERE per la conversione di un valore in lettere
|
|
// !! - chiusura applicazione
|
|
|
|
// !! da fare:
|
|
// !! -------
|
|
// !! - verificare le messaggistiche verso l'utente e il controllo dell'interattività
|
|
// !! - aggiungere lettura del tipo di modulo dal form (quando sarà fatto)
|
|
// !! - completare routine di scelta di cosa fare al cambio del modulo
|
|
// !! - aggiungere tutti gli altri messaggi di gestione dei documenti di vendita (clienti,
|
|
// !! totalizzatori, calcoli, ecc.)
|
|
// !! - tutto il resto!
|
|
|
|
|
|
|
|
#include "ve1100.h"
|
|
#include "ve0100b.h"
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// classe TDocVen_Form customizzata dalla Form per i documenti di vendita
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
class TDocVen_Form: public TForm {
|
|
TRelation &_firmrel; // relazione di gestione dei dati della ditta corrente
|
|
protected:
|
|
virtual bool validate(TForm_item &, TToken_string &);
|
|
public:
|
|
TDocVen_Form(const char *, TRelation &);
|
|
};
|
|
|
|
|
|
|
|
TDocVen_Form::TDocVen_Form(const char* name, TRelation &rel): TForm(name), _firmrel(rel) {}
|
|
|
|
bool TDocVen_Form::validate(TForm_item &cf, TToken_string &s) {
|
|
const TString code(s.get(0)); // prende il primo parametro, il codice del messaggio
|
|
|
|
if (code== "_ISAMREAD") {
|
|
// lettura generica di un file del database
|
|
// sintassi: _ISAMREAD <file> <espressione input>,<espressione input>,... <espressione output>,<espressione output>,...
|
|
// dove: <file> è il numero logico del file o il nome della tabella
|
|
// <espressione input> è un'espressione del tipo <campo file>=<espressione campi form>
|
|
// <espressione campi form> è un'espressione di costanti numeriche, stringhe e valori di campi della form (indicati con il loro numero preceduto da #)
|
|
// <espressione output> è un'espressione del tipo <campo form o gruppo>=<campo file> (se è un gruppo deve essere seguito da @) oppure solo <campo file> (il campo della form è quello corrente)
|
|
int i, j, poseq, posrv, itms;
|
|
pagetype pt;
|
|
char sec;
|
|
TLocalisamfile *file;
|
|
TString f_code(s.get()); // prende il codice del file da leggere
|
|
if (atoi(f_code) != 0) file= new TLocalisamfile(atoi(f_code)); // se il codice è numerico allora è un file
|
|
else file= new TTable(f_code); // altrimenti è una tabella
|
|
TToken_string in(s.get(), ',');
|
|
for (i=0; i<in.items(); i++) { // scansione sugli elementi dell'input
|
|
TString curr(in.get(i));
|
|
poseq= curr.find("=="); // divide la stringa corrente in lvalue e rvalue
|
|
if (poseq== -1) {
|
|
poseq= curr.find('=');
|
|
if (poseq != -1) posrv= poseq+1;
|
|
} else posrv= poseq+2;
|
|
const TString &fld= curr.left(poseq); // preleva il nome del campo del file alla sinistra dell'uguale
|
|
const TString &expr= curr.mid(posrv); // preleva l'espressione di assegnamento alla destra dell'uguale
|
|
TExpression rval(expr, _strexpr);
|
|
for (j=0; j<rval.numvar(); j++) { // scansione delle variabili dell'espressione di rvalue
|
|
TString var= rval.varname(j);
|
|
if (var[0]=='#') var.ltrim(1); // rimuove dalla stringa il primo carattere
|
|
TForm_item &fi= cf.find_field(var);
|
|
rval.setvar(j, fi.get()); // il valore corrente del campo viene settato nell'espressione
|
|
}
|
|
file->put(fld, (const char *)rval); // scrive il risultato dell'espressione nel campo del file
|
|
}
|
|
if (file->read()== NOERR) { // tenta una lettura del file
|
|
TToken_string out(s.get(), ',');
|
|
for (i=0; i<out.items(); i++) { // scansione sugli elementi dell'output
|
|
TString curr(out.get(i));
|
|
poseq= curr.find("=="); // divide la stringa corrente in lvalue e rvalue
|
|
if (poseq== -1) {
|
|
poseq= curr.find('=');
|
|
if (poseq != -1) posrv= poseq+1;
|
|
} else posrv= poseq+2;
|
|
if (poseq== -1) {
|
|
const TString &dat= file->get(curr); // preleva il nome del campo del file e lo legge dal record
|
|
cf.set(dat); // setta il campo letto dal file nel campo corrente della form
|
|
} else {
|
|
TString fld= curr.left(poseq); // preleva il nome del campo del form alla sinistra dell'uguale
|
|
const TString &dat= file->get(curr.mid(posrv)); // preleva il nome del campo del file alla destra dell'uguale e lo legge dal record
|
|
if (fld[0]=='#') fld.ltrim(1);
|
|
if (fld.right(1)== "@") { // se c'è la a-commerciale è un gruppo
|
|
if (fld.find("->") != -1) { // se nel gruppo c'è la freccia si riferisce ad un'altra sezione
|
|
sec= fld[0];
|
|
if (fld[1] != '-') pt= char2page(fld[1]);
|
|
else pt= even_page;
|
|
itms= section(sec, pt).fields();
|
|
} else { // altrimenti si riferisce alla sezione corrente
|
|
sec= cf.section().section_type();
|
|
pt= cf.section().page_type();
|
|
itms= cf.section().fields();
|
|
}
|
|
for (j=0; j<itms; j++) { // per ogni campo della sezione specificata (o sottointesa)...
|
|
TForm_item &fi= section(sec, pt).field(j);
|
|
fi.set(dat); // ...il contenuto viene settato al valore del file
|
|
}
|
|
} else {
|
|
TForm_item &fi= cf.find_field(fld);
|
|
fi.set(dat);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
delete file;
|
|
return (TRUE);
|
|
} // fine _ISAMREAD
|
|
|
|
if (code== "_TABLEREAD") {
|
|
// lettura generica di un campo di una tabella
|
|
// sintassi: _TABLEREAD <tabella> <chiave> <campo file>
|
|
// dove: <tabella> nome tabella da leggere
|
|
// <chiave> costante stringa o riferimento a campo della form (preceduto da '#') da usare come chiave di ricerca
|
|
// <campo file> identificativo del campo da leggere dalla tabella
|
|
TTable tab(s.get()); // prende il nome della tabella
|
|
TString in(s.get()); // prende il valore o il campo da usare come codice di ricerca
|
|
if (in.left(1)== '#') {
|
|
in.ltrim(1);
|
|
TForm_item &fi= cf.find_field(in);
|
|
in= fi.get();
|
|
}
|
|
tab.put("CODTAB", in); // setta la chiave nella tabella
|
|
if (tab.read()== NOERR) {
|
|
const TString &fld= s.get(); // prende il nome del campo da leggere...
|
|
cf.set(tab.get(fld)); // ...e lo scrive nel campo del form
|
|
}
|
|
return (TRUE);
|
|
} // fine _TABLEREAD
|
|
|
|
if (code== "_DITTA") {
|
|
// lettura dei dati della ditta
|
|
// sintassi: _DITTA {<campo relazione>|<macro>}
|
|
// dove: <campo relazione> è un riferimento alla relazione di gestione dei dati della ditta (es. 113@->DENCOM è la denominazione del comune di residenza della ditta)
|
|
// <macro> è uno delle macro seguenti:
|
|
// &RAGSOC ragione sociale
|
|
// &IND indirizzo (fiscale se c'è, oppure di residenza)
|
|
// &NUM numero civico (fiscale se c'è, oppure di residenza)
|
|
// &CAP CAP (fiscale se c'è, oppure di residenza)
|
|
// &COM comune (fiscale se c'è, oppure di residenza)
|
|
// &IVA partita iva
|
|
// &CF codice fiscale
|
|
// &TEL numero di telefono (con prefisso)
|
|
// &FAX numero di fax (con prefisso)
|
|
// nota: la relazione di della ditta è così strutturata:
|
|
// %NDITTE (9) Dati ditte
|
|
// + %ANAGR (6) Anagrafica generale (indirizzo, ecc.)
|
|
// + %COMUNI (113@) Comune di residenza
|
|
// + %COMUNI (213@) Comune di residenza fiscale
|
|
TString in(s.get());
|
|
if (in[0]=='&') {
|
|
in.ltrim(1);
|
|
bool _fisc= _firmrel.lfile(6).get("INDRF").not_empty();
|
|
if (in=="RAGSOC") cf.set(_firmrel.lfile().get("RAGSOC"));
|
|
if (in=="IND") {
|
|
if (_fisc) cf.set(_firmrel.lfile(6).get("INDRF"));
|
|
else cf.set(_firmrel.lfile(6).get("INDRES"));
|
|
}
|
|
if (in=="NUM") {
|
|
if (_fisc) cf.set(_firmrel.lfile(6).get("CIVRF"));
|
|
else cf.set(_firmrel.lfile(6).get("CIVRES"));
|
|
}
|
|
if (in=="CAP") {
|
|
if (_fisc) cf.set(_firmrel.lfile(6).get("CAPRF"));
|
|
else cf.set(_firmrel.lfile(6).get("CAPRES"));
|
|
}
|
|
if (in=="COM") {
|
|
if (_fisc) cf.set(_firmrel.lfile(-213).get("DENCOM"));
|
|
else cf.set(_firmrel.lfile(-113).get("DENCOM"));
|
|
}
|
|
if (in=="IVA") cf.set(_firmrel.lfile(6).get("PAIV"));
|
|
if (in=="CF") cf.set(_firmrel.lfile(6).get("COFI"));
|
|
if (in=="TEL") {
|
|
TString tel(_firmrel.lfile().get("PTEL"));
|
|
tel << "/" << _firmrel.lfile().get("TEL");
|
|
cf.set(tel);
|
|
}
|
|
if (in=="FAX") {
|
|
TString tel(_firmrel.lfile().get("PFAX"));
|
|
tel << "/" << _firmrel.lfile().get("FAX");
|
|
cf.set(tel);
|
|
}
|
|
} else {
|
|
TFieldref fref(s.get(), 0);
|
|
cf.set(fref.read(&_firmrel));
|
|
}
|
|
return (TRUE);
|
|
} // fine _DITTA
|
|
|
|
if (code== "_CIFRELETTERE") {
|
|
// conversione di un reale da cifre a lettere
|
|
// sintassi: _CIFRELETTERE [<campo form>]
|
|
// dove: <campo form> è il campo della form (preceduto da '#') da cui prendere il valore, se non è specificato è sottointeso il campo corrente
|
|
// nota: prende il valore del campo specificato e scrive la sua conversione in lettere nel campo corrente
|
|
TString in;
|
|
if (s.items()==2) {
|
|
in= s.get();
|
|
if (in.left(1)== '#') in.ltrim(1);
|
|
TForm_item &fi= cf.find_field(in);
|
|
in= fi.get();
|
|
} else in= cf.get();
|
|
real n(in);
|
|
cf.set(n.string("LETTERE"));
|
|
return (TRUE);
|
|
} // fine _CIFRELETTERE
|
|
|
|
return TForm::validate(cf, s); // se il codice del messaggio non è identificato viene passato alla funzione standard
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
// classe TStampa_Doc_Vendita customizzata dalla TApplication per l'applicazione principale
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
enum behaviour {
|
|
skip,
|
|
go,
|
|
cancel
|
|
};
|
|
|
|
|
|
|
|
class TStampa_Doc_Vendita: public TApplication {
|
|
TString _codnum; // codice di numerazione
|
|
TString _provv; // stampa provvisioria
|
|
int _anno; // anno della documentazione
|
|
long _dalnum, _alnum; // estremi di numerazione dei documenti
|
|
bool _interattivo; // flag che indica se il prog. funziona in interattivo o in batch
|
|
bool _definitiva; // flag che indica se la stampa è definitiva o no
|
|
TRelation *_firmrel; // puntatore alla relazione che gestisce i dati della ditta corrente
|
|
protected:
|
|
virtual bool create(void);
|
|
virtual bool destroy(void);
|
|
virtual bool menu(MENU_TAG);
|
|
int select(void);
|
|
virtual void print(void);
|
|
virtual void on_firm_change(void);
|
|
virtual behaviour on_module_change(const TString &); // funzione chiamata ad ogni cambio modulo durante la stampa
|
|
virtual bool query_final_print(void); // funzione chiamata all'inizializzazione per sapere se la stampa è definitiva
|
|
};
|
|
|
|
|
|
|
|
bool TStampa_Doc_Vendita::create() {
|
|
TApplication::create();
|
|
_firmrel= new TRelation(LF_NDITTE); // istanziamento e impostazione della relazione di gestione della ditta corrente
|
|
_firmrel->add(LF_ANAG, "TIPOA=TIPOA|CODANAGR=CODANAGR");
|
|
_firmrel->add(LF_COMUNI, "COM=COMRES", 1, LF_ANAG, 100+LF_COMUNI);
|
|
_firmrel->add(LF_COMUNI, "COM=COMRF", 1, LF_ANAG, 200+LF_COMUNI);
|
|
if (argc()>2) { // lettura dei parametri iniziali dalla linea di comando
|
|
_codnum= argv(2); // il primo parametro è il codice di numerazione
|
|
_anno= atoi(argv(3)); // il secondo è l'anno
|
|
_provv= argv(4); // il terzo è il flag di numerazione provvisoria
|
|
_dalnum= atol(argv(5)); // il quarto è il numero di documento di partenza
|
|
_alnum= atol(argv(6)); // il quinto è il numero di documento di fine
|
|
_interattivo= FALSE;
|
|
print();
|
|
} else { // oppure lancio della maschera
|
|
_interattivo= TRUE;
|
|
dispatch_e_menu(BAR_ITEM(1));
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TStampa_Doc_Vendita::destroy() {
|
|
delete _firmrel; // distruzione della relazione di gestione della ditta corrente
|
|
return TApplication::destroy();
|
|
}
|
|
|
|
void TStampa_Doc_Vendita::on_firm_change() {
|
|
TLocalisamfile &firmfile= _firmrel->lfile();
|
|
firmfile.put("CODDITTA", get_firm());
|
|
_firmrel->read();
|
|
}
|
|
|
|
int TStampa_Doc_Vendita::select() {
|
|
TMask m("ve1100a");
|
|
if (m.run() == K_ENTER) {
|
|
_codnum= m.get(F_CODNUM); // lettura dei dati dalla maschera
|
|
_anno= m.get_int(F_ANNO);
|
|
//_provv= (m.get_bool(F_PROVV))?("P"):("D");
|
|
_provv = m.get(F_PROVV);
|
|
_dalnum= m.get_long(F_DA_NDOC);
|
|
_alnum= m.get_long(F_A_NDOC);
|
|
return 1;
|
|
} else return 0; // 0 indica che non si è usciti con "Conferma" dalla maschera
|
|
}
|
|
|
|
bool TStampa_Doc_Vendita::menu(MENU_TAG) { // procedura di dispatch dei menu
|
|
int s;
|
|
while ((s= select()) != 0) if (s==1) print(); // se la selezione della maschera ritorna 1 viene lanciata la stampa
|
|
return FALSE;
|
|
}
|
|
|
|
void TStampa_Doc_Vendita::print() {
|
|
_definitiva= query_final_print(); // legge il flag di stampa definitiva
|
|
printer().open(); // apre la stampante
|
|
TFilename nomeform, profilo; // istanzia le stringhe per il nome del form di stampa e del profilo di configurazione
|
|
TString modulo, modulo_prec; // istanzia le stringhe per l'inseguimento del modulo di carta
|
|
//TToken_string stati("",','); // token string con gli stati validi dei documenti
|
|
TTable tip("%TIP"); // istanzia la tabella dei tipi di documento per i profili
|
|
TRelation rel(LF_DOC); // istanzia la relazione sul file principale
|
|
TLocalisamfile &doc= rel.lfile(); // prende il riferimento al file principale
|
|
TCursor cur(&rel); // crea il cursore principale dalla relazione
|
|
doc.put("CODNUM", _codnum); // compone la chiave per il record di inizio cursore
|
|
doc.put("ANNO", _anno);
|
|
doc.put("PROVV", _provv);
|
|
doc.put("NDOC", _dalnum);
|
|
doc.read(); // posiziona il file sul record
|
|
TRectype darec= doc.curr(); // copia il record di inizio cursore
|
|
doc.put("NDOC", _alnum); // compone la chiave per il record di fine cursore
|
|
doc.read(); // posiziona il file sul record
|
|
TRectype arec= doc.curr(); // copia il record di fine cursore
|
|
cur.setregion(darec, arec); // imposta il filtro sul cursore di stampa
|
|
for (int i= 0; i<cur.items(); i++)// ciclo sugli elementi del cursore di stampa
|
|
{
|
|
cur= i; // posiziona il cursore
|
|
tip.put("CODTAB", doc.get("TIPODOC")); // posiziona la tabella dei tipi di documento
|
|
int err=tip.read();
|
|
if (err==NOERR) // legge la tabella
|
|
{
|
|
nomeform= tip.get("S5"); // legge il nome del form di stampa
|
|
profilo= tip.get("S4"); // legge il nome del profilo di configurazione
|
|
profilo.ext("ini");
|
|
TConfig config(profilo, "STAMPA"); // apre il file di configurazione del profilo
|
|
TToken_string stati ((const char*)config.get("STATIVALIDI"), ','); // legge gli stati validi di questo tipo di documento
|
|
if (_definitiva && (stati.get_pos(doc.get("STATO"))== -1)) // se lo stato del doc. corrente non è valido...
|
|
{
|
|
if (_interattivo) error_box("Non è possibile stampare un documento con stato non valido"); // ...viene mostrato un messaggio (solo in modo interattivo)...
|
|
break; // ...e la stampa viene interrotta
|
|
}
|
|
behaviour whattodo= go; // istanzia la variabile di comportamento
|
|
TDocVen_Form f(nomeform, *_firmrel); // istanzia il form
|
|
// !! modulo= f.get_module_code(); // legge dal form il codice del modulo di carta per la stampa
|
|
if (modulo_prec.empty()) modulo_prec= modulo; // se siamo al primo passaggio la variabile di modulo precedente viene riempita
|
|
if (modulo != modulo_prec) whattodo= on_module_change(modulo); // se il modulo è cambiato dalla stampa precedente interroga la funzione per sapere che comportamento tenere
|
|
if (whattodo==cancel) // se non si può procedere la stampa viene interrotta
|
|
break;
|
|
else if (whattodo==go) // altrimenti prosegue
|
|
{
|
|
TCursor &fcur= *(f.cursor()); // ricava il riferimento al cursore originale del form
|
|
darec= arec= doc.curr(); // prepara i record per il filtro
|
|
fcur.setregion(darec, arec); // setta il filtro sul form (solo il record corrente)
|
|
f.print(0,0); // stampa il record corrente del form
|
|
if (_definitiva && (numerazione_definitiva(doc) != NOERR)) // se la stampa è definitiva viene lanciata la procedura di rinumerazione
|
|
{
|
|
if (_interattivo) error_box("Non è possibile completare la procedura di numerazione definitiva dei documenti");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// error_box("Il documento corrente non può essere trovato nella tabella dei tipi di documento");
|
|
error_box ("Errore %d leggendo da %TIP.", err);
|
|
break;
|
|
}
|
|
}
|
|
printer().close(); // chiude la stampante
|
|
}
|
|
|
|
behaviour TStampa_Doc_Vendita::on_module_change(const TString &modulo) {
|
|
// !! qui va messa la reazione al cambio di modulo
|
|
// !! - se non si è in interattivo bisogna, immagino, ritornare sempre "skip"
|
|
// !! - se si è in interattivo bisogna chiedere all'utente il da farsi, eventualmente
|
|
// !! fornendo il nome esteso del modulo da inserire facendo una seek sulla tabella
|
|
return skip;
|
|
}
|
|
|
|
bool TStampa_Doc_Vendita::query_final_print() {
|
|
if (_interattivo) { // se siamo in interattivo viene richiesto all'utente se la stampa è definitiva o meno
|
|
if (yesno_box("E' una stampa definitiva?")) return TRUE;
|
|
else return FALSE;
|
|
} else return (strcmp(argv(7), "D")==0); // altrimenti lo legge dalla linea di comando
|
|
}
|
|
|
|
|
|
|
|
int ve1100(int argc, char* argv[]) {
|
|
TStampa_Doc_Vendita a;
|
|
a.run(argc, argv, "Stampa documenti di vendita");
|
|
return (0);
|
|
}
|