root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ri/rilib01.cpp
alex 623b930fbf Patch level : 10,0 nopatch 
Files correlati     : ri0.exe
Ricompilazione Demo : [ ]
Commento            :


Riclassificazioni


git-svn-id: svn://10.65.10.50/branches/R_10_00@20790 c028cbd2-c16b-5b4b-a496-9718f37d4682
2010-08-23 07:50:06 +00:00

1073 lines
26 KiB
C++
Executable File
Raw Blame History

#include <diction.h>
#include <lffiles.h>
#include <causali.h>
#include <clifo.h>
#include <mov.h>
#include <pconti.h>
#include <rmov.h>
#include <riclpdc.h>
#include <saldi.h>
#include <tabutil.h>
#include "../cg/cglib02.h"
#include "rilib01.h"
class TSaldo_ricl : public TSaldo
{
TArray _progdare;
TArray _progavere;
public:
const real& saldo_periodo(int g, int c, long s, const TArray & dal, const TArray& al, bool provv);
const real& progdare(int p) const { return (real &) _progdare[p];}
const real& progavere(int p) const { return (real &) _progavere[p];}
TSaldo_ricl() { }
virtual ~TSaldo_ricl() {}
};
const real& TSaldo_ricl::saldo_periodo(int g, int c, long s, const TArray & dal, const TArray & al, bool provv)
{
const int nper = al.items();
const TDate & da = (const TDate &) dal[0];
const TDate & a = (const TDate &) al[nper - 1];
saldoini_ref() = ZERO;
saldo_ref() = ZERO;
prgdare_ref() = ZERO;
prgavere_ref() = ZERO;
set_movimentato(false);
_progdare.destroy();
_progavere.destroy();
for (int p = 0; p < nper; p++)
{
_progdare.add(new real);
_progavere.add(new real);
}
TEsercizi_contabili es;
const int codes = es.date2esc(da);
const TDate inizio = es.esercizio(codes).inizio();
TString80 key; key.format("%04d| |%d|%d|%ld", codes, g, c, s);
const TRectype& saldo = cache().get(LF_SALDI, key);
key.format("%d|%d", g, c);
const int indbil = atoi(cache().get(LF_PCON, key, PCN_INDBIL));
if ((indbil <= 2 || indbil == 5) && saldo.get_real(SLD_SALDO).is_zero())
saldoini_ref() = saldofin_esprec(codes,g,c,s);
else
{
if (saldo.get_char(SLD_FLAGSALINI) == 'A')
saldoini_ref() = -saldo.get_real(SLD_SALDO);
else
saldoini_ref() = saldo.get_real(SLD_SALDO);
}
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();
if (items > 0)
{
cur.freeze();
TProgind* p = NULL;
if (items > 100) // E' proprio utile la progind?
{
TString80 prompt;
prompt.format(FR("Calcolo saldo del conto %d.%d.%ld"), g, c, s);
p = new TProgind(items, prompt, false);
}
for (cur = 0L; cur.pos() < items; ++cur)
{
if (p != NULL)
p->addstatus(1L);
const long num_reg = rmov.get_long(RMV_NUMREG);
const real importo = rmov.get_real(RMV_IMPORTO);
if (!importo.is_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 TRectype& mov = cache().get(LF_MOV, num_reg);
const TDate & datacomp = mov.get_date(MOV_DATACOMP);
const TRectype& cau = cache().get(LF_CAUSALI, mov.get(MOV_CODCAUS));
if ((provv || !mov.get_bool(MOV_PROVVIS)) && cau.get(CAU_MOVAP).blank())
{
if (datacomp >= da && datacomp <= a)
{
int per = 0;
set_movimentato();
for (per = 0; per < nper; per++)
if (datacomp <= (const TDate &) al[per])
break;
if (sezione == 'D')
{
prgdare_ref() += importo;
if (per < nper)
((real&)_progdare[per]) += importo;
}
else
{
prgavere_ref() += importo;
if (per < nper)
((real&)_progavere[per]) += importo;
}
}
else
if (datacomp >= inizio && datacomp < da)
{
if (sezione == 'D')
saldoini_ref() += importo;
else
saldoini_ref() -= importo;
}
}
}
}
if (p != NULL)
delete p;
}
saldo_ref() = saldoini_ref() + prgdare_ref() - prgavere_ref();
return saldo_ref();
}
class TSaldo_periodo : public TObject
{
TArray _saldo_iniziale;
TArray _prog_dare;
TArray _prog_avere;
TArray _saldo;
bool _movimentato;
public:
TVariant & saldoini(int nper) { return (TVariant &) _saldo_iniziale[nper]; }
TVariant & pavere(int nper) { return (TVariant &) _prog_avere[nper]; }
TVariant & pdare(int nper) { return (TVariant &) _prog_dare[nper]; }
TVariant & saldo(int nper) { return (TVariant &) _saldo[nper]; }
const TVariant & saldoini(int nper) const { return (TVariant &) _saldo_iniziale[nper]; }
const TVariant & pavere(int nper) const { return (TVariant &) _prog_avere[nper]; }
const TVariant & pdare(int nper) const { return (TVariant &) _prog_dare[nper]; }
const TVariant & saldo(int nper) const { return (TVariant &) _saldo[nper]; }
const int nper() const { return _saldo.items(); }
void update(char tcf, int gruppo, int conto, long sottoconto, bool provv, const TArray & from, const TArray & to);
bool is_zero() const;
bool movimentato() const { return _movimentato;}
const TSaldo_periodo & operator +=(const TSaldo_periodo & sp);
const TSaldo_periodo & operator -=(const TSaldo_periodo & sp);
TSaldo_periodo(int items);
TSaldo_periodo(char tcf, int gruppo, int conto, long sottoconto, bool provv, const TArray & from, const TArray & to);
virtual ~TSaldo_periodo() {}
};
void TSaldo_periodo::update(char tcf, int gruppo, int conto, long sottoconto, bool provv, const TArray & from, const TArray & to)
{
TSaldo_ricl sal;
const int nper = from.items();
_saldo_iniziale.destroy();
_prog_avere.destroy();
_prog_dare.destroy();
_saldo.destroy();
_movimentato = false;
for (int i = 0; i < nper; i++)
{
_saldo_iniziale.add(new TVariant(ZERO));
_prog_avere.add(new TVariant(ZERO));
_prog_dare.add(new TVariant(ZERO));
_saldo.add(new TVariant(ZERO));
}
if (sottoconto == 0L) // E' un conto
{
if (tcf > ' ')
{
TRelation relcf(LF_CLIFO);
TRectype & clifo = relcf.curr();
clifo.put(CLI_TIPOCF, tcf);
TCursor cur(&relcf, "", 1, &clifo, &clifo);
const TRecnotype items = cur.items();
cur.freeze();
TString prompt = tcf == 'C' ? TR("Ricalcolo saldi Clienti") : TR("Ricalcolo saldi Fornitori");
prompt << ' ' << gruppo << ' ' << conto;
TProgind p(items, prompt, FALSE);
for (cur = 0L; !p.iscancelled() && cur.pos() < items; ++cur)
{
const long sottocontocli = clifo.get_long(CLI_CODCF);
sal.saldo_periodo(gruppo, conto, sottocontocli, from, to, provv);
real sld = sal.saldoini();
_movimentato |= sal.movimentato();
for (int i = 0; i < nper; i++)
{
saldoini(i) += sld;
pavere(i) += sal.progavere(i);
pdare(i) += sal.progdare(i);
sld += sal.progdare(i) - sal.progavere(i);
saldo(i) += sld;
}
p.addstatus(1L);
}
}
}
else
{
sal.saldo_periodo(gruppo, conto, sottoconto, from, to, provv);
real sld = sal.saldoini();
_movimentato = sal.movimentato();
for (int i = 0; i < nper; i++)
{
saldoini(i) = sld;
pavere(i) = sal.progavere(i);
pdare(i) = sal.progdare(i);
sld += sal.progdare(i) - sal.progavere(i);
saldo(i) = sld;
}
}
}
bool TSaldo_periodo::is_zero() const
{
const int items = nper();
for (int i = 0; i < items; i++)
{
if (!saldoini(i).as_real().is_zero())
return false;
if (!pavere(i).as_real().is_zero())
return false;
if (!pdare(i).as_real().is_zero())
return false;
if (!saldo(i).as_real().is_zero())
return false;
}
return true;
}
const TSaldo_periodo & TSaldo_periodo::operator +=(const TSaldo_periodo & sp)
{
const int items_to_add = min(nper(), sp.nper());
for (int i = 0; i < items_to_add; i++)
{
saldoini(i) += sp.saldoini(i);
pavere(i) += sp.pavere(i);
pdare(i) += sp.pdare(i);
saldo(i) += sp.saldo(i);
}
_movimentato |= sp.movimentato();
return *this;
}
const TSaldo_periodo & TSaldo_periodo::operator -=(const TSaldo_periodo & sp)
{
const int items_to_sub = min(nper(), sp.nper());
for (int i = 0; i < items_to_sub; i++)
{
saldoini(i) += sp.saldoini(i);
pavere(i) += sp.pavere(i);
pdare(i) += sp.pdare(i);
saldo(i) += sp.saldo(i);
}
_movimentato |= sp.movimentato();
return *this;
}
TSaldo_periodo::TSaldo_periodo(int items)
{
_saldo_iniziale.destroy();
_prog_avere.destroy();
_prog_dare.destroy();
_saldo.destroy();
for (int i = 0; i < items; i++)
{
_saldo_iniziale.add(new TVariant(ZERO));
_prog_avere.add(new TVariant(ZERO));
_prog_dare.add(new TVariant(ZERO));
_saldo.add(new TVariant(ZERO));
}
_movimentato = false;
}
TSaldo_periodo::TSaldo_periodo(char tcf, int gruppo, int conto, long sottoconto, bool provv, const TArray & from, const TArray & to)
{
update(tcf, gruppo, conto, sottoconto, provv, from, to);
_movimentato = false;
}
class TSaldi_recordset_data :public TObject
{
TAssoc_array _saldi;
int _nper;
TArray _from;
TArray _to;
bool _provv;
TString16 _codricl;
TString8 _table;
public:
TAssoc_array & saldi() { return _saldi; }
int & nper() { return _nper; }
TArray & from() { return _from; }
TArray & to() { return _to; }
bool & provv() { return _provv; }
TString & codricl() { return _codricl; }
TString & table() { return _table; }
TSaldi_recordset_data() : _nper(0), _provv(0) { }
virtual ~TSaldi_recordset_data() { }
};
HIDDEN TArray __shuttle;
HIDDEN int __curr_id = -1;
HIDDEN TSaldi_recordset_data & saldi_data() { return *(TSaldi_recordset_data *) __shuttle.objptr(__curr_id); }
HIDDEN TSaldi_recordset_data & saldi_data(int id) { __curr_id = id; return *(TSaldi_recordset_data *) __shuttle.objptr(id); }
const TSaldo_periodo & saldo_periodo_conto(char tcf, int gruppo, int conto, long sottoconto)
{
TSaldi_recordset_data & data = saldi_data();
TToken_string key;
key.add(gruppo);
key.add(conto);
key.add(sottoconto);
TSaldo_periodo * values = (TSaldo_periodo *) data.saldi().objptr(key);
if (values == NULL)
{
if (sottoconto > 0L || tcf > ' ')
values = new TSaldo_periodo(tcf, gruppo, conto, sottoconto, data.provv(), data.from(), data.to());
else
values = new TSaldo_periodo(data.from().items());
data.saldi().add(key, values);
}
return * values;
}
const TSaldo_periodo & saldo_periodo_conto(int id, char tcf, int gruppo, int conto, long sottoconto)
{
__curr_id = id;
return saldo_periodo_conto(tcf, gruppo, conto, sottoconto);
}
const TSaldo_periodo & saldo_periodo_ricl(const char * codricl, const char *cod)
{
TSaldi_recordset_data & data = saldi_data();
TSaldo_periodo * values = (TSaldo_periodo *) data.saldi().objptr(cod);
if (values == NULL)
{
values = new TSaldo_periodo(data.nper());
TString query ;
TString fromto;
query <<"USE " << LF_RICLPDC << " KEY 3\n";
fromto << RICLPDC_TIPORIC << "=" << codricl << " " << RICLPDC_CODICE << "=" << cod;
query << "FROM " << fromto << "\nTO " << fromto << "\n";
TISAM_recordset ricl(query);
for (bool ok = ricl.move_first(); ok ; ok = ricl.move_next())
{
const int gruppo = ricl.get(PCN_GRUPPO).as_int();
const int conto = ricl.get(PCN_CONTO).as_int();
const long sottoconto = ricl.get(PCN_SOTTOCONTO).as_int();
query = "USE "; query << LF_PCON << "\n";
fromto = PCN_GRUPPO; fromto << "=" << gruppo;
if (conto > 0)
fromto << " " << PCN_CONTO << "=" << conto;
if (sottoconto > 0)
fromto << " " << PCN_SOTTOCONTO << "=" << sottoconto;
query << "FROM " << fromto << "\nTO " << fromto << "\n";
TISAM_recordset conti(query);
for (bool ok = conti.move_first(); ok ; ok = conti.move_next())
{
const int gruppoc = conti.get(PCN_GRUPPO).as_int();
const int contoc = conti.get(PCN_CONTO).as_int();
const long sottocontoc = conti.get(PCN_SOTTOCONTO).as_int();
const char tcf = conti.get(PCN_TMCF).as_string()[0];
TSaldo_periodo s(tcf, gruppoc, contoc, sottocontoc, data.provv(), data.from(), data.to());
*values += s;
}
}
data.saldi().add(cod, values);
}
return * values;
}
const TSaldo_periodo & saldo_periodo_ricl(int id, const char * codricl, const char *cod)
{
TSaldi_recordset_data & data = saldi_data(id);
return saldo_periodo_ricl(codricl, cod);
}
const int TSaldi_conti_recordset::nper() const
{
return saldi_data(_id).nper();
}
const TDate & TSaldi_conti_recordset::from(int n) const
{
return n < nper() ? (const TDate &) saldi_data(_id).from()[n] : botime ;
}
const TDate & TSaldi_conti_recordset::to(int n) const
{
return n < nper() ? (const TDate &) saldi_data(_id).to()[n] : botime ;
}
bool TSaldi_conti_recordset::provv() const
{
return saldi_data(_id).provv();
}
void TSaldi_conti_recordset::requery()
{
saldi_data(_id).saldi().destroy();
TISAM_recordset::requery();
}
void TSaldi_conti_recordset::set_custom_columns()
{
TRecordset_column_info c;
c._type = _realfld;
c._width = 18;
for (int i = 0; i < nper(); i++)
{
if (_sel_columns > 0)
{
c._name.format("SALDOINI[%d]", i);
add_column_info(c);
c._name.format("PDARE[%d]", i);
add_column_info(c);
c._name.format("PAVERE[%d]", i);
add_column_info(c);
}
c._name.format("SALDO[%d]", i);
add_column_info(c);
}
}
HIDDEN bool non_zero(const TRelation * r)
{
TLocalisamfile & pcon = r->lfile(LF_PCON);
const char tcf = pcon.get_char(PCN_TMCF);
const int gruppo = pcon.get_int(PCN_GRUPPO);
const int conto = pcon.get_int(PCN_CONTO);
const long sottoconto = pcon.get_long(PCN_SOTTOCONTO);
const TSaldo_periodo & s = saldo_periodo_conto(tcf, gruppo, conto, sottoconto);
return s.movimentato() || !s.is_zero();
}
TCursor* TSaldi_conti_recordset::cursor() const
{
bool new_cursor = !valid_cursor();
TCursor * c = TISAM_recordset::cursor();
if (new_cursor)
{
if (!_all)
c->set_filterfunction(non_zero);
((TSaldi_conti_recordset *) this)->set_custom_columns();
}
return c;
}
const TSaldo_periodo & TSaldi_conti_recordset::saldo_periodo()
{
const int gruppo = get(PCN_GRUPPO).as_int();
const int conto = get(PCN_CONTO).as_int();
const long sottoconto = get(PCN_SOTTOCONTO).as_int();
char tcf = get(PCN_TMCF).as_string()[0];
return saldo_periodo_conto(tcf, gruppo, conto, sottoconto);
}
const TVariant& TSaldi_conti_recordset::get_field(int logic, const char* field) const
{
const TString80 fname(field);
if (_sel_columns > 0)
{
if (fname.starts_with("SALDOINI"))
return ((TSaldi_conti_recordset *)this)->saldo_periodo().saldoini(atoi(fname.mid(9)));
else
if (fname.starts_with("PAVERE"))
return ((TSaldi_conti_recordset *)this)->saldo_periodo().pavere(atoi(fname.mid(7)));
else
if (fname.starts_with("PDARE"))
return ((TSaldi_conti_recordset *)this)->saldo_periodo().pdare(atoi(fname.mid(6)));
}
if (fname.starts_with("SALDO"))
return ((TSaldi_conti_recordset *)this)->saldo_periodo().saldo(atoi(fname.mid(6)));
else
if (fname.starts_with("INDBIL"))
{
TVariant & var = get_tmp_var();
TString16 key; key.format("%ld|%ld", get(PCN_GRUPPO).as_int(), get(PCN_CONTO).as_int());
const int indbil = atoi(cache().get(LF_PCON, key, PCN_INDBIL));
var = indbil;
return var;
}
return TISAM_recordset::get_field(logic, field);
}
void TSaldi_conti_recordset::set_fromto()
{
TSaldi_recordset_data & data = saldi_data(_id);
TDate dal = (TDate &) data.from()[0];
data.from().destroy();
if (data.nper() <= 0)
data.nper() = 1;
if (dal.ok())
{
const TRectype & per = cache().get("&PER", _codper);
for (int i = 0; i < data.nper(); i++)
{
TDate al = dal;
al += per.get_int("I0");
al += per.get_int("I1") * 7;
al.addmonth(per.get_int("I2"));
al.addyear(per.get_int("I3"));
if (al > dal)
--al;
else
al = dal;
data.from().add(dal);
data.to().add(al);
dal = ++al;
}
}
}
TSaldi_conti_recordset::TSaldi_conti_recordset(const char * codper, int nper, const TDate & dal, int sel_columns, bool provv, bool all,
const TString& sql)
: TISAM_recordset(sql), _codper(codper), _sel_columns(sel_columns), _all(all)
{
_id = __shuttle.add(new TSaldi_recordset_data);
TSaldi_recordset_data & data = saldi_data(_id);
data.nper() = nper;
data.provv() = provv;
data.from().destroy();
data.to().destroy();
data.from().add(dal);
set_fromto();
if (sql.blank())
{
TString query("USE ");
query << LF_PCON;
query << "\nDISPLAY \"Gruppo\" GRUPPO\nDISPLAY \"Conto\" CONTO\nDISPLAY \"Sottoconto\" SOTTOCONTO\nDISPLAY \"Descrizione\" DESCR\nDISPLAY \"Indicatore Bil.\" INDBIL\n";
set(query);
}
else
{
const int p = sql.find("RICLCG");
if (p > 0)
{
TString query(sql.left(p));
query << LF_PCON << sql.mid(p + 6);
set(query);
}
}
}
TSaldi_conti_recordset::TSaldi_conti_recordset(const TMask& m, const TString& sql) : TISAM_recordset(sql)
{
_id = __shuttle.add(new TSaldi_recordset_data);
TSaldi_recordset_data & data = saldi_data(_id);
const int items = m.fields();
data.from().destroy();
data.to().destroy();
_codper.cut(0);
_all = true;
_sel_columns = 0;
for (short i = 0; i < items; i++)
{
const TMask_field &f = m.fld(i);
const TFieldref* fld = f.field();
if (fld != NULL)
{
TString80 fldname=fld->name();
if (fldname.starts_with("PER"))
_codper = f.get();
else
if (fldname.starts_with("NPER"))
data.nper() = f.get_long();
else
if (fldname.starts_with("DAL"))
data.from().add(new TDate(f.get()), 0);
else
if (fldname.starts_with("PROVV"))
data.provv() = f.get().full();
else
if (fldname.starts_with("ALL"))
_all = f.get().full();
else
if (fldname.starts_with("COLTYPE"))
_sel_columns = atoi(f.get());
}
}
set_fromto();
if (sql.blank())
{
TString query("USE ");
query << LF_PCON;
query << "\nDISPLAY \"Gruppo\" GRUPPO\nDISPLAY \"Conto\" CONTO\nDISPLAY \"Sottoconto\" SOTTOCONTO\nDISPLAY \"Descrizione\" DESCR\nDISPLAY \"Indicatore Bil.\" INDBIL\n";
set(query);
}
else
{
const int p = sql.find("RICLCG");
if (p > 0)
{
TString query(sql.left(p));
query << LF_PCON << sql.mid(p + 6);
set(query);
}
}
}
TSaldi_conti_recordset::~TSaldi_conti_recordset()
{
__shuttle.destroy(_id);
}
void TSaldi_ricl_recordset::set_custom_columns()
{
TRecordset_column_info c;
c._type = _longfld;
c._name = "INDBIL";
c._width = 1;
add_column_info(c);
c._type = _realfld;
c._width = 18;
for (int i = 0; i < nper(); i++)
{
if (sel_columns() > 0)
{
c._name.format("SALDOINI[%d]", i);
add_column_info(c);
c._name.format("PDARE[%d]", i);
add_column_info(c);
c._name.format("PAVERE[%d]", i);
add_column_info(c);
}
c._name.format("SALDO[%d]", i);
add_column_info(c);
}
}
const TSaldo_periodo & TSaldi_ricl_recordset::saldo_periodo()
{
const TString16 cod = get("CODTAB").as_string();
return saldo_periodo_ricl(_codricl, cod);
}
const TVariant& TSaldi_ricl_recordset::get_field(int logic, const char* field) const
{
const TString80 fname(field);
if (sel_columns() > 0)
{
if (fname.starts_with("SALDOINI"))
return ((TSaldi_ricl_recordset *)this)->saldo_periodo().saldoini(atoi(fname.mid(9)));
else
if (fname.starts_with("PAVERE"))
return ((TSaldi_ricl_recordset *)this)->saldo_periodo().pavere(atoi(fname.mid(7)));
else
if (fname.starts_with("PDARE"))
return ((TSaldi_ricl_recordset *)this)->saldo_periodo().pdare(atoi(fname.mid(6)));
}
if (fname.starts_with("SALDO"))
return ((TSaldi_ricl_recordset *)this)->saldo_periodo().saldo(atoi(fname.mid(6)));
else
if (fname.starts_with("INDBIL"))
return get("I0");
return TISAM_recordset::get_field(logic, field);
}
HIDDEN bool non_zero_ricl(const TRelation * r)
{
TSaldi_recordset_data & data = saldi_data();
const TString16 codricl = data.codricl();
const TString & table = data.table();
TLocalisamfile & tab = r->lfile(table);
const TString16 cod = tab.get("CODTAB");
const TSaldo_periodo & s = saldo_periodo_ricl(codricl, cod);
return s.movimentato() || !s.is_zero();
}
TCursor* TSaldi_ricl_recordset::cursor() const
{
bool new_cursor = !valid_cursor();
TCursor * c = TISAM_recordset::cursor();
if (new_cursor)
{
if (!_all)
c->set_filterfunction(non_zero_ricl);
((TSaldi_ricl_recordset *) this)->set_custom_columns();
}
return c;
}
bool TSaldi_ricl_recordset::provv() const
{
return saldi_data(_id).provv();
}
const int TSaldi_ricl_recordset::nper() const
{
return saldi_data(_id).nper();
}
const TDate & TSaldi_ricl_recordset::from(int n) const
{
return (const TDate &) saldi_data(_id).from()[n];
}
const TDate & TSaldi_ricl_recordset::to(int n) const
{
return (const TDate &) saldi_data(_id).to()[n] ;
}
void TSaldi_ricl_recordset::requery()
{
saldi_data(_id).saldi().destroy();
TISAM_recordset::requery();
}
void TSaldi_ricl_recordset::set_fromto()
{
TSaldi_recordset_data & data = saldi_data(_id);
TDate dal = (TDate &) data.from()[0];
data.from().destroy();
if (data.nper() <= 0)
data.nper() = 1;
if (dal.ok())
{
const TRectype & per = cache().get("&PER", _codper);
for (int i = 0; i < data.nper(); i++)
{
TDate al = dal;
al += per.get_int("I0");
al += per.get_int("I1") * 7;
al.addmonth(per.get_int("I2"));
al.addyear(per.get_int("I3"));
if (al > dal)
--al;
else
al = dal;
data.from().add(dal);
data.to().add(al);
dal = ++al;
}
}
}
TSaldi_ricl_recordset::TSaldi_ricl_recordset(const char * codricl, const char * codper, int nper, const TDate & dal, int sel_columns, bool provv,
bool all, const TString& sql) : TISAM_recordset(sql), _codricl(codricl), _all(all), _sel_columns(sel_columns)
{
_id = __shuttle.add(new TSaldi_recordset_data);
TSaldi_recordset_data & data = saldi_data(_id);
TString8 table;
data.from().destroy();
data.to().destroy();
if (_codricl.starts_with("RI"))
table = "&RCO";
else
if (_codricl.starts_with("TS"))
table = "&TCTCO";
else
if (_codricl.starts_with("ZU"))
table << "&TCZCO";
data.codricl() = _codricl;
data.table() = table;
set_fromto();
if (sql.blank())
{
TString query;
query << "USE " << table << "\nDISPLAY \"Codice\" CODTAB\nDISPLAY \"Descrizione\" S0\n";
set(query);
}
else
{
const int p = sql.find("RICLCG");
if (p > 0)
{
TString query(sql.left(p));
query << table << sql.mid(p + 6);
set(query);
}
}
}
TSaldi_ricl_recordset::TSaldi_ricl_recordset(const TMask& m, const TString& sql) : TISAM_recordset(sql)
{
_id = __shuttle.add(new TSaldi_recordset_data);
TSaldi_recordset_data & data = saldi_data(_id);
const int items = m.fields();
data.from().destroy();
data.to().destroy();
_codricl.cut(0);
_codper.cut(0);
_all = true;
_sel_columns = 0;
for (short i = 0; i < items; i++)
{
const TMask_field &f = m.fld(i);
const TFieldref* fld = f.field();
if (fld != NULL)
{
TString80 fldname=fld->name();
if (fldname.starts_with("TRICL"))
_codricl = f.get();
else
if (fldname.starts_with("RICL"))
_codricl << f.get();
if (fldname.starts_with("PER"))
_codper = f.get();
else
if (fldname.starts_with("NPER"))
data.nper() = f.get_long();
else
if (fldname.starts_with("DAL"))
data.from().add(new TDate(f.get()), 0);
else
if (fldname.starts_with("PROVV"))
data.provv() = f.get().full();
else
if (fldname.starts_with("ALL"))
_all = f.get().full();
else
if (fldname.starts_with("COLTYPE"))
_sel_columns = atoi(f.get());
}
}
TString8 table;
if (_codricl.starts_with("RI"))
table = "&RCO";
else
if (_codricl.starts_with("TS"))
table = "&TCTCO";
else
if (_codricl.starts_with("ZU"))
table << "&TCZCO";
data.codricl() = _codricl;
data.table() = table;
set_fromto();
if (sql.blank())
{
TString query;
query << "USE " << table << "\nDISPLAY \"Codice\" CODTAB\nDISPLAY \"Descrizione\" S0\n";
set(query);
}
else
{
const int p = sql.find("RICLCG");
if (p > 0)
{
TString query(sql.left(p));
query << table << sql.mid(p + 6);
set(query);
}
}
}
TSaldi_ricl_recordset::~TSaldi_ricl_recordset()
{
__shuttle.destroy(_id);
}
///////////////////////////////////////////////////////////
// TDocument_report
///////////////////////////////////////////////////////////
KEY TRicl_report::run_form(TMask& m)
{
KEY key = TReport::run_form(m);
if (key == K_ENTER)
{
const int items = m.fields();
_codricl.cut(0);
_codper.cut(0);
_nper = 0;
_dal = botime;
_provv = false;
_all = true;
_sel_columns = 0;
for (short i = 0; i < items; i++)
{
const TMask_field &f = m.fld(i);
const TFieldref* fld = f.field();
if (fld != NULL)
{
TString80 fldname=fld->name();
if (fldname.starts_with("TRICL"))
_codricl = f.get();
else
if (fldname.starts_with("RICL"))
_codricl << f.get();
if (fldname.starts_with("PER"))
_codper = f.get();
else
if (fldname.starts_with("NPER"))
_nper = f.get_long();
else
if (fldname.starts_with("DAL"))
_dal = TDate(f.get());
else
if (fldname.starts_with("PROVV"))
_provv = f.get().full();
else
if (fldname.starts_with("ALL"))
_all = f.get().full();
else
if (fldname.starts_with("COLTYPE"))
_sel_columns = atoi(f.get());
}
}
}
return key;
}
bool TRicl_report::set_recordset(const TString& query)
{
if (query.find("RICLCG") > 0)
{
if (_codricl.full())
return TReport::set_recordset(new TSaldi_ricl_recordset(_codricl, _codper, _nper, _dal, _sel_columns, _provv, _all, query));
else
return TReport::set_recordset(new TSaldi_conti_recordset(_codper, _nper, _dal, _sel_columns, _provv, _all, query));
}
return TReport::set_recordset(query);
}
bool TRicl_report::load(const char* name)
{
const bool ok = TReport::load(name);
if (ok)
{
// Purtroppo il recordset delle sottosezioni deve essere reimpostato a mano
for (int i = 11; i <= 999; i++)
{
TReport_section* sec = find_section('B', i);
if (sec != NULL)
{
TRecordset* recset = sec->recordset();
if (recset != NULL)
{
const TString use = recset->query_text();
if (use.find("RICLCG") > 0)
{
if (_codricl.full())
return TReport::set_recordset(new TSaldi_ricl_recordset(_codricl, _codper, _nper, _dal, _sel_columns, _provv, _all, use));
else
return TReport::set_recordset(new TSaldi_conti_recordset(_codper, _nper, _dal, _sel_columns, _provv, _all, use));
sec->set_recordset(recset);
}
}
}
}
}
return ok;
}
size_t TRicl_report::get_usr_words(TString_array& words) const
{
TReport::get_usr_words(words);
const char* const name[] = { NULL };
((TRicl_report*)this)->_first_msg = words.items(); // Calcola il primo numero disponibile
for (size_t i = 0; name[i] != NULL; i++)
words.add(name[i]);
return words.items();
}
bool TRicl_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)
{
default: break;
}
while (!stack.pop().is_null()); // Svuota eventuali parametri variabili inutilizzati
return true;
}
Reference in New Issue View Git Blame Copy Permalink