root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ve/velib04c.cpp
alex a0a36d6b33 Patch level : XX.282 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            : Riportata la versione 01.05 patch 282


git-svn-id: svn://10.65.10.50/trunk@8019 c028cbd2-c16b-5b4b-a496-9718f37d4682
1999-04-06 15:34:39 +00:00

607 lines
22 KiB
C++
Executable File
Raw Blame History

#include <progind.h>
#include <tabutil.h>
#include <doc.h>
#include <rdoc.h>
#include <effetti.h>
#include <reffetti.h>
#include "../cg/cgsaldac.h"
#include "../ef/ef0101.h"
#include "velib.h"
///////////////////////////////////////////////////////////
// TGenerazione_effetti
///////////////////////////////////////////////////////////
TGenerazione_effetti::TGenerazione_effetti(const char* cod)
: TElaborazione(cod)
{
_valid_array.set(2); // tratta
_valid_array.set(3); // riba
_valid_array.set(5); // paghero'
_valid_array.set(7); // tratta accettata
_valid_array.set(8); // rapporti interbancari diretti (rid)
_valid_array.reset(9); // bonifici
_docfile = new TLocalisamfile(LF_DOC);
_rdocfile = new TLocalisamfile(LF_RIGHEDOC);
// _cessfile = new TLocalisamfile(LF_CESS);
_occas = new TLocalisamfile(LF_OCCAS);
_clifo = new TLocalisamfile(LF_CLIFO);
_cfven = new TLocalisamfile(LF_CFVEN);
_tab = new TLocalisamfile(LF_TAB);
_efffile = new TLocalisamfile(LF_EFFETTI);
_refffile = new TLocalisamfile(LF_REFFETTI);
_cpg = new TTable("%CPG");
}
TGenerazione_effetti::TGenerazione_effetti(const TRectype& rec)
: TElaborazione(rec)
{
_valid_array.set(2); // tratta
_valid_array.set(3); // riba
_valid_array.set(5); // paghero'
_valid_array.set(7); // tratta accettata
_valid_array.set(8); // rapporti interbancari diretti (rid)
_valid_array.reset(9); // bonifici
_docfile = new TLocalisamfile(LF_DOC);
_rdocfile = new TLocalisamfile(LF_RIGHEDOC);
// _cessfile = new TLocalisamfile(LF_CESS);
_occas = new TLocalisamfile(LF_OCCAS);
_clifo = new TLocalisamfile(LF_CLIFO);
_cfven = new TLocalisamfile(LF_CFVEN);
_tab = new TLocalisamfile(LF_TAB);
_efffile = new TLocalisamfile(LF_EFFETTI);
_refffile = new TLocalisamfile(LF_REFFETTI);
_cpg = new TTable("%CPG");
}
TGenerazione_effetti::~TGenerazione_effetti()
{
delete _docfile;
delete _rdocfile;
// delete _cessfile;
delete _occas;
delete _clifo;
delete _cfven;
delete _efffile;
delete _refffile;
delete _tab;
delete _cpg;
}
void TGenerazione_effetti::display_error(TDocumento& doc)
{
TString msg;
TString numerazione = doc.numerazione();
const long numero = doc.numero();
switch (_error)
{
case nr_doc_error:
msg.format("Rilevato un numero di documento errato contabilizzando il documento %s/%ld."
"Verificare il numero documento e il codice numerazione inseriti in tabella.",(const char*)numerazione,numero);
break;
case chg_stat_error:
msg.format("Rilevato un errore cambiando lo stato al documento %s/%ld."
"Verificare l'integrita' del file documenti.",(const char*)numerazione,numero);
break;
case datadoc_error:
msg.format("Rilevato una data documento vuota relativamente al documento %s/%ld."
"Verificare l'informazione inserita.",(const char*)numerazione,numero);
break;
case codpag_error:
msg.format("Rilevato un codice pagamento non esistente relativamente al documento %s/%ld."
"Verificare l'esistenza del codice pagamento inserito.",(const char*)numerazione,numero);
break;
case scadenze_error:
msg.format("Calcolate 0 scadenze relativamente al documento %s/%ld."
"Verificare la correttezza del codice pagamento inserito.",(const char*)numerazione,numero);
break;
case write_error:
if (_efffile->status() != NOERR)
msg.format("Si e' verificato l' errore %d in scrittura sul file effetti relativamente al documento %s/%ld"
"Verificare la consistenza del file.",_efffile->status(),(const char*)numerazione,numero);
else
msg.format("Si e' verificato l' errore %d in scrittura sul file righe effetti relativamente al documento %s/%ld"
"Verificare la consistenza del file.",_refffile->status(),(const char*)numerazione,numero);
break;
default:
msg.format("E' stato rilevato un errore generico contabilizzando il documento %s/%ld.",
(const char*)numerazione,numero);
break;
}
warning_box(msg);
_error = no_error; // reset error, as any other one would do, so you can show me the other ones.
_can_write = FALSE; // But from now on u cannot write anymore. U must exit this program and repair errors occurred.
}
error_type TGenerazione_effetti::change_doc_status(TDocumento& doc)
// Cambia lo stato del documento
{
doc.stato(get("S4")[0]);
if (doc.rewrite() != NOERR)
_error = chg_stat_error;
return _error;
}
error_type TGenerazione_effetti::change_group_status(TDocumento& doc)
// Cambia lo stato dei documenti raggruppati
{
const int items = _group_array.items();
if (items > 0)
{
_error = no_error;
TToken_string * group_element;
int i=0;
// Ciclo sugli elementi dell'assoc_array
for (group_element = (TToken_string *) _group_array.first_item(); group_element != NULL && i < items; i++,group_element = (TToken_string*)_group_array.succ_item())
{
group_element->restart();
const int doc_items = group_element->items();
for (int j=0;j<doc_items;j++)
{
TToken_string t(group_element->get(j),'$');
char provv = t.get_char(0);
int anno = t.get_int(1);
TString codnum(t.get(2));
long numdoc = t.get_long(3);
if (doc.read(provv,anno,codnum,numdoc) == NOERR) // Legge il documento
{
doc.put(DOC_STATO,get("S4")[0]);
doc.rewrite();
}
}
}
}
return _error;
}
error_type TGenerazione_effetti::write_groups()
{
const int items = _effetti_array.items();
int err = NOERR;
_error = no_error;
for (int i = 0; i<items && err == NOERR; i++) // scorre gli effetti generati e li scrive su file
{
TEffetto& effetto = (TEffetto&)_effetti_array[i];
const real importo = effetto.get_real(EFF_IMPORTO);
if (importo > ZERO) // Gli effetti negativi non vanno scritti
err = effetto.write(*_efffile); // Pensa a tutto lui per rinumerare...
}
if (err != NOERR)
{
i--;
for (int j = 0; j<i; j++) // rimuove gli effetti raggruppati, per non lasciare documenti raggruppati parzialmente
{
TEffetto& effetto = (TEffetto&)_effetti_array[j];
// posso fare tranquillamente la remove, visto che la numerazione dell'effetto e' gia' stata effettuata
effetto.remove(*_efffile);
}
error_box("Errore %d nella scrittura gruppi di effetti. Nessun raggruppamento effettuato.",err);
}
return _error;
}
// Criteri di raggruppamento effetti.
// Un documento puo' essere raggruppato con i seguenti criteri:
// - flag di raggruppamento effetti a TRUE (obbligatorio)
// - cliente (obbligatorio)
// - valuta (obbligatorio)
// - data scadenza (opzionale)
// - flag di sosp. d'imposta (opzionale)
// - cambio valuta (opzionale)
// - cond di pagamento (opzionale)
// - banca (opzionale)
// - tipo doc. (opzionale)
// - cod. numerazione (opzionale)
// - agente (opzionale)
// I parametri opzionali sono decisi nella tabella elaborazioni
// Spiegazione del raggruppamento:
// Il raggruppamento di documenti diversi in uno stesso effetto consiste nella creazione
// di piu' righe dello stesso effetto.
// Ad esempio supponiamo di avere il cliente 10 con 4 fatture ognuna con condizioni di pagamento diverse
// la fattura 1 e' suddivisa in 2 rate (10.000 + 30.000)
// la fattura 2 e' suddivisa in 4 rate (15.000 + 20.000 + 25.000 + 30.000)
// la fattura 3 e' suddivisa in 5 rate (20.000 + 40.000 + 80.000 + 160.000 + 320.000)
// la fattura 4 e' suddivisa in 3 rate (50.000 + 100.000 + 150.000)
// Il numero di effetti generati equivale al massimo numero di rate (5 in questo caso)
// quindi avremo 5 effetti:
// il primo avra' 4 righe (prima rata di tutte le fatture)
// il secondo avra' 4 righe (seconda rata di tutte le fatture)
// il terzo avra' 3 righe (terza rata delle fatture 2,3,4)
// il quarto avra' 2 righe (quarta rata delle fatture 2 e 3)
// il quinto avra' 1 riga (quinta rata della fattura 3)
// La testata di ogni effetto conterra' il totale (somma) dei singoli importi delle righe
// ovvero:
// tot. primo effetto: 95.000
// tot. secondo effetto: 190.000
// tot. terzo effetto: 255.000
// tot. quarto effetto: 190.000
// tot. quinto effetto: 320.000
// I dati della testata (soprattutto la data di scadenza) di ogni effetto vengono presi dal
// primo documento valido per la generazione dell'effetto corrente:
// per i primi due effetti vale la fattura 1
// per gli effetti 3 e 4 vale la fattura 2
// per l'effetto 5 vale la fattura 3.
// Questo e' quanto ho appreso (Hope I'm right...) ;-)
void TGenerazione_effetti::group_bills(TDocumento& doc)
{
// Bail out if there aren't items...
_error = no_error;
const int items = _group_array.items();
if (items == 0) return;
int i=0,j,n,offset=0;
TString msg1,msg2;
TString16 codpag;
real imprata, imprataval, importo, importoval;
msg1 = "Raggruppamento effetti";
#ifdef DBG
TProgind p(items,msg1,TRUE,TRUE,1);
#else
TProgind p(items,msg1,FALSE,TRUE,1);
#endif
TToken_string * group_element;
// Ciclo sugli elementi dell'assoc_array
for (group_element = (TToken_string *) _group_array.first_item(); group_element != NULL && i < items; i++,group_element = (TToken_string*)_group_array.succ_item())
{
#ifdef DBG
if (p.iscancelled()) break;
#endif
p.setstatus(i+1);
// Ciclo sui documenti da raggruppare
group_element->restart();
const int doc_items = group_element->items();
for (j=0;j<doc_items;j++)
{
#ifdef DBG
if (p.iscancelled()) break;
#endif
TToken_string t(group_element->get(j),'$');
char provv = t.get_char(0);
int anno = t.get_int(1);
TString codnum(t.get(2));
long numdoc = t.get_long(3);
if (doc.read(provv,anno,codnum,numdoc) != NOERR) continue; // Legge il documento (giusto saltare e proseguire se non lo trova?)
msg2 = "Documento: ";
msg2 << codnum << "/" << numdoc;
xvt_statbar_set(msg2);
do_events();
// Ricalcola le scadenze
codpag = doc.get(DOC_CODPAG);
_cpg->put("CODTAB",codpag);
if (_cpg->read()!= NOERR)
{
_error = codpag_error;
return;
}
const real totale_fatt = doc.totale_doc();
const bool valuta = doc.in_valuta();
const real change = doc.cambio();
const TDate datafatt = doc.get_date(DOC_DATADOC);
const bool is_nota_credito = doc.is_nota_credito();
// Qui il controllo sul residuo da pagare per il documento corrente non va effettuato,
// proprio perch<63> si sta effettuando un raggruppamento di effetti; eventuali documenti
// con importo negativi (assimilati a note di credito) vanno presi in considerazione
// per la composizione dell'importo finale dell'effetto. Un effetto puo' essere composto
// anche da righe di valore negativo ma esso non verr<72> scritto solo nel caso in cui l'importo
// totale (la somma delle singole righe) sia negativo a sua volta
{
calc_pagamento(doc);
TPagamento& pag = doc.pagamento();
const int numrate = pag.n_rate( );
if (numrate < 1)
{
_error = scadenze_error;
return;
}
// Scorre le scadenze
for (n = 1; n <= numrate && good(); n++)
{
if (valid_type(pag.tipo_rata(n-1)))
{
// Se non esiste effetto n-esimo (corrisponde al numero di rata corrente+offset)
// lo genera con la relativa riga. Se esiste vi somma gli importi ed accoda la riga
const bool is_new = n+offset > _effetti_array.items();
if (is_new) // Nuovo effetto: crea effetto con i dati di questo documento (e' il primo che incontro nella scansione)
{
TEffetto effetto;
// Setta i dati della testata;
effetto.put(EFF_DATASCAD, pag.data_rata(n-1));
effetto.put(EFF_TIPOPAG,pag.tipo_rata(n-1));
effetto.put(EFF_ULTCLASS,pag.ulc_rata(n-1));
effetto.put(EFF_CODCF, doc.get_long(DOC_CODCF));
effetto.put(EFF_CODVAL, doc.get(DOC_CODVAL));
effetto.put(EFF_CAMBIO, change);
effetto.put(EFF_DATACAMBIO,doc.get_date(DOC_DATACAMBIO));
effetto.put(EFF_CODABI,doc.get(DOC_CODABIA));
effetto.put(EFF_CODCAB,doc.get(DOC_CODCABA));
effetto.put(EFF_EFFCOMP,TRUE);
_effetti_array.add(effetto);
}
// aggiorna totale effetto (testata)
TEffetto& effetto=(TEffetto&)_effetti_array[n+offset-1];
importo = effetto.get_real(EFF_IMPORTO);
imprata = pag.importo_rata(n-1,FALSE);
if (is_nota_credito)
imprata = -imprata;
importo += imprata;
effetto.put(EFF_IMPORTO,importo);
if (valuta)
{
importoval = effetto.get_real(EFF_IMPORTOVAL);
imprataval = pag.importo_rata(n-1,TRUE);
if (is_nota_credito)
imprataval = -imprataval;
importoval += imprataval;
effetto.put(EFF_IMPORTOVAL,importoval);
}
// Crea la nuova riga di questo effetto
const int rows = effetto.rows_r();
TRectype& riga = effetto.row_r(rows+1,TRUE);
// reffetto.put(REFF_NPROGTR,nprog);
riga.put(REFF_NRIGATR,rows+1);
riga.put(REFF_NRATA,n);
riga.put(REFF_DATAFATT, datafatt);
riga.put(REFF_PROVV,provv);
riga.put(REFF_ANNODOC,anno);
riga.put(REFF_CODNUM,codnum);
riga.put(REFF_NFATT,numdoc);
riga.put(REFF_IMPFATT,totale_fatt);
riga.put(REFF_IMPORTO,imprata);
if (valuta)
{
riga.put(REFF_IMPFATTVAL,totale_fatt);
real totfatlit = totale_fatt*change;
riga.put(REFF_IMPFATT,totfatlit);
riga.put(REFF_IMPORTOVAL,imprataval);
}
}
} // Ciclo sulle scadenze
}
} // Ciclo sui documenti di questo gruppo
offset=_effetti_array.items();
} // Ciclo sui gruppi
// Cambia lo stato a tutti i documenti raggruppati
if (good() && _can_write)
if (write_groups() == no_error)
{
_total_bills += _effetti_array.items();
change_group_status(doc);
}
_effetti_array.destroy();
_group_array.destroy();
}
bool TGenerazione_effetti::valid_type(int pag) const
{
return _valid_array[pag];
}
void TGenerazione_effetti::calc_pagamento(TDocumento& doc)
{
TPagamento& pag = doc.pagamento();
const real change = doc.cambio();
real totspese = doc.spese();
real totimposte = doc.imposta();
real pagato = doc.get(DOC_IMPPAGATO);
real totimponibili = doc.totale_doc() - totimposte - totspese;
const bool valuta = doc.in_valuta();
if (valuta)
{
const TString16 codval = doc.valuta();
real val1 = totimponibili * change;
real val2 = totimposte * change;
real val3 = totspese * change;
pag.set_total_valuta( totimponibili, totimposte, totspese, change, val1, val2 ,val3, doc.valuta());
}
else
pag.set_total( totimponibili, totimposte, totspese );
pag.set_rate_auto();
//Riaggiusta le rate a seconda del valore gia' pagato
real rata,v;
const int numrate = pag.n_rate( );
for (int i = 0; i< numrate; i++)
{
rata = pag.importo_rata(i,valuta);
if (rata > pagato)
{
v = rata - pagato;
pagato = ZERO;
}
else
{
v = ZERO;
pagato -= rata;
}
pag.set_imprata(i, v, valuta);
if (valuta)
{
v *= change;
v.round();
pag.set_imprata(i, v, FALSE);
}
}
// Scorre all'indietro per rimuovere le rate a 0, evitando fastidiose
// complicazioni dovute al pack delle rate effettuato dalla remove_rate()
for (i=numrate-1; i>=0; i--)
{
if (pag.importo_rata(i,valuta) == ZERO)
pag.remove_rata(i);
}
}
void TGenerazione_effetti::generate_bill(TDocumento& doc) // bill in inglese significa anche effetto eheheh ;-)
{
// That's my JOB!
// Ogni rata della fattura (si parla di effetti attivi per ora) genera 1 effetto.
// con almeno una riga.
// Ad es. Se ho una fattura suddivisa in 3 rate essa generera' 3 effetti con una riga.
// Nel caso si decida di raggruppare gli effetti (vedi criteri di raggruppamento)
// avro' un effetto con tante righe quante scadenze di fattura sono raggruppabili
// Le fatture possono generare effetti solo per i seguenti tipi di pagamento:
// 2 - Tratta
// 3 - Ri.Ba.
// 5 - Paghero'
// 7 - Tratta accettata
// 8 - Rapporti interbancari diretti
// Caso mai tale insieme risultasse incompleto od errato basta solo modificare l'enum posto all'inizio del programma
if (!doc.is_nota_credito()) // I documenti immessi come note di credito non generano effetti...(che senso hanno gli effetti con importi negativi?)
{
TString16 codpag(doc.get(DOC_CODPAG));
_cpg->put("CODTAB",codpag);
if (_cpg->read()!= NOERR)
{
_error = codpag_error;
return;
}
TString16 data(doc.get(DOC_DATAINSC));
if (data.empty())
data = doc.get(DOC_DATADOC);
const real totale_fatt = doc.totale_doc(); // Importo in valuta
if (totale_fatt - doc.get_real(DOC_IMPPAGATO) > ZERO && !doc.get_bool(DOC_ACCSALDO)) // procede se non e' a saldo
{
const bool valuta = doc.in_valuta();
const real change = doc.cambio();
// calcolo delle scadenze
calc_pagamento(doc);
TPagamento & pag = doc.pagamento();
// CHECK(pag,"Failed to create a TPagamento");
const int numrate = pag.n_rate( );
if (numrate < 1)
{
_error = scadenze_error;
return;
}
_efffile->last();
// Variabili per la scrittura dell'effetto
long nprog = _efffile->get_long(EFF_NPROGTR)+1;
const long codcf = doc.get_long(DOC_CODCF);
const TString16 codval(doc.get(DOC_CODVAL));
const TDate data_cambio = doc.get_date(DOC_DATACAMBIO);
const long codabi = doc.get_long(DOC_CODABIA);
const long codcab = doc.get_long(DOC_CODCABA);
const TString16 provv(doc.get(DOC_PROVV));
const int anno = doc.get_int(DOC_ANNO);
const TString16 codnum(doc.get(DOC_CODNUM));
const long nfatt = doc.get_long(DOC_NDOC);
const TDate datafatt = doc.get_date(DOC_DATADOC);
TRectype& effetto = _efffile->curr();
TRectype& reffetto = _refffile->curr();
real importo;
for (int i = 0; i < numrate && good(); i++)
{
if (valid_type(pag.tipo_rata(i)))
{
effetto.zero();
reffetto.zero();
effetto.put(EFF_NPROGTR,nprog);
effetto.put(EFF_DATASCAD, pag.data_rata(i));
effetto.put(EFF_TIPOPAG,pag.tipo_rata(i));
effetto.put(EFF_ULTCLASS,pag.ulc_rata(i));
effetto.put(EFF_CODCF, codcf);
effetto.put(EFF_CODVAL, codval);
if (valuta)
{
effetto.put(EFF_CAMBIO, change);
effetto.put(EFF_DATACAMBIO,data_cambio);
}
effetto.put(EFF_CODABI,codabi);
effetto.put(EFF_CODCAB,codcab);
effetto.put(EFF_EFFCOMP,TRUE);
if (i == numrate - 1) effetto.put(EFF_ULTRATA,TRUE);
// Put sulla riga dell'effetto
reffetto.put(REFF_NPROGTR,nprog);
reffetto.put(REFF_NRIGATR,1);
reffetto.put(REFF_DATAFATT, datafatt);
reffetto.put(REFF_NRATA,i+1);
reffetto.put(REFF_PROVV,provv);
reffetto.put(REFF_ANNODOC,anno);
reffetto.put(REFF_CODNUM,codnum);
reffetto.put(REFF_NFATT,nfatt);
importo = pag.importo_rata(i,FALSE);
effetto.put(EFF_IMPORTO,importo);
reffetto.put(REFF_IMPFATT,totale_fatt);
reffetto.put(REFF_IMPORTO,importo);
if (valuta)
{
importo = pag.importo_rata(i,TRUE); // Importo in valuta
real totfatlit = totale_fatt*change; //Not sure about this...
effetto.put(EFF_IMPORTOVAL,importo);
reffetto.put(REFF_IMPFATTVAL,totale_fatt);
reffetto.put(REFF_IMPFATT,totfatlit);
reffetto.put(REFF_IMPORTOVAL,importo);
}
if (_efffile->write() == NOERR && _refffile->write() == NOERR)
{
_total_bills++;
nprog++;
}
else _error = write_error;
}
}
}
}
if (good() && _can_write)
change_doc_status(doc);
}
bool TGenerazione_effetti::elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
const TDate& data_elab, bool interattivo)
{
_error = no_error;
_can_write = TRUE;
_total_bills = 0L;
_cpg->setkey(1); // Setta per sicurezza la chiave 1 nel caso l'elaborazione sia invocata da VE0
const int items = doc_in.items(); // Numero dei documenti in questa elaborazione
TProgind p(items,"Generazione effetti",FALSE,TRUE,1);
for (int i = 0; i < items ; i++) // Scorriamo tutti i documenti nella lista
{
generate_bill(doc_in[i]); // Genera gli effetti corrispondenti
p.setstatus(i+1);
if (!good())
display_error(doc_in[i]);
}
// Effettua il raggruppamento di eventuali documenti rimasti
TDocumento doc;
if (good())
group_bills(doc);
// Mostra eventuali errori residui
if (!good())
display_error(doc);
return _can_write;
}
Reference in New Issue View Git Blame Copy Permalink