From 28323a0ac8ed69e320deaac33a93bf56304c78f2 Mon Sep 17 00:00:00 2001 From: luca83 Date: Thu, 12 Nov 2009 13:38:44 +0000 Subject: [PATCH] Patch level : 10.0 patch 508 Files correlati : lv3 Ricompilazione Demo : [ ] Commento : Aggiunta l'evasione da terminalino git-svn-id: svn://10.65.10.50/trunk@19608 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- lv/lv3.cpp | 1 + lv/lv3.h | 1 + lv/lv3200.cpp | 16 +- lv/lv3400.cpp | 915 +++++++++++++++++++++++++++++++++++++++++++++++++ lv/lv3400a.h | 22 ++ lv/lv3400a.uml | 203 +++++++++++ lv/lvlib.cpp | 60 +++- lv/lvlib.h | 25 ++ 8 files changed, 1233 insertions(+), 10 deletions(-) create mode 100755 lv/lv3400.cpp create mode 100755 lv/lv3400a.h create mode 100755 lv/lv3400a.uml diff --git a/lv/lv3.cpp b/lv/lv3.cpp index ff20b8683..061a5eceb 100755 --- a/lv/lv3.cpp +++ b/lv/lv3.cpp @@ -10,6 +10,7 @@ int main(int argc, char** argv) case 0: lv3100(argc, argv); break; // gestione manuale bolle lv3100 case 1: lv3200(argc, argv); break; // evasione buoni di prelievo lv3200 case 2: lv3300(argc, argv); break; // gestione manuale buoni di prelievo lv3300 + case 3: lv3400(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 cd8dc55d6..265256d7b 100755 --- a/lv/lv3.h +++ b/lv/lv3.h @@ -4,5 +4,6 @@ int lv3100(int argc, char* argv[]); int lv3200(int argc, char* argv[]); int lv3300(int argc, char* argv[]); +int lv3400(int argc, char* argv[]); #endif // __LV3_H diff --git a/lv/lv3200.cpp b/lv/lv3200.cpp index db6384ba5..683f0c2c3 100755 --- a/lv/lv3200.cpp +++ b/lv/lv3200.cpp @@ -396,8 +396,7 @@ void TEvasione_msk::genera_documento() TToken_string key; key.add(codart); key.add(1); - const TRectype& umart = cache().get(LF_UMART, key); - TString4 um = umart.get(UMART_UM); + const TString4 um = cache().get(LF_UMART, key, UMART_UM); TRiga_documento& rdoc = doc.new_row("21"); rdoc.put(RDOC_CODART, codart); @@ -489,7 +488,7 @@ void TEvasione_msk::genera_documento() warning_box(TR("Non è stato possibile generare nessun documento")); reset(F_NDOC); - send_key(K_TAB, F_NDOC); + send_key(K_SPACE, F_NDOC); } //EVADI_TUTTO: metodo che forza a "evaso" tutte le righe e lancia la generazione del buono di consegna associato @@ -1073,9 +1072,8 @@ TEvasione_msk::TEvasione_msk():TAutomask("lv3200a") //classe TEvasione_app class TEvasione_app : public TSkeleton_application -{ - TEvasione_msk* _msk; - +{ + TEvasione_msk* _msk; protected: virtual bool create(); virtual bool destroy(); @@ -1088,7 +1086,7 @@ public: //CREATE: metodo costruttore bool TEvasione_app::create() { - _msk = new TEvasione_msk(); + _msk = new TEvasione_msk; open_files(LF_DOC, LF_RIGHEDOC); return TSkeleton_application::create(); } @@ -1110,8 +1108,8 @@ bool TEvasione_app::transfer() void TEvasione_app::main_loop() { while (_msk->run() == K_ENTER) - transfer(); -} + transfer(); + } int lv3200(int argc, char *argv[]) { diff --git a/lv/lv3400.cpp b/lv/lv3400.cpp new file mode 100755 index 000000000..b735dd8d1 --- /dev/null +++ b/lv/lv3400.cpp @@ -0,0 +1,915 @@ +#include +#include +#include +#include +#include +#include +#include + +#include "lvlib.h" +#include "../mg/clifogiac.h" +#include "../ve/velib.h" + +#include "clifo.h" +#include "lvcondv.h" +#include "lvrcondv.h" +#include "lvrconsplan.h" + +#include "lv3400a.h" + + ////////////////////////////// + //// TQUANTITA_RIGA //// + ////////////////////////////// + +//Classe TQuantita_riga +class TQuantita_riga: public TObject +{ + int _nriga; + bool _evaso; + long _qtadacon; + long _qtacon; + int _pacchi; + +public: + int get_nriga() const; + bool get_evaso() const; + long get_qta_da_con() const; + long get_qta_con() const; + int get_pacchi() const; + + void set_nriga(const int nriga); + void set_evaso(const bool evaso); + void set_qta_da_con(const long qta); + void set_qta_con(const long qta); + void set_pacchi(const int pacchi); + + void add_qta_con(const long qta); + void add_pacchi(const int pacchi = 1); + + TQuantita_riga(bool evaso = false, long qtadc = 0, long qtac = 0, int pacchi = 0); +}; + +//GET_NRIGA: metodo che restituisce il numero di riga +int TQuantita_riga::get_nriga() const +{ + return _nriga; +} + +//GET_EVASO: metodo che restituisce il booleano evaso +bool TQuantita_riga::get_evaso() const +{ + return _evaso; +} + +//GET_QTA_DA_CON: metodo che restituisce la quantità da consegnare +long TQuantita_riga::get_qta_da_con() const +{ + return _qtadacon; +} + +//GET_QTA_CON: metodo che restituisce la quantità consegnata +long TQuantita_riga::get_qta_con() const +{ + return _qtacon; +} + +//GET_PACCHI: metodo che restituisce il humero dei pacchi consegnati +int TQuantita_riga::get_pacchi() const +{ + return _pacchi; +} + +//SET_NRIGA: metodo che setta il numero di riga +void TQuantita_riga::set_nriga(const int nriga) +{ + _nriga = nriga; +} + +//SET_EVASO: metodo che setta il booleano evaso +void TQuantita_riga::set_evaso(const bool evaso) +{ + _evaso = evaso; +} + +//SET_QTA_DA_CON: metodo che settala quantità da consegnare +void TQuantita_riga::set_qta_da_con(const long qta) +{ + _qtadacon = qta; +} + +//SET_QTA_CON: metodo che setta la quantità consegnata +void TQuantita_riga::set_qta_con(const long qta) +{ + _qtacon = qta; +} + +//SET_PACCHI: metodo che setta il hnumero di pacchi consegnato +void TQuantita_riga::set_pacchi(const int pacchi) +{ + _pacchi = pacchi; +} + +//ADD_QTA_CON: metodo che aggiunge un quantitativo di roba alla quantità consegnata +void TQuantita_riga::add_qta_con(const long qta) +{ + _qtacon += qta; +} + +//ADD_PACCHI: metodo che aggiunge un certo numero di pacchi a quelli consegnati (default = 1) +void TQuantita_riga::add_pacchi(const int pacchi) +{ + _pacchi += pacchi; +} + +//metodo costruttore +TQuantita_riga::TQuantita_riga(bool evaso, long qtadc, long qtac, int pacchi) +{ + set_evaso(evaso); + set_qta_da_con(qtadc); + set_qta_con(qtac); + set_pacchi(pacchi); +} + + //////////////////////////// + //// TRIGHE_ARRAY //// + //////////////////////////// + +//Classe TRighe_array +class TRighe_array: public TAssoc_array +{ +public: + TQuantita_riga* quantita(TString& codart, TDate& data, bool create); +}; + +//QUANTITA: metodo che cerca nel TAssoc_array le quantità della riga interessata in base ai parametri passati +//e lo crea in automatico se il parametro create vale "true" +TQuantita_riga* TRighe_array::quantita(TString& codart, TDate& data, bool create) +{ + TToken_string key; + key.add(codart); + key.add(data); + + TQuantita_riga* qr = (TQuantita_riga*)objptr(key); + + if(qr == NULL && create) + { + qr = new TQuantita_riga(); + add(key, qr); + } + return qr; +} + +//class TEvasione_ter_msk +class TEvasione_ter_msk: public TAutomask +{ + TDocumento _buonori; + int _ndoc; + int _autoselect; + TString4 _tpev; + TAssoc_array _pacchi; + TRighe_array _ra; + +protected: + void campi_cliente(); + + void precarica_righe(); + void genera_buono(); + void evadi(); + void registra(); + + void riempi_sheet(); + void spezza_riga(); + + bool controlla(); + + void evadi_da_terminale(); + + virtual void on_idle(); + virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); + +public: + TEvasione_ter_msk(); +}; + +//PRECARICA_RIGHE: metodo che carica in un TAssoc_array le righe documento +void TEvasione_ter_msk::precarica_righe() +{ + TDoc_key kdoc(get_date(F_TDATADOC1).year(), ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0), get_long(F_TNDOC1)); + + TBuono_prelievo doc(kdoc); + + _buonori = doc; + + TDate oggi(TODAY); + + for(int i = 1; i <= doc.rows(); i++) + { + TRiga_documento& row = doc[i]; + TBuono_prelievo_row rdoc(row); + + TDate dataeva = rdoc.dataeva(); + if (!dataeva.ok()) + dataeva = oggi; + + TString80 codart = rdoc.codart(); + + TQuantita_riga* qr = _ra.quantita(codart, dataeva, true); + qr->set_nriga(i); + qr->set_evaso(rdoc.evaso()); + qr->set_qta_da_con(rdoc.qta_dacons()); + qr->set_qta_con(rdoc.qta_consegnata()); + qr->set_pacchi(rdoc.num_pacchi()); + } +} + +//GENERA_BUONO: metodo che genera il buono di consegna partendo dal buono di ritiro +void TEvasione_ter_msk::genera_buono() +{ + //per prima cosa salva il buono di prelievo + registra(); + + TDoc_key kdoc(get_date(F_TDATADOC1).year(), ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0), get_long(F_TNDOC1)); + TBuono_prelievo bpre(kdoc); + const long codcf = bpre.codcf(); + const int codcont = bpre.codcont(); + + TLaundry_contract cont(codcf, codcont); + //leggo se devo scrivere il prezzo sulla bolla + //const bool prinbo = cont.get_bool(LVCONDV_STPRZBOL); + const bool prinbo = true; //sempre a true; verrà gestita a video in futuro (27/10/2009) + + //dati documento da generare + TString4 codnum = ini_get_string(CONFIG_DITTA, "lv", "NUM_GEN"); + TString4 tipodoc = ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_GEN"); + char stato = cache().get("%TIP", tipodoc, "S2").left(1)[0]; + + const TDate databpre = bpre.datadoc(); + const TDate databolla = get_date(F_TDATADOC1); + const TDate datagen(TODAY); + TDate dadata = databpre; + TDate adata = datagen; + adata.addmonth(); + + if(_ndoc == 0) + { + TString query2; + query2 << "USE DOC\n" + << "FROM PROVV=\"D\" ANNO=" << datagen.year() << " CODNUM=\"" << codnum << "\"\n" + << "TO PROVV=\"D\" ANNO=" << datagen.year() << " CODNUM=\"" << codnum << "\""; + TISAM_recordset bolle(query2); + bolle.move_last(); + _ndoc = bolle.get(DOC_NDOC).as_int(); + } + + TString query1 = "USE LVRCONSPLAN KEY 3\n"; + query1 << "FROM CODCF=" << codcf << " CODCONT=" << codcont << " DTCONS=#DADATA\n"; + query1 << "TO CODCF=" << codcf << " CODCONT=" << codcont << " DTCONS=#ADATA\n"; + TISAM_recordset consegne(query1); + consegne.set_var("#DADATA", ++dadata); + consegne.set_var("#ADATA", adata); + consegne.move_first(); + const TDate dataprco = consegne.get(LVRCONSPLAN_DTCONS).as_date(); + const int coditi = consegne.get(LVRCONSPLAN_CODITI).as_int(); + + //recupero il codpag + TToken_string key; + key.add('C'); + key.add(codcf); + const TString4 codpag = cache().get(LF_CLIFO, key, CLI_CODPAG); + + //reupero la cuasale di magazzino di testata + const TString16 causmag = cache().get("%TIP", tipodoc, "S9"); + + //preparo la testata del documento + TDocumento doc('D', kdoc.anno(), codnum, ++_ndoc); + doc.put(DOC_TIPODOC, tipodoc); + doc.put(DOC_STATO, stato); + doc.put(DOC_DATADOC, databolla); + doc.put(DOC_TIPOCF, 'C'); + doc.put(DOC_CODCF, codcf); + doc.put(DOC_CODCONT, codcont); + doc.put(DOC_CODPAG, codpag); + doc.put(DOC_CAUSMAG, causmag); + doc.put("DATAGEN", datagen); //data generazione del documento + doc.put("DATAPRCO", dataprco); //data prevista consegna + doc.put("CODITI", coditi); //codice itinerario + + for (int i = 1; i <= bpre.rows(); i++) + { + TRiga_documento& row = bpre[i]; + TBuono_prelievo_row rbpre(row); + + //nella bolla ci vanno solo le righe evase e non associate + if (!rbpre.evaso()) + continue; + + TDoc_key kbuono = rbpre.rifbcon(); + if (kbuono.full()) + continue; + + const TString80 codart = rbpre.codart(); + TString descr = rbpre.desart(); + + const TRectype& rcont = cont.row(codart); + + //recupero i valori delle dotazione temporanea dal magazzino del cliente + TLocalisamfile magcli(LF_CLIFOGIAC); + magcli.put(CLIFOGIAC_ANNOES, datagen.year()); + magcli.put(CLIFOGIAC_TIPOCF, 'C'); + magcli.put(CLIFOGIAC_CODCF, codcf); + magcli.put(CLIFOGIAC_INDSPED, 0); //in realtà è da leggere dal contratto + magcli.put(CLIFOGIAC_CODART, codart); + magcli.put(CLIFOGIAC_NRIGA, 1); + //leggo il record corrispondente + magcli.read(); + 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 TString4 um = cache().get(LF_UMART, key, UMART_UM); + + TRiga_documento& rdoc = doc.new_row("21"); + rdoc.put(RDOC_CODART, codart); + rdoc.put(RDOC_CODARTMAG,codart); + rdoc.put(RDOC_CHECKED,'X'); + rdoc.put(RDOC_GENERATA, true); + + if(descr.len() <= 50) + rdoc.put(RDOC_DESCR, descr); + else + { + rdoc.put(RDOC_DESCR, descr.left(50)); + rdoc.put(RDOC_DESCEST, descr.sub(50)); + rdoc.put(RDOC_DESCLUNGA, true); + } + + rdoc.put(RDOC_QTA, rbpre.qta_consegnata()); //consegnato + rdoc.put(RDOC_QTAGG1, rbpre.qta_ritirata()); //ritirato + + 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)) + dtmp = true; + + if(dtmp) + { + rdoc.put("DOTMP", dottmp); + rdoc.add("DOTMP", rbpre.qta_consegnata() - rbpre.qta_ritirata()); + } + + rdoc.put(RDOC_CODAGG1, rbpre.causale()); + + const TRectype& anamag = cache().get(LF_ANAMAG, codart); + //gestione prezzo + if (prinbo) + { + real prezzo; + if (cont.get_int(LVCONDV_TIPOLIS) == 0) + prezzo = rcont.get_real(LVRCONDV_PREZZO); + else + prezzo = anamag.get_real(ANAMAG_COSTSTD); + + rdoc.put(RDOC_PREZZO, prezzo); + rdoc.put(RDOC_SCONTO, rcont.get(LVRCONDV_SCONTPERC)); //sconto + } + + rdoc.put(RDOC_UMQTA, um); + + //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.put(RDOC_CODMAG, magazzino); + rdoc.put(RDOC_CODMAGC, magazzinoc); + + //salvo i riferimenti + TDoc_key rifbcon(datagen.year(), codnum, _ndoc); + rbpre.set_rifbcon(rifbcon); + } + + //salva la bolla solo se ha almeno una riga + int err = 1; + if (doc.rows() > 0) + { + 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.rewrite(); + } + + if (err == NOERR) + { + if (yesno_box(TR("Il documento è stato generato; si desiderla stamparlo?"))) + { + //stampa automatica + TString80 str; + str << "ve1 -2 " << codnum << ' ' << datagen.year() << " D " << _ndoc << " S D"; + TExternal_app stampa(str); + stampa.run(); + } + } + else + warning_box(TR("Non è stato possibile generare nessun documento")); + + reset(F_TNDOC1); + send_key(K_SPACE, F_TNDOC1); +} + +//EVADI: metodo che setta a evaso tutte le righe del documento +void TEvasione_ter_msk::evadi() +{ + FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm) + { + TQuantita_riga* qr = (TQuantita_riga*)itm; + qr->set_evaso(true); + } +} + +//REGISTRA: metodo che salva il buono di prelievo così com'è +void TEvasione_ter_msk::registra() +{ + TDoc_key kdoc(get_date(F_TDATADOC1).year(), ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0), get_long(F_TNDOC1)); + + TBuono_prelievo doc(kdoc); + + TDate oggi(TODAY); + + FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm) + { + TQuantita_riga* qr = (TQuantita_riga*)itm; + int nriga = qr->get_nriga(); + + //se nriga > 0 vuol dire che si è aggiornata una riga già esistente; + //altrimenti significa che ho spezzato una riga + if (nriga > 0) + { + TRiga_documento& row = doc[nriga]; + TBuono_prelievo_row rdoc(row); + + rdoc.set_evaso(qr->get_evaso()); + rdoc.set_qta_consegnata(qr->get_qta_con()); + rdoc.set_qta_dacons(qr->get_qta_da_con()); + rdoc.set_num_pacchi(qr->get_pacchi()); + rdoc.set_dataeva(oggi); + } + else + { + //trovo la riga con quel codart + TToken_string chiave(key); + TString80 codart = chiave.get(0); + + int i; + for(i = 1; i <= doc.rows(); i++) + { + TRiga_documento& row = doc[i]; + if(codart == row.get(RDOC_CODART)) + break; + } + + //creo una copia di questa riga + TRiga_documento& row1 = doc[i]; + TRiga_documento& row2 = doc.new_row("24"); + + row2 = row1; + TBuono_prelievo_row rdoc(row2); + + //setto le quantità corrette + rdoc.set_evaso(qr->get_evaso()); + rdoc.set_qta_consegnata(qr->get_qta_con()); + rdoc.set_qta_dacons(qr->get_qta_da_con()); + rdoc.set_num_pacchi(qr->get_pacchi()); + rdoc.set_dataeva(oggi); + } + } + doc.rewrite(); + //visto che sto evadendo tramite barcode quando salvo salvo anche tutti i pacchi associati + //generando i movimenti di magazzino di scarico + TLocalisamfile pacchi(LF_PACCHI); + TLocalisamfile movi(LF_MOVMAG); + + //cerco l'ultimo numero di chiave in movmag + TISAM_recordset mov("USE MOVMAG"); + long nummov = 0; + + if(mov.move_last()) + nummov += mov.get(MOVMAG_NUMREG).as_int(); + + const TCausale_magazzino causale((ini_get_string(CONFIG_DITTA, "lv", "CAUSCARMAG"))); + TString8 magazzino; + magazzino << ini_get_string(CONFIG_DITTA, "lv", "CODMAG") << ini_get_string(CONFIG_DITTA, "lv", "CODMAGP"); + + TEsercizi_contabili es; + int annoes = es.date2esc(oggi); + + TMov_mag movmag(++nummov); + movmag.put(MOVMAG_ANNOES, annoes); + movmag.put(MOVMAG_DATAREG, oggi); + movmag.put(MOVMAG_CODCAUS, causale.codice()); + + FOR_EACH_ASSOC_OBJECT(_pacchi, o, codpacco, rifdoc) + { + TDoc_key kdoc = *(TToken_string*)rifdoc; + + TRiga_pacco rp(codpacco); + const TString80 codart = rp.articolo(); + const long qta = rp.quantita().integer(); + + //recupero l'unità di misura principale di quest'articolo + TToken_string key; + key.add(codart); + key.add(1); + const TString4 um = cache().get(LF_UMART, key, UMART_UM); + + rp.set_rigabolla(kdoc.anno(), kdoc.codnum(), kdoc.ndoc(), 0); //SOLUZIONE MOMENTANEA PER VEDERE SE FUNZIONA TUTTO + rp.rewrite(pacchi); + + //faccio la nuova riga del movimento di magazzino + TRectype& rmovmag = movmag.new_row(); + rmovmag.put(RMOVMAG_CODMAG, magazzino); + rmovmag.put(RMOVMAG_CODART, codart); + + rmovmag.put(RMOVMAG_UM, um); + rmovmag.put(RMOVMAG_QUANT, qta); + } + movmag.write(movi); +} + +void TEvasione_ter_msk::riempi_sheet() +{ + TSheet_field& sheet = sfield(F_TRIGHE); + sheet.destroy(); + + FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm) + { + TToken_string chiave(key); + TQuantita_riga& qr = *(TQuantita_riga*)itm; + + if(!qr.get_evaso()) + { + TToken_string riga = sheet.row(-1); + riga.add("", 0); + riga.add(chiave.get(0), 1); + riga.add(qr.get_qta_da_con(), 2); + riga.add(qr.get_qta_con(), 3); + } + } + sheet.force_update(); +} + +void TEvasione_ter_msk::spezza_riga() +{ + const TDate oggi(TODAY); + const TDate nulla(NULLDATE); + + FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm) + { + TToken_string chiave(key); + TQuantita_riga& qr = *(TQuantita_riga*)itm; + + if((TDate)chiave.get() == oggi && !qr.get_evaso()) + { + int qtadacon = qr.get_qta_da_con(); + int qtacon = qr.get_qta_con(); + int pacchi = qr.get_pacchi(); + + qr.set_evaso(true); + qr.set_qta_da_con(qtacon); + + TToken_string chiave1; + chiave1.add(chiave.get(0), 0); + chiave1.add(nulla, 1); + + TQuantita_riga qr1; + qr1.set_evaso(false); + qr1.set_qta_da_con(qtadacon - qtacon); + qr1.set_qta_con(0); + qr1.set_pacchi(0); + + _ra.add(chiave1, qr1); + } + } +} + +bool TEvasione_ter_msk::controlla() +{ + bool evaso = true; + FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm) + { + TQuantita_riga* qr = (TQuantita_riga*)itm; + + if(!qr->get_evaso()) + { + evaso = false; + break; + } + } + return evaso; +} + + +//EVADI_DA_TERMINALE: metodo che somma alla riga corretta un pacco (quello pistolato) e lo assegna a un cliente, +//sottraendolo dal magazzino del pulito +void TEvasione_ter_msk::evadi_da_terminale() +{ + TString80 codpacco = get(F_TBARCODE); + + const TDate oggi(TODAY); + + if (codpacco.full()) + { + const TRiga_pacco rp(codpacco); + const TString80 codart = rp.articolo(); + const long qtapacco = rp.quantita().integer(); + + //se il pacco è già stato pistolettato lo tolgo dai pacchi da evadere, altrimenti cerco di sommarlo + //a una riga documento esistente + if (_pacchi.is_key(codpacco)) + { + _pacchi.remove(codpacco); + + TToken_string key; + key.add(codart); + key.add(oggi); + + if (_ra.is_key(key)) + { + TQuantita_riga& qr = *(TQuantita_riga*)_ra.objptr(key); + qr.add_pacchi(-1); + qr.add_qta_con(-1 * qtapacco); + + if (qr.get_evaso()) + qr.set_evaso(false); + } + } + else + { + TDoc_key kdoc(get_date(F_TDATADOC1).year(), ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0), get_int(F_TNDOC1)); + + TToken_string key; + key.add(codart); + key.add(oggi); + + if (_ra.is_key(key)) + { + TQuantita_riga& qr = *(TQuantita_riga*)_ra.objptr(key); + + if (qr.get_evaso()) + { + if(yesno_box(TR("Si desidera sommare il pacco a una riga già evasa?"))) + { + qr.add_pacchi(); + qr.add_qta_con(qtapacco); + } + } + else + { + qr.add_pacchi(); + qr.add_qta_con(qtapacco); + + if(qr.get_qta_con() > qr.get_qta_da_con()) + { + warning_box(TR("ATTENZIONE: si sta consegnando un quantitativo maggiore al dovuto")); + qr.set_evaso(true); + } + } + _pacchi.add(codpacco, kdoc); + } + else + warning_box(TR("Non è stato possibile sommare il pacco a nessuna riga del buono")); + } + } +} + +//ON_FIELD_EVENT: metodo che gestisce gli eventi sui campi della maschera +bool TEvasione_ter_msk::on_field_event(TOperable_field& f, TField_event e, long jolly) +{ + //a seconda del bottone premuto esegui un metodo diverso + switch (f.dlg()) + { + case DLG_SELECT: + { + if (e == fe_button) + evadi(); + } + break; + case DLG_PREVIEW: + { + if (e == fe_button) + { + show(F_TDATADOC1); + show(F_TBARCODE); + show(F_TPACCHI); + show(F_TQTAPACCO); + show(F_TQTACON); + show(F_TQTADACON); + + show(F_TRIGHE); + riempi_sheet(); + } + } + break; + case DLG_ELABORA: + { + if (e == fe_button) + if (controlla()) + genera_buono(); + else + { + if(yesno_box(TR("ATTENZIONE: non tutte le righe sono evase. Si desidera continuare ugualmente?"))) + { + if(yesno_box(TR("Si desidera considerare evase tutte le righe?" + "(in caso contrario le righe evase parzialmente verranno spezzate su due righe)"))) + evadi(); + else + { + spezza_riga(); + genera_buono(); + } + } + else + send_key(K_SPACE, DLG_CANCEL); + } + } + break; + case DLG_CANCEL: + { + show(F_TDATADOC1); + show(F_TBARCODE); + show(F_TPACCHI); + show(F_TQTAPACCO); + show(F_TQTACON); + show(F_TQTADACON); + + hide(F_TRIGHE); + + _autoselect = 1; + } + break; + case DLG_SAVEREC: + { + if (e == fe_button) + registra(); + } + break; + case F_TNDOC: + { + if (e == fe_modify && !f.empty()) + { + show(F_TCODCF); + show(F_TRAGSOC); + show(F_TNDOC1); set(F_TNDOC1, get_int(F_TNDOC)); + show(F_TDATADOC1); set(F_TDATADOC1, get_date(F_TDATADOC)); + show(F_TBARCODE); + show(F_TPACCHI); + show(F_TQTAPACCO); + show(F_TQTACON); + show(F_TQTADACON); + + hide(F_TCODNUM); + hide(F_TTPDOC); + hide(F_TNDOC); + hide(F_TDATADOC); + hide(F_TANNO); + hide(F_TDATAPRCO); + + update(); + + precarica_righe(); + } + } + break; + case F_TBARCODE: + { + if (e == fe_modify && f.get().full()) + { + _autoselect = 1; + evadi_da_terminale(); + + if (controlla()) + send_key(K_SPACE, DLG_ELABORA); + } + } + case F_TNDOC1: + { + if (e == fe_modify && f.get().empty()) + { + hide(F_TCODCF); + hide(F_TRAGSOC); + hide(F_TNDOC1); + hide(F_TDATADOC1); + hide(F_TBARCODE); + hide(F_TPACCHI); + hide(F_TQTAPACCO); + hide(F_TQTACON); + hide(F_TQTADACON); + + show(F_TCODNUM); + show(F_TTPDOC); + show(F_TNDOC); reset(F_TNDOC); + show(F_TDATADOC); reset(F_TDATADOC); + show(F_TANNO); + show(F_TDATAPRCO); + } + } + break; + default:break; + } + return true; +} + +void TEvasione_ter_msk:: on_idle() +{ + TMask::on_idle(); + if (_autoselect >= 0 && get(F_TBARCODE).full()) + { + reset(F_TBARCODE); + field(F_TBARCODE).set_focus(); + _autoselect = -1; + } +} + +TEvasione_ter_msk::TEvasione_ter_msk():TAutomask("lv3400a") +{ + //precarico i campi fissi + set(F_TCODNUM, ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0)); + set(F_TTPDOC, ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0)); + + const TRectype& tpdoc = cache().get("%NUM", ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0)); + set(F_TDESCR, tpdoc.get("S0")); + + TDate data(TODAY); + TEsercizi_contabili es; + int annoes = es.date2esc(data); + set(F_TANNO, annoes); + + hide(F_TCODCF); + hide(F_TRAGSOC); + hide(F_TNDOC1); + hide(F_TDATADOC1); + hide(F_TBARCODE); + hide(F_TPACCHI); + hide(F_TQTAPACCO); + hide(F_TQTACON); + hide(F_TQTADACON); + hide(F_TRIGHE); +} + + ///////////////////////////////// + //// TEVASIONE_TER_APP //// + ///////////////////////////////// + +//classe TEvasione_ter_app +class TEvasione_ter_app : public TSkeleton_application +{ + TEvasione_ter_msk* _msk; +protected: + virtual bool create(); + virtual bool destroy(); + +public: + bool transfer(); + virtual void main_loop(); +}; + +//CREATE: metodo costruttore +bool TEvasione_ter_app::create() +{ + _msk = new TEvasione_ter_msk(); + open_files(LF_DOC, LF_RIGHEDOC); + return TSkeleton_application::create(); +} + +//DESTROY: metodo distruttore +bool TEvasione_ter_app::destroy() +{ + delete _msk; + return TApplication::destroy(); +} + +//TRANSFER: metodo che scorre i campi nome e, se sono pieni, richiama il metodo +//ELABORA_FILE(), che effettivamente fa l'elaborazione +bool TEvasione_ter_app::transfer() +{ + return true; +} + +void TEvasione_ter_app::main_loop() +{ + while (_msk->run() == K_ENTER) + transfer(); + } + +int lv3400(int argc, char *argv[]) +{ + TEvasione_ter_app a; + a.run (argc, argv, "Evasione Buoni di Prelievo"); + return TRUE; +} diff --git a/lv/lv3400a.h b/lv/lv3400a.h new file mode 100755 index 000000000..2be295ce3 --- /dev/null +++ b/lv/lv3400a.h @@ -0,0 +1,22 @@ +//Campi Maschera lv3200b +#define F_TCODNUM 401 +#define F_TTPDOC 402 +#define F_TDESCR 403 +#define F_TNDOC 404 +#define F_TANNO 405 +#define F_TDATADOC 406 +#define F_TDATAPRCO 407 +#define F_TCODCF 408 +#define F_TRAGSOC 409 +#define F_TNDOC1 410 +#define F_TDATADOC1 411 +#define F_TBARCODE 412 +#define F_TPACCHI 413 +#define F_TQTAPACCO 414 +#define F_TQTACON 415 +#define F_TQTADACON 416 +#define F_TRIGHE 417 + +#define S_TCODART 301 +#define S_TDACONS 302 +#define S_TCONS 303 \ No newline at end of file diff --git a/lv/lv3400a.uml b/lv/lv3400a.uml new file mode 100755 index 000000000..37bc7f743 --- /dev/null +++ b/lv/lv3400a.uml @@ -0,0 +1,203 @@ +#include "lv3400a.h" + +PAGE "Evasione Buoni di prelievo" -1 -1 35 10 + +STRING F_TCODNUM 4 +BEGIN + PROMPT 1 1 "" + FLAGS "D" +END + +STRING F_TTPDOC 4 +BEGIN + PROMPT 6 1 "" + FLAGS "D" +END + +STRING F_TDESCR 50 10 +BEGIN + PROMPT 11 1 "" + FLAGS "D" +END + +NUMBER F_TNDOC 6 +BEGIN + PROMPT 1 2 "Numero Doc. " + USE LF_DOC SELECT (STATO==2) + JOIN LF_CLIFO TO LF_DOC INTO TIPOCF==TIPOCF CODCF==CODCF + INPUT PROVV "D" + INPUT ANNO F_TANNO SELECT + INPUT CODNUM F_TCODNUM SELECT + INPUT NDOC F_TNDOC + INPUT TIPOCF "C" + DISPLAY "Num." CODNUM + DISPLAY "Data\ndocumento" DATADOC + DISPLAY "Ragione Sociale@10" LF_CLIFO->RAGSOC + OUTPUT F_TNDOC NDOC + OUTPUT F_TDATADOC DATADOC + OUTPUT F_TCODCF CODCF + OUTPUT F_TRAGSOC LF_CLIFO->RAGSOC +END + +NUMBER F_TANNO 4 +BEGIN + PROMPT 1 3 "Anno Esercizio " + FLAGS "D" +END + +DATE F_TDATADOC +BEGIN + PROMPT 1 4 "Data Doc. " +END + +DATE F_TDATAPRCO +BEGIN + PROMPT 1 5 "Prev Con. " +END + +NUMBER F_TCODCF 6 +BEGIN + PROMPT 1 0 "Cliente " + FLAGS "D" +END + +STRING F_TRAGSOC 20 +BEGIN + PROMPT 1 1 "" + FLAGS "D" +END + +NUMBER F_TNDOC1 6 +BEGIN + PROMPT 1 2 "Buono Numero " +END + +DATE F_TDATADOC1 +BEGIN + PROMPT 1 3 "Data Doc. " +END + +STRING F_TBARCODE 50 12 +BEGIN + PROMPT 1 4 "Barcode " +END + +NUMBER F_TPACCHI 6 +BEGIN + PROMPT 1 5 "Pacchi " +END + +NUMBER F_TQTAPACCO 6 +BEGIN + PROMPT 1 6 "Quantità pacco" +END + +NUMBER F_TQTACON 6 +BEGIN + PROMPT 1 7 "Quantità Cons." +END + +NUMBER F_TQTADACON 6 +BEGIN + PROMPT 1 8 "Da Consegnare " +END + +SPREADSHEET F_TRIGHE 0 6 +BEGIN + PROMPT 1 3 "Righe" + ITEM "Cod.\nArt." + ITEM "Da Cons." + ITEM "Consegnato" +END + +ENDPAGE + +TOOLBAR "Topbar" 0 0 0 2 + +BUTTON DLG_SELECT 2 2 +BEGIN + PROMPT 1 1 "Tutti" + PICTURE TOOL_MULTISEL + MESSAGE EXIT K_F5 +END + +BUTTON DLG_PREVIEW 2 2 +BEGIN + PROMPT 1 1 "Controlla" + PICTURE TOOL_PREVIEW + MESSAGE EXIT K_F6 +END + +BUTTON DLG_ELABORA 2 2 +BEGIN + PROMPT 1 1 "Evadi" + PICTURE TOOL_ELABORA + MESSAGE EXIT K_F7 +END + +BUTTON DLG_SAVEREC 2 2 +BEGIN + PROMPT 1 1 "Salva" + PICTURE TOOL_SAVEREC + MESSAGE_EXIT K_F8 +END + +BUTTON DLG_CANCEL 2 2 +BEGIN + PROMPT 1 1 "Annulla" + PICTURE TOOL_CANCEL + MESSAGE EXIT K_F9 +END + +BUTTON DLG_QUIT 2 2 +BEGIN + PROMPT 3 1 "Fine" + MESSAGE EXIT,K_QUIT + PICTURE TOOL_QUIT +END + +ENDPAGE +ENDMASK + +PAGE "Riga" -1 -1 22 11 + +STRING S_TCODART 9 +BEGIN + PROMPT 1 1 "Articolo " + FLAGS "D" +END + +NUMBER S_TDACONS 6 +BEGIN + PROMPT 1 2 "Da consegnare " + FLAGS "D" +END + +NUMBER S_TCONS 6 +BEGIN + PROMPT 1 3 "Quantità Cons." +END + +ENDPAGE + +TOOLBAR "" 0 0 0 2 + +BUTTON DLG_OK 2 2 +BEGIN + PROMPT 1 1 "" +END + +BUTTON DLG_DELREC 2 2 +BEGIN + PROMPT 2 1 "Elimina" + MESSAGE EXIT,K_DEL + PICTURE BMP_DELREC +END + +BUTTON DLG_CANCEL 2 2 +BEGIN + PROMPT 4 1 "" +END + +ENDPAGE +ENDMASK \ No newline at end of file diff --git a/lv/lvlib.cpp b/lv/lvlib.cpp index db19c9db4..f32da8c0c 100755 --- a/lv/lvlib.cpp +++ b/lv/lvlib.cpp @@ -792,6 +792,49 @@ TDoc_key::TDoc_key(const int anno, const TString& codnum, const long ndoc, const add(ndoc); } + ///////////////////////// + //// TRDOC_KEY //// + ///////////////////////// + +//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti +const char TRdoc_key::provv() +{ + return get(0)[0]; +} + +//ANNO: metodo che restituisce l'anno dalla TToken_string chiave dei documenti +const int TRdoc_key::anno() +{ + return get_int(1); +} + +//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti +const char* TRdoc_key::codnum() +{ + return get(2); +} + +//NDOC: metodo che restituisce il numero documento dalla TToken_string chiave dei documenti +const long TRdoc_key::ndoc() +{ + return get_int(3); +} + +const int TRdoc_key::nriga() +{ + return get_int(4); +} + +//metodi costruttori +TRdoc_key::TRdoc_key(const int anno, const TString& codnum, const long ndoc, const int nriga, const char provv) +{ + add(provv); + add(anno); + add(codnum); + add(ndoc); + add(nriga); +} + ///////////////////////////////////////////////////// //// TBUONO_PRELIEVO & TBUONO_PRELIEVO_ROW //// ///////////////////////////////////////////////////// @@ -930,6 +973,15 @@ const TToken_string& TBuono_prelievo_row::rifbrit() const return kdoc; } +//DATAEVA: metodo che restituisce la data di evasione di queòòa riga +const TDate& TBuono_prelievo_row::dataeva() const +{ + TDate& data = _rdoc.get_date("DATAEVA"); + if (!data.ok()) + data = NULLDATE; + return data; +} + //SET_EVASO: metodo che setta il contenuto del flag evaso void TBuono_prelievo_row::set_evaso(const bool evaso) { @@ -997,7 +1049,7 @@ void TBuono_prelievo_row::set_um(const char* um) _rdoc.put(RDOC_UMQTA, um); } -//SET_UM: metodo che setta l'unità di misura +//SET_PREZZO: metodo che setta il prezzo void TBuono_prelievo_row::set_prezzo(const real prezzo) { _rdoc.put(RDOC_PREZZO, prezzo); @@ -1044,6 +1096,12 @@ void TBuono_prelievo_row::set_rifbrit(const TToken_string& keybrit) _rdoc.put("RIFBRIT", str); } +//SET_DATAEVA: metodo che setta la data di evasione di quella riga +void TBuono_prelievo_row::set_dataeva(const TDate& data) +{ + _rdoc.put("DATAEVA", data); +} + //ADD_QTA_CONSEGNATA: metodo che somma una quantita alla quantità presente in una riga documento void TBuono_prelievo_row::add_qta_consegnata(const long qta) { diff --git a/lv/lvlib.h b/lv/lvlib.h index 8b282c9ba..4b65d4cd9 100755 --- a/lv/lvlib.h +++ b/lv/lvlib.h @@ -190,6 +190,29 @@ public: TDoc_key(const TDoc_key& key):TToken_string(key){} }; + ///////////////////////// + //// TRDOC_KEY //// + ///////////////////////// + +//classe TRdoc_key +class TRdoc_key: public TToken_string +{ +public: + const char provv(); + const int anno(); + const char* codnum(); + const long ndoc(); + const int nriga(); + + TRdoc_key& operator= (const char* key){set(key);} + + TRdoc_key(const int anno, const TString& codnum, const long ndoc, const int nriga, const char provv = 'D'); + TRdoc_key(const char* key):TToken_string(key){} + TRdoc_key(const TToken_string& key):TToken_string(key){} + TRdoc_key(const TRdoc_key& key):TToken_string(key){} +}; + + ///////////////////////////////////////////////////// //// TBUONO_PRELIEVO & TBUONO_PRELIEVO_ROW //// ///////////////////////////////////////////////////// @@ -231,6 +254,7 @@ public: const long cong_att() const; const TToken_string& rifbcon() const; const TToken_string& rifbrit() const; + const TDate& dataeva() const; void set_evaso(const bool evaso); void set_codart(const char* codart); @@ -249,6 +273,7 @@ public: void set_cong_att(const long qtacong); void set_rifbcon(const TToken_string& keybcon); void set_rifbrit(const TToken_string& keybrit); + void set_dataeva(const TDate& data); void add_qta_consegnata(const long qta); void add_pacchi(const int nmr = 1);