From 052f340bb774a2640cb7bbbab3f43b911ed4a2fe Mon Sep 17 00:00:00 2001 From: luca83 Date: Wed, 4 Nov 2009 10:06:55 +0000 Subject: [PATCH] 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 --- lv/lv3.cpp | 3 +- lv/lv3.h | 1 + lv/lv3200.cpp | 72 ++- lv/lv3200a.uml | 7 - lv/lv3300.cpp | 1227 +++++++++++++++++++++++++++++++++++++++++++++++ lv/lvbolacp.src | 31 +- lv/lvmenu.men | 3 +- lv/verig24.ini | 13 + lv/verig24.uml | 474 ++++++++++++++++++ 9 files changed, 1792 insertions(+), 39 deletions(-) create mode 100755 lv/lv3300.cpp create mode 100755 lv/verig24.ini create mode 100755 lv/verig24.uml diff --git a/lv/lv3.cpp b/lv/lv3.cpp index 6cd667c8b..ff20b8683 100755 --- a/lv/lv3.cpp +++ b/lv/lv3.cpp @@ -8,7 +8,8 @@ int main(int argc, char** argv) switch (r) { case 0: lv3100(argc, argv); break; // gestione manuale bolle lv3100 - case 1: lv3200(argc, argv); break; // evasione buoni si prelievo lv3200 + case 1: lv3200(argc, argv); break; // evasione buoni di prelievo lv3200 + case 2: lv3300(argc, argv); break; // gestione manuale buoni di prelievo lv3300 default: lv3100(argc, argv); break; // gestione manuale bolle lv3100 } return 0; diff --git a/lv/lv3.h b/lv/lv3.h index 02f214307..cd8dc55d6 100755 --- a/lv/lv3.h +++ b/lv/lv3.h @@ -3,5 +3,6 @@ int lv3100(int argc, char* argv[]); int lv3200(int argc, char* argv[]); +int lv3300(int argc, char* argv[]); #endif // __LV3_H diff --git a/lv/lv3200.cpp b/lv/lv3200.cpp index 64231ade1..a0817c859 100755 --- a/lv/lv3200.cpp +++ b/lv/lv3200.cpp @@ -269,8 +269,7 @@ void TEvasione_msk::carica_righe() riga.add(rdoc.cong_pre(), sheet.cid2index(S_CONGPRE)); riga.add(rdoc.cong_att(), sheet.cid2index(S_CONGATT)); - riga.add(rdoc.rifbcon(), sheet.cid2index(S_RIFBCON)); - riga.add(rdoc.rifbrit(), sheet.cid2index(S_RIFBRIT)); + riga.add(rdoc.rifbcon(), sheet.cid2index(S_RIFBCON)); } else rdoc.set_evaso(true); @@ -381,6 +380,13 @@ void TEvasione_msk::genera_documento() long dottmp = magcli.get_long(CLIFOGIAC_DOTTM); long dotod = magcli.get_long(CLIFOGIAC_DOTOD); + //recupero l'unità di misura principale di quest'articolo + TToken_string key; + key.add(codart); + key.add(1); + const TRectype& umart = cache().get(LF_UMART, key); + TString4 um = umart.get(UMART_UM); + TRiga_documento& rdoc = doc.new_row("21"); rdoc.put(RDOC_CODART, codart); rdoc.put(RDOC_CODARTMAG,codart); @@ -399,8 +405,8 @@ void TEvasione_msk::genera_documento() rdoc.put(RDOC_QTA, rbpre.qta_consegnata()); //consegnato rdoc.put(RDOC_QTAGG1, rbpre.qta_ritirata()); //ritirato - rdoc.put("DOTOD", dotod); - rdoc.add("DOTOD", rbpre.qta_consegnata()); + dotod += (rbpre.qta_consegnata() - rbpre.qta_ritirata()); + rdoc.put("DOTOD", dotod); bool dtmp = false; if (datagen >= rcont.get_date(LVRCONDV_INDTTMP) && datagen <= rcont.get_date(LVRCONDV_FIDTTMP)) @@ -409,7 +415,7 @@ void TEvasione_msk::genera_documento() if(dtmp) { rdoc.put("DOTMP", dottmp); - rdoc.add("DOTMP", rbpre.qta_consegnata()); + rdoc.add("DOTMP", rbpre.qta_consegnata() - rbpre.qta_ritirata()); } rdoc.put(RDOC_CODAGG1, rbpre.causale()); @@ -427,6 +433,8 @@ void TEvasione_msk::genera_documento() rdoc.put(RDOC_PREZZO, prezzo); rdoc.put(RDOC_SCONTO, rcont.get(LVRCONDV_SCONTPERC)); //sconto } + + rdoc.put(RDOC_UMQTA, um); //scrivo il magazzino TString8 magazzino; @@ -450,7 +458,7 @@ void TEvasione_msk::genera_documento() err = doc.write(); const TString4 stato = cache().get("%TIP", ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0), "S2").mid(1,1); bpre.put(DOC_STATO, stato); - bpre.write(); + bpre.rewrite(); set(F_STATO, stato); } @@ -470,7 +478,6 @@ void TEvasione_msk::genera_documento() reset(F_NDOC); send_key(K_TAB, F_NDOC); - field(F_NDOC).set_focus(); } //EVADI_TUTTO: metodo che forza a "evaso" tutte le righe e lancia la generazione del buono di consegna associato @@ -519,6 +526,8 @@ void TEvasione_msk::salva() TDoc_key kdoc(get_int(F_ANNO), get(F_CODNUM), get_long(F_NDOC)); TBuono_prelievo doc(kdoc); + TLaundry_contract cont(get_long(F_CODCF), get_long(F_CODCONT)); + //nel caso avessi spezzato le righe, risrcivendole da capo mi vengono ordinate per codice //ATTENZIONE: devo eliminare le sole righe che sono sullo sheet, cioè quelle che hanno //quantità da consegnare maggiore di zero @@ -528,7 +537,7 @@ void TEvasione_msk::salva() TBuono_prelievo_row rdoc(row); if (rdoc.qta_dacons() > 0) - doc.destroy_row(i, true); + doc.destroy_row(i, true); } TSheet_field& sheet = sfield(F_RIGHE); @@ -539,7 +548,7 @@ void TEvasione_msk::salva() //per ogni riga dello sheet genero una riga documento FOR_EACH_SHEET_ROW(sheet, r, riga) { - TRiga_documento& row = doc.new_row("21"); + TRiga_documento& row = doc.new_row("24"); TBuono_prelievo_row rdoc(row); const char flgev = riga->get(sheet.cid2index(S_EVASO))[0]; @@ -549,18 +558,51 @@ void TEvasione_msk::salva() else flag = false; + const TString80 codart = riga->get(sheet.cid2index(S_CODART)); + rdoc.set_evaso(flag); - rdoc.set_codart(riga->get(sheet.cid2index(S_CODART))); + rdoc.set_codart(codart); rdoc.set_desart(riga->get(sheet.cid2index(S_ARTDESCR))); rdoc.set_causale(riga->get(sheet.cid2index(S_CAUSALE))); rdoc.set_qta_ritirata(riga->get_int(sheet.cid2index(S_RITIRATO))); rdoc.set_qta_dacons(riga->get_int(sheet.cid2index(S_DACONS))); rdoc.set_qta_consegnata(riga->get_int(sheet.cid2index(S_CONSEGNATO))); - rdoc.set_num_pacchi(riga->get_int(sheet.cid2index(S_PACCHI))); + rdoc.set_num_pacchi(riga->get_int(sheet.cid2index(S_PACCHI))); rdoc.set_cong_att(riga->get_int(sheet.cid2index(S_CONGPRE))); rdoc.set_cong_pre(riga->get_int(sheet.cid2index(S_CONGATT))); rdoc.set_rifbcon(riga->get(sheet.cid2index(S_RIFBCON))); - rdoc.set_rifbrit(riga->get(sheet.cid2index(S_RIFBRIT))); + + //recupero l'unità di misura principale di quest'articolo + TToken_string key; + key.add(codart); + key.add(1); + const TRectype& umart = cache().get(LF_UMART, key); + rdoc.set_um(umart.get(UMART_UM)); + + //recupero il codiva di quest'articolo + const TRectype& anamag = cache().get(LF_ANAMAG, codart); + rdoc.set_codiva(anamag.get(ANAMAG_CODIVA)); + + const TRectype& rcont = cont.row(codart); + + //controllo da dove devo prendere il prezzo + real prezzo; + + if (cont.get_int(LVCONDV_TIPOLIS) == 0) + prezzo = rcont.get_real(LVRCONDV_PREZZO); + else + prezzo = anamag.get_real(ANAMAG_COSTSTD); + rdoc.set_prezzo(prezzo); + + //scrivo il magazzino + TString8 magazzino; + TString8 magazzinoc; + + magazzino << ini_get_string(CONFIG_DITTA, "lv", "CODMAG") << ini_get_string(CONFIG_DITTA, "lv", "CODMAGN"); + magazzinoc << ini_get_string(CONFIG_DITTA, "lv", "CODMAG") << ini_get_string(CONFIG_DITTA, "lv", "CODMAGC"); + + rdoc.set_mag(magazzino); + rdoc.set_magc(magazzinoc); } doc.rewrite(); } @@ -602,8 +644,7 @@ void TEvasione_msk::annulla_operazioni() riga.add(rdoc.cong_pre(), sheet.cid2index(S_CONGPRE)); riga.add(rdoc.cong_att(), sheet.cid2index(S_CONGATT)); - riga.add(rdoc.rifbcon(), sheet.cid2index(S_RIFBCON)); - riga.add(rdoc.rifbrit(), sheet.cid2index(S_RIFBRIT)); + riga.add(rdoc.rifbcon(), sheet.cid2index(S_RIFBCON)); } sheet.force_update(); } @@ -846,7 +887,10 @@ bool TEvasione_msk::on_field_event(TOperable_field& f, TField_event e, long joll sistema_pacchi(); if (controlla()) + { genera_documento(); + //field(F_NDOC).set_focus(); + } } } break; diff --git a/lv/lv3200a.uml b/lv/lv3200a.uml index 63bc869ad..95e2c7bac 100755 --- a/lv/lv3200a.uml +++ b/lv/lv3200a.uml @@ -211,7 +211,6 @@ BEGIN ITEM "Cong.\nPrec." ITEM "Cong.\nAtt." ITEM "Riferimenti\nbuoni cons." - ITEM "Riferimenti\nbuoni rit." END ENDPAGE @@ -322,11 +321,5 @@ BEGIN FLAGS "D" END -STRING S_RIFBRIT 255 50 -BEGIN - PROMPT 1 7 "Riferimenti buono di ritiro " - FLAGS "D" -END - ENDPAGE ENDMASK \ No newline at end of file diff --git a/lv/lv3300.cpp b/lv/lv3300.cpp new file mode 100755 index 000000000..ebe915018 --- /dev/null +++ b/lv/lv3300.cpp @@ -0,0 +1,1227 @@ +#include + +#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à che gli passo se è 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ù o in meno gli devo dare e aggiorno la quantità + 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è 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 è.. +//..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è con quantità 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à 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 è una data di previsto passaggio; + //se non lo è chiedi conferma se si desidera mantenre la data indicata manualmente o se + //è 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 è 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 è 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 è 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 è 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 è 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 è 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'è 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 è 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 è 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; +} \ No newline at end of file diff --git a/lv/lvbolacp.src b/lv/lvbolacp.src index fcf5a513b..68b5489a2 100755 --- a/lv/lvbolacp.src +++ b/lv/lvbolacp.src @@ -199,12 +199,12 @@ Col(4)=FR_LIV4 Col(5)=FR_DESCR||28 Col(6)=FR_CAULAV|Caus.|5 Col(7)=FR_RITIRO|Ritiro|6 -Col(8)=FR_JOLLY5|Da cons|8 -Col(9)=FR_QTA|Cons.|6 -Col(10)=FR_JOLLY6|Pacchi|6 +Col(8)=FR_QTA|Da cons|8 +Col(9)=FR_QTAEVASA|Cons.|6 +Col(10)=FR_NCOLLI|Pacchi|6 Col(11)=FR_PREZZO||6 -Col(12)=FR_JOLLY1@R|Dotaz.|7 -Col(13)=FR_JOLLY2@R|D.Temp.|7 +Col(12)=FR_JOLLY1|Dotaz.|7 +Col(13)=FR_JOLLY2|D.Temp.|7 Col(14)=FR_JOLLY3|Inizio|10 Col(15)=FR_JOLLY4|Fine|10 Col(16)=FR_UMQTA @@ -212,19 +212,18 @@ Col(17)=FR_SCONTO Col(18)=FR_PERCPROV Col(19)=FR_PERCPROV1 Col(20)=FR_CODIVA -Col(21)=FR_NCOLLI -Col(22)=FR_PNETTO -Col(23)=FR_TARA -Col(24)=FR_CAUS -Col(25)=FR_CODMAGC -Col(26)=FR_CODDEPC -Col(27)=FR_CODMAG -Col(28)=FR_CODDEP -Col(29)=FR_TIPORIGA|Tipo|4 +Col(21)=FR_PNETTO +Col(22)=FR_TARA +Col(23)=FR_CAUS +Col(24)=FR_CODMAGC +Col(25)=FR_CODDEPC +Col(26)=FR_CODMAG +Col(27)=FR_CODDEP +Col(28)=FR_TIPORIGA|Tipo|4 +Col(29)=FR_JOLLY5|Rif. buoni cons.|20 [RIGHE] -Tipo(0)=23 -Tipo(1)=05 +Tipo(0)=24 [HANDLERS] Handler(0) = 106|4101 diff --git a/lv/lvmenu.men b/lv/lvmenu.men index 2cbda3dbe..9bb857c33 100755 --- a/lv/lvmenu.men +++ b/lv/lvmenu.men @@ -103,13 +103,14 @@ Item_02 = "Acquisizione del Pulito", "lv2 -8", "F" Item_03 = "Generazione buoni di prelievo", "lv2 -3 P", "F" Item_04 = "Generazione buoni di consegna", "lv2 -3 C", "F" Item_05 = "Buoni di Ritiro", "lv3 -0 -filtI1=1 -defNUM_RIT(0),TIPODOC_RIT(0),lv", "F" -Item_06 = "Buoni di Prelievo", "lv3 -0 -filtI1=1 -defNUM_PRE(0),TIPODOC_PRE(0),lv", "F" +Item_06 = "Buoni di Prelievo", "lv3 -2 -filtI1=1 -defNUM_PRE(0),TIPODOC_PRE(0),lv", "F" Item_07 = "Buoni di Consegna", "lv3 -0 -filtI1=1 -defNUM_GEN,TIPODOC_GEN,lv", "F" Item_08 = "Fatture", "ve0 -1 -filtI1=2 -defNUM_FAT,TIPODOC_FAT,lv", "F" Item_09 = "Ordini Fornitori", "ve0 -1 -filtI1=3 -defNUM_ORF,TIPODOC_ORF,lv", "F" Item_10 = "Ordini Clienti", "ve0 -1 -filtI1=3 -defNUM_ORC,TIPODOC_ORC,lv", "F" Item_11 = "Fatturazione", "lv2 -4", "F" Item_12 = "Evasione Buoni di Prelievo manuale", "lv3 -1 M", "F" +Item_13 = "Evasione Buoni di Prelievo barcode", "lv3 -1 B", "F" Item_13 = "Stampe", [LVMENU_050] [LVMENU_050] diff --git a/lv/verig24.ini b/lv/verig24.ini new file mode 100755 index 000000000..0af1f2beb --- /dev/null +++ b/lv/verig24.ini @@ -0,0 +1,13 @@ +#Profilo di riga tipo merce lavanderie +[MAIN] +CALCOLI=* +CAMPICALC= +IMPONIBILE=IMPNS + +[HANDLERS] +NHANDLER = 5 +1 = 133|4101 +2 = 112|4102 +3 = 105|4103 +4 = 152|4104 +5 = 103|4105 \ No newline at end of file diff --git a/lv/verig24.uml b/lv/verig24.uml new file mode 100755 index 000000000..2368f8a10 --- /dev/null +++ b/lv/verig24.uml @@ -0,0 +1,474 @@ +#include "..\ve\verig.h" + +TOOLBAR "" 0 0 0 2 + +BUTTON DLG_OK 10 2 +BEGIN + PROMPT -14 -1 "" +END + +BUTTON DLG_CANCEL 10 2 +BEGIN + PROMPT -24 -1 "" +END + +BUTTON DLG_DELREC 10 2 +BEGIN + PROMPT -34 -1 "Elimina" + MESSAGE EXIT,K_DEL +END + +BUTTON DLG_USER 10 2 +BEGIN + PROMPT -44 -1 "~Collega" + PICTURE BMP_LINK +END + +ENDPAGE + +PAGE "Merce Lavanderia" 0 2 0 0 + +GROUPBOX DLG_NULL 78 3 +BEGIN + PROMPT 0 0 "" +END + +LIST FR_TIPORIGA 2 50 +BEGIN + PROMPT 2 1 "Tipo riga " + FIELD TIPORIGA +END + +GROUPBOX DLG_NULL 78 10 +BEGIN + PROMPT 1 3 "@bArticolo" +END + +STRING FR_CODART 8 +BEGIN + PROMPT 2 4 "Articolo " + USE LF_ANAMAG KEY 1 + INPUT CODART FR_CODART + DISPLAY "Codice@6" CODART + DISPLAY "Descrizione@50" DESCR + OUTPUT FR_CODART CODART + OUTPUT FR_DESCRART DESCR + FLAGS "U" + FIELD CODART + ADD RUN ve2 -3 +END + +STRING FR_DESCRART 50 +BEGIN + PROMPT 25 4 "" + USE LF_ANAMAG KEY 2 + INPUT DESCR FR_DESCRART + DISPLAY "Descrizione@50" DESCR + DISPLAY "Codice@8" CODART + COPY OUTPUT FR_CODART + ADD RUN ve2 -3 + FIELD DESCR +END + +STRING FR_HDESC 50 +BEGIN + PROMPT 100 100 "Descrizione " + USE LF_ANAMAG KEY 2 + INPUT DESCR FR_HDESC + DISPLAY "Descrizione@50" DESCR + DISPLAY "Codice@20" CODART + COPY OUTPUT FR_CODART +END + +STRING FR_CODARTMAG 20 +BEGIN + PROMPT 200 6 "" + FIELD CODARTMAG + FLAGS "G" +END + +BOOLEAN FR_CHECKED +BEGIN + PROMPT 51 50 "" + FIELD CHECKED + FLAGS "D" +END + +STRING FR_LIV1 15 +BEGIN + PROMPT 2 5 "Liv.Gia. " + FLAGS "U" + USE GCG + JOIN FCG ALIAS 500 INTO CODTAB==CODTAB[1,1] + INPUT CODTAB[1,1] "1" + INPUT CODTAB[2,] FR_LIV1 + DISPLAY "Livello@20" 500@->S0 + DISPLAY "Gruppo@15" CODTAB[2,] + DISPLAY "Descrizione@30" S0 + OUTPUT FR_LIV1 CODTAB[2,] + MESSAGE EMPTY RESET,FR_LIV2|RESET,FR_LIV3|RESET,FR_LIV4 + MESSAGE ENABLE,FR_LIV2 + CHECKTYPE NORMAL +END + +STRING FR_LIV2 15 +BEGIN + PROMPT 28 5 "" + FLAGS "U" + USE GCG + JOIN FCG ALIAS 500 INTO CODTAB==CODTAB[1,1] + INPUT CODTAB[1,1] "2" + INPUT CODTAB[2,] FR_LIV2 + DISPLAY "Livello@20" 500@->S0 + DISPLAY "Gruppo@15" CODTAB[2,] + DISPLAY "Descrizione@30" S0 + OUTPUT FR_LIV2 CODTAB[2,] + MESSAGE EMPTY RESET,FR_LIV3|RESET,FR_LIV4 + MESSAGE ENABLE,FR_LIV3 + CHECKTYPE NORMAL +END + +STRING FR_LIV3 15 +BEGIN + PROMPT 45 5 "" + FLAGS "U" + USE GCG + JOIN FCG ALIAS 500 INTO CODTAB==CODTAB[1,1] + INPUT CODTAB[1,1] "3" + INPUT CODTAB[2,] FR_LIV3 + DISPLAY "Livello@20" 500@->S0 + DISPLAY "Gruppo@15" CODTAB[2,] + DISPLAY "Descrizione@30" S0 + OUTPUT FR_LIV3 CODTAB[2,] + MESSAGE EMPTY RESET,FR_LIV4 + MESSAGE ENABLE,FR_LIV4 + CHECKTYPE NORMAL +END + +STRING FR_LIV4 15 +BEGIN + PROMPT 62 5 "" + FLAGS "U" + USE GCG + JOIN FCG ALIAS 500 INTO CODTAB==CODTAB[1,1] + INPUT CODTAB[1,1] "4" + INPUT CODTAB[2,] FR_LIV4 + DISPLAY "Livello@20" 500@->S0 + DISPLAY "Gruppo@15" CODTAB[2,] + DISPLAY "Descrizione@30" S0 + OUTPUT FR_LIV4 CODTAB[2,] + CHECKTYPE NORMAL +END + +STRING FR_UMQTA 3 +BEGIN + PROMPT 2 6 "U.M. " + USE LF_UMART KEY 2 + JOIN %UMS INTO CODTAB=UM + INPUT CODART FR_CODARTMAG SE + INPUT UM FR_UMQTA + DISPLAY "Codice@20" UM + DISPLAY "Descrizione@50" %UMS->S0 + OUTPUT FR_UMQTA UM + FIELD UMQTA + FLAG "U" + CHECKTYPE REQUIRED +END + +STRING FR_UMQTA2 2 +BEGIN + PROMPT 2 6 "U.M. " + USE %UMS + INPUT CODTAB FR_UMQTA2 + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT FR_UMQTA2 CODTAB + FIELD UMQTA + FLAG "U" + CHECKTYPE NORMAL +END + +CURRENCY FR_PREZZO 15 +BEGIN + PROMPT 13 6 "Prezzo " + FLAGS "U" + FIELD PREZZO +END + +STRING FR_SCONTO 15 +BEGIN + PROMPT 36 6 "Sconto " + FIELD SCONTO +END + +NUMBER FR_PERCPROV 5 2 +BEGIN + PROMPT 59 6 "Provv. " + FIELD PERCPROV +END + +NUMBER FR_PERCPROV1 5 2 +BEGIN + PROMPT 72 6 "" + FIELD PERCPROV1 +END + +STRING FR_CAULAV 3 +BEGIN + PROMPT 2 7 "Cau. Lav. " + USE &LVCAU + INPUT CODTAB FR_CAULAV + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT FR_CAULAV CODTAB + OUTPUT FR_DESCAU S0 + OUTPUT FR_FLCONS B1 + OUTPUT FR_FLRIT B0 + CHECKTYPE REQUIRED + FLAGS "U" + FIELD CODAGG1 +END + +STRING FR_DESCAU 50 +BEGIN + PROMPT 18 7 "" + FLAGS "D" +END + +BOOLEAN FR_FLCONS +BEGIN + PROMPT 50 50 "Flag consegnato" + FLAGS "HG" +END + +BOOLEAN FR_FLRIT +BEGIN + PROMPT 50 50 "Flag ritirato" + FLAGS "HG" +END + +NUMBER FR_RITIRO 6 0 +BEGIN + PROMPT 2 8 "Ritirato " + FIELD QTAGG1 +END + +NUMBER FR_QTA 6 0 +BEGIN + PROMPT 20 8 "Da cons. " + FIELD QTA +END + +NUMBER FR_QTAEVASA 6 0 +BEGIN + PROMPT 40 8 "Consegnato " + FIELD QTAEVASA + FLAGS "D" +END + +NUMBER FR_NCOLLI 7 +BEGIN + PROMPT 60 8 "Pacchi " + FIELD NCOLLI + FLAGS "D" +END + +NUMBER FR_JOLLY1 6 0 +BEGIN + PROMPT 2 9 "Dot. Od. " + FIELD DOTOD + FLAGS "D" +END + +NUMBER FR_JOLLY2 6 0 +BEGIN + PROMPT 20 9 "Dot. Tem. " + FIELD DOTMP + FLAGS "D" +END + +DATE FR_JOLLY3 +BEGIN + PROMPT 40 9 "Inizio " + FIELD DADATATMP + FLAGS "D" +END + +DATE FR_JOLLY4 +BEGIN + PROMPT 60 9 "Fine " + FIELD ADATATMP + FLAGS "D" +END + +NUMBER FR_TARA 15 2 +BEGIN + PROMPT 2 10 "Tara " + FIELD TARA +END + +NUMBER FR_PNETTO 6 2 +BEGIN + PROMPT 25 10 "Peso netto " + FIELD PNETTO +END + +STRING FR_CODIVA 4 +BEGIN + PROMPT 2 11 "IVA " + USE %IVA + INPUT CODTAB FR_CODIVA + DISPLAY "Codice@20" CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT FR_CODIVA CODTAB + OUTPUT FR_DESIVA S0 + FLAGS "U" + VALIDATE ZEROFILL_FUNC 2 + CHECKTYPE NORMAL + FIELD CODIVA +END + +STRING FR_DESIVA 50 +BEGIN + PROMPT 13 11 "" + USE %IVA KEY 2 + INPUT S0 FR_DESIVA + DISPLAY "Descrizione@50" S0 + DISPLAY "Codice@20" CODTAB + OUTPUT FR_CODIVA CODTAB + OUTPUT FR_DESIVA S0 +END + +STRING FR_TIPODET 1 +BEGIN + PROMPT 67 11 "Indetr. " + USE %DET + INPUT CODTAB FR_TIPODET + DISPLAY "Codice" CODTAB + DISPLAY "Tipo" I0 + DISPLAY "Descrizione@50" S0 + OUTPUT FR_TIPODET CODTAB + CHECKTYPE NORMAL + FLAGS "U" +END + +GROUPBOX DLG_NULL 78 6 +BEGIN + PROMPT 1 13 "@bMagazzino" +END + +STRING FR_CODMAG 4 +BEGIN + PROMPT 2 14 "Magazzino " + USE MAG SELECT CODTAB[4,5]=="" + INPUT CODTAB FR_CODMAG + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT FR_CODMAG CODTAB + OUTPUT FR_DESMAG S0 + WARNING "Magazzino assente" + FLAGS "U" + CHECKTYPE NORMAL + FIELD CODMAG[1,3] +END + +STRING FR_DESMAG 50 +BEGIN + PROMPT 26 14 "" + FLAGS "D" +END + +STRING FR_CODDEP 4 +BEGIN + PROMPT 2 15 "Deposito " + USE MAG SELECT (CODTAB[1,3]==#FR_CODMAG) && (CODTAB[4,5]!="") + INPUT CODTAB[1,3] FR_CODMAG + INPUT CODTAB[4,5] FR_CODDEP + DISPLAY "Codice mag." CODTAB[1,3] + DISPLAY "Codice dep." CODTAB[4,5] + DISPLAY "Descrizione@50" S0 + OUTPUT FR_CODMAG CODTAB[1,3] + OUTPUT FR_CODDEP CODTAB[4,5] + OUTPUT FR_DESDEP S0 + MESSAGE DIRTY,FR_CODMAG|K_TAB,FR_CODMAG + CHECKTYPE NORMAL + WARNING "Deposito assente" + FLAGS "U" + FIELD CODMAG[4,5] +END + +STRING FR_DESDEP 50 +BEGIN + PROMPT 26 15 "" + FLAGS "D" +END + +STRING FR_CODMAGC 4 +BEGIN + PROMPT 2 16 "Magazzino Col. " + COPY USE FR_CODMAG + INPUT CODTAB FR_CODMAGC + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT FR_CODMAGC CODTAB + OUTPUT FR_DESMAGC S0 + WARNING "Magazzino assente" + FLAGS "U" + CHECKTYPE NORMAL + FIELD CODMAGC[1,3] +END + +STRING FR_DESMAGC 50 +BEGIN + PROMPT 26 16 "" + FLAGS "D" +END + +STRING FR_CODDEPC 4 +BEGIN + PROMPT 2 17 "Deposito " + USE MAG SELECT (CODTAB[1,3]==#FR_CODMAGC) && (CODTAB[4,5]!="") + INPUT CODTAB[1,3] FR_CODMAGC + INPUT CODTAB[4,5] FR_CODDEPC + DISPLAY "Codice mag." CODTAB[1,3] + DISPLAY "Codice dep." CODTAB[4,5] + DISPLAY "Descrizione@50" S0 + OUTPUT FR_CODMAGC CODTAB[1,3] + OUTPUT FR_CODDEPC CODTAB[4,5] + OUTPUT FR_DESDEPC S0 + MESSAGE DIRTY,FR_CODMAGC|K_TAB,FR_CODMAGC + CHECKTYPE NORMAL + WARNING "Deposito assente" + FLAGS "U" + FIELD CODMAGC[4,5] +END + +STRING FR_DESDEPC 50 +BEGIN + PROMPT 26 17 "" + FLAGS "D" +END + +GROUPBOX DLG_NULL 78 4 +BEGIN + PROMPT 1 19 "@bRiferimenti documenti" +END + +STRING FR_JOLLY5 20 +BEGIN + PROMPT 2 20 "Buono di Consegna" + FIELD RIFBCON + FLAGS "D" +END + +ENDPAGE + +PAGE "Analitica" 0 2 0 0 + +GROUPBOX DLG_NULL 78 14 +BEGIN + PROMPT 1 0 "Contabilita' analitica" +END + +ENDPAGE +ENDMASK