280 lines
7.6 KiB
C++
Executable File
280 lines
7.6 KiB
C++
Executable File
#include <applicat.h>
|
|
#include <isam.h>
|
|
#include <mask.h>
|
|
#include <prefix.h>
|
|
#include <progind.h>
|
|
#include <relation.h>
|
|
#include <tabutil.h>
|
|
#include <utility.h>
|
|
|
|
#include <mov.h>
|
|
#include <urldefid.h>
|
|
|
|
#include "cg5.h"
|
|
#include "cg5400.h"
|
|
|
|
class TRipristina_stampa : public TApplication
|
|
{
|
|
enum TOperation { restore_reg, restore_inl };
|
|
TOperation _op;
|
|
|
|
protected: // TApplication
|
|
virtual bool create() ;
|
|
virtual bool menu(MENU_TAG);
|
|
|
|
public:
|
|
void azzera_lim(int year, int month) const;
|
|
|
|
bool reg_restore(const TString& reg, int year, int month, int day, bool giornale);
|
|
bool inl_restore(const TString& lbu, int year, int month);
|
|
|
|
TRipristina_stampa() : _op(restore_reg) {}
|
|
};
|
|
|
|
// Azzera flag di stampato della liquidazione mensile dal mese dato in poi
|
|
void TRipristina_stampa::azzera_lim(int year, int month) const
|
|
{
|
|
TTable lim("LIM"); // Azzera i flag di stampa liquidazione
|
|
lim.put("CODTAB", format("%04d%02d", year, month));
|
|
for (int err = lim.read(_isgteq); err == NOERR; err = lim.next())
|
|
{
|
|
if (atoi(lim.get("CODTAB").left(4)) != year) break;
|
|
const bool stampato = lim.get_bool("B1");
|
|
if (stampato)
|
|
{
|
|
lim.zero("B1");
|
|
lim.rewrite();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool TRipristina_stampa::reg_restore(const TString& regist,
|
|
int year, int month, int day,
|
|
bool giornale)
|
|
{
|
|
CHECKD(month > 0 && month < 13, "Mese errato ", month);
|
|
|
|
bool ok = TRUE;
|
|
const char * const fieldname = giornale ? MOV_STAMPATO : MOV_REGST;
|
|
TRelation rel(LF_MOV);
|
|
TLocalisamfile& mov = rel.lfile();
|
|
TTable reg("REG");
|
|
TString16 s; s.format("%04d%s", year, (const char*)regist);
|
|
|
|
reg.zero();
|
|
reg.put("CODTAB", s);
|
|
|
|
TDate inizio_anno(1, 1, year);
|
|
if (reg.read(_isequal, _lock) == NOERR)
|
|
{
|
|
TDate dlast(reg.get_date("D3"));
|
|
|
|
if (giornale)
|
|
{
|
|
TTable esc("ESC");
|
|
esc.zero();
|
|
esc.put("CODTAB", format("%04d", year));
|
|
if (esc.read() != NOERR)
|
|
return error_box("Esercizio %s assente", year);
|
|
|
|
TDate wd(esc.get_date("D0"));
|
|
inizio_anno = wd;
|
|
|
|
// Determina il corretto anno solare dell'esercizio: se il giorno di inizio esercizio
|
|
// e successivo alla data di ripristino allora mi trovo nell'anno solare successivo
|
|
year = wd.year();
|
|
if (wd.month() > month || (wd.month() == month && wd.day() > day))
|
|
year++;
|
|
}
|
|
|
|
const int ld = TDate::last_day(month, year);
|
|
if (day > ld) day = ld;
|
|
TDate d(day, month, year); // Data di ripristino
|
|
|
|
TRectype from(mov.curr()); from.zero();
|
|
TRectype to(from);
|
|
TString80 filter;
|
|
|
|
from.put(MOV_DATAREG, d);
|
|
to.put(MOV_DATAREG, dlast);
|
|
if (!giornale)
|
|
filter.format("%s==\"%s\"", MOV_REG, (const char*)regist);
|
|
|
|
TCursor cursor(&rel, filter, 2, &from, &to);
|
|
long last_num = 0L;
|
|
|
|
cursor = 0L;
|
|
const long nitems = cursor.items();
|
|
|
|
TProgind p(nitems ? nitems : 1, format("Ripristino stampa del registro %s", (const char*)regist) , TRUE, TRUE, 70);
|
|
|
|
if (giornale)
|
|
{
|
|
last_num = mov.get_long(MOV_NUMGIO);
|
|
if (last_num > 0) last_num--;
|
|
CHECK(last_num >= 0, "Ultimo numero stampato impossibile");
|
|
}
|
|
for (; ok && cursor.pos() < cursor.items(); ++cursor)
|
|
{
|
|
p.addstatus(1);
|
|
mov.read(_isequal, _lock);
|
|
mov.zero(fieldname); // Azzera flag STAMPATO o REGST
|
|
|
|
ok = (mov.rewrite() == NOERR);
|
|
if (!ok)
|
|
error_box("Errore nell'aggiornamento del movimento %ld.\n Errore n. %d",
|
|
mov.get_long(MOV_NUMREG), mov.status());
|
|
}
|
|
|
|
if (d > inizio_anno) // Aggiorna data ultima stampa
|
|
{
|
|
--d;
|
|
reg.put("D3", d); // Data ultima stampa
|
|
if (!giornale)
|
|
{
|
|
const int mese = d.month();
|
|
if (reg.get_int("I4") > mese)
|
|
reg.put("I4", (long)mese); // Ultimo mese di stampa liquidazione
|
|
if (reg.get_int("I8") >= mese)
|
|
reg.zero("I8"); // Mese di ultima stampa credito precedente
|
|
// azzera_lim(year, mese+1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
reg.zero("D3");
|
|
if (!giornale)
|
|
{
|
|
reg.zero("I4");
|
|
reg.zero("I8");
|
|
// azzera_lim(year, 1);
|
|
}
|
|
}
|
|
|
|
ok = (reg.rewrite() == NOERR);
|
|
if (!ok)
|
|
error_box("Errore nell'aggiornamento del registro %s.\n Errore n. %d",
|
|
(const char*)regist, mov.status());
|
|
}
|
|
else
|
|
ok = error_box("Impossibile leggere il registro %s anno %s",
|
|
(const char*)regist, (const char*)year);
|
|
|
|
return ok;
|
|
}
|
|
|
|
|
|
bool TRipristina_stampa::inl_restore(const TString& lib, int year, int month)
|
|
{
|
|
TLocalisamfile inl(LF_INDLIB);
|
|
|
|
inl.zero();
|
|
inl.put("ANNO", year);
|
|
inl.put("CODLIB", lib);
|
|
const TRectype filter(inl.curr());
|
|
|
|
bool ok = FALSE;
|
|
|
|
// Azzera il flag di stampato sugli indici con mese >= month
|
|
for (inl.read(_isgteq); inl.good() && inl.curr() == filter; inl.next())
|
|
if (inl.get_int("MESEREG") >= month && inl.get_bool("STAMPATO"))
|
|
{
|
|
inl.zero("STAMPATO");
|
|
ok = inl.rewrite() == NOERR;
|
|
if (!ok)
|
|
{
|
|
error_box("Errore di ripristino dell'indice %ld", inl.get_long("NUMREG"));
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ok) // Se e' stato ripristinato almeno un indice e non ci sono stati errori
|
|
{
|
|
TTable lbu("%LBU");
|
|
lbu.put("CODTAB", format("%4d%s", year, (const char*)lib));
|
|
ok = lbu.read() == NOERR;
|
|
if (ok)
|
|
{
|
|
TDate d(1, month, year); // Riporta la data di ultima stampa
|
|
lbu.put("D0", d);
|
|
ok = lbu.rewrite() == NOERR;
|
|
}
|
|
if (!ok)
|
|
error_box("Impossibile aggiornare il libro unico %s per l'anno %d", (const char*)lib, year);
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
bool TRipristina_stampa::create()
|
|
{
|
|
TApplication::create();
|
|
|
|
if (argc() > 2 && stricmp(argv(2), "INL") == 0)
|
|
_op = restore_inl;
|
|
|
|
dispatch_e_menu(BAR_ITEM(1));
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool TRipristina_stampa::menu(MENU_TAG)
|
|
{
|
|
TMask msk(_op == restore_inl ? "cg5400b" : "cg5400a") ;
|
|
|
|
while (msk.run() == K_ENTER)
|
|
{
|
|
long firm = 0L;
|
|
const TString16 reg = msk.get(F_REG);
|
|
bool giornale = FALSE;
|
|
|
|
if (_op == restore_reg)
|
|
{
|
|
firm = msk.get_long(F_FIRM);
|
|
giornale = msk.get_int(F_TIPO) == 5;
|
|
}
|
|
|
|
const int year = msk.get_int(giornale ? F_ESER : F_YEAR);
|
|
const int month = msk.get_int(F_MESE);
|
|
int day = giornale ? msk.get_int(F_DAY) : 1;
|
|
if (day < 1) day = 1;
|
|
|
|
if (prefix().exist(firm))
|
|
{
|
|
TString256 mess("Attenzione ripristino della stampa de");
|
|
if (_op == restore_reg)
|
|
mess << (giornale ? "l giornale" : "l registro");
|
|
else
|
|
mess << "gli indici del libro ";
|
|
mess << ' ' << reg << "\ndell'" << (giornale ? "esercizio " : "anno ") << year;
|
|
if (_op == restore_reg) mess << " della ditta " << firm;
|
|
mess << " dal " << day << '-' << month << '-' << year;
|
|
|
|
if (yesno_box(mess))
|
|
{
|
|
mess << "\nSi desidera veramente continuare?";
|
|
if (yesno_box(mess))
|
|
{
|
|
switch (_op)
|
|
{
|
|
case restore_inl:
|
|
inl_restore(reg, year, month); break;
|
|
default:
|
|
reg_restore(reg, year, month, day, giornale); break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else error_box("Gli archivi della ditta %ld non sono stati ancora generati", firm);
|
|
msk.reset();
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
int cg5400(int argc, char* argv[])
|
|
{
|
|
TRipristina_stampa a ;
|
|
a.run(argc, argv, "Ripristino stampe");
|
|
return 0;
|
|
}
|