root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg0500.cpp
guy 93bd116018 Corretto errore 1176 sulle causali (cambiamento da FV a FA o viceversa) 
1126               (gestione conti sulle righe)
Corretta registrazione tipo attivita nelle righe IVA della prima nota


git-svn-id: svn://10.65.10.50/trunk@450 c028cbd2-c16b-5b4b-a496-9718f37d4682
1994-10-25 11:06:08 +00:00

1121 lines
29 KiB
C++
Executable File
Raw Blame History

// cg0500.cpp - Tabella causali
#include <applicat.h>
#include <msksheet.h>
#include <relapp.h>
#include <tabutil.h>
#include <config.h>
#include <utility.h>
#include <clifo.h>
#include <pconti.h>
#include <causali.h>
#include <rcausali.h>
#include "cglib.h"
#include "cg2103.h"
#include "cg0500.h"
#define SS_TIPOCF 102
#define SS_GRUPPO 103
#define SS_CONTO 104
////////////////////////////////////////////////////////////////////////////
// Funzioni legate ai parametri ditta
////////////////////////////////////////////////////////////////////////////
HIDDEN bool salda_conto()
{
static bool _saldaconto = 2;
if (_saldaconto == 2)
{
TConfig conf(CONFIG_DITTA);
_saldaconto = conf.get_bool("GesSal");
}
return _saldaconto;
}
HIDDEN bool gestione_valuta()
{
static bool _gest_val = 2;
if (_gest_val == 2)
{
TConfig conf(CONFIG_DITTA);
_gest_val = conf.get_bool("GesVal");
}
return _gest_val;
}
HIDDEN int anno_iva()
{
static int _anno_iva = 0;
if (_anno_iva == 0)
{
TConfig conf(CONFIG_DITTA);
_anno_iva = (int)conf.get_long("AnLiIv", "cg");
if (_anno_iva < 1900)
{
_anno_iva = TDate(TODAY).year();
error_box("Nei parametri ditta manca l'anno liquidazione IVA: assumo %d", _anno_iva);
}
}
return _anno_iva;
}
////////////////////////////////////////////////////////////////////////////
//
// Le righe di causale:
//
// Righe_rcaus e' un array di TRiga_caus.
//
// - 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 TRiga_caus : public TToken_string
{
public:
const TString& operator = (const TString& s)
{return TToken_string::operator=(s);}
TRiga_caus (TConto& tc, // il conto
const char *df="", // descrizione fissa
char tipocf=' ', // tipo C/F
char sezione=' ', // dare/avere
const char * des="", // descrizione del conto
const char * desagg="", // codice descr. aggiuntiva
char rigaiva=' ', // se e' una riga iva
const char * codiva=""); // codice iva
};
TRiga_caus::TRiga_caus (TConto& tc,const char * df, char tipocf, char sez,
const char * des, const char * desagg,
char rigaiva, const char * codiva)
: TToken_string(128)
{
add(df); add(tipocf);
// add(tc.tipo());
if (tc.ok())
{
add(tc.gruppo());
add(tc.conto());
add(tc.sottoconto());
}
else add(" | | ");
add(sez); add(des);
add(desagg);
add(rigaiva);
add(codiva);
}
class TRighe_rcaus : public TArray
{
public:
void set_descr (int numrig=-1, const char * descr="");
void clear(int riga); // pulisce una riga in seguito ad Azzera
void clear_descr(); // cancella solo le descrizioni fisse
void CaricaRigheLibere();
void CausaleIncassoPagamento();
void CausaleRitenutaOccas ();
void CausaleVendite ();
void CausaleAcquisti();
TRighe_rcaus() : TArray(20) {}
};
void TRighe_rcaus::clear_descr()
{
for (int i=0; i < items(); i++)
{
TRiga_caus *r = (TRiga_caus*)objptr(i);
if (r) r->add("", 0);
}
}
void TRighe_rcaus::clear(int row)
{
TRiga_caus* r = (TRiga_caus*)objptr(row);
if (r)
{
/*
r->add("", 1); r->add(0, 2); r->add(0, 3);
r->add(0L, 4); r->add("", 5); r->add("", 6);
r->add("", 7); r->add("", 8); r->add("", 9);
*/
*r = r->get(0);
}
}
void TRighe_rcaus::set_descr(int i, const char * dfi)
{
TRiga_caus *r = (TRiga_caus*)objptr(i);
if (r == NULL)
{
TConto tc;
r = new TRiga_caus(tc, dfi);
add(r,i);
}
else
r->add(dfi, 0);
}
bool filtra_reg(const TRelation * r);
typedef enum { acquisto, vendita, incasso_pagamento,
ritenuta_occas, incasso_pagamento_gesval } tipo_descr;
class TCaus_app : public TRelation_application
{
int _filtro; // tipo di filtro su tab. reg.
// 1 vendite senza corrisp
// 2 vendite con corrisp
// 3 acquisti
// 4 sia acquisti che vendite
friend bool filtra_reg(const TRelation * r);
static bool tipocf_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 tipomov_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 codcausim_hndl (TMask_field& f, KEY k);
static bool m770_hndl (TMask_field& f, KEY k);
static bool leggi_riga (int r, KEY k);
TRelation * _rel;
TMask * _msk;
TLocalisamfile * _conti;
int _mode; // Modo maschera corrente
int _items;
// Bitarray delle righe lette da file all'inizio.
// Quando leggo dal file la riga n setto il bit n.
TBit_array _righe_gia_presenti;
void togli_dal_file(const TString&);
void read_rcaus(TMask&);
bool descr2array(TMask&, bool fromHandler);
bool fill_sheet(TMask&);
protected:
virtual bool user_create();
virtual bool user_destroy();
virtual TRelation* get_relation() const { return _rel; }
virtual TMask* get_mask(int mode) { return _msk; }
virtual bool changing_mask(int mode) {return FALSE; }
virtual bool remove();
void init_mask(TMask&);
virtual void init_query_mode(TMask&);
virtual void init_insert_mode(TMask&);
virtual void init_modify_mode(TMask&);
virtual int rewrite(const TMask& m);
virtual int write(const TMask& m);
int re_write (const TMask& m, bool rewrite=FALSE);
virtual int read(TMask& m);
// int cancella(long items);
public:
bool _forcedCopy;
TRighe_rcaus _righe_rcaus; // Array delle descrizioni delle righe
tipo_descr _tipo_des; // Il tipo di causale corrente
int _riga; // Riga corrente dello sheet (set_notify)
void compilaarray (const TString&, int, int, int);
void array2sheet(); // Copia le descrizioni dall'array allo sheet
TMask* main_mask() const { return _msk; }
TMask& ss_mask() const { return ss().sheet_mask(); }
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 mostra_campi(TMask_field& f);
TLocalisamfile & conti() { return *_conti; }
TCaus_app() {}
};
HIDDEN TCaus_app& app() { return (TCaus_app&) main_app(); }
// Per sapere su che riga sono dello spreadsheet. v. set_notify piu' sotto
// e per pulire la sezione Dare/avere in caso di riga azzerata
bool TCaus_app::leggi_riga(int r, KEY k)
{
if (k == K_SPACE)
app()._riga = r;
if (k == K_ENTER)
{
TToken_string &riga = app().ss().row(r);
const int g = riga.get_int(2);
if (g == 0) // riga azzerata
{
riga.add("", 1); // pulisco tipo C/F
riga.add("", 5); // pulisco Dare/Avere
app()._righe_rcaus.clear(r); // pulisco la riga anche nell'array
app().ss().force_update(r);
}
}
return TRUE;
}
bool filtra_reg(const TRelation * r)
{
bool ok = FALSE;
const TRectype& rec = r->lfile().curr();
const int anno = atoi(rec.get("CODTAB").left(4));
if (anno == anno_iva())
{
const int tiporeg = rec.get_int("I0");
const bool corrisp = rec.get_bool("B0");
switch (app()._filtro)
{
case 1:
ok = tiporeg == 1; break;
case 2:
ok = (tiporeg == 1 && corrisp); break;
case 3:
ok = tiporeg == 2; break;
case 4: // tiporeg 1 senza corrisp OPPURE 2 (NC ST ND AF)
ok = (tiporeg == 1 && !corrisp) || tiporeg == 2; break;
default:
break;
}
}
return ok;
}
////////////////////////////////////////////////////////////////////////////
// Handler della maschera principale
////////////////////////////////////////////////////////////////////////////
/************
se m770==6 le descrizioni devono essere
1. conto
2. cassa/banca
3. erario
************/
bool TCaus_app::m770_hndl (TMask_field& f, KEY k)
{
if (k == K_TAB)
{
TMask& m = f.mask();
const int m770 = m.get_int(F_M_770);
if (m770 == 6)
app().fill_sheet(m);
}
return TRUE;
}
bool TCaus_app::tipodoc_hndl (TMask_field& f, KEY k)
{
// 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());
TEdit_field& field_reg = f.mask().efield(F_COD_REG);
if (val.not_empty() && val != "IN" && val != "PG" && val != "AN")
{
f.mask().hide(F_TIPO_MOV_2);
if (salda_conto()) f.mask().show(F_TIPO_MOV_1);
f.mask().enable(F_COD_REG);
field_reg.check_type(CHECK_REQUIRED);
TipoIVA i = nessuna_iva;
TTable tabtpd("%TPD");
tabtpd.put("CODTAB", val);
if (tabtpd.read() == NOERR)
{
i = (TipoIVA)tabtpd.get_int("I0"); // IVA acquisti, vendite, generica
bool corrisp = tabtpd.get_bool("B0");
if (i == 1) // vendite
{
if (corrisp) { // vendite con corrispettivi
app()._filtro = 2;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
}
else { // vendite senza corrispettivi
app()._filtro = 1;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
}
} else
if ( i == 2 ) // acquisti
{
app()._filtro = 3;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
} else
if ( i == 9 ) // sia acquisti che vendite
{
app()._filtro = 4;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
}
}
}
else // TIPODOC vuoto || IN || PG || AN
{
f.mask().set(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);
}
// Ma davvero esiste il registro ?
const TString16 codreg(f.mask().get(F_COD_REG));
if (codreg.not_empty())
{
TRegistro registro(codreg, anno_iva());
if (registro.name().empty())
return f.error_box("Non esiste il registro %s per l'anno %d",
(const char *)codreg, anno_iva());
}
app().mostra_campi(f);
app().fill_sheet(f.mask());
}
return TRUE;
}
bool TCaus_app::tipomov_hndl (TMask_field& f, KEY k)
{
if (k == K_SPACE)
{
app().mostra_campi(f);
if (f.focusdirty())
app().fill_sheet(f.mask());
}
return TRUE;
}
// Il codice causale per incasso immediato, se specificato, deve
// essere puramente contabile (= codreg vuoto e tpm = Nessuno
bool TCaus_app::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)
{
const int tpm = caus.get_int(CAU_TIPOMOV);
TString16 codreg = caus.get(CAU_REG);
if (codreg.not_empty() || tpm != 0)
return f.warning_box("La causale per l'incasso immediato specificata (%s) deve essere puramente contabile",
(const char *) causim);
}
}
return TRUE;
}
bool TCaus_app::mostra_campi(TMask_field& f)
{
TMask& m = f.mask();
const int tpm = m.get_int(F_TIPO_MOV);
TString16 codreg = m.get(F_COD_REG);
if (codreg.empty())
{
m.hide(F_AUTO_FAT);
m.hide(F_ALLEGAT);
m.hide(F_FAT_RITARDO);
m.hide(F_OP_INTRACOM);
m.hide(F_VALINTRA);
// if (salda_conto())
m.hide(F_COD_CAUS_IM);
switch (tpm)
{
case 0:
m.show(F_OP_FINE_ANNO);
m.show(F_COLL_CESP);
m.show(F_M_770);
if (salda_conto()) m.hide(F_MOV_VALU);
m.hide(F_MOV_SEZ);
break;
case 3:
case 5:
case 6:
if (gestione_valuta()) m.show(F_MOV_VALU);
if (salda_conto()) m.show(F_MOV_SEZ);
m.show(F_M_770);
m.hide(F_OP_FINE_ANNO);
m.hide(F_COLL_CESP);
break;
default:
break;
}
}
else
{ // codreg non vuoto
m.hide(F_OP_FINE_ANNO);
m.hide(F_MOV_SEZ);
if (gestione_valuta()) m.show(F_MOV_VALU);
if (!salda_conto())
m.show(F_COD_CAUS_IM);
m.show(F_AUTO_FAT);
m.show(F_ALLEGAT);
m.show(F_FAT_RITARDO);
m.show(F_COLL_CESP);
m.show(F_OP_INTRACOM);
m.show(F_VALINTRA);
}
return TRUE;
}
bool TCaus_app::cod_reg_hndl (TMask_field& f, KEY k)
{
if (k == K_TAB)
{
app().mostra_campi(f);
if (f.focusdirty()) app().fill_sheet(f.mask());
return TRUE;
}
// controllo di consistenza tra codice (tipo) registro e tipo documento
if (k == K_ENTER)
{
// bool ok = TRUE;
const TString16 tpd = f.mask().get(F_TIPO_DOC);
const TString16 codreg = f.mask().get(F_COD_REG);
if (tpd.not_empty())
{
TipoIVA i = nessuna_iva;
TRegistro grog(codreg, anno_iva());
TTable tabtpd("%TPD");
tabtpd.put("CODTAB", tpd);
if (tabtpd.read() == NOERR)
{
i = (TipoIVA)tabtpd.get_int("I0"); // IVA acquisti, vendite, generica
const TipoIVA ri = grog.iva();
if (i == iva_generica) i = ri;
if (i != ri)
{
return f.warning_box("Tipo documento incompatibile con tipo registro");
i = iva_errata;
}
}
}
}
return TRUE;
}
////////////////////////////////////////////////////////////////////////////
// Handler della maschera dello spreadsheet
////////////////////////////////////////////////////////////////////////////
bool TCaus_app::conto_hndl (TMask_field& f, KEY k)
{
// Se specifico il conto deve essere non vuoto il gruppo
if (f.to_check(k))
{
int io = f.dlg();
int c = f.mask().get_int(io);
int g = f.mask().get_int(io - 1);
if (c > 0)
if (g == 0)
return f.warning_box("Non accetto un conto senza gruppo");
}
// Controllo: << se e' fattura solo la riga 1 o 7 possono essere C/F >>
if (k == K_ENTER)
{
char scarta = '\0';
int ultima = 8;
char cf = f.mask().get(SS_TIPOCF)[0];
TMask_field& cfld = f.mask().field(SS_TIPOCF);
const int tpr = app().main_mask()->get_int(F_TIPO_REG);
bool puramente_contabile = FALSE;
switch (tpr)
{
case 1: scarta = 'F'; break;
case 2: scarta = 'C'; break;
case 0:
scarta = 'Z'; // Accetto tutto
puramente_contabile = TRUE;
switch (app()._tipo_des)
{
case incasso_pagamento: ultima = 11; break;
case incasso_pagamento_gesval: ultima = 12; break;
default: break;
}
}
if (!puramente_contabile)
{
if (app()._riga > ultima) // se sono nelle righe libere accetto TUTTO..
return TRUE;
else
if (app()._riga == 0 || app()._riga == 6)
{
if (cf == scarta)
return cfld.warning_box(
"Impossibile inserire un %s con registro di tipo %s nella riga %d",
cf == 'C' ? "cliente" : "fornitore",
tpr == 1 ? "vendite" : "acquisti", app()._riga+1);
}
else
if (cf == 'C' || cf == 'F')
return cfld.warning_box(
"Impossibile inserire un %s con registro di tipo %s nella riga %d",
cf == 'C' ? "cliente" : "fornitore",
tpr == 1 ? "vendite" : "acquisti", app()._riga+1);
}
}
return TRUE;
}
// 1. Se specifico il sottoconto devono essere non vuoti gruppo e conto
// 2. g-c-s devono esistere
bool TCaus_app::sottoconto_hndl (TMask_field& f, KEY k)
{
if (f.to_check(k))
{
int io = f.dlg();
int s = f.mask().get_int(io);
int g = f.mask().get_int(SS_GRUPPO);
int c = f.mask().get_int(SS_CONTO);
if (s > 0)
if (g == 0 || c == 0)
return f.warning_box("Non accetto un sottoconto con gruppo o conto vuoti");
/* A che cavolo serve CHECKTYPE NORMAL ????????????????????????????????????????
TConto tc(g,c,s);
if (!tc.read(app().conti().curr()))
return f.warning_box("Conto inesistente");
*/
}
return TRUE;
}
// Handler del campo tipocf della maschera di edit dello sheet
// Abilita 109 e 110 (rigaiva e codiva) SOLO SE registro 1 o 2
bool TCaus_app::tipocf_hndl (TMask_field& f, KEY k)
{
if (k == K_SPACE)
{
const int tpr = app().main_mask()->get_int(F_TIPO_REG);
if (tpr == 1 || tpr == 2) {
f.mask().enable(109); f.mask().enable(110);
}
else {
f.mask().disable(109); f.mask().disable(110);
}
}
return TRUE;
}
////////////////////////////////////////////////////////////////////////////
// Funzioni che caricano le varie descrizioni fisse nell'array
////////////////////////////////////////////////////////////////////////////
void TRighe_rcaus::CausaleVendite()
{
int i=0;
TConto tc();
app()._tipo_des = vendita;
// set_descr(i++, "C Clienti", 'C');
set_descr(i++, "C Clienti"); // Lascio scelta libera
set_descr(i++, "C Di ricavo");
set_descr(i++, "C Iva vendite");
set_descr(i++, "C Iva non detraibile");
set_descr(i++, "C Imp. esenti");
set_descr(i++, "C Imp. non imponibili");
set_descr(i++, "C Imp. non soggetti");
set_descr(i++, "C Ritenute fiscali");
set_descr(i++, "C Ritenute soc.");
CaricaRigheLibere();
}
void TRighe_rcaus::CausaleAcquisti()
{
int i=0;
app()._tipo_des = acquisto;
// set_descr( i++, "C Fornitori", 'F');
set_descr( i++, "C Fornitori");
set_descr(i++, "C Di costo");
set_descr(i++, "C Iva acquisti");
set_descr(i++, "C Iva non detraibile");
set_descr(i++, "C Imp. esenti");
set_descr(i++, "C Imp. non imponibili");
set_descr(i++, "C Imp. non soggetti");
set_descr(i++, "C Ritenute fiscali");
set_descr(i++, "C Ritenute soc.");
CaricaRigheLibere();
}
void TRighe_rcaus::CausaleRitenutaOccas()
{
int i=0;
app()._tipo_des = ritenuta_occas;
set_descr (i++, "Costo");
set_descr (i++, "Cassa/banca");
set_descr (i++, "Erario");
CaricaRigheLibere();
}
void TRighe_rcaus::CaricaRigheLibere()
{
for (int i = items(); i < 20; i++)
set_descr(i);
}
void TRighe_rcaus::CausaleIncassoPagamento()
{
int i=0;
app()._tipo_des = incasso_pagamento;
set_descr ( i++, "C Clienti/Fornitori");
set_descr ( i++, "C Cassa o banca");
set_descr ( i++, "C Tratta");
set_descr ( i++, "C Ricevuta bancaria");
set_descr ( i++, "C Cessione");
set_descr ( i++, "C Paghero'");
set_descr ( i++, "C Lettera di credito");
set_descr ( i++, "C Abb. pass/sc.");
set_descr ( i++, "C Abb. att/sc.");
set_descr ( i++, "C Spese e rimborsi");
set_descr ( i++, "C Ritenute fiscali");
if (gestione_valuta())
{
set_descr (i++, "C Differenza cambio");
app()._tipo_des = incasso_pagamento_gesval;
}
CaricaRigheLibere();
}
void TCaus_app::compilaarray(const TString& tpd, int tpm, int tpr, int m770)
{
_forcedCopy = FALSE;
if (tpd.empty() || tpd == "IN" || tpd == "AN" || tpd == "PG")
{
if (salda_conto())
{
switch (tpm) {
case 3:
case 5:
case 6:
_righe_rcaus.CausaleIncassoPagamento();
break;
case 0:
if (m770 == 6)
_righe_rcaus.CausaleRitenutaOccas();
else {
_forcedCopy = TRUE;
_righe_rcaus.clear_descr();
_righe_rcaus.CaricaRigheLibere();
}
break;
default:
_forcedCopy = TRUE;
_righe_rcaus.clear_descr();
_righe_rcaus.CaricaRigheLibere();
break;
}
}
else { // NO saldaconto
_forcedCopy = TRUE;
_righe_rcaus.clear_descr();
_righe_rcaus.CaricaRigheLibere();
}
}
else // C'e' il tipodoc.
{
if (tpr == 1)
_righe_rcaus.CausaleVendite();
else
if (tpr == 2)
_righe_rcaus.CausaleAcquisti();
else
{
_forcedCopy = TRUE;
_righe_rcaus.clear_descr();
_righe_rcaus.CaricaRigheLibere();
}
}
}
bool TCaus_app::fill_sheet(TMask& m)
{
descr2array(m, TRUE);
array2sheet();
return TRUE;
}
int TCaus_app::read(TMask& m)
{
m.autoload(_rel);
descr2array(m, FALSE);
array2sheet();
read_rcaus(m);
return NOERR;
}
void TCaus_app::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 TCaus_app::read_rcaus(TMask& m)
{
int numrig, g, c;
long s;
TString d(50), da(3), civa(3);
char sz, cf;
bool riva;
TLocalisamfile& rcaus = _rel->lfile(LF_RCAUSALI);
_rel->update(); // chiamo position_rels()
const TString cod(_rel->lfile().get(RCA_CODCAUS));
_righe_gia_presenti.reset();
// _righe_rcaus.destroy();
rcaus.zero();
rcaus.put(RCA_CODCAUS, cod);
int e = rcaus.read(_isgteq);
while (e == NOERR && rcaus.get(RCA_CODCAUS) == cod)
{
numrig = rcaus.get_int(RCA_NRIGA);
CHECK(numrig > 0, "Causale con numero riga nullo");
g = rcaus.get_int(RCA_GRUPPO);
c = rcaus.get_int(RCA_CONTO);
s = rcaus.get_long(RCA_SOTTOCONTO);
sz = rcaus.get_char(RCA_SEZIONE);
d = rcaus.get(RCA_DESC);
da = rcaus.get(RCA_CODDESC);
cf = rcaus.get_char(RCA_TIPOCF);
riva = rcaus.get_bool(RCA_RIGAIVA);
civa = rcaus.get(RCA_CODIVA);
TConto tc(g,c,s,cf);
add_riga(numrig-1, cf, sz, d, da, riva, civa, tc);
_righe_gia_presenti.set(numrig);
e = rcaus.next();
}
}
// ricopio l'array Righe_rcaus nello sheet
void TCaus_app::array2sheet()
{
TString80 dfi;
_items = _righe_rcaus.items();
bool update = FALSE;
for (int i = 0; i < _items; i++)
{
TToken_string& riga = ss().row(i);
TToken_string* r = (TToken_string*)_righe_rcaus.objptr(i);
dfi = r->get(0);
// Ricopio la descrizione solo se non vuota
if (_forcedCopy)
{
update = TRUE;
riga.add(dfi,0);
}
else
if (dfi.not_empty())
{
update = TRUE;
riga.add(dfi,0);
}
}
if (update) ss().force_update();
}
bool TCaus_app::descr2array(TMask& m, bool fromHandler)
{
TLocalisamfile& caus = _rel->lfile();
TString16 tpd, codreg;
int tpm, m770, tpr;
// if (m.mode() == MODE_MOD && !fromHandler)
if (fromHandler)
{
codreg = m.field(F_COD_REG).get();
tpd = m.field(F_TIPO_DOC).get();
tpm = m.get_int(F_TIPO_MOV);
m770 = m.get_int(F_M_770);
}
else if (m.mode() == MODE_MOD)
{
codreg = caus.get("REG");
tpd = caus.get("TIPODOC");
tpm = caus.get_int("TIPOMOV");
m770 = caus.get_int("M770");
}
else
{ // sono in inserimento e prima di entrare negli handler
codreg = m.field(F_COD_REG).get();
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);
if (reg.read() == NOERR)
tpr = reg.get_int("I0");
else
tpr = 0;
}
// carico le descrizioni fisse nell'array Righe_rcaus
compilaarray(tpd,tpm,tpr,m770);
return TRUE;
}
void TCaus_app::togli_dal_file(const TString& cau)
{
long i;
TLocalisamfile& rcaus = _rel->lfile(LF_RCAUSALI);
long last = _righe_gia_presenti.last_one();
long start = _righe_gia_presenti.first_one();
for (i=start; i<=last; i++)
{
if (_righe_gia_presenti[i])
{
rcaus.zero();
rcaus.put(RCA_CODCAUS,cau);
rcaus.put(RCA_NRIGA, i);
// if (rcaus.read() == NOERR)
rcaus.remove();
_righe_gia_presenti.reset(i);
}
}
}
int TCaus_app::write(const TMask& m)
{
return re_write(m, FALSE);
}
int TCaus_app::rewrite(const TMask& m)
{
return re_write(m, TRUE);
}
int TCaus_app::re_write(const TMask& m,bool rewrite)
{
const TString16 cau(m.get(F_COD_CAUS));
TString80 desc;
TString16 coddesc;
TLocalisamfile& caus = _rel->lfile(LF_CAUSALI);
TLocalisamfile& rcaus = _rel->lfile(LF_RCAUSALI);
m.autosave(_rel);
TSheet_field& cs = ss();
// _items = _righe_rcaus.items();
_items = cs.items();
for (int i = 0; i < _items; i++)
{
TToken_string &riga = cs.row(i);
if (riga.empty_items()) continue;
const char tipo_cf = riga.get_char(1);
const int g = riga.get_int(2);
const int c = riga.get_int(3);
long s = riga.get_long(4);
char sezione = riga.get_char(5);
desc = riga.get(6);
coddesc = riga.get(7);
if (g > 0 || c > 0 || s > 0L)
{
rcaus.zero();
rcaus.put (RCA_CODCAUS, (const char *)cau);
rcaus.put (RCA_NRIGA, i+1); // Numerare da uno!
rcaus.put (RCA_GRUPPO , g);
rcaus.put (RCA_CONTO , c);
rcaus.put (RCA_SOTTOCONTO, s);
rcaus.put (RCA_SEZIONE, sezione);
rcaus.put (RCA_DESC , (const char *)desc);
rcaus.put (RCA_CODDESC, (const char *)coddesc);
rcaus.put (RCA_TIPOCF, tipo_cf);
if (rewrite) {
if (_righe_gia_presenti[i+1]) {
rcaus.rewrite();
_righe_gia_presenti.reset(i+1);
}
else
rcaus.write();
}
else
rcaus.write();
}
}
if (rewrite)
{
togli_dal_file(cau); // Elimina dal file le righe rimaste nel bitarray
return caus.rewrite();
}
else
return caus.write();
}
bool TCaus_app::remove()
{
_rel->restore_status(); // senno' non riesco a leggere il cod. caus.
_rel->update(); // chiamo position_rels()
const TString cod(_rel->lfile().get(RCA_CODCAUS));
const bool ok = TRelation_application::remove();
if (ok)
{
TLocalisamfile& rcaus = _rel->lfile(LF_RCAUSALI);
rcaus.zero();
rcaus.put(RCA_CODCAUS, cod);
int e = rcaus.read(_isgteq);
while (e == NOERR && rcaus.get(RCA_CODCAUS) == cod)
{
rcaus.remove();
e = rcaus.next();
}
}
return ok;
}
void TCaus_app::init_query_mode(TMask& m)
{
_righe_rcaus.destroy();
ss().reset();
init_mask(m);
}
void TCaus_app::init_insert_mode(TMask& m)
{
ss().reset();
init_mask(m);
}
void TCaus_app::init_modify_mode(TMask& m)
{
init_mask(m);
}
void TCaus_app::init_mask(TMask& m)
{
// 27/06/94 Setto il campo nascosto F_ANNOES all'anno di liq. Iva
// preso dai par.ditta
const int anno = anno_iva();
m.set(F_ANNOES, anno);
}
bool TCaus_app::user_create()
{
_rel = new TRelation (LF_CAUSALI);
_rel->add(LF_RCAUSALI, "CODCAUS=CODCAUS");
_conti = new TLocalisamfile (LF_PCON);
_msk = new TMask("cg0500a");
if (!salda_conto())
{
_msk->hide (F_MOV_SEZ);
_msk->hide (F_TIPO_MOV_1);
_msk->hide (F_TIPO_MOV_2);
_msk->show (F_COD_CAUS_IM);
}
else
{
_msk->show (F_MOV_SEZ);
_msk->hide (F_COD_CAUS_IM);
}
if (gestione_valuta())
_msk->show (F_MOV_VALU);
else
_msk->hide (F_MOV_VALU);
_msk->set_handler(F_TIPO_DOC, tipodoc_hndl);
if (salda_conto())
{
_msk->set_handler(F_TIPO_MOV_1, 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_CAUS_IM, codcausim_hndl);
_msk->set_handler(F_M_770, m770_hndl);
TSheet_field& cs = ss();
cs.set_notify(leggi_riga);
cs.sheet_mask().set_handler(102, tipocf_hndl); // 102 e' il TIPOCF
cs.sheet_mask().set_handler(104, conto_hndl);
cs.sheet_mask().set_handler(105, sottoconto_hndl);
cs.sheet_mask().set_handler(205, sottoconto_hndl);
cs.sheet_mask().set_handler(305, sottoconto_hndl);
_forcedCopy = FALSE;
return TRUE;
}
bool TCaus_app::user_destroy()
{
delete _msk;
delete _rel;
delete _conti;
return TRUE;
}
int cg0500(int argc, char* argv[])
{
TCaus_app a;
a.run(argc, argv, "Tabella causali");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink