root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/lv/lv3200.cpp
luca83 0f98aa36c1 Patch level : 10.0 patch 491 
Files correlati     : lv3
Ricompilazione Demo : [ ]
Commento            :
Aggiunto il controllo "genera il documento solo per le righe non associate"


git-svn-id: svn://10.65.10.50/trunk@19540 c028cbd2-c16b-5b4b-a496-9718f37d4682
2009-10-28 16:38:59 +00:00

867 lines
25 KiB
C++
Executable File
Raw Blame History

#include <applicat.h>
#include <automask.h>
#include <defmask.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 "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();
bool controlla();
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;
if (dif == 0)
{
const TString& codart1 = row1.get(1);
const TString& codart2 = row2.get(1);
dif = codart1.compare(codart2);
}
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 TString& codart1 = row1.get(1);
const TString& codart2 = row2.get(1);
int dif = codart1.compare(codart2);
if (dif == 0)
{
const int qta1 = row1.get_int(6);
const int qta2 = row2.get_int(6);
dif = qta2 - qta1;
}
return dif;
}
//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
{
TString8 str = data.string();
if (str.empty())
{
reset(F_GIORNO);
reset(F_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);
}
if (get(F_RAGSOC).empty())
{
TToken_string key;
key.add('C');
key.add(codcf);
const TRectype& clifo = cache().get(LF_CLIFO, key);
set(F_RAGSOC, clifo.get(CLI_RAGSOC));
set(F_RICALT, clifo.get(CLI_RICALT));
}
}
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_RICALT);
reset(F_RAGSOC);
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);
const TString4 stato = doc.get(DOC_STATO);
set(F_STATO, stato);
disable(F_STATO);
set(F_DATADOC, doc.get_date(DOC_DATADOC)); setta_campi_data();
set(F_CODCF, doc.get_long(DOC_CODCF)); setta_campi_cliente(); field(F_CODCF).set_dirty();
_buonori = doc;
if(doc.rows() > 0)
{
enable(DLG_SELECT);
enable(DLG_PREVIEW);
if(stato == "1")
enable(DLG_ELABORA);
enable(DLG_SAVEREC);
enable(DLG_CANCEL);
show(F_RIGHE);
}
TSheet_field& sheet = sfield(F_RIGHE);
sheet.row(-1);
//preparo l'array delle posizioni dei campi nello sheet
_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));
sheet.destroy();
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() ? "X" : "", _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.sort(sort_by_codart);
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);
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 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 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);
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();
const TString4 stato = cache().get("%TIP", ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0), "S2").mid(1,1);
bpre.put(DOC_STATO, stato);
bpre.write();
set(F_STATO, stato);
}
}
//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()
{
TSheet_field& sheet = sfield(F_RIGHE);
FOR_EACH_SHEET_ROW_BACK(sheet, r, riga1)
{
char flgev = riga1->get_char(_posizioni.posizione("evaso"));
if (flgev != 'X')
{
TToken_string& riga2 = sheet.row(-1);
riga2 = *riga1;
const int dacons2 = riga2.get_int(_posizioni.posizione("ritirato")) - riga2.get_int(_posizioni.posizione("consegnato"));
riga2.add(dacons2, _posizioni.posizione("dacons"));
riga2.add(0L, _posizioni.posizione("consegnato"));
riga2.add(0L, _posizioni.posizione("pacchi"));
const int dacons1 = riga1->get_int(_posizioni.posizione("ritirato")) - riga1->get_int(_posizioni.posizione("consegnato"));
riga1->add(dacons1, _posizioni.posizione("dacons"));
riga1->add("X", _posizioni.posizione("evaso"));
}
}
sheet.sort(sort_by_codart);
sheet.force_update();
}
//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("21");
TBuono_prelievo_row rdoc(row);
const char flgev = riga->get(_posizioni.posizione("evaso"))[0];
bool flag;
if (flgev == 'X')
flag = true;
else
flag = false;
rdoc.set_evaso(flag);
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() ? "X" : "", _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();
}
//CONTROLLA: metodo che controlla se tutte le righe sono evase
bool TEvasione_msk::controlla()
{
TSheet_field& sheet = sfield(F_RIGHE);
bool evaso = true;
FOR_EACH_SHEET_ROW(sheet, r, row)
{
const char flgev = row->get(_posizioni.posizione("evaso"))[0];
if (flgev != 'X')
evaso = false;
}
return evaso;
}
//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()
{
TMask& msk = sfield(F_RIGHE).sheet_mask();
TString80 codart = msk.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)
{
int pacchi = msk.get_int(S_PACCHI);
int qta_consegnata = pacchi * ppconf;
msk.set(S_CONSEGNATO, qta_consegnata);
}
}
void TEvasione_msk::sistema_pacchi()
{
TMask& msk = sfield(F_RIGHE).sheet_mask();
TString80 codart = msk.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)
{
int qta_consegnata = msk.get_int(S_CONSEGNATO);
int pacchi = qta_consegnata / ppconf;
msk.set(S_PACCHI, pacchi);
}
}
//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()
{
}
//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 DLG_SELECT:
{
if (e == fe_button)
evadi_tutto();
}
break;
case DLG_PREVIEW:
{
riordina_righe();
}
break;
case DLG_ELABORA:
{
if (e == fe_button)
if (controlla())
genera_documento();
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_tutto();
else
{
spezza_riga();
genera_documento();
}
}
else
riordina_righe();
}
}
break;
case DLG_SAVEREC:
{
if (e == fe_button)
salva();
}
break;
case DLG_CANCEL:
{
if (e == fe_button)
{
annulla_operazioni();
return false;
}
}
break;
case F_NDOC:
{
if (e == fe_modify)
if (f.get_long() > 0)
carica_righe();
else
{
sfield(F_RIGHE).destroy();
disable(DLG_SELECT);
disable(DLG_PREVIEW);
disable(DLG_ELABORA);
disable(DLG_SAVEREC);
disable(DLG_CANCEL);
reset(F_STATO);
reset(F_DATADOC); setta_campi_data();
reset(F_CODCF); setta_campi_cliente();
hide(F_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)
{
TMask& msk = sfield(F_RIGHE).sheet_mask();
//la riga risulta evasa se la quantità consegnata è maggiore o uguale alla quantità da consegnare
if(msk.get_long(S_CONSEGNATO) > msk.get_long(S_DACONS))
{
warning_box(TR("ATTENZIONE: stai consegnando un quantitativo maggiore al dovuto"));
msk.set(S_EVASO, "X");
}
else if (msk.get_long(S_CONSEGNATO) == msk.get_long(S_DACONS))
msk.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);
hide(F_RIGHE);
disable(DLG_SELECT);
disable(DLG_PREVIEW);
disable(DLG_ELABORA);
disable(DLG_SAVEREC);
disable(DLG_CANCEL);
_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();
open_files(LF_DOC, LF_RIGHEDOC);
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;
}
Reference in New Issue View Git Blame Copy Permalink