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

orrezioni da PARMA a causali mastrini chiusura e registri.

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@159 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
nik 1994-09-05 11:10:59 +00:00
parent 47dd388b62
commit 8f12c7fc4d
9 changed files with 2636 additions and 1767 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

439
cg/cg0500.cpp
View File

@ -64,9 +64,18 @@ HIDDEN int anno_iva()
} }
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
//
// Le righe di causale: // Le righe di causale:
// Righe_rcaus e' un array di Riga_rcaus //
// Riga_rcaus e' una token_string corrispondente ad una riga dello spreadsheet // Righe_rcaus e' un array di Riga_rcaus.
//
// - NB - Contiene solo le descrizioni fisse!
//
// I dati letti dal file sono memorizzati direttamente nello spreadsheet
// Quando cambiano i campi tipodoc, codreg, tpm della testata le nuove
// descrizioni vengono caricate in questo array e poi ricopiate (solo le
// descrizioni) nello spreadsheet.
//
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
class Riga_rcaus : public TToken_string class Riga_rcaus : public TToken_string
{ {
@ -89,35 +98,23 @@ Riga_rcaus::Riga_rcaus (TConto& tc,const char * df, char tipocf, char sez,
bool rigaiva, const char * codiva) bool rigaiva, const char * codiva)
: TToken_string(80) : TToken_string(80)
{ {
add(df); add(df); add(tipocf);
// add(tc.tipo()); // add(tc.tipo());
add(tipocf); if (tc.ok()) {
if (tc.ok()) add((long)tc.gruppo()); add((long)tc.conto());
{
add((long)tc.gruppo());
add((long)tc.conto());
add((long)tc.sottoconto()); add((long)tc.sottoconto());
} }
else else {
{ add(""); add(""); add("");
add("");
add("");
add("");
} }
add(sez); add(sez); add(des); add(desagg);
add(des); add((char)rigaiva); add(codiva);
add(desagg);
add((char)rigaiva);
add(codiva);
} }
class TRighe_rcaus : public TArray class TRighe_rcaus : public TArray
{ {
public: public:
void set_descr (int numrig=-1, const char * descr="", char tipocf=' '); void set_descr (int numrig=-1, const char * descr="", char tipocf=' ');
void add_riga(int numrig, char tipocf,
char sezione, const char * des, const char * desagg,
bool rigaiva, const char * codiva, TConto& tc );
void clear(int riga); // pulisce una riga in seguito ad Azzera void clear(int riga); // pulisce una riga in seguito ad Azzera
void ClearDescr(); // cancella solo le descrizioni fisse void ClearDescr(); // cancella solo le descrizioni fisse
void CaricaRigheLibere(); void CaricaRigheLibere();
@ -130,10 +127,8 @@ public:
void TRighe_rcaus::ClearDescr() void TRighe_rcaus::ClearDescr()
{ {
for (int i=0; i < items(); i++) for (int i=0; i < items(); i++) {
{
Riga_rcaus *r = (Riga_rcaus*)objptr(i); Riga_rcaus *r = (Riga_rcaus*)objptr(i);
if (r) r->add("", 0); if (r) r->add("", 0);
} }
} }
@ -142,55 +137,19 @@ void TRighe_rcaus::clear(int row)
{ {
Riga_rcaus *r = (Riga_rcaus*)objptr(row); Riga_rcaus *r = (Riga_rcaus*)objptr(row);
if (r) if (r) {
{ r->add("", 1); r->add(0, 2); r->add(0, 3);
r->add("", 1); r->add(0L, 4); r->add("", 5); r->add("", 6);
r->add(0, 2); r->add("", 7); r->add("", 8); r->add("", 9);
r->add(0, 3);
r->add(0L, 4);
r->add("", 5);
r->add("", 6);
r->add("", 7);
r->add("", 8);
r->add("", 9);
} }
} }
void TRighe_rcaus::add_riga(int i, char tipocf,
char sez, const char * des, const char * desagg, bool rigaiva,
const char * codiva, TConto& tc)
{
Riga_rcaus *r = (Riga_rcaus*)objptr(i);
int g=0,c=0;
long s=0L;
if (r == NULL)
{
r = new Riga_rcaus (tc,"",tipocf,sez,des,desagg,rigaiva,codiva);
add(r,i); // ???
}
g = tc.gruppo();
c = tc.conto();
s = tc.sottoconto();
r->add(tipocf, 1);
r->add((long)g, 2);
r->add((long)c, 3);
r->add((long)s, 4);
r->add(sez, 5);
r->add(des, 6);
r->add(desagg, 7);
r->add(rigaiva ? "X" : "", 8);
r->add(codiva, 9);
}
void TRighe_rcaus::set_descr(int i, const char * dfi, char tipocf) void TRighe_rcaus::set_descr(int i, const char * dfi, char tipocf)
{ {
Riga_rcaus *r = (Riga_rcaus*)objptr(i); Riga_rcaus *r = (Riga_rcaus*)objptr(i);
TConto tc; TConto tc;
if (r == NULL) if (r == NULL) {
{
r = new Riga_rcaus (tc,dfi,tipocf); r = new Riga_rcaus (tc,dfi,tipocf);
add(r,i); add(r,i);
} }
@ -213,12 +172,12 @@ typedef enum { acquisto, vendita, incasso_pagamento,
friend bool filtra_reg(const TRelation * r); friend bool filtra_reg(const TRelation * r);
static bool tipocf_hndl (TMask_field& f, KEY k); static bool tipocf_hndl (TMask_field& f, KEY k);
// static bool m770_hndl (TMask_field& f, KEY k);
static bool cod_reg_hndl (TMask_field& f, KEY k); static bool cod_reg_hndl (TMask_field& f, KEY k);
static bool tipodoc_hndl (TMask_field& f, KEY k); static bool tipodoc_hndl (TMask_field& f, KEY k);
static bool tipomov_hndl (TMask_field& f, KEY k); static bool tipomov_hndl (TMask_field& f, KEY k);
static bool conto_hndl (TMask_field& f, KEY k); static bool conto_hndl (TMask_field& f, KEY k);
static bool sottoconto_hndl (TMask_field& f, KEY k); static bool sottoconto_hndl (TMask_field& f, KEY k);
static bool codcausim_hndl (TMask_field& f, KEY k);
static bool leggi_riga (int r, KEY k); static bool leggi_riga (int r, KEY k);
TRelation * _rel; TRelation * _rel;
@ -231,11 +190,8 @@ typedef enum { acquisto, vendita, incasso_pagamento,
void togli_dal_file(const TString&); void togli_dal_file(const TString&);
void read_rcaus(TMask&); void read_rcaus(TMask&);
bool descr2array(TMask&); bool descr2array(TMask&, bool fromHandler = TRUE);
bool descr2array2(TMask&);
bool fill_sheet(TMask&); bool fill_sheet(TMask&);
static bool has_iva (const char * tpc);
bool is_clifo(const char * tpc);
protected: protected:
virtual bool user_create(); virtual bool user_create();
@ -264,9 +220,12 @@ public:
void compilaarray (const TString&, int, int, int); void compilaarray (const TString&, int, int, int);
void array2sheet(); // Copia le descrizioni dall'array allo sheet void array2sheet(); // Copia le descrizioni dall'array allo sheet
TMask * main_mask() const { return _msk; } TMask* main_mask() const { return _msk; }
TMask & ss_mask() const { return ss().sheet_mask(); } TMask& ss_mask() const { return ss().sheet_mask(); }
TSheet_field& ss() const { return (TSheet_field&)_msk->field(F_SHEET_GCS);} TSheet_field& ss() const { return (TSheet_field&)_msk->field(F_SHEET_GCS);}
void add_riga (int numrig, char cf, char sz, TString& d, TString& da,
bool riva, TString& civa, TConto& tc);
bool MostraCampi(TMask_field& f);
CG0500_application() {} CG0500_application() {}
}; };
@ -330,78 +289,61 @@ bool filtra_reg(const TRelation * r)
} }
bool CG0500_application::has_iva (const char * tpconto)
{
TFixed_string tpc(tpconto);
// Lascio abilitato codiva e rigaiva solo per i conti senza descr.fissa
if (tpc.trim().empty())
return TRUE;
else
return FALSE;
}
bool CG0500_application::is_clifo (const char * tpconto)
{
TFixed_string tpc(tpconto);
if ( (tpc == "C Clienti/Fornitori") || (tpc == "C Clienti") ||
(tpc == "C Fornitori") )
return TRUE;
return FALSE;
}
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// Handler della maschera principale // Handler della maschera principale
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
bool CG0500_application::tipodoc_hndl (TMask_field& f, KEY k) bool CG0500_application::tipodoc_hndl (TMask_field& f, KEY k)
{ {
// if (k == K_TAB) // if (k == K_TAB && f.focusdirty())
if (k == K_TAB && f.focusdirty()) // Testo K_TAB perche' il controllo deve scattare anche all'inizio
// per vedere, per es., se il registro scritto nella causale
// esiste ancora
if (k == K_TAB)
{ {
const TString16 val(f.get()); const TString16 val(f.get());
const int tpm = f.mask().get_int(F_TIPO_MOV);
TEdit_field& field_reg = (TEdit_field&)f.mask().field(F_COD_REG); TEdit_field& field_reg = (TEdit_field&)f.mask().field(F_COD_REG);
if (val.not_empty() && val != "IN" && val != "PG" && val != "AN") if (val.not_empty() && val != "IN" && val != "PG" && val != "AN")
{ {
f.mask().show(F_OP_FINE_ANNO); if (salda_conto()) {
f.mask().show(F_M_770); f.mask().hide(F_TIPO_MOV_2);
f.mask().hide(F_TIPO_MOV_2); f.mask().show(F_TIPO_MOV_1);
f.mask().show(F_TIPO_MOV_1); }
f.mask().enable(F_COD_REG); f.mask().enable(F_COD_REG);
field_reg.check_type(CHECK_REQUIRED); field_reg.check_type(CHECK_REQUIRED);
// Cambio il filtro sui registri // Cambio il filtro sui registri: con tipo=1
// con tipo=1 if (val == "FV" || val == "FF" || val == "FS") {
if (val == "FV" || val == "FF" || val == "FS")
{
app()->_filtro = 1; app()->_filtro = 1;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg); field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
} } else
// con tipo=1 e corrisp="X"
// con tipo=1 e corrisp="X" if (val == "CN" || val == "RN" || val == "CR" ||
if (val == "CN" || val == "RN" || val == "CR" || val == "SC" || val == "RF" || val == "SN") {
val == "SC" || val == "RF" || val == "SN") app()->_filtro = 2;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
} else
// Possono essere 1 o 2
if (val == "NC" || val == "ST" || val == "ND" ||
val == "AF") {
app()->_filtro = 4;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
} else
// con tipo=2
if (val == "FA" || val == "BD") {
app()->_filtro = 3;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
}
// Ma davvero esiste il registro ?
TString16 codreg=f.mask().get(F_COD_REG);
if (codreg.not_empty())
{ {
app()->_filtro = 2; TRegistro registro(codreg, anno_iva());
field_reg.browse()->cursor()->set_filterfunction(filtra_reg); if (!registro.read(codreg, anno_iva()))
return f.warning_box("Non esiste il registro %s per l'anno %d",
(const char *)codreg, anno_iva());
} }
// Possono essere 1 o 2
if (val == "NC" || val == "ST" || val == "ND" ||
val == "AF")
{
app()->_filtro = 4;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
}
// con tipo=2
if (val == "FA" || val == "BD")
{
app()->_filtro = 3;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
}
} }
else // TIPODOC vuoto || IN || PG || AN else // TIPODOC vuoto || IN || PG || AN
{ {
@ -410,50 +352,97 @@ bool CG0500_application::tipodoc_hndl (TMask_field& f, KEY k)
f.mask().set(F_COD_REG,""); f.mask().set(F_COD_REG,"");
f.mask().disable(F_COD_REG); f.mask().disable(F_COD_REG);
f.mask().hide(F_TIPO_MOV_1); if (salda_conto()) {
f.mask().show(F_TIPO_MOV_2); f.mask().hide(F_TIPO_MOV_1);
f.mask().show(F_TIPO_MOV_2);
if ( !salda_conto() || tpm == 0 ) }
{ }
f.mask().show(F_OP_FINE_ANNO); if (f.focusdirty()) {
f.mask().show(F_M_770); app()->fill_sheet(f.mask());
} app()->MostraCampi(f); // show-hide di diversi campi pilotati da codreg
else
{
f.mask().hide(F_OP_FINE_ANNO);
f.mask().hide(F_M_770);
}
} }
app()->fill_sheet(f.mask());
} }
return TRUE; return TRUE;
} }
bool CG0500_application::tipomov_hndl (TMask_field& f, KEY k) bool CG0500_application::tipomov_hndl (TMask_field& f, KEY k)
{ {
if (f.to_check(k)) if (k == K_SPACE) {
{ app()->MostraCampi(f);
const int tpm = atoi(f.get()); app()->fill_sheet(f.mask());
if (tpm > 0) }
return TRUE;
}
// Il codice causale per incasso immediato, se specificato, deve
// essere puramente contabile (= codreg vuoto e tpm = Nessuno
bool CG0500_application::codcausim_hndl (TMask_field& f, KEY k)
{
if (f.to_check(k)) {
TString16 causim(f.get());
TLocalisamfile& caus = *app()->_rel->lfile(LF_CAUSALI);
caus.zero();
caus.put(CAU_CODCAUS, causim);
if (caus.read() == NOERR)
{ {
if ( (tpm == 3) || (tpm == 5) || (tpm == 6) ) const int tpm = caus.get_int(CAU_TIPOMOV);
f.mask().enable(F_MOV_SEZ); TString16 codreg = caus.get(CAU_REG);
else if (codreg.not_empty() || tpm != 0)
f.mask().disable(F_MOV_SEZ); return f.warning_box("La causale per l'incasso immediato specificata (%s) deve essere puramente contabile",
(const char *) causim);
} }
if (k == K_TAB) }
app()->fill_sheet(f.mask()); return TRUE;
}
bool CG0500_application::MostraCampi(TMask_field& f)
{
const int tpm = f.mask().get_int(F_TIPO_MOV);
TString16 codreg = f.mask().get(F_COD_REG);
if (codreg.empty())
{
switch (tpm) {
case 0:
f.mask().show(F_OP_FINE_ANNO);
f.mask().hide(F_MOV_VALU);
f.mask().hide(F_MOV_SEZ);
break;
case 3:
case 5:
case 6:
f.mask().hide(F_OP_FINE_ANNO);
f.mask().show(F_MOV_VALU);
f.mask().show(F_MOV_SEZ);
f.mask().hide(F_COLL_CESP);
break;
default:
f.mask().show(F_COLL_CESP);
break;
}
}
else { // codreg non vuoto
f.mask().hide(F_OP_FINE_ANNO);
f.mask().hide(F_MOV_SEZ);
if (gestione_valuta())
f.mask().show(F_MOV_VALU);
} }
return TRUE; return TRUE;
} }
bool CG0500_application::cod_reg_hndl (TMask_field& f, KEY k) bool CG0500_application::cod_reg_hndl (TMask_field& f, KEY k)
{ {
if (k == K_TAB && f.focusdirty()) // if (k == K_TAB && f.focusdirty())
app()->fill_sheet(f.mask()); if (k == K_TAB)
{
app()->MostraCampi(f);
if (f.focusdirty()) app()->fill_sheet(f.mask());
return TRUE;
}
// controllo di consistenza tra codice (tipo) registro e tipo documento // controllo di consistenza tra codice (tipo) registro e tipo documento
if (k == K_ENTER && f.dirty()) // if (k == K_ENTER && f.dirty())
if (k == K_ENTER)
{ {
bool ok = TRUE; bool ok = TRUE;
@ -464,7 +453,8 @@ bool CG0500_application::cod_reg_hndl (TMask_field& f, KEY k)
if (tpd.not_empty() && tpd != "AN" && tpd != "PG" && tpd != "IN") if (tpd.not_empty() && tpd != "AN" && tpd != "PG" && tpd != "IN")
{ {
if (codreg.empty()) ok = FALSE; if (codreg.empty())
return f.warning_box("Manca il codice del registro");
} }
else else
{ {
@ -500,14 +490,6 @@ bool CG0500_application::cod_reg_hndl (TMask_field& f, KEY k)
return TRUE; return TRUE;
} }
/* ???
bool CG0500_application::m770_hndl (TMask_field& f, KEY k)
{
if (k == K_TAB && f.focusdirty())
app()->fill_sheet(f.mask());
return TRUE;
}
*/
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// Handler della maschera dello spreadsheet // Handler della maschera dello spreadsheet
@ -594,26 +576,17 @@ bool CG0500_application::sottoconto_hndl (TMask_field& f, KEY k)
return TRUE; return TRUE;
} }
// Handler del campo tipocf ? della maschera di edit dello sheet // Handler del campo tipocf della maschera di edit dello sheet
// Abilita 109 e 110 (rigaiva e codiva) SOLO SE registro 1 o 2 // Abilita 109 e 110 (rigaiva e codiva) SOLO SE registro 1 o 2
// Controlla all'uscita che il tipo C/F vada bene per la riga corrente
// in questo modo:
// se tpr==1 NON accetta nelle righe 1 o 7 il tipo F
// se tpr==2 NON accetta nelle righe 1 o 7 il tipo C
// nelle righe sopra la 10 sono libero
//
bool CG0500_application::tipocf_hndl (TMask_field& f, KEY k) bool CG0500_application::tipocf_hndl (TMask_field& f, KEY k)
{ {
if (k == K_SPACE) if (k == K_SPACE)
{ {
TString16 cf(f.get());
const int tpr = app()->main_mask()->get_int(F_TIPO_REG); const int tpr = app()->main_mask()->get_int(F_TIPO_REG);
if (tpr == 1 || tpr == 2) if (tpr == 1 || tpr == 2) {
{
f.mask().enable(109); f.mask().enable(110); f.mask().enable(109); f.mask().enable(110);
} }
else else {
{
f.mask().disable(109); f.mask().disable(110); f.mask().disable(109); f.mask().disable(110);
} }
} }
@ -621,7 +594,7 @@ bool CG0500_application::tipocf_hndl (TMask_field& f, KEY k)
} }
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// Funzioni che caricano le varie descrizioni fisse // Funzioni che caricano le varie descrizioni fisse nell'array
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
void TRighe_rcaus::CausaleVendite() void TRighe_rcaus::CausaleVendite()
{ {
@ -733,7 +706,7 @@ void CG0500_application::compilaarray(const TString& tpd, int tpm, int tpr, int
bool CG0500_application::fill_sheet(TMask& m) bool CG0500_application::fill_sheet(TMask& m)
{ {
descr2array2(m); descr2array(m);
array2sheet(); array2sheet();
return TRUE; return TRUE;
} }
@ -741,12 +714,25 @@ bool CG0500_application::fill_sheet(TMask& m)
int CG0500_application::read(TMask& m) int CG0500_application::read(TMask& m)
{ {
m.autoload(_rel); m.autoload(_rel);
descr2array(m); descr2array(m, FALSE);
array2sheet(); array2sheet();
read_rcaus(m); read_rcaus(m);
return NOERR; return NOERR;
} }
void CG0500_application::add_riga(int numrig,
char cf, char sz, TString& d, TString& da, bool riva,
TString& civa, TConto& tc)
{
TSheet_field& cs = ss();
TToken_string & riga = cs.row(numrig);
riga.add(cf, 1); riga.add(tc.gruppo(), 2);
riga.add(tc.conto(), 3); riga.add(tc.sottoconto(),4);
riga.add(sz, 5); riga.add(d, 6); riga.add(da,7);
riga.add(riva ? "X" : "", 8);
riga.add(civa, 9);
}
void CG0500_application::read_rcaus(TMask& m) void CG0500_application::read_rcaus(TMask& m)
{ {
int numrig, g, c; int numrig, g, c;
@ -755,7 +741,6 @@ void CG0500_application::read_rcaus(TMask& m)
char sz, cf; char sz, cf;
bool riva; bool riva;
TLocalisamfile * rcaus = _rel->lfile(LF_RCAUSALI); TLocalisamfile * rcaus = _rel->lfile(LF_RCAUSALI);
TSheet_field& cs = ss();
_rel->update(); // chiamo position_rels() _rel->update(); // chiamo position_rels()
@ -770,22 +755,16 @@ void CG0500_application::read_rcaus(TMask& m)
g = rcaus->get_int(RCA_GRUPPO); g = rcaus->get_int(RCA_GRUPPO);
c = rcaus->get_int(RCA_CONTO); c = rcaus->get_int(RCA_CONTO);
s = rcaus->get_long(RCA_SOTTOCONTO); s = rcaus->get_long(RCA_SOTTOCONTO);
sz = rcaus->get(RCA_SEZIONE)[0]; sz = rcaus->get_char(RCA_SEZIONE);
d = rcaus->get(RCA_DESC); d = rcaus->get(RCA_DESC);
da = rcaus->get(RCA_CODDESC); da = rcaus->get(RCA_CODDESC);
cf = rcaus->get(RCA_TIPOCF)[0]; // cf = rcaus->get(RCA_TIPOCF)[0];
cf = rcaus->get_char(RCA_TIPOCF);
riva = rcaus->get_bool(RCA_RIGAIVA); riva = rcaus->get_bool(RCA_RIGAIVA);
civa = rcaus->get(RCA_CODIVA); civa = rcaus->get(RCA_CODIVA);
TConto tc(g,c,s,cf); TConto tc(g,c,s,cf);
TToken_string & riga = cs.row(numrig-1);
riga.add(cf, 1); riga.add(g, 2); riga.add(c, 3); riga.add(s,4);
riga.add(sz, 5); riga.add(d, 6); riga.add(da,7);
riga.add(riva ? "X" : "", 8);
riga.add(civa, 9);
// _righe_rcaus.add_riga(numrig-1, cf, sz, d, da, riva, civa, tc); add_riga(numrig-1, cf, sz, d, da, riva, civa, tc);
// g.right_just(3); c.right_just(3); s.right_just(6);
// _righe_rcaus.add_riga(numrig-1,"",g,c,s,sz,d,da,tc,riva,civa);
_righe_gia_presenti.set(numrig); _righe_gia_presenti.set(numrig);
ok = _rel->next_match(LF_RCAUSALI); ok = _rel->next_match(LF_RCAUSALI);
@ -802,8 +781,7 @@ void CG0500_application::array2sheet()
for (int i = 0; i < _items; i++) for (int i = 0; i < _items; i++)
{ {
TToken_string & riga = ss().row(i); TToken_string & riga = ss().row(i);
// Riga_rcaus * r = (Riga_rcaus*)_righe_rcaus.objptr(i); TToken_string * r = (TToken_string*)_righe_rcaus.objptr(i);
TToken_string * r = (TToken_string*)_righe_rcaus.objptr(i);
if (r != NULL) if (r != NULL)
{ {
dfi = r->get(0); dfi = r->get(0);
@ -815,37 +793,13 @@ void CG0500_application::array2sheet()
ss().force_update(); ss().force_update();
} }
bool CG0500_application::descr2array2(TMask& m) bool CG0500_application::descr2array(TMask& m, bool fromHandler)
{ {
TLocalisamfile& caus = *_rel->lfile(); TLocalisamfile& caus = *_rel->lfile();
TString16 tpd, codreg; TString16 tpd, codreg;
int tpm, m770, tpr; int tpm, m770, tpr;
codreg = m.field(F_COD_REG).get(); if (m.mode() == MODE_MOD && !fromHandler)
tpd = m.field(F_TIPO_DOC).get();
tpm = m.get_int(F_TIPO_MOV);
m770 = m.get_int(F_M_770);
/*
TString16 chiave; chiave << anno_iva() << codreg;
TTable reg("REG");
reg.put("CODTAB", chiave);
reg.read();
tpr = reg.get_int("I0");
*/
tpr = m.get_int(F_TIPO_REG);
// carico le descrizioni fisse nell'array Righe_rcaus
compilaarray(tpd,tpm,tpr,m770);
return TRUE;
}
bool CG0500_application::descr2array(TMask& m)
{
TLocalisamfile& caus = *_rel->lfile();
TString16 tpd, codreg;
int tpm, m770;
if (m.mode() == MODE_MOD)
{ {
codreg = caus.get("REG"); codreg = caus.get("REG");
tpd = caus.get("TIPODOC"); tpd = caus.get("TIPODOC");
@ -860,11 +814,16 @@ bool CG0500_application::descr2array(TMask& m)
m770 = m.get_int(F_M_770); m770 = m.get_int(F_M_770);
} }
TString16 chiave; chiave << anno_iva() << codreg; if (fromHandler)
TTable reg("REG"); tpr = m.get_int(F_TIPO_REG);
reg.put("CODTAB", chiave); else
reg.read(); {
int tpr = reg.get_int("I0"); TString16 chiave; chiave << anno_iva() << codreg;
TTable reg("REG");
reg.put("CODTAB", chiave);
reg.read();
tpr = reg.get_int("I0");
}
// carico le descrizioni fisse nell'array Righe_rcaus // carico le descrizioni fisse nell'array Righe_rcaus
compilaarray(tpd,tpm,tpr,m770); compilaarray(tpd,tpm,tpr,m770);
@ -886,7 +845,9 @@ void CG0500_application::togli_dal_file(const TString& cau)
rcaus->zero(); rcaus->zero();
rcaus->put(RCA_CODCAUS,cau); rcaus->put(RCA_CODCAUS,cau);
rcaus->put(RCA_NRIGA, i); rcaus->put(RCA_NRIGA, i);
rcaus->remove(); if (rcaus->read() == NOERR)
rcaus->remove();
_righe_gia_presenti.reset(i);
} }
} }
} }
@ -933,14 +894,14 @@ int CG0500_application::re_write(const TMask& m,bool rewrite)
if (g > 0 || c > 0 || s > 0L) if (g > 0 || c > 0 || s > 0L)
{ {
rcaus->zero(); rcaus->zero();
rcaus->put (RCA_CODCAUS, cau); rcaus->put (RCA_CODCAUS, (const char *)cau);
rcaus->put (RCA_NRIGA, i+1); // Numerare da uno! rcaus->put (RCA_NRIGA, i+1); // Numerare da uno!
rcaus->put (RCA_GRUPPO , g); rcaus->put (RCA_GRUPPO , g);
rcaus->put (RCA_CONTO , c); rcaus->put (RCA_CONTO , c);
rcaus->put (RCA_SOTTOCONTO, s); rcaus->put (RCA_SOTTOCONTO, s);
rcaus->put (RCA_SEZIONE, sezione); rcaus->put (RCA_SEZIONE, sezione);
rcaus->put (RCA_DESC , desc); rcaus->put (RCA_DESC , (const char *)desc);
rcaus->put (RCA_CODDESC, coddesc); rcaus->put (RCA_CODDESC, (const char *)coddesc);
rcaus->put (RCA_TIPOCF, tipo_cf); rcaus->put (RCA_TIPOCF, tipo_cf);
if (rewrite) if (rewrite)
{ {
@ -1069,26 +1030,28 @@ bool CG0500_application::user_create()
_msk = new TMask("cg0500a"); _msk = new TMask("cg0500a");
if (!salda_conto()) if (!salda_conto()) {
{
_msk->hide (F_MOV_SEZ); _msk->hide (F_MOV_SEZ);
_msk->hide (F_TIPO_MOV); _msk->hide (F_TIPO_MOV_1);
_msk->hide (F_TIPO_MOV_2);
_msk->show (F_COD_CAUS_IM);
} }
else else {
_msk->show (F_MOV_SEZ);
_msk->hide (F_COD_CAUS_IM); _msk->hide (F_COD_CAUS_IM);
}
if (gestione_valuta())
_msk->show (F_MOV_VALU);
else
_msk->hide (F_MOV_VALU);
if (!gestione_valuta()) _msk->hide (F_MOV_VALU);
_msk->set_handler(F_TIPO_DOC, tipodoc_hndl); _msk->set_handler(F_TIPO_DOC, tipodoc_hndl);
_msk->set_handler(F_TIPO_MOV_1, tipomov_hndl); _msk->set_handler(F_TIPO_MOV_1, tipomov_hndl);
_msk->set_handler(F_TIPO_MOV_2, tipomov_hndl); _msk->set_handler(F_TIPO_MOV_2, tipomov_hndl);
_msk->set_handler(F_COD_REG, cod_reg_hndl); _msk->set_handler(F_COD_REG, cod_reg_hndl);
// _msk->set_handler(F_M_770, m770_hndl); _msk->set_handler(F_COD_CAUS_IM, codcausim_hndl);
//
// Handler del campo GRUPPO della maschera di edit dello sheet.
// Uso per abilitare il campo C/F per alcuni tipi di conti.
//
TSheet_field& cs = ss(); TSheet_field& cs = ss();
cs.set_notify(leggi_riga); cs.set_notify(leggi_riga);

582
cg/cg0500a.uml
View File

@ -1,291 +1,291 @@
#include "cg0500.h" #include "cg0500.h"
TOOLBAR "" 0 20 0 2 TOOLBAR "" 0 20 0 2
#include <toolbar.h> #include <toolbar.h>
ENDPAGE ENDPAGE
PAGE "" -1 -1 77 20 PAGE "" -1 -1 77 20
GROUPBOX DLG_NULL -1 3 GROUPBOX DLG_NULL -1 3
BEGIN BEGIN
PROMPT 1 0 "" PROMPT 1 0 ""
END END
STRING F_COD_CAUS 3 STRING F_COD_CAUS 3
BEGIN BEGIN
PROMPT 3 1 "Codice " PROMPT 3 1 "Codice "
FIELD LF_CAUSALI->CODCAUS FIELD LF_CAUSALI->CODCAUS
KEY 1 KEY 1
FLAGS "U" FLAGS "U"
USE LF_CAUSALI USE LF_CAUSALI
INPUT CODCAUS F_COD_CAUS INPUT CODCAUS F_COD_CAUS
DISPLAY "Cod. causale" CODCAUS DISPLAY "Cod. causale" CODCAUS
DISPLAY "Descrizione @50" DESCR DISPLAY "Descrizione @50" DESCR
DISPLAY "Tipo documento" TIPODOC DISPLAY "Tipo documento" TIPODOC
DISPLAY "Codice registro" REG DISPLAY "Codice registro" REG
DISPLAY "Tipo movimento" TIPOMOV DISPLAY "Tipo movimento" TIPOMOV
OUTPUT F_COD_CAUS CODCAUS OUTPUT F_COD_CAUS CODCAUS
OUTPUT F_DESCR DESCR OUTPUT F_DESCR DESCR
HELP "Codice causale" HELP "Codice causale"
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
END END
STRING F_DESCR 40 STRING F_DESCR 40
BEGIN BEGIN
PROMPT 17 1 "Descrizione " PROMPT 17 1 "Descrizione "
FIELD LF_CAUSALI->DESCR FIELD LF_CAUSALI->DESCR
COPY USE F_COD_CAUS COPY USE F_COD_CAUS
INPUT CODCAUS F_COD_CAUS INPUT CODCAUS F_COD_CAUS
INPUT DESCR F_DESCR INPUT DESCR F_DESCR
DISPLAY "Cod. causale" CODCAUS DISPLAY "Cod. causale" CODCAUS
DISPLAY "Descrizione @50" DESCR DISPLAY "Descrizione @50" DESCR
DISPLAY "Tipo documento" TIPODOC DISPLAY "Tipo documento" TIPODOC
DISPLAY "Codice registro" REG DISPLAY "Codice registro" REG
DISPLAY "Tipo movimento" TIPOMOV DISPLAY "Tipo movimento" TIPOMOV
OUTPUT F_COD_CAUS CODCAUS OUTPUT F_COD_CAUS CODCAUS
OUTPUT F_DESCR DESCR OUTPUT F_DESCR DESCR
HELP "Descrizione della causale" HELP "Descrizione della causale"
END END
STRING F_TIPO_DOC 2 STRING F_TIPO_DOC 2
BEGIN BEGIN
PROMPT 2 4 "Tipo doc. " PROMPT 2 4 "Tipo doc. "
FIELD LF_CAUSALI->TIPODOC FIELD LF_CAUSALI->TIPODOC
USE %TPD USE %TPD
INPUT CODTAB F_TIPO_DOC INPUT CODTAB F_TIPO_DOC
DISPLAY "Tipo " CODTAB DISPLAY "Tipo " CODTAB
DISPLAY "Descrizione @50 " S0 DISPLAY "Descrizione @50 " S0
OUTPUT F_TIPO_DOC CODTAB OUTPUT F_TIPO_DOC CODTAB
HELP "Tipo documento" HELP "Tipo documento"
CHECKTYPE NORMAL CHECKTYPE NORMAL
MESSAGE SHOW, 2@ // MESSAGE SHOW, 2@
MESSAGE EMPTY HIDE, 2@ // MESSAGE EMPTY HIDE, 2@
FLAGS "U" FLAGS "U"
END END
STRING F_COD_REG 3 STRING F_COD_REG 3
BEGIN BEGIN
PROMPT 23 4 "Cod. reg. " PROMPT 23 4 "Cod. reg. "
FIELD LF_CAUSALI->REG FIELD LF_CAUSALI->REG
USE REG USE REG
INPUT CODTAB[1,4] F_ANNOES INPUT CODTAB[1,4] F_ANNOES
INPUT CODTAB[5,7] F_COD_REG INPUT CODTAB[5,7] F_COD_REG
DISPLAY "Anno" CODTAB[1,4] DISPLAY "Anno" CODTAB[1,4]
DISPLAY "Codice registro " CODTAB[5,7] DISPLAY "Codice registro " CODTAB[5,7]
DISPLAY "Tipo" I0 DISPLAY "Tipo" I0
DISPLAY "Registro corrispettivi" B0 DISPLAY "Registro corrispettivi" B0
DISPLAY "Descrizione @50" S0 DISPLAY "Descrizione @50" S0
OUTPUT F_ANNOES CODTAB[1,4] OUTPUT F_ANNOES CODTAB[1,4]
OUTPUT F_COD_REG CODTAB[5,7] OUTPUT F_COD_REG CODTAB[5,7]
OUTPUT F_TIPO_REG I0 OUTPUT F_TIPO_REG I0
OUTPUT F_CORRISP B0 OUTPUT F_CORRISP B0
HELP "Codice registro" HELP "Codice registro"
CHECKTYPE NORMAL CHECKTYPE NORMAL
FLAGS "D" FLAGS "D"
END END
// Questo rimane sempre nascosto // Questo rimane sempre nascosto
STRING F_TIPO_MOV 2 STRING F_TIPO_MOV 2
BEGIN BEGIN
PROMPT 68 4 "" PROMPT 68 4 ""
FIELD LF_CAUSALI->TIPOMOV FIELD LF_CAUSALI->TIPOMOV
FLAGS "H" FLAGS "H"
END END
// Viene mostrato questo se TPD non vuoto e diverso da IN AN PG // Viene mostrato questo se TPD non vuoto e diverso da IN AN PG
LISTBOX F_TIPO_MOV_1 1 20 LISTBOX F_TIPO_MOV_1 1 20
BEGIN BEGIN
PROMPT 44 4 "Tipo mov. " PROMPT 44 4 "Tipo mov. "
FIELD LF_CAUSALI->TIPOMOV FIELD LF_CAUSALI->TIPOMOV
HELP "Tipo movimento" HELP "Tipo movimento"
ITEM " |Nessuno" MESSAGE COPY,F_TIPO_MOV ITEM " |Nessuno" MESSAGE COPY,F_TIPO_MOV
ITEM "1|Fattura" MESSAGE COPY,F_TIPO_MOV ITEM "1|Fattura" MESSAGE COPY,F_TIPO_MOV
ITEM "2|Nota credito" MESSAGE COPY,F_TIPO_MOV ITEM "2|Nota credito" MESSAGE COPY,F_TIPO_MOV
// GROUP 2 // GROUP 2
END END
// Viene mostrato questo se TPD vuoto o uguale a IN AN PG // Viene mostrato questo se TPD vuoto o uguale a IN AN PG
LISTBOX F_TIPO_MOV_2 1 20 LISTBOX F_TIPO_MOV_2 1 20
BEGIN BEGIN
PROMPT 44 4 "Tipo mov. " PROMPT 44 4 "Tipo mov. "
FIELD LF_CAUSALI->TIPOMOV FIELD LF_CAUSALI->TIPOMOV
HELP "Inserire il tipo movimento" HELP "Inserire il tipo movimento"
ITEM " |Nessuno" MESSAGE COPY,F_TIPO_MOV ITEM " |Nessuno" MESSAGE COPY,F_TIPO_MOV
ITEM "3|Incasso/pagamento " MESSAGE COPY,F_TIPO_MOV ITEM "3|Incasso/pagamento " MESSAGE COPY,F_TIPO_MOV
ITEM "5|Insoluto" MESSAGE COPY,F_TIPO_MOV ITEM "5|Insoluto" MESSAGE COPY,F_TIPO_MOV
ITEM "6|Pagamento insoluto" MESSAGE COPY,F_TIPO_MOV ITEM "6|Pagamento insoluto" MESSAGE COPY,F_TIPO_MOV
FLAGS "H" FLAGS "H"
END END
STRING F_ANNOES 4 STRING F_ANNOES 4
BEGIN BEGIN
PROMPT 2 6 "" PROMPT 2 6 ""
FLAGS "H" FLAGS "H"
END END
STRING F_TIPO_REG 4 STRING F_TIPO_REG 4
BEGIN BEGIN
PROMPT 23 5 "" PROMPT 23 5 ""
FLAGS "H" FLAGS "H"
END END
BOOLEAN F_CORRISP BOOLEAN F_CORRISP
BEGIN BEGIN
PROMPT 33 5 "" PROMPT 33 5 ""
FLAGS "H" FLAGS "H"
END END
SPREADSHEET F_SHEET_GCS SPREADSHEET F_SHEET_GCS
BEGIN BEGIN
PROMPT 2 7 "" PROMPT 2 7 ""
ITEM "Tipo conto@21" ITEM "Tipo conto@21"
ITEM "C/F" ITEM "C/F"
ITEM "Gr." ITEM "Gr."
ITEM "Co." ITEM "Co."
ITEM "Sottoc." ITEM "Sottoc."
ITEM "D/A" ITEM "D/A"
ITEM "Descrizione@50" ITEM "Descrizione@50"
ITEM "Descr. agg." ITEM "Descr. agg."
ITEM "Iva" ITEM "Iva"
ITEM "Cod.Iva" ITEM "Cod.Iva"
END END
ENDPAGE ENDPAGE
PAGE "" -1 -1 77 20 PAGE "" -1 -1 77 20
GROUPBOX DLG_NULL -1 3 GROUPBOX DLG_NULL -1 3
BEGIN BEGIN
PROMPT 1 0 "Campi obbligatori in caricamento documenti" PROMPT 1 0 "@BCampi obbligatori in caricamento documenti"
END END
BOOLEAN F_DATA_DOC BOOLEAN F_DATA_DOC
BEGIN BEGIN
PROMPT 2 1 "Data documento" PROMPT 2 1 "Data documento"
FIELD LF_CAUSALI->DATADOC FIELD LF_CAUSALI->DATADOC
HELP "" HELP ""
CHECKTYPE NORMAL CHECKTYPE NORMAL
END END
BOOLEAN F_NUM_DOC BOOLEAN F_NUM_DOC
BEGIN BEGIN
PROMPT 34 1 "Numero documento" PROMPT 34 1 "Numero documento"
FIELD LF_CAUSALI->NUMDOC FIELD LF_CAUSALI->NUMDOC
CHECKTYPE NORMAL CHECKTYPE NORMAL
END END
BOOLEAN F_AUTO_FAT BOOLEAN F_AUTO_FAT
BEGIN BEGIN
PROMPT 2 4 "Autofattura art.34" PROMPT 2 4 "Autofattura art.34"
FIELD LF_CAUSALI->AUTOFATT FIELD LF_CAUSALI->AUTOFATT
CHECKTYPE NORMAL CHECKTYPE NORMAL
GROUP 2 GROUP 2
END END
BOOLEAN F_ALLEGAT BOOLEAN F_ALLEGAT
BEGIN BEGIN
PROMPT 34 4 "Documento in allegati" PROMPT 34 4 "Doc. non va in allegati fine anno"
FIELD LF_CAUSALI->ALLEG FIELD LF_CAUSALI->ALLEG
GROUP 2 GROUP 2
END END
BOOLEAN F_FAT_RITARDO BOOLEAN F_FAT_RITARDO
BEGIN BEGIN
PROMPT 2 6 "Fattura in ritardo" PROMPT 2 6 "Fattura in ritardo"
FIELD LF_CAUSALI->RITFATT FIELD LF_CAUSALI->RITFATT
GROUP 2 GROUP 2
END END
STRING F_COD_CAUS_IM 3 STRING F_COD_CAUS_IM 3
BEGIN BEGIN
PROMPT 34 6 "Codice causale per l'incasso immediato " PROMPT 34 6 "Codice causale per l'incasso immediato "
FIELD LF_CAUSALI->CODCAUSIM FIELD LF_CAUSALI->CODCAUSIM
COPY USE F_COD_CAUS COPY USE F_COD_CAUS
INPUT CODCAUS F_COD_CAUS_IM INPUT CODCAUS F_COD_CAUS_IM
COPY DISPLAY F_COD_CAUS COPY DISPLAY F_COD_CAUS
OUTPUT F_COD_CAUS_IM CODCAUS OUTPUT F_COD_CAUS_IM CODCAUS
CHECKTYPE NORMAL CHECKTYPE NORMAL
MESSAGE CLEAR, F_M_770 // MESSAGE CLEAR, F_M_770
GROUP 2 GROUP 2
END END
BOOLEAN F_OP_INTRACOM BOOLEAN F_OP_INTRACOM
BEGIN BEGIN
PROMPT 2 8 "Operazione intracomunitaria" PROMPT 2 8 "Operazione intracomunitaria"
FIELD LF_CAUSALI->INTRACOM FIELD LF_CAUSALI->INTRACOM
MESSAGE TRUE "X", F_MOV_VALU | DISABLE, F_MOV_VALU // MESSAGE TRUE "X", F_MOV_VALU | DISABLE, F_MOV_VALU
MESSAGE FALSE "", F_MOV_VALU | ENABLE, F_MOV_VALU // MESSAGE FALSE "", F_MOV_VALU | ENABLE, F_MOV_VALU
GROUP 2 GROUP 2
END END
BOOLEAN F_VALINTRA BOOLEAN F_VALINTRA
BEGIN BEGIN
PROMPT 34 8 "Gestione valuta per operazioni intrac." PROMPT 34 8 "Gestione valuta per operazioni intrac."
FIELD LF_CAUSALI->VALINTRA FIELD LF_CAUSALI->VALINTRA
GROUP 2 GROUP 2
END END
BOOLEAN F_MOV_VALU BOOLEAN F_MOV_VALU
BEGIN BEGIN
PROMPT 2 10 "Movimento in valuta" PROMPT 2 10 "Movimento in valuta"
FIELD LF_CAUSALI->MOVVAL FIELD LF_CAUSALI->MOVVAL
GROUP 2 GROUP 2
END END
BOOLEAN F_MOV_SEZ BOOLEAN F_MOV_SEZ
BEGIN BEGIN
PROMPT 34 10 "Movimento solo sezionale" PROMPT 34 10 "Movimento solo sezionale"
FIELD LF_CAUSALI->MOVSEZ FIELD LF_CAUSALI->MOVSEZ
FLAGS "D" FLAGS "H"
END END
LISTBOX F_OP_FINE_ANNO 1 10 LISTBOX F_OP_FINE_ANNO 1 10
BEGIN BEGIN
PROMPT 2 12 "Operazioni di fine anno " PROMPT 2 12 "Operazioni di fine anno "
ITEM " | " ITEM " | "
ITEM "C|Chiusura" ITEM "C|Chiusura"
ITEM "A|Apertura" ITEM "A|Apertura"
FIELD LF_CAUSALI->MOVAP FIELD LF_CAUSALI->MOVAP
FLAGS "H" FLAGS "H"
END END
LISTBOX F_COLL_CESP 1 40 LISTBOX F_COLL_CESP 1 40
BEGIN BEGIN
PROMPT 2 14 "Collegamento cespiti " PROMPT 2 14 "Collegamento cespiti "
FIELD LF_CAUSALI->COLLCESP FIELD LF_CAUSALI->COLLCESP
HELP "Inserire il tipo di collegamento cespiti" HELP "Inserire il tipo di collegamento cespiti"
ITEM " |Nessuno" ITEM " |Nessuno"
ITEM "A|Acquisto cespite" ITEM "A|Acquisto cespite"
ITEM "B|Rettifica acquisto" ITEM "B|Rettifica acquisto"
ITEM "C|Sostenimento costi" ITEM "C|Sostenimento costi"
ITEM "E|Eliminazione dal processo produttivo" ITEM "E|Eliminazione dal processo produttivo"
ITEM "M|Rivalutazione monetaria" ITEM "M|Rivalutazione monetaria"
ITEM "P|Reinvestimento plusvalenze" ITEM "P|Reinvestimento plusvalenze"
ITEM "R|Rivalutazione economica" ITEM "R|Rivalutazione economica"
ITEM "T|Trasferimento" ITEM "T|Trasferimento"
ITEM "V|Vendita cespite" ITEM "V|Vendita cespite"
ITEM "Z|Rettifica vendita" ITEM "Z|Rettifica vendita"
END END
LISTBOX F_M_770 1 40 LISTBOX F_M_770 1 40
BEGIN BEGIN
PROMPT 2 16 "Collegamento Mod.770 " PROMPT 2 16 "Collegamento Mod.770 "
FIELD LF_CAUSALI->M770 FIELD LF_CAUSALI->M770
HELP "Inserire il tipo di collegamento Mod.770" HELP "Inserire il tipo di collegamento Mod.770"
ITEM " |Nessuno" MESSAGE ENABLE,F_COD_CAUS_IM ITEM " |Nessuno" // MESSAGE ENABLE,F_COD_CAUS_IM
ITEM "1|Ricevuta e/o pagamento fattura percip." MESSAGE CLEAR,F_COD_CAUS_IM ITEM "1|Ricevuta e/o pagamento fattura percip." // MESSAGE CLEAR,F_COD_CAUS_IM
ITEM "2|Versamento ritenute percip." MESSAGE CLEAR,F_COD_CAUS_IM ITEM "2|Versamento ritenute percip." // MESSAGE CLEAR,F_COD_CAUS_IM
ITEM "3|Versamento ritenute dipendente" MESSAGE CLEAR,F_COD_CAUS_IM ITEM "3|Versamento ritenute dipendente" // MESSAGE CLEAR,F_COD_CAUS_IM
ITEM "4|Versamento contributi dipendente" MESSAGE CLEAR,F_COD_CAUS_IM ITEM "4|Versamento contributi dipendente" // MESSAGE CLEAR,F_COD_CAUS_IM
ITEM "5|Compensi non soggetti" MESSAGE CLEAR,F_COD_CAUS_IM ITEM "5|Compensi non soggetti" // MESSAGE CLEAR,F_COD_CAUS_IM
ITEM "6|Ritenute per operazioni occasionali" MESSAGE CLEAR,F_COD_CAUS_IM ITEM "6|Ritenute per operazioni occasionali" // MESSAGE CLEAR,F_COD_CAUS_IM
END END
ENDPAGE ENDPAGE
ENDMASK ENDMASK
#include "cg0500b.uml" #include "cg0500b.uml"

404
cg/cg0500b.uml
View File

@ -1,201 +1,203 @@
#include "cg0500.h"
#include "cg0500.h"
PAGE "" -1 -1 68 11
PAGE "" -1 -1 68 11
STRING 101 22
BEGIN STRING 101 22
PROMPT 1 1 "Tipo " BEGIN
FLAGS "D" PROMPT 1 1 "Tipo "
END FLAGS "D"
END
LISTBOX 102 1 11
BEGIN LISTBOX 102 1 11
PROMPT 33 1 "C/F " BEGIN
ITEM " |Conto" PROMPT 33 1 "C/F "
MESSAGE SHOW,105|HIDE,205|HIDE,305 ITEM " |Conto"
ITEM "C|Cliente" MESSAGE SHOW,105|HIDE,205|HIDE,305
MESSAGE SHOW,205|HIDE,105|HIDE,305 ITEM "C|Cliente"
ITEM "F|Fornitore" MESSAGE SHOW,205|HIDE,105|HIDE,305
MESSAGE SHOW,305|HIDE,105|HIDE,205 ITEM "F|Fornitore"
FLAGS "DG" MESSAGE SHOW,305|HIDE,105|HIDE,205
GROUP 1 FLAGS "DG"
// FLAGS "U" GROUP 1
END // FLAGS "U"
END
NUMBER 103 3
BEGIN NUMBER 103 3
PROMPT 1 3 "Gruppo " BEGIN
FIELD LF_RCAUSALI->GRUPPO PROMPT 1 3 "Gruppo "
USE LF_PCON KEY 1 SELECT (CONTO="") && (SOTTOCONTO="") FIELD LF_RCAUSALI->GRUPPO
INPUT GRUPPO 103 USE LF_PCON KEY 1 SELECT (CONTO="") && (SOTTOCONTO="")
DISPLAY "Gruppo" GRUPPO INPUT GRUPPO 103
DISPLAY "Descrizione@50" DESCR DISPLAY "Gruppo" GRUPPO
DISPLAY "Tipo C/F" TMCF DISPLAY "Descrizione@50" DESCR
CHECKTYPE NORMAL DISPLAY "Tipo C/F" TMCF
OUTPUT 103 GRUPPO CHECKTYPE NORMAL
OUTPUT 107 DESCR OUTPUT 103 GRUPPO
// OUTPUT 102 TMCF OUTPUT 107 DESCR
WARNING "Gruppo inesistente o mancante" // OUTPUT 102 TMCF
// CHECKTYPE REQUIRED WARNING "Gruppo inesistente o mancante"
CHECKTYPE NORMAL // CHECKTYPE REQUIRED
GROUP 1 CHECKTYPE NORMAL
ADD RUN CG0 -1 GROUP 1
END ADD RUN CG0 -0
END
NUMBER 104 3
BEGIN NUMBER 104 3
PROMPT 15 3 "Conto " BEGIN
FIELD LF_RCAUSALI->CONTO PROMPT 15 3 "Conto "
USE LF_PCON KEY 1 SELECT (CONTO!="") && (SOTTOCONTO="") FIELD LF_RCAUSALI->CONTO
INPUT GRUPPO 103 USE LF_PCON KEY 1 SELECT (CONTO!="") && (SOTTOCONTO="")
INPUT CONTO 104 INPUT GRUPPO 103
DISPLAY "Gruppo" GRUPPO INPUT CONTO 104
DISPLAY "Conto" CONTO DISPLAY "Gruppo" GRUPPO
DISPLAY "Descrizione@50" DESCR DISPLAY "Conto" CONTO
DISPLAY "Tipo C/F" TMCF DISPLAY "Descrizione@50" DESCR
CHECKTYPE NORMAL DISPLAY "Tipo C/F" TMCF
OUTPUT 102 TMCF CHECKTYPE NORMAL
OUTPUT 104 CONTO OUTPUT 102 TMCF
OUTPUT 103 GRUPPO OUTPUT 104 CONTO
OUTPUT 107 DESCR OUTPUT 103 GRUPPO
WARNING "Conto inesistente o mancante" OUTPUT 107 DESCR
ADD RUN CG0 -1 WARNING "Conto inesistente o mancante"
GROUP 1 ADD RUN CG0 -0
END GROUP 1
END
// Sottoconto NORMALE
NUMBER 105 6 // Sottoconto NORMALE
BEGIN NUMBER 105 6
PROMPT 29 3 "Sottoconto " BEGIN
FIELD LF_RCAUSALI->SOTTOCONTO PROMPT 29 3 "Sottoconto "
USE LF_PCON SELECT SOTTOCONTO!="" FIELD LF_RCAUSALI->SOTTOCONTO
INPUT GRUPPO 103 USE LF_PCON SELECT SOTTOCONTO!=""
INPUT CONTO 104 INPUT GRUPPO 103
INPUT SOTTOCONTO 105 INPUT CONTO 104
DISPLAY "Gruppo" GRUPPO INPUT SOTTOCONTO 105
DISPLAY "Conto" CONTO DISPLAY "Gruppo" GRUPPO
DISPLAY "Sottoconto" SOTTOCONTO DISPLAY "Conto" CONTO
DISPLAY "Descrizione@50" DESCR DISPLAY "Sottoconto" SOTTOCONTO
OUTPUT 103 GRUPPO DISPLAY "Descrizione@50" DESCR
OUTPUT 104 CONTO OUTPUT 103 GRUPPO
OUTPUT 105 SOTTOCONTO OUTPUT 104 CONTO
OUTPUT 107 DESCR OUTPUT 105 SOTTOCONTO
ADD RUN CG0 -1 OUTPUT 107 DESCR
CHECKTYPE NORMAL ADD RUN CG0 -0
GROUP 1 CHECKTYPE NORMAL
END GROUP 1
END
// Sottoconto CLIENTI
NUMBER 205 6 // Sottoconto CLIENTI
BEGIN NUMBER 205 6
PROMPT 29 3 "Cliente " BEGIN
FIELD LF_RCAUSALI->SOTTOCONTO PROMPT 29 3 "Cliente "
USE LF_CLIFO KEY 1 SELECT (TIPOCF=="C") FIELD LF_RCAUSALI->SOTTOCONTO
INPUT TIPOCF "C" USE LF_CLIFO KEY 1 SELECT (TIPOCF=="C")
INPUT CODCF 205 INPUT TIPOCF "C"
DISPLAY "Gruppo" GRUPPO INPUT CODCF 205
DISPLAY "Conto" CONTO DISPLAY "Gruppo" GRUPPO
DISPLAY "Sottoconto" CODCF DISPLAY "Conto" CONTO
DISPLAY "Ragione sociale@50" RAGSOC DISPLAY "Sottoconto" CODCF
DISPLAY "Tipo C/F" TIPOCF DISPLAY "Ragione sociale@50" RAGSOC
OUTPUT 205 CODCF DISPLAY "Tipo C/F" TIPOCF
OUTPUT 107 RAGSOC OUTPUT 205 CODCF
CHECKTYPE NORMAL OUTPUT 107 RAGSOC
FLAGS "H" CHECKTYPE NORMAL
MESSAGE COPY,105 FLAGS "H"
ADD RUN CG0 -1 MESSAGE COPY,105
GROUP 1 ADD RUN CG0 -1
END GROUP 1
END
// Sottoconto FORNITORI
NUMBER 305 6 // Sottoconto FORNITORI
BEGIN NUMBER 305 6
PROMPT 29 3 "Fornitore " BEGIN
FIELD LF_RCAUSALI->SOTTOCONTO PROMPT 29 3 "Fornitore "
USE LF_CLIFO KEY 1 SELECT (TIPOCF=="F") FIELD LF_RCAUSALI->SOTTOCONTO
INPUT TIPOCF "F" USE LF_CLIFO KEY 1 SELECT (TIPOCF=="F")
INPUT CODCF 305 INPUT TIPOCF "F"
DISPLAY "Gruppo" GRUPPO INPUT CODCF 305
DISPLAY "Conto" CONTO DISPLAY "Gruppo" GRUPPO
DISPLAY "Sottoconto" CODCF DISPLAY "Conto" CONTO
DISPLAY "Ragione sociale@50" RAGSOC DISPLAY "Sottoconto" CODCF
DISPLAY "Tipo C/F" TIPOCF DISPLAY "Ragione sociale@50" RAGSOC
OUTPUT 305 CODCF DISPLAY "Tipo C/F" TIPOCF
OUTPUT 107 RAGSOC OUTPUT 305 CODCF
CHECKTYPE NORMAL OUTPUT 107 RAGSOC
FLAGS "H" CHECKTYPE NORMAL
MESSAGE COPY,105 FLAGS "H"
ADD RUN CG0 -1 MESSAGE COPY,105
GROUP 1 ADD RUN CG0 -1
END GROUP 1
END
LISTBOX 106 5
BEGIN LISTBOX 106 5
PROMPT 51 3 "Sezione " BEGIN
ITEM "D|Dare" PROMPT 51 3 "Sezione "
ITEM "A|Avere" ITEM "D|Dare"
FIELD LF_RCAUSALI->SEZIONE ITEM "A|Avere"
CHECKTYPE REQUIRED FIELD LF_RCAUSALI->SEZIONE
END CHECKTYPE REQUIRED
FLAGS "U"
STRING 107 50 END
BEGIN
PROMPT 1 5 "Descrizione " STRING 107 50
FIELD LF_RCAUSALI->DESC BEGIN
GROUP 1 PROMPT 1 5 "Descrizione "
END FIELD LF_RCAUSALI->DESC
GROUP 1
STRING 108 3 END
BEGIN
PROMPT 1 7 "Descrizione aggiuntiva " STRING 108 3
FIELD LF_RCAUSALI->CODDESC BEGIN
USE %DPN PROMPT 1 7 "Descrizione aggiuntiva "
INPUT CODTAB 108 FIELD LF_RCAUSALI->CODDESC
DISPLAY "Codice" CODTAB USE %DPN
DISPLAY "Descrizione @50" S0 INPUT CODTAB 108
OUTPUT 108 CODTAB DISPLAY "Codice" CODTAB
FLAGS "R" DISPLAY "Descrizione @50" S0
CHECKTYPE NORMAL OUTPUT 108 CODTAB
GROUP 1 FLAGS "R"
END CHECKTYPE NORMAL
GROUP 1
BOOLEAN 109 END
BEGIN
PROMPT 34 7 "Riga iva " BOOLEAN 109
FIELD LF_RCAUSALI->RIGAIVA BEGIN
FLAGS "D" PROMPT 34 7 "Riga iva "
END FIELD LF_RCAUSALI->RIGAIVA
FLAGS "D"
STRING 110 4 END
BEGIN
USE %IVA STRING 110 4
PROMPT 48 7 "Codice iva " BEGIN
INPUT CODTAB 110 USE %IVA
FIELD LF_RCAUSALI->CODIVA PROMPT 48 7 "Codice iva "
DISPLAY "Codice " CODTAB INPUT CODTAB 110
DISPLAY "Descrizione @50" S0 FIELD LF_RCAUSALI->CODIVA
OUTPUT 110 CODTAB DISPLAY "Codice " CODTAB
FLAGS "D" DISPLAY "Descrizione @50" S0
GROUP 1 OUTPUT 110 CODTAB
END FLAGS "D"
GROUP 1
BUTTON DLG_OK 9 2 END
BEGIN
PROMPT -13 -1 "" BUTTON DLG_OK 9 2
END BEGIN
PROMPT -13 -1 ""
BUTTON DLG_CANCEL 9 2 END
BEGIN
PROMPT -23 -1 "" BUTTON DLG_CANCEL 9 2
END BEGIN
PROMPT -23 -1 ""
BUTTON DLG_NULL 9 2 END
BEGIN
PROMPT -33 -1 "Azzera" BUTTON DLG_NULL 9 2
MESSAGE RESET,1@ BEGIN
END PROMPT -33 -1 "Azzera"
MESSAGE RESET,1@
ENDPAGE END
ENDMASK ENDPAGE
ENDMASK

19
cg/cg3200.cpp
View File

@ -60,9 +60,8 @@ class CG3200_application : public TPrintapp
bool _stampaprogre,_stampatotiva,_stampatot,_prima_volta,_stampa_mov_prov; bool _stampaprogre,_stampatotiva,_stampatot,_prima_volta,_stampa_mov_prov;
int _annomsk,_annoesmsk,_annoes,_annomsksucc; long _annomsk,_annoesmsk,_sottoc,_numreg,_annoes;
long _sottoc,_numreg,_protiva,_numgio; long _annomsksucc,_numgio,_protiva;
bool _stampa_progressivi_si,_competenza,_inizio_stampa,_puoi_stampare; bool _stampa_progressivi_si,_competenza,_inizio_stampa,_puoi_stampare;
int _tipocf; int _tipocf;
char _ricerca; char _ricerca;
@ -438,7 +437,7 @@ bool CG3200_application::preprocess_pconti(int file, int counter)
_mov->curr().zero(); _mov->curr().zero();
_mov->curr().put(MOV_NUMREG,_numreg); _mov->curr().put(MOV_NUMREG,_numreg);
_mov->read(); _mov->read();
_annoes = _mov->get_int(MOV_ANNOES); _annoes = atol(_mov->curr().get(MOV_ANNOES));
_regiva = _mov->curr().get(MOV_REG); _regiva = _mov->curr().get(MOV_REG);
// Controlla se saldo e' diverso da 0 // Controlla se saldo e' diverso da 0
@ -468,7 +467,7 @@ bool CG3200_application::preprocess_pconti(int file, int counter)
_numdoc = _mov->curr().get(MOV_NUMDOC); _numdoc = _mov->curr().get(MOV_NUMDOC);
descrizione_causale(); descrizione_causale();
_descrizionemov = _mov->curr().get(MOV_DESCR); _descrizionemov = _mov->curr().get(MOV_DESCR);
_numgio = _mov->get_long(MOV_NUMGIO); _numgio = atol(_mov->curr().get(MOV_NUMGIO));
if (_sezione == "D") if (_sezione == "D")
{ {
_totale_periodo_dare += _importo; _totale_periodo_dare += _importo;
@ -592,7 +591,7 @@ bool CG3200_application::preprocess_clifo(int file, int counter)
_mov->curr().zero(); _mov->curr().zero();
_mov->curr().put(MOV_NUMREG,_numreg); _mov->curr().put(MOV_NUMREG,_numreg);
_mov->read(); _mov->read();
_annoes = _mov->get_int(MOV_ANNOES); _annoes = atol(_mov->curr().get(MOV_ANNOES));
_regiva = _mov->curr().get(MOV_REG); _regiva = _mov->curr().get(MOV_REG);
// Controlla se saldo e' diverso da 0 // Controlla se saldo e' diverso da 0
@ -622,7 +621,7 @@ bool CG3200_application::preprocess_clifo(int file, int counter)
_numdoc = _mov->curr().get(MOV_NUMDOC); _numdoc = _mov->curr().get(MOV_NUMDOC);
descrizione_causale(); descrizione_causale();
_descrizionemov = _mov->curr().get(MOV_DESCR); _descrizionemov = _mov->curr().get(MOV_DESCR);
_numgio = _mov->get_int(MOV_NUMGIO); _numgio = atol(_mov->curr().get(MOV_NUMGIO));
if (_sezione == "D") if (_sezione == "D")
{ {
_totale_periodo_dare += _importo; _totale_periodo_dare += _importo;
@ -929,7 +928,7 @@ bool CG3200_application::set_print(int)
_data_ini = (_msk->get(F_DATAINI)); _data_ini = (_msk->get(F_DATAINI));
_data_fine = (_msk->get(F_DATAFINE)); _data_fine = (_msk->get(F_DATAFINE));
_annomsk = _msk->get_int(F_ANNO); _annomsk = atol(_msk->get(F_ANNO));
if (_annomsk == 0) if (_annomsk == 0)
if (_data_fine == botime) //Se data_fine e' vuota if (_data_fine == botime) //Se data_fine e' vuota
@ -1000,7 +999,7 @@ bool CG3200_application::set_print(int)
a.put(PCN_CONTO,contofine); a.put(PCN_CONTO,contofine);
a.put(PCN_SOTTOCONTO,sottocontofine); a.put(PCN_SOTTOCONTO,sottocontofine);
current_cursor()->setregion(da, a); current_cursor()->setregion(&da, &a);
} }
else else
{ {
@ -1030,7 +1029,7 @@ bool CG3200_application::set_print(int)
a.put(CLI_CONTO,contofine); a.put(CLI_CONTO,contofine);
a.put(CLI_CODCF,sottocontofine); a.put(CLI_CODCF,sottocontofine);
current_cursor()->setregion(da, a); current_cursor()->setregion(&da, &a);
} }
if (_stampatotiva) if (_stampatotiva)

548
cg/cg4400.cpp
View File

@ -6,7 +6,7 @@
TFixed_string TMP (__tmp, MAXSTR); TFixed_string TMP (__tmp, MAXSTR);
HIDDEN CG4400_application * app() { return (CG4400_application*) MainApp(); } CG4400_application * app() { return (CG4400_application*) MainApp(); }
bool filter_func (const TRelation * r) bool filter_func (const TRelation * r)
{ {
@ -17,10 +17,12 @@ bool filter_func (const TRelation * r)
if (codreg != app()->_codreg || annoes != app()->_annoes) if (codreg != app()->_codreg || annoes != app()->_annoes)
return FALSE; return FALSE;
if (app()->_stampa_tutti_i_registri)
if ( (app()->_tipo_reg != 1) && (app()->_tipo_reg != 2) ) //Non puo' essere che _tipo_reg sia diverso da 1 o 2, nel caso di stampa tutti i registri !
return FALSE; //if (app()->_stampa_tutti_i_registri)
// if ( (app()->_tipo_reg != 1) && (app()->_tipo_reg != 2) )
// return FALSE;
return TRUE; return TRUE;
} }
@ -36,9 +38,12 @@ HIDDEN int compare(const TObject** o1, const TObject** o2)
{ {
TRigaiva* r1 = (TRigaiva*)*o1; TRigaiva* r1 = (TRigaiva*)*o1;
TRigaiva* r2 = (TRigaiva*)*o2; TRigaiva* r2 = (TRigaiva*)*o2;
TString16 campo1; campo1.format("%d%4s", r1->_tipodet, (const char*)r1->_codiva); TString campo1;
TString16 campo2; campo2.format("%d%4s", r2->_tipodet, (const char*)r2->_codiva); TString campo2;
return (strcmp(campo1, campo2));
campo1.format("%d%4s", r1->_tipodet, (const char*)r1->_codiva);
campo2.format("%d%4s", r2->_tipodet, (const char*)r2->_codiva);
return (strcmp((const char*)campo1, (const char*)campo2));
} }
/* /*
@ -60,6 +65,8 @@ bool mask_select (TMask_field& f, KEY k)
// build sheet // build sheet
if (k == K_SPACE) if (k == K_SPACE)
{ {
f.mask().field(DA_CODICE).set("");
f.mask().field(A_CODICE).set("");
app()->_ditte->destroy(); chk = 0l; app()->_ditte->destroy(); chk = 0l;
for (i = 0; i < app()->_nomiditte.items(); i++) for (i = 0; i < app()->_nomiditte.items(); i++)
{ {
@ -158,9 +165,9 @@ bool mask_cod (TMask_field& f, KEY k)
TabLbu.read(); TabLbu.read();
if ( TabLbu.good() ) if ( TabLbu.good() )
{ {
f.mask().set(MESE,TabLbu.get_long("I0")+1); // f.mask().set(MESE,TabLbu.get_long("I0")+1);
f.mask().set(ULTIMO_MESE,TabLbu.get_long("I0")); f.mask().set(ULTIMO_MESE,TabLbu.get_long("I0"));
f.mask().set(ULTIMA_PAGINA,TabLbu.get("I1")); f.mask().set(ULTIMA_PAGINA,TabLbu.get_long("I1"));
} }
} }
return TRUE; return TRUE;
@ -168,7 +175,8 @@ bool mask_cod (TMask_field& f, KEY k)
bool mask_fino_a_mese (TMask_field& f, KEY k) bool mask_fino_a_mese (TMask_field& f, KEY k)
{ {
if ( (k == K_TAB) && f.mask().is_running() ) //if ( (k == K_TAB) && f.mask().is_running() )
if (k == K_ENTER)
{ {
TTable TabReg ("REG"); TTable TabReg ("REG");
TString16 codtab; TString16 codtab;
@ -188,7 +196,8 @@ bool mask_fino_a_mese (TMask_field& f, KEY k)
--primo; --primo;
giorni_del_mese = primo.day(); giorni_del_mese = primo.day();
} }
TDate datasup = format("%02d/%02d/%4d",giorni_del_mese,fino_a_mese,anno); if (codreg != "") TDate datasup = format("%02d/%02d/%4d",giorni_del_mese,fino_a_mese,anno);
if (codreg != "")
{ {
TabReg.zero(); TabReg.zero();
codtab << anno << codreg; codtab << anno << codreg;
@ -199,7 +208,7 @@ bool mask_fino_a_mese (TMask_field& f, KEY k)
TDate data = TabReg.get_date("D3"); TDate data = TabReg.get_date("D3");
if (datasup < data) if (datasup < data)
{ {
TString16 datas = format("02d/%4d", data.month(), data.year()); TString16 datas = format("%02d/%4d", data.month(), data.year());
f.warning_box ("La data specificata non deve essere inferiore al %s (ultima data di stampa specificata sul registro)", (const char*)datas); f.warning_box ("La data specificata non deve essere inferiore al %s (ultima data di stampa specificata sul registro)", (const char*)datas);
return FALSE; return FALSE;
} }
@ -221,7 +230,7 @@ bool mask_fino_a_mese (TMask_field& f, KEY k)
TDate data = TabReg.get_date("D3"); TDate data = TabReg.get_date("D3");
if (datasup > data) if (datasup > data)
{ {
TString16 datas = format("02d/%4d", data.month(), data.year()); TString16 datas = format("%02d/%4d", data.month(), data.year());
f.warning_box ("La data specificata non deve essere superiore al %s (ultima data di stampa del libro giornale)", (const char*)datas); f.warning_box ("La data specificata non deve essere superiore al %s (ultima data di stampa del libro giornale)", (const char*)datas);
return FALSE; return FALSE;
} }
@ -295,7 +304,6 @@ const char * CG4400_application::descr_doc(const char * tipo)
TString codtab = format ("%-2s", tipo); TString codtab = format ("%-2s", tipo);
tab_tpd.zero(); tab_tpd.zero();
tab_tpd.put("CODTAB", codtab); tab_tpd.put("CODTAB", codtab);
if (tab_tpd.read()==NOERR) if (tab_tpd.read()==NOERR)
TMP = tab_tpd.get("S0"); TMP = tab_tpd.get("S0");
@ -311,7 +319,6 @@ const char * CG4400_application::descr_iva(const char * cod)
TString codtab = format ("%-4s", cod); TString codtab = format ("%-4s", cod);
tab_iva.zero(); tab_iva.zero();
tab_iva.put("CODTAB", codtab); tab_iva.put("CODTAB", codtab);
if (tab_iva.read()==NOERR) if (tab_iva.read()==NOERR)
TMP = tab_iva.get("S0"); TMP = tab_iva.get("S0");
@ -362,9 +369,9 @@ const char * CG4400_application::ricerca_occ(const char * occ)
void CG4400_application::user_create() void CG4400_application::user_create()
{ {
_nditte = new TLocalisamfile(LF_NDITTE); _nditte = new TLocalisamfile(LF_NDITTE);
_ditte = new TArray_sheet(-1, -1, 0, 0, "Selezione Ditte", _ditte = new TArray_sheet(-1, -1, 0, 0, "Selezione Ditte",
"@1|Cod.@5|Ragione Sociale@50"); "@1|Cod.@5|Ragione Sociale@50");
_n_ditte = 0l; _n_ditte = 0l;
for (_nditte->first(); !_nditte->eof(); _nditte->next()) for (_nditte->first(); !_nditte->eof(); _nditte->next())
{ {
@ -378,13 +385,15 @@ void CG4400_application::user_create()
_tab = new TLocalisamfile(LF_TAB); _tab = new TLocalisamfile(LF_TAB);
_tabcom = new TLocalisamfile(LF_TABCOM); _tabcom = new TLocalisamfile(LF_TABCOM);
_tabreg = new TTable("REG"); _tabreg = new TTable("REG");
_tablbu = new TTable("%LBU");
_tabinl = new TTable("%INL");
_clifo = new TLocalisamfile(LF_CLIFO); _clifo = new TLocalisamfile(LF_CLIFO);
_occas = new TLocalisamfile(LF_OCCAS); _occas = new TLocalisamfile(LF_OCCAS);
_rel = new TRelation (LF_MOV); _rel = new TRelation (LF_MOV);
_rel->add(LF_CAUSALI,"CODCAUS=CODCAUS",1,LF_MOV); _rel->add(LF_CAUSALI,"CODCAUS=CODCAUS",1,LF_MOV);
_rel->add(LF_RMOVIVA,"NUMREG=NUMREG",1,LF_MOV); _rel->add(LF_RMOVIVA,"NUMREG=NUMREG",1,LF_MOV);
_cur = new TCursor(_rel, "", 1); _cur = new TCursor(_rel, "", 1);
_cur->set_filterfunction(filter_func); //_cur->set_filterfunction(filter_func);
add_cursor(_cur); add_cursor(_cur);
add_file(LF_MOV); add_file(LF_MOV);
@ -571,38 +580,108 @@ bool CG4400_application::controlla_liquidazione()
return TRUE; return TRUE;
} }
/*controlla che i movimenti con data di registrazione compresa tra l'anno precednte e l'ultima data stampata siano tutti gia' stati stampati*/ //controlla che i movimenti con data di registrazione compresa tra l'anno precedente e l'ultima data stampata siano tutti gia' stati stampati in forma definitiva*/
bool CG4400_application::controlla_mov() bool CG4400_application::controlla_mov()
{ {
TLocalisamfile mov (LF_MOV); TLocalisamfile mov (LF_MOV);
bool stampato, ok = TRUE; bool ok = TRUE;
long numreg; byte tipo;
TString codreg; TDate udata;
mov.zero();
TRectype a (mov.curr());
TDate data = format("01/01/%4d", _annoes - 1); TDate data = format("01/01/%4d", _annoes - 1);
mov.put(MOV_DATAREG, data); TRecnotype rec = _tabreg->recno();
a.put (MOV_DATAREG, _data_da); for (mov.first(); !mov.eof(); mov.next())
mov.read(_isgteq);
while (mov.curr() < a && !mov.eof())
{ {
stampato = mov.get_bool(MOV_STAMPATO); TString16 reg = mov.get(MOV_REG);
numreg = mov.get_long(MOV_NUMREG); TDate datareg = mov.get_date(MOV_DATAREG);
if (!_stampa_tutti_i_registri) if (_stampa_tutti_i_registri)
codreg = mov.get(MOV_REG); cerca_reg (reg, tipo, udata);
else codreg = ""; else udata = _data_da;
if (codreg == _codreg) if ( (_stampa_tutti_i_registri && ((tipo == 1)||(tipo == 2)))
if (!stampato) || ((!_stampa_tutti_i_registri)&&(reg == _codreg)) )
{ if ( (datareg >= data) && (datareg <= udata) )
warning_box("Il movimento con numero di registrazione %ld non e' ancora stato stampato in forma definitiva!", numreg); {
ok = FALSE; bool stampato = mov.get_bool(MOV_STAMPATO);
} long numreg = mov.get_long(MOV_NUMREG);
mov.next(); if (!stampato)
} {
warning_box("Il movimento con numero di registrazione %ld non e' ancora stato stampato in forma definitiva!", numreg);
ok = FALSE;
}
}
}
_tabreg->readat(rec);
return ok; return ok;
} }
void CG4400_application::cerca_reg(const TString& c, byte& t, TDate& d)
{
TString16 cod = "";
cod << _annoes << c;
_tabreg->zero();
_tabreg->put("CODTAB", cod);
if (_tabreg->read() == NOERR)
{
t = _tabreg->get_int ("I0");
d = _tabreg->get_date("D3");
}
}
/*
bool CG4400_application::controlla_mov()
{
bool ok = TRUE;
if (_stampa_tutti_i_registri)
{
TRecnotype rec = _tabreg->recno();//la first l'ho gia' fatta
for (; !_tabreg->eof(); _tabreg->next())
{
TString codtab = _tabreg->get("CODTAB");
int anno = atoi(codtab.mid(0,4));
if (anno != _annoes) break;
TDate data_da = _tabreg->get_date("D3");
TString16 codreg = codtab.mid(4,3);
leggi_movimenti(data_da, codreg, ok);
}
_tabreg->readat(rec);
}
else
leggi_movimenti(_data_da, _codreg, ok);
return ok;
}
void CG4400_application::leggi_movimenti(const TDate& d, const TString& cod, bool& ok)
{
TLocalisamfile mov (LF_MOV);
bool stampato;
long numreg;
TString codreg;
TDate data = format("01/01/%4d", _annoes - 1);
mov.zero();
TRectype a (mov.curr());
mov.put(MOV_DATAREG, data);
a.put (MOV_DATAREG, d);
mov.read(_isgteq);
while (mov.curr() < a && !mov.eof())
{
stampato = mov.get_bool(MOV_STAMPATO);
numreg = mov.get_long(MOV_NUMREG);
codreg = mov.get(MOV_REG);
if (codreg == cod)
if (!stampato)
{
warning_box("Il movimento con numero di registrazione %ld non e' ancora stato stampato in forma definitiva!", numreg);
ok = FALSE;
}
mov.next();
}
}
*/
void CG4400_application::set_page_tot_reg() void CG4400_application::set_page_tot_reg()
{ {
TString riga(_stampa_width); TString riga(_stampa_width);
@ -764,7 +843,94 @@ void CG4400_application::set_page_tot_reg()
set_row(rw, "@81g%r@98g%r", &tot_imponibp, &tot_impostap); set_row(rw, "@81g%r@98g%r", &tot_imponibp, &tot_impostap);
} }
_iva_array.destroy(); _iva_array.destroy();
} }
}
bool CG4400_application::compila_reg()
{
byte tipo;
int anno;
long codditta = _nditte->get_long("CODDITTA");
_codtab = "";
if (_codreg.trim().empty())
{
_stampa_tutti_i_registri = TRUE;
for (_tabreg->first(); !_tabreg->eof(); _tabreg->next())
{
_codtab = _tabreg->get("CODTAB");
tipo = _tabreg->get_int("I0");
anno = atoi(_codtab.mid(0,4));
if (anno > _annoes)
{
warning_box("Non esistono registri IVA della Ditta %ld per l'anno %d",
codditta, _annoes);
return FALSE;
}
if (anno == _annoes)
{
if ( tipo == 1 || tipo == 2 ) //registro iva
{
_codreg = _codtab.mid(4,3);
_tipo_reg = _tabreg->get_int("I0");
_pagine_stampate = _tabreg->get_int("I1");
_data_da = _tabreg->get_date ("D3");
_codatt = _tabreg->get("S8");
_attivita = desc_attivita(_codatt);
_desc_lib = _tabreg->get ("S0");
break;
}
else continue;
}
}
}
else // stampa un solo registro
{
_stampa_tutti_i_registri = FALSE;
_codtab << _annoes << _codreg;
_tabreg->zero();
_tabreg->put("CODTAB", _codtab);
if (_tabreg->read() == NOERR)
{
_tipo_reg = _tabreg->get_int("I0");
_pagine_stampate = _tabreg->get_int("I1");
//_pagine_numerate = tab_reg.get_int("I2");
//_stampa_ok = tab_reg.get_int("I7");
//_nprog_da = tab_reg.get_long ("I6");
//_tot_dare = tab_reg.get_real ("R1")
//_tot_avere = tab_reg.get_real ("R2");
_data_da = _tabreg->get_date ("D3");
//_stampa_intesta = _tabreg->get_bool ("B9");
_codatt = _tabreg->get("S8");
_attivita = desc_attivita(_codatt);
_desc_lib = _tabreg->get ("S0");
return TRUE;
}
else
{
warning_box("Il registro IVA specificato non esiste nella \n Ditta %ld", codditta, _annoes);
return FALSE;
}
}
return TRUE;;
}
bool CG4400_application::compila_lib()
{
TTable tab_lib ("%LBU");
TString16 cod;
cod << _annoes << _codlib;
tab_lib.zero();
tab_lib.put("CODTAB", cod);
if (tab_lib.read() == NOERR)
{
_stampa_ind_ditta = tab_lib.get_bool("B1");
return TRUE;
}
return FALSE;
} }
bool CG4400_application::preprocess_print(int file, int counter) bool CG4400_application::preprocess_print(int file, int counter)
@ -775,52 +941,33 @@ bool CG4400_application::preprocess_print(int file, int counter)
_riga_rmi.destroy(); _riga_rmi.destroy();
_tot_iva_array.destroy(); _tot_iva_array.destroy();
_doc_array.destroy(); _doc_array.destroy();
_dataregp = ""; _dataregp = "";
_mov_empty = TRUE; _mov_empty = TRUE;
_primast = get_page_number();
set_print_zero(); set_print_zero();
} }
return TRUE; return TRUE;
} }
bool CG4400_application::compila_reg()
{
TTable tab_reg ("REG");
tab_reg.zero();
tab_reg.put("CODTAB", _codtab);
if (tab_reg.read() == NOERR)
{
_tipo_reg = tab_reg.get_int("I0");
// _pagine_stampate = tab_reg.get_int("I1");
// _pagine_numerate = tab_reg.get_int("I2");
//_stampa_ok = tab_reg.get_int("I7");
//_nprog_da = tab_reg.get_long ("I6");
//_tot_dare = tab_reg.get_real ("R1")
//_tot_avere = tab_reg.get_real ("R2");
_data_da = tab_reg.get_date ("D3");
//_stampa_intesta = tab_reg.get_bool ("B9");
_codatt = tab_reg.get("S8");
_attivita = desc_attivita(_codatt);
_desc_lib = tab_reg.get ("S0");
return TRUE;
}
return FALSE;
}
bool CG4400_application::preprocess_page(int file, int counter) bool CG4400_application::preprocess_page(int file, int counter)
{ {
if (file == LF_MOV) if (file == LF_MOV)
{ {
if (counter) return TRUE;
int rr = 0; int rr = 0;
TString ragsoc; TString ragsoc;
TString tipo_op = ""; TString tipo_op = "";
TLocalisamfile* mov = _cur->file(LF_MOV); TLocalisamfile* mov = _cur->file(LF_MOV);
TLocalisamfile* caus = _cur->file(LF_CAUSALI); TLocalisamfile* caus = _cur->file(LF_CAUSALI);
long annoes = mov->get_long(MOV_ANNOES);
TString16 codreg = mov->get(MOV_REG);
_datareg = mov->get_date(MOV_DATAREG); _datareg = mov->get_date(MOV_DATAREG);
if (codreg != _codreg || annoes != _annoes)
return FALSE;
if (_data_da.string() != "" && _data_a.string() != "") if (_data_da.string() != "" && _data_a.string() != "")
if ( (_datareg < _data_da || _datareg > _data_a) || (!_datareg.ok()) ) if ( (_datareg < _data_da || _datareg > _data_a) || (!_datareg.ok()) )
return FALSE; return FALSE;
@ -841,10 +988,19 @@ bool CG4400_application::preprocess_page(int file, int counter)
char tipocf = mov->get(MOV_TIPO)[0]; char tipocf = mov->get(MOV_TIPO)[0];
TString ocfpi = mov->get(MOV_OCFPI); TString ocfpi = mov->get(MOV_OCFPI);
long codcf = mov->get_long(MOV_CODCF); long codcf = mov->get_long(MOV_CODCF);
long numgio = mov->get_long(MOV_NUMGIO);
bool stampato = mov->get_bool(MOV_STAMPATO); bool stampato = mov->get_bool(MOV_STAMPATO);
bool intra = caus->get_bool(CAU_INTRACOM); bool intra = caus->get_bool(CAU_INTRACOM);
bool autof = caus->get_bool(CAU_AUTOFATT); bool autof = caus->get_bool(CAU_AUTOFATT);
TString descrcau = caus->get(CAU_DESCR); TString descrcau = caus->get(CAU_DESCR);
//aggiornamento di mov
if (_tipo_stampa != 3)
if (!stampato)
{
mov->put(MOV_STAMPATO,TRUE);
mov->rewrite();
}
if ( intra && autof) if ( intra && autof)
tipo_op = "3"; tipo_op = "3";
@ -903,31 +1059,163 @@ bool CG4400_application::preprocess_page(int file, int counter)
if (stampato) if (stampato)
set_row(_r, "@131g*"); set_row(_r, "@131g*");
} }
if (_tipo_stampa == 4) //stampa con riferimento al libro giornale
set_row(_r, "@125g%ld", numgio);
} }
return TRUE; return TRUE;
} }
void CG4400_application::aggiorna_reg()
{
TString16 codtab;
TTable Tabreg ("REG");
TTable TabInl ("%INL");
long stampate, pag;
const word ultimast = get_page_number();
codtab << _annoes << _codreg;
Tabreg.zero();
Tabreg.put("CODTAB", codtab);
if (Tabreg.read() == NOERR)
{
stampate = ultimast - _primast + 1;
if (!_mov_empty) //cioe' se e' stata stampata almeno una pagina
{
pag = _pagine_stampate + stampate;
Tabreg.put("I1", pag);
}
Tabreg.put("D3", _data_a);
Tabreg.rewrite();
}
if (_tipo_stampa == 2) //stampa su libro unico
//sulla tabella %inl (indice libro unico) devo generare una riga per ogni registro stampato
{
bool trovato = FALSE;
codtab = "";
codtab << _annoes << _codlib;
TabInl.zero();
TRectype nuovo (TabInl.curr());
TRectype recprec (TabInl.curr());
TabInl.put("CODTAB", codtab);
TRectype rec (TabInl.curr());
TabInl.read (_isgteq);
for (; !TabInl.eof(); TabInl.next())
{
if (TabInl.curr() != rec) break;
trovato = TRUE;
recprec = TabInl.curr();
}
TString16 cod;
if (trovato)
{
TString16 cod_inl = recprec.get("CODTAB");
long numero_riga = atol(cod_inl.mid(7,6));
cod_inl = cod_inl.mid(0,7);
nuovo = recprec;
cod << cod_inl << numero_riga + 1;
}
else
cod << codtab << 1L;
long numini = _pagine_stampate + 1;
nuovo.put("CODTAB", cod);
nuovo.put("I0", _annoes);
nuovo.put("I1", _fino_a_mese);
nuovo.put("I2", _primast);
nuovo.put("I3", ultimast);
nuovo.put("I4", get_firm());
nuovo.put("S0", _codreg);
nuovo.put("I5", numini);
nuovo.put("I6", pag);
TabInl.write(nuovo);
}
}
void CG4400_application::aggiorna_lib()
{
TString16 cod;
TTable lbu ("%LBU");
const word stampate = get_page_number();
cod << _annoes << _codlib;
lbu.zero();
lbu.put("CODTAB", cod);
if (lbu.read() == NOERR)
{
lbu.put("I0", _fino_a_mese);
lbu.put("I1", stampate);
lbu.rewrite();
}
}
print_action CG4400_application::postprocess_page (int file, int counter)
{
if (file == LF_MOV)
{
TLocalisamfile* mov = _cur->file(LF_MOV);
_cur->save_status();
++(*_cur);
_dataregs = mov->get_date(MOV_DATAREG);
--(*_cur);
_cur->restore_status();
if (_dataregs.month() != _dataregp.month())
{
set_page_tot_reg();
return REPEAT_PAGE;
}
}
return NEXT_PAGE;
}
print_action CG4400_application::postprocess_print(int file, int counter) print_action CG4400_application::postprocess_print(int file, int counter)
{ {
if (file == LF_MOV) if (file == LF_MOV)
{ {
//aggiorna registri solo se non e' stampa di prova
if (_tipo_stampa != 3)
aggiorna_reg();
if (_stampa_tutti_i_registri) if (_stampa_tutti_i_registri)
{ {
TString16 codtab;
int anno, tipo;
//vado avanti dal punto in cui sono
_tabreg->next(); _tabreg->next();
TString codtab = _tabreg->get("CODTAB"); for (; !_tabreg->eof(); _tabreg->next())
int anno = atoi(codtab.mid(0,4)); {
if ( (_tabreg->eof()) || (anno != _annoes) ) tipo = _tabreg->get_int("I0");
if ( (tipo == 1) || (tipo == 2) ) //registro iva
{
codtab = _tabreg->get("CODTAB");
anno = atoi(codtab.mid(0,4));
break;
}
}
if ( (_tabreg->eof()) || (anno != _annoes) )
{
if (_tipo_stampa == 2) //stampa su libro unico
aggiorna_lib();
return NEXT_PAGE; return NEXT_PAGE;
}
else else
{ {
_tipo_reg = _tabreg->get_int("I0"); _tipo_reg = _tabreg->get_int("I0");
_desc_lib = _tabreg->get("S0"); _desc_lib = _tabreg->get("S0");
_data_da = _tabreg->get_date("D3"); _data_da = _tabreg->get_date("D3");
_codreg = codtab.mid(4,3); _pagine_stampate = _tabreg->get_int("I1");
if (!_mov_empty ) _codreg = codtab.mid(4,3);
_primast = get_page_number();
if (!_mov_empty )
printer().formfeed(); printer().formfeed();
_cur->set_filterfunction(NULL); _cur->set_filterfunction(NULL);
_cur->set_filterfunction(filter_func); _cur->set_filterfunction(filter_func);
// (*_cur) = 0L;
_mov_empty = TRUE; _mov_empty = TRUE;
return REPEAT_PAGE; return REPEAT_PAGE;
} }
@ -951,21 +1239,27 @@ print_action CG4400_application::postprocess_print(int file, int counter)
else if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) ) else if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) )
{ {
TLocalisamfile* mov = _cur->file(LF_MOV); TLocalisamfile* mov = _cur->file(LF_MOV);
TDate dataregp = mov->get_date(MOV_DATAREG); /*
TDate dataregp = mov->get_date(MOV_DATAREG);
_cur->save_status();
++(*_cur);
TDate datareg = mov->get_date(MOV_DATAREG);
--(*_cur);
_cur->restore_status();
if (datareg.month() != dataregp.month())
{
set_page_tot_reg();
return REPEAT_PAGE;
}
_cur->save_status(); if (_dataregp.month() != _dataregs.month())
++(*_cur); {
TDate datareg = mov->get_date(MOV_DATAREG); set_page_tot_reg();
--(*_cur); return REPEAT_PAGE;
_cur->restore_status(); }
if (datareg.month() != dataregp.month()) */
{
set_page_tot_reg();
return REPEAT_PAGE;
}
} }
} }
return NEXT_PAGE; return NEXT_PAGE;
} }
@ -984,16 +1278,20 @@ bool CG4400_application::set_print(int n)
else if (_tipo_stampa == 3) //stampa di prova else if (_tipo_stampa == 3) //stampa di prova
_codreg = m.get(CODICE_LIBRO_PROVA); _codreg = m.get(CODICE_LIBRO_PROVA);
else _codreg = m.get(CODICE_LIBRO); else _codreg = m.get(CODICE_LIBRO);
if (_codreg.trim().empty()) /*
{ if (_codreg.trim().empty())
_tabreg->first(); {
_codtab = _tabreg->get("CODTAB"); _tabreg->first();
_codreg = _codtab.mid(4,3); _codtab = _tabreg->get("CODTAB");
_stampa_tutti_i_registri = TRUE; _codreg = _codtab.mid(4,3);
} _stampa_tutti_i_registri = TRUE;
else }
_stampa_tutti_i_registri = FALSE; else
{
_codtab << _annoes << _codreg;
_stampa_tutti_i_registri = FALSE;
}
**/
//Se stampa di prova l'utente indica data_da e data_a //Se stampa di prova l'utente indica data_da e data_a
if (_tipo_stampa == 3) if (_tipo_stampa == 3)
{ {
@ -1011,8 +1309,12 @@ bool CG4400_application::set_print(int n)
{ {
if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) ) if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) )
_fino_a_mese = m.get_int(FINO_A_MESE); _fino_a_mese = m.get_int(FINO_A_MESE);
else else //stampa su libro unico
_fino_a_mese = m.get_int(MESE); {
_codlib = m.get(CODICE_LIB_UN);
_fino_a_mese = m.get_int(MESE);
set_page_number(m.get_int(ULTIMA_PAGINA) + 1);
}
if (_fino_a_mese == 12) if (_fino_a_mese == 12)
giorni_del_mese = 31; giorni_del_mese = 31;
else else
@ -1024,10 +1326,9 @@ bool CG4400_application::set_print(int n)
_data_a=format("%02d/%02d/%4d",giorni_del_mese,_fino_a_mese,_annoes); _data_a=format("%02d/%02d/%4d",giorni_del_mese,_fino_a_mese,_annoes);
// NB data_da viene letta nella preprocess_page // NB data_da viene letta nella preprocess_page
} }
_codtab = format("%4d%-3s",_annoes, (const char *)_codreg); // compila_reg();
compila_reg(); if (_tipo_stampa == 2)
//if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) ) compila_lib();
stampa_registri_IVA(); stampa_registri_IVA();
} }
else warning_box("Nessuna ditta selezionata!"); else warning_box("Nessuna ditta selezionata!");
@ -1045,6 +1346,9 @@ void CG4400_application::stampa_registri_IVA()
if (_selected[l]) if (_selected[l])
{ {
TApplication::set_firm(_nditte->get_long("CODDITTA")); TApplication::set_firm(_nditte->get_long("CODDITTA"));
ok = compila_reg(); // cerca il primo registro valido (nel caso di stampa tutti i registri), senno' legge i dati del registro specificato
if (!ok) continue;
_cur->set_filterfunction(filter_func);
_frequiva = _nditte->get("FREQVIVA")[0]; _frequiva = _nditte->get("FREQVIVA")[0];
if (_tipo_stampa != 3) //stampa definitiva if (_tipo_stampa != 3) //stampa definitiva
ok = controlla_liquidazione() && controlla_mov(); ok = controlla_liquidazione() && controlla_mov();
@ -1086,9 +1390,9 @@ bool CG4400_application::set_ditte(TMask& m)
int CG4400_application::stampa_intestazione_ditta() int CG4400_application::stampa_intestazione_ditta()
{ {
TDati_ditta tditta(get_firm(), _stampa_width); TDati_ditta tditta(get_firm(), _stampa_width);
TString riga (tditta.prima_riga());
int r=1; int r=1;
TString riga(tditta.prima_riga());
set_header (r, "%s", (const char *) riga); set_header (r, "%s", (const char *) riga);
r++; r++;
@ -1152,9 +1456,13 @@ else
else else
{ {
set_header(r,"@10gNum.@19gDocumento@68gT Tipo@103gCod %s@121g@124gT", (const char*) nd1); set_header(r,"@10gNum.@19gDocumento@68gT Tipo@103gCod %s@121g@124gT", (const char*) nd1);
if (_tipo_stampa == 4) //stampa definitiva con rif. al libro giornale
set_header(r, "@127gNumero");
r++; r++;
set_header(r, "Data reg. prot.@17gData@25gNumero Codice Ragione sociale/descrizione@68gO Doc.@76gTotale doc.@91gImponibile Iva %s@112gImposta@124g%s", set_header(r, "Data reg. prot.@17gData@25gNumero Codice Ragione sociale/descrizione@68gO Doc.@76gTotale doc.@91gImponibile Iva %s@112gImposta@124g%s",
(const char*) nd2, (const char*) cor); (const char*) nd2, (const char*) cor);
if (_tipo_stampa == 4)
set_header(r, "@127goperaz");
r++; r++;
} }
riga.fill('-'); riga.fill('-');
@ -1169,3 +1477,15 @@ int cg4400 (int argc, char * argv[])
} }

250
cg/cg4400.h
View File

@ -1,121 +1,129 @@
// //
// cg4400.h // cg4400.h
// //
#include <isam.h> #include <isam.h>
#include <lffiles.h> #include <lffiles.h>
#include <printapp.h> #include <printapp.h>
#include <mask.h> #include <mask.h>
#include <strings.h> #include <strings.h>
#include <tabutil.h> #include <tabutil.h>
#include <utility.h> #include <utility.h>
#include <stdlib.h> #include <stdlib.h>
#include <urldefid.h> #include <urldefid.h>
#include <sheet.h> #include <sheet.h>
#include <config.h> #include <config.h>
#include <nditte.h>
#include <anagr.h> #include <nditte.h>
#include <comuni.h> #include <anagr.h>
#include <mov.h> #include <comuni.h>
#include <rmoviva.h> #include <mov.h>
#include <clifo.h> #include <rmoviva.h>
#include <occas.h> #include <clifo.h>
#include <causali.h> #include <occas.h>
#include "cglib03.h" #include <causali.h>
const int MAXSTR = 128; #include "cglib03.h"
static char __tmp[MAXSTR];
const int MAXSTR = 128;
//enum STAMPA { bollati=1, unici=2 }; static char __tmp[MAXSTR];
const int TABREG = (int)TTable::name2log("REG");
//enum STAMPA { bollati=1, unici=2 };
bool filter_func (const TRelation*); const int TABREG = (int)TTable::name2log("REG");
bool my_handler (TMask_field&, KEY);
bool mask_cod (TMask_field&, KEY); bool filter_func (const TRelation*);
bool mask_mese (TMask_field&, KEY); bool my_handler (TMask_field&, KEY);
bool mask_fino_a_mese (TMask_field&, KEY); bool mask_cod (TMask_field&, KEY);
bool mask_select (TMask_field&, KEY); bool mask_mese (TMask_field&, KEY);
bool mask_verifica (TMask_field&, KEY); bool mask_fino_a_mese (TMask_field&, KEY);
bool mask_annulla (TMask_field&, KEY); bool mask_select (TMask_field&, KEY);
bool mask_verifica (TMask_field&, KEY);
class TDati_ditta : public TObject bool mask_annulla (TMask_field&, KEY);
{
TLocalisamfile * _nditte, * _anag, *_comuni; class TDati_ditta : public TObject
TString _ragsoc, _cofi, _paiva; {
TString _comunefis, _viafis, _provfis, _cap; TLocalisamfile * _nditte, * _anag, *_comuni;
long _codditta; TString _ragsoc, _cofi, _paiva;
int _stampa_width; TString _comunefis, _viafis, _provfis, _cap;
protected: long _codditta;
void get_dati_ditta(); int _stampa_width;
TRectype& look_com (const char * codice); protected:
public: void get_dati_ditta();
const char* prima_riga (); TRectype& look_com (const char * codice);
const char* seconda_riga (); public:
TDati_ditta (long cod_ditta, int stampa_width); const char* prima_riga ();
virtual ~TDati_ditta(); const char* seconda_riga ();
}; TDati_ditta (long cod_ditta, int stampa_width);
virtual ~TDati_ditta();
class CG4400_application : public TPrintapp };
{
friend bool filter_func (const TRelation *r); class CG4400_application : public TPrintapp
friend bool mask_cod (TMask_field&, KEY); {
friend bool mask_mese (TMask_field&, KEY); friend bool filter_func (const TRelation *r);
friend bool mask_fino_a_mese (TMask_field&, KEY); friend bool mask_cod (TMask_field&, KEY);
friend bool my_handler (TMask_field&, KEY); friend bool mask_mese (TMask_field&, KEY);
friend bool mask_select (TMask_field&, KEY); friend bool mask_fino_a_mese (TMask_field&, KEY);
friend bool mask_verifica (TMask_field&, KEY); friend bool my_handler (TMask_field&, KEY);
friend bool mask_annulla (TMask_field&, KEY); friend bool mask_select (TMask_field&, KEY);
friend bool mask_verifica (TMask_field&, KEY);
TCursor * _cur; friend bool mask_annulla (TMask_field&, KEY);
TRelation *_rel;
TLocalisamfile *_clifo, *_nditte, *_occas, *_tab, *_tabcom; TCursor * _cur;
TTable *_tabreg; TRelation *_rel;
TRigaiva_array _iva_array, _riga_rmi; TLocalisamfile *_clifo, *_nditte, *_occas, *_tab, *_tabcom;
TTipodoc_array _doc_array; TTable *_tabreg, *_tablbu, *_tabinl;
TRiga_array _tot_iva_array; TRigaiva_array _iva_array, _riga_rmi;
TArray_sheet *_ditte; TTipodoc_array _doc_array;
TBit_array _selected; TRiga_array _tot_iva_array;
TArray _nomiditte; //array descrizioni ditte per sheet TArray_sheet *_ditte;
bool _riferim, _mov_empty; TBit_array _selected;
char _frequiva; TArray _nomiditte; //array descrizioni ditte per sheet
TDate _data_da, _data_a, _data_stampa, _dataregp, _datareg; bool _mov_empty, _stampa_ind_ditta, _stampa_tutti_i_registri;
long _annoes, _n_ditte; char _frequiva;
int _riepil, _tipo_reg, _fino_a_mese, _tipo_stampa; TDate _data_da, _data_a, _data_stampa, _dataregp, _dataregs, _datareg;
int _r, _stampa_width; // riga corrente di stampa long _annoes, _n_ditte;
real _totale_doc; word _primast;
TString _codreg, _desc_lib, _codatt, _attivita; int _riepil, _tipo_reg, _fino_a_mese, _tipo_stampa, _pagine_stampate;
TString _codtab, _tipodoc, _descr_doc; int _r, _stampa_width; // riga corrente di stampa
bool _stampa_tutti_i_registri; real _totale_doc;
TString _codreg, _desc_lib, _codatt, _attivita;
public: TString _codtab, _tipodoc, _descr_doc, _codlib;
const char* desc_attivita (const char * codatt);
const char* descr_doc (const char * tipo); public:
const char* descr_iva (const char * cod); const char* desc_attivita (const char * codatt);
const char* ricerca_cf (char tipocf, long codcf); const char* descr_doc (const char * tipo);
const char* ricerca_occ(const char * occ); const char* descr_iva (const char * cod);
int setta_riga (int, const TRigaiva&, real&, real&, real&, real&); const char* ricerca_cf (char tipocf, long codcf);
int riga_rmoviva(); const char* ricerca_occ(const char * occ);
bool set_print(int); int setta_riga (int, const TRigaiva&, real&, real&, real&, real&);
bool set_ditte(TMask&); int riga_rmoviva();
bool compila_reg(); bool set_print(int);
bool controlla_liquidazione(); bool set_ditte(TMask&);
bool controlla_mov(); bool compila_reg();
void stampa_registri_IVA(); bool compila_lib();
void set_page_tot_reg(); bool controlla_liquidazione();
void calcola_progressivi(real&, real&, const char*, const int); bool controlla_mov();
void user_create(); void cerca_reg(const TString&, byte&, TDate&);
void user_destroy(); //void leggi_movimenti(const TDate&, const TString&, bool&);
bool preprocess_page(int, int); void stampa_registri_IVA();
int stampa_intestazione_ditta(); void set_page_tot_reg();
bool preprocess_print(int, int); void aggiorna_reg();
print_action postprocess_print(int, int); void aggiorna_lib();
void preprocess_header(); void calcola_progressivi(real&, real&, const char*, const int);
void user_create();
CG4400_application() : TPrintapp(),_ditte(NULL),_selected(10000), void user_destroy();
_nomiditte(100) {} bool preprocess_page(int, int);
int stampa_intestazione_ditta();
virtual ~CG4400_application() {} bool preprocess_print(int, int);
}; print_action postprocess_print(int, int);
print_action postprocess_page (int, int);
void preprocess_header();
CG4400_application() : TPrintapp(),_ditte(NULL),_selected(10000),
_nomiditte(100) {}
virtual ~CG4400_application() {}
};

228
cg/cg4400a.uml
View File

@ -5,33 +5,33 @@
PAGE "Stampa registri IVA" -1 -1 56 19 PAGE "Stampa registri IVA" -1 -1 56 19
/* /*
LISTBOX TIPO_STAMPA 2 27 LISTBOX TIPO_STAMPA 2 27
BEGIN BEGIN
PROMPT 2 1 "Tipo stampa " PROMPT 2 1 "Tipo stampa "
ITEM "1|Libri bollati della ditta" ITEM "1|Libri bollati della ditta"
MESSAGE SHOW,1@|HIDE,2@|HIDE,3@ MESSAGE SHOW,1@|HIDE,2@|HIDE,3@
ITEM "2|Libri unici dello studio" ITEM "2|Libri unici dello studio"
MESSAGE SHOW,2@|HIDE,1@|HIDE,3@ MESSAGE SHOW,2@|HIDE,1@|HIDE,3@
ITEM "3|Stampa di prova" ITEM "3|Stampa di prova"
MESSAGE SHOW,3@|HIDE,1@|HIDE,2@|SHOW,CODICE_LIBRO MESSAGE SHOW,3@|HIDE,1@|HIDE,2@|SHOW,CODICE_LIBRO
ITEM "4|Stampa libri con riferimenti al libro giornale" ITEM "4|Stampa libri con riferimenti al libro giornale"
MESSAGE SHOW,1@|HIDE,2@|HIDE,3@ MESSAGE SHOW,1@|HIDE,2@|HIDE,3@
END END
*/ */
NUMBER TIPO_STAMPA 1 NUMBER TIPO_STAMPA 1
BEGIN BEGIN
PROMPT 2 1 "Tipo stampa " PROMPT 2 1 "Tipo stampa "
SHEET "Cod|Descrizione@50" SHEET "Cod|Descrizione@50"
INPUT TIPO_STAMPA INPUT TIPO_STAMPA
OUTPUT TIPO_STAMPA OUTPUT TIPO_STAMPA
ITEM "1|Libri bollati della ditta" ITEM "1|Libri bollati della ditta"
ITEM "2|Libri unici dello studio" ITEM "2|Libri unici dello studio"
ITEM "3|Stampa di prova" ITEM "3|Stampa di prova"
ITEM "4|Stampa libri con riferimenti al libro giornale" ITEM "4|Stampa libri con riferimenti al libro giornale"
END END
GROUPBOX DLG_NULL 35 5 GROUPBOX DLG_NULL 35 5
BEGIN BEGIN
PROMPT 20 1 "Scelta ditte" PROMPT 20 1 "Scelta ditte"
@ -39,25 +39,27 @@ END
NUMBER DA_CODICE 6 NUMBER DA_CODICE 6
BEGIN BEGIN
PROMPT 21 2 "Da codice " PROMPT 21 2 "Da codice "
HELP "Immettere codice ditta di partenza per la selezione" HELP "Immettere codice ditta di partenza per la selezione"
USE LF_NDITTE KEY 1 USE LF_NDITTE KEY 1
DISPLAY "Codice" CODDITTA CHECKTYPE NORMAL
DISPLAY "Ragione sociale@50" RAGSOC INPUT CODDITTA DA_CODICE
OUTPUT DA_CODICE CODDITTA DISPLAY "Codice" CODDITTA
CHECKTYPE NORMAL DISPLAY "Ragione sociale@50" RAGSOC
OUTPUT DA_CODICE CODDITTA
END END
NUMBER A_CODICE 6 NUMBER A_CODICE 6
BEGIN BEGIN
PROMPT 21 3 "A codice " PROMPT 21 3 "A codice "
HELP "Immettere codice ditta di fine selezione" HELP "Immettere codice ditta di fine selezione"
COPY USE DA_CODICE COPY USE DA_CODICE
DISPLAY "Codice" CODDITTA CHECKTYPE NORMAL
DISPLAY "Ragione sociale@50" RAGSOC INPUT CODDITTA A_CODICE
OUTPUT A_CODICE CODDITTA COPY DISPLAY DA_CODICE
END OUTPUT A_CODICE CODDITTA
END
STRING F_SELECT 6 STRING F_SELECT 6
BEGIN BEGIN
PROMPT 21 4 "Scelte n. " PROMPT 21 4 "Scelte n. "
@ -81,70 +83,71 @@ BEGIN
PROMPT 42 4 "Verifica" PROMPT 42 4 "Verifica"
//MESSAGE EXIT,F_VERIFICA //MESSAGE EXIT,F_VERIFICA
END END
DATE DATA_STAMPA DATE DATA_STAMPA
BEGIN BEGIN
PROMPT 2 6 "Data stampa " PROMPT 2 6 "Data stampa "
FLAG "AH" FLAG "AH"
GROUP 3 GROUP 3
END END
NUMBER ANNO 4 NUMBER ANNO 4
BEGIN BEGIN
PROMPT 2 7 "Anno " PROMPT 2 7 "Anno "
FLAGS "A" FLAGS "A"
END END
STRING CODICE_LIBRO 3 STRING CODICE_LIBRO 3
BEGIN BEGIN
PROMPT 20 7 "Codice libro " PROMPT 20 7 "Codice libro "
HELP "Specificare il codice libro di cui si chiede la stampa; nel caso in cui non si indichi nessun codice verranno stampati tutti i libri delle ditte selezionate" HELP "Specificare il codice libro di cui si chiede la stampa; nel caso in cui non si indichi nessun codice verranno stampati tutti i libri delle ditte selezionate"
USE REG SELECT (I0<"3") && (S7=="") && (CODTAB[1,4]==#111) USE REG SELECT (I0<"3") && (S6=="") && (CODTAB[1,4]==#111)
INPUT CODTAB[1,4] ANNO INPUT CODTAB[1,4] ANNO
INPUT CODTAB[5,7] CODICE_LIBRO INPUT CODTAB[5,7] CODICE_LIBRO
DISPLAY "Anno " CODTAB[1,4]
DISPLAY "Codice " CODTAB[5,7]
DISPLAY "Descrizione @40" S0
OUTPUT ANNO CODTAB[1,4]
OUTPUT CODICE_LIBRO CODTAB[5,7]
CHECKTYPE NORMAL
FLAGS "R"
GROUP 1
END
STRING CODICE_LIBRO_PROVA 3
BEGIN
PROMPT 20 7 "Codice libro "
HELP "Specificare il codice libro di cui si chiede la stampa; nel caso in cui non si indichi nessun codice verranno stampati tutti i libri delle ditte selezionate"
USE REG SELECT (I0<"3") && (CODTAB[1,4]==#111)
INPUT CODTAB[1,4] ANNO
INPUT CODTAB[5,7] CODICE_LIBRO
DISPLAY "Anno " CODTAB[1,4]
DISPLAY "Codice " CODTAB[5,7]
DISPLAY "Descrizione @40" S0
OUTPUT ANNO CODTAB[1,4]
OUTPUT CODICE_LIBRO CODTAB[5,7]
CHECKTYPE NORMAL
FLAGS "R"
GROUP 1
END
STRING CODICE_LIB_UN 3
BEGIN
PROMPT 20 7 "Cod.libro unico "
USE %LBU SELECT CODTAB[1,4]==#111
INPUT CODTAB[1,4] ANNO
INPUT CODTAB[5,7] CODICE_LIB_UN
DISPLAY "Anno " CODTAB[1,4] DISPLAY "Anno " CODTAB[1,4]
DISPLAY "Codice " CODTAB[5,7] DISPLAY "Codice " CODTAB[5,7]
DISPLAY "Descrizione @40" S0 DISPLAY "Descrizione @40" S0
OUTPUT ANNO CODTAB[1,4] OUTPUT ANNO CODTAB[1,4]
OUTPUT CODICE_LIB_UN CODTAB[5,7] OUTPUT CODICE_LIBRO CODTAB[5,7]
FLAGS "R" //CHECKTYPE NORMAL
CHECKTYPE REQUIRED FLAGS "UR"
GROUP 2 GROUP 1
END END
STRING CODICE_LIBRO_PROVA 3
BEGIN
PROMPT 20 7 "Codice libro "
HELP "Specificare il codice libro di cui si chiede la stampa; nel caso in cui non si indichi nessun codice verranno stampati tutti i libri delle ditte selezionate"
USE REG SELECT (I0<"3") && (CODTAB[1,4]==#111)
INPUT CODTAB[1,4] ANNO
INPUT CODTAB[5,7] CODICE_LIBRO
DISPLAY "Anno " CODTAB[1,4]
DISPLAY "Codice " CODTAB[5,7]
DISPLAY "Descrizione @40" S0
OUTPUT ANNO CODTAB[1,4]
OUTPUT CODICE_LIBRO CODTAB[5,7]
//CHECKTYPE NORMAL
FLAGS "UR"
GROUP 1
END
STRING CODICE_LIB_UN 3
BEGIN
PROMPT 20 7 "Cod.libro unico "
HELP "Specificare il codice del libro unico su cui deve essere effettuata la stampa"
USE %LBU SELECT CODTAB[1,4]==#111
INPUT CODTAB[1,4] ANNO
INPUT CODTAB[5,7] CODICE_LIB_UN
DISPLAY "Anno " CODTAB[1,4]
DISPLAY "Codice " CODTAB[5,7]
DISPLAY "Descrizione @40" S0
OUTPUT ANNO CODTAB[1,4]
OUTPUT CODICE_LIB_UN CODTAB[5,7]
FLAGS "UR"
CHECKTYPE REQUIRED
GROUP 2
END
GROUPBOX DLG_NULL 52 3 GROUPBOX DLG_NULL 52 3
BEGIN BEGIN
PROMPT 2 9 "Stampa movimenti" PROMPT 2 9 "Stampa movimenti"
@ -162,59 +165,60 @@ BEGIN
GROUP 3 GROUP 3
END END
LISTBOX FINO_A_MESE 10 LISTBOX FINO_A_MESE 10
BEGIN BEGIN
PROMPT 5 10 "Fino al mese " PROMPT 5 10 "Fino al mese "
FLAGS "M" FLAGS "M"
GROUP 1 GROUP 1
END END
LISTBOX MESE 10 LISTBOX MESE 10
BEGIN BEGIN
PROMPT 5 10 "Mese " PROMPT 5 10 "Mese "
FLAGS "M" FLAGS "M"
GROUP 2 GROUP 2
END END
LISTBOX TIPO_RIEPILOGATIVO 11 LISTBOX TIPO_RIEPILOGATIVO 11
BEGIN BEGIN
PROMPT 2 12 "Tipo riepilogativo " PROMPT 2 12 "Tipo riepilogativo "
HELP "Selezionare Del periodo/Annuale a seconda che si desideri la stampa della liquidazione periodica/annuale"
ITEM "P|Del periodo" ITEM "P|Del periodo"
ITEM "A|Annuale" ITEM "A|Annuale"
GROUP 1 GROUP 1
END END
LISTBOX ULTIMO_MESE 10 LISTBOX ULTIMO_MESE 10
BEGIN BEGIN
PROMPT 2 13 "Ultimo mese stampa su libro unico " PROMPT 2 13 "Ultimo mese stampa su libro unico "
FLAGS "MD" FLAGS "MD"
GROUP 2 GROUP 2
END END
NUMBER ULTIMA_PAGINA 4 NUMBER ULTIMA_PAGINA 4
BEGIN BEGIN
PROMPT 2 14 "Ultimo numero di pagina stampata libro unico " PROMPT 2 14 "Ultimo numero di pagina stampata libro unico "
FLAGS "R" FLAGS "R"
GROUP 2 GROUP 2
END END
STRING CODICE_LIBRO_IVA 3 STRING CODICE_LIBRO_IVA 3
BEGIN BEGIN
PROMPT 2 15 "Eventuale codice libro IVA " PROMPT 2 15 "Eventuale codice libro IVA "
HELP "Se non viene indicato nessun cod. libro IVA, vengono stampati tutti i registri delle ditte selezionate" HELP "Se non viene indicato nessun cod. libro IVA, vengono stampati tutti i registri delle ditte selezionate"
USE REG SELECT (I0<"3") && (S7=="") && (CODTAB[1,4]==#111) USE REG SELECT (I0<"3") && (S6=="") && (CODTAB[1,4]==#111)
INPUT CODTAB[1,4] ANNO INPUT CODTAB[1,4] ANNO
INPUT CODTAB[5,7] CODICE_LIBRO_IVA INPUT CODTAB[5,7] CODICE_LIBRO_IVA
DISPLAY "Anno " CODTAB[1,4] DISPLAY "Anno " CODTAB[1,4]
DISPLAY "Codice " CODTAB[5,7] DISPLAY "Codice " CODTAB[5,7]
DISPLAY "Descrizione @40" S0 DISPLAY "Descrizione @40" S0
OUTPUT ANNO CODTAB[1,4] OUTPUT ANNO CODTAB[1,4]
OUTPUT CODICE_LIBRO_IVA CODTAB[5,7] OUTPUT CODICE_LIBRO_IVA CODTAB[5,7]
CHECKTYPE NORMAL //CHECKTYPE NORMAL
FLAGS "R" FLAGS "UR"
GROUP 2 GROUP 2
END END
BUTTON DLG_OK 9 2 BUTTON DLG_OK 9 2
BEGIN BEGIN
PROMPT -12 -1 "" PROMPT -12 -1 ""

981
cg/cg4600.cpp
View File

File diff suppressed because it is too large Load Diff

952
cg/cglib01.cpp
View File

@ -1,487 +1,471 @@
// cglib01.cpp // cglib01.cpp
// calcolo dei saldi // calcolo dei saldi
#include <applicat.h> #include <applicat.h>
#include <date.h> #include <date.h>
#include <real.h> #include <real.h>
#include <lffiles.h> #include <lffiles.h>
#include <isam.h> #include <isam.h>
#include <utility.h> #include <utility.h>
#include <config.h> #include <config.h>
#include <rmov.h> #include <rmov.h>
#include <mov.h> #include <mov.h>
#include <saldi.h> #include <saldi.h>
#include <pconti.h> #include <pconti.h>
#include <clifo.h> #include <clifo.h>
#include "cglib.h" #include "cglib.h"
const MAXSTR = 128; const MAXSTR = 128;
static char __tmp [MAXSTR]; static char __tmp [MAXSTR];
static TFixed_string tmp (__tmp, MAXSTR); static TFixed_string tmp (__tmp, MAXSTR);
TClifo_list::TClifo_list(int g, int c, char tipocf) TClifo_list::TClifo_list(int g, int c, char tipocf)
{ {
TLocalisamfile cf(LF_CLIFO); TLocalisamfile cf(LF_CLIFO);
destroy(); destroy();
cf.setkey(3); cf.setkey(3);
cf.zero(); cf.zero();
cf.put(CLI_TIPOCF,tipocf); cf.put(CLI_TIPOCF,tipocf);
cf.put(CLI_GRUPPO,g); cf.put(CLI_GRUPPO,g);
cf.put(CLI_CONTO,c); cf.put(CLI_CONTO,c);
TRectype rec(cf.curr()); TRectype rec(cf.curr());
cf.read(_isgteq); cf.read(_isgteq);
for ( ;!cf.eof();cf.next()) for ( ;!cf.eof();cf.next())
{ {
if (cf.curr() > rec) break; if (cf.curr() > rec) break;
TRectype r(cf.curr()); TRectype r(cf.curr());
add(r); add(r);
} }
} }
Saldo::Saldo() Saldo::Saldo()
{ {
_saldo_iniziale = 0.00; _saldo_iniziale = ZERO;
_prg_dare = 0.00; _prg_dare = ZERO;
_prg_avere = 0.00; _prg_avere = ZERO;
_saldo = 0.00; _saldo = ZERO;
_indbil = 0; _indbil = 0;
_saldi = new TLocalisamfile(LF_SALDI); _saldi = new TLocalisamfile(LF_SALDI);
_mov = new TLocalisamfile(LF_MOV); _mov = new TLocalisamfile(LF_MOV);
_rmov = new TLocalisamfile(LF_RMOV); _rmov = new TLocalisamfile(LF_RMOV);
_clifo = new TLocalisamfile(LF_CLIFO); _clifo = new TLocalisamfile(LF_CLIFO);
} _rec = new TRectype(LF_SALDI);
}
Saldo::~Saldo()
{ Saldo::~Saldo()
delete _saldi; {
delete _mov; delete _saldi;
delete _rmov; delete _mov;
delete _clifo; delete _rmov;
} delete _clifo;
delete _rec;
real Saldo::saldofin_esprec(int annoes, int g, int c, long s) }
{
real saldo,pdare,pavere,pdaresca,paveresca; real Saldo::saldofin_esprec(int annoes, int g, int c, long s)
char flag; {
real saldo,pdare,pavere,pdaresca,paveresca;
TRectype app = ricerca_progr_prec(annoes-1, g, c, s); char flag;
TLocalisamfile& saldi = *_saldi;
flag = app.get(SLD_FLAGSALINI)[0]; TRecnotype numrec = saldi.recno();
saldo = app.get_real(SLD_SALDO); TRectype app = ricerca_progr_prec(annoes-1, g, c, s);
pdare = app.get_real(SLD_PDARE);
pavere = app.get_real(SLD_PAVERE); flag = app.get(SLD_FLAGSALINI)[0];
pdaresca = app.get_real(SLD_PDARESCA); saldo = app.get_real(SLD_SALDO);
paveresca = app.get_real(SLD_PAVERESCA); pdare = app.get_real(SLD_PDARE);
if (flag == 'D') pavere = app.get_real(SLD_PAVERE);
return saldo+pdaresca-paveresca+pdare-pavere;//saldo finale es. precedente; pdaresca = app.get_real(SLD_PDARESCA);
else //if (flag == 'A') paveresca = app.get_real(SLD_PAVERESCA);
return pdaresca-saldo-paveresca+pdare-pavere;
} saldi.readat(numrec);
real Saldo::calcola_saldo_iniziale(int annoes,int g,int c,long s,int indbil) if (flag == 'D')
{ return saldo+pdaresca-paveresca+pdare-pavere;
real saldoini, pdaresca, paveresca; else
char flag; return pdaresca-saldo-paveresca+pdare-pavere;
TLocalisamfile& saldi = *_saldi; }
saldi.zero(); real Saldo::calcola_saldo_iniziale(int annoes,int g,int c,long s,int indbil)
saldi.put(SLD_GRUPPO,g); {
if (c != 0) real saldoini, pdaresca, paveresca;
saldi.put(SLD_CONTO,c); char flag;
if (s != 0) TLocalisamfile& saldi = *_saldi;
saldi.put(SLD_SOTTOCONTO,s);
saldi.put(SLD_ANNOES,annoes); saldi.zero();
saldi.put(SLD_GRUPPO,g);
saldi.read(); if (c != 0)
saldi.put(SLD_CONTO,c);
if (saldi.bad()) if (s != 0)
saldi.zero(); saldi.put(SLD_SOTTOCONTO,s);
saldi.put(SLD_ANNOES,annoes);
flag = saldi.get(SLD_FLAGSALINI)[0];
saldoini = saldi.get_real(SLD_SALDO); saldi.read();
pdaresca = saldi.get_real(SLD_PDARESCA);
paveresca = saldi.get_real(SLD_PAVERESCA); if (saldi.bad())
saldi.zero();
if (saldoini == 0.00) //e il conto e' patrimoniale o d'ordine
if ( (indbil == 1)||(indbil == 2)||(indbil == 5) ) flag = saldi.get(SLD_FLAGSALINI)[0];
saldoini = saldofin_esprec(annoes, g, c, s); saldoini = saldi.get_real(SLD_SALDO);
pdaresca = saldi.get_real(SLD_PDARESCA);
if (flag == 'D') paveresca = saldi.get_real(SLD_PAVERESCA);
return saldoini+pdaresca-paveresca;
else //if (flag == 'A') if (saldoini == 0.00) //e il conto e' patrimoniale o d'ordine
return pdaresca-saldoini-paveresca; if ( (indbil == 1)||(indbil == 2)||(indbil == 5) )
} saldoini = saldofin_esprec(annoes, g, c, s);
// La funzione seguente calcola il saldo per data limite o all'ultima immissione es.in / if (flag == 'D')
// corso o precedente, a seconda del valore dei suoi parametri al momento della chiamata return saldoini+pdaresca-paveresca;
bool Saldo::calcola(int annoes, int annoesprec, int g, int c, long s, else //if (flag == 'A')
const TDate& data_inf, const TDate& data_sup, return pdaresca-saldoini-paveresca;
int indbil, bool controllo_competenza, const TDate& inizio_es, }
const TDate& fine_es, const TDate& fine_es_prec,bool stp_prov)
{ // La funzione seguente calcola il saldo per data limite o all'ultima immissione es.in /
if (data_sup.ok()) // corso o precedente, a seconda del valore dei suoi parametri al momento della chiamata
{ bool Saldo::calcola(int annoes, int annoesprec, int g, int c, long s,
if (!calcola_data_limite(annoes, g, c, s, data_inf, data_sup, indbil, const TDate& data_inf, const TDate& data_sup,
controllo_competenza, inizio_es, fine_es, fine_es_prec,stp_prov)) int indbil, bool controllo_competenza, const TDate& inizio_es,
return FALSE; const TDate& fine_es, const TDate& fine_es_prec,bool stp_prov)
} {
else if (data_sup.ok())
if (!calcola_ultima_immissione(annoes, annoesprec, g, c, s, indbil)) {
return FALSE; if (!calcola_data_limite(annoes, g, c, s, data_inf, data_sup, indbil,
controllo_competenza, inizio_es, fine_es, fine_es_prec,stp_prov))
return TRUE; return FALSE;
} }
else
const char* Saldo::causale_chiusura_es() if (!calcola_ultima_immissione(annoes, annoesprec, g, c, s, indbil))
{ return FALSE;
TConfig conf(CONFIG_DITTA);
tmp = conf.get("CoCaCh"); return TRUE;
}
return __tmp;
} const char* Saldo::causale_chiusura_es()
{
const char* Saldo::causale_apertura_es() TConfig conf(CONFIG_DITTA);
{ tmp = conf.get("CoCaCh");
TConfig conf(CONFIG_DITTA);
tmp = conf.get("CoCaAp"); return __tmp;
}
return __tmp;
} const char* Saldo::causale_apertura_es()
{
bool Saldo::causale_mov(long nr, const TDate& inizio_es, const TDate& data_sup, TString& provv) TConfig conf(CONFIG_DITTA);
{ tmp = conf.get("CoCaAp");
TString codcaus;
TDate datareg; return __tmp;
TLocalisamfile& mov = *_mov; }
mov.zero(); bool Saldo::causale_mov(long nr, const TDate& inizio_es, const TDate& data_sup, TString& provv)
mov.put (MOV_NUMREG,nr); {
TString codcaus;
if (mov.read() == NOERR) TDate datareg;
{ TLocalisamfile& mov = *_mov;
codcaus = mov.get(MOV_CODCAUS);
datareg = mov.get_date(MOV_DATAREG); mov.zero();
provv = mov.get(MOV_PROVVIS); mov.put (MOV_NUMREG,nr);
if (codcaus == causale_chiusura_es())
return TRUE; if (mov.read() == NOERR)
{
if (codcaus == causale_apertura_es()) codcaus = mov.get(MOV_CODCAUS);
if ( (datareg < inizio_es) || (datareg > data_sup) ) datareg = mov.get_date(MOV_DATAREG);
return TRUE; provv = mov.get(MOV_PROVVIS);
} if (codcaus == causale_chiusura_es())
return FALSE; return TRUE;
}
if (codcaus == causale_apertura_es())
bool Saldo::calcola_data_limite(int annoes, int g, int c, long s, const TDate& data_inf, const TDate& data_sup, int indbil, bool controllo_competenza, const TDate& inizio_es, const TDate& fine_es, const TDate& fine_es_prec,bool stp_prov) if ( (datareg < inizio_es) || (datareg > data_sup) )
{ return TRUE;
TString sezione, gcs_corr, gcs_prec="", provv = ""; }
real importo, dep = 0.00; return FALSE;
int gruppo, conto, annoe; }
long sottoconto, num_reg;
TLocalisamfile& rmov = *_rmov; bool Saldo::calcola_data_limite(int annoes, int g, int c, long s, const TDate& data_inf, const TDate& data_sup, int indbil, bool controllo_competenza, const TDate& inizio_es, const TDate& fine_es, const TDate& fine_es_prec,bool stp_prov)
{
TDate data_rmv; TString sezione, gcs_corr, gcs_prec="", provv = "";
bool esito = FALSE; real importo, dep = 0.00;
int gruppo, conto, annoe;
rmov.setkey(2); long sottoconto, num_reg;
rmov.zero(); TLocalisamfile& rmov = *_rmov;
rmov.put(RMV_GRUPPO,g);
if (c != 0) TDate data_rmv;
rmov.put(RMV_CONTO,c); bool esito = FALSE;
if (s != 0)
rmov.put(RMV_SOTTOCONTO,s); rmov.setkey(2);
TRectype rec(rmov.curr()); rmov.zero();
rmov.put(RMV_GRUPPO,g);
rmov.read(_isgteq); if (c != 0)
for ( ; !rmov.eof(); rmov.next()) rmov.put(RMV_CONTO,c);
{ if (s != 0)
if (rmov.curr() != rec) break; rmov.put(RMV_SOTTOCONTO,s);
TRectype rec(rmov.curr());
annoe = rmov.get_int(RMV_ANNOES);
gruppo = rmov.get_int(RMV_GRUPPO); rmov.read(_isgteq);
conto = rmov.get_int(RMV_CONTO); for ( ; !rmov.eof(); rmov.next())
sottoconto = rmov.get_long(RMV_SOTTOCONTO); {
data_rmv = rmov.get_date(RMV_DATAREG); if (rmov.curr() != rec) break;
num_reg = rmov.get_long(RMV_NUMREG);
annoe = rmov.get_int(RMV_ANNOES);
//se la causale del movimento e' uguale a quella di chiusura, il movimento non va considerato gruppo = rmov.get_int(RMV_GRUPPO);
if (causale_mov(num_reg,inizio_es,data_sup,provv)) conto = rmov.get_int(RMV_CONTO);
break; sottoconto = rmov.get_long(RMV_SOTTOCONTO);
data_rmv = rmov.get_date(RMV_DATAREG);
if ((!stp_prov) && (provv.trim().not_empty())) //se non e' richiesta stampa num_reg = rmov.get_long(RMV_NUMREG);
continue; //mov. provvisori li scarto
//se la causale del movimento e' uguale a quella di chiusura, il movimento non va considerato
gcs_corr = format ("%3d%3d%6ld", gruppo, conto, sottoconto); if (causale_mov(num_reg,inizio_es,data_sup,provv))
break;
if (gcs_corr != gcs_prec)
{ if ((!stp_prov) && (provv.trim().not_empty())) //se non e' richiesta stampa
gcs_prec = gcs_corr; continue; //mov. provvisori li scarto
dep += calcola_saldo_iniziale(annoe,gruppo,conto,sottoconto,indbil);
} gcs_corr = format ("%3d%3d%6ld", gruppo, conto, sottoconto);
//controllo sulle date if (gcs_corr != gcs_prec)
if (annoe != annoes) {
if (annoe != annoes-1) gcs_prec = gcs_corr;
continue; dep += calcola_saldo_iniziale(annoe,gruppo,conto,sottoconto,indbil);
}
if (controllo_competenza)
if ( (annoe == annoes -1) && (data_sup != fine_es) ) //controllo sulle date
continue; if (annoe != annoes)
else if (annoe != annoes-1)
if ( (data_rmv <= fine_es) && (data_rmv <= fine_es_prec) || continue;
(data_rmv > fine_es) )
continue; if (controllo_competenza)
if ( (annoe == annoes -1) && (data_sup != fine_es) )
if ( (data_rmv < data_inf) || (data_rmv > data_sup) ) continue;
continue; else
if ( (data_rmv <= fine_es) && (data_rmv <= fine_es_prec) ||
sezione = rmov.get(RMV_SEZIONE); (data_rmv > fine_es) )
importo = rmov.get_real(RMV_IMPORTO); continue;
if (importo.is_zero()) if ( (data_rmv < data_inf) || (data_rmv > data_sup) )
continue; continue;
esito = TRUE; sezione = rmov.get(RMV_SEZIONE);
importo = rmov.get_real(RMV_IMPORTO);
if (sezione == "D") dep += importo;
else dep -= importo; if (importo.is_zero())
continue;
}
_saldo = dep; esito = TRUE;
return esito;
} if (sezione == "D") dep += importo;
else dep -= importo;
bool Saldo::calcola_ultima_immissione(int annoes, int annoesprec, int g, int c,
long s, int indbil) }
{ _saldo = dep;
//Si considerano i saldi e non piu' i movimenti return esito;
}
int gruppo, conto, annoe;
long sottoconto; bool Saldo::calcola_ultima_immissione(int annoes, int annoesprec, int g, int c,
real saldo, pdare, pavere; long s, int indbil)
TLocalisamfile& saldi = *_saldi; {
bool esito = FALSE; //Si considerano i saldi e non piu' i movimenti
char sezione;
_saldo_iniziale = 0.00; int gruppo, conto, annoe;
_prg_dare = 0.00; long sottoconto;
_prg_avere = 0.00; TLocalisamfile& saldi = *_saldi;
saldi.zero(); bool esito = TRUE;
if (annoes != 0) _saldo_iniziale = ZERO;
saldi.put(SLD_ANNOES,annoes); _prg_dare = ZERO;
if (g != 0) _prg_avere = ZERO;
saldi.put(SLD_GRUPPO,g); _saldo = ZERO;
if (c != 0)
saldi.put(SLD_CONTO,c); saldi.zero();
if (s != 0)
saldi.put(SLD_SOTTOCONTO,s); if (annoes != 0) saldi.put(SLD_ANNOES,annoes);
if (g != 0) saldi.put(SLD_GRUPPO,g);
if (saldi.read() == NOERR) if (c != 0) saldi.put(SLD_CONTO,c);
{ if (s != 0) saldi.put(SLD_SOTTOCONTO,s);
annoe = saldi.get_int(SLD_ANNOES);
gruppo = saldi.get_int(SLD_GRUPPO); if (saldi.read() == NOERR)
conto = saldi.get_int(SLD_CONTO); {
sottoconto = saldi.get_long(SLD_SOTTOCONTO); annoe = saldi.get_int(SLD_ANNOES);
saldo = saldi.get_real(SLD_SALDO); gruppo = saldi.get_int(SLD_GRUPPO);
pdare = saldi.get_real(SLD_PDARE); conto = saldi.get_int(SLD_CONTO);
pavere = saldi.get_real(SLD_PAVERE); sottoconto = saldi.get_long(SLD_SOTTOCONTO);
_saldo_iniziale = saldi.get_real(SLD_SALDO);
if (annoesprec == 0) //all'ultima immissione es.in corso _prg_dare = saldi.get_real(SLD_PDARE);
{ _prg_avere = saldi.get_real(SLD_PAVERE);
if ( (pdare == 0)&&(pavere == 0.0) ) sezione = saldi.get_char(SLD_FLAGSALINI);
{
if ( (indbil == 3) || (indbil == 4) ) if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
return esito;
if (annoesprec == 0) //all'ultima immissione es.in corso
if ( (indbil == 1) || (indbil == 2) || (indbil == 5) ) {
{ // if (indbil == 3 || indbil == 4)
if (saldo == 0) // return esito;
{
saldo = saldofin_esprec(annoes,gruppo,conto,sottoconto); if (indbil == 1 || indbil == 2 || indbil == 5)
if (saldo == 0.00) if (_saldo_iniziale == ZERO)
return esito; _saldo_iniziale += saldofin_esprec(annoes,gruppo,conto,sottoconto);
}
_saldo_iniziale = saldo; // i tre valori precedenti vengono utilizzati per la stampa bilancio
} // di verifica
} _saldo = _saldo_iniziale + _prg_dare - _prg_avere;
else _saldo_iniziale = saldo; }
else //all'ultima immissione es.precedente
esito = TRUE; {
_prg_dare = pdare; TRecnotype numrec = saldi.recno();
_prg_avere = pavere; TRectype app = ricerca_progr_prec(annoe-1, gruppo, conto, sottoconto);
annoe = app.get_int (SLD_ANNOES);
// i tre valori precedenti vengono utilizzati per la stampa bilancio _prg_dare = app.get_real(SLD_PDARE);
// di verifica _prg_avere = app.get_real(SLD_PAVERE);
#ifdef DBG
_saldo = _saldo_iniziale + _prg_dare - _prg_avere; TString16 pd, pa;
pa = _prg_avere.string();
} pd = _prg_dare.string();
else //all'ultima immissione es.precedente warning_box ("pdare=%s pavere=%s", (const char*)pd, (const char *)pa);
{ #endif
TRecnotype numrec = saldi.recno(); saldi.readat(numrec);
TRectype app = ricerca_progr_prec(annoe-1, gruppo, conto, sottoconto); _saldo = _prg_dare - _prg_avere;
annoe = app.get_int (SLD_ANNOES); }
pdare = app.get_real(SLD_PDARE); }
pavere = app.get_real(SLD_PAVERE); return esito;
saldi.readat(numrec); }
if ( (pdare == 0) && (pavere == 0) )
return esito; TRectype& Saldo::ricerca_progr_prec (int annoesprec, int g, int c, long s)
{
esito = TRUE; TLocalisamfile& saldi = *_saldi;
_prg_dare = pdare;
_prg_avere = pavere; saldi.zero();
_saldo = pdare - pavere; // static TRectype rec(saldi.curr());
}
} if (annoesprec != 0) saldi.put(SLD_ANNOES,annoesprec);
return esito; if (g != 0) saldi.put(SLD_GRUPPO,g);
} if (c != 0) saldi.put(SLD_CONTO,c);
if (s != 0) saldi.put(SLD_SOTTOCONTO,s);
TRectype& Saldo::ricerca_progr_prec (int annoesprec, int g, int c, long s)
{ saldi.read();
TLocalisamfile& saldi = *_saldi; if (saldi.bad()) saldi.zero();
saldi.zero(); *_rec = saldi.curr();
static TRectype rec(saldi.curr()); return *_rec;
}
if (annoesprec != 0)
saldi.put(SLD_ANNOES,annoesprec); //calcolo dei progressivi attuali
if (g != 0) bool Saldo::prg_attuali(int annoes,TConto& conto,int indbil,real& prgdare,real& prgavere)
saldi.put(SLD_GRUPPO,g); {
if (c != 0) real saldoini, pdare, pavere, pdaresca, paveresca;
saldi.put(SLD_CONTO,c); char flagsalini;
if (s != 0)
saldi.put(SLD_SOTTOCONTO,s);
saldi.read();
if (saldi.bad())
saldi.zero();
rec = saldi.curr();
return rec;
}
//calcolo dei progressivi attuali
bool Saldo::prg_attuali(int annoes,TConto& conto,int indbil,real& prgdare,real& prgavere)
{
real saldoini, pdare, pavere, pdaresca, paveresca;
char flagsalini;
int g = conto.gruppo(); int g = conto.gruppo();
int c = conto.conto(); int c = conto.conto();
long s = conto.sottoconto(); long s = conto.sottoconto();
TLocalisamfile& saldi = *_saldi; TLocalisamfile& saldi = *_saldi;
saldi.zero(); saldi.zero();
saldi.put(SLD_GRUPPO,g); saldi.put(SLD_GRUPPO,g);
if (conto.conto() != 0) if (conto.conto() != 0)
saldi.put(SLD_CONTO,c); saldi.put(SLD_CONTO,c);
if (conto.sottoconto() != 0) if (conto.sottoconto() != 0)
saldi.put(SLD_SOTTOCONTO,s); saldi.put(SLD_SOTTOCONTO,s);
saldi.put(SLD_ANNOES,annoes); saldi.put(SLD_ANNOES,annoes);
if (saldi.read() == NOERR) if (saldi.read() == NOERR)
{ {
flagsalini = saldi.get(SLD_FLAGSALINI)[0]; flagsalini = saldi.get(SLD_FLAGSALINI)[0];
saldoini = saldi.get_real(SLD_SALDO); saldoini = saldi.get_real(SLD_SALDO);
if ( (indbil == 1) || (indbil == 2) || (indbil == 5) ) if ( (indbil == 1) || (indbil == 2) || (indbil == 5) )
if (saldoini == 0) if (saldoini == 0)
{ {
saldoini = saldofin_esprec(annoes,conto.gruppo(),conto.conto(),conto.sottoconto()); saldoini = saldofin_esprec(annoes,conto.gruppo(),conto.conto(),conto.sottoconto());
if (saldoini > 0.00) if (saldoini > 0.00)
flagsalini = 'D'; flagsalini = 'D';
else flagsalini = 'A'; else flagsalini = 'A';
} }
pdare = saldi.get_real(SLD_PDARE); pdare = saldi.get_real(SLD_PDARE);
pavere = saldi.get_real(SLD_PAVERE); pavere = saldi.get_real(SLD_PAVERE);
pdaresca = saldi.get_real(SLD_PDARESCA); pdaresca = saldi.get_real(SLD_PDARESCA);
paveresca = saldi.get_real(SLD_PAVERESCA); paveresca = saldi.get_real(SLD_PAVERESCA);
if (flagsalini == 'D') if (flagsalini == 'D')
{ {
prgdare = saldoini + pdare + pdaresca; prgdare = saldoini + pdare + pdaresca;
prgavere = pavere + paveresca; prgavere = pavere + paveresca;
} }
else else
{ {
prgdare = pdare + pdaresca; prgdare = pdare + pdaresca;
prgavere = saldoini + pavere + paveresca; prgavere = saldoini + pavere + paveresca;
} }
} }
return TRUE; return TRUE;
} }
bool Saldo::prg_mov_eliminati(int annoes,TConto& conto,int indbil,real& prgdare,real& prgavere) bool Saldo::prg_mov_eliminati(int annoes,TConto& conto,int indbil,real& prgdare,real& prgavere)
{ {
real saldoini, pdaresca, paveresca; real saldoini, pdaresca, paveresca;
char flagsalini; char flagsalini;
TLocalisamfile& saldi = *_saldi; TLocalisamfile& saldi = *_saldi;
saldi.zero(); saldi.zero();
saldi.put(SLD_GRUPPO,conto.gruppo()); saldi.put(SLD_GRUPPO,conto.gruppo());
if (conto.conto() != 0) if (conto.conto() != 0)
saldi.put(SLD_CONTO,conto.conto()); saldi.put(SLD_CONTO,conto.conto());
if (conto.sottoconto() != 0) if (conto.sottoconto() != 0)
saldi.put(SLD_SOTTOCONTO,conto.sottoconto()); saldi.put(SLD_SOTTOCONTO,conto.sottoconto());
saldi.put(SLD_ANNOES,annoes); saldi.put(SLD_ANNOES,annoes);
if (saldi.read() == NOERR) if (saldi.read() == NOERR)
{ {
flagsalini = saldi.get(SLD_FLAGSALINI)[0]; flagsalini = saldi.get(SLD_FLAGSALINI)[0];
saldoini = saldi.get_real(SLD_SALDO); saldoini = saldi.get_real(SLD_SALDO);
if ( (indbil == 1) || (indbil == 2) || (indbil == 5) ) if ( (indbil == 1) || (indbil == 2) || (indbil == 5) )
if (saldoini == 0) if (saldoini == 0)
{ {
saldoini = saldofin_esprec(annoes,conto.gruppo(),conto.conto(),conto.sottoconto()); saldoini = saldofin_esprec(annoes,conto.gruppo(),conto.conto(),conto.sottoconto());
if (saldoini > 0.00) if (saldoini > 0.00)
flagsalini = 'D'; flagsalini = 'D';
else flagsalini = 'A'; else flagsalini = 'A';
} }
pdaresca = saldi.get_real(SLD_PDARESCA); pdaresca = saldi.get_real(SLD_PDARESCA);
paveresca = saldi.get_real(SLD_PAVERESCA); paveresca = saldi.get_real(SLD_PAVERESCA);
if (flagsalini == 'D') if (flagsalini == 'D')
{ {
prgdare = saldoini + pdaresca; prgdare = saldoini + pdaresca;
prgavere = paveresca; prgavere = paveresca;
} }
else else
{ {
prgdare = pdaresca; prgdare = pdaresca;
prgavere = saldoini + paveresca; prgavere = saldoini + paveresca;
} }
} }
return TRUE; return TRUE;
} }
TLocalisamfile * get_descr_cf (TLocalisamfile * pconti, TLocalisamfile * get_descr_cf (TLocalisamfile * pconti,
TLocalisamfile * clifo, int g, int c, long s) TLocalisamfile * clifo, int g, int c, long s)
{ {
pconti->zero(); pconti->zero();
pconti->put (PCN_GRUPPO, g); pconti->put (PCN_GRUPPO, g);
pconti->put (PCN_CONTO , c); pconti->put (PCN_CONTO , c);
pconti->put (PCN_SOTTOCONTO, s); pconti->put (PCN_SOTTOCONTO, s);
pconti->read(); pconti->read();
if (pconti->good()) if (pconti->good())
return pconti; return pconti;
TString tipocf = pconti->get(PCN_TMCF); TString tipocf = pconti->get(PCN_TMCF);
long codcf = s; long codcf = s;
clifo->zero(); clifo->zero();
clifo->put(CLI_CODCF, codcf); clifo->put(CLI_CODCF, codcf);
clifo->put(CLI_TIPOCF, tipocf); clifo->put(CLI_TIPOCF, tipocf);
clifo->read(); clifo->read();
if (clifo->good()) if (clifo->good())
return clifo; return clifo;
return NULL; return NULL;
} }