282 lines
9.3 KiB
C++
Executable File
282 lines
9.3 KiB
C++
Executable File
#include "velib.h"
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TFatturazione bolle
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TFatturazione_bolle::TFatturazione_bolle(const char* cod)
|
|
: TElaborazione(cod)
|
|
{
|
|
}
|
|
|
|
void TFatturazione_bolle::tipi_validi(TToken_string& tipi) const
|
|
{
|
|
tipi.cut(0);
|
|
TString16 t;
|
|
for (int i = 0; i < TElaborazione::_max_tipi_doc_elab; i++)
|
|
{
|
|
t = tipo_iniziale(i);
|
|
if (t.not_empty())
|
|
tipi.add(t);
|
|
}
|
|
CHECK(!tipi.empty_items(), "Nessun tipo documento valido");
|
|
}
|
|
|
|
void TFatturazione_bolle::stati_validi(TToken_string& stati) const
|
|
{
|
|
stati.cut(0);
|
|
for (int i = 0; i < TElaborazione::_max_tipi_doc_elab; i++)
|
|
{
|
|
const char s = stato_iniziale(i);
|
|
if (s != '\0')
|
|
stati.add(s);
|
|
}
|
|
CHECK(!stati.empty_items(), "Nessuno stato documento valido");
|
|
}
|
|
|
|
|
|
bool TFatturazione_bolle::raggruppa(TDocumento& doc_in, TDocumento& doc_out)
|
|
{
|
|
#ifdef DBG
|
|
const TString16 tipodoc = doc_in.tipo().codice();
|
|
int i;
|
|
|
|
for (i = 0; i < TElaborazione::_max_tipi_doc_elab; i++)
|
|
{
|
|
if (tipodoc == tipo_iniziale(i))
|
|
break;
|
|
}
|
|
if (i >= TElaborazione::_max_tipi_doc_elab)
|
|
{
|
|
NFCHECK("Tipo documento non valido: '%s'", (const char*)tipodoc);
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
|
|
const char stato_finale_in = get_char("S4");
|
|
doc_in.stato(stato_finale_in);
|
|
|
|
const char stato_finale_out = get_char("S9");
|
|
doc_out.stato(stato_finale_out);
|
|
|
|
if (gestione_riferimenti())
|
|
{
|
|
// Determina ed eventualmente crea la riga di riferimento
|
|
const int riga_rif = riferimenti_in_testa() ? 1 : doc_out.physical_rows()+1;
|
|
if (riga_rif > doc_out.physical_rows())
|
|
{
|
|
TRiga_documento& rout = doc_out.new_row();
|
|
rout.forza_sola_descrizione();
|
|
}
|
|
|
|
TRiga_documento& rout = doc_out[riga_rif];
|
|
|
|
// Costruisce la stringa di riferimento
|
|
TString riferimento;
|
|
doc_in.riferimento(riferimento);
|
|
if (riferimento.empty())
|
|
riferimento = doc_in.tipo().descrizione();
|
|
if (usa_doc_rif() && doc_in.get(DOC_NUMDOCRIF).not_empty())
|
|
{
|
|
riferimento << " n. " << doc_in.get(DOC_NUMDOCRIF);
|
|
riferimento << " del " << doc_in.get(DOC_DATADOCRIF);
|
|
}
|
|
else
|
|
{
|
|
riferimento << " n. " << doc_in.numero();
|
|
riferimento << " del " << doc_in.data().string();
|
|
}
|
|
|
|
// Setta la descrizione se vuota
|
|
if (rout.get(RDOC_DESCR).empty())
|
|
rout.put(RDOC_DESCR, riferimento);
|
|
else
|
|
{
|
|
// Altrimenti aggiungi il riferimento al memo
|
|
TString memo(1024);
|
|
memo = rout.get(RDOC_DESCEST);
|
|
if (memo.empty())
|
|
{
|
|
TString80 rif(rout.get(RDOC_DESCR));
|
|
rif << '\n';
|
|
rout.put(RDOC_DESCR, rif);
|
|
rout.put(RDOC_DESCLUNGA, "X");
|
|
}
|
|
else
|
|
memo << '\n';
|
|
memo << riferimento;
|
|
rout.put(RDOC_DESCEST, memo);
|
|
}
|
|
}
|
|
|
|
const bool ignora_desc = ignora_descrizioni();
|
|
|
|
TToken_string campi_riga(80);
|
|
const bool ragg_rig = raggruppa_righe();
|
|
if (ragg_rig)
|
|
{
|
|
campi_riga = "CODART|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");
|
|
}
|
|
|
|
TRiga_documento tmp(&doc_in);
|
|
for (int r = 1; r <= doc_in.physical_rows(); r++)
|
|
{
|
|
const TRiga_documento* rin = &doc_in[r];
|
|
const bool rindesc = rin->sola_descrizione(); // La riga di input e' descrittiva
|
|
if (ignora_desc && rindesc)
|
|
continue;
|
|
|
|
if (prezzo_da_ordine()) // Se devo copiare il prezzo originale all'ordine
|
|
{
|
|
const TRectype* row_ord = rin->find_original_rdoc();
|
|
if (row_ord != NULL)
|
|
{
|
|
tmp = *rin; rin = &tmp;
|
|
const real ord_price = row_ord->get_real(RDOC_PREZZO);
|
|
const TString ord_scont = row_ord->get(RDOC_SCONTO);
|
|
tmp.put(RDOC_PREZZO, ord_price);
|
|
tmp.put(RDOC_SCONTO, ord_scont);
|
|
}
|
|
}
|
|
|
|
bool elaborata = FALSE;
|
|
|
|
// Raggruppo le righe se e' settato il flag di raggruppamento e
|
|
// se la riga non contiene solo una descrizione
|
|
if (ragg_rig && !rindesc) // Se devo raggruppare le righe ...
|
|
{
|
|
const int last = doc_out.physical_rows();
|
|
for (int o = 1; o <= last; o++) // ... cerca una riga compatibile
|
|
{
|
|
TRiga_documento& rout = doc_out[o];
|
|
if (rout.sola_descrizione()) // Ignora le righe descrittive
|
|
continue;
|
|
|
|
if (rin->raggruppabile(rout, campi_riga)) // Se esiste una riga compatibile ...
|
|
{
|
|
rout += *rin; // ... sommaci la quantita' ecc.
|
|
elaborata = TRUE; // Ricorda di averla gia' elaborata
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!elaborata) // Se la riga non e' stata gia' sommata ...
|
|
{
|
|
TRiga_documento& rout = doc_out.new_row(); // ... crea una riga nuova e
|
|
doc_out.copy_data(rout, *rin); // copiaci tutti i campi della riga sorgente.
|
|
rout.set_original_rdoc_key(*rin); // memorizza il codice della riga originale
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TFatturazione_bolle::elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
|
const TDate& data_elab, bool interattivo)
|
|
{
|
|
bool ok = TRUE;
|
|
|
|
TToken_string campi_doc(128); // Lista di campi che devono essere uguali
|
|
campi_doc = "TIPOCF|CODCF|CODVAL|CODLIN"; // Uguali sempre
|
|
|
|
// Uguali opzionalmente
|
|
const char* cond[] = { "CAMBIO", "SCONTO", "TIPODOC", "CODNUM",
|
|
"CODPAG", "CODABIA|CODCABA", "CODLIST", "CODAG",
|
|
"CODSPMEZZO", "CODPORTO", "CAUSTRASP", "CODVETT1|CODVETT2|CODVETT3",
|
|
"CODINDSP",
|
|
NULL };
|
|
|
|
for (int u = 0; cond[u]; u++)
|
|
if (doc_uguale(u)) campi_doc.add(cond[u]);
|
|
|
|
for (int id = 0; id < doc_in.items() && ok; id++)
|
|
{
|
|
TDocumento& campione = doc_in[id];
|
|
const int tot = doc_out.items();
|
|
int od = tot;
|
|
|
|
if (interattivo)
|
|
{
|
|
od = 0;
|
|
const TString16 tipo(campione.get(DOC_TIPOCF));
|
|
const long codice = campione.get_long(DOC_CODCF);
|
|
|
|
if (tipo != doc_out[od].get(DOC_TIPOCF) ||
|
|
codice != doc_out[od].get_long(DOC_CODCF))
|
|
return error_box("Documenti incompatibili : cliente/fornitore diverso");
|
|
}
|
|
else
|
|
{
|
|
if (campione.raggruppabile()) // Se il documento ha il flag di raggruppabilita' ...
|
|
{
|
|
for (od = 0; od < tot; od++) // ... cerca un documento compatibile.
|
|
{
|
|
if (campione.raggruppabile(doc_out[od], campi_doc))
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (od >= tot) // Se non ho trovato un documento compatibile ...
|
|
{ // ... creane uno nuovo (certamente compatibile)
|
|
const char provv = tipo_numerazione();
|
|
// const int anno = campione.anno();
|
|
const int anno = data_elab.year();
|
|
// const TString codnum = codice_numerazione_finale();
|
|
const TString16 codnum(campione.get("CODNUM"));
|
|
const TString16 tipo_out(get("S8")); // Tipo del documento di output
|
|
|
|
TDocumento* new_doc = new TDocumento(provv, anno, codnum, -1);
|
|
|
|
// Attenzione! Il cambio del tipo documento provocherebbe il reset delle variabili
|
|
// Per cui lo scrivo temporaneamente nel tipo del documento d'ingresso
|
|
// TRecfield td(campione, DOC_TIPODOC); // Uso il TRecfield per scavalcare tutti gli automatismi
|
|
// const TString16 old_tipo_in = td; // Salvo il vecchio tipo
|
|
// td = tipo_out; // Setto il nuovo
|
|
TDocumento::copy_data(new_doc->head(), campione.head()); // Copio la testata
|
|
// td = old_tipo_in; // Ripristino il vecchio
|
|
|
|
new_doc->put("DATADOC", data_elab);
|
|
|
|
// Aggiungilo alla lista dei documenti in uscita
|
|
od = doc_out.add(new_doc);
|
|
}
|
|
|
|
ok = raggruppa(campione, doc_out[od]);
|
|
|
|
campione.flush_rows();
|
|
}
|
|
|
|
const int tot = doc_out.items();
|
|
const TString codnum(codice_numerazione_finale());
|
|
const TString16 tipo_out(get("S8")); // Tipo del documento di output
|
|
|
|
for (int i = 0; i < tot; i++) // Forza tipo e numerazione documento.
|
|
{
|
|
TDocumento & d = doc_out[i];
|
|
d.put("CODNUM", codnum);
|
|
|
|
TToken_string key; key.add(d.get(DOC_TIPOCF)); key.add(d.get(DOC_CODCF));
|
|
const TRectype & cfven = cache().get(LF_CFVEN, key);
|
|
const TString16 tipo_cli(cfven.get(CFV_TIPODOCFAT));
|
|
|
|
TRecfield td(d, DOC_TIPODOC); // Uso il TRecfield per scavalcare tutti gli automatismi
|
|
#ifdef DBG
|
|
real tot = d.totale_doc();
|
|
#endif
|
|
td = tipo_cli.empty() ? tipo_out : tipo_cli;
|
|
TString16 sconto(d.get(DOC_SCONTOPERC));
|
|
d.put(DOC_SCONTOPERC, sconto);
|
|
#ifdef DBG
|
|
tot = d.totale_doc();
|
|
#endif
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
|