518 lines
12 KiB
C++
Executable File
518 lines
12 KiB
C++
Executable File
// Rinumerazione movimenti e saldi
|
|
// fv 12/12/93
|
|
// -------------------------------------------------------------------------
|
|
// *TBI* Partenza dall'ultimo movimento stampato
|
|
// *TBI* Aggiornamento scadenziario
|
|
// *TBI* Aggiornamento cespiti
|
|
// -------------------------------------------------------------------------
|
|
|
|
#include <applicat.h>
|
|
#include <isam.h>
|
|
#include <sort.h>
|
|
#include <lffiles.h>
|
|
#include <urldefid.h>
|
|
#include <stdlib.h>
|
|
#include <utility.h>
|
|
#include <mask.h>
|
|
#include <progind.h>
|
|
|
|
//#if XVT_OS == XVT_OS_SCOUNIX
|
|
#include <signal.h>
|
|
//#endif
|
|
|
|
#define FLD_CG41_YEAR 100
|
|
|
|
#include <mov.h>
|
|
#include <rmov.h>
|
|
#include <rmoviva.h>
|
|
#include <saldi.h>
|
|
#include <causali.h>
|
|
|
|
// for access()
|
|
#if XVT_OS == XVT_OS_DOS || XVT_OS == XVT_OS_WIN
|
|
#include <io.h>
|
|
#else
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
struct therec {
|
|
char DATAREG[7];
|
|
char REG[4];
|
|
char DATADOC[7];
|
|
char NUMDOC[7];
|
|
char ANNOES[5];
|
|
char NUMREG[8];
|
|
};
|
|
|
|
struct truc {
|
|
char GRUPPO[4];
|
|
char CONTO[4];
|
|
char SOTTOCONTO[7];
|
|
char SEZIONE[2];
|
|
char IMPORTO[19];
|
|
char NUMREG[8];
|
|
};
|
|
|
|
|
|
class CG4100_App : public TApplication
|
|
{
|
|
TString _year;
|
|
|
|
public:
|
|
|
|
virtual bool create();
|
|
virtual bool destroy();
|
|
|
|
bool set_parms(bool year);
|
|
virtual bool menu(MENU_TAG m);
|
|
|
|
void restore_mov(TSystemisamfile& a, TSystemisamfile& b, TSystemisamfile& c);
|
|
void sort_all();
|
|
bool sort_mov();
|
|
bool sort_sal();
|
|
|
|
CG4100_App() : TApplication(), _year(4)
|
|
{ }
|
|
virtual ~CG4100_App() {}
|
|
};
|
|
|
|
|
|
bool CG4100_App::create()
|
|
{
|
|
TApplication::create();
|
|
|
|
// UNIX: signal() per intercettare errori
|
|
#if XVT_OS == XVT_OS_SCOUNIX
|
|
signal(SIGINT,SIG_IGN);
|
|
#endif
|
|
|
|
if (fexist("__sal__.sav"))
|
|
warning_box("Un'operazione di riordino saldi si e' conclusa"
|
|
" impropriamente. Si raccomanda di rieseguirla");
|
|
|
|
if (fexist("__mov__.sav"))
|
|
warning_box("Un'operazione di riordino movimenti si e' conclusa"
|
|
" impropriamente. Si raccomanda di rieseguirla");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool CG4100_App::destroy()
|
|
{
|
|
// UNIX: resettare i segnali
|
|
#if XVT_OS == XVT_OS_SCOUNIX
|
|
signal(SIGINT,SIG_DFL);
|
|
#endif
|
|
|
|
return TApplication::destroy();
|
|
}
|
|
|
|
bool CG4100_App::set_parms(bool year)
|
|
{
|
|
TMask m("cg4100a");
|
|
|
|
if (!year)
|
|
m.hide(FLD_CG41_YEAR);
|
|
|
|
m.run();
|
|
|
|
_year = m.get(FLD_CG41_YEAR);
|
|
|
|
return m.last_key() == K_ENTER;
|
|
}
|
|
|
|
|
|
bool CG4100_App::menu(MENU_TAG m)
|
|
{
|
|
switch (m)
|
|
{
|
|
case BAR_ITEM(1):
|
|
sort_mov();
|
|
break;
|
|
case BAR_ITEM(2):
|
|
sort_sal();
|
|
break;
|
|
}
|
|
return TApplication::menu(m);
|
|
}
|
|
|
|
|
|
void CG4100_App::restore_mov(TSystemisamfile& mov, TSystemisamfile& rmov,
|
|
TSystemisamfile& rmoviva)
|
|
{
|
|
long rn, rec;
|
|
if (fexist("__mov__.ind"))
|
|
{
|
|
// rebuild all indexes
|
|
mov.close(); rmov.close(); rmoviva.close();
|
|
mov.packfile(); rmov.packfile(); rmoviva.packfile();
|
|
mov.packindex(); rmov.packindex(); rmoviva.packindex();
|
|
remove("__mov__.ind");
|
|
return;
|
|
}
|
|
|
|
FILE* fp = fopen("__mov__.sav","r");
|
|
if (feof(fp))
|
|
{
|
|
warning_box("File di ripristino vuoto; il ripristino non e' necessario");
|
|
remove("__mov__.sav");
|
|
return;
|
|
};
|
|
|
|
for (;;)
|
|
{
|
|
if (feof(fp)) break;
|
|
fscanf(fp,"%ld %ld", &rn, &rec);
|
|
|
|
mov.readat(rec);
|
|
mov.curr().put(MOV_NUMREG,format("%ld",rn));
|
|
mov.rewrite();
|
|
|
|
for (;;)
|
|
{
|
|
if (feof(fp)) break;
|
|
fscanf(fp,"%ld",&rec);
|
|
if (rec == -1l) break;
|
|
rmov.readat(rec);
|
|
rmov.curr().put(RMV_NUMREG,format("%ld",rn));
|
|
rmov.rewrite();
|
|
}
|
|
for (;;)
|
|
{
|
|
if (feof(fp)) break;
|
|
fscanf(fp,"%ld",&rec);
|
|
if (rec == -1l) break;
|
|
rmoviva.readat(rec);
|
|
rmoviva.curr().put(RMI_NUMREG,format("%ld",rn));
|
|
rmoviva.rewrite();
|
|
}
|
|
}
|
|
|
|
fclose(fp);
|
|
remove("__mov__.sav");
|
|
}
|
|
|
|
|
|
bool CG4100_App::sort_mov()
|
|
{
|
|
if (!set_parms(FALSE))
|
|
return FALSE;
|
|
|
|
TSystemisamfile mov(LF_MOV);
|
|
TSystemisamfile rmov(LF_RMOV);
|
|
TSystemisamfile rmoviva(LF_RMOVIVA);
|
|
|
|
if (mov.open(_excllock) || rmov.open(_excllock) ||
|
|
rmoviva.open(_excllock))
|
|
{
|
|
warning_box("Gli archivi sono in uso. Operazione interrotta");
|
|
return FALSE;
|
|
}
|
|
|
|
mov.first();
|
|
mov.indexoff(); rmov.indexoff(); rmoviva.indexoff();
|
|
|
|
TSort sort(sizeof(struct therec));
|
|
|
|
if (fexist("__mov__.sav") || fexist("__mov__.ind"))
|
|
{
|
|
// previous operation failed
|
|
if (yesno_box("Un riordinamento precedente e' fallito.\n"
|
|
" Ripristino la situazione iniziale ora?" ))
|
|
restore_mov(mov, rmov, rmoviva);
|
|
else return FALSE;
|
|
}
|
|
|
|
therec rbuf;
|
|
|
|
sort.addsortkey(rbuf.DATAREG - (char*)&rbuf, 6);
|
|
sort.addsortkey(rbuf.REG - (char*)&rbuf, 3);
|
|
sort.addsortkey(rbuf.NUMDOC - (char*)&rbuf, 6);
|
|
sort.addsortkey(rbuf.DATADOC - (char*)&rbuf, 6);
|
|
|
|
sort.init();
|
|
|
|
TProgind prnd(mov.items(),
|
|
"Riordino archivio movimenti in corso\nOrdinamento file movimenti...",
|
|
FALSE,TRUE,30);
|
|
|
|
|
|
while (!mov.eof())
|
|
{
|
|
do_events();
|
|
TDate d(mov.curr().get(MOV_DATAREG));
|
|
strcpy(rbuf.DATAREG, format("%ld",(long)d));
|
|
strcpy(rbuf.REG, mov.curr().get(MOV_REG));
|
|
d = mov.curr().get(MOV_DATADOC);
|
|
strcpy(rbuf.NUMDOC, mov.curr().get(MOV_NUMDOC));
|
|
strcpy(rbuf.DATADOC, format("%ld",(long)d));
|
|
strcpy(rbuf.ANNOES, mov.curr().get(MOV_ANNOES));
|
|
strcpy(rbuf.NUMREG, mov.curr().get(MOV_NUMREG));
|
|
|
|
sort.sort((char*)&rbuf);
|
|
mov.next();
|
|
prnd.addstatus(1);
|
|
}
|
|
sort.endsort();
|
|
|
|
prnd.setstatus(0);
|
|
prnd.set_text("Riordino archivio movimenti in corso\nRiscrittura file movimenti...");
|
|
|
|
therec* rr;
|
|
long num = 1;
|
|
|
|
while ((rr = (therec*)sort.retrieve()) != NULL)
|
|
{
|
|
do_events();
|
|
if (atol(rr->NUMREG) != num)
|
|
{
|
|
// find record
|
|
mov.curr().zero();
|
|
mov.curr().put(MOV_NUMREG, rr->NUMREG);
|
|
mov.curr().put(MOV_ANNOES, rr->ANNOES);
|
|
|
|
mov.read();
|
|
// should never happen
|
|
CHECK(!mov.bad(), "Archivio movimenti inconsistente. Questo si' che e' un casino.");
|
|
|
|
// retrieve and change NUMREG
|
|
TString rgn = rr->NUMREG;
|
|
FILE* fsav = fopen("__mov__.sav","a");
|
|
fprintf(fsav,"%s %d ", (const char*)rgn, mov.recno());
|
|
fclose(fsav);
|
|
|
|
mov.curr().put(MOV_NUMREG,num);
|
|
mov.rewrite();
|
|
// update linked records
|
|
|
|
rmov.curr().zero();
|
|
rmov.curr().put(RMV_NUMREG,rgn);
|
|
rmov.read(_isgteq);
|
|
|
|
|
|
while (!rmov.eof())
|
|
{
|
|
if (rgn != rmov.curr().get(RMV_NUMREG))
|
|
break;
|
|
fsav = fopen("__mov__.sav","a");
|
|
fprintf(fsav,"%ld ", (long)rmov.recno());
|
|
fclose(fsav);
|
|
rmov.curr().put(RMV_NUMREG,num);
|
|
rmov.rewrite();
|
|
rmov.next();
|
|
}
|
|
fsav = fopen("__mov__.sav","a");
|
|
fprintf(fsav,"-1"); fclose(fsav);
|
|
|
|
rmoviva.curr().zero();
|
|
rmoviva.curr().put(RMI_NUMREG,rgn);
|
|
rmoviva.read(_isgteq);
|
|
|
|
while (!rmoviva.eof())
|
|
{
|
|
if (rgn != rmoviva.curr().get(RMV_NUMREG))
|
|
break;
|
|
fsav = fopen("__mov__.sav","a");
|
|
fprintf(fsav,"%ld ", (long)rmov.recno());
|
|
fclose(fsav);
|
|
rmoviva.curr().put(RMI_NUMREG,num);
|
|
rmoviva.rewrite();
|
|
rmoviva.next();
|
|
}
|
|
fsav = fopen("__mov__.sav","a");
|
|
fprintf(fsav,"-1"); fclose(fsav);
|
|
}
|
|
num++;
|
|
prnd.addstatus(1);
|
|
}
|
|
|
|
remove("__mov__.sav");
|
|
|
|
FILE* fsav = fopen("__mov__.ind","w"); fclose(fsav);
|
|
|
|
prnd.set_text("Riordino archivio movimenti in corso\nRicostruzione files indice...");
|
|
|
|
// rebuild indexes
|
|
mov.close(); rmov.close(); rmoviva.close();
|
|
mov.packfile(); rmov.packfile(); rmoviva.packfile();
|
|
mov.packindex(); rmov.packindex(); rmoviva.packindex();
|
|
|
|
remove("__mov__.ind");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool CG4100_App::sort_sal()
|
|
{
|
|
bool first;
|
|
|
|
if (!set_parms(TRUE))
|
|
return FALSE;
|
|
|
|
FILE* fp = fopen ("__sal__.sav","w");
|
|
fclose(fp);
|
|
|
|
TLocalisamfile rmov(LF_RMOV);
|
|
TLocalisamfile saldi(LF_SALDI);
|
|
TLocalisamfile mov(LF_MOV);
|
|
TLocalisamfile causali(LF_CAUSALI);
|
|
|
|
long jj = 0l;
|
|
|
|
rmov.first(); saldi.first(); mov.first(); causali.first();
|
|
|
|
TSort sort(sizeof(struct truc));
|
|
truc rbuf;
|
|
|
|
sort.addsortkey(rbuf.GRUPPO - (char*)&rbuf, 3);
|
|
sort.addsortkey(rbuf.CONTO - (char*)&rbuf, 3);
|
|
sort.addsortkey(rbuf.SOTTOCONTO - (char*)&rbuf, 6);
|
|
sort.addsortkey(rbuf.SEZIONE - (char*)&rbuf, 1);
|
|
|
|
sort.init();
|
|
|
|
TProgind prnd(rmov.items(),
|
|
"Riordino archivio saldi in corso\nOrdinamento archivio movimenti...",
|
|
FALSE,TRUE,30);
|
|
|
|
while (!rmov.eof())
|
|
{
|
|
if (_year == rmov.curr().get(RMV_ANNOES))
|
|
{
|
|
strcpy(rbuf.GRUPPO, rmov.curr().get(RMV_GRUPPO));
|
|
strcpy(rbuf.CONTO, rmov.curr().get(RMV_CONTO));
|
|
strcpy(rbuf.SOTTOCONTO, rmov.curr().get(RMV_SOTTOCONTO));
|
|
strcpy(rbuf.SEZIONE, rmov.curr().get(RMV_SEZIONE));
|
|
strcpy(rbuf.IMPORTO, rmov.curr().get(RMV_IMPORTO));
|
|
strcpy(rbuf.NUMREG, rmov.curr().get(RMV_NUMREG));
|
|
sort.sort((char*)&rbuf);
|
|
jj++;
|
|
}
|
|
rmov.next();
|
|
prnd.addstatus(1);
|
|
do_events();
|
|
}
|
|
|
|
prnd.setstatus(0);
|
|
prnd.set_text("Riordino archivio saldi in corso\nRiscrittura file saldi...");
|
|
prnd.setmax(jj);
|
|
|
|
do_events();
|
|
sort.endsort();
|
|
|
|
truc* rr = (truc*)sort.retrieve();
|
|
|
|
while (rr != NULL)
|
|
{
|
|
do_events();
|
|
|
|
real dare = 0.0, avere = 0.0, saldo = 0.0;
|
|
TString conto, sottoconto, gruppo, h;
|
|
|
|
saldi.curr().zero();
|
|
saldi.curr().put(SLD_CONTO, rr->CONTO);
|
|
saldi.curr().put(SLD_SOTTOCONTO, rr->SOTTOCONTO);
|
|
saldi.curr().put(SLD_GRUPPO, rr->GRUPPO);
|
|
saldi.curr().put(SLD_ANNOES, _year);
|
|
saldi.read();
|
|
|
|
if (saldi.eof())
|
|
{
|
|
saldi.curr().zero();
|
|
saldi.curr().put(SLD_CONTO, rr->CONTO);
|
|
saldi.curr().put(SLD_SOTTOCONTO, rr->SOTTOCONTO);
|
|
saldi.curr().put(SLD_GRUPPO, rr->GRUPPO);
|
|
saldi.curr().put(SLD_ANNOES, _year);
|
|
}
|
|
else
|
|
{
|
|
saldi.curr().put(SLD_SALDO,"");
|
|
saldi.curr().put(SLD_PDARESCA,"");
|
|
saldi.curr().put(SLD_PAVERESCA,"");
|
|
saldi.curr().put(SLD_PDARE,"");
|
|
saldi.curr().put(SLD_PAVERE,"");
|
|
saldi.curr().put(SLD_DATAULMOV,"");
|
|
saldi.curr().put(SLD_NUMULTMOV,"");
|
|
saldi.rewrite();
|
|
}
|
|
|
|
first = TRUE;
|
|
|
|
do
|
|
{
|
|
bool apertura = FALSE;
|
|
|
|
conto = rr->CONTO;
|
|
sottoconto = rr->SOTTOCONTO;
|
|
gruppo = rr->GRUPPO;
|
|
h = rr->SEZIONE;
|
|
|
|
real imp = rr->IMPORTO;
|
|
|
|
// cerca causale
|
|
mov.curr().zero();
|
|
mov.curr().put(MOV_ANNOES,_year);
|
|
mov.curr().put(MOV_NUMREG, rr->NUMREG);
|
|
mov.read();
|
|
|
|
CHECK(!mov.bad(),"Archivi movimenti e righe inconsistenti");
|
|
causali.curr().zero();
|
|
causali.curr().put(CAU_CODCAUS,mov.curr().get(MOV_CODCAUS));
|
|
|
|
CHECK(!causali.bad(),"Archivi causali e movimenti inconsistenti");
|
|
|
|
if (first)
|
|
{ apertura = causali.curr().get_bool(CAU_MOVAP); first = FALSE; }
|
|
|
|
if (apertura)
|
|
{
|
|
saldo += imp;
|
|
}
|
|
else
|
|
{
|
|
if (rr->SEZIONE[0] == 'D')
|
|
dare += imp;
|
|
else avere += imp;
|
|
}
|
|
prnd.addstatus(1);
|
|
rr = (truc*)sort.retrieve();
|
|
do_events();
|
|
}
|
|
while (rr && conto == rr->CONTO && sottoconto == rr->SOTTOCONTO &&
|
|
gruppo == rr->GRUPPO);
|
|
|
|
if (dare != 0.0)
|
|
{
|
|
saldi.curr().put(SLD_PDARE,dare);
|
|
saldi.curr().put(SLD_FLAGSALINI,"D");
|
|
}
|
|
else if (avere != 0.0)
|
|
{
|
|
saldi.curr().put(SLD_PAVERE,avere);
|
|
saldi.curr().put(SLD_FLAGSALINI,"A");
|
|
}
|
|
else if (saldo != 0.0)
|
|
{
|
|
saldi.curr().put(SLD_SALDO,saldo);
|
|
saldi.curr().put(SLD_FLAGSALINI,h);
|
|
}
|
|
|
|
if (saldi.eof())
|
|
saldi.write();
|
|
else
|
|
saldi.rewrite();
|
|
}
|
|
remove("__sal__.sav");
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
int cg4100(int argc, char* argv[])
|
|
{
|
|
CG4100_App main_app;
|
|
main_app.run(argc, argv, "Riordinamento movimenti/Ricalcolo Saldi");
|
|
return TRUE;
|
|
}
|
|
|