405617dfae
Files correlati : cg0.exe cg3.exe cg3700a.msk Ricompilazione Demo : [ ] Commento : EP20085 Non riesco a richiamare, perché non viene nemmeno visualizzato fra quelli esistenti, un registro inserito nella tabella registri con codice alfanumerico (es.VE1) EP20087 Lavoro col mouse: inserisco un nuovo movimento con causale V01 (o in generale con qualsiasi causale) nella pagina testata, seleziono con mouse la descrizione della causale e clicco su "modifica/copia". Entro nella tebella descrizioni aggiuntive (come per aggiungerne una nuova) mi posiziono sul campo descrizione e vado su (modifica/incolla): il testo non viene copiato e quando esco dalla maschera errore EP20090 Mancano le ricerche sui campi registri e fornitori git-svn-id: svn://10.65.10.50/trunk@11255 c028cbd2-c16b-5b4b-a496-9718f37d4682
951 lines
28 KiB
C++
Executable File
951 lines
28 KiB
C++
Executable File
/////////////////////////////////////////////////////////////////////////////
|
|
// cglib02.cpp
|
|
//
|
|
// Aggiornamento saldi
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
#include <diction.h>
|
|
#include <progind.h>
|
|
#include <relation.h>
|
|
#include <tabutil.h>
|
|
#include <utility.h>
|
|
#include <xvtility.h>
|
|
|
|
#include "cglib01.h"
|
|
#include "cglib02.h"
|
|
|
|
#include <causali.h>
|
|
#include <mov.h>
|
|
#include <pconti.h>
|
|
#include <rmov.h>
|
|
#include <saldi.h>
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TSaldi_list
|
|
///////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Cerca l'esercizio precedente di EseCorr
|
|
// Se EseCorr e' gia' il primo ritorna 0
|
|
//
|
|
HIDDEN int EsePre(const int EseCorr)
|
|
{
|
|
TEsercizi_contabili esc;
|
|
return esc.pred(EseCorr);
|
|
}
|
|
|
|
// aep e' l'esercizio precedente
|
|
TSaldi_list::TSaldi_list(int gr, int co, int aec, int aep_par)
|
|
{
|
|
TString16 key;
|
|
int aep = aep_par;
|
|
|
|
destroy();
|
|
|
|
// Se non passo l'anno precedente lo devo comunque calcolare
|
|
if (aep_par == 0)
|
|
aep = EsePre(aec);
|
|
|
|
TLocalisamfile cf(LF_SALDI);
|
|
cf.setkey(2);
|
|
cf.put(SLD_GRUPPO,gr);
|
|
cf.put(SLD_CONTO,co);
|
|
|
|
for (cf.read(_isgteq);!cf.eof();cf.next())
|
|
{
|
|
if (!cf.get_bool(SLD_FLSCA))
|
|
{
|
|
const int ae = cf.get_int(SLD_ANNOES);
|
|
const int g = cf.get_int(SLD_GRUPPO);
|
|
const int c = cf.get_int(SLD_CONTO);
|
|
const long s = cf.get_long(SLD_SOTTOCONTO);
|
|
|
|
if (g != gr || c != co) break;
|
|
if (ae != aec && ae != aep) continue;
|
|
|
|
const TRectype& r = cf.curr();
|
|
key.format("%3d%3d%6ld", g, c, s);
|
|
|
|
// Se avevo chiesto anche l'es. prec. puo' darsi che l'abbia gia' trovato
|
|
bool force = !aep_par;
|
|
add(key, r, force);
|
|
}
|
|
}
|
|
}
|
|
|
|
TRectype* TSaldi_list::saldi() const
|
|
{
|
|
TObject* o = ((TAssoc_array*)this)->get();
|
|
return (TRectype*)o;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TSaldo
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TSaldo::TSaldo() : _saldi(LF_SALDI), _saldoiniziale(ZERO), _saldo_iniziale(ZERO),
|
|
_prg_dare(ZERO), _prg_avere(ZERO), _saldo(ZERO), _annoes(0),
|
|
_indbil(0), _prec(FALSE), _movimentato(FALSE), _significativo(FALSE),
|
|
_rec_presente_ec(FALSE), _rec_presente_ep(FALSE),
|
|
_causali_apertura(LF_CAUSALI, CAU_MOVAP), _movimenti(LF_MOV)
|
|
|
|
{}
|
|
|
|
real TSaldo::saldofin_esprec(int annoes, int g, int c, long s, bool saldo_chiusura, bool provvis)
|
|
{
|
|
const int annoesprec = EsePre(annoes);
|
|
_significativo = FALSE;
|
|
|
|
if (!ricerca_progr_prec(annoesprec, g, c, s)) // non ci sono esercizi prima del primo
|
|
return ZERO;
|
|
|
|
const char flag = _saldi.get(SLD_FLAGSALINI)[0];
|
|
const real saldo = _saldi.get_real(SLD_SALDO);
|
|
const real pdare = _saldi.get_real(SLD_PDARE);
|
|
const real pavere = _saldi.get_real(SLD_PAVERE);
|
|
const real pdarepro = _saldi.get_real(SLD_PDAREPRO);
|
|
const real paverepro = _saldi.get_real(SLD_PAVEREPRO);
|
|
const char flagsf = _saldi.get_char(SLD_FLAGSALFIN);
|
|
const real saldosf = _saldi.get_real(SLD_SALDOFIN);
|
|
|
|
real tot = pdare-pavere;
|
|
|
|
if (flag == 'D') tot += saldo;
|
|
else tot -= saldo;
|
|
|
|
if (saldo_chiusura) // W96SALDI del 18-07-96
|
|
{ // Ho aggiunto il flag saldo_chiusura con valore di
|
|
if (flagsf == 'D') // default a FALSE, perche' il saldo finale dell' esercizio
|
|
tot += saldosf; // precedente va considerato solamente nel calcolo dei
|
|
else // progressivi precedenti nella stampa mastrini,
|
|
tot -= saldosf; // che e' l'unico programma ad usare la funzione
|
|
} // passandogli come flag saldo_chiusura il valore TRUE.
|
|
|
|
if (provvis)
|
|
{
|
|
tot += pdarepro;
|
|
tot -= paverepro;
|
|
}
|
|
|
|
_significativo = (tot != 0);
|
|
return tot;
|
|
}
|
|
|
|
//richiamata nel bilancio a sez.contr per data limite
|
|
//in realta' calcola il saldo finale es.prec
|
|
real TSaldo::calcola_saldo_iniziale(int g,int c,long s,int indbil)
|
|
{
|
|
real saldoini;
|
|
_significativo = TRUE;
|
|
|
|
_saldi.zero();
|
|
_saldi.put(SLD_GRUPPO,g);
|
|
_saldi.put(SLD_CONTO,c);
|
|
_saldi.put(SLD_SOTTOCONTO,s);
|
|
_saldi.put(SLD_ANNOES,_annoes);
|
|
_saldi.put(SLD_FLSCA,"");
|
|
|
|
if (_rec_presente_ec = (_saldi.read() == NOERR))
|
|
saldoini = _saldi.get_real(SLD_SALDO);
|
|
|
|
_significativo = _rec_presente_ec && saldoini != ZERO;
|
|
|
|
if (saldoini != ZERO) //non va considerato!!! Vedi appunti
|
|
_saldo_iniziale = ZERO;
|
|
|
|
if (saldoini == ZERO)
|
|
{
|
|
if (indbil == 1 || indbil == 2 || indbil == 5)
|
|
{
|
|
_prec = TRUE;
|
|
saldoini = saldofin_esprec(_annoes, g, c, s);
|
|
}
|
|
_saldo_iniziale = saldoini;
|
|
}
|
|
return _saldo_iniziale;
|
|
}
|
|
|
|
/*
|
|
const TString& TSaldo::causale_chiusura_es() const
|
|
{
|
|
TConfig conf(CONFIG_DITTA, "cg");
|
|
TString& tmp = get_tmp_string();
|
|
tmp = conf.get("CoCaCh");
|
|
return tmp;
|
|
}
|
|
|
|
const TString& TSaldo::causale_apertura_es() const
|
|
{
|
|
TConfig conf(CONFIG_DITTA, "cg");
|
|
TString& tmp = get_tmp_string();
|
|
tmp = conf.get("CoCaAp");
|
|
return tmp;
|
|
}
|
|
*/
|
|
|
|
bool TSaldo::leggi_mov(long nr)
|
|
{
|
|
TString16 n;
|
|
n<<nr;
|
|
const TRectype& mov = _movimenti.get(n);
|
|
const bool ok = !mov.empty();
|
|
if (ok)
|
|
{
|
|
_codcaus = mov.get(MOV_CODCAUS);
|
|
_datareg = mov.get(MOV_DATAREG);
|
|
_provv = mov.get(MOV_PROVVIS); // _provv.trim();
|
|
_datacomp = mov.get(MOV_DATACOMP);
|
|
if (_movimenti.items() >= 2048)
|
|
_movimenti.destroy();
|
|
}
|
|
else
|
|
NFCHECK("Testata assente: %ld", nr);
|
|
return ok;
|
|
}
|
|
|
|
//per bilancio scalare (ovvero a sezioni contrapposte) per data limite
|
|
bool TSaldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDate& data_inf,
|
|
const TDate& data_sup, int indbil, int stp_prov, const char* filter)
|
|
{
|
|
_saldo_iniziale = ZERO;
|
|
_saldo = ZERO;
|
|
_movimentato = FALSE;
|
|
_rec_presente_ep = FALSE;
|
|
_rec_presente_ec = FALSE;
|
|
_prec = FALSE;
|
|
|
|
TRelation rel(LF_RMOV);
|
|
TRectype& rmov = rel.curr();
|
|
|
|
rmov.zero();
|
|
rmov.put(RMV_GRUPPO,g);
|
|
rmov.put(RMV_CONTO,c);
|
|
rmov.put(RMV_SOTTOCONTO,s);
|
|
TCursor cur(&rel, filter, 2, &rmov, &rmov);
|
|
const TRecnotype items = cur.items();
|
|
cur.freeze();
|
|
|
|
// Anche se non movimentato vado a vedere il saldo
|
|
if (stp_prov != 3 && (filter == NULL || *filter == '\0'))
|
|
_saldo = calcola_saldo_iniziale(g,c,s,indbil);
|
|
|
|
for (cur = 0L; cur.pos() < items; ++cur)
|
|
{
|
|
const long num_reg = rmov.get_long(RMV_NUMREG);
|
|
|
|
if (!leggi_mov(num_reg)) // Leggo la testata
|
|
continue; // Evita righe orfane!
|
|
|
|
TDate data_mov;
|
|
if (bilancio == DataLimite)
|
|
data_mov = _datacomp;
|
|
else
|
|
{
|
|
if (_annoes == 0)
|
|
data_mov = _datareg;
|
|
else
|
|
data_mov = _datacomp;
|
|
}
|
|
|
|
if (data_mov < data_inf || data_mov > data_sup)
|
|
continue;
|
|
|
|
// "Se la causale del movimento e' di chiusura,
|
|
// o di apertura il movimento non va considerato"
|
|
if (_codcaus.not_empty())
|
|
{
|
|
const TString& movap = _causali_apertura.decode(_codcaus);
|
|
if (movap == "C")
|
|
continue;
|
|
}
|
|
|
|
//bilancio normale (non comprende i provvisori) ?
|
|
if (stp_prov == 1 && _provv.not_empty())
|
|
continue;
|
|
|
|
//bilancio dei soli provvisori ?
|
|
if (stp_prov == 3 && _provv.empty())
|
|
continue;
|
|
|
|
const char sezione = rmov.get_char(RMV_SEZIONE);
|
|
const real importo = rmov.get_real(RMV_IMPORTO);
|
|
|
|
// I mov. di puro riferimento (= con importo = 0) vanno scartati
|
|
if (importo == ZERO)
|
|
continue;
|
|
|
|
_movimentato = TRUE;
|
|
|
|
if (sezione == 'D')
|
|
_saldo += importo;
|
|
else
|
|
_saldo -= importo;
|
|
}
|
|
|
|
#ifdef DBG
|
|
xvt_statbar_refresh();
|
|
#endif
|
|
|
|
return _movimentato;
|
|
}
|
|
|
|
|
|
//per bilancio di verifica all'ultima immissione
|
|
bool TSaldo::ultima_immissione_verifica(int annoes,int g,int c,long s,int indbil,int stp_prov)
|
|
{
|
|
//Si considerano i saldi e non piu' i movimenti
|
|
char sezione;
|
|
int gruppo, conto, annoe;
|
|
long sottoconto;
|
|
real pdarepro, paverepro;
|
|
bool esito = FALSE;
|
|
|
|
_saldo_iniziale = ZERO;
|
|
_saldoiniziale = ZERO;
|
|
_prg_dare = ZERO;
|
|
_prg_avere = ZERO;
|
|
_saldo = ZERO;
|
|
_saldofin = ZERO;
|
|
_sezsf = ' ';
|
|
|
|
_saldi.zero();
|
|
_saldi.put(SLD_ANNOES,annoes);
|
|
_saldi.put(SLD_GRUPPO,g);
|
|
_saldi.put(SLD_CONTO,c);
|
|
_saldi.put(SLD_SOTTOCONTO,s);
|
|
_saldi.put(SLD_FLSCA, "");
|
|
|
|
if (_saldi.read() == NOERR)
|
|
{
|
|
annoe = _saldi.get_int(SLD_ANNOES);
|
|
gruppo = _saldi.get_int(SLD_GRUPPO);
|
|
conto = _saldi.get_int(SLD_CONTO);
|
|
sottoconto = _saldi.get_long(SLD_SOTTOCONTO);
|
|
_saldo_iniziale = _saldi.get_real(SLD_SALDO);
|
|
_prg_dare = _saldi.get_real(SLD_PDARE);
|
|
_prg_avere = _saldi.get_real(SLD_PAVERE);
|
|
pdarepro = _saldi.get_real(SLD_PDAREPRO);
|
|
paverepro = _saldi.get_real(SLD_PAVEREPRO);
|
|
sezione = _saldi.get_char(SLD_FLAGSALINI);
|
|
_sezsf = _saldi.get_char(SLD_FLAGSALFIN); // W96SALDI del 19-06-96 modifica richiesta
|
|
_saldofin = _saldi.get_real(SLD_SALDOFIN); // da PATRIZIA
|
|
|
|
if (stp_prov == 1) //bilancio normale (senza provvisori)
|
|
if (_saldo_iniziale == ZERO && _prg_dare == ZERO && _prg_avere == ZERO)
|
|
return esito;
|
|
// if (stp_prov == 0 && paverepro == ZERO)
|
|
if (stp_prov == 3 && paverepro == ZERO && pdarepro == ZERO) // Modifica del 24-09-96 errore MI0890.
|
|
{
|
|
_saldo = _prg_dare = _prg_avere = ZERO; // N.B. Non e' detto che funzioni sempre!!!!!!
|
|
return esito;
|
|
}
|
|
|
|
if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
|
|
|
|
if (_sezsf == 'A') _saldofin = -_saldofin; // W96SALDI del 19-06-96
|
|
|
|
_saldoiniziale = _saldo_iniziale; //saldo iniziale presente sul record saldi
|
|
//non comprensivo del saldo finale es.precedente
|
|
|
|
if (stp_prov != 3)
|
|
if (indbil == 1 || indbil == 2 || indbil == 5)
|
|
if (_saldo_iniziale == ZERO)
|
|
_saldo_iniziale += saldofin_esprec(annoes,gruppo,conto,sottoconto);
|
|
|
|
esito = TRUE;
|
|
|
|
switch (stp_prov)
|
|
{
|
|
case 1:
|
|
_saldo = _saldo_iniziale + _prg_dare - _prg_avere + _saldofin; // W96SALDI del 19-06-96
|
|
break;
|
|
case 2:
|
|
_saldo = _saldo_iniziale + _prg_dare - _prg_avere + pdarepro - paverepro + _saldofin; // W96SALDI del 19-06-96
|
|
if (pdarepro != ZERO) // Modifica del 24-09-96 errore MI0890: nel caso in cui i progressivi
|
|
_prg_dare = pdarepro; // pdarepro o paverepro sono compilati sono in presenza di un movimento
|
|
if (paverepro != ZERO) // provvisorio, dunque li trasferisco nei progressivi che poi uso nel
|
|
_prg_avere = paverepro; // CG1500 per la stampa.
|
|
break;
|
|
case 3:
|
|
_saldo = pdarepro - paverepro;
|
|
_prg_dare = pdarepro; // Idem come sopra.
|
|
_prg_avere = paverepro; // N.B. Non e' detto che funzioni sempre!!!!!!
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return esito;
|
|
}
|
|
|
|
//per bilancio a sezioni contrapposte all'ultima immissione
|
|
// W96SALDI in questa funzione e' stato aggiunto il parametro saldo_chiusura che di default
|
|
// e' TRUE. A cosa serve ? Serve per includere nel calcolo del saldo all' ultima immissione
|
|
// anche il saldo finale compilato nei movimenti di chiusura (se non venisse considerato i conti
|
|
// risulterebbero aperti); siccome alcuni programmi (esempio il bilancio IV dir. CEE) non ne
|
|
// devono tenere conto, si e' data la possibilita' di usare la funzione passandogli il parametro a FALSE.
|
|
// Modifica del 09-07-96
|
|
bool TSaldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil,int stp_prov,bool saldo_chiusura)
|
|
{
|
|
//Si considerano i saldi e non piu' i movimenti
|
|
char sezione;
|
|
int gruppo, conto, annoe;
|
|
long sottoconto;
|
|
real pdarepro, paverepro;
|
|
bool esito = FALSE;
|
|
|
|
_saldo_iniziale = ZERO;
|
|
_prg_dare = ZERO;
|
|
_prg_avere = ZERO;
|
|
_saldo = ZERO;
|
|
_saldofin = ZERO;
|
|
_sezsf = ' ';
|
|
_rec_presente_ec = FALSE;
|
|
_rec_presente_ep = FALSE;
|
|
_prec = FALSE;
|
|
|
|
_saldi.zero();
|
|
_saldi.put(SLD_ANNOES,annoes);
|
|
_saldi.put(SLD_GRUPPO,g);
|
|
_saldi.put(SLD_CONTO,c);
|
|
_saldi.put(SLD_SOTTOCONTO,s);
|
|
_saldi.put(SLD_FLSCA, "");
|
|
|
|
if (_saldi.read() == NOERR)
|
|
{
|
|
annoe = _saldi.get_int(SLD_ANNOES);
|
|
gruppo = _saldi.get_int(SLD_GRUPPO);
|
|
conto = _saldi.get_int(SLD_CONTO);
|
|
sottoconto = _saldi.get_long(SLD_SOTTOCONTO);
|
|
_saldo_iniziale = _saldi.get_real(SLD_SALDO);
|
|
_prg_dare = _saldi.get_real(SLD_PDARE);
|
|
_prg_avere = _saldi.get_real(SLD_PAVERE);
|
|
pdarepro = _saldi.get_real(SLD_PDAREPRO);
|
|
paverepro = _saldi.get_real(SLD_PAVEREPRO);
|
|
sezione = _saldi.get_char(SLD_FLAGSALINI);
|
|
_sezsf = _saldi.get_char(SLD_FLAGSALFIN);
|
|
_saldofin = _saldi.get_real(SLD_SALDOFIN);
|
|
|
|
if (stp_prov == 1) //bilancio normale (senza provvisori)
|
|
esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO);
|
|
|
|
if (stp_prov == 2) //bilancio globale (con provvisori)
|
|
esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO
|
|
|| pdarepro != ZERO || paverepro != ZERO);
|
|
|
|
if (stp_prov == 3) //bilancio dei soli mov. provvisori
|
|
esito = (pdarepro != ZERO || paverepro != ZERO);
|
|
|
|
if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
|
|
|
|
if (saldo_chiusura) // W96SALDI modifica inserita per il discorso di inclusione oppure
|
|
if (_sezsf == 'A') // no del saldo di chiusura inserita il 09-07-96
|
|
_saldofin = -_saldofin;
|
|
|
|
_rec_presente_ec = esito;
|
|
}
|
|
|
|
if (stp_prov != 3)
|
|
if (indbil == 1 || indbil == 2 || indbil == 5)
|
|
if (_saldo_iniziale == ZERO)
|
|
{
|
|
_prec = TRUE;
|
|
_saldo_iniziale += saldofin_esprec(annoes,g,c,s);
|
|
}
|
|
|
|
if (stp_prov == 1)
|
|
_saldo = _saldo_iniziale + _prg_dare - _prg_avere;
|
|
|
|
if (stp_prov == 2)
|
|
_saldo = _saldo_iniziale + _prg_dare - _prg_avere + pdarepro - paverepro;
|
|
|
|
if (stp_prov == 3)
|
|
_saldo = pdarepro - paverepro;
|
|
|
|
if (saldo_chiusura) // W96SALDI modifica inserita per il discorso di inclusione oppure
|
|
_saldo += _saldofin; // no del saldo di chiusura inserita il 09-07-96
|
|
|
|
return esito;
|
|
}
|
|
|
|
real & TSaldo::saldo_periodo(int g, int c, long s, const TDate& dal, const TDate& al,
|
|
int indbil, bool provv, const TString & codcomm)
|
|
|
|
{
|
|
_saldo_iniziale = ZERO;
|
|
_saldo = ZERO;
|
|
_prg_dare = ZERO;
|
|
_prg_avere = ZERO;
|
|
_movimentato = FALSE;
|
|
_rec_presente_ep = FALSE;
|
|
_rec_presente_ec = FALSE;
|
|
_prec = FALSE;
|
|
|
|
TEsercizi_contabili es;
|
|
const int codes = es.date2esc(dal);
|
|
const TDate inizio = es.esercizio(codes).inizio();
|
|
const bool is_commessa = codcomm.not_empty();
|
|
|
|
_annoes = codes;
|
|
if( !is_commessa)
|
|
{
|
|
TString key(20);
|
|
|
|
key.format("%04d| |%d|%d|%ld", _annoes, g, c, s);
|
|
const TRectype & saldo = cache().get(LF_SALDI, key);
|
|
|
|
_saldo_iniziale = saldo.get_real(SLD_SALDO);
|
|
_prec = _saldo_iniziale == ZERO;
|
|
|
|
if (_prec)
|
|
{
|
|
_prec = TRUE;
|
|
_saldo_iniziale = saldofin_esprec(codes,g,c,s);
|
|
}
|
|
else
|
|
if (saldo.get_char(SLD_FLAGSALINI) == 'A')
|
|
_saldo_iniziale = -_saldo_iniziale;
|
|
}
|
|
|
|
|
|
TRelation relrmov(LF_RMOV);
|
|
TRectype & rmov = relrmov.curr();
|
|
|
|
rmov.put(RMV_GRUPPO,g);
|
|
rmov.put(RMV_CONTO,c);
|
|
rmov.put(RMV_SOTTOCONTO,s);
|
|
|
|
TCursor cur(&relrmov, "", 2, &rmov, &rmov);
|
|
const TRecnotype items = cur.items();
|
|
|
|
cur.freeze();
|
|
|
|
TString prompt(30);
|
|
|
|
prompt.format(FR("Calcolo saldo conto %d-%d-%ld"), g, c, s);
|
|
|
|
TProgind p(items, prompt, FALSE);
|
|
|
|
for (cur = 0L; cur.pos() < items && !p.iscancelled(); ++cur)
|
|
{
|
|
p.addstatus(1L);
|
|
|
|
const long num_reg = rmov.get_long(RMV_NUMREG);
|
|
const real importo = rmov.get_real(RMV_IMPORTO);
|
|
|
|
if ((!is_commessa || codcomm == rmov.get(RMV_CODCMS)) &&
|
|
importo != ZERO)
|
|
{
|
|
const char sezione = rmov.get_char(RMV_SEZIONE);
|
|
// "Se la causale del movimento e' di chiusura,
|
|
// o di apertura il movimento non va considerato"
|
|
const TString& movap = _causali_apertura.decode(_codcaus);
|
|
leggi_mov(num_reg);
|
|
|
|
if ((provv || _provv.empty()) && movap.blank())
|
|
{
|
|
if (_datacomp >= dal && _datacomp <= al)
|
|
{
|
|
_movimentato = TRUE;
|
|
|
|
if (sezione == 'D')
|
|
_prg_dare += importo;
|
|
else
|
|
_prg_avere += importo;
|
|
}
|
|
else
|
|
if ((!is_commessa) && _datacomp >= inizio && _datacomp < dal)
|
|
{
|
|
if (sezione == 'D')
|
|
_saldo_iniziale += importo;
|
|
else
|
|
_saldo_iniziale -= importo;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
_saldo = _saldo_iniziale + _prg_dare - _prg_avere;
|
|
return _saldo;
|
|
}
|
|
|
|
bool TSaldo::ricerca_progr_prec (int annoesprec, int g, int c, long s)
|
|
{
|
|
if (annoesprec == 0)
|
|
_rec_presente_ep = FALSE;
|
|
else
|
|
{
|
|
const int oldkey = _saldi.getkey();
|
|
_saldi.setkey(1);
|
|
_saldi.zero();
|
|
_saldi.put(SLD_ANNOES,annoesprec);
|
|
_saldi.put(SLD_GRUPPO,g);
|
|
_saldi.put(SLD_CONTO,c);
|
|
_saldi.put(SLD_SOTTOCONTO,s);
|
|
_saldi.put(SLD_FLSCA, "");
|
|
_rec_presente_ep = _saldi.read() == NOERR;
|
|
_saldi.setkey(oldkey);
|
|
}
|
|
return _rec_presente_ep;
|
|
}
|
|
|
|
//calcolo dei progressivi attuali (normali o eliminati)
|
|
bool TSaldo::prg_saldo(int annoes, TConto& conto, real& prgdare, real& prgavere, bool scar)
|
|
{
|
|
_saldi.zero();
|
|
_saldi.put(SLD_GRUPPO,conto.gruppo());
|
|
_saldi.put(SLD_CONTO,conto.conto());
|
|
_saldi.put(SLD_SOTTOCONTO,conto.sottoconto());
|
|
_saldi.put(SLD_ANNOES,annoes);
|
|
_saldi.put(SLD_FLSCA, scar);
|
|
|
|
bool ok = _saldi.read() == NOERR;
|
|
|
|
if (ok)
|
|
{
|
|
const char flagsalini = _saldi.get_char(SLD_FLAGSALINI);
|
|
const real saldoini = _saldi.get_real(SLD_SALDO);
|
|
prgdare = _saldi.get_real(SLD_PDARE);
|
|
prgavere = _saldi.get_real(SLD_PAVERE);
|
|
|
|
if (flagsalini == 'D')
|
|
prgdare += saldoini ;
|
|
else
|
|
prgavere += saldoini;
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TContoExt
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TContoExt : public TConto
|
|
{
|
|
bool _scaricato;
|
|
|
|
public:
|
|
|
|
bool scaricato() const { return _scaricato; }
|
|
|
|
TContoExt(int g = 0, int c = 0, long s = 0L, char t = ' ', const char* d = NULL, bool sc = FALSE)
|
|
: TConto(g, c, s, t, d), _scaricato(sc) {}
|
|
TContoExt(TToken_string& tgcsd, int from, int mode = 0, bool sc = FALSE)
|
|
: TConto(tgcsd, from, mode), _scaricato(sc) {}
|
|
virtual ~TContoExt() {}
|
|
};
|
|
|
|
TConto* TTab_conti::add(const TBill& c, int anno, bool scar)
|
|
{
|
|
TString80 key;
|
|
key.format("%4d%3d%3d%6ld", anno, c.gruppo(), c.conto(), c.sottoconto());
|
|
if (scar) key << "X";
|
|
TContoExt* tc = new TContoExt(c.gruppo(), c.conto(), c.sottoconto(),
|
|
c.tipo(), NULL, scar);
|
|
TAssoc_array::add(key, tc);
|
|
return tc;
|
|
}
|
|
|
|
TConto* TTab_conti::find(const TBill& c, int anno, bool scar)
|
|
{
|
|
TString80 key;
|
|
key.format("%4d%3d%3d%6ld", anno, c.gruppo(), c.conto(), c.sottoconto());
|
|
if (scar) key << "X";
|
|
TContoExt* tc = (TContoExt*)objptr(key);
|
|
return tc;
|
|
}
|
|
|
|
void TTab_conti::remove(const TBill& c, int anno, bool scar)
|
|
{
|
|
TString80 key;
|
|
key.format("%4d%3d%3d%6ld", anno, c.gruppo(), c.conto(), c.sottoconto());
|
|
if (scar) key << "X";
|
|
TAssoc_array::remove(key);
|
|
}
|
|
|
|
void TTab_conti::aggiorna_conto(const TBill& tcon,
|
|
int anno_es, const TImporto& importo, tiposal movap,
|
|
bool provv, bool somma, bool movimentato, bool scaricato)
|
|
{
|
|
TContoExt* tc = (TContoExt*)find(tcon, anno_es, scaricato);
|
|
if (tc == NULL)
|
|
tc = (TContoExt*)add(tcon, anno_es, scaricato);
|
|
|
|
const real i(somma ? importo.valore() : -importo.valore());
|
|
|
|
if (provv)
|
|
{
|
|
if (importo.sezione() == 'D')
|
|
tc->darepro() += i;
|
|
else
|
|
tc->averepro() += i;
|
|
}
|
|
else
|
|
{
|
|
if (movap == apertura)
|
|
{
|
|
if (importo.sezione() == 'D')
|
|
tc->saldo() += i;
|
|
else
|
|
tc->saldo() -= i;
|
|
}
|
|
else
|
|
{
|
|
if (movap == chiusura)
|
|
{
|
|
if (importo.sezione() == 'D')
|
|
tc->saldofin() += i;
|
|
else
|
|
tc->saldofin() -= i;
|
|
}
|
|
else
|
|
{
|
|
if (importo.sezione() == 'D')
|
|
tc->dare() += i;
|
|
else
|
|
tc->avere() += i;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// rimuovo dalla tabella il conto se dare e avere vanno a zero
|
|
if (!movimentato)
|
|
if (tc->dare().is_zero() && tc->avere().is_zero() &&
|
|
tc->saldofin().is_zero() && tc->darepro().is_zero() &&
|
|
tc->averepro().is_zero() && tc->saldo().is_zero())
|
|
remove(*tc, anno_es, scaricato);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TSaldo_agg
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TSaldo_agg::TSaldo_agg() : _anno_es(0), _data_ulmov(""), _num_ulmov(0l),
|
|
_movap(normale), _provv(FALSE), _movimentato(FALSE)
|
|
{}
|
|
|
|
void TSaldo_agg::aggiorna(const TBill& tc, const TImporto& imp, bool somma, bool scaricato)
|
|
{
|
|
_tab_conti.aggiorna_conto(tc, _anno_es, imp, _movap, _provv, somma, _movimentato, scaricato);
|
|
}
|
|
|
|
void TSaldo_agg::aggiorna(int gruppo, int conto, long sottoconto, const real& importo, char sezione,
|
|
bool somma, bool scaricato)
|
|
{
|
|
const TImporto imp(sezione, importo);
|
|
_tab_conti.aggiorna_conto(TBill(gruppo, conto, sottoconto), _anno_es, imp, _movap,
|
|
_provv, somma, _movimentato, scaricato);
|
|
}
|
|
|
|
void TSaldo_agg::reset()
|
|
{
|
|
_tab_conti.destroy();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// pulizia file saldi
|
|
//
|
|
// Scorro il file saldi per l' anno year o per tutti gli anni se year = 0
|
|
// e azzero i progressivi.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TSaldo_agg::clear_saldi(int year)
|
|
{
|
|
TLocalisamfile saldi(LF_SALDI);
|
|
|
|
set_anno_es(year);
|
|
saldi.zero();
|
|
if (anno_es() != 0)
|
|
saldi.put(SLD_ANNOES, anno_es());
|
|
|
|
TRectype last(saldi.curr());
|
|
|
|
for (saldi.read(_isgteq, _lock);
|
|
!saldi.eof() && saldi.curr() <= last;
|
|
saldi.next(_lock))
|
|
{
|
|
if (!saldi.get_bool(SLD_FLSCA))
|
|
{
|
|
saldi.remove();
|
|
}
|
|
else
|
|
{
|
|
saldi.put(SLD_FLSCA, "");
|
|
saldi.write();
|
|
saldi.put(SLD_FLSCA, "X");
|
|
saldi.read(_isequal,_unlock);
|
|
}
|
|
}
|
|
saldi.reread(_unlock);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Aggiornamento file saldi
|
|
//
|
|
// Scorro la tabella dei conti interna _tab_conti.
|
|
// Per ogni conto cerco il record su saldi, se non c'e' lo creo.
|
|
// Se c'e' gia' lo aggiorno nel seguente modo:
|
|
// GLOP
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void TSaldo_agg::registra()
|
|
{
|
|
real si, r;
|
|
char flag_salini;
|
|
TDate data_ulmov;
|
|
long num_ulmov;
|
|
TLocalisamfile saldi(LF_SALDI);
|
|
int conti = _tab_conti.items();
|
|
|
|
_tab_conti.restart();
|
|
for (int i = 0; i < conti; i++)
|
|
{
|
|
THash_object* hobj = _tab_conti.get_hashobj();
|
|
TContoExt& tcon = (TContoExt&)hobj->obj();
|
|
CHECK(tcon.ok(), "Tentativo di saldare un conto incompleto");
|
|
const int annoes = atoi(hobj->key().left(4));
|
|
|
|
saldi.zero();
|
|
saldi.put(SLD_ANNOES, annoes);
|
|
saldi.put(SLD_GRUPPO, tcon.gruppo());
|
|
saldi.put(SLD_CONTO, tcon.conto());
|
|
saldi.put(SLD_SOTTOCONTO, tcon.sottoconto());
|
|
saldi.put(SLD_FLSCA, tcon.scaricato());
|
|
|
|
bool update = TRUE;
|
|
|
|
if (saldi.read(_isequal, _lock) != NOERR)
|
|
{
|
|
saldi.zero();
|
|
saldi.put(SLD_ANNOES, atoi(hobj->key().left(4)));
|
|
saldi.put(SLD_GRUPPO, tcon.gruppo());
|
|
saldi.put(SLD_CONTO, tcon.conto());
|
|
saldi.put(SLD_SOTTOCONTO, tcon.sottoconto());
|
|
saldi.put(SLD_FLSCA, tcon.scaricato());
|
|
|
|
si = tcon.saldo();
|
|
if (si < ZERO)
|
|
{ flag_salini = 'A'; si = -si; }
|
|
else
|
|
flag_salini = 'D';
|
|
|
|
saldi.put(SLD_FLAGSALINI, flag_salini);
|
|
saldi.put(SLD_SALDO, si);
|
|
saldi.put(SLD_PDARE, tcon.dare());
|
|
saldi.put(SLD_PAVERE, tcon.avere());
|
|
saldi.put(SLD_PDAREPRO, tcon.darepro());
|
|
saldi.put(SLD_PAVEREPRO, tcon.averepro());
|
|
|
|
real sf = tcon.saldofin();
|
|
char flag_salfin = sf < ZERO ? 'A' : 'D';
|
|
if (flag_salfin == 'A') sf = -sf;
|
|
|
|
saldi.put(SLD_FLAGSALFIN, flag_salfin);
|
|
saldi.put(SLD_SALDOFIN, sf);
|
|
|
|
if (_num_ulmov != 0L) saldi.put(SLD_NUMULTMOV, _num_ulmov);
|
|
if (_data_ulmov.ok()) saldi.put(SLD_DATAULMOV, _data_ulmov);
|
|
update = saldi.write() == _isreinsert;
|
|
if (update)
|
|
saldi.read(_isequal, _lock);
|
|
}
|
|
|
|
if (update)
|
|
{
|
|
num_ulmov = saldi.get_long(SLD_NUMULTMOV);
|
|
data_ulmov = saldi.get_date(SLD_DATAULMOV);
|
|
|
|
if ((_num_ulmov != 0L) && (_num_ulmov > num_ulmov))
|
|
saldi.put(SLD_NUMULTMOV, _num_ulmov);
|
|
if ((_data_ulmov.ok()) && (_data_ulmov > data_ulmov))
|
|
saldi.put(SLD_DATAULMOV, _data_ulmov);
|
|
r = tcon.saldo();
|
|
si = saldi.get_real(SLD_SALDO);
|
|
flag_salini = saldi.get_char(SLD_FLAGSALINI);
|
|
if (r != ZERO)
|
|
{
|
|
if (flag_salini == 'A') si = r - si;
|
|
else si += r;
|
|
if (si < ZERO)
|
|
{
|
|
flag_salini = 'A'; si = -si;
|
|
}
|
|
else
|
|
flag_salini = 'D';
|
|
saldi.put(SLD_FLAGSALINI, flag_salini);
|
|
saldi.put(SLD_SALDO, si);
|
|
}
|
|
|
|
TImporto sf('D', tcon.saldofin());
|
|
char old_flag_sf = saldi.get(SLD_FLAGSALFIN)[0];
|
|
TImporto old_sf(old_flag_sf, saldi.get_real(SLD_SALDOFIN));
|
|
|
|
sf += old_sf;
|
|
sf.normalize();
|
|
saldi.put(SLD_FLAGSALFIN, sf.sezione());
|
|
saldi.put(SLD_SALDOFIN, sf.valore());
|
|
|
|
r = saldi.get_real(SLD_PDARE);
|
|
r += tcon.dare();
|
|
saldi.put(SLD_PDARE, r);
|
|
|
|
r = saldi.get_real(SLD_PAVERE);
|
|
r += tcon.avere();
|
|
saldi.put(SLD_PAVERE, r);
|
|
|
|
r = saldi.get_real(SLD_PDAREPRO);
|
|
r += tcon.darepro();
|
|
saldi.put(SLD_PDAREPRO, r);
|
|
|
|
r = saldi.get_real(SLD_PAVEREPRO);
|
|
r += tcon.averepro();
|
|
saldi.put(SLD_PAVEREPRO, r);
|
|
|
|
const int err = saldi.rewrite();
|
|
if (err != NOERR)
|
|
yesnofatal_box(FR("Errore %d nell'aggiornamento del saldo %d %d %ld"),
|
|
err, tcon.gruppo(), tcon.conto(), tcon.sottoconto());
|
|
}
|
|
|
|
// Calcolo saldo finale per controllo segno in prima nota
|
|
if (si.is_zero())
|
|
{
|
|
TLocalisamfile pcon(LF_PCON);
|
|
TRectype& curr = pcon.curr();
|
|
curr.put(PCN_GRUPPO, tcon.gruppo());
|
|
curr.put(PCN_CONTO, tcon.conto());
|
|
const int err = pcon.read();
|
|
if (err == NOERR)
|
|
{
|
|
const int indbil = curr.get_int(PCN_INDBIL);
|
|
if (indbil == 1 || indbil == 2 || indbil == 5)
|
|
{
|
|
TSaldo saldo;
|
|
si = saldo.saldofin_esprec(annoes, tcon.gruppo(), tcon.conto(), tcon.sottoconto());
|
|
if (si < ZERO)
|
|
{
|
|
flag_salini = 'A'; si = -si;
|
|
}
|
|
else
|
|
flag_salini = 'D';
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Era errore fatale
|
|
}
|
|
}
|
|
|
|
TImporto sf(flag_salini, si);
|
|
const TImporto dare('D', saldi.get_real(SLD_PDARE));
|
|
const TImporto avere('A', saldi.get_real(SLD_PAVERE));
|
|
sf += dare;
|
|
sf += avere;
|
|
sf.normalize(+1); // Rendi sempre positivo
|
|
tcon.saldo_finale() = sf;
|
|
}
|
|
}
|