root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ba/bacnv.cpp
angelo c880db2a71 Aggiunto codebase 5.1. 
- bacnvid e' l'applicazione di conversione.
- bacnv contiene l'applicazione di conversione a qualsiasi formato.


git-svn-id: svn://10.65.10.50/trunk@1534 c028cbd2-c16b-5b4b-a496-9718f37d4682
1995-07-03 07:52:10 +00:00

566 lines
13 KiB
C++
Executable File
Raw Blame History

#include <xvt.h>
#include <applicat.h>
#include <assoc.h>
#include <isam.h>
#include <mailbox.h>
#include <progind.h>
#include <prefix.h>
#include <tabutil.h>
#include <urldefid.h>
#include <utility.h>
#include <extcdecl.h>
#if XVT_OS == XVT_OS_WIN
#include <direct.h>
#define RMDIR _rmdir
#else
#define RMDIR rmdir
#endif
#include <rmov.h>
#define usage "Errore - uso : bacnv [1|2|3|4] ditta"
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Applicazione di conversione archivi XBase, valida per tutti e 4 i tipi di DLL
///////////////////////////////////////////////////////////////////////////////////////////////////////
class TConversione_xbase : public TApplication
{
protected:
virtual bool create () ;
virtual bool destroy();
void update();
void convert_dir();
int convert_file(int logicnum);
public:
TConversione_xbase() {}
~TConversione_xbase() {}
};
bool TConversione_xbase::create() // initvar e arrmask
{
TApplication::create();
update();
return FALSE;
}
bool TConversione_xbase::destroy() // releasev e arrmask
{
return TApplication::destroy() ;
}
int TConversione_xbase::convert_file(int logicnum)
{
int err = NOERR;
TSystemisamfile f(logicnum);
err=f.pack(); // Pack data and index, so rebuild indexes according to present DLL, leaving old indexes
return err;
}
void TConversione_xbase::convert_dir()
{
const TString pref(prefix().name());
const bool is_com = prefix().is_com();
TDir d;
d.get(LF_DIR);
const int items = (int)d.eod();
TString80 s("Aggiornamento archivi ");
if (pref == "com") s << "comuni";
else s << " della ditta " << atol (pref);
TProgind p((long)(items ? items : 1), s, TRUE, TRUE, 70);
p.setstatus(1L);
for (int i = 2; i <= items; i++)
{
p.setstatus((long)(i+1));
d.get(i, _nolock, _nordir, _sysdirop);
const bool to_convert = (is_com ? d.is_com() : d.is_firm());
if (to_convert && d.len() > 0)
convert_file(i);
}
}
void TConversione_xbase::update()
{
long firm = get_firm();
TString pref;
if (firm == 0) pref = prefix().name();
do_events();
begin_wait();
prefix().set("com");
convert_dir();
TLocalisamfile ditte(LF_NDITTE);
set_autoload_new_files(FALSE);
for (ditte.first(); !ditte.eof(); ditte.next())
{
const long codditta = ditte.get_long("CODDITTA");
const TRecnotype rec = ditte.recno();
if (prefix().exist(codditta))
{
set_firm(codditta);
convert_dir();
}
}
if (firm > 0) set_firm(firm);
else prefix().set(pref);
set_autoload_new_files(TRUE);
end_wait();
}
/////////////////////////////////////////////////////////////////////////////////////////
// Applicazione di conversione archivi
/////////////////////////////////////////////////////////////////////////////////////////
class TConversione_archivi : public TApplication
{
int _nconv;
long _codditta;
long _oldditta;
int _error;
protected: // TApplication
virtual bool create() ;
virtual bool destroy() ;
virtual bool menu(MENU_TAG);
public:
bool convert_rmov(TLocalisamfile & rmov, TArray & recs, int nrecs);
void contropartita_rmov();
void liala(const char* table);
bool patch_uff(TRectype & rec, const char * const fnames[]);
bool collate(TRectype & rec, const char * f1, const char * f2);
void patch_com(void);
void zero_770(void);
void convert_patty(void);
TConversione_archivi() : _oldditta(0), _codditta(0), _error(0) {}
};
bool TConversione_archivi::create()
{
TApplication::create();
if (argc() < 3)
{
_error = 101;
TMessage msg("ba1100", 0, format("%d", _error));
msg.send();
return FALSE;
}
else
{
_nconv = atoi(argv(1));
if (_nconv > 1)
{
_oldditta = get_firm();
_codditta = atol(argv(argc() - 1));
if (_codditta != _oldditta)
{
if (_codditta == 0) prefix().set("com");
else set_firm(_codditta);
}
}
dispatch_e_menu(MENU_ITEM(1));
return TRUE;
}
}
bool TConversione_archivi::destroy()
{
if (_nconv > 1 && _codditta != _oldditta)
{
if (_oldditta == 0) prefix().set("com");
else set_firm(_oldditta);
}
if (_error > 0)
{
TMessage msg("ba1100", 0, format("%d", _error));
msg.send();
}
return TRUE;
}
bool TConversione_archivi::menu(MENU_TAG)
{
switch (_nconv)
{
case 1:
{
TSystemisamfile f(atoi(argv(2)));
TFilename lf;
lf.format("%sstd/%s", __ptprf, argv(3));
if (fexist(lf))
f.load(lf, '|', '\0', '\n', TRUE, TRUE);
}
break;
case 2:
liala("LIA");
liala("PLA");
break;
case 3:
if (_codditta == 0)
patch_com();
case 4:
if (_codditta == 0)
zero_770();
case 5:
convert_patty();
default:
break;
}
return FALSE;
}
///////////////////////////////////////////////////////////
// Cambia i movimenti contabili in modo che abbiano un
// conto di contropartita e non una riga di riferimento
///////////////////////////////////////////////////////////
bool TConversione_archivi::convert_rmov(TLocalisamfile & rmov, TArray & recs, int nrecs)
{
const TRecnotype pos = rmov.recno();
for (int i = 0; i < nrecs; i++)
{
TRectype & r0 = (TRectype &) recs[i];
const int rcontr = r0.get_int(RMV_RCONTR) - 1;
if (rcontr >= 0 && rcontr < nrecs)
{
const TRectype & r1 = (const TRectype &) recs[rcontr];
r0.put(RMV_TIPOCC, r1.get(RMV_TIPOC));
r0.put(RMV_GRUPPOC, r1.get_int(RMV_GRUPPO));
r0.put(RMV_CONTOC, r1.get_int(RMV_CONTO));
r0.put(RMV_SOTTOCONTOC, r1.get_long(RMV_SOTTOCONTO));
}
r0.zero(RMV_RCONTR);
if (rmov.rewrite(r0) != NOERR)
{
const long reg = r0.get_long(RMV_NUMREG);
error_box("Non riesco ad aggiornare la riga contabile %ld / %d\nErrore n. %d", reg, i + 1, rmov.status());
rmov.readat(pos);
_error = 102;
return FALSE;
}
}
rmov.readat(pos);
return TRUE;
}
void TConversione_archivi::contropartita_rmov()
{
TDir d;
d.get(LF_RMOV);
if (d.eox() == 0) return;
TLocalisamfile rmov(LF_RMOV);
const TRecnotype nitems = rmov.items();
TArray recs;
long oldreg = -1;
long reg = -1;
int nrow = 0;
TProgind p(nitems ? nitems : 1,
format("Conversione righe di movimento della ditta %ld", get_firm()),
FALSE, TRUE, 70);
for (rmov.first(); rmov.good(); rmov.next())
{
p.addstatus(1);
reg = rmov.get_long(RMV_NUMREG);
if (oldreg != reg)
{
if (oldreg > 0)
if (convert_rmov(rmov, recs, nrow) == FALSE)
return;
oldreg = reg;
nrow = 0;
}
recs.add(rmov.curr(), nrow++);
CHECKD(nrow == rmov.get_int(RMV_NUMRIG), "Missed row ", nrow);
}
if (oldreg > 0)
if (convert_rmov(rmov, recs, nrow) == FALSE)
return;
}
///////////////////////////////////////////////////////////
// Passa le tabelle LIA e PLA a %LIA e %PLA
///////////////////////////////////////////////////////////
void TConversione_archivi::liala(const char* table)
{
TString16 tab(table);
TTable lia(tab);
tab.insert("%", 0);
TTable cia(tab);
const long n = lia.items()+1;
TProgind p(n, format("Conversione tabella %s della ditta %ld", table, get_firm()), FALSE, TRUE, 70);
TString16 firm; firm.format("%05ld", get_firm());
TString16 codtab;
for (lia.first(); lia.good(); lia.next())
{
codtab = lia.get("CODTAB");
codtab.insert(firm, 0);
lia.put("CODTAB", codtab);
cia.write(lia.curr());
}
for (lia.first(); lia.good(); lia.next())
lia.remove();
}
///////////////////////////////////////////////////////////
// Sposta i codici uffici imposte e uffici IVA nei comuni
///////////////////////////////////////////////////////////
bool TConversione_archivi::collate(TRectype & rec, const char * f1, const char * f2)
{
if (rec.get(f1).empty())
{
TString16 s(rec.get(f2));
if (s.not_empty())
{
rec.put(f1, s);
rec.zero(f2);
return TRUE;
}
}
return FALSE;
}
bool TConversione_archivi::patch_uff(TRectype & rec, const char * const fnames[])
{
bool updated = collate(rec, fnames[1], fnames[2]);
updated |= collate(rec, fnames[0], fnames[1]);
updated |= collate(rec, fnames[1], fnames[2]);
return updated;
}
void TConversione_archivi::patch_com()
{
TLocalisamfile comuni(LF_COMUNI);
const char * const uff_iidd[] = {"UFFIIDD1", "UFFIIDD2", "UFFIIDD3"} ;
const char * const uff_iva[] = {"UFFIVA1", "UFFIVA2", "UFFIVA3"} ;
const TRecnotype nitems = comuni.items();
TProgind p(nitems ? nitems : 1, format("Conversione comuni"), FALSE, TRUE, 70);
for (comuni.first(); comuni.good(); comuni.next())
{
p.addstatus(1);
bool updated = patch_uff(comuni.curr(), uff_iidd);
updated = patch_uff(comuni.curr(), uff_iva) || updated;
if (updated)
comuni.rewrite();
}
}
void TConversione_archivi::zero_770()
{
for (int i = LF_BASE ; i <= LF_DETH; i++)
{
TDir d;
d.get(i, _lock, _nordir, _sysdirop);
d.eod() = 0L;
d.eox() = 0L;
d.put(i, _nordir, _sysdirop);
}
TToken_string files;
if (fexist(format("%scom/770", __ptprf)))
{
files.format("%scom/770/%s", __ptprf, "*");
list_files(files);
for (const char * s = files.get(); s != NULL; s = files.get())
remove(s);
RMDIR(format("%scom/770", __ptprf));
}
if (fexist(format("%s770", __ptprf)))
{
files.format("%s770/%s", __ptprf, "*");
list_files(files);
for (const char * s = files.get(); s != NULL; s = files.get())
remove(s);
RMDIR(format("%s770", __ptprf));
}
}
void TConversione_archivi::convert_patty()
{
{
TTable ivd("%IVD");
ivd.zero();
ivd.put("CODTAB", "9E0023");
if (ivd.read(_isequal, _lock) == NOERR)
ivd.remove();
}
{
TTable doc("%TPD");
doc.zero();
doc.put("CODTAB", "AN");
if (doc.read(_isequal, _lock) == NOERR)
doc.remove();
doc.zero();
doc.put("CODTAB", "IN");
if (doc.read(_isequal, _lock) == NOERR)
doc.remove();
doc.zero();
doc.put("CODTAB", "PG");
if (doc.read(_isequal, _lock) == NOERR)
doc.remove();
doc.zero();
doc.put("CODTAB", "NA");
if (doc.read(_isequal, _lock) == NOERR)
doc.remove();
}
TAssoc_array causarr;
TDir d;
d.get(LF_CAUS,_nolock,_nordir,_sysdirop);
if (d.is_com())
d.get(LF_CAUS,_nolock,_comdir);
if (d.eod() > 0L)
{
TLocalisamfile caus(LF_CAUSALI);
for (caus.first(_lock); caus.good(); caus.next(_lock))
{
const TString16 tpd(caus.get("TIPODOC"));
const TString16 incimm(caus.get("CODCAUSIM"));
if (incimm.not_empty())
causarr.add(incimm, incimm);
if (tpd == "AN") caus.zero("TIPODOC");
else
if (tpd == "IN") caus.zero("TIPODOC");
else
if (tpd == "PG") caus.zero("TIPODOC");
else
if (tpd == "NA") caus.put("TIPODOC","NC");
caus.rewrite();
}
}
const bool topatch = causarr.items() > 0;
d.get(LF_MOV);
if (d.eod() > 0L)
{
TLocalisamfile mov(LF_MOV);
for (mov.first(_lock); mov.good(); mov.next(_lock))
{
const TString16 tpd(mov.get("TIPODOC"));
if (topatch)
{
const TString16 codcaus(mov.get("CODCAUS"));
if (causarr.objptr(codcaus) != NULL)
{
mov.zero("DATA74TER");
mov.zero("REG");
mov.zero("PROTIVA");
mov.zero("UPROTIVA");
mov.zero("REGST");
mov.zero("TIPO");
mov.zero("CODCF");
mov.zero("TOTDOC");
mov.zero("RITFIS");
mov.zero("RITSOC");
mov.zero("PROVVIS");
mov.zero("CODVALI");
mov.zero("CAMBIOI");
mov.zero("CORRLIRE");
mov.zero("CORRVALUTA");
mov.zero("OCFPI");
mov.zero("CODPAG");
}
}
if (tpd == "AN") mov.zero("TIPODOC");
else
if (tpd == "IN") mov.zero("TIPODOC");
else
if (tpd == "PG") mov.zero("TIPODOC");
else
if (tpd == "NA") mov.put("TIPODOC","NC");
mov.rewrite();
}
}
{
}
if (_codditta == 0)
{
TSystemisamfile f(LF_FORM);
TFilename lf;
lf.format("%sstd/lf0054.txt", __ptprf);
if (fexist(lf))
f.load(lf);
}
}
///////////////////////////////////////////////////////////
// Programma di conversione archivi speciale
///////////////////////////////////////////////////////////
int main(int argc,char** argv)
{
const int r = (argc > 1) ? atoi(argv[1]) : 0;
if (r < 0 || r > 5)
{
error_box(usage);
return 100;
}
else
if (r==0)
{
TConversione_xbase a;
a.run(argc,argv, "Conversione archivi di xBase");
}
else
{
TConversione_archivi a ;
a.run(argc, argv, "Conversione archivi");
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink