root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/lv/lv3300.cpp
luca83 052f340bb7 Patch level : 10.0 patch 494 
Files correlati     : lv3, lvbolacp.msk verig24.msk lvmenu
Ricompilazione Demo : [ ]
Commento            :
Aggiunta la gestione dei buoni di prelievo (con relativa chiasmata a menu e relativo profilo)

Correzioni varie sull'evasione dei buoni di prelievo


git-svn-id: svn://10.65.10.50/trunk@19564 c028cbd2-c16b-5b4b-a496-9718f37d4682
2009-11-04 10:06:55 +00:00

1227 lines
38 KiB
C++
Executable File
Raw Blame History

#include <execp.h>
#include "../ve/ve0100.h"
#include "../ve/veini.h"
#include "../ve/veuml.h"
#include "../ve/veuml3.h"
#include "../ve/verig.h"
#include "../ve/vepriv.h"
#include "lvlib.h"
#include "lvcondv.h"
#include "lvrcondv.h"
#include "lvrconsplan.h"
#include "../mg/clifogiac.h"
#include "../ve/rcondv.h"
#define FOR_EACH_DOC_ROW_BACK(d, r, row) const TRiga_documento* row = NULL; for (int r = d.rows(); r > 0 && (row = &d[r]) != NULL; r--)
//////////////////////////////////////////
//// CLASSE TGESTIONE_BUONI_MSK ////
//////////////////////////////////////////
//Definizione della classe della maschera
class TGestione_buoni_msk : public TDocumento_mask
{
long _stcodcf;
long _stcodcont;
protected:
static void arrotonda(const TMask& msk, real& quantita);
static void dettaglio_causale(TSheet_field& ss);
//hanlder di documento:
static bool set_data_handler(TMask_field& f, KEY k);
static bool set_contratto_handler(TMask_field& f, KEY k);
static bool set_dataprco_handler(TMask_field& f, KEY k);
static bool set_righe_buono_handler(TMask_field& f, KEY k);
static bool pre_ritirato_handler(TMask_field& f, KEY k);
static bool pre_daconsegnare_handler(TMask_field& f, KEY k);
static bool pre_codart_handler(TMask_field& f, KEY k);
static bool pre_causale_handler(TMask_field& f, KEY k);
static bool pre_codmag_handler(TMask_field& f, KEY k);
static bool ss_notify(TSheet_field& ss, int r, KEY key);
static bool ss_handler(TMask_field& f, KEY key);
virtual void on_idle();
public:
virtual void user_set_handler( short fieldid, int index);
virtual void user_set_row_handler(TMask& rm, short field, int index);
void reset_var_mask() {_stcodcf = 0; _stcodcont = 0;}
TDate proponi_dataprco() const;
TGestione_buoni_msk(const char* tipodoc);
int _autoselect;
};
//////////////////////////////////////////
//// CLASSE TGESTIONE_BUONI_APP ////
//////////////////////////////////////////
// Definizione della classe dell'applicazione motore
class TGestione_buoni_app : public TMotore_application
{
TGiac_per_cli _giac;
protected:
virtual TMask* get_mask( int mode );
virtual int write( const TMask& m );
virtual int rewrite( const TMask& m );
virtual int read ( TMask& m );
virtual void init_insert_mode( TMask& m );
virtual void init_modify_mode( TMask& m );
void elimina_vuote( const TMask& m);
virtual const char * query_mask_name() { return "lv3300a"; }
public:
TGiac_per_cli& giacenza();
TGestione_buoni_app() {}
};
inline TGestione_buoni_app& gbapp() { return (TGestione_buoni_app &)main_app(); };
//////////////////////////////////////////
//// CLASSE TGestione_buoni_msk ////
//////////////////////////////////////////
//ARROTONDA: metodo che arrotonda la quantit<69> che gli passo se <20> previsto sul contratto
void TGestione_buoni_msk::arrotonda(const TMask& msk, real& quantita)
{
int perarr = ini_get_int(CONFIG_DITTA, "lv", "Perarr");
const TString& codart = msk.get(FR_CODART);
//instanzio una cache sulla tabella del magazzino
const TRectype& anamag = cache().get(LF_ANAMAG,codart);
//recupero i dati di interesse dall'anagrafica di magazzino
const long ppconf = anamag.get_long(ANAMAG_PPCONF);
if (ppconf > 0)
{
TDocumento_mask& dmsk = (TDocumento_mask&) msk.get_sheet()->mask();
//recupero dal documento i dati di interesse per recuperare...
//...i dati dalla riga contratto
const long codcf = dmsk.get_long(F_CODCF);
const int indsped = dmsk.get_int(F_CODINDSP);
TDate datadoc = dmsk.get_date(F_DATADOC);
if (!datadoc.ok())
datadoc = TODAY;
const TLaundry_contract cont(codcf, indsped, datadoc);
//leggo la riga del contratto per l'articolo corrente
const TRectype& rcont = cont.row(codart);
//recupero i dati di interesse dalla riga del contratto
if (rcont.get_int(LVRCONDV_CALCCONS) == 1)
{
//calcolo di quanti pezzi sforo
long arr = quantita.integer() % ppconf;
//calcolo quanti pezzi in pi<70> o in meno gli devo dare e aggiorno la quantit<69>
if (arr > ppconf * perarr / 100) //arr <= ppconf*perarr/100 -> formula calcolo congualgio di Tassan
{
arr = ppconf - arr;
quantita += arr;
}
else
quantita -= arr;
}
}
}
//DETTAGLIO_CAUSALE: metodo che setta esplode la causale negli appositi campi
void TGestione_buoni_msk::dettaglio_causale(TSheet_field& ss)
{
TGestione_buoni_msk& dmsk = (TGestione_buoni_msk&) ss.mask();
TString4 causale = ss.cell(ss.selected(),ss.cid2index(FR_CODAGG1));
//instanzio una cache sulle causali
const TCausale_lavanderie cau(causale);
//esplodo la causale
dmsk.set(F_LVCODCAU, cau.codice());
dmsk.set(F_LVDESCAU, cau.descr());
}
//PROPONI_DATAPRCO: metodo che propone la prima data di prevista consegna
TDate TGestione_buoni_msk::proponi_dataprco() const
{
TDate dadata = get(F_DATADOC);
TDate dataprco = NULLDATE;
if (dadata.ok())
{
TDate adata = dadata;
++dadata;
adata.addmonth(1);
TString query = "USE LVRCONSPLAN KEY 3\n";
query << "FROM CODCF=" << get(F_CODCF) << " CODCONT=" << get(F_LVCODCONT) << " DTCONS=" << dadata << "\n";
query << "TO CODCF=" << get(F_CODCF) << " CODCONT=" << get(F_LVCODCONT) << " DTCONS=" << adata << "\n";
TISAM_recordset consegne(query);
if (consegne.move_first())
dataprco = consegne.get(LVRCONSPLAN_DTCONS).as_date();
}
return dataprco;
}
////////////////////////////
// HANDLER DI DOCUMENTO //
////////////////////////////
void TGestione_buoni_msk:: on_idle()
{
TDocumento_mask::on_idle();
if (_autoselect >= 0)
{
TSheet_field& s = sfield(F_SHEET);
if (_autoselect < s.items())
{
//per ora 4 fisso perch<63> non sappiamo calcolare la colonna del ritirato
s.set_focus_cell_id(_autoselect, FR_QTAGG1);
dettaglio_causale(s);
}
_autoselect = -1;
}
}
//magico metodo per settare, al cambio riga dello sheet, il focus sul campo desiderato (il campo in questione <20>..
//..definito nella on_idle(); ricordarsi la set_notify() nel costruttore della maschera senno' viene eseguito l'ss_notify()..
//..standard e non questo qui ridefinito. Allah!
bool TGestione_buoni_msk::ss_notify(TSheet_field& ss, int r, KEY key)
{
TGestione_buoni_msk& dmsk = (TGestione_buoni_msk&) ss.mask();
if (key == K_TAB && dmsk._autoselect < 0 && dmsk.is_running())
dmsk._autoselect = r; //riga per settare il focus
return TDocumento_mask::ss_notify(ss, r, key);
}
//SS_HANDLER: handler che mi peremette di evitare la registrazione in caso di documento
//senza righe valide (cio<69> con quantit<69> diverese da zero)
bool TGestione_buoni_msk::ss_handler(TMask_field& f, KEY key)
{
if ((key == K_ENTER) && f.mask().insert_mode())
{
TSheet_field& ss = (TSheet_field&)f;
bool vuote = true;
if (ss.items() > 0)
vuote = false;
if(!vuote)
{
vuote = true;
FOR_EACH_SHEET_ROW(ss, r, row)
{
if (row->get_int(ss.cid2index(FR_QTA)) != 0 || row->get_int(ss.cid2index(FR_QTAGG1)) != 0)
vuote = false;
}
}
if (!app().is_transaction() && vuote)
return error_box(TR("Il documento e' privo di righe valide e pertanto verr<72> ignorato"));
}
return TDocumento_mask::ss_handler(f, key);
}
//SET_DATA_HANDLER: handler che si occupa di decodificare i campi data in testata
bool TGestione_buoni_msk::set_data_handler(TMask_field& f, KEY k)
{
bool ok = true;
switch(f.dlg())
{
case F_DATADOC: ok = data_hndl( f, k ); break;
default: break;
}
TGestione_buoni_msk& dmsk = (TGestione_buoni_msk&)f.mask();
TDate oggi(TODAY);
TDate primo = oggi;
primo.set_day(1);
if (dmsk.get_date(F_DATADOC) != oggi)
{
oggi = dmsk.get_date(F_DATADOC);
primo = oggi;
primo.set_day(1);
}
//decodifica del giorno della settimana
dmsk.set(F_LVGIORNO, itow(oggi.wday()));
//settimana del mese = settimana(oggi) - settimana(primo del mese) + 1
long tmp = oggi.week() - primo.week() + 1;
TString4 settimana;
settimana << tmp;
dmsk.set(F_LVSETTIMANA, settimana);
return ok;
}
//SET_CONTRATTO_HANDLER: handler che si occupa di riempire il campo contratto in testata
bool TGestione_buoni_msk::set_contratto_handler(TMask_field& f, KEY k)
{
TGestione_buoni_msk& dmsk = (TGestione_buoni_msk&)f.mask();
const long codcf = dmsk.get_long(F_CODCF);
const int indsped = dmsk.get_int(F_CODINDSP);
TDate datadoc = dmsk.get_date(F_DATADOC);
if (!datadoc.ok())
datadoc = TODAY;
const int anno = datadoc.year();
if (codcf <= 0)
return true;
long codcont = lv_find_contract(codcf, indsped, datadoc);
if (codcont <= 0)
{
warning_box(TR("Non ci sono contratti in essere alla data indicata"));
return true;
}
else
{
TString16 tmp;
tmp << codcont;
dmsk.set(F_LVCODCONT, tmp);
const TDate dataprco = dmsk.proponi_dataprco();
if (dataprco.ok() && dmsk.field(F_LVDATAPRCO).empty())
dmsk.set(F_LVDATAPRCO, dataprco);
}
return true;
}
//SET_DATAPRCO_HANDLER: handler che si occupa della gestione del campo "data di prevista consegna"
bool TGestione_buoni_msk::set_dataprco_handler(TMask_field& f, KEY k)
{
//se sto leggendo o generando un buono di ritiro, abilito questo campo
if (k == K_TAB)
{
TGestione_buoni_msk& dmsk = (TGestione_buoni_msk&)f.mask();
TDocumento& doc = dmsk.doc();
//se la data viene modificata a mano, controlla se <20> una data di previsto passaggio;
//se non lo <20> chiedi conferma se si desidera mantenre la data indicata manualmente o se
//<2F> meglio riproporre la data di previsto passaggio
if (!f.empty() && f.focusdirty() && doc.get_date("DATAPRCO") != (TDate)f.get())
{
doc.put("DATAPRCO", f.get());
TString query1 = "USE LVRCONSPLAN KEY 3\n";
query1 << "FROM CODCF=" << dmsk.get(F_CODCF) << " CODCONT=\"" << dmsk.get(F_LVCODCONT) << "\" DTCONS=" << f.get() << "\n";
query1 << "TO CODCF=" << dmsk.get(F_CODCF) << " CODCONT=\"" << dmsk.get(F_LVCODCONT) << "\" DTCONS=" << f.get() << "\n";
TISAM_recordset consegne(query1);
if (!consegne.move_first())
{
f.set_focusdirty(false);
if (!yesno_box(TR("Non <20> previsto nessun passaggio per questa data, confermi lo stesso?")))
{
const TDate dataprco = dmsk.proponi_dataprco();
if (dataprco.ok())
{
f.set(dataprco);
doc.put("DATAPRCO", dataprco);
}
}
}
}
}
return true;
}
//SET_RIGHE_BUONO_HANDLER: handler di bolla, carica le righe contratto sulle bolle, preparando la struttura del documento
bool TGestione_buoni_msk::set_righe_buono_handler(TMask_field& f, KEY k)
{
bool ok = true;
switch(f.dlg())
{
case F_CODCF: ok = TDocumento_mask::clifo_handler( f, k ); break;
default: break;
}
TGestione_buoni_msk& dmsk = (TGestione_buoni_msk&)f.mask();
if (ok && k == K_TAB && ((dmsk.insert_mode() && f.to_check(k, true)) || f.focusdirty()))
{
f.set_focusdirty(false);
TDocumento& doc = dmsk.doc();
TSheet_field& sheet = dmsk.sfield(F_SHEET);
int nrighe = sheet.items();
const long codcf = dmsk.get_long(F_CODCF);
const int indsped = dmsk.get_int(F_CODINDSP);
TDate datadoc = dmsk.get_date(F_DATADOC);
if (!datadoc.ok())
datadoc = TODAY;
const int anno = datadoc.year();
if (codcf <= 0)
return true;
const long codcont = lv_find_contract(codcf,indsped,datadoc);
if (codcont <= 0)
{
warning_box(TR("Non ci sono contratti in essere alla data indicata"));
return true;
}
else
{
doc.put(DOC_CODCF, codcf);
doc.put(DOC_DATADOC, datadoc);
doc.put(DOC_CODINDSP, indsped);
doc.put(DOC_CODCONT, codcont);
const TDate dataprco = dmsk.proponi_dataprco();
if (dataprco.ok() && dmsk.field(F_LVDATAPRCO).empty())
doc.put("DATAPRCO", dataprco);
}
if (dmsk._stcodcf == codcf && dmsk._stcodcont == codcont && nrighe > 0)
return true;
dmsk.mask2doc();
dmsk._stcodcf = codcf;
dmsk._stcodcont = codcont;
//elimino tutte le righe del documento
doc.destroy_rows();
//tipo riga
const TString& tprig = dmsk.get(F_LBTIPORIGA);
//instanzio una cache sulla tabella dei contratti
const TLaundry_contract tcont(codcf, codcont);
//estraggo i dati di interesse dalla cache
const int tplis = tcont.get_int(LVCONDV_TIPOLIS); //tipo listino
//instanzio un recordset sulle righe del contratto considerato
TISAM_recordset rcont("USE LVRCONDV\nFROM CODCF=#CODCF CODCONT=#CODCONT\nTO CODCF=#CODCF CODCONT=#CODCONT");
rcont.set_var("#CODCF",codcf);
rcont.set_var("#CODCONT",codcont);
//leggo dalla configurazione i codici magazzino e deposito standard
TString8 codmag;
codmag << ini_get_string(CONFIG_DITTA, "lv", "CODMAG") << ini_get_string(CONFIG_DITTA, "lv", "CODMAGC");
//per ogni riga estraggo l'articolo, il relativo prezzo e l'eventaule sconto da applicare,
//...riportati in bolla solo se necessario
for (bool ok = rcont.move_first(); ok; ok = rcont.move_next())
{
//creo una nuova riga documento
TRiga_documento& rdoc = doc.new_row(tprig);
//recupero i dati di interesse dalla riga del contratto e li inserisco sullo sheet
const TString80 codart = rcont.get(LVRCONDV_CODART).as_string();
TString4 causale = rcont.get(LVRCONDV_CAUSLAV).as_string();
if (causale.blank() || atoi(causale) == 0)
causale = ini_get_string(CONFIG_DITTA, "lv", "CAUSLAV");
//instanzio una cache sulle anagrafice di magazzino
const TRectype& anamag = cache().get(LF_ANAMAG,codart);
TToken_string key;
key.add(codart);
key.add(1);
const TRectype& umart = cache().get(LF_UMART, key);
rdoc.put(RDOC_CODART,codart);
rdoc.put(RDOC_CODARTMAG,codart);
rdoc.put(RDOC_CHECKED,'X');
rdoc.put(RDOC_DESCR, anamag.get(ANAMAG_DESCR));
rdoc.put(RDOC_UMQTA, umart.get(UMART_UM));
rdoc.put(RDOC_CODAGG1,causale);
rdoc.put(RDOC_CODIVA,anamag.get(ANAMAG_CODIVA));
TString8 codmagold = rdoc.get(RDOC_CODMAG);
if (codmagold.empty())
{
rdoc.put(RDOC_CODMAG, codmag);
rdoc.put(RDOC_CODMAGC, codmag);
}
//gestione campi dotazione odierna e dotazione temporanea
TGiac_per_cli& giac = gbapp().giacenza();
giac.preset(doc);
real dotod = giac.giac_att(rdoc, true);
rdoc.put("DOTOD", dotod);
real dotmp = giac.giac_att(rdoc, false);
rdoc.put("DOTMP", dotmp);
//elaborazione per il prezzo: o lo prendo dalle righe contratto, o dall'anagrafica magazzino
const TString& sconto = rcont.get(LVRCONDV_SCONTPERC).as_string();
rdoc.put(RDOC_SCONTO, sconto);
//controllo da dove devo prendere il prezzo
real prezzo;
if (tplis == 0)
prezzo = rcont.get(LVRCONDV_PREZZO).as_real();
else
prezzo = anamag.get_real(ANAMAG_COSTSTD);
rdoc.put(RDOC_PREZZO, prezzo);
}
dmsk.doc2mask(false);
FOR_EACH_MASK_FIELD(dmsk, i, f)
{
if (f->has_check())
f->check(STARTING_CHECK);
if (f->is_edit())
f->on_hit();
}
const int poscons = sheet.cid2index(FR_QTAEVASA);
const int pospacchi = sheet.cid2index(FR_NCOLLI);
const int posdotod = sheet.cid2index(FR_JOLLY1);
const int posdotmp = sheet.cid2index(FR_JOLLY2);
const int posdatmp = sheet.cid2index(FR_JOLLY3);
const int posatmp = sheet.cid2index(FR_JOLLY4);
const int posrif = sheet.cid2index(FR_JOLLY5);
FOR_EACH_SHEET_ROW(sheet, i, riga)
{
sheet.disable_cell(i, poscons);
sheet.disable_cell(i, pospacchi);
sheet.disable_cell(i, posdotod);
sheet.disable_cell(i, posdotmp);
sheet.disable_cell(i, posdatmp);
sheet.disable_cell(i, posatmp);
sheet.disable_cell(i, posrif);
}
sheet.force_update();
dmsk._autoselect = 0;
}
return ok;
}
//PRE_RITIRATO_HANDLER: handler sul campo ritirato, che copia nel campo consegnato
//lo stesso valore eventualmente arrotondato e aggiorna il campo "dotazione odierna" (sempre)
//e il campo "dotazione temporanea" (se la causale <20> giusta)
bool TGestione_buoni_msk::pre_ritirato_handler(TMask_field& f, KEY k)
{
if (f.to_check(k))
{
//maschera di riga
TMask& msk = f.mask();
//maschera di documento
TSheet_field* sheet = msk.get_sheet();
TDocumento_mask& dmsk = (TDocumento_mask&)sheet->mask();
const long codcf = dmsk.get_long(F_CODCF);
const int indsped = dmsk.get_int(F_CODINDSP);
TDate datadoc = dmsk.get_date(F_DATADOC);
if (!datadoc.ok())
datadoc = TODAY;
//recupero i valori della dotazione iniziale dal magazzino del cliente
TLocalisamfile magcli(LF_CLIFOGIAC);
magcli.put(CLIFOGIAC_ANNOES, datadoc.year());
magcli.put(CLIFOGIAC_TIPOCF, 'C');
magcli.put(CLIFOGIAC_CODCF, codcf);
magcli.put(CLIFOGIAC_INDSPED, indsped);
magcli.put(CLIFOGIAC_CODART, msk.get(FR_CODART));
magcli.put(CLIFOGIAC_NRIGA, 1);
//leggo il record corrispondente
magcli.read();
long dotin = magcli.get_long(CLIFOGIAC_DOTIN);
real ritirato = f.get();
real dotod = msk.get_real(FR_JOLLY1);
if (ritirato > dotod && f.dirty() && dotin > 0)
warning_box(TR("ATTENZIONE: stai ritirando un quantitativo maggiore della dotazione!"));
TDocumento& doc = dmsk.doc();
TRiga_documento& rdoc = dmsk.doc()[sheet->selected()+1];
rdoc.put(RDOC_QTAGG1,ritirato);
if (msk.field(FR_QTA).enabled() && msk.field(FR_QTA).empty() && !msk.field(FR_QTA).focusdirty())
{
real consegnato = ritirato;
arrotonda(msk, consegnato);
msk.set(FR_QTA, consegnato, 0x3);
return true;
}
//gestione campi dotazione odierna e dotazione temporanea
TGiac_per_cli& giac = gbapp().giacenza();
dotod = giac.giac_att(rdoc, true);
msk.set(FR_JOLLY1, dotod);
rdoc.put("DOTOD", dotod);
//scrivo la dotazione temporanea solo se esistono le date di dotazione temporanea e questa non <20> scaduta
if (rdoc.get_date("DADATATMP").ok() && rdoc.get_date("ADATATMP").ok() && rdoc.get_date("ADATATMP") >= doc.get_date(DOC_DATADOC))
{
real dotmp = giac.giac_att(rdoc, false);
msk.set(FR_JOLLY2, dotmp);
rdoc.put("DOTMP", dotmp);
}
}
return true;
}
//PRE_DACONSEGNARE_HANDLER: per adesso <20> solo un segna - posto
bool TGestione_buoni_msk::pre_daconsegnare_handler(TMask_field& f, KEY k)
{
bool ok = true;
switch(f.dlg())
{
case FR_QTA: ok = qta_handler( f, k ); break;
default: break;
}
if (f.to_check(k))
{
TMask& msk = f.mask();
real consegnato = f.get();
//gestione campi dotazione odierna e dotazione temporanea
TSheet_field* sheet = msk.get_sheet();
TDocumento_mask& dmask = (TDocumento_mask&)sheet->mask();
TDocumento& doc = dmask.doc();
TRiga_documento& rdoc = dmask.doc()[sheet->selected()+1];
rdoc.put(RDOC_QTA, consegnato);
TGiac_per_cli& giac = gbapp().giacenza();
real dotod = giac.giac_att(rdoc, true);
msk.set(FR_JOLLY1, dotod);
rdoc.put("DOTOD", dotod);
//scrivo la dotazione temporanea solo se esistono le date di dotazione temporanea e questa non <20> scaduta
if (rdoc.get_date("DADATATMP").ok() && rdoc.get_date("ADATATMP").ok() && rdoc.get_date("ADATATMP") >= doc.get_date(DOC_DATADOC))
{
real dotmp = giac.giac_att(rdoc, false);
msk.set(FR_JOLLY2, dotmp);
rdoc.put("DOTMP", dotmp);
}
}
return ok;
}
//PRE_CODART_HANDLER: handler sul campo codice articolo, che carica la causale relativa all'articolo
//e controlla se l'articolo che si sta inserendo fa parte della dotazione del cliente
bool TGestione_buoni_msk::pre_codart_handler(TMask_field& f, KEY k)
{
bool ok = true;
switch(f.dlg())
{
case FR_CODART: ok = codart_handler( f, k ); break;
default: break;
}
if (ok && (k == K_ENTER || k == K_TAB))
{
TMask& msk = f.mask();
const TString& codart = msk.get(FR_CODART);
if (codart.full())
{
TGestione_buoni_msk& dmsk = (TGestione_buoni_msk&) msk.get_sheet()->mask();
TSheet_field* sheet = msk.get_sheet();
TRiga_documento& rdoc = dmsk.doc()[sheet->selected()+1];
rdoc.put(RDOC_CODART, codart);
//recupero dal documento i dati di interesse per recuperare...
//...i dati dalla riga contratto
const long codcf = dmsk.get_long(F_CODCF);
const int indsped = dmsk.get_int(F_CODINDSP);
TDate datadoc = dmsk.get_date(F_DATADOC);
if (!datadoc.ok())
datadoc = TODAY;
TLaundry_contract cont(codcf, indsped, datadoc);
const TRectype& rcont = cont.row(codart);
//cerco la causale relativa all'articolo; se non la trovo prendo quella standard
TString4 causale = rcont.get(LVRCONDV_CAUSLAV);
if (causale.blank() || atoi(causale) == 0 )
causale = ini_get_string(CONFIG_DITTA, "lv", "CAUSLAV");
if (rdoc.get("DOTOD").empty())
{
//gestione campi dotazione odierna e dotazione temporanea
TGiac_per_cli& giac = gbapp().giacenza();
giac.preset(dmsk.doc());
real dotod = giac.giac_att(rdoc, true);
rdoc.put("DOTOD", dotod);
TString16 tmp;
tmp << dotod;
msk.field(FR_JOLLY1).set(tmp);
}
if (rdoc.get(RDOC_CODAGG1).empty())
msk.set(FR_CODAGG1, causale);
if (k == K_ENTER && rcont.get_int(LVRCONDV_CALCCONS) == 1)
{
TSheet_field* sheet = msk.get_sheet();
TRiga_documento rdoc = dmsk.doc()[sheet->selected()+1];
const real ritor = rdoc.get_real(RDOC_QTAGG4);
const real conor = rdoc.get_real(RDOC_QTAGG3);
const real ritat = msk.get_real(FR_QTAGG1);
const real conat = msk.get_real(FR_QTA);
//instanzio una cache sulle causali
causale = sheet->cell(sheet->selected(),sheet->cid2index(FR_CODAGG1));
const TCausale_lavanderie cau(causale);
if (cau.movcong() && (ritor != ritat || conor != conat))
{
const real congor = rcont.get_real(LVRCONDV_QTACONG);
const real congat = conat - ritat + congor;
rdoc.put(RDOC_QTAGG5, congat); //conguaglio dopo modifica manuale
TLocalisamfile rcondv(LF_LVRCONDV);
rcondv.put(LVRCONDV_CODCF,codcf);
rcondv.put(LVRCONDV_CODCONT,cont.get_int(LVCONDV_CODCONT));
rcondv.put(LVRCONDV_CODART,codart);
if (rcondv.read() == NOERR)
{
rcondv.put(LVRCONDV_QTACONG,congat);
rcondv.rewrite();
}
}
}
if (rcont.empty())
{
real prezzo;
//PROPONI PREZZO
TToken_string key;
key.add('C');
key.add(codcf);
const TRectype& cfven = cache().get(LF_CFVEN, key);
bool trvlst = false;
if (!cfven.empty())
{
//se <20> settata la categoria merceologica, leggo sia il listino che la cat merc, altrimenti solo il listino
TString8 codlis = cfven.get(CFV_CODLIST);
TString8 catven;
if (!ini_get_bool(CONFIG_DITTA, "ve", "GESLISCV"))
catven = "";
else
catven = cfven.get(CFV_CATVEN);
//cerco il prezzo sul listino
key.cut(0);
key.add('L'); //tipo
key.add(catven); //catven
key.add(""); //tipocf
key.add(""); //codcf
key.add(codlis); //codlis
key.add('A'); //tiporiga
key.add(codart); //codriga
key.add(""); //um
key.add(""); //nscagl
const TRectype& rcondv = cache().get(LF_RCONDV, key);
if (!rcondv.empty())
{
prezzo = rcondv.get_real(RCONDV_PREZZO);
trvlst = true;
}
}
//se non ho trovato un listino, o se non c'<27> un listino impostato
//propongo come prezzo il valore convenzionale
if (!trvlst)
{
key.cut(0);
key.add(codart);
key.add(1);
const TRectype& umart = cache().get(LF_UMART, key);
prezzo = umart.get_real(UMART_PREZZO);
if (umart.get(UMART_PREZZO).full())
trvlst = true;
}
rdoc.put(RDOC_PREZZO, prezzo);
}
//controllo se si vuole aggiungere un eventuale nuovo articolo al contratto
if (cont.get_int(LVCONDV_CODCONT) <= 0)
warning_box(TR("ATTENZIONE: stai generando una bolla per un cliente che non ha nessun contratto in essere"));
else if (k == K_ENTER && f.dirty() && msk.get(FR_CODARTMAG).full() && rcont.empty() &&
yesno_box(TR("L'articolo in esame non fa parte della dotazione standard di questo cliente."
"Si desidera aggiungerla ai contratti?")))
{
cont.add_row(codart);
//questo pezzo sostituisce il metodo edit
TFilename ininame; ininame.temp();
{
TConfig ini(ininame, "Transaction");
ini.set("Action", "LINK");
TString16 p; p << "168";
ini.set_paragraph(p);
ini.set(LVCONDV_CODCF, codcf);
ini.set(LVCONDV_CODCONT, cont.get_int(LVCONDV_CODCONT));
}
TString app = "lv0 -3";
app << " -i" << ininame;
app << " -c" << codart;
TExternal_app a(app);
ok = a.run() == 0;
}
}
}
return ok;
}
//PRE_CAUSALE_HANDLER: handler che abilita e/o disabilita i campi di consegnato e ritirato in base alla causale
//e tenendo conto se l'articolo <20> bloccato o meno
bool TGestione_buoni_msk::pre_causale_handler(TMask_field& f, KEY k)
{
if (f.to_check(k, true))
{
TString4 codmagdef = ini_get_string(CONFIG_DITTA, "lv", "CODMAG"); //magazzino
TString4 coddepdef = ini_get_string(CONFIG_DITTA, "lv", "CODMAGC"); //magazzino del circolante (deposito)
//leggo la causale che ho scritto nella riga corrente dello sheet
TString4 causale = f.get();
if (causale.full())
{
TMask& msk = f.mask();
//leggo il codart che ho scritto nella riga corrente delle sheet
const TString& codart = msk.get(FR_CODART);
//srcrivo nel documento la causale
TGestione_buoni_msk& dmsk = (TGestione_buoni_msk&) msk.get_sheet()->mask();
TSheet_field& sheet = dmsk.sfield(F_SHEET);
//esplodo la descrizione della causale
dettaglio_causale(sheet);
TDocumento& doc = dmsk.doc();
TRiga_documento& rdoc = doc[msk.get_sheet()->selected()+1];
TString4 codmag(doc.clifor().vendite().get(CFV_CODMAG));
TString4 coddep(doc.clifor().vendite().get(CFV_CODDEP));
TString4 codmagcoll(codmag);
TString4 coddepcoll(coddep);
rdoc.put(RDOC_CODAGG1, causale);
//recupero i dati di interesse dalla testata per poter trovare il contratto
const long codcf = dmsk.get_long(F_CODCF);
const int indsped = dmsk.get_int(F_CODINDSP);
TDate datadoc = dmsk.get_date(F_DATADOC);
if (!datadoc.ok())
datadoc = TODAY;
//trovo il contratto utlizzato e la riga contratto specifica che mi serve
const TLaundry_contract cont(codcf, indsped, datadoc);
const TRectype& rcont = cont.row(codart);
TCausale_lavanderie cau(causale);
//movimento o meno la dotazione temporanea/odierna a seconda di cosa prevede la causale
int sgn_rit = 0;
int sgn_con = 0;
if (cau.is_ritiro())
{
const TCausale_magazzino& rit = cau.causale_ritiro();
if (codmagcoll.blank() && rit.has_default_mag())
{
codmagcoll = rit.default_mag();
coddepcoll = rit.default_dep();
}
sgn_rit = rit.sgn(s_dottm);
}
if (cau.is_consegna())
{
const TCausale_magazzino& con = cau.causale_consegna();
if (codmag.blank() && con.has_default_mag())
{
codmag = con.default_mag();
coddep = con.default_dep();
}
sgn_con = con.sgn(s_dottm);
}
//setto il valore della dotazione temporanea
TGiac_per_cli& giac = gbapp().giacenza();
giac.preset(doc);
real dotmp = giac.giac_att(rdoc, false);
rdoc.put("DOTMP", dotmp);
TString16 tmp;
tmp << dotmp;
msk.field(FR_JOLLY2).set(tmp);
//setto le date di inizio e fine della dotazione temporanea
TDate dadata = rcont.get_date(LVRCONDV_INDTTMP);
TDate adata = rcont.get_date(LVRCONDV_FIDTTMP);
bool fdotmp = false;
//disabilito i campi di dotazione temporanea se la causale non prevede la loro movimentazione
if (sgn_rit == 0 && sgn_con == 0)
{
msk.field(FR_JOLLY3).disable();
msk.field(FR_JOLLY4).disable();
}
else
{
msk.field(FR_JOLLY3).enable();
msk.field(FR_JOLLY4).enable();
fdotmp = true;
}
if (dadata.ok() || fdotmp)
{
TLocalisamfile rcondv(LF_LVRCONDV);
rcondv.put(LVRCONDV_CODCF,codcf);
rcondv.put(LVRCONDV_CODCONT,cont.get_int(LVCONDV_CODCONT));
rcondv.put(LVRCONDV_CODART,msk.get(FR_CODART));
if (rdoc.get_date("DADATATMP").empty())
{
if (!dadata.ok() && rcondv.read() == NOERR)
{
rcondv.put(LVRCONDV_INDTTMP, datadoc);
rcondv.rewrite();
rdoc.put("DADATATMP", datadoc);
msk.field(FR_JOLLY3).set(datadoc);
}
else
{
rdoc.put("DADATATMP", dadata);
msk.field(FR_JOLLY3).set(dadata);
}
}
if (rdoc.get_date("ADATATMP").empty())
{
if (adata.ok() && adata <= datadoc)
{
rdoc.put("ADATATMP", adata);
msk.field(FR_JOLLY4).set(adata);
}
else
{
//instanzio in TRecordset sui giri
TISAM_recordset giri("USE LVRCONSPLAN KEY 3\nSELECT DTCONS>#DATADOC\nFROM CODCF=#CODCF CODCONT=#CODCONT\nTO CODCF=#CODCF CODCONT=#CODCONT");
giri.set_var("#DATADOC", datadoc);
giri.set_var("#CODCF", codcf);
giri.set_var("#CODCONT", cont.get_long(LVCONDV_CODCONT));
if (giri.move_first())
{
rdoc.put("ADATATMP", giri.get(LVRCONSPLAN_DTCONS).as_date());
msk.field(FR_JOLLY4).set(giri.get(LVRCONSPLAN_DTCONS).as_date());
if (rcondv.read() == NOERR)
{
rcondv.put(LVRCONDV_FIDTTMP, giri.get(LVRCONSPLAN_DTCONS).as_date());
rcondv.rewrite();
}
}
}
}
}
//abilito o disabilito azzerandolo il campo "Ritirato" a seconda di cosa prevede la causale
if (cau.is_ritiro())
{
msk.field(FR_QTAGG1).enable(true);
if (codmagcoll.blank())
{
codmagcoll = codmagdef;
msk.field(FR_CODMAGC).set(codmagcoll);
}
if (coddepcoll.blank())
{
coddepcoll = coddepdef; //magazzino del circolante
msk.field(FR_CODDEPC).set(coddepcoll);
}
}
else
{
msk.field(FR_QTAGG1).set("");
msk.field(FR_QTAGG1).disable();
}
//abilito o disabilito azzerandolo il campo "Consegnato" a seconda di cosa prevede la causale
//ATTENZIONE: questo campo risulta sempre disabilitato se l'articolo <20> bloccato
if (cau.is_consegna() && rcont.get(LVRCONDV_ARTBLOC).empty())
{
msk.field(FR_QTA).enable(true);
if (codmag.blank())
{
codmag = codmagdef;
msk.field(FR_CODMAG).set(codmag);
}
if (coddep.blank())
{
coddep = coddepdef;
msk.field(FR_CODDEP).set(coddep);
}
}
else
{
msk.field(FR_QTA).set("");
msk.field(FR_QTA).disable();
}
}
}
return true;
}
//PRE_CODMAG_HANDLER: handler che limita l'esecuzione
bool TGestione_buoni_msk::pre_codmag_handler(TMask_field& f, KEY k)
{
bool ok = true;
if (f.to_check(k, true))
{
TMask& msk = f.mask();
const TString& causale = msk.get(FR_CAULAV);
if (causale.full())
{
switch(f.dlg())
{
case FR_CODMAG: ok = codmag_handler( f, k ); break;
default: break;
}
}
}
return ok;
}
//metodo che setta gli handler sui campi di riga
void TGestione_buoni_msk::user_set_row_handler(TMask& rm, short field, int index)
{
switch(index)
{
case 4101: rm.set_handler(field, pre_ritirato_handler); break;
case 4102: rm.set_handler(field, pre_daconsegnare_handler); break;
case 4103: rm.set_handler(field, pre_codart_handler); break;
case 4104: rm.set_handler(field, pre_causale_handler); break;
case 4105: rm.set_handler(field, pre_codmag_handler); break;
default: break;
}
}
//metodo che setta l'handler di bolla
void TGestione_buoni_msk::user_set_handler( short fieldid, int index)
{
switch(index)
{
case 4101: set_field_handler(fieldid, set_data_handler); break;
case 4102: set_field_handler(fieldid, set_contratto_handler); break;
case 4103: set_field_handler(fieldid, set_righe_buono_handler); break;
case 4105: set_field_handler(fieldid, set_dataprco_handler); break;
default: /*TDocumento_mask::user_set_handler(fieldid, index);*/ break;
}
}
TGestione_buoni_msk::TGestione_buoni_msk(const char* tipodoc) : TDocumento_mask(tipodoc), _autoselect(-1)
{
if (ini_get_bool(CONFIG_DITTA, "lv", "Datafissa"))
field(F_DATADOC).disable();
sfield(F_SHEET).set_nav_column(FR_QTA, FR_QTAGG1);
sfield(F_SHEET).set_auto_append();
sfield(F_SHEET).set_handler( ss_handler );
sfield(F_SHEET).set_notify( ss_notify );
}
//////////////////////////////////////////
//// CLASSE TGestione_buoni_app ////
//////////////////////////////////////////
//ridefinisco il metodo get_mask delle TMotore_application
TMask* TGestione_buoni_app::get_mask( int mode )
{
if (mode == MODE_INS || mode == MODE_MOD)
{
TString4 tipodoc;
if (mode == MODE_MOD)
tipodoc = get_relation()->curr().get(DOC_TIPODOC); // Lo prendo dalla relazione (Gelai)
else
tipodoc = TMotore_application::get_mask(MODE_QUERY)->get(F_TIPODOC);
if (_doc_masks.objptr(tipodoc) == NULL)
{
TGestione_buoni_msk* m = new TGestione_buoni_msk(tipodoc);
TSheet_field& sheet = m->sfield(F_SHEET);
if (sheet.exist_column(FR_JOLLY1))
{
//setto l'allineamento a destra dei campi incriminati e pure criminali
sheet.set_column_justify(sheet.cid2index(FR_JOLLY1), true);
sheet.set_column_justify(sheet.cid2index(FR_JOLLY2), true);
}
_doc_masks.add(tipodoc, m);
const TTipo_documento& tdoc = m->doc().tipo();
const TString_array& handlers = tdoc.handlers();
FOR_EACH_ARRAY_ROW(handlers, i, row)
{
m->user_set_handler( row->get_int( 0 ), row->get_int( 1 ) );
}
}
}
return TMotore_application::get_mask(mode);
}
void TGestione_buoni_app::elimina_vuote( const TMask& m)
{
TDocumento_mask& mask = (TDocumento_mask&) m;
TDocumento& d = mask.doc();
TSheet_field& sheet = mask.sfield(F_SHEET);
FOR_EACH_DOC_ROW_BACK(d, r, row)
{
if (row->is_articolo() && row->get_int(RDOC_QTA) == 0 && row->get_int(RDOC_QTAGG1) == 0)
{
d.destroy_row(r,true);
}
}
}
//ridefinisco il metodo write delle TMotore_application
int TGestione_buoni_app::write( const TMask& m )
{
elimina_vuote(m);
return TMotore_application::write(m);
}
//ridefinisco il metodo rewrite delle TMotore_application
int TGestione_buoni_app::rewrite( const TMask& m )
{
elimina_vuote(m);
return TMotore_application::rewrite(m);
}
//ridefinisco il metodo read della TMotore_application
int TGestione_buoni_app::read(TMask& m)
{
const int err = TMotore_application::read(m);
if (err == NOERR)
{
TGestione_buoni_msk& mask = (TGestione_buoni_msk&) m;
TDocumento& d = mask.doc();
_giac.reset(d);
FOR_EACH_DOC_ROW_BACK(d, r, row)
_giac.load_row((TRiga_documento&)*row);
mask._autoselect = 0;
TSheet_field& sheet = mask.sfield(F_SHEET);
const int poscons = sheet.cid2index(FR_QTAEVASA);
const int pospacchi = sheet.cid2index(FR_NCOLLI);
const int posdotod = sheet.cid2index(FR_JOLLY1);
const int posdotmp = sheet.cid2index(FR_JOLLY2);
const int posdatmp = sheet.cid2index(FR_JOLLY3);
const int posatmp = sheet.cid2index(FR_JOLLY4);
const int posrif = sheet.cid2index(FR_JOLLY5);
FOR_EACH_SHEET_ROW(sheet, i, riga)
{
sheet.disable_cell(i, poscons);
sheet.disable_cell(i, pospacchi);
sheet.disable_cell(i, posdotod);
sheet.disable_cell(i, posdotmp);
sheet.disable_cell(i, posdatmp);
sheet.disable_cell(i, posatmp);
sheet.disable_cell(i, posrif);
}
sheet.force_update();
}
return err;
}
//ridefinisco il metodo init_insert_mode della TMotore_application
void TGestione_buoni_app::init_insert_mode(TMask &m)
{
TGestione_buoni_msk& mask = (TGestione_buoni_msk&) m;
TDocumento& d = mask.doc();
_giac.reset(d);
//se sto leggendo o generando un buono di ritiro, abilito questo campo
bool enable_dataprco = mask.get(F_CODNUM) == ini_get_string(CONFIG_DITTA, "lv", "NUM_RIT(0)") &&
mask.get(F_TIPODOC) == ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_RIT(0)");
mask.field(F_LVDATAPRCO).enable(enable_dataprco);
mask.reset_var_mask();
mask.first_focus(F_CODCF, false);
return TMotore_application::init_insert_mode(m);
}
//ridefinisco il metodo init_query_mode della TMotore_application
void TGestione_buoni_app::init_modify_mode(TMask &m)
{
TGestione_buoni_msk& mask = (TGestione_buoni_msk&) m;
//se sto leggendo o generando un buono di ritiro, abilito questo campo
bool enable_dataprco = mask.get(F_CODNUM) == ini_get_string(CONFIG_DITTA, "lv", "NUM_RIT(0)") &&
mask.get(F_TIPODOC) == ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_RIT(0)");
mask.field(F_LVDATAPRCO).enable(enable_dataprco);
mask.first_focus(F_CODCF, false);
return TMotore_application::init_modify_mode(m);
}
//metodo che mi restituisce la giac
TGiac_per_cli& TGestione_buoni_app::giacenza()
{
return _giac;
}
int lv3300( int argc, char* argv[])
{
TGestione_buoni_app a;
a.run( argc, argv, TR("Buoni di Prelievo"));
return 0;
}
Reference in New Issue View Git Blame Copy Permalink