888 lines
27 KiB
C++
Executable File
888 lines
27 KiB
C++
Executable File
#include "velib04.h"
|
||
#include "velib04d.h"
|
||
|
||
#include <recset.h>
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TConsegna ordini mask
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class TConsegna_mask : public TAutomask
|
||
{
|
||
bool _ordina_per_codice;
|
||
bool _ignora_descrizioni;
|
||
const TDocumento* _indoc;
|
||
const TDocumento* _outdoc;
|
||
|
||
protected:
|
||
virtual bool on_field_event(class TOperable_field& f, TField_event e, long jolly);
|
||
|
||
public:
|
||
void doc2mask(const TDocumento& indoc, const TDocumento& outdoc, const TString & articolo);
|
||
TConsegna_mask(int header_code = 0, bool per_codice = false, bool ignora_descrizioni = false);
|
||
};
|
||
|
||
bool TConsegna_mask::on_field_event(class TOperable_field& f, TField_event e, long jolly)
|
||
{
|
||
bool update_row = false;
|
||
switch (f.dlg())
|
||
{
|
||
case S_QTADAEVADERE:
|
||
if (e == fe_modify && jolly > 0)
|
||
{
|
||
TMask& m = f.mask();
|
||
const real qta_residua = m.get_real(S_QTARESIDUA);
|
||
const real qta_daevadere = m.get_real(S_QTADAEVADERE);
|
||
if (qta_daevadere > ZERO)
|
||
{
|
||
m.set(S_RIGACONSEGNATA, "X");
|
||
if (qta_daevadere >= qta_residua)
|
||
{
|
||
m.set(S_RIGAEVASA, "X");
|
||
m.disable(S_RIGAEVASA);
|
||
}
|
||
else
|
||
m.enable(S_RIGAEVASA);
|
||
}
|
||
else
|
||
{
|
||
m.set(S_RIGAEVASA, " ");
|
||
m.enable(S_RIGAEVASA);
|
||
}
|
||
update_row = !m.is_running();
|
||
}
|
||
break;
|
||
case S_RIGAEVASA:
|
||
if (e == fe_modify && jolly > 0 && f.get().not_empty())
|
||
{
|
||
TMask& m = f.mask();
|
||
const real qta_daevadere = m.get_real(S_QTADAEVADERE);
|
||
if (qta_daevadere.is_zero())
|
||
{
|
||
const TString& residuo = m.get(S_QTARESIDUA);
|
||
m.set(S_QTADAEVADERE, residuo, true);
|
||
update_row = !m.is_running();
|
||
}
|
||
}
|
||
break;
|
||
case F_CONSEGNA:
|
||
if (e == fe_button)
|
||
{
|
||
TSheet_field& s = sfield(F_ROWS);
|
||
FOR_EACH_SHEET_ROW(s, n, row) if (!s.cell_disabled(n,S_RIGACONSEGNATA-FIRST_FIELD))
|
||
{
|
||
bool select = true;
|
||
const real residuo = row->get(S_QTARESIDUA-FIRST_FIELD);
|
||
const real evaso = row->get(S_QTADAEVADERE-FIRST_FIELD);
|
||
if (evaso.is_zero() && residuo > ZERO)
|
||
{
|
||
row->add(residuo.string(), S_QTADAEVADERE-FIRST_FIELD);
|
||
row->add("X", S_RIGAEVASA-FIRST_FIELD);
|
||
s.disable_cell(n, S_RIGAEVASA-FIRST_FIELD);
|
||
}
|
||
if (evaso.is_zero() && residuo.is_zero())
|
||
{
|
||
const int nriga = row->get_int(S_NUMRIGA-FIRST_FIELD);
|
||
const TRiga_documento& rdoc = (*_indoc)[nriga];
|
||
select = rdoc.quantita().is_zero();
|
||
}
|
||
if (select)
|
||
row->add("X", S_RIGACONSEGNATA-FIRST_FIELD);
|
||
}
|
||
s.force_update();
|
||
}
|
||
break;
|
||
case F_ROWS:
|
||
if (e == se_query_add || e == se_query_del)
|
||
return false;
|
||
if (e == fe_close)
|
||
{
|
||
const TString8 codcausmag = _outdoc->get(DOC_CAUSMAG);
|
||
if (codcausmag.full() && _outdoc->tipo().check_giac())
|
||
{
|
||
const TCausale_magazzino& causmag = ::cached_causale_magazzino(codcausmag);
|
||
const int alarm = causmag.get_int("I4");
|
||
if (alarm > 0)
|
||
{
|
||
TSheet_field& s = (TSheet_field&)f;
|
||
TAssoc_array giacenze;
|
||
FOR_EACH_SHEET_ROW(s, n, row)
|
||
{
|
||
const bool cons = row->get_char(0) > ' '; // E' da consegnare?
|
||
if (cons)
|
||
{
|
||
const real e = row->get(s.cid2index(S_QTADAEVADERE));
|
||
if (!e.is_zero())
|
||
{
|
||
TToken_string key(32, ' ');
|
||
key = row->get(s.cid2index(S_CODART));
|
||
if (!cache().get(LF_ANAMAG, key).empty()) // Controlla solo articoli a magazzino
|
||
{
|
||
key.add(row->get(s.cid2index(S_LIVGIAC1)));
|
||
key.add(row->get(s.cid2index(S_LIVGIAC2)));
|
||
key.add(row->get(s.cid2index(S_LIVGIAC3)));
|
||
key.add(row->get(s.cid2index(S_LIVGIAC4)));
|
||
key.trim();
|
||
real* g = (real*)giacenze.objptr(key);
|
||
if (g == NULL)
|
||
{
|
||
g = new real(row->get(s.cid2index(S_GIACENZA)));
|
||
giacenze.add(key, g);
|
||
}
|
||
*g -= e;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
bool some_errors = false;
|
||
FOR_EACH_ASSOC_OBJECT(giacenze, h, k, o)
|
||
{
|
||
const real& g = *(real*)o;
|
||
if (g < ZERO)
|
||
{
|
||
TString msg;
|
||
msg << TR("L'articolo ") << k << TR(" avr<76> una giacenza di ") << g.stringa();
|
||
switch (alarm)
|
||
{
|
||
case 1: warning_box(msg); break;
|
||
case 2:
|
||
msg << ":\n" << TR("Si desidera proseguire ugualmente?");
|
||
if (!yesno_box(msg))
|
||
some_errors = true;
|
||
break;
|
||
default: some_errors = !error_box(msg); break;
|
||
}
|
||
}
|
||
}
|
||
if (some_errors)
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
if (update_row)
|
||
{
|
||
TSheet_field& s = sfield(F_ROWS);
|
||
const int riga = s.selected();
|
||
s.update_row(riga);
|
||
s.force_update(riga);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
int rows_sort_func(TSheet_field& s, int i, int j)
|
||
{
|
||
const TToken_string& s1 = s.row(i);
|
||
const TToken_string& s2 = s.row(j);
|
||
|
||
const short fields[] = { S_CODART, S_LIVGIAC1, S_LIVGIAC2, S_LIVGIAC3, S_LIVGIAC4,
|
||
S_CODMAG, S_CODDEP, S_RIGAEVASA, S_DATACONS, S_QTARESIDUA, -1 };
|
||
// Temporary vars
|
||
TString80 ss1, ss2;
|
||
real rr1, rr2;
|
||
|
||
int ret = 0;
|
||
for (int field = 0; ret == 0 && fields[field] > 0; field++)
|
||
{
|
||
const short id = fields[field];
|
||
if (id == S_QTARESIDUA)
|
||
{
|
||
s1.get(id-FIRST_FIELD, rr1);
|
||
s2.get(id-FIRST_FIELD, rr2);
|
||
ret = rr2 < rr1 ? -1 : (rr2 > rr1 ? 1 : 0);
|
||
}
|
||
else
|
||
{
|
||
s1.get(id-FIRST_FIELD, ss1);
|
||
s2.get(id-FIRST_FIELD, ss2);
|
||
if (id == S_DATACONS)
|
||
{
|
||
const TDate dd1 = ss1, dd2 = ss2;
|
||
ret = int(dd1 - dd2);
|
||
}
|
||
else
|
||
ret = ss1.compare(ss2);
|
||
}
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
void TConsegna_mask::doc2mask(const TDocumento& indoc, const TDocumento& outdoc, const TString& articolo)
|
||
{
|
||
TWait_cursor hourglass;
|
||
_indoc = &indoc;
|
||
_outdoc = &outdoc;
|
||
|
||
for (int n = fields()-1; n >= 0; n--)
|
||
{
|
||
TMask_field& f = fld(n);
|
||
const TFieldref* fr = f.field();
|
||
if (fr != NULL)
|
||
{
|
||
const TString& val = indoc.get(fr->name());
|
||
f.set(val);
|
||
}
|
||
}
|
||
|
||
const TDate oggi(TODAY);
|
||
TEsercizi_contabili esc;
|
||
const int codes = esc.date2esc(oggi);
|
||
|
||
const TTipo_documento& tip = indoc.tipo();
|
||
const bool ordine_quadro = tip.is_ordine_quadro();
|
||
const bool show_evaded = ordine_quadro || tip.mostra_righe_evase_in_elaborazione();
|
||
|
||
TSheet_field& s = sfield(F_ROWS);
|
||
s.destroy();
|
||
|
||
const int rows = indoc.physical_rows();
|
||
int rowno = 0;
|
||
for (int i = 0; i < rows; i++)
|
||
{
|
||
const TRiga_documento& rec = indoc[i+1];
|
||
const real residuo = rec.qtaresidua();
|
||
const bool evasa = residuo.is_zero() && !ordine_quadro;
|
||
bool show_line = show_evaded || !evasa;
|
||
if (rec.is_descrizione())
|
||
show_line = !_ignora_descrizioni;
|
||
|
||
if ( show_line && (articolo.blank() || articolo == rec.get(RDOC_CODARTMAG)) )
|
||
{
|
||
TToken_string& r = s.row(-1);
|
||
r = " ";
|
||
if (evasa)
|
||
r.add(" ");
|
||
else
|
||
r.add(residuo.string());
|
||
r.add(" "); // Da evadere
|
||
if (evasa)
|
||
{
|
||
s.disable_cell(rowno, -1); // Disbilita tutta la riga ...
|
||
s.enable_cell(rowno, 0); // ... tranne il flag di consegna
|
||
r.add("X"); // La considera evasa
|
||
}
|
||
else
|
||
r.add(" ");
|
||
r.add(rec.get(RDOC_CODMAG).left(3));
|
||
r.add(rec.get(RDOC_CODMAG).mid(3));
|
||
r.add(rec.get(RDOC_CODART));
|
||
const TString& livello = rec.get(RDOC_LIVELLO);
|
||
for (int l = 1; l <= 4; l++)
|
||
r.add(livelli_giacenza().unpack_grpcode(livello, l));
|
||
|
||
if (!evasa && rec.is_articolo())
|
||
{
|
||
const TArticolo_giacenza ag(rec.get(RDOC_CODARTMAG));
|
||
const real giac = ag.empty()? ZERO : ag.giacenza_anno(rec.get(RDOC_CODMAG), livello, codes);
|
||
r.add(giac.string(), s.cid2index(S_GIACENZA));
|
||
}
|
||
|
||
// Reperisce data di consegna da riga o testata
|
||
TDate data_cons = rec.get(RDOC_DATACONS);
|
||
if (!data_cons.ok())
|
||
data_cons = indoc.get_date(DOC_DATACONS);
|
||
r.add(data_cons, s.cid2index(S_DATACONS));
|
||
|
||
r.add(rec.get(RDOC_PREZZO), s.cid2index(S_PREZZO));
|
||
r.add(rec.get(RDOC_DESCR), s.cid2index(S_DESCR));
|
||
r.add(rec.get(RDOC_TIPORIGA), s.cid2index(S_TIPORIGA));
|
||
r.add(rec.get(RDOC_NRIGA), s.cid2index(S_NUMRIGA));
|
||
r.add(rec.get(RDOC_CODAGG1), s.cid2index(S_CODAGG1));
|
||
r.add(rec.get(RDOC_CODAGG2), s.cid2index(S_CODAGG2));
|
||
rowno++;
|
||
}
|
||
}
|
||
if (_ordina_per_codice)
|
||
s.sort(rows_sort_func);
|
||
}
|
||
|
||
TConsegna_mask::TConsegna_mask(int header_code, bool per_codice, bool ignora_descrizioni)
|
||
: TAutomask("velib04d"), _ordina_per_codice(per_codice), _indoc(NULL), _outdoc(NULL),
|
||
_ignora_descrizioni(ignora_descrizioni)
|
||
{
|
||
TCodgiac_livelli cl;
|
||
TSheet_field& s = sfield(F_ROWS);
|
||
cl.set_sheet_columns(s, S_LIVGIAC1);
|
||
if (header_code == 1)
|
||
{
|
||
s.set_column_header(S_QTARESIDUA, HR("Quantit<EFBFBD>\nconsegnata"));
|
||
s.sheet_mask().field(S_QTARESIDUA).set_prompt(PR("Q.t<> consegnata"));
|
||
|
||
s.set_column_header(S_QTADAEVADERE, HR("Quantit<EFBFBD>\nda fatturare"));
|
||
s.sheet_mask().field(S_QTADAEVADERE).set_prompt(PR("Q.t<> da fatturare"));
|
||
} else
|
||
if (header_code == 2)
|
||
{
|
||
s.set_column_header(S_QTARESIDUA, HR("Residuo"));
|
||
s.sheet_mask().field(S_QTARESIDUA).set_prompt(PR("Residuo "));
|
||
|
||
s.set_column_header(S_QTADAEVADERE, HR("Da evadere"));
|
||
s.sheet_mask().field(S_QTADAEVADERE).set_prompt(PR("Da evadere "));
|
||
}
|
||
|
||
TConfig c(CONFIG_DITTA, "ve");
|
||
for (int i = 1; i <= 2; i++)
|
||
{
|
||
TString8 n; n.format("CODAGG%d", i);
|
||
if (c.exist(n))
|
||
{
|
||
const short id = i == 1 ? S_CODAGG1 : S_CODAGG2;
|
||
TString80 codagg = c.get(n);
|
||
TMask_field& agg = s.sheet_mask().field(id);
|
||
s.set_column_header(id, codagg);
|
||
codagg.rpad(strlen(agg.prompt()));
|
||
agg.set_prompt(codagg);
|
||
}
|
||
}
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TConsegna ordini
|
||
///////////////////////////////////////////////////////////
|
||
|
||
bool TConsegna_ordini::calcola_ncolli_tara_pnetto(const TString& codart, const real& qta,
|
||
real& ncolli, real& tara, real& pnetto) const
|
||
{
|
||
const TRectype& articolo = cache().get(LF_ANAMAG, codart);
|
||
const real ppcollo = articolo.get_real(ANAMAG_PPCOLLO);
|
||
|
||
if (ppcollo > ZERO)
|
||
{
|
||
ncolli = qta / ppcollo;
|
||
ncolli.ceil(0);
|
||
}
|
||
else
|
||
ncolli = ZERO;
|
||
|
||
tara = ncolli * articolo.get_real(ANAMAG_TARA);
|
||
pnetto = qta * articolo.get_real(ANAMAG_PESO);
|
||
|
||
return true;
|
||
}
|
||
|
||
bool TConsegna_ordini::aggiorna_ncolli_tara_pnetto(TRiga_documento& r) const
|
||
{
|
||
const TString& codart = r.get(RDOC_CODARTMAG);
|
||
bool ok = codart.full();
|
||
if (ok)
|
||
{
|
||
TArticolo& articolo = cached_article(codart);
|
||
const real qta = articolo.convert_to_um(r.quantita(), NULL, r.get(RDOC_UMQTA));
|
||
real ncolli, tara, pnetto;
|
||
ok = calcola_ncolli_tara_pnetto(codart, qta, ncolli, tara, pnetto);
|
||
if (ok)
|
||
{
|
||
r.put(RDOC_NCOLLI, ncolli);
|
||
r.put(RDOC_TARA, tara);
|
||
r.put(RDOC_PNETTO, pnetto);
|
||
}
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
bool TConsegna_ordini::genera_righe_riferimento(const TDocumento& indoc, TDocumento& outdoc, TSheet_field& s) const
|
||
{
|
||
// Determina ed eventualmente crea la riga di riferimento
|
||
const int riga_rif = riferimenti_in_testa() ? 1 : outdoc.physical_rows()+1;
|
||
if (riga_rif > outdoc.physical_rows())
|
||
{
|
||
TRiga_documento& rout = outdoc.new_row();
|
||
rout.forza_sola_descrizione();
|
||
}
|
||
|
||
TRiga_documento& rout = outdoc[riga_rif];
|
||
|
||
TString memo = rout.get(RDOC_DESCR);
|
||
if (rout.get_bool(RDOC_DESCLUNGA))
|
||
memo << rout.get(RDOC_DESCEST);
|
||
|
||
// Costruisce la stringa di riferimento
|
||
|
||
TString rifrow(indoc.tipo().descrizione());
|
||
TString rifext;
|
||
|
||
indoc.riferimento(rifext);
|
||
|
||
const int posrif = rifext.find("[RIF]");
|
||
|
||
if (rifext.full() && posrif < 0)
|
||
{
|
||
rifrow = rifext;
|
||
rifext.cut(0);
|
||
}
|
||
|
||
const TString4 numrif = num_riferimenti_in();
|
||
if (numrif.full())
|
||
{
|
||
TAssoc_array doc_rows;
|
||
TString riferimenti;
|
||
|
||
FOR_EACH_SHEET_ROW(s, n, row)
|
||
{
|
||
const int r = row->get_int(s.cid2index(S_NUMRIGA));
|
||
if (row->get_char(0) > ' ') // E' da consegnare?
|
||
{
|
||
const TRiga_documento& rin = indoc[r];
|
||
TString query("USE RDOC KEY 4");
|
||
TString select;
|
||
const char provv = rin.get_char(RDOC_PROVV);
|
||
const int anno = rin.get_int(RDOC_ANNO);
|
||
const TString4 codnum = rin.get(RDOC_CODNUM);
|
||
const long ndoc = rin.get_long(RDOC_NDOC);
|
||
const int idriga = rin.get_int(RDOC_IDRIGA);
|
||
|
||
query << "\nSELECT CODNUM=\"" << numrif << '\"';
|
||
select.format("DAPROVV=\"%c\" DAANNO=%d DACODNUM=\"%s\" DANDOC=%ld DAIDRIGA=%d", provv, anno, (const char *) codnum, ndoc, idriga);
|
||
query << "\nFROM " << select;
|
||
query << "\nTO " << select;
|
||
|
||
TISAM_recordset recset(query);
|
||
for (bool ok = recset.move_first(); ok; ok = recset.move_next())
|
||
{
|
||
const char provv = recset.get(RDOC_PROVV).as_string()[0];
|
||
const int anno = recset.get(RDOC_ANNO).as_int();
|
||
const TString4 codnum = recset.get(RDOC_CODNUM).as_string();
|
||
const long ndoc = recset.get(RDOC_NDOC).as_int();
|
||
TString doc_key; doc_key.format("%c|%d|%s|%ld", provv, anno, (const char *) codnum, ndoc);
|
||
if (!doc_rows.is_key(doc_key))
|
||
{
|
||
const TDocumento d(provv, anno, codnum, ndoc);
|
||
TString rif;
|
||
|
||
if (!d.empty())
|
||
{
|
||
d.riferimento(rif);
|
||
TString80 nrifin = d.get(DOC_NUMDOCRIF);
|
||
|
||
if (nrifin.blank())
|
||
nrifin = d.get(DOC_DOC1);
|
||
if (nrifin.blank())
|
||
nrifin = d.get(DOC_DOC2);
|
||
if (nrifin.blank())
|
||
nrifin = d.get(DOC_DOC3);
|
||
|
||
if (usa_doc_rif() && nrifin.full())
|
||
{
|
||
rif << " n. " << nrifin;
|
||
rif << " del " << d.get(DOC_DATADOCRIF);
|
||
}
|
||
else
|
||
{
|
||
rif << " n. " << d.numero();
|
||
rif << " del " << d.data().string();
|
||
}
|
||
if (riferimenti.full())
|
||
riferimenti << '\n';
|
||
riferimenti << rif; }
|
||
doc_rows.add(doc_key);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
memo.insert(riferimenti);
|
||
}
|
||
TString80 nrif = indoc.get(DOC_NUMDOCRIF);
|
||
|
||
if (nrif.blank())
|
||
nrif = indoc.get(DOC_DOC1);
|
||
if (nrif.blank())
|
||
nrif = indoc.get(DOC_DOC2);
|
||
if (nrif.blank())
|
||
nrif = indoc.get(DOC_DOC3);
|
||
if (usa_doc_rif() && nrif.full())
|
||
{
|
||
rifrow << " n. " << nrif;
|
||
rifrow << " del " << indoc.get(DOC_DATADOCRIF);
|
||
}
|
||
else
|
||
{
|
||
rifrow << " n. " << indoc.numero();
|
||
rifrow << " del " << indoc.data().string();
|
||
}
|
||
if (memo.full())
|
||
memo << '\n';
|
||
if (rifext.blank())
|
||
memo << rifrow;
|
||
else
|
||
{
|
||
if (posrif >= 0)
|
||
{
|
||
int i ;
|
||
|
||
for (i = 0; rifext[posrif + i + 5] != '\0'; i++)
|
||
rifext[posrif + i] = rifext[posrif + i + 5];
|
||
rifext[posrif + i] = '\0';
|
||
rifext.insert(rifrow, posrif);
|
||
}
|
||
memo << rifext;
|
||
}
|
||
rout.put(RDOC_DESCLUNGA, memo.len() > 50);
|
||
rout.put(RDOC_DESCR, memo.left(50));
|
||
rout.put(RDOC_DESCEST, memo.mid(50));
|
||
rout.put("RIFR", "X");
|
||
|
||
return true;
|
||
}
|
||
|
||
// Metodo virtuale per permettere elaborazioni NON interattive in classi derivate
|
||
bool TConsegna_ordini::run_consegna_mask(TMask& m)
|
||
{
|
||
return m.run() == K_ENTER;
|
||
}
|
||
|
||
bool TConsegna_ordini::elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
||
const TDate& data_elab, bool interattivo)
|
||
{
|
||
const int items_in = doc_in.items();
|
||
const int items_out = doc_out.items();
|
||
CHECK(items_in > 0, "Nessun documento da elaborare");
|
||
CHECK(items_out> 0, "Nessun documento da generare");
|
||
CHECK(items_in == 1 || items_out == 1 || items_out == items_in,
|
||
"Numero di documenti da elaborare 'strano'");
|
||
|
||
bool ok = false; // Ho elaborato almeno una riga?
|
||
const int header_code = intestazioni_sheet();
|
||
|
||
TConsegna_mask m(header_code, ordina_per_codice(), get_bool("B3"));
|
||
|
||
const int items_max = items_in > items_out ? items_in : items_out;
|
||
|
||
const TString& articolo = params().get("ARTICOLO");
|
||
const bool multi_evasion = interattivo && articolo.full() && !real::is_null(params().get("QUANTITA"));
|
||
|
||
pre_process_input(doc_in);
|
||
|
||
for (int d = 0; d < items_max; d++)
|
||
{
|
||
TDocumento& indoc = doc_in[d < items_in ? d : 0];
|
||
TDocumento& outdoc = doc_out[d < items_out ? d : 0];
|
||
m.doc2mask(indoc, outdoc, articolo);
|
||
if (multi_evasion)
|
||
{
|
||
const TString& um = params().get("UM");
|
||
m.show(F_UMQTA);
|
||
m.set(F_UMQTA, um);
|
||
|
||
int dec = 5;
|
||
TReal_field& fld_qta = (TReal_field&)m.efield(F_QTA);
|
||
const TRectype& rum = cache().get("%UMS", um);
|
||
if (!rum.empty() && rum.get_bool("B0"))
|
||
dec = rum.get_int("I0");
|
||
fld_qta.set_decimals(dec);
|
||
|
||
fld_qta.show();
|
||
fld_qta.set(params().get("QUANTITA"));
|
||
}
|
||
else
|
||
{
|
||
m.hide(F_UMQTA);
|
||
m.hide(F_QTA);
|
||
}
|
||
|
||
//if (m.run() != K_ENTER) break;
|
||
if (!run_consegna_mask(m))
|
||
break;
|
||
|
||
TSheet_field& s = m.sfield(F_ROWS);
|
||
bool one_checked = false;
|
||
if (!s.empty())
|
||
{
|
||
FOR_EACH_SHEET_ROW(s, n, row)
|
||
{
|
||
one_checked = row->get_char(0) > ' '; // E' da consegnare?
|
||
if (one_checked)
|
||
break;
|
||
}
|
||
}
|
||
if (!one_checked)
|
||
continue;
|
||
|
||
// Genera riferimenti solo se c'e' almeno una riga spuntata
|
||
if (gestione_riferimenti())
|
||
genera_righe_riferimento(indoc, outdoc, s);
|
||
|
||
TToken_string campi_riga(80);
|
||
const bool ragg_rig = raggruppa_righe();
|
||
|
||
if (ragg_rig)
|
||
{
|
||
campi_riga = "CODART|LIVELLO|UMQTA"; // Uguali sempre
|
||
// Uguali opzionalmente
|
||
if (riga_uguale(0)) campi_riga.add("CODMAG");
|
||
if (riga_uguale(1)) campi_riga.add("CODIVA");
|
||
if (riga_uguale(2)) campi_riga.add("PREZZO|SCONTO");
|
||
}
|
||
|
||
const bool evadi = outdoc.tipo().da_evadere();
|
||
TAssoc_array scarti;
|
||
|
||
FOR_EACH_SHEET_ROW(s, n, row)
|
||
{
|
||
const int r = row->get_int(s.cid2index(S_NUMRIGA));
|
||
TRiga_documento& inrec = indoc[r];
|
||
if (row->get_char(0) > ' ') // E' da consegnare?
|
||
{
|
||
const real daeva = row->get(S_QTADAEVADERE - FIRST_FIELD);
|
||
const bool eva = row->get_char(S_RIGAEVASA - FIRST_FIELD) > ' ';
|
||
if (evadi && (daeva > ZERO || eva))
|
||
{
|
||
ok = true; // Ho evaso almeno una riga!
|
||
const char* fqe = inrec.field_qtaevasa();
|
||
inrec.add(fqe, daeva); // nuovo modo di incrementare
|
||
inrec.put(RDOC_RIGAEVASA, eva ? "X" : "");
|
||
|
||
if (eva && calcola_scarti())
|
||
{
|
||
real scarto = inrec.quantita() - inrec.qtaevasa();
|
||
if (scarto > ZERO)
|
||
{
|
||
const TString& articolo = inrec.get(RDOC_CODARTMAG);
|
||
if (articolo.full())
|
||
{
|
||
TToken_string* ska = (TToken_string*)scarti.objptr(articolo);
|
||
if (ska == NULL)
|
||
{
|
||
ska = new TToken_string(inrec.get(RDOC_UMQTA));
|
||
ska->add(scarto.string(), 1);
|
||
scarti.add(articolo, ska);
|
||
}
|
||
else
|
||
{
|
||
scarto = inrec.articolo().convert_to_um(scarto, inrec.get(RDOC_UMQTA), ska->get(0));
|
||
real s = ska->get(1); s += scarto;
|
||
ska->add(s.string(), 1);
|
||
}
|
||
ska->add(r, 2);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (multi_evasion)
|
||
{
|
||
const TString4 um = inrec.get(RDOC_UMQTA);
|
||
const real qta = inrec.articolo().convert_to_um(daeva, params().get("UM"), um);
|
||
params().set("QUANTITA", params().get_real("QUANTITA") - qta);
|
||
}
|
||
|
||
bool elaborata = false;
|
||
if (ragg_rig)
|
||
{
|
||
for (int i = 1; i <= outdoc.physical_rows(); i++)
|
||
{
|
||
TRiga_documento& outrec = outdoc[i];
|
||
if (outrec.sola_descrizione()) // Ignora le righe descrittive
|
||
continue;
|
||
if (inrec.raggruppabile(outrec, campi_riga)) // Se esiste una riga compatibile ...
|
||
{
|
||
if (!daeva.is_zero())
|
||
{
|
||
const TString& qta_field = outrec.field_qta();
|
||
outrec.add(qta_field, daeva); // nuovo modo di incrementare
|
||
|
||
real ncolli, tara, pnetto;
|
||
calcola_ncolli_tara_pnetto(outrec.get(RDOC_CODARTMAG), daeva, ncolli, tara, pnetto);
|
||
outrec.add(RDOC_NCOLLI, ncolli);
|
||
outrec.add(RDOC_TARA, tara);
|
||
outrec.add(RDOC_PNETTO, pnetto);
|
||
|
||
outrec.dirty_fields(); // Forza ricalcolo formule
|
||
}
|
||
elaborata = true; // Ricorda di averla gia' elaborata
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (!elaborata) // Se la riga non e' stata gia' sommata ...
|
||
{
|
||
int j = outdoc.physical_rows();
|
||
|
||
if (raggruppa_per_riferimento())
|
||
{
|
||
TToken_string key = inrec.get_rdoc_key();
|
||
|
||
key.add("",4);
|
||
for (; j >= 1; j--)
|
||
{
|
||
TToken_string keyrow = outdoc[j].get_original_rdoc_key();
|
||
keyrow.add("",4);
|
||
|
||
if (key == keyrow)
|
||
break;
|
||
}
|
||
}
|
||
const TString4 tiporiga = inrec.get(RDOC_TIPORIGA);
|
||
TRiga_documento& outrec = j < 1 || j >= outdoc.physical_rows() ? outdoc.new_row(tiporiga) : outdoc.insert_row(j + 1, tiporiga);
|
||
const TString& qta_field_orig = inrec.field_qta();
|
||
const TString& qta_field = outrec.field_qta();
|
||
const TString& qtaevasa_field = inrec.field_qtaevasa();
|
||
|
||
TDocumento::copy_data(outrec, inrec);
|
||
if (qta_field_orig != RDOC_QTA)
|
||
{
|
||
outrec.put(RDOC_QTA, UNO);
|
||
outrec.put(qta_field_orig, daeva);
|
||
}
|
||
else
|
||
{
|
||
outrec.put(qta_field, daeva);
|
||
if (qta_field != RDOC_QTA)
|
||
outrec.put(RDOC_QTA, UNO);
|
||
}
|
||
aggiorna_ncolli_tara_pnetto(outrec);
|
||
if (kill_descrizione_estesa() && outrec.tipo().tipo() != RIGA_DESCRIZIONI) // Cancello eventualmente la descrizione estesa
|
||
{
|
||
outrec.zero(RDOC_DESCLUNGA);
|
||
outrec.zero(RDOC_DESCEST);
|
||
}
|
||
|
||
outrec.dirty_fields(); // Forza ricalcolo peso etc.
|
||
outrec.zero(qtaevasa_field); // Azzera quantita' evasa erroneamente copiata dall'ordine
|
||
outrec.zero(RDOC_RIGAEVASA); // Azzera flag di evasa erroneamente copiata dall'ordine
|
||
outrec.set_original_rdoc_key(inrec);
|
||
if (reload_prices())
|
||
{
|
||
outrec.zero(RDOC_CHECKED);
|
||
|
||
const TString& codiva = outdoc.codesiva();
|
||
if (codiva.full())
|
||
outrec.put(RDOC_CODIVA, codiva);
|
||
|
||
const TString& codart = outrec.get(RDOC_CODARTMAG);
|
||
if (codart.full() && reload_descriptions())
|
||
{
|
||
const TRectype& anamag = cache().get(LF_ANAMAG, codart);
|
||
outrec.put(RDOC_DESCR, anamag.get(ANAMAG_DESCR));
|
||
|
||
// Euroforesi 12/01/2012 richiede anche descrizione aggiuntiva
|
||
const TString& agg = anamag.get(ANAMAG_DESCRAGG);
|
||
if (agg.full())
|
||
{
|
||
outrec.put(RDOC_DESCLUNGA, true);
|
||
outrec.put(RDOC_DESCEST, agg);
|
||
}
|
||
else
|
||
{
|
||
outrec.zero(RDOC_DESCLUNGA);
|
||
outrec.zero(RDOC_DESCEST);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (prezzo_da_ordine())
|
||
{
|
||
//const bool doc_al_lordo = outdoc.tipo().calcolo_lordo();
|
||
const TString80 codart = outrec.get(RDOC_CODARTMAG);
|
||
const TRectype& anamag = cache().get(LF_ANAMAG, codart);
|
||
|
||
if (!anamag.empty())
|
||
{
|
||
const TFixed_string field_prezzo = outdoc.tipo().field_prezzo();
|
||
if (field_prezzo.full())
|
||
outrec.put(RDOC_PREZZO, anamag.get_real(field_prezzo));
|
||
else
|
||
{
|
||
const TString4 um = outrec.get(RDOC_UMQTA);
|
||
if (um.full())
|
||
{
|
||
TLocalisamfile umart(LF_UMART);
|
||
umart.setkey(2);
|
||
umart.put(UMART_CODART, codart);
|
||
umart.put(UMART_UM, um);
|
||
if (umart.read() == NOERR)
|
||
outrec.put(RDOC_PREZZO, umart.get_real(UMART_PREZZO));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
TDate dc = outrec.get(RDOC_DATACONS); // Controllo che sia sempre piena la data di consegna,
|
||
if (!dc.ok()) // che potrebbe venire da righe che non ce l'hanno perch<63> uguale alla testata!
|
||
{
|
||
dc = row->get(S_DATACONS - FIRST_FIELD);
|
||
outrec.put(RDOC_DATACONS, dc);
|
||
}
|
||
|
||
const int last_row = outdoc.physical_rows();
|
||
if (j > 0 && last_row > 0 && gestione_riferimenti())
|
||
{
|
||
const TRiga_documento& last_rdoc = outdoc[last_row];
|
||
if (last_rdoc.is_descrizione() && last_rdoc.get("RIFR").full())
|
||
outdoc.destroy_row(last_row, true);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Inserisce le eventuali righe di scarto al posto giusto
|
||
FOR_EACH_ASSOC_OBJECT(scarti, h, codart, obj)
|
||
{
|
||
TString4 tiporiga = "01"; // Riga merce standard
|
||
int i = 0;
|
||
// Cerca l'ultima riga del documento avente lo stesso articolo dello scarto
|
||
for (i = outdoc.physical_rows(); i > 0; i--)
|
||
{
|
||
const TRiga_documento& or = outdoc[i];
|
||
if (or.get(RDOC_CODARTMAG) == codart && or.is_articolo())
|
||
{
|
||
tiporiga = or.get(RDOC_TIPORIGA); // Memorizza tipo riga preferito dall'utente
|
||
break;
|
||
}
|
||
}
|
||
// Crea una nuova riga merce senza articolo e con sola descrizione, qta ed um
|
||
TRiga_documento& outrec = outdoc.insert_row(i+1, tiporiga);
|
||
TString descr; descr << TR("Scarto ") << codart;
|
||
outrec.put(RDOC_DESCR, descr);
|
||
TToken_string& ska = *(TToken_string*)obj;
|
||
outrec.put(RDOC_UMQTA, ska.get(0));
|
||
outrec.put(RDOC_QTA, ska.get());
|
||
const TRiga_documento & inrec = indoc[ska.get_int()];
|
||
outrec.set_original_rdoc_key(inrec);
|
||
}
|
||
|
||
if (reload_prices())
|
||
{
|
||
TDocumento_mask * m = new TDocumento_mask(outdoc.get(DOC_TIPODOC));
|
||
|
||
m->doc() = outdoc;
|
||
m->doc2mask();
|
||
m->mask2doc();
|
||
outdoc = m->doc();
|
||
delete m;
|
||
}
|
||
|
||
if (nettifica())
|
||
{
|
||
FOR_EACH_PHYSICAL_RDOC_BACK(indoc, i, rdoc)
|
||
{
|
||
TRiga_documento& inrec = *rdoc;
|
||
if (inrec.is_evasa())
|
||
indoc.destroy_row(i, true);
|
||
else
|
||
{
|
||
const real evaso = inrec.qtaevasa();
|
||
const char* fq = inrec.field_qta();
|
||
const char* fqe = inrec.field_qtaevasa();
|
||
inrec.add(fq, -evaso); // nuovo modo di incrementare
|
||
inrec.zero(fqe);
|
||
}
|
||
}
|
||
}
|
||
if (indoc.is_evaso())
|
||
indoc.stato(stato_finale_doc_iniziale()[0]);
|
||
}
|
||
|
||
if (ok) // Ho elaborato almeno una riga?
|
||
{
|
||
post_process_input(doc_in);
|
||
post_process(doc_out, doc_in);
|
||
}
|
||
|
||
return ok;
|
||
}
|