961 lines
24 KiB
C++
Executable File
961 lines
24 KiB
C++
Executable File
// cg0500.cpp - Tabella causali
|
|
|
|
#include <applicat.h>
|
|
#include <msksheet.h>
|
|
#include <relapp.h>
|
|
#include <tabutil.h>
|
|
#include <config.h>
|
|
#include <utility.h>
|
|
|
|
#include <causali.h>
|
|
#include <rcausali.h>
|
|
#include <clifo.h>
|
|
#include <pconti.h>
|
|
|
|
#include "cglib.h"
|
|
#include "cg2103.h"
|
|
#include "cg0500.h"
|
|
|
|
typedef enum { no_descr, 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
|
|
|
|
TSheet_field* _sheet;
|
|
|
|
// Parametri ditta
|
|
bool _valuta, _saldaconto;
|
|
int _anno_iva;
|
|
|
|
protected:
|
|
static 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 sezione_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 ss_notify (int r, KEY k);
|
|
|
|
TRelation * _rel;
|
|
TMask * _msk;
|
|
|
|
// 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 fill_sheet(TMask&);
|
|
|
|
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 carica_righe_libere();
|
|
void causale_inc_pag();
|
|
void causale_ritenute ();
|
|
void causale_vendite ();
|
|
void causale_acquisti();
|
|
|
|
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 read_firm_params();
|
|
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;
|
|
tipo_descr _tipo_des; // Il tipo di causale corrente
|
|
|
|
void compila_array (const TString&, int, int, int);
|
|
|
|
TSheet_field& ss() const { return *_sheet; }
|
|
TMask& ss_mask() const { return _sheet->sheet_mask(); }
|
|
|
|
void add_riga (int numrig, char sz, TConto& tc, const TString& d, const TString& da);
|
|
bool mostra_campi(TMask_field& f);
|
|
|
|
bool valuta() const { return _valuta; }
|
|
bool saldaconto() const { return _saldaconto; }
|
|
int anno_iva() const { return _anno_iva; }
|
|
|
|
TCaus_app() {}
|
|
};
|
|
|
|
HIDDEN TCaus_app& app() { return (TCaus_app&) main_app(); }
|
|
|
|
bool TCaus_app::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 == app().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 == 2 || (tiporeg == 1 && !corrisp) ; break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// Funzioni che caricano le varie descrizioni fisse nell'array
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Cancella tutta la riga tranne la descrizione
|
|
void TCaus_app::clear(int riga)
|
|
{
|
|
TToken_string& r = ss().row(riga);
|
|
r = r.get(0);
|
|
ss().force_update(riga);
|
|
}
|
|
|
|
// Setta la descrizione di una riga senza cmbiare il resto
|
|
void TCaus_app::set_descr(int i, const char * dfi)
|
|
{
|
|
TToken_string& r = ss().row(i);
|
|
r.add(dfi, 0);
|
|
}
|
|
|
|
void TCaus_app::carica_righe_libere()
|
|
{
|
|
for (int i = ss().items(); i < 20; i++)
|
|
set_descr(i);
|
|
ss().force_update();
|
|
}
|
|
|
|
// Cancella tutte le descrizioni delle righe
|
|
void TCaus_app::clear_descr()
|
|
{
|
|
TArray& a = ss().rows_array();
|
|
for (int i=0; i < a.items(); i++)
|
|
{
|
|
TToken_string& r = (TToken_string&)a[i];
|
|
r.add("", 0);
|
|
}
|
|
app()._tipo_des = no_descr;
|
|
}
|
|
|
|
void TCaus_app::causale_vendite()
|
|
{
|
|
if (_tipo_des == vendita)
|
|
return;
|
|
|
|
clear_descr();
|
|
_tipo_des = vendita;
|
|
|
|
int i=0;
|
|
set_descr(i++, "C Clienti");
|
|
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.");
|
|
carica_righe_libere();
|
|
}
|
|
|
|
|
|
void TCaus_app::causale_acquisti()
|
|
{
|
|
if (_tipo_des == acquisto)
|
|
return;
|
|
|
|
clear_descr();
|
|
_tipo_des = acquisto;
|
|
|
|
int i=0;
|
|
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.");
|
|
carica_righe_libere();
|
|
}
|
|
|
|
void TCaus_app::causale_ritenute()
|
|
{
|
|
if (_tipo_des == ritenuta_occas)
|
|
return;
|
|
|
|
clear_descr();
|
|
_tipo_des = ritenuta_occas;
|
|
|
|
int i=0;
|
|
set_descr (i++, "Costo");
|
|
set_descr (i++, "Cassa/banca");
|
|
set_descr (i++, "Erario");
|
|
carica_righe_libere();
|
|
}
|
|
|
|
void TCaus_app::causale_inc_pag()
|
|
{
|
|
const tipo_descr tipo_des = valuta() ? incasso_pagamento_gesval : incasso_pagamento;
|
|
|
|
if (_tipo_des == tipo_des)
|
|
return;
|
|
|
|
clear_descr();
|
|
_tipo_des = tipo_des;
|
|
|
|
int i=0;
|
|
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 (_tipo_des == incasso_pagamento_gesval)
|
|
set_descr (i++, "C Differenza cambio");
|
|
carica_righe_libere();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// 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 (app().saldaconto()) 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 (app().saldaconto())
|
|
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, app().anno_iva());
|
|
if (registro.name().empty())
|
|
return f.error_box("Non esiste il registro %s per l'anno %d",
|
|
(const char *)codreg, app().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 (saldaconto()) m.hide(F_MOV_VALU);
|
|
m.hide(F_MOV_SEZ);
|
|
break;
|
|
case 3:
|
|
case 5:
|
|
case 6:
|
|
if (valuta()) m.show(F_MOV_VALU);
|
|
if (saldaconto()) 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 (valuta()) m.show(F_MOV_VALU);
|
|
if (!saldaconto())
|
|
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, app().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::ss_notify(int r, KEY k)
|
|
{
|
|
if (k == K_ENTER)
|
|
{
|
|
TToken_string &riga = app().ss().row(r);
|
|
const int g = riga.get_int(3);
|
|
if (g == 0) // riga azzerata
|
|
app().clear(r); // pulisco la riga anche nell'array
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TCaus_app::sezione_hndl (TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_ENTER)
|
|
{
|
|
if (f.mask().get(SS_GRUPPO).not_empty())
|
|
{
|
|
if (f.get().empty())
|
|
{
|
|
const int riga = app().ss().selected();
|
|
if (riga == 0 || riga == 8)
|
|
return f.error_box("E' necessario specificare la sezione D/A");
|
|
}
|
|
}
|
|
else
|
|
f.reset();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TCaus_app::conto_hndl (TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_ENTER)
|
|
{
|
|
char scarta = 'Z';
|
|
int ultima = 8;
|
|
|
|
const TipoIVA tpr = (TipoIVA)app().curr_mask().get_int(F_TIPO_REG);
|
|
|
|
switch (tpr)
|
|
{
|
|
case iva_vendite:
|
|
scarta = 'F'; break; // Scarta vendite a fornitori
|
|
case iva_acquisti:
|
|
scarta = 'C'; break; // Scarta acquisti da clienti
|
|
default:
|
|
scarta = 'Z'; // Accetta tutto
|
|
switch (app()._tipo_des)
|
|
{
|
|
case incasso_pagamento:
|
|
ultima = 11; break;
|
|
case incasso_pagamento_gesval:
|
|
ultima = 12; break;
|
|
default:
|
|
ultima = 8; break;
|
|
}
|
|
}
|
|
|
|
TMask_field& sez = f.mask().field(SS_SEZIONE);
|
|
char sezione = toupper(sez.get()[0]);
|
|
if (sezione != 'A' && sezione != 'D') sezione = ' ';
|
|
char sezione_consigliata = ' ';
|
|
|
|
const bool full = f.mask().get(SS_GRUPPO).not_empty();
|
|
|
|
const int riga = app().ss().selected();
|
|
if (tpr != nessuna_iva && riga <= ultima)
|
|
{
|
|
TMask_field& cfld = f.mask().field(SS_TIPOCF);
|
|
const char cf = toupper(cfld.get()[0]);
|
|
|
|
bool ok = TRUE;
|
|
if (riga == 0 || riga == 8)
|
|
{
|
|
ok = cf != scarta;
|
|
if (full && sezione == ' ')
|
|
{
|
|
if (riga == 0)
|
|
sezione_consigliata = cf == 'C' ? 'D' : 'A';
|
|
else
|
|
sezione_consigliata = app().ss().row(0).get_char(1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ok = cf != 'C' && cf != 'F';
|
|
if (full && sezione == ' ')
|
|
sezione_consigliata = app().ss().row(0).get_char(1) == 'D' ? 'A' : 'D';
|
|
}
|
|
|
|
if (!ok)
|
|
return cfld.error_box(
|
|
"%s non valido con registro %s", cf == 'C' ? "Cliente" : "Fornitore", iva2name(tpr));
|
|
}
|
|
|
|
if (sezione == ' ' && sezione_consigliata != ' ')
|
|
{
|
|
const char sc[2] = { sezione_consigliata, '\0' };
|
|
sez.set(sc);
|
|
}
|
|
}
|
|
|
|
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 (k == K_ENTER && f.get().not_empty())
|
|
{
|
|
const TMask& m = f.mask();
|
|
const bool ok = m.get(SS_GRUPPO).not_empty() && m.get(SS_CONTO).not_empty();
|
|
if (!ok) return f.error_box("Conto incompleto");
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void TCaus_app::compila_array(const TString& tpd, int tpm, int tpr, int m770)
|
|
{
|
|
_forcedCopy = FALSE;
|
|
if (tpd.empty() || tpd == "IN" || tpd == "AN" || tpd == "PG")
|
|
{
|
|
if (saldaconto())
|
|
{
|
|
switch (tpm) {
|
|
case 3:
|
|
case 5:
|
|
case 6:
|
|
causale_inc_pag();
|
|
break;
|
|
case 0:
|
|
if (m770 == 6)
|
|
{
|
|
causale_ritenute();
|
|
}
|
|
else
|
|
{
|
|
_forcedCopy = TRUE;
|
|
clear_descr();
|
|
carica_righe_libere();
|
|
}
|
|
break;
|
|
default:
|
|
_forcedCopy = TRUE;
|
|
clear_descr();
|
|
carica_righe_libere();
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{ // NO saldaconto
|
|
_forcedCopy = TRUE;
|
|
clear_descr();
|
|
carica_righe_libere();
|
|
}
|
|
}
|
|
else // C'e' il tipodoc.
|
|
{
|
|
if (tpr == 1)
|
|
causale_vendite();
|
|
else
|
|
if (tpr == 2)
|
|
causale_acquisti();
|
|
else
|
|
{
|
|
_forcedCopy = TRUE;
|
|
clear_descr();
|
|
carica_righe_libere();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Relapp functions
|
|
///////////////////////////////////////////////////////////
|
|
|
|
int TCaus_app::read(TMask& m)
|
|
{
|
|
m.autoload(_rel);
|
|
read_rcaus(m);
|
|
fill_sheet(m);
|
|
return NOERR;
|
|
}
|
|
|
|
void TCaus_app::add_riga(int numrig, char sz, TConto& tc, const TString& d, const TString& da)
|
|
{
|
|
TToken_string& riga = ss().row(numrig);
|
|
riga = riga.get(0); // Lascia invariata la descrizione ...
|
|
if (riga.empty()) riga = " "; // ... se esiste gia'
|
|
riga.add(sz);
|
|
riga.add(tc.string(0x3));
|
|
riga.add(d);
|
|
riga.add(da);
|
|
}
|
|
|
|
void TCaus_app::read_rcaus(TMask& m)
|
|
{
|
|
TLocalisamfile& rcaus = _rel->lfile(LF_RCAUSALI);
|
|
TTable dpn("%DPN");
|
|
|
|
_rel->update(); // chiamo position_rels()
|
|
const TString16 cod(_rel->lfile().get(RCA_CODCAUS));
|
|
TString16 d;
|
|
TString80 da;
|
|
|
|
_righe_gia_presenti.reset();
|
|
|
|
rcaus.zero();
|
|
rcaus.put(RCA_CODCAUS, cod);
|
|
|
|
for (int err = rcaus.read(_isgteq);
|
|
err == NOERR && rcaus.get(RCA_CODCAUS) == cod;
|
|
err = rcaus.next())
|
|
{
|
|
const numrig = rcaus.get_int(RCA_NRIGA);
|
|
CHECK(numrig > 0, "Causale con numero riga nullo");
|
|
const char sz = rcaus.get_char(RCA_SEZIONE);
|
|
const char cf = rcaus.get_char(RCA_TIPOCF);
|
|
const int g = rcaus.get_int(RCA_GRUPPO);
|
|
const int c = rcaus.get_int(RCA_CONTO);
|
|
const long s = rcaus.get_long(RCA_SOTTOCONTO);
|
|
d = rcaus.get(RCA_CODDESC);
|
|
|
|
if (d.not_empty())
|
|
{
|
|
dpn.put("CODTAB", d);
|
|
dpn.read() ;
|
|
da = dpn.get("S0");
|
|
} else da.cut(0);
|
|
|
|
TConto tc(g,c,s,cf);
|
|
add_riga(numrig-1, sz, tc, d, da);
|
|
|
|
_righe_gia_presenti.set(numrig);
|
|
}
|
|
}
|
|
|
|
|
|
bool TCaus_app::fill_sheet(TMask& m)
|
|
{
|
|
TLocalisamfile& caus = _rel->lfile();
|
|
TString16 tpd, codreg;
|
|
int tpm, m770, tpr;
|
|
|
|
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
|
|
compila_array(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);
|
|
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 re)
|
|
{
|
|
const TString16 codcau(m.get(F_COD_CAUS));
|
|
TString16 coddesc;
|
|
|
|
TLocalisamfile& caus = _rel->lfile(LF_CAUSALI);
|
|
TLocalisamfile& rcaus = _rel->lfile(LF_RCAUSALI);
|
|
|
|
m.autosave(_rel);
|
|
|
|
for (int i = 0; i < ss().items(); i++)
|
|
{
|
|
TToken_string &riga = ss().row(i);
|
|
|
|
const char sezione = riga.get_char(1);
|
|
const char tipo_cf = riga.get_char();
|
|
const int g = riga.get_int();
|
|
if (g == 0) continue;
|
|
|
|
const int c = riga.get_int();
|
|
long s = riga.get_long();
|
|
riga.get(); // Salta descrizione conto
|
|
coddesc = riga.get();
|
|
|
|
if (g > 0)
|
|
{
|
|
rcaus.zero();
|
|
rcaus.put (RCA_CODCAUS, codcau);
|
|
rcaus.put (RCA_NRIGA, i+1); // Numerare da uno!
|
|
rcaus.put (RCA_SEZIONE, sezione);
|
|
rcaus.put (RCA_TIPOCF, tipo_cf);
|
|
rcaus.put (RCA_GRUPPO , g);
|
|
rcaus.put (RCA_CONTO , c);
|
|
rcaus.put (RCA_SOTTOCONTO, s);
|
|
rcaus.put (RCA_CODDESC, coddesc);
|
|
if (_righe_gia_presenti[i+1])
|
|
{
|
|
rcaus.rewrite();
|
|
_righe_gia_presenti.reset(i+1);
|
|
}
|
|
else
|
|
rcaus.write();
|
|
}
|
|
}
|
|
|
|
if (re)
|
|
{
|
|
togli_dal_file(codcau); // 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_mask(TMask& m)
|
|
{
|
|
m.set(F_ANNOES, _anno_iva);
|
|
}
|
|
|
|
void TCaus_app::init_query_mode(TMask& m)
|
|
{
|
|
read_firm_params();
|
|
ss().reset();
|
|
init_mask(m);
|
|
}
|
|
|
|
void TCaus_app::init_insert_mode(TMask& m)
|
|
{
|
|
init_mask(m);
|
|
_righe_gia_presenti.reset();
|
|
}
|
|
|
|
void TCaus_app::init_modify_mode(TMask& m)
|
|
{
|
|
init_mask(m);
|
|
}
|
|
|
|
|
|
void TCaus_app::read_firm_params()
|
|
{
|
|
TConfig conf(CONFIG_DITTA);
|
|
|
|
_saldaconto = conf.get_bool("GesSal");
|
|
_valuta = conf.get_bool("GesVal");
|
|
_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);
|
|
conf.set("AnLiIv", _anno_iva);
|
|
}
|
|
}
|
|
|
|
bool TCaus_app::user_create()
|
|
{
|
|
_rel = new TRelation (LF_CAUSALI);
|
|
_rel->add(LF_RCAUSALI, "CODCAUS=CODCAUS");
|
|
|
|
_msk = new TMask("cg0500a");
|
|
_sheet = &(TSheet_field&)_msk->field(F_SHEET_GCS);
|
|
|
|
read_firm_params();
|
|
|
|
_msk->show(F_TIPO_MOV_1, saldaconto());
|
|
_msk->show(F_TIPO_MOV_2, saldaconto());
|
|
_msk->show (F_MOV_SEZ, saldaconto());
|
|
_msk->show (F_COD_CAUS_IM, !saldaconto());
|
|
_msk->show (F_MOV_VALU, valuta());
|
|
|
|
_msk->set_handler(F_TIPO_DOC, tipodoc_hndl);
|
|
if (saldaconto())
|
|
{
|
|
_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(ss_notify);
|
|
|
|
cs.sheet_mask().set_handler(SS_SEZIONE, sezione_hndl);
|
|
cs.sheet_mask().set_handler(SS_CONTO, conto_hndl);
|
|
cs.sheet_mask().set_handler(SS_SOTTOCONTO, sottoconto_hndl);
|
|
cs.sheet_mask().set_handler(SS_SOTTOCONTO+100, sottoconto_hndl);
|
|
cs.sheet_mask().set_handler(SS_SOTTOCONTO+200, sottoconto_hndl);
|
|
|
|
_forcedCopy = FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TCaus_app::user_destroy()
|
|
{
|
|
delete _msk;
|
|
delete _rel;
|
|
return TRUE;
|
|
}
|
|
|
|
int cg0500(int argc, char* argv[])
|
|
{
|
|
TCaus_app a;
|
|
a.run(argc, argv, "Tabella causali");
|
|
return 0;
|
|
}
|
|
|