root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ca/calib02.cpp
guy 5b97f21b73 Patch level : 2.2 
Files correlati     : ca3
Ricompilazione Demo : [ ]
Commento            :

Aggiunta classe TAnal_bill per gestire congiuntamente CONTO.COSTO,COMMESSA,FASE
Prima versione di alcuni report per bilancio di verifica


git-svn-id: svn://10.65.10.50/trunk@13224 c028cbd2-c16b-5b4b-a496-9718f37d4682
2005-06-27 16:35:27 +00:00

485 lines
12 KiB
C++
Executable File
Raw Blame History

#include <xvt.h>
#include "calib01.h"
#include "calib02.h"
#include "../cg/cglib01.h"
#include "../include/rdoc.h"
#include "movana.h"
#include "rmovana.h"
#include "saldana.h"
///////////////////////////////////////////////////////////
// TAnal_report
///////////////////////////////////////////////////////////
bool TAnal_report::get_usr_val(const TString& name, TVariant& var) const
{
// CODCONTO:1, CODCMS:3, FASCMS:2, ecc...
const int namelen = name.len();
if (namelen >= 6 && name[namelen-2] == ':')
{
int logicnum = 0;
if (name.starts_with("CODCONTO:"))
logicnum = LF_PCONANA; else
if (name.starts_with("CODCMS:"))
logicnum = LF_COMMESSE; else
if (name.starts_with("CODCOSTO:"))
logicnum = LF_CDC; else
if (name.starts_with("FASCMS:"))
logicnum = LF_FASI;
if (logicnum > 0)
{
const TMultilevel_code_info& mci = ca_multilevel_code_info(logicnum);
const int level = name[namelen-1]-'1';
if (level < mci.levels())
{
TString16 fldname = name; fldname.cut(namelen-2);
TFieldref field = mci.fieldref(level);
field.set_name(fldname);
field.set_from(0);
fldname.cut(0) << field; // Trasformo il TFieldref in stringa!
get_record_field(fldname, var);
}
else
var.set_null();
return true;
}
}
return TReport::get_usr_val(name, var);
}
size_t TAnal_report::get_usr_words(TString_array& words) const
{
TReport::get_usr_words(words);
const char* const name[] =
{
"CA_FORMAT_COSTO",
"CA_FORMAT_COMMESSA",
"CA_FORMAT_FASE",
"CA_FORMAT_CONTO",
"CA_FORMAT_CMSCDC",
NULL
};
((TAnal_report*)this)->_first_msg = words.items(); // Calcola il primo numero disponibile
size_t i;
for (i = 0; name[i] != NULL; i++)
words.add(name[i]);
return words.items();
}
void TAnal_report::msg_format(int logicnum, TVariant_stack& stack)
{
const TString& str_in = curr_field()->get().as_string();
if (str_in.not_empty())
{
TString80 separator = " ";
if (stack.items() > 0)
separator = stack.pop().as_string();
if (separator.not_empty())
{
const TMultilevel_code_info& mci = ca_multilevel_code_info(logicnum);
TString str_out;
for (int i = 0; i < mci.levels(); i++)
{
const TFieldref& fld = mci.fieldref(i);
const TString& str = str_in.sub(fld.from(), fld.to());
if (str.not_empty())
{
if (i > 0) str_out << separator;
str_out << str;
}
else
break;
}
curr_field()->set(str_out);
}
}
}
void TAnal_report::msg_format_costo (TVariant_stack& stack)
{ msg_format(LF_CDC, stack); }
void TAnal_report::msg_format_commessa(TVariant_stack& stack)
{ msg_format(LF_COMMESSE, stack); }
void TAnal_report::msg_format_fase (TVariant_stack& stack)
{ msg_format(LF_FASI, stack); }
void TAnal_report::msg_format_conto (TVariant_stack& stack)
{ msg_format(LF_PCONANA, stack); }
void TAnal_report::msg_format_commessa_costo(TVariant_stack& stack)
{
const TMultilevel_code_info& main_info = ca_multilevel_code_info(LF_FASI);
msg_format(main_info.parent(), stack);
}
bool TAnal_report::execute_usr_word(unsigned int opcode, TVariant_stack& stack)
{
if (opcode < _first_msg)
return TReport::execute_usr_word(opcode, stack);
opcode -= _first_msg;
switch (opcode)
{
case 0 : msg_format_costo(stack); break;
case 1 : msg_format_commessa(stack); break;
case 2 : msg_format_fase(stack); break;
case 3 : msg_format_conto(stack); break;
case 4 : msg_format_commessa_costo(stack); break;
default: break;
}
return true;
}
///////////////////////////////////////////////////////////
// TAnal_bill
///////////////////////////////////////////////////////////
int TAnal_bill::compare(const TSortable& s) const
{
const TAnal_bill& b = (const TAnal_bill&)s;
int cmp = _conto.compare(b._conto);
if (cmp == 0)
{
cmp = _costo.compare(b._costo);
if (cmp == 0)
{
cmp = _commessa.compare(b._commessa);
if (cmp == 0)
cmp = _fase.compare(b._fase);
}
}
return cmp;
}
bool TAnal_bill::match(const TAnal_bill& b) const
{
if (b._conto.not_empty() && _conto != b._conto)
return false;
if (b._costo.not_empty() && _costo != b._costo)
return false;
if (b._commessa.not_empty() && _commessa != b._commessa)
return false;
if (b._fase.not_empty() && _fase != b._fase)
return false;
return true;
}
void TAnal_bill::set_conto(const char* c)
{ _conto = c; _conto.trim(); }
void TAnal_bill::set_costo(const char* c)
{ _costo = c; _costo.trim(); }
void TAnal_bill::set_commessa(const char* c)
{ _commessa = c; _commessa.trim(); }
void TAnal_bill::set_fase(const char* c)
{ _fase = c; _fase.trim(); }
const TString& TAnal_bill::conto() const
{ return _conto; }
const TString& TAnal_bill::costo() const
{ return _costo; }
const TString& TAnal_bill::commessa() const
{ return _commessa; }
const TString& TAnal_bill::fase() const
{ return _fase; }
void TAnal_bill::reset()
{
_conto = _costo = _commessa = _fase = "";
}
bool TAnal_bill::get(const TRectype& rec)
{
bool ok = true;
reset();
switch(rec.num())
{
case LF_RMOVANA:
set_conto(rec.get(RMOVANA_CODCONTO));
set_costo(rec.get(RMOVANA_CODCCOSTO));
set_commessa(rec.get(RMOVANA_CODCMS));
set_fase(rec.get(RMOVANA_CODFASE));
break;
case LF_RIGHEDOC:
set_commessa(RDOC_CODCMS);
set_fase(RDOC_FASCMS);
break;
case LF_SALDANA:
set_conto(rec.get(SALDANA_CONTO));
set_costo(rec.get(SALDANA_COSTO));
set_commessa(rec.get(SALDANA_COMMESSA));
set_fase(rec.get(SALDANA_FASE));
break;
default:
ok = false;
break;
}
return ok;
}
TAnal_bill::TAnal_bill()
{ }
TAnal_bill::TAnal_bill(const TAnal_bill& b)
{
set_conto(b.conto());
set_costo(b.costo());
set_commessa(b.commessa());
set_fase(b.fase());
}
TAnal_bill::TAnal_bill(const char* conto, const char* costo, const char* commessa, const char* fase)
{
set_conto(conto);
set_costo(costo);
set_commessa(commessa);
set_fase(fase);
}
TAnal_bill::TAnal_bill(const TRectype& rec)
{
get(rec);
}
///////////////////////////////////////////////////////////
// TAnal_balance
///////////////////////////////////////////////////////////
class TAnal_balance : public TObject
{
public:
TImporto saldo_fine_anno(const TAnal_bill& bill, int annofin, word tipo) const;
bool saldo_movimenti(const TAnal_bill& bill, const TDate& dal, const TDate& al, word tipo, TSaldanal& s) const;
bool saldi(const TAnal_bill& bill, const TDate& dal, const TDate& al, word tipo, TSaldanal& s) const;
};
TImporto TAnal_balance::saldo_fine_anno(const TAnal_bill& b, int anno, word tipo) const
{
TImporto saldo;
if (anno > 0)
{
TString query, select;
if (b.costo().not_empty())
select << "(CODCOSTO=='" << b.costo() << "')";
if (b.commessa().not_empty())
{
if (select.not_empty()) select << "&&";
select << "(CODCMS=='" << b.commessa() << "')";
}
if (b.fase().not_empty())
{
if (select.not_empty()) select << "&&";
select << "(FASCMS=='" << b.fase() << "')";
}
if (b.conto().not_empty())
{
if (select.not_empty()) select << "&&";
select << "(CONTO=='" << b.conto() << "')";
}
query << "USE SALDANA";
if (select.not_empty())
query << " SELECT " << select;
if (anno > 0)
query << "\nTO ANNO=" << anno << '\n';
TISAM_recordset saldini(query);
for (int i = 0; i < saldini.items(); i++)
{
if (tipo & 1)
{
const char sez = saldini.get(SALDANA_SEZIONE).as_string()[0];
const real imp = saldini.get(SALDANA_SALDO).as_real();
saldo += TImporto(sez, imp);
}
if (tipo & 2)
{
const char sez = saldini.get(SALDANA_SEZIONEP).as_string()[0];
const real imp = saldini.get(SALDANA_SALDOP).as_real();
saldo += TImporto(sez, imp);
}
if (tipo & 4)
{
const char sez = saldini.get(SALDANA_SEZIONEV).as_string()[0];
const real imp = saldini.get(SALDANA_SALDOV).as_real();
saldo += TImporto(sez, imp);
}
}
saldo.normalize();
}
return saldo;
}
bool TAnal_balance::saldo_movimenti(const TAnal_bill& b,
const TDate& dal, const TDate& al, word tipo,
TSaldanal& s) const
{
TDate dataini;
if (dal.ok())
{
TEsercizi_contabili esc;
const int annoprec = esc.date2prevesc(dal);
if (annoprec > 0)
dataini = esc[annoprec].fine()+1L;
}
TString query, select;
if (b.costo().not_empty())
{
if (select.not_empty())
select << "&&";
select << "(CODCOSTO==\"" << b.costo() << "\")";
}
if (b.commessa().not_empty())
{
if (select.not_empty())
select << "&&";
select << "(CODCMS==\"" << b.commessa() << "\")";
}
if (b.fase().not_empty())
{
if (select.not_empty())
select << "&&";
select << "(CODFASE==\"" << b.fase() << "\")";
}
query << "USE RMOVANA KEY 2\n";
if (select.not_empty())
query << "SELECT " << select << "\n";
// Faccio la join solo se mi serve il tipo movimento in testata
if (tipo != 0 && tipo != 7)
query << "JOIN MOVANA INTO NUMREG==NUMREG\n";
query << "FROM CODCONTO=" << b.conto();
if (dataini.ok())
query << " DATACOMP=" << dataini;
query << "\n";
query << "TO CODCONTO=" << b.conto();
if (al.ok())
query << " DATACOMP=" << al;
query << "\n";
TISAM_recordset rmovana(query);
s._movimentato = false;
for (int i = 0; i < rmovana.items(); i++)
{
rmovana.move_to(i);
// Controllo il tipo movimento solo se necessario
if (tipo != 0 && tipo != 7)
{
const char tipomov = rmovana.get("107.TIPOMOV").as_string()[0];
int ntipomov = 0;
if (tipomov == 'P')
ntipomov = 2; else
if (tipomov == 'V')
ntipomov = 4;
else
ntipomov = 1;
if ((ntipomov & tipo) == 0)
continue;
}
const TDate data = rmovana.get(RMOVANA_DATACOMP).as_date();
const TImporto imp(rmovana.get(RMOVANA_SEZIONE).as_string()[0],
rmovana.get(RMOVANA_IMPORTO).as_real());
if (data >= dal)
{
if (imp.sezione() == 'D')
s._dare += imp;
else
s._avere += imp;
s._movimentato = true;
}
else
{
s._ini += imp;
}
}
s._ini.normalize();
s._fin = s._ini;
s._fin += s._dare;
s._fin += s._avere;
s._fin.normalize();
return s._movimentato;
}
bool TAnal_balance::saldi(const TAnal_bill& bill,
const TDate& dal, const TDate& al, word tipo,
TSaldanal& s) const
{
TEsercizi_contabili esc;
const int annoprec = esc.date2prevesc(dal);
s._ini = saldo_fine_anno(bill, annoprec, tipo);
return saldo_movimenti(bill, dal, al, tipo, s);
}
////////////////////////////////////////////////////////
// TSaldi_cache
////////////////////////////////////////////////////////
class TSaldi_cache : private TCache
{
TAnal_balance _bal;
protected:
virtual TObject* key2obj(const char* key);
public:
const TSaldanal& saldo(const TAnal_bill& bill, const TDate& dal, const TDate& al, word tipi = 0x1);
TSaldi_cache() : TCache(3883) { }
};
TObject* TSaldi_cache::key2obj(const char* key)
{
TSaldanal* s = new TSaldanal;
TToken_string tok(key);
const TAnal_bill bill(tok.get(0), tok.get(1), tok.get(2), tok.get(3));
const TDate dal = tok.get(4); // Le get precedenti avvengono in ordine inverso!
const TDate al = tok.get();
const int tipo = tok.get_int();
s->_movimentato = _bal.saldi(bill, dal, al, tipo, *s);
return s;
}
const TSaldanal& TSaldi_cache::saldo(const TAnal_bill& bill, const TDate& dal, const TDate& al, word tipi)
{
TToken_string key;
key.add(bill.conto(), 0);
key.add(bill.costo(), 1);
key.add(bill.commessa(), 2);
key.add(bill.fase(), 3);
key.add(dal, 4);
key.add(al, 5);
key.add(tipi, 6);
return *(const TSaldanal*)objptr(key);
}
const TSaldanal& ca_saldo(const TAnal_bill& bill, const TDate& dal, const TDate& al, word tipi)
{
static TSaldi_cache* cache = NULL;
if (cache == NULL)
cache = new TSaldi_cache;
return cache->saldo(bill, dal, al, tipi);
}
Reference in New Issue View Git Blame Copy Permalink