root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Patch level : 10.0 patch 508

Browse Source 
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
This commit is contained in:
luca83 2009-11-12 13:38:44 +00:00
parent 0c7e5cb405
commit 28323a0ac8
8 changed files with 1233 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lv/lv3.cpp
View File

@ -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;

1
lv/lv3.h
View File

@ -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

16
lv/lv3200.cpp
View File

@ -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[])
{

915
lv/lv3400.cpp Executable file
View File

@ -0,0 +1,915 @@
#include <applicat.h>
#include <automask.h>
#include <defmask.h>
#include <execp.h>
#include <reputils.h>
#include <reprint.h>
#include <utility.h>
#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;
}

22
lv/lv3400a.h Executable file
View File

@ -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

203
lv/lv3400a.uml Executable file
View File

@ -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

60
lv/lvlib.cpp
View File

@ -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)
{

25
lv/lvlib.h
View File

@ -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);