517 lines
16 KiB
C++
Executable File
517 lines
16 KiB
C++
Executable File
// Gestione sconti di Riga/Incondizionati/Documenti
|
||
#include <config.h>
|
||
#include <recarray.h>
|
||
#include <relapp.h>
|
||
#include <tabutil.h>
|
||
|
||
#include "ve2100.h"
|
||
|
||
#define MAX_REAL "9999999999.99999" //mmmhh..
|
||
|
||
static void key_hide(TMask & m, short id, int key = 1)
|
||
{
|
||
TEditable_field & e = ((TEditable_field &)m.field(id));
|
||
e.reset_key(key);
|
||
e.check_type(CHECK_NONE);
|
||
e.set_field("");
|
||
m.hide(id);
|
||
}
|
||
|
||
static void key_disable(TMask & m, short id, int key = 1)
|
||
{
|
||
((TEditable_field &)m.field(id)).reset_key(key);
|
||
m.disable(id);
|
||
}
|
||
|
||
static void key_enable(TMask & m, short id, int key = 1)
|
||
{
|
||
((TEditable_field &)m.field(id)).set_key(key);
|
||
m.enable(id);
|
||
}
|
||
struct enable_key_info
|
||
{
|
||
bool enabled;
|
||
short normal_field,search_field;
|
||
};
|
||
|
||
class TTabelle_sconti: public TRelation_application {
|
||
TMask *_msk; // maschera principale
|
||
TRelation *_rel; // relazione principale
|
||
|
||
char _sconti; // carattere che indica il tipo di tabella
|
||
bool _catven; // abilitazione della gestione della categoria di vendita
|
||
bool _scoum; // abilitazione della gestione delle unita' di misura
|
||
bool _sca; // abilitazione della gestione degli scaglioni
|
||
enable_key_info _sci_k_id[4]; // struct contenente informazioni sull'abilitazione degli sconti incondizionati
|
||
TString _gessco; // indicatore di abilitazione degli sconti incondizionati
|
||
TString _gesscoriga; // indicatore di abilitazione degli sconti di riga
|
||
|
||
virtual bool user_create();
|
||
virtual bool user_destroy();
|
||
virtual TMask *get_mask(int) { return _msk; }
|
||
virtual bool changing_mask(int) { return FALSE; }
|
||
virtual TRelation *get_relation() const { return _rel; }
|
||
virtual void init_query_mode(TMask& m);
|
||
virtual void init_query_insert_mode(TMask& m);
|
||
virtual bool remove(); // metodo usato per rimuovere il record sul file
|
||
void renumber_sca(const TRectype& r); //metodo per rinumerare gli scaglioni
|
||
// static void fill_rec(TRectype& r, TMask& m);
|
||
static real find_prev_qta(TRectype& r);
|
||
static real find_next_qta(TRectype& r);
|
||
static bool handle_qta(TMask_field &, KEY); // handler della quantita' limite per scaglione
|
||
static bool handle_sca(TMask_field &, KEY); // handler dello scaglione
|
||
// Gli handler seguenti sono necessari solo per controllare l'esistenza effettiva del campo immesso
|
||
// Si dira' perche' non e' stato messo un bel CHECKTYPE FORCED su tali campi?
|
||
// Risposta, perche quando si clicca su nuovo per andare in modo ricerca/inserimento, tutti i campi
|
||
// che hanno CHECKTYPE FORCED risultano non essere validi. Percio' si e' rimesso il CHECKTYPE REQUIRED
|
||
// e si controlla la consistenza del campo.
|
||
// static bool handle_um(TMask_field &, KEY); // handler delle unita' di misura per gli sconti di riga
|
||
static bool handle_check(TMask_field &, KEY); // handler per i check
|
||
// static bool handle_sco(TMask_field &, KEY); // handler delle sconto cliente
|
||
// static bool handle_zon(TMask_field &, KEY); // handler delle zone
|
||
// static bool handle_cpg(TMask_field &, KEY); // handler delle condizioni di pagamento
|
||
|
||
public:
|
||
// @cmember Disabilita la verifica del modulo : essendo una anagrafica, va sempre abilitata
|
||
virtual bool check_autorization() const {return FALSE;}
|
||
TTabelle_sconti() {_sca = _scoum = _catven = FALSE;}
|
||
virtual ~TTabelle_sconti() {}
|
||
};
|
||
|
||
inline TTabelle_sconti& app() { return (TTabelle_sconti &) main_app(); }
|
||
|
||
// Handlers per i campi quantita' limite e scaglione, valgono solo per gli sconti di riga
|
||
|
||
/*void TTabelle_sconti::fill_rec(TRectype &r, TMask& m)
|
||
{
|
||
TString16 tipo(m.get(F_R_TIPO));
|
||
TString16 codcat(m.get(F_R_CODCAT));
|
||
TString codart(m.get(F_R_CODART));
|
||
if (codart.empty()) codart = m.get(F_R_CODART_A);
|
||
TString16 um(m.get(F_R_UM));
|
||
int sca = m.get_int(F_R_SCA);
|
||
r.zero();
|
||
r.put("TIPO",tipo);r.put("CODCAT",codcat);
|
||
r.put("CODART",codart); r.put("UM",um);r.put("NSCAGL",sca);
|
||
}
|
||
*/
|
||
|
||
real TTabelle_sconti::find_prev_qta(TRectype& r)
|
||
{
|
||
TLocalisamfile f(LF_SCONTI);
|
||
real qta = 0.0;
|
||
f.curr() = r;
|
||
int nscagl = r.get_int("NSCAGL");
|
||
f.put("NSCAGL", nscagl-1);
|
||
if (f.read() == NOERR)
|
||
qta = f.get_real("QLIM");
|
||
return qta;
|
||
}
|
||
|
||
real TTabelle_sconti::find_next_qta(TRectype& r)
|
||
{
|
||
TLocalisamfile f(LF_SCONTI);
|
||
real qta(MAX_REAL);
|
||
f.curr() = r;
|
||
int nscagl = r.get_int("NSCAGL");
|
||
f.put("NSCAGL", nscagl+1);
|
||
if (f.read() == NOERR)
|
||
qta = f.get_real("QLIM");
|
||
return qta;
|
||
}
|
||
|
||
bool TTabelle_sconti::handle_qta(TMask_field &f, KEY k)
|
||
{
|
||
if (f.to_check(k))
|
||
{
|
||
TMask& m = f.mask();
|
||
real qta_prev,qta_next;
|
||
real current_qta(f.get());
|
||
TRelation r(LF_SCONTI);
|
||
m.autosave(r);
|
||
TRectype r1(r.curr());
|
||
TRectype r2(r1);
|
||
|
||
qta_prev = find_prev_qta(r1);
|
||
qta_next = find_next_qta(r2);
|
||
int sca = m.get_int(F_R_SCA);
|
||
if (sca == 1 && current_qta == 0.0)
|
||
{
|
||
f.error_box("La quantita' limite deve essere maggiore di 0");
|
||
return FALSE;
|
||
}
|
||
if (sca == 9 && current_qta == 0.0) return TRUE;
|
||
if (qta_next <= current_qta)
|
||
{
|
||
f.error_box("La quantita' limite deve essere minore di %s.",
|
||
(const char*)qta_next.string());
|
||
return FALSE;
|
||
}
|
||
if (qta_prev >= current_qta)
|
||
{
|
||
f.error_box("La quantita' limite deve maggiore di %s.",
|
||
(const char*)qta_prev.string());
|
||
return FALSE;
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool TTabelle_sconti::handle_sca(TMask_field &f, KEY k)
|
||
{
|
||
TMask& m = f.mask();
|
||
if (f.to_check(k))
|
||
{
|
||
int sca = atoi(f.get());
|
||
if (sca == 1) return TRUE;
|
||
|
||
TRelation sconti(LF_SCONTI);
|
||
|
||
m.autosave(sconti);
|
||
|
||
TRectype r(sconti.curr());
|
||
|
||
sconti.read();
|
||
if (sconti.bad()) // se non l'ha trovato significa che e' in inserimento
|
||
{
|
||
sca--;
|
||
sconti.curr() = r;
|
||
sconti.curr().put("NSCAGL",sca); //cerca quello precedente...
|
||
if (sconti.read() != NOERR) // se non lo trova segnala l'errore di errata sequenza
|
||
{
|
||
f.error_box("Il numero di scaglione immesso non e' in sequenza.");
|
||
return FALSE;
|
||
}
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool TTabelle_sconti::handle_check(TMask_field &f, KEY k)
|
||
{
|
||
if (f.to_check(k))
|
||
{
|
||
TEditable_field & check_field = f.mask().efield(f.dlg() + 100);
|
||
|
||
check_field.set(f.get());
|
||
if (!check_field.check())
|
||
return f.error_box(check_field.get_warning());
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
/*
|
||
bool TTabelle_sconti::handle_um(TMask_field &f, KEY k)
|
||
{
|
||
if (f.to_check(k))
|
||
{
|
||
TMask& m = f.mask();
|
||
TString art(m.get(F_R_CODART));
|
||
TLocalisamfile a(LF_UMART);
|
||
a.setkey(2);
|
||
a.put("UM",f.get());
|
||
a.put("CODART",art);
|
||
if (a.read() != NOERR)
|
||
{
|
||
f.error_box("Unita' di misura non presente per l'articolo indicato");
|
||
return FALSE;
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
*/
|
||
|
||
bool TTabelle_sconti::user_create()
|
||
{
|
||
bool gotcha= FALSE; // booleano di avvenuta inizializzazione
|
||
|
||
_sconti= '*'; // inizializzazione dell'indicatore del tipo di tabella
|
||
if (argc()>2)
|
||
_sconti = toupper((argv(2))[0]); // se c'<27>, prende il tipo di tabella dalla linea di comando
|
||
else
|
||
{
|
||
TMask choose("ve2100"); // istanzia la maschera di scelta del tipo di tabella
|
||
if (choose.run() == K_ENTER)
|
||
_sconti = toupper((choose.get(F_TIPOSC))[0]); // prende il tipo di tabella dalla maschera
|
||
else
|
||
return FALSE;
|
||
}
|
||
TConfig prassid(CONFIG_DITTA, "ve"); // apre il file di configurazione di ditta
|
||
switch (_sconti) {
|
||
case 'D': // sconti documento
|
||
_msk= new TMask("ve2100d"); // apre la maschera relativa
|
||
set_search_field(F_D_CODCAT); // setta il campo di ricerca
|
||
gotcha= TRUE;
|
||
break;
|
||
case 'R': // sconti di riga
|
||
_gesscoriga = prassid.get("GESSCORIGA"); // legge lo stato del parametro di abilitazione degli sconti riga
|
||
if (_gesscoriga == "A")
|
||
{
|
||
_msk= new TMask("ve2100r"); // apre la maschera relativa
|
||
|
||
_catven= prassid.get_bool("GESSCORIGACV"); // legge il parametro di abilitazione delle categorie di vendita
|
||
if (!_catven)
|
||
key_disable(*_msk, F_R_CODCAT); // se non <20> abilitato, viene disabilitato anche il campo
|
||
|
||
_scoum = prassid.get_bool("GESSCOUM"); // legge il parametro di abilitazione delle unita' di misura
|
||
if (!_scoum)
|
||
key_disable(*_msk, F_R_UM); // se non e' abilitato, viene disabilitato anche il campo
|
||
// else
|
||
// _msk->set_handler(F_R_UM,handle_um);
|
||
|
||
_sca = prassid.get_bool("GESSCOSCA"); // legge il parametro di abilitazione degli scaglioni
|
||
if (!_sca)
|
||
{
|
||
key_disable(*_msk, F_R_SCA); // se non e' abilitato, viene disabilitato anche il campo
|
||
_msk->disable(F_R_QLIM); // disabilita pure la qta' limite
|
||
}
|
||
else
|
||
{
|
||
_msk->set_handler(F_R_QLIM, handle_qta); // setta l'handler per controllare la quantita' limite
|
||
_msk->set_handler(F_R_SCA, handle_sca); // setta l'handler per controllare la sequenza degli scaglioni
|
||
}
|
||
_msk->set_handler(F_R_CODART_A,handle_check);
|
||
_msk->set_handler(F_R_RFA_A,handle_check);
|
||
_msk->set_handler(F_R_GRM_A,handle_check);
|
||
_msk->set_handler(F_R_SGM_A,handle_check);
|
||
gotcha= TRUE;
|
||
|
||
const char * rigakey = prassid.get("SCORIGAKEY");
|
||
|
||
_msk->set(F_R_TIPO_RIGA, rigakey);
|
||
switch (*rigakey)
|
||
{
|
||
case 'A' :
|
||
key_hide(*_msk, F_R_RFA_A);
|
||
key_hide(*_msk, F_R_RFA);
|
||
key_hide(*_msk, F_R_GRM_A);
|
||
key_hide(*_msk, F_R_GRM);
|
||
key_hide(*_msk, F_R_SGM_A);
|
||
key_hide(*_msk, F_R_SGM);
|
||
break;
|
||
case 'R' :
|
||
key_hide(*_msk, F_R_CODART_A);
|
||
key_hide(*_msk, F_R_CODART);
|
||
key_hide(*_msk, F_R_GRM_A);
|
||
key_hide(*_msk, F_R_GRM);
|
||
key_hide(*_msk, F_R_SGM_A);
|
||
key_hide(*_msk, F_R_SGM);
|
||
break;
|
||
case 'C' :
|
||
key_hide(*_msk, F_R_CODART_A);
|
||
key_hide(*_msk, F_R_CODART);
|
||
key_hide(*_msk, F_R_RFA_A);
|
||
key_hide(*_msk, F_R_RFA);
|
||
key_hide(*_msk, F_R_GRM_A);
|
||
key_hide(*_msk, F_R_GRM);
|
||
break;
|
||
case 'L' :
|
||
key_hide(*_msk, F_R_CODART_A);
|
||
key_hide(*_msk, F_R_CODART);
|
||
key_hide(*_msk, F_R_RFA_A);
|
||
key_hide(*_msk, F_R_RFA);
|
||
key_hide(*_msk, F_R_SGM_A);
|
||
key_hide(*_msk, F_R_SGM);
|
||
break;
|
||
default :
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
error_box("Gli sconti di riga non sono abilitati nella configurazione");
|
||
break;
|
||
case 'I': // sconti incondizionati
|
||
_gessco= prassid.get("GESSCO"); // legge lo stato del parametro di abilitazione degli sconti
|
||
if (_gessco=="A") {
|
||
_msk= new TMask("ve2100i"); // apre la maschera relativa
|
||
// inizializza l'array dei campi da disabilitare condizionalmente
|
||
_sci_k_id[0].normal_field = F_I_CATVEN;
|
||
_sci_k_id[0].search_field = F_I_RICERCA;
|
||
_sci_k_id[0].enabled = TRUE;
|
||
_sci_k_id[1].normal_field = F_I_SCCLIENTI;
|
||
_sci_k_id[1].search_field = F_I_RICERCA_SC;
|
||
_sci_k_id[1].enabled = TRUE;
|
||
_sci_k_id[2].normal_field = F_I_ZONE;
|
||
_sci_k_id[2].search_field = F_I_RICERCA_ZO;
|
||
_sci_k_id[2].enabled = TRUE;
|
||
_sci_k_id[3].normal_field = F_I_CONDPAG;
|
||
_sci_k_id[3].search_field = F_I_RICERCA_CO;
|
||
_sci_k_id[3].enabled = TRUE;
|
||
_msk->set_handler(F_I_RICERCA, handle_check);
|
||
_msk->set_handler(F_I_RICERCA_SC, handle_check);
|
||
_msk->set_handler(F_I_RICERCA_ZO, handle_check);
|
||
_msk->set_handler(F_I_RICERCA_CO, handle_check);
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
if (!prassid.get_bool("SCOKEY", NULL, i+1)) // se nel file di config. il campo non <20> abilitato...
|
||
{
|
||
key_disable(*_msk, _sci_k_id[i].normal_field); // il campo non <20> abilitato viene disabilitato anche sulla maschera
|
||
key_disable(*_msk, _sci_k_id[i].search_field);
|
||
_sci_k_id[i].enabled = FALSE;
|
||
}
|
||
else gotcha = TRUE;
|
||
}
|
||
if (!gotcha) error_box("Non ci sono campi chiave abilitati nella configurazione della ditta");
|
||
////
|
||
////
|
||
//// Necessito della possibilita' di cambiare il filtro alla browse di un TEdit_field!!
|
||
//// Cosi' posso far vedere solo i record editabili.
|
||
////
|
||
} else error_box("Gli sconti incondizionati non sono abilitati nella configurazione");
|
||
break;
|
||
default: // messaggio di errore se si indica una tabella non valida
|
||
error_box("Indicare la tabella sulla linea di comando (D, R o I) oppure selezionarla dalla maschera di partenza");
|
||
break;
|
||
}
|
||
if (gotcha) _rel= new TRelation(LF_SCONTI); // se <20> stata selezionata una tabella, apre la relazione (un unico file)
|
||
return (gotcha);
|
||
}
|
||
|
||
bool TTabelle_sconti::user_destroy() {
|
||
delete _rel;
|
||
delete _msk;
|
||
return TRUE;
|
||
}
|
||
|
||
void TTabelle_sconti::init_query_mode(TMask& m) {
|
||
|
||
switch (_sconti)
|
||
{
|
||
case 'D':
|
||
set_search_field(F_D_CODCAT); // setta il campo di ricerca
|
||
break;
|
||
case 'I':
|
||
{
|
||
for (int i = 0; i < 4 ; i++)
|
||
{
|
||
if (_sci_k_id[i].enabled)
|
||
{
|
||
m.show(_sci_k_id[i].search_field);
|
||
m.hide(_sci_k_id[i].normal_field);
|
||
key_enable(m,_sci_k_id[i].search_field);
|
||
key_disable(m,_sci_k_id[i].normal_field);
|
||
}
|
||
}
|
||
set_search_field(F_I_RICERCA);
|
||
}
|
||
break;
|
||
case 'R':
|
||
{
|
||
const char * rigakey = m.get(F_R_TIPO_RIGA);
|
||
|
||
switch (*rigakey)
|
||
{
|
||
case 'A' :
|
||
m.show(F_R_CODART_A);
|
||
m.hide(F_R_CODART);
|
||
set_search_field(F_R_CODART_A); // setta il campo di ricerca
|
||
break;
|
||
case 'R' :
|
||
m.show(F_R_RFA_A);
|
||
m.hide(F_R_RFA);
|
||
set_search_field(F_R_RFA_A); // setta il campo di ricerca
|
||
break;
|
||
case 'C' :
|
||
m.show(F_R_SGM_A);
|
||
m.hide(F_R_SGM);
|
||
set_search_field(F_R_SGM_A); // setta il campo di ricerca
|
||
break;
|
||
case 'L' :
|
||
m.show(F_R_GRM_A);
|
||
m.hide(F_R_GRM);
|
||
set_search_field(F_R_GRM_A); // setta il campo di ricerca
|
||
break;
|
||
default :
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
default: break;
|
||
}
|
||
}
|
||
|
||
void TTabelle_sconti::init_query_insert_mode(TMask& m)
|
||
{
|
||
switch (_sconti)
|
||
{
|
||
case 'D':
|
||
set_search_field(F_D_CODCAT); // setta il campo di ricerca
|
||
break;
|
||
case 'I':
|
||
{
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
if (_sci_k_id[i].enabled)
|
||
{
|
||
m.show(_sci_k_id[i].normal_field);
|
||
m.hide(_sci_k_id[i].search_field);
|
||
key_enable(m,_sci_k_id[i].normal_field);
|
||
key_disable(m,_sci_k_id[i].search_field);
|
||
}
|
||
}
|
||
set_search_field(F_I_CATVEN);
|
||
}
|
||
break;
|
||
case 'R':
|
||
{
|
||
const char * rigakey = m.get(F_R_TIPO_RIGA);
|
||
|
||
switch (*rigakey)
|
||
{
|
||
case 'A' :
|
||
m.show(F_R_CODART);
|
||
m.hide(F_R_CODART_A);
|
||
set_search_field(F_R_CODART); // setta il campo di ricerca
|
||
break;
|
||
case 'R' :
|
||
m.show(F_R_RFA);
|
||
m.hide(F_R_RFA_A);
|
||
set_search_field(F_R_RFA); // setta il campo di ricerca
|
||
break;
|
||
case 'C' :
|
||
m.show(F_R_SGM);
|
||
m.hide(F_R_SGM_A);
|
||
set_search_field(F_R_SGM); // setta il campo di ricerca
|
||
break;
|
||
case 'L' :
|
||
m.show(F_R_GRM);
|
||
m.hide(F_R_GRM_A);
|
||
set_search_field(F_R_GRM); // setta il campo di ricerca
|
||
break;
|
||
default :
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
default: break;
|
||
}
|
||
}
|
||
|
||
void TTabelle_sconti::renumber_sca(const TRectype& r)
|
||
{
|
||
TRectype from(r);
|
||
from.zero("NSCAGL");
|
||
TRecord_array rec_arr(from,"NSCAGL");
|
||
if (rec_arr.read(from) == NOERR)
|
||
{
|
||
rec_arr.pack();
|
||
rec_arr.rewrite();
|
||
}
|
||
}
|
||
|
||
bool TTabelle_sconti::remove()
|
||
{
|
||
TRectype r(LF_SCONTI);
|
||
const bool rt = TRelation_application::remove();
|
||
if (_sca) // rinumera gli scaglioni
|
||
renumber_sca(r);
|
||
return rt;
|
||
}
|
||
|
||
int ve2100(int argc, char* argv[]) {
|
||
TTabelle_sconti a;
|
||
|
||
a.run(argc, argv, "Tabella sconti ");
|
||
return 0;
|
||
}
|