1084 lines
29 KiB
C++
Executable File
1084 lines
29 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 <clifo.h>
|
|
#include <pconti.h>
|
|
#include <causali.h>
|
|
#include <rcausali.h>
|
|
|
|
#include "cglib.h"
|
|
#include "cg0501.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("Anno liquidazione IVA non specificato: assumo %d", _anno_iva);
|
|
}
|
|
}
|
|
return _anno_iva;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Le righe di causale:
|
|
//
|
|
// 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
|
|
{
|
|
public:
|
|
const TString& operator = (const TString& s)
|
|
{return TToken_string::operator=(s);}
|
|
|
|
Riga_rcaus (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
|
|
bool rigaiva=' ', // se e' una riga iva
|
|
const char * codiva=""); // codice iva
|
|
};
|
|
|
|
Riga_rcaus::Riga_rcaus (TConto& tc,const char * df, char tipocf, char sez,
|
|
const char * des, const char * desagg,
|
|
bool rigaiva, const char * codiva)
|
|
: TToken_string(80)
|
|
{
|
|
add(df); add(tipocf);
|
|
// add(tc.tipo());
|
|
if (tc.ok()) {
|
|
add((long)tc.gruppo()); add((long)tc.conto());
|
|
add((long)tc.sottoconto());
|
|
}
|
|
else {
|
|
add(""); add(""); add("");
|
|
}
|
|
add(sez); add(des); add(desagg);
|
|
add((char)rigaiva); add(codiva);
|
|
}
|
|
|
|
class TRighe_rcaus : public TArray
|
|
{
|
|
public:
|
|
void set_descr (int numrig=-1, const char * descr="", char tipocf=' ');
|
|
void clear(int riga); // pulisce una riga in seguito ad Azzera
|
|
void ClearDescr(); // cancella solo le descrizioni fisse
|
|
void CaricaRigheLibere();
|
|
void CausaleIncassoPagamento();
|
|
void CausaleRitenutaOccas ();
|
|
void CausaleVendite ();
|
|
void CausaleAcquisti();
|
|
TRighe_rcaus() : TArray(20) {}
|
|
};
|
|
|
|
void TRighe_rcaus::ClearDescr()
|
|
{
|
|
for (int i=0; i < items(); i++) {
|
|
Riga_rcaus *r = (Riga_rcaus*)objptr(i);
|
|
if (r) r->add("", 0);
|
|
}
|
|
}
|
|
|
|
void TRighe_rcaus::clear(int row)
|
|
{
|
|
Riga_rcaus *r = (Riga_rcaus*)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);
|
|
}
|
|
}
|
|
|
|
void TRighe_rcaus::set_descr(int i, const char * dfi, char tipocf)
|
|
{
|
|
Riga_rcaus *r = (Riga_rcaus*)objptr(i);
|
|
TConto tc;
|
|
|
|
if (r == NULL) {
|
|
r = new Riga_rcaus (tc,dfi,tipocf);
|
|
add(r,i);
|
|
}
|
|
r->add(dfi, 0);
|
|
r->add(tipocf, 1);
|
|
}
|
|
|
|
bool filtra_reg(const TRelation * r);
|
|
|
|
typedef enum { acquisto, vendita, incasso_pagamento,
|
|
ritenuta_occas, incasso_pagamento_gesval } tipo_descr;
|
|
|
|
class CG0500_application : public TRelation_application
|
|
{
|
|
int _filtro; // tipo di filtro su tab. reg.
|
|
// 1 vendite senza corrisp
|
|
// 2 vendite con corrisp
|
|
// 3 acquisti
|
|
|
|
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 leggi_riga (int r, KEY k);
|
|
|
|
TRelation * _rel;
|
|
TMask * _msk;
|
|
int _mode; // Modo maschera corrente
|
|
int _items;
|
|
|
|
TBit_array _righe_gia_presenti;
|
|
|
|
void togli_dal_file(const TString&);
|
|
|
|
void read_rcaus(TMask&);
|
|
bool descr2array(TMask&, bool fromHandler = TRUE);
|
|
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:
|
|
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 MostraCampi(TMask_field& f);
|
|
|
|
CG0500_application() {}
|
|
};
|
|
|
|
HIDDEN CG0500_application * app() { return (CG0500_application*) MainApp(); }
|
|
|
|
// 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 CG0500_application::leggi_riga(int r, KEY k)
|
|
{
|
|
if (k == K_SPACE) app()->_riga = r;
|
|
|
|
if (k == K_ENTER)
|
|
{
|
|
TToken_string &riga = app()->ss().row(r);
|
|
int g = riga.get_int(3);
|
|
int c = riga.get_int(4);
|
|
long s = riga.get_long(5);
|
|
if (g == 0 && c == 0 && s == 0L) // 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)
|
|
{
|
|
const TString codtab(r->lfile()->get("CODTAB"));
|
|
int tiporeg = r->lfile()->get_int("I0");
|
|
bool corrisp = r->lfile()->get_bool("B0");
|
|
|
|
const int anno = atoi(codtab.left(4));
|
|
|
|
switch (app()->_filtro)
|
|
{
|
|
case 1:
|
|
if (anno == anno_iva() && tiporeg == 1)
|
|
return TRUE;
|
|
break;
|
|
case 2:
|
|
if (anno == anno_iva() && tiporeg == 1 && corrisp)
|
|
return TRUE;
|
|
break;
|
|
case 3:
|
|
if (anno == anno_iva() && tiporeg == 2)
|
|
return TRUE;
|
|
break;
|
|
case 4: // tiporeg 1 senza corrisp OPPURE 2 (NC ST ND AF)
|
|
if (anno == anno_iva())
|
|
if ( (tiporeg == 1 && !corrisp) || tiporeg == 2 )
|
|
return TRUE;
|
|
break;
|
|
default:
|
|
return FALSE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// Handler della maschera principale
|
|
////////////////////////////////////////////////////////////////////////////
|
|
bool CG0500_application::tipodoc_hndl (TMask_field& f, KEY k)
|
|
{
|
|
// 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());
|
|
TEdit_field& field_reg = (TEdit_field&)f.mask().field(F_COD_REG);
|
|
|
|
if (val.not_empty() && val != "IN" && val != "PG" && val != "AN")
|
|
{
|
|
if (salda_conto()) {
|
|
f.mask().hide(F_TIPO_MOV_2);
|
|
f.mask().show(F_TIPO_MOV_1);
|
|
}
|
|
f.mask().enable(F_COD_REG);
|
|
field_reg.check_type(CHECK_REQUIRED);
|
|
|
|
// Cambio il filtro sui registri: con tipo=1
|
|
if (val == "FV" || val == "FF" || val == "FS") {
|
|
app()->_filtro = 1;
|
|
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
|
|
} else
|
|
// con tipo=1 e corrisp="X"
|
|
if (val == "CN" || val == "RN" || val == "CR" ||
|
|
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())
|
|
{
|
|
TRegistro registro(codreg, anno_iva());
|
|
if (!registro.read(codreg, anno_iva()))
|
|
return f.warning_box("Non esiste il registro %s per l'anno %d",
|
|
(const char *)codreg, anno_iva());
|
|
}
|
|
}
|
|
else // TIPODOC vuoto || IN || PG || AN
|
|
{
|
|
// Devo poter rivedere tutti i registri se ho cancellato il campo TIPODOC
|
|
field_reg.check_type(CHECK_NORMAL);
|
|
|
|
f.mask().set(F_COD_REG,"");
|
|
f.mask().disable(F_COD_REG);
|
|
if (salda_conto()) {
|
|
f.mask().hide(F_TIPO_MOV_1);
|
|
f.mask().show(F_TIPO_MOV_2);
|
|
}
|
|
}
|
|
if (f.focusdirty()) {
|
|
app()->fill_sheet(f.mask());
|
|
app()->MostraCampi(f); // show-hide di diversi campi pilotati da codreg
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool CG0500_application::tipomov_hndl (TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_SPACE) {
|
|
app()->MostraCampi(f);
|
|
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 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)
|
|
{
|
|
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 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;
|
|
}
|
|
|
|
bool CG0500_application::cod_reg_hndl (TMask_field& f, KEY k)
|
|
{
|
|
// if (k == K_TAB && f.focusdirty())
|
|
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
|
|
// if (k == K_ENTER && f.dirty())
|
|
if (k == K_ENTER)
|
|
{
|
|
bool ok = TRUE;
|
|
|
|
const TString16 tpd = f.mask().get(F_TIPO_DOC);
|
|
const int tipo = f.mask().get_int(F_TIPO_REG);
|
|
const bool corrisp = f.mask().get_bool(F_CORRISP);
|
|
const TString16 codreg = f.mask().get(F_COD_REG);
|
|
|
|
if (tpd.not_empty() && tpd != "AN" && tpd != "PG" && tpd != "IN")
|
|
{
|
|
if (codreg.empty())
|
|
return f.warning_box("Manca il codice del registro");
|
|
}
|
|
else
|
|
{
|
|
// con tipo=1
|
|
if (tpd == "FV" || tpd == "FS" || tpd == "FS")
|
|
{
|
|
if (tipo != 1) ok = FALSE;
|
|
} else
|
|
|
|
// con tipo=1 e corrisp="X"
|
|
if (tpd == "CN" || tpd == "RN" || tpd == "CR" ||
|
|
tpd == "SC" || tpd == "RF" || tpd == "SN")
|
|
{
|
|
if (tipo != 1 || !corrisp) ok = FALSE;
|
|
} else
|
|
// Possono essere 1 o 2
|
|
if (tpd == "NC" || tpd == "ST" || tpd == "ND" ||
|
|
tpd == "AF")
|
|
{
|
|
if (tipo != 1 && tipo != 2) ok = FALSE;
|
|
} else
|
|
|
|
// con tipo=2
|
|
if (tpd == "FA" || tpd == "BD")
|
|
{
|
|
if (tipo != 2) ok = FALSE;
|
|
}
|
|
}
|
|
if (!ok)
|
|
return f.warning_box("Il registro (tipo %d) non e' compatibile con il tipo di documento (%s)",
|
|
tipo, (const char*)tpd);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// Handler della maschera dello spreadsheet
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// Se specifico il conto deve essere non vuoto il gruppo
|
|
bool CG0500_application::conto_hndl (TMask_field& f, KEY k)
|
|
{
|
|
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: << 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);
|
|
|
|
switch (tpr)
|
|
{
|
|
case 1:
|
|
scarta = 'F';
|
|
break;
|
|
case 2:
|
|
scarta = 'C';
|
|
break;
|
|
case 0:
|
|
scarta = 'Z'; // Accetto tutto
|
|
switch (app()->_tipo_des)
|
|
{
|
|
case incasso_pagamento:
|
|
ultima = 11;
|
|
break;
|
|
case incasso_pagamento_gesval:
|
|
ultima = 12;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
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 != '\0')
|
|
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;
|
|
}
|
|
|
|
// Se specifico il sottoconto devono essere non vuoti gruppo e conto
|
|
bool CG0500_application::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");
|
|
}
|
|
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 CG0500_application::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 CG0500_application::compilaarray(const TString& tpd, int tpm, int tpr, int m770)
|
|
{
|
|
if (tpd.empty() || tpd == "IN" || tpd == "AN" || tpd == "PG")
|
|
{
|
|
if ( tpm == 3 || tpm == 5 || tpm == 6 )
|
|
_righe_rcaus.CausaleIncassoPagamento();
|
|
else
|
|
{
|
|
if ( !salda_conto() || tpm == 0 )
|
|
if (m770 == 6)
|
|
{
|
|
_righe_rcaus.CausaleRitenutaOccas();
|
|
return;
|
|
}
|
|
_righe_rcaus.ClearDescr();
|
|
_righe_rcaus.CaricaRigheLibere();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (tpr == 1)
|
|
_righe_rcaus.CausaleVendite();
|
|
else
|
|
if (tpr == 2)
|
|
_righe_rcaus.CausaleAcquisti();
|
|
else
|
|
{
|
|
_righe_rcaus.ClearDescr();
|
|
_righe_rcaus.CaricaRigheLibere();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CG0500_application::fill_sheet(TMask& m)
|
|
{
|
|
descr2array(m);
|
|
array2sheet();
|
|
return TRUE;
|
|
}
|
|
|
|
int CG0500_application::read(TMask& m)
|
|
{
|
|
m.autoload(_rel);
|
|
descr2array(m, FALSE);
|
|
array2sheet();
|
|
read_rcaus(m);
|
|
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)
|
|
{
|
|
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()
|
|
|
|
_righe_gia_presenti.reset();
|
|
// _righe_rcaus.destroy();
|
|
|
|
bool ok = _rel->is_first_match(LF_RCAUSALI);
|
|
while (ok)
|
|
{
|
|
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(RCA_TIPOCF)[0];
|
|
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);
|
|
ok = _rel->next_match(LF_RCAUSALI);
|
|
}
|
|
}
|
|
|
|
// ricopio l'array Righe_rcaus nello sheet
|
|
void CG0500_application::array2sheet()
|
|
{
|
|
char _dfi [30];
|
|
TFixed_string dfi(_dfi,30);
|
|
_items = _righe_rcaus.items();
|
|
// ss().reset();
|
|
for (int i = 0; i < _items; i++)
|
|
{
|
|
TToken_string & riga = ss().row(i);
|
|
TToken_string * r = (TToken_string*)_righe_rcaus.objptr(i);
|
|
if (r != NULL)
|
|
{
|
|
dfi = r->get(0);
|
|
riga.add(dfi,0);
|
|
}
|
|
else
|
|
riga.cut(0);
|
|
}
|
|
ss().force_update();
|
|
}
|
|
|
|
bool CG0500_application::descr2array(TMask& m, bool fromHandler)
|
|
{
|
|
TLocalisamfile& caus = *_rel->lfile();
|
|
TString16 tpd, codreg;
|
|
int tpm, m770, tpr;
|
|
|
|
if (m.mode() == MODE_MOD && !fromHandler)
|
|
{
|
|
codreg = caus.get("REG");
|
|
tpd = caus.get("TIPODOC");
|
|
tpm = caus.get_int("TIPOMOV");
|
|
m770 = caus.get_int("M770");
|
|
}
|
|
else
|
|
{
|
|
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);
|
|
}
|
|
|
|
if (fromHandler)
|
|
tpr = m.get_int(F_TIPO_REG);
|
|
else
|
|
{
|
|
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
|
|
compilaarray(tpd,tpm,tpr,m770);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CG0500_application::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 CG0500_application::write(const TMask& m)
|
|
{
|
|
return re_write(m, FALSE);
|
|
}
|
|
|
|
int CG0500_application::rewrite(const TMask& m)
|
|
{
|
|
return re_write(m, TRUE);
|
|
}
|
|
|
|
int CG0500_application::re_write(const TMask& m,bool rewrite)
|
|
{
|
|
const TString16 cau(m.get(F_COD_CAUS));
|
|
TString80 desc;
|
|
TString16 coddesc;
|
|
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;
|
|
|
|
desc = riga.get(0);
|
|
const char tipo_cf = riga.get_char();
|
|
const int g = riga.get_int();
|
|
const int c = riga.get_int();
|
|
long s = riga.get_long();
|
|
char sezione = riga.get_char();
|
|
desc = riga.get();
|
|
coddesc = riga.get();
|
|
|
|
// NB spostato TIPOCF da terzultimo a secondo
|
|
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]) // bitarray delle righe lette da file all'inizio
|
|
{
|
|
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 _rel->rewrite();
|
|
}
|
|
else
|
|
return _rel->write();
|
|
}
|
|
|
|
|
|
/*
|
|
int CG0500_application::cancella(long items)
|
|
{
|
|
TLocalisamfile * rcaus = _rel->lfile(LF_RCAUSALI);
|
|
const TString codcaus = _rel->lfile()->get(RCA_CODCAUS);
|
|
for (int i = 1; i <= items; i++)
|
|
{
|
|
rcaus->zero();
|
|
rcaus->put(RCA_CODCAUS, codcaus);
|
|
rcaus->put(RCA_NRIGA, i);
|
|
if (rcaus->read(_isequal, _lock) == NOERR)
|
|
rcaus->remove();
|
|
}
|
|
return rcaus->status();
|
|
}
|
|
*/
|
|
|
|
|
|
bool CG0500_application::remove()
|
|
{
|
|
const bool ok = TRelation_application::remove();
|
|
if (ok)
|
|
{
|
|
const TString cod(_rel->lfile()->get(RCA_CODCAUS));
|
|
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 CG0500_application::init_query_mode(TMask& m)
|
|
{
|
|
_righe_rcaus.destroy();
|
|
ss().reset();
|
|
init_mask(m);
|
|
}
|
|
|
|
void CG0500_application::init_insert_mode(TMask& m)
|
|
{
|
|
ss().reset();
|
|
init_mask(m);
|
|
}
|
|
|
|
void CG0500_application::init_modify_mode(TMask& m)
|
|
{
|
|
init_mask(m);
|
|
}
|
|
|
|
void CG0500_application::init_mask(TMask& m)
|
|
{
|
|
const TString tpd(m.get(F_TIPO_DOC));
|
|
const TString tpm(m.get(F_TIPO_MOV));
|
|
|
|
// F_TIPO_MOV e', nella maschera, un campo nascosto.
|
|
// Sono visibili nella maschera F_TIPO_MOV_1 oppure F_TIPO_MOV2,
|
|
// a seconda che F_TIPO_DOC sia compilato oppure no.
|
|
// All'inizio viene fatto l'output del campo TIPOMOV del file nel campo
|
|
// nascosto F_TIPO_MOV.
|
|
// Qui il contenuto di F_TIPO_MOV viene mandato a F_TIPO_MOV_1
|
|
// oppure F_TIPO_MOV_2.
|
|
if (tpd.empty() || tpd == "IN" || tpd == "AN" || tpd == "PG")
|
|
{
|
|
m.hide(F_TIPO_MOV_1);
|
|
m.set(F_TIPO_MOV_2, tpm);
|
|
m.show(F_TIPO_MOV_2);
|
|
}
|
|
else
|
|
{
|
|
m.hide(F_TIPO_MOV_2);
|
|
m.set(F_TIPO_MOV_1, tpm);
|
|
m.show(F_TIPO_MOV_1);
|
|
}
|
|
// 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);
|
|
|
|
// Setto il tipo reg e il flag corrisp nei campi nascosti della maschera
|
|
// perche non mi fa l'output su di essi quando carica i dati dal file
|
|
/*
|
|
TRegistro reg(codreg, anno);
|
|
const int tipo = reg.tipo();
|
|
m.set(F_TIPO_REG, tipo);
|
|
m.set(F_CORRISP, reg.corrisp());
|
|
*/
|
|
}
|
|
|
|
|
|
bool CG0500_application::user_create()
|
|
{
|
|
_rel = new TRelation (LF_CAUSALI);
|
|
_rel->add(LF_RCAUSALI, "CODCAUS=CODCAUS");
|
|
|
|
_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);
|
|
_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);
|
|
|
|
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(105, sottoconto_hndl);
|
|
cs.sheet_mask().set_handler(205, sottoconto_hndl);
|
|
cs.sheet_mask().set_handler(305, sottoconto_hndl);
|
|
cs.sheet_mask().set_handler(104, conto_hndl);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool CG0500_application::user_destroy()
|
|
{
|
|
delete _msk;
|
|
delete _rel;
|
|
return TRUE;
|
|
}
|
|
|
|
int cg0500(int argc, char* argv[])
|
|
{
|
|
CG0500_application a;
|
|
a.run(argc, argv, "Tabella causali");
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|