campo-sirio/ve/velib04.cpp
alex cd80466f09 Patch level : 3.0 nopatch
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :

Documentazione modulo vendita al dettaglio


git-svn-id: svn://10.65.10.50/trunk@14149 c028cbd2-c16b-5b4b-a496-9718f37d4682
2006-07-11 13:12:41 +00:00

348 lines
9.3 KiB
C++
Executable File

#include <execp.h>
#include "velib04.h"
///////////////////////////////////////////////////////////
// Lista di documenti
///////////////////////////////////////////////////////////
TDate TLista_documenti::num2date(char provv, int anno, const char* codnum, long num) const
{
TLocalisamfile doc(LF_DOC);
CHECK(num > 0, "Numero documento nullo.");
TDocumento::set_key(doc.curr(), provv, anno, codnum, num);
if (doc.read(_isgteq) != NOERR) // In caso d'errore ...
doc.last(); // prendi l'ultimo
return doc.get_date(DOC_DATADOC);
}
bool TLista_documenti::find(char provv, int anno, const char * codnum, long ndoc) const
{
bool found = false;
if (ndoc > 0)
{
const int it = items();
for (int i = 0; !found && i < it; i++)
{
const TDocumento & d = doc(i);
found = ((d.head().get_long(DOC_NDOC) == ndoc) &&
(d.head().get_char(DOC_PROVV) == provv) &&
(d.head().get_int(DOC_ANNO) == anno) &&
(d.head().get(DOC_CODNUM) == codnum));
}
}
return found;
}
int TLista_documenti::read(char provv, char tipocf, long clifo, int anno,
TToken_string& tipidoc, TToken_string& statidoc,
const TDate& dd, const TDate& ad,
const char* codnum, long dn, long an)
{
CHECK(provv == 'D' || provv == 'P', "Provvisorio o Definitivo?");
CHECK(tipocf == 'C' || tipocf == 'F', "Il tipo deve essere Cliente o Fornitore");
CHECKD(clifo > 0L, "Codice cliente non valido", clifo);
CHECKD(anno > 1900, "Anno non valido: ", anno);
CHECK(!tipidoc.empty_items(), "Lista dei tipi documento vuota");
CHECK(!statidoc.empty_items(), "Lista degli stati documento vuota");
TRelation doc(LF_DOC);
TRectype start(LF_DOC), stop(LF_DOC);
int anno_start, anno_stop;
start.put(DOC_TIPOCF, tipocf);
stop.put(DOC_TIPOCF, tipocf);
start.put(DOC_CODCF, clifo);
stop.put(DOC_CODCF, clifo);
start.put(DOC_PROVV, provv);
stop.put(DOC_PROVV, provv);
anno_start = anno_stop = anno;
if (dd.ok())
{
anno_start = dd.year();
start.put(DOC_ANNO, anno_start);
}
if (ad.ok())
{
anno_stop = ad.year();
stop.put(DOC_ANNO, anno_stop);
}
if (dn > 0)
{
const TDate d(num2date(provv, anno_start, codnum, dn));
start.put(DOC_DATADOC, d);
start.put(DOC_ANNO, d.year());
start.put(DOC_NDOC, dn);
}
else
{
if (dd.ok() && dd > botime)
start.put(DOC_DATADOC, dd);
if (anno_start <= anno_stop)
start.put(DOC_ANNO, anno_start);
}
if (an > 0)
{
const TDate d(num2date(provv, anno_stop, codnum, an));
stop.put(DOC_DATADOC, d);
stop.put(DOC_ANNO, d.year());
stop.put(DOC_NDOC, an);
}
else
{
if (ad.ok() && ad < eotime)
stop.put(DOC_DATADOC, ad);
stop.put(DOC_ANNO, anno_stop);
}
TString filter(16);
if (codnum && *codnum)
{
bool numfilter = FALSE;
if (start.get(DOC_DATADOC).empty())
numfilter = TRUE;
else
start.put(DOC_CODNUM, codnum);
if (stop.get(DOC_DATADOC).empty())
numfilter = TRUE;
else
stop.put(DOC_CODNUM, codnum);
if (numfilter)
filter << "CODNUM=\"" << codnum << '"';
}
TCursor cur(&doc, filter, 2, &start, &stop);
const TRectype& head = cur.curr();
_documenti.destroy();
for (cur = 0; cur.ok(); ++cur)
{
const TString4 tipodoc = head.get(DOC_TIPODOC);
const TString4 statodoc = head.get(DOC_STATO);
bool match = FALSE;
for (int i = tipidoc.items()-1; i>=0; i--)
{
if (tipodoc == tipidoc.get(i))
if (statodoc == statidoc.get(i))
{
match = TRUE;
break;
}
}
if (match)
{
TDocumento* d = new TDocumento(head);
_documenti.add(d);
}
}
return _documenti.items();
}
int TLista_documenti::write(bool re) const
{
int err = NOERR;
for (int i = 0; i < _documenti.items() && err == NOERR; i++)
{
err = doc(i).write(re);
((TDocumento&)doc(i)).flush_rows();
}
return err;
}
///////////////////////////////////////////////////////////
// TParametri_elaborazione
///////////////////////////////////////////////////////////
void TParametri_elaborazione::set(const char * name, const char * val)
{
_par.add(name, new TString(val), TRUE);
}
const TString & TParametri_elaborazione::get(const char * name) const
{
TObject *val = _par.objptr(name);
if (val == NULL)
return EMPTY_STRING;
else
return (const TString &) *val;
}
///////////////////////////////////////////////////////////
// TElaborazione
///////////////////////////////////////////////////////////
TElaborazione::TElaborazione(const char* cod) : TRectype(LF_TABCOM)
{
settab("ELD");
if (cod && *cod)
read(cod);
}
int TElaborazione::read(const char* cod)
{
int err = NOERR;
*this = cache().get("%ELD", cod);
if (empty())
{
yesnofatal_box("Codice elaborazione non valido: %s", cod);
err = _iskeynotfound;
}
return err;
}
///////////////////////////////////////////////////////////
// TElaborazione_esterna
///////////////////////////////////////////////////////////
TElaborazione_esterna::TElaborazione_esterna(const char* cod)
: TElaborazione(cod)
{
}
bool TElaborazione_esterna::elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
const TDate& data_elab, bool interattivo)
{
if (applicazione_esterna().blank())
error_box("Non e' stato specificato il nome del'applicazione esterna");
CHECK(doc_in.items() == 1, "Si deve specificare uno e un solo documento in entrata");
CHECK(doc_out.items() == 1, "Si deve specificare uno e un solo documento in uscita");
TFilename name; name.temp("ext");
TDocumento& d = doc_in[0];
const int doc_fields = d.items();
TString16 par;
{
TConfig c(name, "Transaction");
c.set("Action", codice());
c.set("ProvvOut", doc_out[0].get(DOC_PROVV));
c.set("AnnoOut", doc_out[0].get(DOC_ANNO));
c.set("CodNumOut", doc_out[0].get(DOC_CODNUM));
c.set("NDocOut", doc_out[0].get(DOC_NDOC));
par.format("%d", LF_DOC);
for (int i = 0; i < doc_fields; i++)
{
const TString16 fname(d.fieldname(i));
TFieldref f(fname, LF_DOC);
f.write(c, par, d.get(fname));
}
for (TVariable_field * v = d.first_variable_field(); v ; v = d.succ_variable_field())
c.set(v->name(), v->get(), par);
const int rows = d.physical_rows();
if (rows > 0)
{
const int row_fields = d[1].items();
for (int r = 1; r <= rows; r++)
{
TRiga_documento row = d[r];
par.format("%d,%d", LF_RIGHEDOC, r);
for (int i = 0; i < row_fields; i++)
{
const TString16 fname(row.fieldname(i));
TFieldref f(fname, LF_RIGHEDOC);
f.write(c, par, row.get(fname));
}
}
}
}
TString command_line(applicazione_esterna()); command_line << " /i" << name;
TExternal_app app(command_line);
if (app.run() == 0)
{
TConfig c(name, "Main");
const TString & res = c.get("Result");
if (res == "SUCCESS")
{
par.format("%d", LF_DOC);
for (int i = 0; i < doc_fields; i++)
{
const TString16 fname(d.fieldname(i));
TFieldref f(fname, LF_DOC);
d.put(fname, f.read(c, par));
}
for (TVariable_field * v = d.first_variable_field(); v ; v = d.succ_variable_field())
v->put(c.get(v->name(), par));
TString_array p;
c.list_paragraphs(p);
d.destroy_rows();
int r = 1 ;
par.format("%d,%d", LF_RIGHEDOC, r);
while (p.find(par) >= 0)
{
const TString& tiporiga = c.get(RDOC_TIPORIGA, par);
TRiga_documento& row = d.new_row(tiporiga);
for (int i = row.items()-1; i >= 0; i--)
{
const TString16 fname(row.fieldname(i));
TFieldref f(fname, LF_RIGHEDOC);
const TString& val = f.read(c, par);
if (val.not_empty())
row.put(fname, val);
}
r++;
par.format("%d,%d", LF_RIGHEDOC, r);
}
return true;
}
else
if (res == "OUTDOC")
{
doc_out[0].read();
return true;
}
}
return false;
}
///////////////////////////////////////////////////////////
// TCopia_documento
///////////////////////////////////////////////////////////
TCopia_documento::TCopia_documento(const char* cod)
: TElaborazione(cod)
{
}
bool TCopia_documento::elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
const TDate& data_elab, bool interattivo)
{
CHECK(doc_in.items() == doc_out.items(), "Si deve specificare un numero uguale di documenti in entrata ed in uscita");
for (int d = 0; d < doc_in.items(); d++)
{
TDocumento& doc_src = doc_in[d];
TDocumento& doc_dest = doc_out[d];
doc_dest.copy_contents(doc_src, false);
doc_dest.put(DOC_DATADOC, data_elab);
}
return TRUE;
}