root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ve/velib04d.cpp
guy 1fd0a23742 Patch level : 2.0 592 
Files correlati     : ve0.exe ve6.exe
Ricompilazione Demo : [ ]
Commento            :

AO20097
In fase di bollettazione voglio evadere un ordine già evaso parzialmente,
se premo su "Consegna tutte le righe" nella bolla generata mi riporta anche
le righe già evase lasciandole tutte con quantità nulla.

GF20100
L'evasione di un ordine con riga merce con qtà a blank non riporta alcuna
riga evasa nel d.d.t.


git-svn-id: svn://10.65.10.50/trunk@11473 c028cbd2-c16b-5b4b-a496-9718f37d4682
2003-10-07 15:27:57 +00:00

431 lines
13 KiB
C++
Executable File
Raw Blame History

#include <automask.h>
#include "velib.h"
#include "velib04d.h"
#include <doc.h>
#include <rdoc.h>
///////////////////////////////////////////////////////////
// TConsegna ordini mask
///////////////////////////////////////////////////////////
class TConsegna_mask : public TAutomask
{
bool _ordina_per_codice;
const TDocumento* _doc;
protected:
virtual bool on_field_event(class TOperable_field& f, TField_event e, long jolly);
public:
void doc2mask(const TDocumento& doc, const TString & articolo);
TConsegna_mask(int header_code = 0, bool per_codice = FALSE);
virtual ~TConsegna_mask() { }
};
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(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 == 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 == ZERO && residuo == ZERO)
{
const int nriga = row->get_int(S_NUMRIGA-FIRST_FIELD);
const TRiga_documento& rdoc = (*_doc)[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;
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;
}
rows_sort_func(TSheet_field & s, int i, int j)
{
TToken_string & s1 = (TToken_string & )(s.row(i));
TToken_string & s2 = (TToken_string & )(s.row(j));
TString ss1, ss2;
TDate dd1, dd2;
real rr1, rr2;
int fields[] = {S_CODART, S_LIVGIAC1, S_LIVGIAC2, S_LIVGIAC3, S_LIVGIAC4,
S_CODMAG, S_CODDEP, S_RIGAEVASA, S_DATACONS, S_QTARESIDUA, -1};
int ret(0), field(0);
while (fields[field] >= 0)
{
if (fields[field] == S_QTARESIDUA)
{
s1.get(fields[field]-FIRST_FIELD, rr1);
s2.get(fields[field]-FIRST_FIELD, rr2);
ret = rr2 < rr1 ? -1 : (rr2 > rr1 ? 1 : 0);
}
else
{
s1.get(fields[field]-FIRST_FIELD ,ss1);
s2.get(fields[field]-FIRST_FIELD ,ss2);
if (fields[field] == S_DATACONS)
{
dd1 = ss1;
dd2 = ss2;
ret = int (dd1.date2ansi() - dd2.date2ansi());
}
else
ret = ss1.compare(ss2);
}
if (ret != 0)
break;
field++;
}
return ret;
}
void TConsegna_mask::doc2mask(const TDocumento& doc, const TString & articolo)
{
TWait_cursor hourglass;
_doc = &doc;
for (int n = fields()-1; n >= 0; n--)
{
TMask_field& f = fld(n);
const TFieldref* fr = f.field();
if (fr)
{
const TString& val = doc.get(fr->name());
f.set(val);
}
}
const bool show_evaded = doc.tipo().mostra_righe_evase_in_elaborazione();
TSheet_field& s = sfield(F_ROWS);
s.destroy();
const int rows = doc.physical_rows();
for (int i = 0; i < rows; i++)
{
const TRiga_documento& rec = doc[i+1];
const real residuo = rec.qtaresidua();
const bool evasa = residuo.is_zero();
if ((show_evaded || !evasa) && (articolo.empty() || articolo == rec.get(RDOC_CODART)))
{
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(i, -1); // Disbilita tutta la riga ...
s.enable_cell(i, 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 (rec.get_date(RDOC_DATACONS).ok())
r.add(rec.get_date(RDOC_DATACONS));
else
r.add(doc.get_date(DOC_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));
}
}
if (_ordina_per_codice)
s.sort(rows_sort_func);
}
TConsegna_mask::TConsegna_mask(int header_code, bool per_codice)
: TAutomask("velib04d") , _ordina_per_codice(per_codice), _doc(NULL)
{
TCodgiac_livelli cl;
TSheet_field& s = sfield(F_ROWS);
cl.set_sheet_columns(s, S_LIVGIAC1);
if (header_code == 1)
{
TString h;
h = "Quantita'\nconsegnata";
s.set_column_header(S_QTARESIDUA, h);
s.sheet_mask().field(S_QTARESIDUA).set_prompt("Q.ta' consegnata");
h = "Quantita'\nda fatturare";
s.set_column_header(S_QTADAEVADERE, h);
s.sheet_mask().field(S_QTADAEVADERE).set_prompt("Q.ta' da fatturare");
}
else
if (header_code == 2)
{
TString h;
h = "Residuo";
s.set_column_header(S_QTARESIDUA, h);
s.sheet_mask().field(S_QTARESIDUA).set_prompt("Residuo ");
h = "Da evadere";
s.set_column_header(S_QTADAEVADERE, h);
s.sheet_mask().field(S_QTADAEVADERE).set_prompt("Da evadere ");
}
}
///////////////////////////////////////////////////////////
// TConsegna ordini
///////////////////////////////////////////////////////////
TConsegna_ordini::TConsegna_ordini(const char* cod)
: TElaborazione(cod)
{
}
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 = TRUE;
const int header_code = intestazioni_sheet();
TConsegna_mask m(header_code, ordina_per_codice());
const int items_max = items_in > items_out ? items_in : items_out;
for (int d = 0; d < items_max && ok; d++)
{
TDocumento& indoc = doc_in[d < items_in ? d : 0];
TDocumento& outdoc = doc_out[d < items_out ? d : 0];
const TString& articolo = params().get("ARTICOLO");
m.doc2mask(indoc, articolo);
TArticolo art;
if (articolo.not_empty())
{
art.read(articolo);
params().set("QUANTITA", ZERO);
}
ok = m.run() == K_ENTER;
if (ok)
{
if (gestione_riferimenti())
{
// 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];
// Costruisce la stringa di riferimento
TString riferimento;
indoc.riferimento(riferimento);
if (riferimento.empty())
riferimento = indoc.tipo().descrizione();
if (usa_doc_rif() && indoc.get(DOC_NUMDOCRIF).not_empty())
{
riferimento << " n. " << indoc.get(DOC_NUMDOCRIF);
riferimento << " del " << indoc.get(DOC_DATADOCRIF);
}
else
{
riferimento << " n. " << indoc.numero();
riferimento << " del " << indoc.data().string();
}
// Setta la descrizione se vuota
if (rout.get("DESCR").empty())
rout.put("DESCR", riferimento);
else
{
// Altrimenti aggiungi il riferimento al memo
TString memo(1024);
memo = rout.get("DESCEST");
if (memo.empty())
{
TString80 rif(rout.get("DESCR"));
rif << '\n';
rout.put("DESCR", rif);
rout.put("DESCLUNGA", "X");
}
else
memo << '\n';
memo << riferimento;
rout.put("DESCEST", memo);
}
}
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");
}
TSheet_field& s = m.sfield(F_ROWS);
int r = 0;
FOR_EACH_SHEET_ROW(s, n, row)
{
r = row->get_int(S_NUMRIGA - FIRST_FIELD);
if (*row->get(0) > ' ') // E' da consegnare?
{
TRiga_documento& inrec = indoc[r];
const real daeva = row->get(S_QTADAEVADERE - FIRST_FIELD);
if (daeva > ZERO || row->get_char(S_RIGAEVASA-FIRST_FIELD) > ' ')
{
const char* fqe = inrec.field_qtaevasa();
const real qtaevasa = inrec.get_real(fqe) + daeva;
inrec.put(fqe, qtaevasa);
inrec.put(RDOC_RIGAEVASA, row->get(S_RIGAEVASA - FIRST_FIELD));
}
if (articolo.not_empty())
{
const TString16 um(inrec.get(RDOC_UMQTA));
const real qta = art.convert_to_um(daeva, params().get("UM"), um);
params().set("QUANTITA", qta + params().get_real("QUANTITA"));
}
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 ...
{
const TString& qta_field = outrec.field_qta();
const real qta = outrec.get_real(qta_field) + daeva;
outrec.put(qta_field, qta);
if (qta_field != RDOC_QTA)
outrec.put(RDOC_QTA, UNO); // Pezza temporanea
outrec.dirty_fields(); // Forza ricalcolo peso etc.
elaborata = TRUE; // Ricorda di averla gia' elaborata
break;
}
}
}
if (!elaborata) // Se la riga non e' stata gia' sommata ...
{
const TString16 tiporiga = inrec.get(RDOC_TIPORIGA);
TRiga_documento & outrec = outdoc.new_row(tiporiga);
const TString& qta_field = outrec.field_qta();
TDocumento::copy_data(outrec, inrec);
outrec.put(qta_field, daeva);
if (qta_field != RDOC_QTA)
{
const real q = inrec.get(RDOC_QTA);
if (q.is_zero())
outrec.put(RDOC_QTA, UNO); // Pezza temporanea
}
outrec.dirty_fields(); // Forza ricalcolo peso etc.
outrec.zero(RDOC_QTAEVASA);
outrec.zero(RDOC_RIGAEVASA);
outrec.set_original_rdoc_key(inrec);
}
}
}
}
if (indoc.is_evaso())
{
indoc.stato(stato_finale_doc_iniziale()[0]);
}
}
return ok;
}
Reference in New Issue View Git Blame Copy Permalink