root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Patch level :10.0

Browse Source 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :
contabilizzazione analitica a buon punto (manca il creatore dei movana)


git-svn-id: svn://10.65.10.50/trunk@20649 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
luca 2010-07-05 15:56:54 +00:00
parent fb11d3182e
commit 59ef1027e6
2 changed files with 489 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

591
ce/ce4400.cpp
View File

@ -1,9 +1,16 @@
#include <applicat.h>
#include <automask.h>
#include <dongle.h>
#include <modaut.h>
#include <progind.h>
#include <recarray.h>
#include <reprint.h>
#include <reputils.h>
#include "../ca/calib01.h"
#include "../ca/calib02.h"
#include "../ca/rmovana.h"
#include "../cg/cg2101.h"
#include "../cg/cglib02.h"
@ -16,6 +23,7 @@
#include "cespi.h"
#include "movam.h"
#include "movce.h"
#include "salcecms.h"
//===============================================================================================
//maschera
@ -124,8 +132,8 @@ public:
virtual int compare(const TSortable& s) const;
const TRectype& categoria() const;
const TString& descr_categoria() const;
TRigamov(const int grp, const TString& spc, const int cat)
: TRectype(LF_RMOV) { _grp = grp; _spc = spc; _cat = cat; }
TRigamov(const int grp, const TString& spc, const int cat, bool is_anal = false)
: TRectype(is_anal ? LF_RMOVANA : LF_RMOV) { _grp = grp; _spc = spc; _cat = cat; }
};
@ -153,7 +161,6 @@ int TRigamov::compare(const TSortable& s) const
cmp = _spc.compare(sc._spc);
if (cmp == 0)
cmp = _cat - sc._cat;
}
return cmp;
@ -161,25 +168,47 @@ int TRigamov::compare(const TSortable& s) const
//===============================================================================================
//Struct che serve per avere ammortamenti per categoria (Codcat|Qamm_tot|Qperse_tot)
struct TSaldo_per_codice :public TSortable
struct TSaldo_per_codice : public TSortable
{
TString4 _spc;
int _grp, _cat;
TString16 _idcespite;
real _qnor, _qant, _qacc;//, _qperse;
void add(const TRectype& rec_ammce);
bool use_pdcc() const;
virtual int compare(const TSortable& s) const;
const TRectype& categoria() const;
const TString& descr_categoria() const;
int compila_rmov(const int tipo, const int riga_nor, TArray& righe_mov, TLog_report& log, const int movdett) const;
int genera_righe(TArray& righe_mov, TLog_report& log, const int movdett) const;
int trova_quota_e_conto_CG(const int tipo, real& quota, TBill& zio, TLog_report& log) const;
int trova_quota_e_conto_CA(const int tipo, real& quota, TAnal_bill& zio, TLog_report& log) const;
int compila_rmov_CG(const int tipo, const int riga_nor, TArray& righe_mov, TLog_report& log, const int movdett) const;
int genera_righe_CG(TArray& righe_mov, TLog_report& log, const int movdett) const;
int compila_rmovana_CA(const int tipo, const int riga_nor, TArray& righe_movana, TLog_report& log,
const int movdett) const;
int genera_righe_CA(TArray& righe_movana, TLog_report& log, const int movdett) const;
TSaldo_per_codice(const int grp, const TString& spc, const int cat, const char* idcespite = "")
: _grp(grp),_spc(spc), _cat(cat), _idcespite(idcespite) {}
};
bool TSaldo_per_codice::use_pdcc() const
{
static char _use_pdcc = ' ';
if (_use_pdcc == ' ')
{
TConfig cfg = ca_config();
_use_pdcc = cfg.get_bool("UsePdcc");
}
return _use_pdcc != '\0';
}
void TSaldo_per_codice::add(const TRectype& rec_ammce)
{
//valore totale degli ammortamenti del cespite di tipo qnor,qant,qacc che trova in AMMCE
@ -215,23 +244,39 @@ int TSaldo_per_codice::compare(const TSortable& s) const
return cmp;
}
const TRectype& TSaldo_per_codice::categoria() const
{
//viene chiamato il metodo standard della ditta_cespiti con l'ultimo parametro true in modo che usi solo...
//...le categorie valide per il collegamento alla contabilita' (tabella CCC)
return ditta_cespiti().categoria(_grp, _spc, _cat, true);
}
const TString& TSaldo_per_codice::descr_categoria() const
{
TString& wrkstring = get_tmp_string();
wrkstring << _grp << ' ' << _spc << ' ' << _cat << ' ' ;
wrkstring << ditta_cespiti().categoria(_grp, _spc, _cat, false).get("S0");
return wrkstring;
}
bool str2bill(const TString& stringona, const int pos, TBill& zio)
{
const int gr = atoi(stringona.mid(pos, 3));
const int co = atoi(stringona.mid(pos+3, 3));
const int co = atoi(stringona.mid(pos + 3, 3));
if (co <= 0)
return false;
const long so = atoi(stringona.mid(pos+6, 6));
const long so = atoi(stringona.mid(pos + 6, 6));
zio.set(gr, co, so);
return true;
}
int TSaldo_per_codice::compila_rmov(const int tipo, const int riga_nor, TArray& righe_mov, TLog_report& log,
const int movdett) const
int TSaldo_per_codice::trova_quota_e_conto_CG(int tipo, real& quota, TBill& zio,
TLog_report& log) const
{
int pos = 0;
const char* field = "S1";
real quota;
switch (tipo)
{
case 1: quota = _qnor; pos = 24; break;
@ -240,11 +285,11 @@ int TSaldo_per_codice::compila_rmov(const int tipo, const int riga_nor, TArray&
default: break;
}
if (quota <= ZERO)
return -1;
return 0;
const TRectype& rec_ccc = categoria();
const TString& stringona = rec_ccc.get(field);
TBill zio;
if (!str2bill(stringona, pos, zio))
{
pos = 24;
@ -253,20 +298,116 @@ int TSaldo_per_codice::compila_rmov(const int tipo, const int riga_nor, TArray&
TString msg;
msg << TR("Manca il conto per le quote ammortamento normali della categoria ") << descr_categoria();
log.log(2, msg);
return -1;
return 0;
}
else
tipo = 1;
}
return tipo;
}
int TSaldo_per_codice::trova_quota_e_conto_CA(int tipo, real& quota, TAnal_bill& zio, TLog_report& log) const
{
//caso CA con use_pdcc
TString80 stringona;
if (use_pdcc())
{
int pos = 0;
const char* field = "S1";
switch (tipo)
{
case 1: quota = _qnor; pos = 24; break;
case 2: quota = _qant; pos = 36; break;
case 3: quota = _qacc; pos = 48; break;
default: break;
}
if (quota <= ZERO)
return 0;
const TRectype& rec_ccc = categoria();
stringona = rec_ccc.get(field).mid(pos, 12);
zio.set_conto(stringona);
if (stringona.blank())
{
pos = 24;
stringona = rec_ccc.get(field).mid(pos, 12);
if (tipo == 1 || stringona.blank())
{
TString msg;
msg << TR("Manca il conto per le quote ammortamento normali della categoria ") << descr_categoria();
log.log(2, msg);
return 0;
}
else
tipo = 1;
}
}
else //caso CA con use_pconana
{
char* field;
switch (tipo)
{
case 1: quota = _qnor; field = "S3"; break;
case 2: quota = _qant; field = "S4"; break;
case 3: quota = _qacc; field = "S5"; break;
default: break;
}
if (quota <= ZERO)
return 0;
const TRectype& rec_ccc = categoria();
stringona = rec_ccc.get(field);
if (stringona.blank())
{
stringona = rec_ccc.get("S3");
if (tipo == 1 || stringona.blank())
{
TString msg;
msg << TR("Manca il conto analitico per le quote ammortamento normali della categoria ") << descr_categoria();
log.log(2, msg);
return 0;
}
else
tipo = 1;
}
}
if (pos == 24 && riga_nor >= 0)
if (tipo > 0)
zio.set_conto(stringona);
return tipo;
}
//metodi per contabilità generale CG
//-----------------------------------
int TSaldo_per_codice::compila_rmov_CG(const int tipo, const int riga_nor, TArray& righe_mov, TLog_report& log,
const int movdett) const
{
real quota;
TBill zio;
const int tipo_trovato = trova_quota_e_conto_CG(tipo, quota, zio, log);
if (tipo_trovato <= 0)
return -1;
if (tipo_trovato == 1 && riga_nor >= 0)
{
TRectype& rmovnor = (TRectype&)righe_mov[riga_nor];
rmovnor.add(RMV_IMPORTO, quota);
return riga_nor;
}
TRigamov* rmov = new TRigamov(_grp, _spc, _cat);
rmov->put(RMV_SEZIONE, "D");
rmov->put(RMV_IMPORTO, quota);
//conto e descrizione dipendono dal livello di dettaglio stabilito nella configurazione del collegamento CG/CE
switch (movdett)
{
@ -312,33 +453,102 @@ int TSaldo_per_codice::compila_rmov(const int tipo, const int riga_nor, TArray&
//metodo di alto livello per la compilazione delle righe contabili;chiama il metodo di basso livello..
//..compila_rmov con i parametri caso x caso
int TSaldo_per_codice::genera_righe(TArray& righe_mov, TLog_report& log, const int movdett) const
int TSaldo_per_codice::genera_righe_CG(TArray& righe_mov, TLog_report& log, const int movdett) const
{
const int righe_prima = righe_mov.items();
const int riga_nor = compila_rmov(1, -1, righe_mov, log, movdett);
const int riga_ant = compila_rmov(2, riga_nor, righe_mov, log, movdett);
const int riga_acc = compila_rmov(3, riga_nor, righe_mov, log, movdett);
// const int riga_persa = compila_rmov(4, -1, righe_mov, log, movdett);
const int riga_nor = compila_rmov_CG(1, -1, righe_mov, log, movdett);
const int riga_ant = compila_rmov_CG(2, riga_nor, righe_mov, log, movdett);
const int riga_acc = compila_rmov_CG(3, riga_nor, righe_mov, log, movdett);
//const int riga_persa = compila_rmov_CG(4, -1, righe_mov, log, movdett);
const int righe_dopo = righe_mov.items();
return righe_dopo - righe_prima; //messo qui tanto per poter compilare
}
const TRectype& TSaldo_per_codice::categoria() const
//metodi per analitica CA
//-------------------------
int TSaldo_per_codice::compila_rmovana_CA(const int tipo, const int riga_nor, TArray& righe_movana, TLog_report& log,
const int movdett) const
{
//viene chiamato il metodo standard della ditta_cespiti con l'ultimo parametro true in modo che usi solo...
//...le categorie valide per il collegamento alla contabilita' (tabella CCC)
return ditta_cespiti().categoria(_grp, _spc, _cat, true);
real quota;
TAnal_bill zio;
const int tipo_trovato = trova_quota_e_conto_CA(tipo, quota, zio, log);
if (tipo_trovato <= 0)
return -1;
if (tipo_trovato == 1 && riga_nor >= 0)
{
TRectype& rmovananor = (TRectype&)righe_movana[riga_nor];
rmovananor.add(RMOVANA_IMPORTO, quota);
return riga_nor;
}
TRigamov* rmovana = new TRigamov(_grp, _spc, _cat, true);
rmovana->put(RMOVANA_SEZIONE, "D");
rmovana->put(RMOVANA_IMPORTO, quota);
//conto e descrizione dipendono dal livello di dettaglio stabilito nella configurazione del collegamento CG/CE
switch (movdett)
{
case 0: //dettaglio per categoria
rmovana->put(RMOVANA_DESCR, rmovana->descr_categoria());
break;
case 1: //dettaglio per cespite
{
const TRectype& rec_cespi = cache().get(LF_CESPI, _idcespite);
rmovana->put(RMOVANA_DESCR, rec_cespi.get(CESPI_DESC));
}
break;
case 2: //dettaglio per cespite con sottoconto=idcespite (idcespite numerico e di 6 cifre max!)
{
const TRectype& rec_cespi = cache().get(LF_CESPI, _idcespite);
rmovana->put(RMOVANA_DESCR, rec_cespi.get(CESPI_DESC));
bool ok = real::is_natural(_idcespite);
if (ok)
{
const long sottoc = atol(_idcespite);
ok = sottoc > 0 && sottoc < 1000000;
if (ok)
{
TString16 stringona = zio.conto().left(6);
stringona << _idcespite.right(6);
zio.set_conto(stringona);
ok = zio.ok();
}
}
if (!ok)
{
TString msg;
msg.format(FR("Il codice cespite %s non e' un sottoconto valido"), (const char*)_idcespite);
log.log(2, msg);
}
}
break;
default:
break;
}
rmovana->put(RMOVANA_CODCONTO, zio.conto());
return righe_movana.add(rmovana);
}
const TString& TSaldo_per_codice::descr_categoria() const
int TSaldo_per_codice::genera_righe_CA(TArray& righe_movana, TLog_report& log, const int movdett) const
{
TString& wrkstring = get_tmp_string();
wrkstring << _grp << ' ' << _spc << ' ' << _cat << ' ' ;
wrkstring << ditta_cespiti().categoria(_grp, _spc, _cat, false).get("S0");
return wrkstring;
const int righe_prima = righe_movana.items();
const int riga_nor = compila_rmovana_CA(1, -1, righe_movana, log, movdett);
const int riga_ant = compila_rmovana_CA(2, riga_nor, righe_movana, log, movdett);
const int riga_acc = compila_rmovana_CA(3, riga_nor, righe_movana, log, movdett);
const int righe_dopo = righe_movana.items();
return righe_dopo - righe_prima;
}
//===============================================================================================
//TMovimentoPN_CE
@ -456,17 +666,17 @@ class TPlus_minus : public TSaldo_per_codice
TArray _ammmv, _movam, _movce;
public:
void genera_mov_elim_ven(TConfig& config_ditta_ce, const TDate& datacomp, const TDate& datareg,
const bool definitivo, TLog_report& log) const;
void genera_mov_elim_ven(const TDate& datareg, const TDate& datacomp, const bool definitivo, TLog_report& log) const;
TPlus_minus(const int gruppo, const TString& specie, const int categoria,
const TArray& ammmv, const TArray& movam, const TArray& movce)
: TSaldo_per_codice(gruppo, specie, categoria), _ammmv(ammmv), _movam(movam), _movce(movce) {}
};
//metodo per la generazione dei movimenti dovuti a plus/minus
void TPlus_minus::genera_mov_elim_ven(TConfig& config_ditta_ce, const TDate& datacomp, const TDate& datareg,
const bool definitivo, TLog_report& log) const
void TPlus_minus::genera_mov_elim_ven(const TDate& datareg, const TDate& datacomp, const bool definitivo, TLog_report& log) const
{
//Parametri dalla maschera
//parametri da utilizzare piu' volte
TString4 codcaus;
//conti fondo, immobilizzo, sopravenienza passiva, plusvalenza, minusvalenza cespite
@ -509,6 +719,7 @@ void TPlus_minus::genera_mov_elim_ven(TConfig& config_ditta_ce, const TDate& dat
const TString& tipodoc = movce.get(MOVCE_TPDOC);
const TDate& datadoc = movce.get_date(MOVCE_DTDOC);
TConfig config_ditta_ce(CONFIG_DITTA, "ce");
if (eliminazione)
codcaus = config_ditta_ce.get("COAUEL");
else
@ -683,22 +894,28 @@ void TPlus_minus::genera_mov_elim_ven(TConfig& config_ditta_ce, const TDate& dat
class TContabilizza_ce : public TSkeleton_application
{
TContabilizza_ce_mask* _mask;
TConfig* _config_ditta_ce;
bool _has_ca;
protected:
virtual void main_loop();
virtual bool create();
virtual bool destroy();
void elabora();
void genera_mov(TArray& righe_mov, const TDate& datareg, const TDate& datacomp,
const TString& codcaus, const int movdett, const bool definitivo, TLog_report& log);
void delete_old_movs(const TDate& ini_es);
void elabora(); //metodo di alto livello per la gestione ordinata del casino
void contabilizza_CG(TAssoc_array& quote_per_codice, TLog_report& cont_cesp_log); //contabilizza ammortamenti in CG
void contabilizza_CA(TAssoc_array& anal_quote_per_codice, TLog_report& cont_cesp_log); //contabilizza ammortamenti in CA
void ordina_saldi(TAssoc_array& quote, TArray& saldi_ordinati); //prende quote e restituisce saldi_ordinati sortato
void genera_mov_CG(TArray& righe_mov, TLog_report& log); //genera movimenti CG
void genera_movana_CA(TArray& righe_movana, TLog_report& log); //genera movimenti CA
void delete_old_movs(const TDate& ini_es); //accoppa i movimenti provvisori (sia i CG che i CA collegati)
//void delete_old_movanas(const TDate& ini_es, const TString& codcaus);
public:
};
//eliminatore dei movimenti CG e CA eventualmente collegati
void TContabilizza_ce::delete_old_movs(const TDate& ini_es)
{
TMovimentoPN_CE pn;
@ -712,23 +929,47 @@ void TContabilizza_ce::delete_old_movs(const TDate& ini_es)
TCursor cur_mov (&pn, filtro, 2, &darec);
const long items = cur_mov.items();
cur_mov.freeze();
TProgind progind(items, "Eliminazione vecchi movimenti provvisori cespiti in corso...", false, true);
TProgind progind(items, "Eliminazione movimenti provvisori cespiti...", false, true);
for (cur_mov = 0; cur_mov.pos() < items; ++cur_mov)
{
progind.addstatus(1);
pn.read();
pn.remove();
TRectype& head = pn.curr();
const long numreg = head.get_long(MOV_NUMREG);
int err = pn.remove();
//rimuove anche l'eventuale movana collegato
if (_has_ca)
{
TString query;
query << "USE MOVANA KEY 3";
query << "\nFROM NUMREGCG=#NUMREGCG";
query << "\nTO NUMREGCG=#NUMREGCG";
TISAM_recordset recset(query);
recset.set_var("#NUMREGCG", numreg);
if (recset.items() > 0)
{
TAnal_mov movana(recset.cursor()->curr(LF_MOVANA));
movana.remove(recset.cursor()->file());
}
} //if(_has_ca)...
}
}
//metodo per la generazione di movimenti con righe per categoria (chiamata se movdett=0)
void TContabilizza_ce::genera_mov(TArray& righe_mov, const TDate& datareg, const TDate& datacomp, const TString& codcaus,
const int movdett, const bool definitivo, TLog_report& log)
//metodo per la generazione di movimenti contabili con righe per categoria
void TContabilizza_ce::genera_mov_CG(TArray& righe_mov, TLog_report& log)
{
//Parametri config ditta cespiti
const TString4 codcaus = _config_ditta_ce->get("COAUQU");
const int movdett = _config_ditta_ce->get_int("MOVDETT");
//Parametri maschera
const TDate fine_es = _mask->get_date(F_FINE_ES);
const TDate datareg = _mask->get_date(F_DATAREG);
const TDate datacomp = min(fine_es, datareg);
const bool definitivo = _mask->get_bool(F_PROVDEF);
//Riempie i campi della testata movimento
long numreg = get_new_numreg();
@ -817,20 +1058,82 @@ void TContabilizza_ce::genera_mov(TArray& righe_mov, const TDate& datareg, const
}
void TContabilizza_ce::genera_movana_CA(TArray& righe_movana, TLog_report& log)
{
}
void TContabilizza_ce::ordina_saldi(TAssoc_array& quote, TArray& saldi_ordinati)
{
//riempie l'array saldi_ordinati con gli elementi dell'assoc quote
FOR_EACH_ASSOC_OBJECT(quote, h, k, obj)
saldi_ordinati.add(h->remove_obj());
//accoppa l'assoc
quote.destroy();
//e ordina l'array per categorie e cespite (questo assurdo giro serve perche' l'assoc non e' ordinabile)
saldi_ordinati.sort();
}
//metodo che gestisce la creazione dei movimenti CG dovuti ad ammortamenti
void TContabilizza_ce::contabilizza_CG(TAssoc_array& quote_per_codice, TLog_report& cont_cesp_log)
{
TArray saldi_ordinati;
ordina_saldi(quote_per_codice, saldi_ordinati);
const int movdett = _config_ditta_ce->get_int("MOVDETT");
//array con le righe movimento CG
TArray righe_mov;
//riempie l'array delle righe movimento CG
FOR_EACH_ARRAY_ITEM(saldi_ordinati, riga, sldobj)
{
const TSaldo_per_codice& sld = *(const TSaldo_per_codice*)sldobj;
sld.genera_righe_CG(righe_mov, cont_cesp_log, movdett);
}
//controllo sul numero righe dell'array (serve solo per controllo al sagace programmatore...)
const int nrighemov = righe_mov.items();
//a questo punto ha l'array con le righe movimento CG completo (righe_mov); da queste righe deve costruire..
//..uno o piu' movimenti di prima nota
//In base al movdett li creera' con righe per categoria o per cespite ma con fondi per categoria
//E' un metodo semimagico!
genera_mov_CG(righe_mov, cont_cesp_log);
}
//metodo che gestisce la creazione dei movimenti CA dovuti ad ammortamenti
void TContabilizza_ce::contabilizza_CA(TAssoc_array& anal_quote_per_codice, TLog_report& cont_cesp_log)
{
TArray anal_saldi_ordinati;
ordina_saldi(anal_quote_per_codice, anal_saldi_ordinati);
const int movdett = _config_ditta_ce->get_int("MOVDETT");
//array con le righe movimento CA
TArray righe_movana;
//riempie l'array delle righe movimento CA
FOR_EACH_ARRAY_ITEM(anal_saldi_ordinati, riga, sldobj)
{
const TSaldo_per_codice& anal_sld = *(const TSaldo_per_codice*)sldobj;
anal_sld.genera_righe_CA(righe_movana, cont_cesp_log, movdett);
}
//controllo sul numero righe dell'array (serve solo per controllo al sagace programmatore...)
const int nrighmovana = righe_movana.items();
//metodo per la creazione del/dei movana analitici
genera_movana_CA(righe_movana, cont_cesp_log);
}
//metodo per gestire la successione degli eventi ad alto livello
void TContabilizza_ce::elabora()
{
// 0) Acquisizione parametri generali, eliminazione movimenti provvisori
//--------------------------------------------------------------------------------
//gettiamo un po' di parametri dalla maschera
const long codes = _mask->get_long(F_ESERCIZIO);
const TDate ini_es = _mask->get_date(F_INIZIO_ES);
const TDate fine_es = _mask->get_date(F_FINE_ES);
//deve accoppare i movimenti provvisori di prima nota da inizio esercizio ad oggi?
if (_mask->get_bool(F_KILLOLD))
delete_old_movs(ini_es);
//ragionamenti sulle date
const TDate datareg = _mask->get_date(F_DATAREG);
const TDate datacomp = min(fine_es, datareg);
//se il trasferimento e' definitivo la data di calcolo e' quella finale dell'esercizio selezionato, senno'...
//...e' quella indicata in F_DATACALC
TDate datacalc;
@ -840,32 +1143,39 @@ void TContabilizza_ce::elabora()
else
datacalc = _mask->get_date(F_DATACALC);
const TDate datareg = _mask->get_date(F_DATAREG);
const TDate datacomp = min(fine_es, datareg);
//Legge un po' di parametri dal ditta.ini che servono al tipo di calcolo
//Situazione fiscale (99,99%) o civilistica (1 suora su 1.000.000)?
const int tpamm = _config_ditta_ce->get_int("TPAMM");
//Tipo di calcolo da eseguire in base al dettaglio
const int movdett = _config_ditta_ce->get_int("MOVDETT");
//Genera movimenti plus/minus? Parametro decisivo per poter generare movimenti cg da movimenti ce
const bool mov_plusmin = _config_ditta_ce->get_bool("COPLMN");
//deve accoppare i movimenti provvisori di prima nota da inizio esercizio ad oggi?
if (_mask->get_bool(F_KILLOLD))
{
delete_old_movs(ini_es);
}
//report con log errori
TLog_report cont_cesp_log(TR("Contabilizzazione cespiti"));
cont_cesp_log.kill_duplicates();
//Legge un po' di parametri dal ditta.ini che servono al tipo di calcolo
TConfig config_ditta_ce(CONFIG_DITTA, "ce");
//Situazione fiscale (99,99%) o civilistica (1 suora su 1.000.000)?
const int tpamm = config_ditta_ce.get_int("TPAMM");
//Tipo di calcolo da eseguire in base al dettaglio
const int movdett = config_ditta_ce.get_int("MOVDETT");
//Codice causale da mettere nei movimenti generati
const TString4 codcaus = config_ditta_ce.get("COAUQU");
//Genera movimenti plus/minus? Parametro decisivo per poter generare movimenti cg da movimenti ce
const bool mov_plusmin = config_ditta_ce.get_bool("COPLMN");
//**********************************************************************************
// 1) Generazione movimenti CG da ammortamenti
//**********************************************************************************
// 1) Preparazione contabilizzazione CG/CA: ammortamenti
//----------------------------------------------------------------------
//programma vero e proprio (calcolo ammortamenti, selezione cespiti validi, trasferimento)
TISAM_recordset cespiti("USE CESPI");
const TRecnotype nrec = cespiti.items();
//Assoc_array Categoria-QammTot
TAssoc_array quote_per_codice;
TAssoc_array quote_per_codice, anal_quote_per_codice;
TArray ammo_plus_minus;
//giro su tutti i cespiti
TProgind pi(nrec, TR("Ricalcolo ammortamenti in corso..."), true, true);
for (int i = 0; cespiti.move_to(i); i++)
{
@ -888,9 +1198,13 @@ void TContabilizza_ce::elabora()
const TRectype& rec_ammce = cespite.amm_pro();
//in base al tipo di dettaglio sceglie il codice dell'assoc_array
//movdett=0 -> codice=codice categoria (assoc_array con record per categorie)
//movdett=1;2 -> codice=idcespite (assoc_array con record per cespite)
TToken_string gsc;
//movdett = 0 -> codice=codice categoria (assoc_array con record per categorie)
//movdett = 1;2 -> codice=idcespite (assoc_array con record per cespite)
//1.1) preparazione contabilizzazione CG
//----------------------------------------
TToken_string gsc;
//chiave per CG
gsc.add(gruppo); gsc.add(specie); gsc.add(codcat);
if (movdett != 0)
gsc.add(idcespite);
@ -914,42 +1228,102 @@ void TContabilizza_ce::elabora()
TPlus_minus* pm = new TPlus_minus(gruppo, specie, codcat, ammmv, movam, movce);
ammo_plus_minus.add(pm);
}
}
} //for(int i...
//1.2) preparazione contabilizzazione CA
//----------------------------------------
if (_has_ca)
{
//per prima cosa necessita dei valori da salcecms
TToken_string key;
key.add(idcespite);
key.add(codes);
TRecord_array righe_salcecms(key, LF_SALCECMS);
//se il cespite, nell'esercizio selezionato, non ha manco un record in salcecms -> si assegna la chiave..
//..di default di salcecms, che si trova nella tabella CCE dell'esercizio cespite in questione
if (righe_salcecms.rows() == 0)
{
TString4 anno;
anno << codes;
const TRectype& rec_cce = cache().get("CCE", anno);
const TString& codcdc = rec_cce.get("S2");
const TString& codcms = rec_cce.get("S3");
const TString& codfase = rec_cce.get("S4");
TRectype rec_salcecms_default(LF_SALCECMS);
rec_salcecms_default.put(SALCECMS_IDCESPITE, idcespite);
rec_salcecms_default.put(SALCECMS_CODES, codes);
rec_salcecms_default.put(SALCECMS_NRIGA, 1);
rec_salcecms_default.put(SALCECMS_CODCDC, codcdc);
rec_salcecms_default.put(SALCECMS_CODCMS, codcms);
rec_salcecms_default.put(SALCECMS_CODFASE, codfase);
rec_salcecms_default.put(SALCECMS_PERCUTIL, CENTO);
//aggiunge al record_array vuoto il record standard
righe_salcecms.add_row(rec_salcecms_default);
}
//se il record_array ha un solo elemento (99% dei casi) è inutile impazzire...
if (righe_salcecms.rows() == 1)
{
const TRectype& curr_salcecms_line = righe_salcecms.row(1);
key = gsc;
key.add(curr_salcecms_line.get(SALCECMS_CODCDC));
key.add(curr_salcecms_line.get(SALCECMS_CODCMS));
key.add(curr_salcecms_line.get(SALCECMS_CODFASE));
TSaldo_per_codice* anal_sc = (TSaldo_per_codice*)anal_quote_per_codice.objptr(key);
//se non trova il codice (categoria o cespite) lo aggiunge...
if (anal_sc == NULL)
{
anal_sc = new TSaldo_per_codice(gruppo, specie, codcat, idcespite);
quote_per_codice.add(key, anal_sc);
}
anal_sc->add(rec_ammce);
}
else //senno' impazziamo!...
{
TGeneric_distrib d_qnor(rec_ammce.get_real(AMMCE_QNOR), 2);
TGeneric_distrib d_qacc(rec_ammce.get_real(AMMCE_QACC), 2);
TGeneric_distrib d_qant(rec_ammce.get_real(AMMCE_QANT), 2);
TArray saldi_ordinati;
//riempie l'array saldi_ordinati con gli elementi dell'assoc quote_per_codice
FOR_EACH_ASSOC_OBJECT(quote_per_codice, h, k, obj)
saldi_ordinati.add(h->remove_obj());
//accoppa l'assoc
quote_per_codice.destroy();
//e ordina l'array per categorie e cespite (questo assurdo giro serve perche' l'assoc non e' ordinabile)
saldi_ordinati.sort();
//array con le righe movimento CG
TArray righe_mov;
//riempie l'array delle righe movimento CG
FOR_EACH_ARRAY_ITEM(saldi_ordinati, riga, sldobj)
{
const TSaldo_per_codice& sld = *(const TSaldo_per_codice*)sldobj;
sld.genera_righe(righe_mov, cont_cesp_log, movdett);
}
for (int i = righe_salcecms.last_row(); i > 0; i = righe_salcecms.pred_row(i))
{
const TRectype& curr_salcecms_line = righe_salcecms.row(i);
const real percutil = curr_salcecms_line.get_real(SALCECMS_PERCUTIL);
d_qnor.add(percutil);
d_qacc.add(percutil);
d_qant.add(percutil);
}
for (int i = righe_salcecms.last_row(); i > 0; i = righe_salcecms.pred_row(i))
{
const TRectype& curr_salcecms_line = righe_salcecms.row(i);
key = gsc;
key.add(curr_salcecms_line.get(SALCECMS_CODCDC));
key.add(curr_salcecms_line.get(SALCECMS_CODCMS));
key.add(curr_salcecms_line.get(SALCECMS_CODFASE));
//controllo sul numero righe dell'array (serve solo per controllo al sagace programmatore...)
const int nrighemov = righe_mov.items();
TSaldo_per_codice* anal_sc = (TSaldo_per_codice*)anal_quote_per_codice.objptr(key);
if (anal_sc == NULL)
{
anal_sc = new TSaldo_per_codice(gruppo, specie, codcat, idcespite);
anal_quote_per_codice.add(key, anal_sc);
}
anal_sc->_qnor += d_qnor.get();
anal_sc->_qacc += d_qacc.get();
anal_sc->_qant += d_qant.get();
} //for(int i...
} //else(if(righe_salcecms == 1...
} //if(_has_ca)...
//a questo punto ha l'array con le righe movimento CG completo (righe_mov); da queste righe deve costruire..
//..uno o piu' movimenti di prima nota
//In base al movdett li creera' con righe per categoria o per cespite ma con fondi per categoria
//E' un metodo semimagico!
genera_mov(righe_mov, datareg, datacomp, codcaus, movdett, definitivo, cont_cesp_log);
} //if (cespite.calc_amm(tpamm,...
} //for (int i = 0; cespiti.move_to(i); i++)...
//**********************************************************************************
// 2) Generazione movimenti CG da movimenti cespiti di vendita/eliminazione
//**********************************************************************************
// 2) Generazione movimenti CG da ammortamenti cespiti
//----------------------------------------------------------------
//contabilizzazione in CG
contabilizza_CG(quote_per_codice, cont_cesp_log);
// 3) Generazione movimenti CG da movimenti cespiti di vendita/eliminazione
//----------------------------------------------------------------------------------
//solo se in configurazione ditta cespiti e' attivo il flag di generazione movimenti plus/minus...
if (mov_plusmin)
{
@ -960,13 +1334,18 @@ void TContabilizza_ce::elabora()
FOR_EACH_ARRAY_ITEM(ammo_plus_minus, riga, pmobj)
{
const TPlus_minus& pm = *(const TPlus_minus*)pmobj;
pm.genera_mov_elim_ven(config_ditta_ce, datacomp, datareg, definitivo, cont_cesp_log);
pm.genera_mov_elim_ven(datareg, datacomp, definitivo, cont_cesp_log);
}
}
//***************************************
// 3) stampa il log degli errori
//***************************************
// 4) Generazione movimenti CA da ammortamenti cespiti
//----------------------------------------------------------
//contabilizzazione in CA
if (_has_ca)
contabilizza_CA(anal_quote_per_codice, cont_cesp_log);
// 5) stampa il log degli errori
//---------------------------------------
TReport_book book;
book.add(cont_cesp_log);
book.preview();
@ -976,11 +1355,17 @@ void TContabilizza_ce::elabora()
bool TContabilizza_ce::create()
{
_mask = new TContabilizza_ce_mask;
//chiede se ha la CA; serve per la contabilizzazione analitica
_has_ca = dongle().active(CAAUT);
//config ditta cespiti
_config_ditta_ce = new TConfig(CONFIG_DITTA, "ce");
return TSkeleton_application::create();
}
bool TContabilizza_ce::destroy()
{
delete _config_ditta_ce;
delete _mask;
return true;
}

1
ce/ce4400a.uml
View File

@ -119,6 +119,7 @@ END
DATA F_DATACALC
BEGIN
PROMPT 2 8 "Data calcolo ammortamenti "
FLAGS "A"
CHECKTYPE REQUIRED
END