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

Patch level : 10.0 patch ???

Browse Source 
Files correlati     : lv3 lvlib (lv0 lv2)
Ricompilazione Demo : [ ]
Commento            :
Aggiunto il programma lv3200 - Evasione dei buoni di prelievo

La maschera sarà completa nel prossimo commit


git-svn-id: svn://10.65.10.50/trunk@19514 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
luca83 2009-10-27 10:00:07 +00:00
parent de42d1e8c1
commit c233147861
7 changed files with 1379 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
lv/lv2900.cpp
View File

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

3
lv/lv3.cpp
View File

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

702
lv/lv3200.cpp Executable file
View File

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

32
lv/lv3200a.h Executable file
View File

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

296
lv/lv3200a.uml Executable file
View File

@ -0,0 +1,296 @@
#include "lv3200a.h"
TOOLBAR "Topbar" 0 0 0 2
#include <elabar.h>
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

264
lv/lvlib.cpp
View File

@ -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())
{
}
}
////////////////////////
//// 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);
}

82
lv/lvlib.h
View File

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