1492 lines
39 KiB
C++
Executable File
1492 lines
39 KiB
C++
Executable File
// Variazione movimenti di prima nota e movimenti iva
|
|
|
|
#include <mask.h>
|
|
#include <relation.h>
|
|
#include <tabutil.h>
|
|
#include <utility.h>
|
|
#include <config.h>
|
|
#include <mailbox.h>
|
|
#include <prefix.h>
|
|
|
|
#include <nditte.h>
|
|
#include <mov.h>
|
|
#include <rmov.h>
|
|
#include <rmoviva.h>
|
|
|
|
#include "cglib04.h"
|
|
#include "cglib.h"
|
|
#include "cg2103.h"
|
|
#include "conto.h"
|
|
|
|
#include "cg2800.h"
|
|
#include "cg2801.h"
|
|
#include "cg2802.h"
|
|
#include "cg2803.h"
|
|
|
|
HIDDEN TString80 TEMP;
|
|
|
|
//HIDDEN int date2esc(const TDate& d, int* prevesc = NULL);
|
|
|
|
class TVar_mov : public TApplication
|
|
{
|
|
TIsamtempfile* _tmov,* _trmov,* _tiva;
|
|
TLocalisamfile* _pcon,* _clifo, *_mov, *_rmov, *_rmoviva;
|
|
TTable* _tab_reg;
|
|
TRectype* _rec_mov,* _rec_rmov,* _rec_riva;
|
|
TTransfer_file _tras_file;
|
|
char _scelta;
|
|
|
|
TString _trasf,_std,_descr_civa;
|
|
long _dittaric,_numreg;
|
|
TString _control_rec,_record;
|
|
bool _righe,_corrisp;
|
|
int _numrig,_tiporeg;
|
|
|
|
public:
|
|
TString _titolo;
|
|
|
|
virtual bool create();
|
|
virtual bool destroy();
|
|
virtual bool menu(MENU_TAG m);
|
|
bool main_loop();
|
|
bool esegui_controlli();
|
|
bool leggi_trasfer();
|
|
bool controlli();
|
|
void leggi_record_controllo();
|
|
bool video_PN();
|
|
bool video_IVA();
|
|
void registra_PN(TMask& m);
|
|
void registra_IVA(TMask& m);
|
|
bool esiste_testata_mov(TMask& m);
|
|
bool ricerca_movimento(TMask& m);
|
|
|
|
bool esiste_riga_mov(TMask& m);
|
|
bool esiste_riga_iva(TMask& m);
|
|
|
|
void ricerca_codcaus(const TString& codcaus);
|
|
void setta_campi_maschera(TMask& m);
|
|
bool setta_campi_maschera_iva(TMask& m);
|
|
|
|
void registra_file_temp_mov(long,const TDate&,const TDate&,const TString&,TString&,long,long,const TString&,TString&);
|
|
void registra_file_trasfer_t(long,int,const TDate&,const TDate&,const TString&,TString&,long,long,const TString&,const TString&);
|
|
void registra_file_temp_rmov(long,int,int,int,long,char,const TString&,int,int,long,const real&);
|
|
void registra_file_trasfer_r(long,int,int,int,long,char,const TString&,int,int,long,const real&);
|
|
void registra_file_trasfer_t_iva(long,const TDate&,long,const TString&,const TString&,const TString&,const TString&,const TString&);
|
|
void registra_file_temp_riva(long,int,const real&,const TString&,const real&,int,int,int,int,long);
|
|
void registra_file_trasfer_r_iva(long,int,const real&,const TString&,const real&,int,int,int,int,long);
|
|
|
|
void setta_parametri_record(const TString& sigla,const TString& flag);
|
|
|
|
const char* converti (TString& data_AS400);
|
|
const char* riconverti(TString& data_PC);
|
|
|
|
static bool codice_registro_hnd (TMask_field& f, KEY k);
|
|
static bool codice_causale_hnd (TMask_field& f, KEY k);
|
|
static bool numero_protocollo_hnd (TMask_field& f, KEY k);
|
|
static bool ultimo_protocollo_hnd (TMask_field& f, KEY k);
|
|
static bool codice_pagamento_hnd (TMask_field& f, KEY k);
|
|
static bool data_stampa (TMask_field& f, KEY k);
|
|
|
|
static bool controllo_partita (TMask_field& f, KEY k);
|
|
static bool controllo_contropartita (TMask_field& f, KEY k);
|
|
static bool controllo_importo (TMask_field& f, KEY k);
|
|
|
|
static bool codice_clifo_hnd (TMask_field& f, KEY k);
|
|
static bool codice_iva_hnd (TMask_field& f, KEY k);
|
|
static bool imposta_hnd (TMask_field& f, KEY k);
|
|
static bool detraibilita_hnd (TMask_field& f, KEY k);
|
|
static bool tipocr_hnd (TMask_field& f, KEY k);
|
|
|
|
bool decodifica_codiva(const TString& codiva);
|
|
|
|
TVar_mov(char mov);
|
|
};
|
|
|
|
HIDDEN TVar_mov& app() { return (TVar_mov &) main_app(); }
|
|
|
|
HIDDEN int date2esc(const TDate& d, int* prevesc)
|
|
{
|
|
if (prevesc) *prevesc = 0;
|
|
TTable esc("ESC");
|
|
for (int err = esc.first(); err == NOERR; err = esc.next())
|
|
{
|
|
const TDate ia(esc.get("D0")); // Data inizio esercizio
|
|
const TDate fa(esc.get("D1")); // Data fine esercizio
|
|
const anno = esc.get_int("CODTAB");
|
|
if (d >= ia && d <= fa)
|
|
return anno;
|
|
if (prevesc) *prevesc = anno;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
TVar_mov::TVar_mov(char mov) : _scelta(toupper(mov))
|
|
{
|
|
switch (_scelta)
|
|
{
|
|
case 'P':
|
|
_titolo = "Variazione movimenti prima nota";
|
|
break;
|
|
|
|
case 'I':
|
|
_titolo = "Variazione movimenti iva";
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool TVar_mov::create()
|
|
{
|
|
TApplication::create();
|
|
|
|
_pcon = new TLocalisamfile (LF_PCON);
|
|
_clifo = new TLocalisamfile (LF_CLIFO);
|
|
_rec_mov = new TRectype (LF_MOV);
|
|
_mov = new TLocalisamfile (LF_MOV);
|
|
_rmov = new TLocalisamfile (LF_RMOV);
|
|
_rmoviva = new TLocalisamfile (LF_RMOVIVA);
|
|
_tab_reg = new TTable ("REG");
|
|
|
|
if (_scelta == 'P')
|
|
{
|
|
TString80 tmpmov = "%";
|
|
tmpmov << get_firm_dir();
|
|
tmpmov << "\\" << TEMP_MOV;
|
|
TString80 tmprmov = "%";
|
|
tmprmov << get_firm_dir();
|
|
tmprmov << "\\" << TEMP_RMOV;
|
|
|
|
_tmov = new TIsamtempfile(LF_MOV, tmpmov, 0);
|
|
_trmov = new TIsamtempfile(LF_RMOV, tmprmov, 0);
|
|
_rec_rmov = new TRectype (LF_RMOV);
|
|
}
|
|
else
|
|
if (_scelta == 'I')
|
|
{
|
|
TString80 tmpmov = "%";
|
|
tmpmov << get_firm_dir();
|
|
tmpmov << "\\" << TEMP_MOV;
|
|
TString80 tmprmoviva = "%";
|
|
tmprmoviva << get_firm_dir();
|
|
tmprmoviva << "\\" << TEMP_RMOVIVA;
|
|
|
|
_tmov = new TIsamtempfile(LF_MOV, tmpmov, 0);
|
|
_tiva = new TIsamtempfile(LF_RMOVIVA, tmprmoviva, 0);
|
|
_rec_riva = new TRectype (LF_RMOVIVA);
|
|
}
|
|
|
|
dispatch_e_menu (BAR_ITEM(1));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::destroy()
|
|
{
|
|
delete _rec_mov;
|
|
delete _pcon;
|
|
delete _clifo;
|
|
delete _mov;
|
|
delete _rmov;
|
|
delete _rmoviva;
|
|
delete _tab_reg;
|
|
|
|
if (_scelta == 'P')
|
|
{
|
|
delete _trmov;
|
|
delete _rec_rmov;
|
|
}
|
|
else
|
|
if (_scelta == 'I')
|
|
{
|
|
delete _tiva;
|
|
delete _rec_riva;
|
|
}
|
|
|
|
delete _tmov;
|
|
|
|
return TApplication::destroy();
|
|
}
|
|
|
|
void TVar_mov::leggi_record_controllo()
|
|
{
|
|
_tras_file.read_control_rec();
|
|
_control_rec = _tras_file.record();
|
|
}
|
|
|
|
const char* TVar_mov::converti (TString& data_AS400)
|
|
{
|
|
TEMP = data_AS400.mid(4,2);
|
|
TEMP << "-" <<data_AS400.mid(2,2);
|
|
TEMP << "-" <<data_AS400.mid(0,2);
|
|
return TEMP;
|
|
}
|
|
|
|
const char* TVar_mov::riconverti (TString& data_PC)
|
|
{
|
|
TEMP = data_PC.mid(8,2);
|
|
TEMP << data_PC.mid(3,2);
|
|
TEMP << data_PC.mid(0,2);
|
|
return TEMP;
|
|
}
|
|
|
|
bool TVar_mov::main_loop()
|
|
{
|
|
_dittaric = get_firm();
|
|
|
|
if (!esegui_controlli()) return FALSE;
|
|
|
|
if (_scelta == 'P')
|
|
{
|
|
if (!video_PN())
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (_scelta == 'I')
|
|
if (!video_IVA())
|
|
return FALSE;
|
|
}
|
|
|
|
setta_parametri_record(" ","C");
|
|
leggi_record_controllo();
|
|
TString str (_control_rec.overwrite(" ",241));
|
|
_tras_file.write_control_rec(str,256);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
bool TVar_mov::video_PN()
|
|
{
|
|
TMask msk ("cg2800a");
|
|
KEY tasto;
|
|
|
|
do
|
|
{
|
|
tasto = msk.run();
|
|
|
|
if (tasto != K_ENTER) return FALSE;
|
|
|
|
if (ricerca_movimento(msk))
|
|
{
|
|
TMask mask ("cg2800b");
|
|
|
|
mask.set_handler(F_REGIVA, codice_registro_hnd);
|
|
mask.set_handler(F_CODCAUS, codice_causale_hnd);
|
|
mask.set_handler(F_PROTIVA, numero_protocollo_hnd);
|
|
mask.set_handler(F_NUPROTIVA, ultimo_protocollo_hnd);
|
|
mask.set_handler(F_CODPAG, codice_pagamento_hnd);
|
|
mask.set_handler(F_DATAREG, data_stampa);
|
|
|
|
if (_righe)
|
|
{
|
|
mask.set_handler(F_SOTTOCONTO, controllo_partita);
|
|
mask.set_handler(F_SOTTOC, controllo_contropartita);
|
|
mask.set_handler(F_IMPORTO , controllo_importo);
|
|
}
|
|
|
|
setta_campi_maschera(mask);
|
|
|
|
tasto = mask.run();
|
|
|
|
switch (tasto)
|
|
{
|
|
case K_ESC :
|
|
break;
|
|
|
|
case K_QUIT :
|
|
break;
|
|
|
|
case K_SAVE :
|
|
{
|
|
registra_PN(mask);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
while (tasto != K_QUIT); //K_ENTER
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void TVar_mov::ricerca_codcaus(const TString& codcaus)
|
|
{
|
|
TLocalisamfile cau (LF_CAUSALI);
|
|
TString tipodoc;
|
|
|
|
cau.setkey(1);
|
|
cau.zero();
|
|
cau.put("CODCAUS", (const char*) codcaus);
|
|
if (cau.read() == NOERR)
|
|
tipodoc = cau.get_char("TIPODOC");
|
|
|
|
TTable tpd ("%TPD");
|
|
|
|
tpd.zero();
|
|
tpd.put("CODTAB", (const char*) tipodoc);
|
|
if (tpd.read() == NOERR)
|
|
_corrisp = tpd.get_bool("B0");
|
|
}
|
|
|
|
bool TVar_mov::video_IVA()
|
|
{
|
|
TMask msk ("cg2800a");
|
|
KEY tasto;
|
|
|
|
do
|
|
{
|
|
tasto = msk.run();
|
|
|
|
if (tasto != K_ENTER) return FALSE;
|
|
|
|
if (ricerca_movimento(msk))
|
|
{
|
|
TMask mask ("cg2800c");
|
|
|
|
TString regiva = _rec_mov->get (MOV_REG);
|
|
|
|
if (!setta_campi_maschera_iva(mask))
|
|
return FALSE;
|
|
|
|
mask.set_handler(F_CODCF, codice_clifo_hnd);
|
|
|
|
if (_righe)
|
|
{
|
|
mask.set_handler(F_SOTTOCONTO, controllo_partita);
|
|
mask.set_handler(F_CODIVA, codice_iva_hnd);
|
|
mask.set_handler(F_IMPOSTA, imposta_hnd);
|
|
mask.set_handler(F_TIPODET, detraibilita_hnd);
|
|
mask.set_handler(F_TIPOCR, tipocr_hnd);
|
|
}
|
|
|
|
tasto = mask.run();
|
|
|
|
switch (tasto)
|
|
{
|
|
case K_ESC :
|
|
break;
|
|
|
|
case K_QUIT :
|
|
break;
|
|
|
|
case K_SAVE :
|
|
{
|
|
registra_IVA(mask);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
while (tasto != K_QUIT); //K_ENTER
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::ricerca_movimento(TMask& m)
|
|
{
|
|
_numrig = atoi(m.get(F_NUMRIG));
|
|
|
|
if (_numrig == 0)
|
|
{
|
|
_righe = FALSE;
|
|
return esiste_testata_mov(m);
|
|
}
|
|
else
|
|
{
|
|
_righe = TRUE;
|
|
esiste_testata_mov(m);
|
|
if (_scelta == 'P')
|
|
return esiste_riga_mov(m);
|
|
else
|
|
return esiste_riga_iva(m);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::esiste_testata_mov(TMask& m)
|
|
{
|
|
long nprog;
|
|
|
|
_numreg = m.get_long(F_NUMREG);
|
|
|
|
_tmov->setkey(1);
|
|
_tmov->zero();
|
|
_tmov->put(MOV_NUMREG, _numreg);
|
|
|
|
if (_tmov->read() == NOERR)
|
|
{
|
|
if (_scelta == 'P')
|
|
{
|
|
nprog = _tmov->get_long(MOV_NUMGIO);
|
|
nprog += _tras_file.start('Z');
|
|
}
|
|
else
|
|
if (_scelta == 'I')
|
|
{
|
|
_tiva->setkey(1);
|
|
_tiva->zero();
|
|
_tiva->put(RMI_NUMREG, _numreg);
|
|
_tiva->read();
|
|
long nr = _tiva->get_long(RMI_NUMREG);
|
|
if (_numreg != nr)
|
|
return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
|
|
|
|
nprog = _tmov->get_long(MOV_ANNOIVA);
|
|
nprog += _tras_file.start('U');
|
|
}
|
|
|
|
_tras_file.read_rec_trasfer(nprog);
|
|
_record = _tras_file.read_rec();
|
|
|
|
char annullato = _record.sub(248,249)[0];
|
|
|
|
if (annullato == 'A')
|
|
return error_box("Registrazione presente ma ANNULLATA: impossibile variarla");
|
|
|
|
*_rec_mov = _tmov->curr();
|
|
}
|
|
else
|
|
return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::esiste_riga_mov(TMask& m)
|
|
{
|
|
_numreg = m.get_long(F_NUMREG);
|
|
_numrig = m.get_int (F_NUMRIG);
|
|
|
|
_trmov->setkey(1);
|
|
_trmov->zero();
|
|
_trmov->put(RMV_NUMREG, _numreg);
|
|
_trmov->put(RMV_NUMRIG, _numrig);
|
|
|
|
if (_trmov->read() == NOERR)
|
|
{
|
|
long nprog = _trmov->get_long(RMV_ANNOES);
|
|
nprog += _tras_file.start('Z');
|
|
|
|
_tras_file.read_rec_trasfer(nprog);
|
|
_record = _tras_file.read_rec();
|
|
|
|
char annullato = _record.sub(248,249)[0];
|
|
|
|
if (annullato == 'A')
|
|
return error_box("Registrazione presente ma ANNULLATA: impossibile variarla");
|
|
|
|
*_rec_rmov = _trmov->curr();
|
|
}
|
|
else
|
|
return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::esiste_riga_iva(TMask& m)
|
|
{
|
|
_numreg = m.get_long(F_NUMREG);
|
|
_numrig = m.get_int (F_NUMRIG);
|
|
|
|
_tiva->setkey(1);
|
|
_tiva->zero();
|
|
_tiva->put(RMI_NUMREG, _numreg);
|
|
_tiva->put(RMI_NUMRIG, _numrig);
|
|
|
|
if (_tiva->read() == NOERR)
|
|
{
|
|
long nprog = _tiva->get_long(RMI_ANNOES);
|
|
nprog += _tras_file.start('U');
|
|
|
|
_tras_file.read_rec_trasfer(nprog);
|
|
_record = _tras_file.read_rec();
|
|
|
|
char annullato = _record.sub(248,249)[0];
|
|
|
|
if (annullato == 'A')
|
|
return error_box("Registrazione presente ma ANNULLATA: impossibile variarla");
|
|
|
|
*_rec_riva = _tiva->curr();
|
|
}
|
|
else
|
|
return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void TVar_mov::setta_campi_maschera(TMask& m)
|
|
{
|
|
int annorif = atoi(_record.sub(21,22));
|
|
TDate datareg (_rec_mov->get_date(MOV_DATAREG));
|
|
TDate datadoc (_rec_mov->get_date(MOV_DATADOC));
|
|
TString numdoc = _rec_mov->get (MOV_NUMDOC);
|
|
TString regiva = _rec_mov->get (MOV_REG);
|
|
regiva.trim();
|
|
long protiva = _rec_mov->get_long(MOV_PROTIVA);
|
|
long nuprotiva = _rec_mov->get_long(MOV_UPROTIVA);
|
|
TString codcaus = _rec_mov->get (MOV_CODCAUS);
|
|
TString codpag = _rec_mov->get (MOV_CODPAG);
|
|
codpag.trim();
|
|
|
|
m.set(F_NUMREG, _numreg);
|
|
m.set(F_NUMRIG, _numrig);
|
|
m.set(F_DATAREG, datareg.string());
|
|
m.set(F_ANNO, annorif);
|
|
m.set(F_DATADOC, datadoc.string());
|
|
m.set(F_NUMDOC, numdoc);
|
|
m.set(F_REGIVA, regiva);
|
|
m.set(F_PROTIVA, protiva);
|
|
m.set(F_NUPROTIVA, nuprotiva);
|
|
m.set(F_CODCAUS, codcaus);
|
|
m.set(F_CODPAG, codpag);
|
|
|
|
m.disable(F_NUMREG);
|
|
m.disable(F_NUMRIG);
|
|
|
|
if (!_righe)
|
|
{
|
|
m.enable(F_DATAREG);
|
|
m.enable(F_ANNO);
|
|
m.enable(F_DATADOC);
|
|
m.enable(F_NUMDOC);
|
|
m.enable(F_REGIVA);
|
|
m.enable(F_PROTIVA);
|
|
m.enable(F_NUPROTIVA);
|
|
m.enable(F_CODCAUS);
|
|
m.enable(F_CODPAG);
|
|
m.disable(F_GRUPPO);
|
|
m.disable(F_CONTO);
|
|
m.disable(F_SOTTOCONTO);
|
|
m.disable(F_SEZIONE);
|
|
m.disable(F_IMPORTO);
|
|
m.disable(F_DESCR);
|
|
m.disable(F_GRUPPOC);
|
|
m.disable(F_CONTOC);
|
|
m.disable(F_SOTTOC);
|
|
}
|
|
else
|
|
if (_righe)
|
|
{
|
|
int gruppo = _trmov->get_int (RMV_GRUPPO);
|
|
int conto = _trmov->get_int (RMV_CONTO);
|
|
long sottocon = _trmov->get_long(RMV_SOTTOCONTO);
|
|
TString sezione = _trmov->get (RMV_SEZIONE);
|
|
TString descr = _trmov->get (RMV_DESCR);
|
|
int gruppoc = _trmov->get_int (RMV_GRUPPOC);
|
|
int contoc = _trmov->get_int (RMV_CONTOC);
|
|
long sottoc = _trmov->get_long(RMV_SOTTOCONTOC);
|
|
real importo = _trmov->get_real(RMV_IMPORTO);
|
|
|
|
m.set(F_GRUPPO, gruppo);
|
|
m.set(F_CONTO, conto);
|
|
m.set(F_SOTTOCONTO, sottocon);
|
|
m.set(F_SEZIONE, sezione);
|
|
m.set(F_DESCR, descr);
|
|
m.set(F_GRUPPOC, gruppoc);
|
|
m.set(F_CONTOC, contoc);
|
|
m.set(F_SOTTOC, sottoc);
|
|
m.set(F_IMPORTO, importo.string());
|
|
|
|
m.disable(F_DATAREG);
|
|
m.disable(F_ANNO);
|
|
m.disable(F_DATADOC);
|
|
m.disable(F_NUMDOC);
|
|
m.disable(F_REGIVA);
|
|
m.disable(F_PROTIVA);
|
|
m.disable(F_NUPROTIVA);
|
|
m.disable(F_CODCAUS);
|
|
m.disable(F_CODPAG);
|
|
|
|
m.enable(F_GRUPPO);
|
|
m.enable(F_CONTO);
|
|
m.enable(F_SOTTOCONTO);
|
|
m.enable(F_SEZIONE);
|
|
m.enable(F_IMPORTO);
|
|
m.enable(F_DESCR);
|
|
m.enable(F_GRUPPOC);
|
|
m.enable(F_CONTOC);
|
|
m.enable(F_SOTTOC);
|
|
}
|
|
}
|
|
|
|
bool TVar_mov::setta_campi_maschera_iva(TMask& m)
|
|
{
|
|
TDate datareg (_rec_mov->get_date(MOV_DATAREG));
|
|
TDate data74ter (_rec_mov->get_date(MOV_DATA74TER));
|
|
TString regiva = _rec_mov->get (MOV_REG);
|
|
regiva.trim();
|
|
TString codcaus = _rec_mov->get (MOV_CODCAUS);
|
|
long codcf = _rec_mov->get_long(MOV_CODCF);
|
|
|
|
TString ragsoc = _record.sub(61,86);
|
|
TString ind = _record.sub(86,108);
|
|
TString localita = _record.sub(108,126);
|
|
TString cap = _record.sub(126,131);
|
|
TString prov = _record.sub(131,133);
|
|
|
|
if (codcaus.not_empty())
|
|
ricerca_codcaus(codcaus);
|
|
|
|
int anno = date2esc(datareg);
|
|
|
|
char cr = regiva[0];
|
|
TString codreg;
|
|
|
|
if (isdigit(cr))
|
|
codreg.format("%03c", cr);
|
|
else
|
|
codreg.format("%-3c", cr);
|
|
|
|
TRegistro rg (codreg, anno);
|
|
_tiporeg = rg.tipo();
|
|
|
|
if (regiva.not_empty())
|
|
{
|
|
if (!rg.ok())
|
|
return error_box("Registrazione presente ma con PRIMANOTA ERRATA: correggerla prima");
|
|
}
|
|
else
|
|
return error_box("Campo NON VALIDO o codice NON PRESENTE in archivio");
|
|
|
|
m.set(F_NUMREG, _numreg);
|
|
m.set(F_NUMRIG, _numrig);
|
|
m.set(F_DATA74TER, data74ter.string());
|
|
m.set(F_CODCF, codcf);
|
|
m.set(F_RAGSOCOCC, ragsoc);
|
|
m.set(F_INDOCC, ind);
|
|
m.set(F_LOCALITA, localita);
|
|
m.set(F_CAPOCC, cap);
|
|
m.set(F_PROVOCC, prov);
|
|
|
|
m.disable(F_NUMREG);
|
|
m.disable(F_NUMRIG);
|
|
|
|
if (!_righe)
|
|
{
|
|
m.enable(F_DATA74TER);
|
|
m.enable(F_CODCF);
|
|
m.enable(F_RAGSOCOCC);
|
|
m.enable(F_INDOCC);
|
|
m.enable(F_LOCALITA);
|
|
m.enable(F_CAPOCC);
|
|
m.enable(F_PROVOCC);
|
|
m.disable(F_IMPONIBILE);
|
|
m.disable(F_CODIVA);
|
|
m.disable(F_IMPOSTA);
|
|
m.disable(F_TIPODET);
|
|
m.disable(F_TIPOCR);
|
|
m.disable(F_GRUPPO);
|
|
m.disable(F_CONTO);
|
|
m.disable(F_SOTTOCONTO);
|
|
}
|
|
else
|
|
if (_righe)
|
|
{
|
|
real imponibile (_tiva->get_real(RMI_IMPONIBILE));
|
|
TString codiva (_tiva->get (RMI_CODIVA));
|
|
real imposta (_tiva->get_real(RMI_IMPOSTA));
|
|
int tipodet = _tiva->get_int (RMI_TIPODET);
|
|
int tipocr = _tiva->get_int (RMI_TIPOCR);
|
|
int gruppo = _tiva->get_int (RMI_GRUPPO);
|
|
int conto = _tiva->get_int (RMI_CONTO);
|
|
long sottoc = _tiva->get_long(RMI_SOTTOCONTO);
|
|
|
|
m.set(F_IMPONIBILE, imponibile.string());
|
|
m.set(F_CODIVA, codiva);
|
|
m.set(F_IMPOSTA, imposta.string());
|
|
m.set(F_TIPODET, tipodet);
|
|
m.set(F_TIPOCR, tipocr);
|
|
m.set(F_GRUPPO, gruppo);
|
|
m.set(F_CONTO, conto);
|
|
m.set(F_SOTTOCONTO, sottoc);
|
|
|
|
m.disable(F_DATA74TER);
|
|
m.disable(F_CODCF);
|
|
m.disable(F_RAGSOCOCC);
|
|
m.disable(F_INDOCC);
|
|
m.disable(F_LOCALITA);
|
|
m.disable(F_CAPOCC);
|
|
m.disable(F_PROVOCC);
|
|
|
|
m.enable(F_IMPONIBILE);
|
|
m.enable(F_CODIVA);
|
|
m.enable(F_IMPOSTA);
|
|
m.enable(F_TIPODET);
|
|
m.enable(F_TIPOCR);
|
|
m.enable(F_GRUPPO);
|
|
m.enable(F_CONTO);
|
|
m.enable(F_SOTTOCONTO);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::codice_registro_hnd(TMask_field& f, KEY k)
|
|
{
|
|
TTable reg ("REG");
|
|
TString descr,dep;
|
|
|
|
if (k == K_TAB || k == K_ENTER)
|
|
{
|
|
TString codreg = f.get();
|
|
char cr = codreg[0];
|
|
TDate datareg (f.mask().get(F_DATAREG));
|
|
int anno = date2esc(datareg);
|
|
|
|
if (isdigit(cr))
|
|
dep.format("%04d%03c", anno, cr);
|
|
else
|
|
dep.format("%04d%-3c", anno, cr);
|
|
|
|
reg.zero();
|
|
reg.put("CODTAB", dep);
|
|
if (reg.read() == NOERR)
|
|
{
|
|
descr = reg.get("S0");
|
|
f.mask().set(F_DESCRREG, descr);
|
|
}
|
|
else
|
|
if (codreg.not_empty() && f.mask().is_running())
|
|
return warning_box("Codice registro IVA non presente in tabella");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::codice_causale_hnd(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_TAB || k == K_ENTER)
|
|
{
|
|
TString codcau = f.get();
|
|
|
|
if (f.mask().is_running())
|
|
{
|
|
TString codreg = f.mask().get(F_REGIVA);
|
|
|
|
if (codreg.not_empty())
|
|
if (codcau.empty())
|
|
return warning_box("Il codice registro IVA e' significativo: deve essere significativo anche il codice causale");
|
|
}
|
|
|
|
TLocalisamfile cau (LF_CAUSALI);
|
|
cau.setkey(1);
|
|
cau.zero();
|
|
cau.put("CODCAUS", codcau);
|
|
if (cau.read() == NOERR)
|
|
{
|
|
const TString& descr = cau.get("DESCR");
|
|
f.mask().set(F_DESCRCAU, descr);
|
|
}
|
|
else
|
|
if (f.mask().is_running())
|
|
return warning_box("Codice causale non presente in tabella");
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::numero_protocollo_hnd(TMask_field& f, KEY k)
|
|
{
|
|
if (k != K_ENTER) return FALSE;
|
|
|
|
TString codreg = f.mask().get(F_REGIVA);
|
|
long protiva = atol(f.mask().get(F_PROTIVA));
|
|
long uprotiva = atol(f.mask().get(F_NUPROTIVA));
|
|
|
|
if (codreg.empty())
|
|
if (protiva != 0)
|
|
return warning_box("Il codice registro IVA non e' significativo: non e' possibile compilare il numero protocollo IVA");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::ultimo_protocollo_hnd(TMask_field& f, KEY k)
|
|
{
|
|
if (k != K_ENTER) return FALSE;
|
|
|
|
TString codreg = f.mask().get(F_REGIVA);
|
|
long protiva = atol(f.mask().get(F_PROTIVA));
|
|
long uprotiva = atol(f.mask().get(F_NUPROTIVA));
|
|
|
|
if (codreg.empty())
|
|
if (uprotiva != 0)
|
|
return warning_box("Il codice registro IVA non e' significativo: non e' possibile compilare l' ultimo numero protocollo IVA");
|
|
|
|
if (protiva == 0)
|
|
if (uprotiva != 0)
|
|
return warning_box("Numero protocollo IVA non significativo: non e' possibile compilare il numero protocollo IVA riepilogato");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::codice_pagamento_hnd(TMask_field& f, KEY k)
|
|
{
|
|
TTable pag ("%CPG");
|
|
TString descr,codpag,dep;
|
|
|
|
if (k == K_TAB || k == K_ENTER)
|
|
{
|
|
codpag = f.get();
|
|
dep.format("%04s", (const char*)codpag);
|
|
|
|
pag.zero();
|
|
pag.put("CODTAB", dep);
|
|
if (pag.read() == NOERR)
|
|
{
|
|
descr = pag.get("S0");
|
|
f.mask().set(F_DESCRPAG, descr);
|
|
}
|
|
else
|
|
if (codpag.not_empty() && k == K_ENTER)
|
|
return warning_box("Codice pagamento non presente in tabella");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::data_stampa(TMask_field& f, KEY k)
|
|
{
|
|
if (k != K_ENTER) return FALSE;
|
|
|
|
TDate datareg (f.mask().get(F_DATAREG));
|
|
const int ae = date2esc(datareg);
|
|
|
|
TLibro_giornale gio;
|
|
gio.read(ae); //se _ae e' zero la read considera come anno quello corrente
|
|
|
|
if (datareg < gio.last_print())
|
|
return warning_box("La data di registrazione e' minore della data di stampa del Libro Giornale");
|
|
|
|
TString codreg = f.mask().get(F_REGIVA);
|
|
|
|
if (!codreg.blank()) //movimento iva (fattura)
|
|
{
|
|
TRegistro rg (codreg, ae);
|
|
|
|
if (datareg < rg.last_print())
|
|
return error_box("La data di registrazione e' minore della data stampa del registro IVA");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::controllo_partita(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_TAB || k == K_ENTER)
|
|
{
|
|
int gruppo = f.mask().get_int (F_GRUPPO);
|
|
int conto = f.mask().get_int (F_CONTO);
|
|
long sottoc = f.mask().get_long(F_SOTTOCONTO);
|
|
|
|
TConto tc (gruppo,conto,sottoc);
|
|
|
|
TString descr = tc.descrizione();
|
|
f.mask().set(F_DESCRPARTITA, descr);
|
|
|
|
if (k == K_ENTER)
|
|
if (!tc.find())
|
|
return warning_box("Sottoconto partita non presente in anagrafica Piano dei Conti oppure anagrafica Clienti / Fornitori");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::controllo_contropartita(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_TAB || k == K_ENTER)
|
|
{
|
|
int gruppo = f.mask().get_int (F_GRUPPOC);
|
|
int conto = f.mask().get_int (F_CONTOC);
|
|
long sottoc = f.mask().get_long(F_SOTTOC);
|
|
|
|
TConto tc (gruppo,conto,sottoc);
|
|
|
|
TString descr = tc.descrizione();
|
|
f.mask().set(F_DESCRCPARTITA, descr);
|
|
|
|
if (k == K_ENTER)
|
|
if (gruppo != 0 && conto != 0 && sottoc != 0)
|
|
if (!tc.find())
|
|
return warning_box("Sottoconto contropartita non presente in anagrafica Piano dei Conti oppure anagrafica Clienti / Fornitori");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::controllo_importo(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_ENTER)
|
|
{
|
|
real importo (f.mask().get(F_IMPORTO));
|
|
char sezione = f.mask().get(F_SEZIONE)[0];
|
|
|
|
if (importo == ZERO && (sezione == 'A' || sezione == 'D') )
|
|
return warning_box("L' importo deve essere significativo");
|
|
if (sezione == '\0' && importo != ZERO)
|
|
return warning_box("La sezione e' nulla: l'importo non puo' essere significativo");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::codice_clifo_hnd(TMask_field& f, KEY k)
|
|
{
|
|
char tipo;
|
|
|
|
if (k == K_TAB || k == K_ENTER)
|
|
{
|
|
long codcf = atol(f.get());
|
|
if (app()._tiporeg == 1)
|
|
tipo = 'C';
|
|
else
|
|
if (app()._tiporeg == 2)
|
|
tipo = 'F';
|
|
|
|
TConto tc (0,0,codcf,tipo);
|
|
|
|
if (tc.find())
|
|
{
|
|
TString descr = tc.descrizione();
|
|
f.mask().set(F_RAGSOCCF, descr);
|
|
}
|
|
else
|
|
if (k == K_ENTER)
|
|
return warning_box("Campo NON VALIDO o codice non presente in archivio");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::codice_iva_hnd(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_TAB || k == K_ENTER)
|
|
{
|
|
TString codiva = f.get();
|
|
|
|
bool ok = app().decodifica_codiva(codiva);
|
|
|
|
f.mask().set(F_DESCRCODIVA, app()._descr_civa);
|
|
|
|
if (k == K_ENTER)
|
|
{
|
|
real imponibile (f.mask().get(F_IMPONIBILE));
|
|
real imposta (f.mask().get(F_IMPOSTA));
|
|
|
|
if ( (imponibile != ZERO || imposta != ZERO) && codiva.empty() )
|
|
return warning_box("Il codice IVA deve essere indicato obbligatoriamente");
|
|
|
|
if (codiva.not_empty())
|
|
if (!ok)
|
|
return warning_box("Codice non presente in tabella");
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::decodifica_codiva(const TString& codiva)
|
|
{
|
|
TTable iva ("%IVA");
|
|
TString dep;
|
|
|
|
dep.format("%-4s", (const char*)codiva);
|
|
|
|
iva.zero();
|
|
iva.put("CODTAB", dep);
|
|
if (iva.read() == NOERR)
|
|
{
|
|
_descr_civa = iva.get("S0");
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
_descr_civa = "";
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::imposta_hnd(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_ENTER)
|
|
{
|
|
real imposta (f.mask().get(F_IMPOSTA));
|
|
|
|
if (app()._corrisp && imposta != ZERO)
|
|
return warning_box("Il movimento e' relativo ad un corrispettivo: l'imposta deve essere uguale a 0");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::detraibilita_hnd(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_ENTER)
|
|
{
|
|
int det = atoi(f.get());
|
|
|
|
if (det != 0 && det != 1 && det != 3 && det != 9)
|
|
return warning_box("Valore non ammesso per il tipo detraibilita'");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::tipocr_hnd(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_ENTER)
|
|
{
|
|
int tcr = atoi(f.get());
|
|
|
|
if (tcr != 0 && tcr != 1 && tcr != 2 && tcr != 3
|
|
&& tcr != 4 && tcr != 5 && tcr != 8 && tcr != 9)
|
|
return warning_box("Valore non ammesso per il tipo costo/ricavo");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void TVar_mov::registra_PN(TMask& m)
|
|
{
|
|
if (!_righe)
|
|
{
|
|
long numreg = m.get_long(F_NUMREG);
|
|
int annorif = m.get_int (F_ANNO);
|
|
TDate datareg (m.get(F_DATAREG));
|
|
TDate datadoc (m.get(F_DATADOC));
|
|
TString numdoc = m.get (F_NUMDOC);
|
|
TString regiva = m.get (F_REGIVA);
|
|
long protiva = m.get_long(F_PROTIVA);
|
|
long nuprotiva = m.get_long(F_NUPROTIVA);
|
|
TString codcaus = m.get (F_CODCAUS);
|
|
TString codpag = m.get (F_CODPAG);
|
|
|
|
registra_file_temp_mov(numreg,datareg,datadoc,numdoc,regiva,protiva,nuprotiva,codcaus,codpag);
|
|
registra_file_trasfer_t(numreg,annorif,datareg,datadoc,numdoc,regiva,protiva,nuprotiva,codcaus,codpag);
|
|
}
|
|
else
|
|
if (_righe)
|
|
{
|
|
long numreg = m.get_long(F_NUMREG);
|
|
int numrig = m.get_int (F_NUMRIG);
|
|
int gruppo = m.get_int (F_GRUPPO);
|
|
int conto = m.get_int (F_CONTO);
|
|
long sottoc = m.get_long(F_SOTTOCONTO);
|
|
char sezione = m.get (F_SEZIONE)[0];
|
|
TString descr = m.get (F_DESCR);
|
|
int gruppoc = m.get_int (F_GRUPPOC);
|
|
int contoc = m.get_int (F_CONTOC);
|
|
long sottocc = m.get_long(F_SOTTOC);
|
|
real importo (m.get(F_IMPORTO));
|
|
|
|
registra_file_temp_rmov(numreg,numrig,gruppo,conto,sottoc,sezione,descr,gruppoc,contoc,sottocc,importo);
|
|
registra_file_trasfer_r(numreg,numrig,gruppo,conto,sottoc,sezione,descr,gruppoc,contoc,sottocc,importo);
|
|
}
|
|
}
|
|
|
|
void TVar_mov::registra_file_temp_mov(long nr,const TDate& dr,const TDate& dd,const TString& nd,TString& ri,
|
|
long pi,long upi,const TString& cc,TString& cp)
|
|
{
|
|
_tmov->setkey(1);
|
|
_tmov->zero();
|
|
_tmov->put(MOV_NUMREG, nr);
|
|
if (_tmov->read() == NOERR)
|
|
{
|
|
_tmov->put(MOV_DATAREG, dr);
|
|
_tmov->put(MOV_DATADOC, dd);
|
|
_tmov->put(MOV_NUMDOC, nd);
|
|
_tmov->put(MOV_REG, ri);
|
|
_tmov->put(MOV_PROTIVA, pi);
|
|
_tmov->put(MOV_UPROTIVA, upi);
|
|
_tmov->put(MOV_CODCAUS, cc);
|
|
_tmov->put(MOV_CODPAG, cp);
|
|
|
|
_tmov->rewrite();
|
|
}
|
|
}
|
|
|
|
void TVar_mov::registra_file_trasfer_t(long nr,int ar,const TDate& dr,const TDate& dd,const TString& nd,TString& ri,
|
|
long pi,long upi,const TString& cc,const TString& cp)
|
|
{
|
|
TString app,str;
|
|
TRectype* rec;
|
|
rec = new TRectype (LF_RMOV);
|
|
|
|
_trmov->setkey(1);
|
|
_trmov->zero();
|
|
_trmov->put(RMV_NUMREG, nr);
|
|
*rec = _trmov->curr();
|
|
|
|
for (_trmov->read(); !_trmov->eof(); _trmov->next())
|
|
{
|
|
if (_trmov->curr() > *rec) break;
|
|
|
|
long numrec = _trmov->get_int(RMV_ANNOES);
|
|
numrec += _tras_file.start('Z');
|
|
|
|
_tras_file.read_rec_trasfer(numrec); //Leggo il record della prima nota
|
|
|
|
app = dr.string();
|
|
str = riconverti(app);
|
|
_tras_file.put(str,"Z1",0,numrec);
|
|
app = dd.string();
|
|
str = riconverti(app);
|
|
_tras_file.put(str,"Z1",4,numrec);
|
|
str = format("%d", ar);
|
|
_tras_file.put(str,"Z1",50,numrec);
|
|
str = format("%-7s", (const char*) nd);
|
|
_tras_file.put(str,"Z1",5,numrec);
|
|
if (ri == "")
|
|
ri = " ";
|
|
_tras_file.put(ri,"Z1",6,numrec);
|
|
_tras_file.put(cc,"Z1",8,numrec);
|
|
str = format("%05ld", pi);
|
|
_tras_file.put(str,"Z1",7,numrec);
|
|
str = format("%05ld", upi);
|
|
_tras_file.put(str,"Z1",10,numrec);
|
|
str = format("%2s", (const char*) cp);
|
|
_tras_file.put(str,"Z1",9,numrec);
|
|
|
|
_tras_file.write(numrec);
|
|
}
|
|
|
|
delete rec;
|
|
}
|
|
|
|
void TVar_mov::registra_file_temp_rmov(long nr,int nri,int g,int c,long s,char sez,const TString& desc,
|
|
int gc,int cc,long sc,const real& imp)
|
|
{
|
|
_trmov->setkey(1);
|
|
_trmov->zero();
|
|
_trmov->put(RMV_NUMREG, nr);
|
|
_trmov->put(RMV_NUMRIG, nri);
|
|
if (_trmov->read() == NOERR)
|
|
{
|
|
_trmov->put(RMV_GRUPPO, g);
|
|
_trmov->put(RMV_CONTO, c);
|
|
_trmov->put(RMV_SOTTOCONTO, s);
|
|
_trmov->put(RMV_SEZIONE, sez);
|
|
_trmov->put(RMV_DESCR, desc);
|
|
_trmov->put(RMV_GRUPPOC, gc);
|
|
_trmov->put(RMV_CONTOC, cc);
|
|
_trmov->put(RMV_SOTTOCONTOC, sc);
|
|
_trmov->put(RMV_IMPORTO, imp);
|
|
|
|
_trmov->rewrite();
|
|
}
|
|
}
|
|
|
|
void TVar_mov::registra_file_trasfer_r(long nr,int nri,int g,int c,long s,char sez,const TString& desc,
|
|
int gc,int cc,long sc,const real& imp)
|
|
{
|
|
TString app,str;
|
|
|
|
_trmov->setkey(1);
|
|
_trmov->zero();
|
|
_trmov->put(RMV_NUMREG, nr);
|
|
_trmov->put(RMV_NUMRIG, nri);
|
|
|
|
if (_trmov->read() == NOERR)
|
|
{
|
|
long numrec = _trmov->get_int(RMV_ANNOES);
|
|
numrec += _tras_file.start('Z');
|
|
|
|
_tras_file.read_rec_trasfer(numrec); //Leggo il record della prima nota
|
|
|
|
str = format("%02d", g);
|
|
_tras_file.put(str,"Z1",17,numrec);
|
|
str = format("%02d", c);
|
|
_tras_file.put(str,"Z1",18,numrec);
|
|
str = format("%06ld", s);
|
|
_tras_file.put(str,"Z1",19,numrec);
|
|
str = format("%c", sez);
|
|
_tras_file.put(str,"Z1",20,numrec);
|
|
str = format("%-30s", (const char*)desc);
|
|
_tras_file.put(str,"Z1",16,numrec);
|
|
str = format("%02d", gc);
|
|
_tras_file.put(str,"Z1",21,numrec);
|
|
str = format("%02d", cc);
|
|
_tras_file.put(str,"Z1",22,numrec);
|
|
str = format("%06ld", sc);
|
|
_tras_file.put(str,"Z1",23,numrec);
|
|
str = format("%011s", (const char*) imp.string());
|
|
_tras_file.put(str,"Z1",24,numrec);
|
|
|
|
_tras_file.write(numrec);
|
|
}
|
|
}
|
|
|
|
void TVar_mov::registra_IVA(TMask& m)
|
|
{
|
|
if (!_righe)
|
|
{
|
|
long numreg = m.get_long(F_NUMREG);
|
|
TDate data74ter (m.get(F_DATA74TER));
|
|
long codcf = m.get_long(F_CODCF);
|
|
TString ragsococc = m.get (F_RAGSOCOCC);
|
|
TString indocc = m.get (F_INDOCC);
|
|
TString localita = m.get (F_LOCALITA);
|
|
TString capocc = m.get (F_CAPOCC);
|
|
TString provocc = m.get (F_PROVOCC);
|
|
|
|
_tmov->setkey(1);
|
|
_tmov->zero();
|
|
_tmov->put(MOV_NUMREG, numreg);
|
|
if (_tmov->read() == NOERR)
|
|
{
|
|
_tmov->put(MOV_DATA74TER, data74ter);
|
|
_tmov->put(MOV_CODCF, codcf);
|
|
|
|
_tmov->rewrite();
|
|
}
|
|
|
|
registra_file_trasfer_t_iva(numreg,data74ter,codcf,ragsococc,indocc,localita,capocc,provocc);
|
|
}
|
|
else
|
|
if (_righe)
|
|
{
|
|
long numreg = m.get_long(F_NUMREG);
|
|
int numrig = m.get_int (F_NUMRIG);
|
|
real imponibile (m.get (F_IMPONIBILE));
|
|
TString codiva = m.get (F_CODIVA);
|
|
real imposta (m.get (F_IMPOSTA));
|
|
int tipodet = m.get_int (F_TIPODET);
|
|
int tipocr = m.get_int (F_TIPOCR);
|
|
int gruppo = m.get_int (F_GRUPPO);
|
|
int conto = m.get_int (F_CONTO);
|
|
long sottoc = m.get_long(F_SOTTOCONTO);
|
|
|
|
registra_file_temp_riva(numreg,numrig,imponibile,codiva,imposta,tipodet,tipocr,gruppo,conto,sottoc);
|
|
registra_file_trasfer_r_iva(numreg,numrig,imponibile,codiva,imposta,tipodet,tipocr,gruppo,conto,sottoc);
|
|
}
|
|
}
|
|
|
|
void TVar_mov::registra_file_trasfer_t_iva(long nr,const TDate& d74,long cf,const TString& rgo,const TString& io,
|
|
const TString& lo,const TString& co,const TString& po)
|
|
{
|
|
TString app,str;
|
|
TRectype* rec;
|
|
rec = new TRectype (LF_RMOVIVA);
|
|
|
|
_tiva->setkey(1);
|
|
_tiva->zero();
|
|
_tiva->put(RMI_NUMREG, nr);
|
|
*rec = _tiva->curr();
|
|
|
|
for (_tiva->read(); !_tiva->eof(); _tiva->next())
|
|
{
|
|
if (_tiva->curr() > *rec) break;
|
|
|
|
long numrec = _tiva->get_int(RMI_ANNOES);
|
|
numrec += _tras_file.start('U');
|
|
|
|
_tras_file.read_rec_trasfer(numrec); //Leggo il record della prima nota
|
|
|
|
app = d74.string();
|
|
str = riconverti(app);
|
|
_tras_file.put(str,"U1",4,numrec);
|
|
str = format("%06d", cf);
|
|
_tras_file.put(str,"U1",6,numrec);
|
|
str = format("%-25s", (const char*)rgo );
|
|
_tras_file.put(str,"U1",50,numrec);
|
|
str = format("%-22s", (const char*)io);
|
|
_tras_file.put(str,"U1",51,numrec);
|
|
str = format("%-18s", (const char*)lo);
|
|
_tras_file.put(str,"U1",52,numrec);
|
|
str = format("%05s", (const char*)co );
|
|
_tras_file.put(str,"U1",53,numrec);
|
|
str = format("%-2s", (const char*)po);
|
|
_tras_file.put(str,"U1",54,numrec);
|
|
|
|
_tras_file.write(numrec);
|
|
}
|
|
|
|
delete rec;
|
|
}
|
|
|
|
void TVar_mov::registra_file_temp_riva(long nr,int nri,const real& imp,const TString& civa,const real& imposta,
|
|
int tdet,int tcr,int g,int c,long s)
|
|
{
|
|
_tiva->setkey(1);
|
|
_tiva->zero();
|
|
_tiva->put(RMI_NUMREG, nr);
|
|
_tiva->put(RMI_NUMRIG, nri);
|
|
if (_tiva->read() == NOERR)
|
|
{
|
|
_tiva->put(RMI_IMPONIBILE, imp);
|
|
_tiva->put(RMI_CODIVA, civa);
|
|
_tiva->put(RMI_IMPOSTA, imposta);
|
|
_tiva->put(RMI_TIPODET, tdet);
|
|
_tiva->put(RMI_TIPOCR, tcr);
|
|
_tiva->put(RMI_GRUPPO, g);
|
|
_tiva->put(RMI_CONTO, c);
|
|
_tiva->put(RMI_SOTTOCONTO, s);
|
|
|
|
_tiva->rewrite();
|
|
}
|
|
}
|
|
|
|
void TVar_mov::registra_file_trasfer_r_iva(long nr,int nri,const real& imp,const TString& civa,const real& imposta,
|
|
int tdet,int tcr,int g,int c,long s)
|
|
{
|
|
TString app,str;
|
|
|
|
_tiva->setkey(1);
|
|
_tiva->zero();
|
|
_tiva->put(RMI_NUMREG, nr);
|
|
_tiva->put(RMI_NUMRIG, nri);
|
|
|
|
if (_tiva->read() == NOERR)
|
|
{
|
|
long numrec = _tiva->get_int(RMI_ANNOES);
|
|
numrec += _tras_file.start('U');
|
|
|
|
_tras_file.read_rec_trasfer(numrec); //Leggo il record dell' iva
|
|
|
|
str = format("%011s", (const char*) imp.string());
|
|
_tras_file.put(str,"U1",14,numrec);
|
|
str = format("%02s", (const char*) civa);
|
|
_tras_file.put(str,"U1",13,numrec);
|
|
str = format("%09s", (const char*) imposta.string());
|
|
_tras_file.put(str,"U1",15,numrec);
|
|
str = format("%d", tdet);
|
|
_tras_file.put(str,"U1",16,numrec);
|
|
str = format("%d", tcr);
|
|
_tras_file.put(str,"U1",17,numrec);
|
|
str = format("%02d", g);
|
|
_tras_file.put(str,"U1",19,numrec);
|
|
str = format("%02d", c);
|
|
_tras_file.put(str,"U1",20,numrec);
|
|
str = format("%06ld", s);
|
|
_tras_file.put(str,"U1",21,numrec);
|
|
|
|
_tras_file.write(numrec);
|
|
}
|
|
}
|
|
|
|
bool TVar_mov::leggi_trasfer()
|
|
{
|
|
_trasf = _tras_file.path(_dittaric);
|
|
_trasf << "\\trasfer";
|
|
|
|
_tras_file.open(_trasf);
|
|
|
|
if (_tras_file.exist())
|
|
{
|
|
if (_tras_file.read_control_rec())
|
|
_control_rec = _tras_file.record();
|
|
else
|
|
return error_box("Rilevati gravi errori negli archivi:procedura interrotta");
|
|
}
|
|
else
|
|
return error_box("Al momento non presenti trasferimenti attivi sulla ditta selezionata");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::esegui_controlli()
|
|
{
|
|
TConfig conf(CONFIG_DITTA);
|
|
|
|
_std = conf.get("FlStTra");
|
|
|
|
if (!prefix().exist(_dittaric))
|
|
return error_box("Rilevati gravi errori negli archivi: procedura interrotta");
|
|
|
|
if (!leggi_trasfer())
|
|
return FALSE;
|
|
|
|
if (!controlli())
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void TVar_mov::setta_parametri_record(const TString& sigla,const TString& flag)
|
|
{
|
|
TConfig conf (CONFIG_DITTA);
|
|
|
|
conf.set("FlStTra", flag);
|
|
|
|
leggi_record_controllo();
|
|
_control_rec.overwrite(sigla,240);
|
|
|
|
const int size = 256;
|
|
|
|
_tras_file.write_control_rec(_control_rec, size);
|
|
}
|
|
|
|
bool TVar_mov::controlli()
|
|
{
|
|
if (_std == "T")
|
|
return error_box("Variazione NON POSSIBILE: eseguire prima la ricezione delle tabelle");
|
|
|
|
if (_std == "M")
|
|
return error_box("Variazione NON POSSIBILE: trasferimento movimenti gia' iniziato");
|
|
|
|
if (_std == "*")
|
|
{
|
|
warning_box("Trasferimento interamente completato: proseguire per cancellare il file");
|
|
fremove(_trasf);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TVar_mov::menu(MENU_TAG m)
|
|
{
|
|
if (m == BAR_ITEM(1))
|
|
return main_loop();
|
|
return FALSE;
|
|
}
|
|
|
|
int cg2800 (int argc, char* argv[])
|
|
{
|
|
switch (*argv[2])
|
|
{
|
|
case 'P':
|
|
{
|
|
TVar_mov main_app(*argv[2]);
|
|
main_app.run(argc, argv,main_app._titolo);
|
|
}
|
|
break;
|
|
case 'I':
|
|
{
|
|
TVar_mov main_app(*argv[2]);
|
|
main_app.run(argc, argv,main_app._titolo);
|
|
}
|
|
break;
|
|
case 'S':
|
|
{
|
|
TDitta_ric a;
|
|
a.run(argc, argv,"Scelta ditta per ricezione");
|
|
}
|
|
break;
|
|
case 'A':
|
|
{
|
|
TAnn_mov a;
|
|
a.run(argc, argv,"Annullamento movimenti da ricevere");
|
|
}
|
|
break;
|
|
case 'V':
|
|
{
|
|
TVis_ric a;
|
|
a.run(argc, argv,"Visualizzazione stato ricezione");
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
//main_app.run(argc, argv,main_app._titolo);
|
|
return TRUE;
|
|
}
|