diff --git a/lv/lv2900.cpp b/lv/lv2900.cpp index 6d0da089c..21bf1b659 100755 --- a/lv/lv2900.cpp +++ b/lv/lv2900.cpp @@ -247,62 +247,6 @@ TRiga_pacco::TRiga_pacco() zero(); } - //////////////////////// - //// TDOC_KEY //// - //////////////////////// - -//classe TDoc_key -class TDoc_key: public TToken_string -{ -public: - - const char provv(); - const int anno(); - const char* codnum(); - const long ndoc(); - - TDoc_key(const int anno, const TString& codnum, const long ndoc, const char provv = 'D'); - TDoc_key(const char* key); -}; - -//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti -const char TDoc_key::provv() -{ - return get(0)[0]; -} - -//ANNO: metodo che restituisce l'anno dalla TToken_string chiave dei documenti -const int TDoc_key::anno() -{ - return get_int(1); -} - -//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti -const char* TDoc_key::codnum() -{ - return get(2); -} - -//NDOC: metodo che restituisce il numero documento dalla TToken_string chiave dei documenti -const long TDoc_key::ndoc() -{ - return get_int(3); -} - -//metodi costruttori -TDoc_key::TDoc_key(const int anno, const TString& codnum, const long ndoc, const char provv) -{ - add(provv); - add(anno); - add(codnum); - add(ndoc); -} - -TDoc_key::TDoc_key(const char* key):TToken_string(key) -{ -} - - //////////////////////////// //// TBUONI_CACHE //// //////////////////////////// @@ -762,8 +706,8 @@ bool TConta_pulito_msk::genera_documenti(const TFilename& file, TAssoc_array& do rdoc.put(RDOC_DESCLUNGA, true); } - rdoc.put(RDOC_QTA, quantita); - rdoc.put(RDOC_QTAGG1, quantita); + rdoc.put(RDOC_QTA, quantita); //consegnato + rdoc.put(RDOC_QTAGG1, quantita); //ritirato rdoc.put("DOTOD", dotod); rdoc.add("DOTOD", quantita); diff --git a/lv/lv3.cpp b/lv/lv3.cpp index f499ba16e..6cd667c8b 100755 --- a/lv/lv3.cpp +++ b/lv/lv3.cpp @@ -7,7 +7,8 @@ int main(int argc, char** argv) const int r = (argc > 1) ? argv[1][1] - '0' : 0; switch (r) { - case 1: break; + case 0: lv3100(argc, argv); break; // gestione manuale bolle lv3100 + case 1: lv3200(argc, argv); break; // evasione buoni si prelievo lv3200 default: lv3100(argc, argv); break; // gestione manuale bolle lv3100 } return 0; diff --git a/lv/lv3200.cpp b/lv/lv3200.cpp new file mode 100755 index 000000000..b7632d912 --- /dev/null +++ b/lv/lv3200.cpp @@ -0,0 +1,702 @@ +#include +#include +#include +#include +#include + +#include "lvlib.h" +#include "../mg/clifogiac.h" +#include "../ve/velib.h" + +#include "lvcondv.h" +#include "lvrcondv.h" +#include "lvrconsplan.h" + +#include "lv3200a.h" + + //////////////////////////////// + //// TPOSIZIONE_ARRAY //// + //////////////////////////////// + +//classe TPosizione_array +class TPosizione_array: public TObject +{ + TAssoc_array _pos; +public: + void aggiungi(const char* key, int pos); + int posizione(const char* key); + + TPosizione_array(){}; +}; + +//AGGIUNGI: metodo che aggiunge una coppia di valori all'array +void TPosizione_array::aggiungi(const char* key, const int pos) +{ + real tmp = pos; + _pos.add(key, tmp); +} + +//POSIZIONE: metodo che data una chiave restituisce la posizione (-1 se non esiste) +int TPosizione_array::posizione(const char* key) +{ + long posizione = -1; + if (_pos.is_key(key)) + { + real& tmp = *(real*)_pos.objptr(key); + posizione = tmp.integer(); + } + return posizione; +} + + ///////////////////////////// + //// TEVASIONE_MSK //// + ///////////////////////////// + +//classe TEvasione_msk +class TEvasione_msk: public TAutomask +{ + TDocumento _buonori; + TPosizione_array _posizioni; + int _ndoc; +protected: + void setta_campi_data(); + void setta_campi_cliente(); + + void carica_righe(); + void riordina_righe(); + void genera_documento(); + void evadi_tutto(); + void spezza_riga(); + void salva(); + void annulla_operazioni(); + + void sistema_quantita(); + void sistema_pacchi(); + void evadi_da_barcode(); + + virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); + +public: + TEvasione_msk(); +}; + + +//SORT_BY_QTA_EVASA: è la rows_comapre_function, cioè la funzione che viene utilizzata +//dal metodo sort degli sheet per riordinare le righe secondo le quantità evase +static int sort_by_qta_evasa(TSheet_field& sheet, int r1, int r2) +{ + TToken_string& row1 = sheet.row(r1); + TToken_string& row2 = sheet.row(r2); + + const int qta1 = row1.get_int(6); + const int qta2 = row2.get_int(6); + + int dif = qta1 - qta2; + + return dif; +} + +//SORT_BY_CODART: è la rows_comapre_function, cioè la funzione che viene utilizzata +//dal metodo sort degli sheet per riordinare le righe secondo i codart e le qta evase +static int sort_by_codart(TSheet_field& sheet, int r1, int r2) +{ + TToken_string& row1 = sheet.row(r1); + TToken_string& row2 = sheet.row(r2); + + /*const int qta1 = row1.get_int(6); + const int qta2 = row2.get_int(6); + + int dif = qta1 - qta2; + + return dif;*/ + + return 0; +} + +//SETTA_CAMPI_DATA: metodo che compila tutti i campi legati alla data +void TEvasione_msk::setta_campi_data() +{ + TDate data = get_date(F_DATADOC); + + if (data.ok()) + { + TDate primo = data; + primo.set_day(1); + + TEsercizi_contabili es; + int annoes = es.date2esc(data); + set(F_ANNO, annoes); + + //decodifica del giorno della settimana + set(F_GIORNO, itow(data.wday())); + //settimana del mese = settimana(oggi) - settimana(primo del mese) + 1 + long tmp = data.week() - primo.week() + 1; + TString4 settimana; + settimana << tmp; + set(F_SETTIMANA, settimana); + } + else + warning_box(TR("Data non valida!")); +} + +//SETTA_CAMPI_CLIENTE: metodo che compila tutti i campi legati al cliente +void TEvasione_msk::setta_campi_cliente() +{ + const long codcf = get_int(F_CODCF); + const TDate data = get_date(F_DATADOC); + + if (codcf > 0) + { + TLaundry_contract cont(codcf, 0, data); + + //se trovo un contratto, allora scrivo il codice contratto e cerco itinerario e data di prevista consegna + //se no avviso che non c'è neanche un contratto valido e svuoto i campi interassati + if(!cont.empty()) + { + set(F_CODCONT, cont.get_int(LVCONDV_CODCONT)); + + TDate adata = data; + adata.addmonth(1); + + TString query = "USE LVRCONSPLAN KEY 3\n"; + query << "FROM CODCF=" << get(F_CODCF) << " CODCONT=" << get(F_CODCONT) << " DTCONS=" << data << "\n"; + query << "TO CODCF=" << get(F_CODCF) << " CODCONT=" << get(F_CODCONT) << " DTCONS=" << adata << "\n"; + TISAM_recordset consegne(query); + + if (consegne.items() >= 2) + { + consegne.move_to(1); + set(F_DATAPRCO, consegne.get(LVRCONSPLAN_DTCONS).as_date()); + set(F_CODITI, consegne.get(LVRCONSPLAN_CODITI).as_int()); + } + else + { + reset(F_DATAPRCO); + reset(F_CODITI); + } + } + else + { + TString msg; + msg << "ATTENZIONE: nessun contratto in essere per il cliente " << codcf << " alla data " << data; + warning_box(msg); + + reset(F_CODCONT); + reset(F_DATAPRCO); + reset(F_CODITI); + } + } + else + { + reset(F_CODCONT); + reset(F_DATAPRCO); + reset(F_CODITI); + } +} + +//CARICA_RIGHE: metodo che carica sullo sheet le righe di un documento selezionato +void TEvasione_msk::carica_righe() +{ + TDoc_key kdoc(get_int(F_ANNO), get(F_CODNUM), get_long(F_NDOC)); + TBuono_prelievo doc(kdoc); + + _buonori = doc; + + TSheet_field sheet = sfield(F_RIGHE); + + for(int i = 1; i <= doc.rows(); i++) + { + TRiga_documento& row = doc[i]; + TBuono_prelievo_row rdoc(row); + + TToken_string& riga = sheet.row(-1); + riga.add(rdoc.evaso(), _posizioni.posizione("evaso")); + riga.add(rdoc.codart(), _posizioni.posizione("codart")); + riga.add(rdoc.desart(), _posizioni.posizione("artdescr")); + riga.add(rdoc.causale(), _posizioni.posizione("causale")); + riga.add(rdoc.qta_ritirata(), _posizioni.posizione("ritirato")); + riga.add(rdoc.qta_dacons(), _posizioni.posizione("dacons")); + riga.add(rdoc.qta_consegnata(), _posizioni.posizione("consegnato")); + + const TRectype& anamag = cache().get(LF_ANAMAG, rdoc.codart()); + //recupero i dati di interesse dall'anagrafica di magazzino + const long ppconf = anamag.get_long(ANAMAG_PPCONF); + + + if (ppconf > 0) + riga.add(rdoc.num_pacchi(), _posizioni.posizione("pacchi")); + else + { + riga.add(0, _posizioni.posizione("pacchi")); + sheet.disable_cell(i, _posizioni.posizione("pacchi")); + } + + riga.add(rdoc.cong_pre(), _posizioni.posizione("congpre")); + riga.add(rdoc.cong_att(), _posizioni.posizione("congatt")); + riga.add(rdoc.rifbcon(), _posizioni.posizione("rifbcon")); + riga.add(rdoc.rifbrit(), _posizioni.posizione("rifbrit")); + } + sheet.force_update(); +} + +//RIORDINA_RIGHE: metodo che riordina le righe dello sheet in base alle quota di evasione +void TEvasione_msk::riordina_righe() +{ + TSheet_field sheet = sfield(F_RIGHE); + sheet.sort(sort_by_qta_evasa); + sheet.force_update(); +} + +//GENERA_DOCUMENTO: metodo che genera il buono di consegna partendo dal buono di ritiro +void TEvasione_msk::genera_documento() +{ + //per prima cosa salva il buono di prelievo + salva(); + + TDoc_key kdoc(get_int(F_ANNO), get(F_CODNUM), get_long(F_NDOC)); + 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); + + //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 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(); + + //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, datagen); + doc.put(DOC_TIPOCF, 'C'); + doc.put(DOC_CODCF, codcf); + doc.put(DOC_CODCONT, codcont); + 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 + if (!rbpre.evaso()) + 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); + + 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 + + rdoc.put("DOTOD", dotod); + rdoc.add("DOTOD", rbpre.qta_consegnata()); + + 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()); + } + + 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 + } + + //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 + if (doc.rows() > 0) + { + doc.write(); + //bpre.set_stato("evaso"); + bpre.write(); + } +} + +//EVADI_TUTTO: metodo che forza a "evaso" tutte le righe e lancia la generazione del buono di consegna associato +void TEvasione_msk::evadi_tutto() +{ + const int posevaso = _posizioni.posizione("evaso"); + TSheet_field sheet = sfield(F_RIGHE); + + FOR_EACH_SHEET_ROW(sheet, r, riga) + { + riga->add("X", posevaso); + } + genera_documento(); +} + +//SPEZZA_RIGA: metodo che spezza una riga del buono in due righe, una per la quota evasa e una per la quota da evadere +void TEvasione_msk::spezza_riga() +{ + TDoc_key kdoc(get_int(F_ANNO), get(F_CODNUM), get_long(F_NDOC)); + TBuono_prelievo bpre(kdoc); + + for(int riga = 1; riga <= bpre.rows(); riga++) + { + TRiga_documento& row = bpre[riga]; + TBuono_prelievo_row rbpre1(row); + + if (rbpre1.evaso()) + continue; + + TRiga_documento rdoc(row); + TBuono_prelievo_row rbpre2(rdoc); + + rbpre2.set_qta_dacons(rbpre2.qta_ritirata() - rbpre2.qta_consegnata()); + rbpre2.set_qta_consegnata(0); + + rbpre1.set_qta_dacons(rbpre1.qta_ritirata() - rbpre1.qta_consegnata()); + rbpre1.set_evaso(true); + } +} + +//SALVA: metodo che salva il buono di prelievo così com'è, senza compiere altre operazioni +void TEvasione_msk::salva() +{ + TDoc_key kdoc(get_int(F_ANNO), get(F_CODNUM), get_long(F_NDOC)); + TBuono_prelievo doc(kdoc); + + //nel caso avessi spezzato le righe, riscirvendole da capo mi vengono ordinate per codice + doc.destroy_rows(); + + TSheet_field sheet = sfield(F_RIGHE); + //riordino lo sheet + sheet.sort(sort_by_codart); + sheet.force_update(); + + //per ogni riga dello sheet genero una riga documento + FOR_EACH_SHEET_ROW(sheet, r, riga) + { + TRiga_documento& row = doc.new_row(); + TBuono_prelievo_row rdoc(row); + + rdoc.set_evaso(riga->get(_posizioni.posizione("evaso")) == "X" ? true: false); + rdoc.set_codart(riga->get(_posizioni.posizione("codart"))); + rdoc.set_desart(riga->get(_posizioni.posizione("artdescr"))); + rdoc.set_causale(riga->get(_posizioni.posizione("causale"))); + rdoc.set_qta_ritirata(riga->get_int(_posizioni.posizione("ritirato"))); + rdoc.set_qta_dacons(riga->get_int(_posizioni.posizione("dacons"))); + rdoc.set_qta_consegnata(riga->get_int(_posizioni.posizione("consegnato"))); + rdoc.set_num_pacchi(riga->get_int(_posizioni.posizione("pacchi"))); + rdoc.set_cong_att(riga->get_int(_posizioni.posizione("congpre"))); + rdoc.set_cong_pre(riga->get_int(_posizioni.posizione("congatt"))); + rdoc.set_rifbcon(riga->get(_posizioni.posizione("rifbcon"))); + rdoc.set_rifbrit(riga->get(_posizioni.posizione("rifbrit"))); + } + doc.rewrite(); +} + +//ANNULLA_OPERAZIONI: metodo elimina tutte le quantità scritte durante l'ultima evasione +//e libera i pacchi eventualmente allocati +void TEvasione_msk::annulla_operazioni() +{ + //ANNULLA PACCHI + + //elimino lo sheet senza salvarlo + TSheet_field sheet = sfield(F_RIGHE); + sheet.destroy(); + + for(int i = 1; i <= _buonori.rows(); i++) + { + TRiga_documento& row = _buonori[i]; + TBuono_prelievo_row rdoc(row); + + TToken_string& riga = sheet.row(-1); + riga.add(rdoc.evaso(), _posizioni.posizione("evaso")); + riga.add(rdoc.codart(), _posizioni.posizione("codart")); + riga.add(rdoc.desart(), _posizioni.posizione("artdescr")); + riga.add(rdoc.causale(), _posizioni.posizione("causale")); + riga.add(rdoc.qta_ritirata(), _posizioni.posizione("ritirato")); + riga.add(rdoc.qta_dacons(), _posizioni.posizione("dacons")); + riga.add(rdoc.qta_consegnata(), _posizioni.posizione("consegnato")); + riga.add(rdoc.num_pacchi(), _posizioni.posizione("pacchi")); + riga.add(rdoc.cong_pre(), _posizioni.posizione("congpre")); + riga.add(rdoc.cong_att(), _posizioni.posizione("congatt")); + riga.add(rdoc.rifbcon(), _posizioni.posizione("rifbcon")); + riga.add(rdoc.rifbrit(), _posizioni.posizione("rifbrit")); + } + sheet.force_update(); +} + +//SISTEMA_QUANTITA: metodo che mantiene allineate le quantita consegnate e il numero +//dei pacchi, moltiplicando il numero dei pacchi per i pezzi per pacco; se scrivo una quantità +//a mano ed è prevista una evasione a pacchi, allora aggiorno il numero dei pacchi +void TEvasione_msk::sistema_quantita() +{ + TString80 codart = get(S_CODART); + + 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) + { + TSheet_field sheet = sfield(F_RIGHE); + TToken_string riga = sheet.row(sheet.selected()); + + int pacchi = get_int(S_PACCHI); + + int qta_consegnata = pacchi * ppconf; + riga.add(qta_consegnata, _posizioni.posizione("consegnato")); + sheet.force_update(sheet.selected()); + } +} + +void TEvasione_msk::sistema_pacchi() +{ + TString80 codart = get(S_CODART); + + 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) + { + TSheet_field sheet = sfield(F_RIGHE); + TToken_string riga = sheet.row(sheet.selected()); + + int qta_consegnata = get_int(S_CONSEGNATO); + + int pacchi = qta_consegnata / ppconf + 1; + riga.add(pacchi, _posizioni.posizione("pacchi")); + sheet.force_update(sheet.selected()); + } +} + +//EVADI_DA_BARCODE: metodo che somma alla riga corretta un pacco (quello pistolato) e lo assegna a un cliente, +//sottraendolo dal magazzino del pulito +void TEvasione_msk::evadi_da_barcode() +{ + TRiga_pacco rp +} + +//ON_FIELD_EVENT: metodo che gestisce gli eventi sui campi della maschera +bool TEvasione_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 F_NDOC: + { + if (e == fe_modify && f.get_long() > 0) + carica_righe(); + } + break; + case F_DATADOC: + { + if (e == fe_modify) + setta_campi_data(); + } + break; + case F_CODCF: + { + if (e == fe_modify) + setta_campi_cliente(); + } + break; + case S_CONSEGNATO: + { + if (e == fe_modify) + { + //la riga risulta evasa se la quantità consegnata è maggiore o uguale alla quantità da consegnare + if(f.get_long() > get_long(S_DACONS)) + { + warning_box(TR("ATTENZIONE: stai consegnando un quantitativo maggiore al dovuto")); + set(S_EVASO, "X"); + } + else if (f.get_long() == get_long(S_DACONS)) + set(S_EVASO, "X"); + sistema_pacchi(); + } + } + break; + case S_PACCHI: + { + if (e == fe_modify) + { + sistema_quantita(); + } + } + break; + default:break; + } + + return true; +} + +//metodo costruttore che precarica i campi di interesse sulla maschera +TEvasione_msk::TEvasione_msk():TAutomask("lv3200a") +{ + //precarico i campi fissi + set(F_CODNUM, ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0)); + set(F_TPDOC, 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_DESCR, tpdoc.get("S0")); + + TDate data(TODAY); + TEsercizi_contabili es; + int annoes = es.date2esc(data); + set(F_ANNO, annoes); + + //preparo l'array delle posizioni dei campi nello sheet + TSheet_field sheet = sfield(F_RIGHE); + _posizioni.aggiungi("evaso", sheet.cid2index(S_EVASO)); + _posizioni.aggiungi("codart", sheet.cid2index(S_CODART)); + _posizioni.aggiungi("desrart", sheet.cid2index(S_ARTDESCR)); + _posizioni.aggiungi("causale", sheet.cid2index(S_CAUSALE)); + _posizioni.aggiungi("ritirato", sheet.cid2index(S_RITIRATO)); + _posizioni.aggiungi("dacons", sheet.cid2index(S_DACONS)); + _posizioni.aggiungi("consegnato", sheet.cid2index(S_CONSEGNATO)); + _posizioni.aggiungi("pacchi", sheet.cid2index(S_PACCHI)); + _posizioni.aggiungi("congpre", sheet.cid2index(S_CONGPRE)); + _posizioni.aggiungi("congatt", sheet.cid2index(S_CONGATT)); + _posizioni.aggiungi("rifbcon", sheet.cid2index(S_RIFBCON)); + _posizioni.aggiungi("rifbrit", sheet.cid2index(S_RIFBRIT)); + + _ndoc = 0; +} + + ///////////////////////////// + //// TEVASIONE_APP //// + ///////////////////////////// + +//classe TEvasione_app +class TEvasione_app : public TSkeleton_application +{ + TEvasione_msk* _msk; + +protected: + virtual bool create(); + virtual bool destroy(); + +public: + bool transfer(); + virtual void main_loop(); +}; + +//CREATE: metodo costruttore +bool TEvasione_app::create() +{ + _msk = new TEvasione_msk(); + return TSkeleton_application::create(); +} + +//DESTROY: metodo distruttore +bool TEvasione_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_app::transfer() +{ + return true; +} + +void TEvasione_app::main_loop() +{ + while (_msk->run() == K_ENTER) + transfer(); +} + +int lv3200(int argc, char *argv[]) +{ + TEvasione_app a; + a.run (argc, argv, "Evasione Buoni di Prelievo"); + return TRUE; +} diff --git a/lv/lv3200a.h b/lv/lv3200a.h new file mode 100755 index 000000000..0e24c76d1 --- /dev/null +++ b/lv/lv3200a.h @@ -0,0 +1,32 @@ +//Acquisizione da contapezzi +//Campi Maschera lv3200a +#define F_CODNUM 201 +#define F_TPDOC 202 +#define F_DESCR 203 +#define F_NDOC 204 +#define F_STATO 205 +#define F_ANNO 206 +#define F_DATADOC 207 +#define F_GIORNO 208 +#define F_SETTIMANA 209 +#define F_DATAPRCO 210 +#define F_CODCF 211 +#define F_RICALT 212 +#define F_CODCONT 213 +#define F_CODITI 214 +#define F_RAGSOC 215 +#define F_RIGHE 216 + +#define S_EVASO 101 +#define S_CODART 102 +#define S_ARTDESCR 103 +#define S_CAUSALE 104 +#define S_CAUDESCR 999 +#define S_RITIRATO 105 +#define S_DACONS 106 +#define S_CONSEGNATO 107 +#define S_PACCHI 108 +#define S_CONGPRE 109 +#define S_CONGATT 110 +#define S_RIFBCON 111 +#define S_RIFBRIT 112 \ No newline at end of file diff --git a/lv/lv3200a.uml b/lv/lv3200a.uml new file mode 100755 index 000000000..3bde9a82c --- /dev/null +++ b/lv/lv3200a.uml @@ -0,0 +1,296 @@ +#include "lv3200a.h" + +TOOLBAR "Topbar" 0 0 0 2 + +#include + +ENDPAGE + +PAGE "Evasione Buoni di prelievo" -1 -1 80 10 + +GROUPBOX DLG_NULL 78 6 +BEGIN + PROMPT 1 1 "@bEstremi documento" +END + +STRING F_CODNUM 4 +BEGIN + PROMPT 2 2 "Documento " + FLAGS "D" +END + +STRING F_TPDOC 4 +BEGIN + PROMPT 17 2 "" + FLAGS "D" +END + +STRING F_DESCR 30 +BEGIN + PROMPT 22 2 "" + FLAGS "D" +END + +NUMBER F_NDOC 6 +BEGIN + PROMPT 54 2 "Num." + USE LF_DOC SELECT ((#F_STATO=="")||(STATO==#F_STATO)) + JOIN LF_CLIFO TO LF_DOC INTO TIPOCF==TIPOCF CODCF==CODCF + INPUT PROVV "D" + INPUT ANNO F_ANNO SELECT + INPUT CODNUM F_CODNUM SELECT + INPUT NDOC F_NDOC + INPUT TIPOCF "C" + DISPLAY "Num." CODNUM + DISPLAY "Anno" ANNO + DISPLAY "Provv" PROVV + DISPLAY "Tipo" TIPODOC + DISPLAY "N.Doc. " NDOC + DISPLAY "Stato@R" STATO + DISPLAY "Data\ndocumento" DATADOC + DISPLAY "C/F" TIPOCF + DISPLAY "Codice" CODCF + DISPLAY "Ragione Sociale@50" LF_CLIFO->RAGSOC + OUTPUT F_NDOC NDOC + OUTPUT F_STATO STATO + OUTPUT F_DATADOC DATADOC + OUTPUT F_CODCF CODCF + OUTPUT F_RICALT LF_CLIFO->RICALT + OUTPUT F_RAGSOC LF_CLIFO->RAGSOC +END + +STRING F_STATO 3 +BEGIN + PROMPT 68 2 "Stato" + USE %STD + INPUT CODTAB F_STATO + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT F_STATO CODTAB + FLAG "U" +END + +NUMBER F_ANNO 4 +BEGIN + PROMPT 2 3 "Esercizio " + FLAGS "D" +END + +DATE F_DATADOC +BEGIN + PROMPT 18 3 "" +END + +STRING F_GIORNO 10 +BEGIN + PROMPT 30 3 "" + FLAGS "D" +END + +NUMBER F_SETTIMANA 1 +BEGIN + PROMPT 42 3 "Settimana" + FLAGS "D" +END + +DATE F_DATAPRCO +BEGIN + PROMPT 54 3 "Data Prv.Con." + FLAGS "D" +END + +NUMBER F_CODCF 6 +BEGIN + PROMPT 2 4 "Cliente " + USE LF_CLIFO + INPUT TIPOCF "C" + INPUT CODCF F_CODCF + DISPLAY "Codice" CODCF + DISPLAY "Ricerca alternativa@30" RICALT + DISPLAY "Ragione Sociale@50" RAGSOC + OUTPUT F_CODCF CODCF + OUTPUT F_RAGSOC RAGSOC + OUTPUT F_RICALT RICALT + CHECKTYPE REQUIRED + ADD RUN cg0 -1 +END + +STRING F_RICALT 30 +BEGIN + PROMPT 21 4 "" + USE LF_CLIFO KEY 6 + INPUT TIPOCF "C" + INPUT RICALT F_RICALT + DISPLAY "Ricerca alternativa@30" RICALT + DISPLAY "Ragione sociale@50" RAGSOC + DISPLAY "Codice" CODCF + COPY OUTPUT F_CODCF + HELP "Chiave di ricerca alternativa" + CHECKTYPE NORMAL + ADD RUN cg0 -1 +END + +NUMBER F_CODCONT 3 +BEGIN + PROMPT 54 4 "Contr." + FLAGS "D" +END + +NUMBER F_CODITI 3 +BEGIN + PROMPT 65 4 "Cod.Iti." + USE &ITI + INPUT CODTAB F_CODITI + DISPLAY "Cod. Iti." CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT F_CODITI CODTAB + FLAGS "Z" +END + +STRING F_RAGSOC 50 +BEGIN + PROMPT 2 5 "Ragione Sociale " + USE LF_CLIFO KEY 2 + INPUT TIPOCF "C" + INPUT RAGSOC F_RAGSOC + DISPLAY "Ragione Sociale@50" RAGSOC + DISPLAY "Ricerca alternativa@30" RICALT + DISPLAY "Codice" CODCF + COPY OUTPUT F_CODCF + CHECKTYPE REQUIRED + ADD RUN cg0 -1 +END + +SPREADSHEET F_RIGHE 0 17 +BEGIN + PROMPT 1 7 "Righe" + ITEM "Evaso" + ITEM "Cod.\nArt." + ITEM "Descrizione" + ITEM "Cau." + ITEM "Ritirato" + ITEM "Da Cons." + ITEM "Consegnato" + ITEM "Pacchi" + ITEM "Cong.\nPrec." + ITEM "Cong.\nAtt." + ITEM "Riferimenti\nbuoni cons." + ITEM "Riferimenti\nbuoni rit." +END + +ENDPAGE +ENDMASK + +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 + +PAGE "Riga" -1 -1 80 10 + +BOOLEAN S_EVASO +BEGIN + PROMPT 1 1 "Evaso" +END + +STRING S_CODART 9 +BEGIN + PROMPT 1 2 "Articolo " + FLAGS "D" +END + +STRING S_ARTDESCR 50 +BEGIN + PROMPT 25 2 "" + FLAGS "D" +END + +STRING S_CAUSALE 3 +BEGIN + PROMPT 1 3 "Causale " + USE &LVCAU + INPUT CODTAB S_CAUSALE + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT S_CAUSALE CODTAB + OUTPUT S_CAUDESCR S0 + CHECKTYPE REQUIRED + FLAGS "U" +END + +STRING S_CAUDESCR 40 +BEGIN + PROMPT 25 3 "" + USE &LVCAU + KEY 2 + INPUT S0 S_CAUDESCR + DISPLAY "Descrizione@50" S0 + DISPLAY "Codice" CODTAB + COPY OUTPUT S_CAUSALE + CHECKTYPE REQUIRED +END + +NUMBER S_RITIRATO 5 +BEGIN + PROMPT 1 4 "Ritirato " + FLAGS "D" +END + +NUMBER S_DACONS 5 +BEGIN + PROMPT 18 4 "Da consegnare " + FLAGS "D" +END + +NUMBER S_CONSEGNATO 5 +BEGIN + PROMPT 40 4 "Consegnato " +END + +NUMBER S_PACCHI 5 +BEGIN + PROMPT 62 4 "Pacchi " +END + +NUMBER S_CONGPRE 5 +BEGIN + PROMPT 1 5 "Conguaglio precedente " + FLAGS "D" +END + +NUMBER S_CONGATT 5 +BEGIN + PROMPT 30 5 "Conguaglio attuale " + FLAGS "D" +END + +STRING S_RIFBCON 255 50 +BEGIN + PROMPT 1 6 "Riferimenti buono di consegna" + 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/lvlib.cpp b/lv/lvlib.cpp index d7745093b..40aef57f1 100755 --- a/lv/lvlib.cpp +++ b/lv/lvlib.cpp @@ -755,4 +755,266 @@ TLavanderie_calendar::TLavanderie_calendar(const int year) : _year(year) TCausale_lavanderie::TCausale_lavanderie(const char * codice): TRectype(cache().get("&CAU", codice)), _rit(caurit()), _cons(caucon()) { -} \ No newline at end of file +} + + + + //////////////////////// + //// TDOC_KEY //// + //////////////////////// + +//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti +const char TDoc_key::provv() +{ + return get(0)[0]; +} + +//ANNO: metodo che restituisce l'anno dalla TToken_string chiave dei documenti +const int TDoc_key::anno() +{ + return get_int(1); +} + +//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti +const char* TDoc_key::codnum() +{ + return get(2); +} + +//NDOC: metodo che restituisce il numero documento dalla TToken_string chiave dei documenti +const long TDoc_key::ndoc() +{ + return get_int(3); +} + +//metodi costruttori +TDoc_key::TDoc_key(const int anno, const TString& codnum, const long ndoc, const char provv) +{ + add(provv); + add(anno); + add(codnum); + add(ndoc); +} + + ///////////////////////////////////////////////////// + //// TBUONO_PRELIEVO & TBUONO_PRELIEVO_ROW //// + ///////////////////////////////////////////////////// + + +//classe TBuono_prelievo + +//CHIAVE: metodo che restituisce una TToken_string (da castare a TDoc_key) che contiene la chiave del documento +const TToken_string& TBuono_prelievo::chiave() const +{ + TToken_string& k = get_tmp_string(); + k.add(get(DOC_PROVV)); + k.add(get(DOC_ANNO)); + k.add(get(DOC_CODNUM)); + k.add(get(DOC_NDOC)); + return k; +} + +//DATADOC: metodo che restituisce la data del documento +const TDate TBuono_prelievo::datadoc() const +{ + return get_date(DOC_DATADOC); +} + +//CODCONT: metodo che restituisce il codice contratto +const long TBuono_prelievo::codcont() const +{ + return get_long(DOC_CODCONT); +} + +//SET_DATAPRCO: metodo che setta la data di prevista consegna +void TBuono_prelievo::set_dataprco(const TDate& data) +{ + put("DATAPRCO", data); +} + +//SET_ITINERARIO: metodo che setta il codice dell'itinerario +void TBuono_prelievo::set_itinerario(const int coditi) +{ + put("CODITI", coditi); +} + +//SET_CONRTATTO: metodo che setta il codice contratto +void TBuono_prelievo::set_contratto(const int codcont) +{ + put("CODCONT", codcont); +} + +//classe TBuono_prelievo_row + +//EVASO: metodo che indica se la riga in questione ha il flag di evaso a true +const bool TBuono_prelievo_row::evaso() const +{ + return _rdoc.get_bool(RDOC_RIGAEVASA); +} + +//CODART: metodo che restiuisce il codice articolo di quella riga +const TString& TBuono_prelievo_row::codart() const +{ + return _rdoc.get(RDOC_CODART); +} + +//DESART: metodo che restituisce la descrizione dell'articolo +const TString& TBuono_prelievo_row::desart() const +{ + TString& str = get_tmp_string(); + str = _rdoc.get(RDOC_DESCR); + + if (_rdoc.get_bool(RDOC_DESCLUNGA)) + str << _rdoc.get(RDOC_DESCEST); + + return str; +} + +//CAUSALE: metodo che restituisce il codice della causale della riga +const TString& TBuono_prelievo_row::causale() const +{ + return _rdoc.get(RDOC_CODAGG1); +} + +//QTA_RITIRATA: metodo che restituisce la quantità ritirata +const long TBuono_prelievo_row::qta_ritirata() const +{ + return _rdoc.get_long(RDOC_QTAGG1); +} + +//QTA_DACONS: metodo che restituisce la quantità da consegnare +const long TBuono_prelievo_row::qta_dacons() const +{ + return _rdoc.get_long(RDOC_QTA); +} + +//QTA_CONSEGNATA: metodo che restituisce la quantità effettivamente consegnata +const long TBuono_prelievo_row::qta_consegnata() const +{ + return _rdoc.get_long(RDOC_QTAEVASA); +} + +//NUM_PACCHI: metodo che restituisce il numero dei pacchi consegnati +const int TBuono_prelievo_row::num_pacchi() const +{ + return _rdoc.get_int(RDOC_NCOLLI); +} + +//CONG_PRE: metodo che restituisce il valore del conguaglio al momento dell'inizio delle operazioni +const long TBuono_prelievo_row::cong_pre() const +{ + return _rdoc.get_long("CONGPRE"); +} + +//CONG_ATT: metodo che restituisce il valore del conguaglio al termine dell'operazione attuale +const long TBuono_prelievo_row::cong_att() const +{ + return _rdoc.get_long("CONGATT"); +} + +//RIFBCON: metodo che restituisce i riferimenti al buono di consegna associato +const TToken_string& TBuono_prelievo_row::rifbcon() const +{ + TToken_string& kdoc = get_tmp_string(); + kdoc = _rdoc.get("RIFBCON"); + return kdoc; +} + +//RIFBRIT: metodo che restituisce i riferimenti al buono di ritiro associato +const TToken_string& TBuono_prelievo_row::rifbrit() const +{ + TToken_string& kdoc = get_tmp_string(); + kdoc = _rdoc.get("RIFBRIT"); + return kdoc; +} + +//SET_EVASO: metodo che setta il contenuto del flag evaso +void TBuono_prelievo_row::set_evaso(const bool evaso) +{ + _rdoc.put(RDOC_RIGAEVASA, evaso); +} + +//SET_CODART: metodo che setta il codice articolo +void TBuono_prelievo_row::set_codart(const char* codart) +{ + _rdoc.put(RDOC_CODART, codart); +} + +//SET_DESART: metodo che setta la descrizione +void TBuono_prelievo_row::set_desart(const TString& desart) +{ + if (desart.len() > 50) + { + _rdoc.put(RDOC_DESCR, desart.left(50)); + _rdoc.put(RDOC_DESCLUNGA, true); + _rdoc.put(RDOC_DESCEST, desart.mid(50)); + } + else + _rdoc.put(RDOC_DESCR, desart); +} + +//SET_CAUSALE: metodo che setta la causale sulla riga +void TBuono_prelievo_row::set_causale(const char* causale) +{ + _rdoc.put(RDOC_CODAGG1, causale); +} + +//SET_QTA_RITIRATA: metodo che setta la quantità ritirata sulla riga +void TBuono_prelievo_row::set_qta_ritirata(const long qta) +{ + _rdoc.put(RDOC_QTAGG1, qta); +} + +//SET_QTA_DACONS: metodo che setta la quyantità da consegnare +void TBuono_prelievo_row::set_qta_dacons(const long qta) +{ + _rdoc.put(RDOC_QTA, qta); +} + +//SET_QTA_CONSEGNATA: metodo che setta la quantita consegnata +void TBuono_prelievo_row::set_qta_consegnata(const long qta) +{ + _rdoc.put(RDOC_QTAEVASA, qta); +} + +//SET_NUM_PACCHI: metodo che setta il numero dei pacchi +void TBuono_prelievo_row::set_num_pacchi(const int numpacchi) +{ + _rdoc.put(RDOC_NCOLLI, numpacchi); +} + +//SET_CONG_PRE: metodo che setta il valore del conguaglio precedente +void TBuono_prelievo_row::set_cong_pre(const long qtacong) +{ + _rdoc.put("CONGPRE", qtacong); +} + +//SET_CONG_ATT: metodo che setta il valore del conguaglio attuale +void TBuono_prelievo_row::set_cong_att(const long qtacong) +{ + _rdoc.put("CONGATT", qtacong); +} + +//SET_RIFBCON: metodo che setta i riferimenti al buono di consegna associato +void TBuono_prelievo_row::set_rifbcon(const TToken_string& keybcon) +{ + _rdoc.put("RIFBCON", keybcon); +} + +//SET_RIFBRIT: metodo che setta i riferimenti al buono di ritiro associato +void TBuono_prelievo_row::set_rifbrit(const TToken_string& keybrit) +{ + _rdoc.put("RIFBRIT", keybrit); +} + +//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) +{ + _rdoc.add(RDOC_QTAEVASA, qta); +} + +//ADD_PACCHI: metodo che aggiunge un certo numero di pacchi al numero presente sulla riga +void TBuono_prelievo_row::add_pacchi(const int nmr) +{ + _rdoc.add(RDOC_NCOLLI, nmr); +} diff --git a/lv/lvlib.h b/lv/lvlib.h index 10a07f2ab..8932cbc02 100755 --- a/lv/lvlib.h +++ b/lv/lvlib.h @@ -164,4 +164,86 @@ public: virtual ~TCausale_lavanderie() {} }; + + //////////////////////// + //// TDOC_KEY //// + //////////////////////// + +//classe TDoc_key +class TDoc_key: public TToken_string +{ +public: + const char provv(); + const int anno(); + const char* codnum(); + const long ndoc(); + + TDoc_key& operator= (const char* key){set(key);} + + TDoc_key(const int anno, const TString& codnum, const long ndoc, const char provv = 'D'); + TDoc_key(const char* key):TToken_string(key){} + TDoc_key(const TToken_string& key):TToken_string(key){} + TDoc_key(const TDoc_key& key):TToken_string(key){} +}; + + ///////////////////////////////////////////////////// + //// TBUONO_PRELIEVO & TBUONO_PRELIEVO_ROW //// + ///////////////////////////////////////////////////// + + +//classe TBuono_prelievo +class TBuono_prelievo: public TDocumento +{ +public: + const TToken_string& chiave() const; + const TDate datadoc() const; + const long codcont() const; + + void set_dataprco(const TDate& data); + void set_itinerario(const int coditi); + void set_contratto(const int codcont); + + TBuono_prelievo& operator= (const TBuono_prelievo bpre){bpre;} + + TBuono_prelievo(TDoc_key& key): TDocumento(key.provv(), key.anno(), key.codnum(), key.ndoc()){}; + TBuono_prelievo(TBuono_prelievo& bpre): TDocumento(bpre){}; +}; + +//classe TBuono_prelievo_row +class TBuono_prelievo_row: public TObject +{ + TRiga_documento& _rdoc; +public: + const bool evaso() const; + const TString& codart() const; + const TString& desart() const; + const TString& causale() const; + const long qta_ritirata() const; + const long qta_dacons() const; + const long qta_consegnata() const; + const int num_pacchi() const; + const long cong_pre() const; + const long cong_att() const; + const TToken_string& rifbcon() const; + const TToken_string& rifbrit() const; + + void set_evaso(const bool evaso); + void set_codart(const char* codart); + void set_desart(const TString& desart); + void set_causale(const char* causale); + void set_qta_ritirata(const long qta); + void set_qta_dacons(const long qta); + void set_qta_consegnata(const long qta); + void set_num_pacchi(const int numpacchi); + void set_cong_pre(const long qtacong); + void set_cong_att(const long qtacong); + void set_rifbcon(const TToken_string& keybcon); + void set_rifbrit(const TToken_string& keybrit); + + void add_qta_consegnata(const long qta); + void add_pacchi(const int nmr = 1); + + TBuono_prelievo_row(TRiga_documento& rdoc):_rdoc(rdoc){} +}; + #endif