root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

New entry!! azzeramento archivi con classe e controclasse

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@4224 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
luciano 1997-03-21 17:32:13 +00:00
parent e1594fd672
commit 4c0c8a7e32
12 changed files with 2364 additions and 1031 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2050
m770/771200.cpp
View File

File diff suppressed because it is too large Load Diff

4
m770/774.cpp
View File

@ -14,7 +14,9 @@ int main(int argc,char** argv)
case 0:
m74100(argc,argv) ; break;
case 1:
riporti_dich(argc,argv) ; break;
riporti_dich(argc,argv) ; break;
case 2:
azzeramento_archivi(argc,argv) ; break;
default:
error_box(usage, argv[0]) ;
}

3
m770/774.h
View File

@ -2,7 +2,8 @@
#define __774_H
extern int m74100 (int argc, char* argv[]);
extern int riporti_dich(int argc, char* argv[]);
extern int riporti_dich(int argc, char* argv[]);
extern int azzeramento_archivi(int argc, char* argv[]);
#endif

3
m770/774.url
View File

@ -8,4 +8,7 @@ MENUBAR MENU_BAR(1)
MENU MENU_BAR(1)
SUBMENU MENU_FILE "~File"
MENUBAR MENU_BAR(2)
MENU MENU_BAR(2)
SUBMENU MENU_FILE "~File"

6
m770/774200.cpp
View File

@ -50,12 +50,6 @@
// Costanti
#define TIPOQUA "TIPOQUA"
// NB Tutte da spostare in lffiles
#define LF_RIGHEF2 100
#define LF_RIGHEF1 99
#define LF_RIGHEF 98
#define LF_QUAGD 101
// inizializzato in TRiporti::set() - usato in filter_func()
HIDDEN TRiporti* this_riporti = NULL;

819
m770/774300.cpp Executable file
View File

@ -0,0 +1,819 @@
// Description:
// Azzeramento archivi
//
// Usage:
// 774 -2 S (livello di studio)
// 774 -2 D (livello di ditta)
// Author:
// L.A.
#include <relapp.h>
#include <progind.h>
#include <urldefid.h>
#include <execp.h>
#include <prefix.h>
#include <form.h>
#include "774200.h"
#include "77lib.h"
#include "resetfil.h"
#include "scandich.h"
#include "774300a.h"
// derivazione della classe TArray_sheet per implementare
// la funzione membro on_key() in modo che gestisca eventuali
// bottoni aggiunti dall'utente
class TArray_sheetDerived : public TArray_sheet
{
public:
// @cmember Gestisce la pressione del tasto (vedi <mf TWindow::on_key>)
virtual bool on_key(KEY);
// @cmember Costruttore
TArray_sheetDerived(short x, short y, short dx, short dy, const char* caption, const char* head, byte buttons = 0):
TArray_sheet(x, y, dx, dy, caption, head, buttons){};
// @cmember Distruttore
virtual ~TArray_sheetDerived(){};
};
class TAzzeramento_archivi : public TRelation_application
{
private:
char _liv;
long _curditta;
int _anno_dich;
TMask* _msk;
TRelation* _rel;
TConfig* _cnf_studio;
TRiporti* _riporti;
TIsamtempfile* _logschede;
// elenco campi da riportare
real _mem_ECCRIT23_BASEBIS;
// elenco file da azzerare
TResetfile* _reset_BASE;
TResetfile* _reset_BASEBIS;
TResetfile* _reset_SOCTRASF;
TResetfile* _reset_PERC;
TResetfile* _reset_SCPERC;
TResetfile* _reset_RVER;
TResetfile* _reset_RPAG;
TResetfile* _reset_DIPEND;
TResetfile* _reset_QUAA;
TResetfile* _reset_QUAA1;
TResetfile* _reset_QUAA2;
TResetfile* _reset_QUAA3;
TResetfile* _reset_QUAB;
TResetfile* _reset_QUAB1;
TResetfile* _reset_QUAC;
TResetfile* _reset_QUAD;
TResetfile* _reset_QUAD1;
TResetfile* _reset_QUAE;
TResetfile* _reset_QUAE1;
TResetfile* _reset_QUAE2;
TResetfile* _reset_PROSPE1;
TResetfile* _reset_QUAF;
TResetfile* _reset_RIGHEF;
TResetfile* _reset_QUAF1;
TResetfile* _reset_RIGHEF1;
TResetfile* _reset_QUAF2;
TResetfile* _reset_RIGHEF2;
TResetfile* _reset_QUAG;
TResetfile* _reset_QUAGD;
TResetfile* _reset_QUAG1;
TResetfile* _reset_QUAH;
TResetfile* _reset_DETH;
TResetfile* _reset_QUAL;
TResetfile* _reset_QUAN;
TResetfile* _reset_QUAP;
TResetfile* _reset_QUAQ;
TResetfile* _reset_QUAR;
TResetfile* _reset_QUAS;
TResetfile* _reset_QUAT;
// elenco di VALIDATE_RECORD function
static bool validate_record_SCPERC(const TRectype& rec);
static bool validate_record_RPAG(const TRectype& rec);
static bool validate_record_RVER(const TRectype& rec);
static bool validate_record_QUAL(const TRectype& rec);
static bool validate_record_DETH(const TRectype& rec);
// elenco di VALIDATE_FIELD function
static bool validate_field_BASE(const TRectype& rec, const TString& fld);
static bool validate_field_BASEBIS(const TRectype& rec, const TString& fld);
// elenco di BEFORE_RESET function
static void before_reset_BASEBIS(TRectype& rec);
// elenco di AFTER_RESET function
static void after_reset_BASEBIS(TRectype& rec);
// validazione e azioni su schede percipienti
bool is_resetable(const TRectype& rec);
// handler di campi
static bool F_AZZSCH_hnd(TMask_field& f, KEY key);
static bool F_AZZQUA_hnd(TMask_field& f, KEY key);
static bool DLG_SAVEREC_hnd(TMask_field& f, KEY key);
// creazione/distruzione istanze d'azzeramento
void azzera_create(const bool azzsch, const bool azzqua);
void azzera_destroy(const bool azzsch, const bool azzqua);
// gestione del log delle schede percipienti
void handle_log();
// stampa del log delle schede percipienti
void print_log();
// elaborazioni previste
void elab_tutte(const bool azzsch, const bool azzqua);
void elab_selezionate(const bool azzsch, const bool azzqua);
void elab_manutenzione(const bool azzsch, const bool azzqua){}
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 void init_modify_mode(TMask&);
virtual int rewrite(const TMask& m);
virtual int write(const TMask& m);
public:
TAzzeramento_archivi(char livello) : _liv(toupper(livello)) {}
~TAzzeramento_archivi() {}
};
// riferimento all'istanza dell'applicazione
TAzzeramento_archivi& app() { return (TAzzeramento_archivi&)main_app(); }
// implementazione per gestire eventuali bottoni aggiunti dall'utente
bool TArray_sheetDerived::on_key(KEY key)
{
// verifico se premuto un bottone utente
switch(key)
{
// ignorato perchè non restituisce se stesso
case K_CTRL+'N':
break;
default:
// verifico altri bottoni non previsti dallo sheet standard
if (key > K_CTRL)
{
for (int i = fields()-1; i >= 0; i--)
{
TMask_field& f = fld(i);
if (f.active() && f.is_kind_of(CLASS_BUTTON_FIELD))
{
TButton_field& b = (TButton_field&)f;
if (b.virtual_key() == key)
{
stop_run(key);
return TRUE;
}
}
}
}
break;
}
// richiamo on_key base
return TArray_sheet::on_key(key);
}
bool TAzzeramento_archivi::user_create()
{
_msk = new TMask("774300a");
_rel = new TRelation(LF_STAZZ);
_cnf_studio = new TConfig(CONFIG_STUDIO,"77");
_anno_dich = _cnf_studio->get_int(ANNO_SEL);
_riporti = new TRiporti;
_logschede = new TIsamtempfile(LF_SCPERC,"LOG",TRUE);
// forzo il file di log delle schede all'auto eliminazione
_logschede->set_autodel();
// attivazione handler campi
_msk->set_handler(F_AZZSCH,F_AZZSCH_hnd);
_msk->set_handler(F_AZZQUA,F_AZZQUA_hnd);
_msk->set_handler(DLG_SAVEREC,DLG_SAVEREC_hnd);
// disattivazione bottoni non utilizzabili
_msk->disable(DLG_DELREC);
return TRUE;
}
bool TAzzeramento_archivi::user_destroy()
{
delete _msk;
delete _rel;
delete _cnf_studio;
delete _riporti;
delete _logschede;
return TRUE;
}
// creazione istanze d'azzeramento
void TAzzeramento_archivi::azzera_create(const bool azzsch, const bool azzqua)
{
// richiesto azzeramento schede percipienti
if (azzsch)
{
_reset_PERC = new TResetfile(LF_PERC);
_reset_SCPERC = new TResetfile(LF_SCPERC,TRUE);
_reset_RVER = new TResetfile(LF_RVER,TRUE);
_reset_RPAG = new TResetfile(LF_RPAG,TRUE);
}
// richiesto azzeramento quadri
if (azzqua)
{
_reset_BASE = new TResetfile(LF_BASE);
_reset_BASEBIS = new TResetfile(LF_BASEBIS);
_reset_SOCTRASF = new TResetfile(LF_SOCTRASF,TRUE);
_reset_DIPEND = new TResetfile(LF_DIPEND);
_reset_QUAA = new TResetfile(LF_QUAA,TRUE);
_reset_QUAA1 = new TResetfile(LF_QUAA1,TRUE);
_reset_QUAA2 = new TResetfile(LF_QUAA2,TRUE);
_reset_QUAA3 = new TResetfile(LF_QUAA3,TRUE);
_reset_QUAB = new TResetfile(LF_QUAB,TRUE);
_reset_QUAB1 = new TResetfile(LF_QUAB1,TRUE);
_reset_QUAC = new TResetfile(LF_QUAC,TRUE);
_reset_QUAD = new TResetfile(LF_QUAD,TRUE);
_reset_QUAD1 = new TResetfile(LF_QUAD1,TRUE);
_reset_QUAE = new TResetfile(LF_QUAE,TRUE);
_reset_QUAE1 = new TResetfile(LF_QUAE1,TRUE);
_reset_QUAE2 = new TResetfile(LF_QUAE2,TRUE);
_reset_PROSPE1 = new TResetfile(LF_PROSPE1,TRUE);
_reset_QUAF = new TResetfile(LF_QUAF,TRUE);
_reset_RIGHEF = new TResetfile(LF_RIGHEF,TRUE);
_reset_QUAF1 = new TResetfile(LF_QUAF1,TRUE);
_reset_RIGHEF1 = new TResetfile(LF_RIGHEF1,TRUE);
_reset_QUAF2 = new TResetfile(LF_QUAF2,TRUE);
_reset_RIGHEF2 = new TResetfile(LF_RIGHEF2,TRUE);
_reset_QUAG = new TResetfile(LF_QUAG,TRUE);
_reset_QUAGD = new TResetfile(LF_QUAGD,TRUE);
_reset_QUAG1 = new TResetfile(LF_QUAG1,TRUE);
_reset_QUAH = new TResetfile(LF_QUAH,TRUE);
_reset_DETH = new TResetfile(LF_DETH,TRUE);
_reset_QUAL = new TResetfile(LF_QUAL,TRUE);
_reset_QUAN = new TResetfile(LF_QUAN,TRUE);
_reset_QUAP = new TResetfile(LF_QUAP,TRUE);
_reset_QUAQ = new TResetfile(LF_QUAQ,TRUE);
_reset_QUAR = new TResetfile(LF_QUAR,TRUE);
_reset_QUAS = new TResetfile(LF_QUAS,TRUE);
_reset_QUAT = new TResetfile(LF_QUAT,TRUE);
}
}
// distruzione istanze d'azzeramento
void TAzzeramento_archivi::azzera_destroy(const bool azzsch, const bool azzqua)
{
// richiesto azzeramento schede percipienti
if (azzsch)
{
delete _reset_PERC;
delete _reset_SCPERC;
delete _reset_RVER;
delete _reset_RPAG;
}
// richiesto azzeramento quadri
if (azzqua)
{
delete _reset_BASE;
delete _reset_BASEBIS;
delete _reset_SOCTRASF;
delete _reset_DIPEND;
delete _reset_QUAA;
delete _reset_QUAA1;
delete _reset_QUAA2;
delete _reset_QUAA3;
delete _reset_QUAB;
delete _reset_QUAB1;
delete _reset_QUAC;
delete _reset_QUAD;
delete _reset_QUAD1;
delete _reset_QUAE;
delete _reset_QUAE1;
delete _reset_QUAE2;
delete _reset_PROSPE1;
delete _reset_QUAF;
delete _reset_RIGHEF;
delete _reset_QUAF1;
delete _reset_RIGHEF1;
delete _reset_QUAF2;
delete _reset_RIGHEF2;
delete _reset_QUAG;
delete _reset_QUAGD;
delete _reset_QUAG1;
delete _reset_QUAH;
delete _reset_DETH;
delete _reset_QUAL;
delete _reset_QUAN;
delete _reset_QUAP;
delete _reset_QUAQ;
delete _reset_QUAR;
delete _reset_QUAS;
delete _reset_QUAT;
}
}
// gestione del log delle schede percipienti
void TAzzeramento_archivi::handle_log()
{
// creazione sheet
TString caption = "Schede percipienti insolute";
TString head = "@1|";
head << "Ditta@5@R|";
head << "Tipo|";
head << "Codice@R|";
head << "Scheda@R|";
head << "Data doc.@10@R|";
head << "Num.doc.|";
head << "Cau.|";
head << "Totale doc.@15@R|";
head << "Compenso@15@R|";
head << "Spese@15@R|";
head << "Iva@15@R";
TArray_sheetDerived log_sheet(12, 3, 66, 20, caption, head);
log_sheet.add_button(DLG_PRINT, "~Stampa", K_CTRL+'S');
// apertura file fisico originale perchè altrimenti da "erore!"
TLocalisamfile f(LF_SCPERC);
// riempimento sheet
for (int err = _logschede->first(); err == NOERR; err = _logschede->next())
{
TToken_string row;
row.add(" ");
row.add(_logschede->get_long("CODDITTA"));
row.add(_logschede->get_char("TIPOA"));
row.add(_logschede->get_long("CODANAGR"));
row.add(_logschede->get_long("NPROG"));
row.add(_logschede->get_date("DATADOC"));
row.add(_logschede->get("NUMDOC"));
row.add(_logschede->get_int("CODCAUS"));
row.add(_logschede->get("TOTALE"));
row.add(_logschede->get("COMPENSO"));
row.add(_logschede->get("SPESE"));
row.add(_logschede->get("IVA"));
log_sheet.add(row);
}
// esecuzione sheet
log_sheet.enable_check();
KEY retkey = log_sheet.run();
// interpreto azione restituita
switch (retkey)
{
case K_CTRL+'S':
yesno_box("Vuoi davvero stampare");
print_log();
break;
case K_ENTER:
yesno_box("Vuoi davvero azzerare");
break;
default:
break;
}
}
// stampa del log delle schede percipienti
void TAzzeramento_archivi::print_log()
{
TForm log_form("logazz");
// log_form.relation()->replace(_logschede);
TArray& a = log_form.head();
TForm_item& fi = log_form.find_field('H',odd_page,1);
fi.set("1995");
log_form.print();
}
// elabora tutte le dichiarazioni
void TAzzeramento_archivi::elab_tutte(const bool azzsch, const bool azzqua)
{
// creazione istanze d'azzeramento
azzera_create(azzsch, azzqua);
// richiesto azzeramento schede percipienti
if (azzsch)
{
// percipienti
_reset_PERC->run();
// schede percipienti (non invertire l'ordine di chiamata!!)
_reset_SCPERC->set_validate_record_function(validate_record_SCPERC);
_reset_RPAG->set_validate_record_function(validate_record_RPAG);
_reset_RVER->set_validate_record_function(validate_record_RVER);
_reset_SCPERC->run();
_reset_RPAG->run();
_reset_RVER->run();
}
// richiesto azzeramento quadri
if (azzqua)
{
// quadro BASE e BASEBIS
_reset_BASE->set_validate_field_function(validate_field_BASE);
_reset_BASEBIS->set_validate_field_function(validate_field_BASEBIS);
_reset_BASEBIS->set_before_reset_function(before_reset_BASEBIS);
_reset_BASEBIS->set_after_reset_function(after_reset_BASEBIS);
_reset_BASE->run();
_reset_BASEBIS->run();
// società trasformate
_reset_SOCTRASF->run();
// quadri A/A1/A2/A3/B/B1
_reset_QUAA->run();
_reset_QUAA1->run();
_reset_QUAA2->run();
_reset_QUAA3->run();
_reset_QUAB->run();
_reset_QUAB1->run();
// quadri C/D/D1/E/E1/E2 e prospetto E1
_reset_QUAC->run();
_reset_QUAD->run();
_reset_QUAD1->run();
_reset_QUAE->run();
_reset_QUAE1->run();
_reset_QUAE2->run();
_reset_PROSPE1->run();
// quadri F/F1/F2/G/G1 e distinta G
_reset_QUAF->run();
_reset_RIGHEF->run();
_reset_QUAF1->run();
_reset_RIGHEF1->run();
_reset_QUAF2->run();
_reset_RIGHEF2->run();
_reset_QUAG->run();
_reset_QUAG1->run();
_reset_QUAGD->run();
// quadro H e dettaglio
_reset_DETH->set_validate_record_function(validate_record_DETH);
_reset_QUAH->run();
_reset_DETH->run();
// quadro L
_reset_QUAL->set_validate_record_function(validate_record_QUAL);
_reset_QUAL->run();
// quadri N/P/Q/R/S/T
_reset_QUAN->run();
_reset_QUAP->run();
_reset_QUAQ->run();
_reset_QUAR->run();
_reset_QUAS->run();
_reset_QUAT->run();
}
// distruzione istanze d'azzeramento
azzera_destroy(azzsch, azzqua);
// controllo se esiste log schede percipienti
if (!_logschede->empty())
handle_log();
return;
}
// elabora le dichiarazioni selezionate (non implementata)
void TAzzeramento_archivi::elab_selezionate(const bool azzsch, const bool azzqua)
{
long codditta;
TScandich scandich(_sel_dich);
for (codditta = scandich.first();
scandich.good(); codditta = scandich.next())
{
_curditta = codditta;
}
return;
}
bool TAzzeramento_archivi::validate_record_SCPERC(const TRectype& rec)
{
// verifica se la scheda è azzerabile
bool isresetable = app().is_resetable(rec);
// scheda da non azzerare
if (!isresetable)
return FALSE;
// scheda da loggare
if (isresetable == 2)
{
app()._logschede->write(rec);
return FALSE;
}
// elimino tutti gli altri record
return TRUE;
}
bool TAzzeramento_archivi::validate_record_RPAG(const TRectype& rec)
{
// apro file e inizializzo chiave schede percipienti
TLocalisamfile scperc(LF_SCPERC);
scperc.setkey(1);
scperc.zero();
scperc.put("CODDITTA",rec.get_long("CODDITTA"));
scperc.put("TIPOA",rec.get_char("TIPOA"));
scperc.put("CODANAGR",rec.get_long("CODANAGR"));
scperc.put("NPROG",rec.get_int("NPROG"));
// non elimino pagamento se esiste scheda di appartenenza
if (scperc.read() == NOERR)
return FALSE;
// elimino tutti gli altri record
return TRUE;
}
bool TAzzeramento_archivi::validate_record_RVER(const TRectype& rec)
{
// apro file e inizializzo chiave schede percipienti
TLocalisamfile scperc(LF_SCPERC);
scperc.setkey(1);
scperc.zero();
scperc.put("CODDITTA",rec.get_long("CODDITTA"));
scperc.put("TIPOA",rec.get_char("TIPOA"));
scperc.put("CODANAGR",rec.get_long("CODANAGR"));
scperc.put("NPROG",rec.get_int("NPROG"));
// non elimino pagamento se esiste scheda di appartenenza
if (scperc.read() == NOERR)
return FALSE;
// elimino tutti gli altri record
return TRUE;
}
bool TAzzeramento_archivi::validate_record_DETH(const TRectype& rec)
{
// non elimino i record con anno maggiore dell'anno dichiarazione
if (rec.get_int("ANNO") > app()._anno_dich)
return FALSE;
// elimino tutti gli altri record
return TRUE;
}
bool TAzzeramento_archivi::validate_record_QUAL(const TRectype& rec)
{
// non elimino i record con anno maggiore dell'anno dichiarazione
if (rec.get_int("QLAP") > app()._anno_dich)
return FALSE;
// elimino tutti gli altri record
return TRUE;
}
bool TAzzeramento_archivi::validate_field_BASE(const TRectype& rec, const TString& fld)
{
if (fld == "ANNODIC" ||
fld == "RAPPR" ||
fld == "CARRAPP" ||
fld == "CODCAAF" ||
fld == "CODPRO" ||
fld == "DITTACAAF")
return FALSE;
return TRUE;
}
bool TAzzeramento_archivi::validate_field_BASEBIS(const TRectype& rec, const TString& fld)
{
if (fld == "L0CCONC1" ||
fld == "L0CCONC2" ||
fld == "L0CCONC3" ||
fld == "L0CTES1" ||
fld == "L0CTES2" ||
fld == "L0CTES3")
return FALSE;
return TRUE;
}
void TAzzeramento_archivi::before_reset_BASEBIS(TRectype& rec)
{
// memorizzo campi da riportare
app()._mem_ECCRIT23_BASEBIS = rec.get_real("ECCRIT23");
return;
}
void TAzzeramento_archivi::after_reset_BASEBIS(TRectype& rec)
{
// campi da riportare
rec.put("ECCRIT12",app()._mem_ECCRIT23_BASEBIS);
return;
}
// questa funzione restituisce :
// FALSE - la scheda non è azzerabile;
// TRUE - la scheda è azzerabile;
// 2 - la scheda è da loggare;
bool TAzzeramento_archivi::is_resetable(const TRectype& rec)
{
// apro file e inizializzo chiave pagamenti
TLocalisamfile rpag(LF_RPAG);
rpag.setkey(1);
rpag.zero();
rpag.put("CODDITTA",rec.get_long("CODDITTA"));
rpag.put("TIPOA",rec.get_char("TIPOA"));
rpag.put("CODANAGR",rec.get_long("CODANAGR"));
rpag.put("NPROG",rec.get_int("NPROG"));
// istanzio record di confronto
TRectype dummyrec(rpag.curr());
// istanzio date di confronto
TDate dummydate(31,12,app()._anno_dich);
TDate dummydate2(01,01,app()._anno_dich);
// inizializzo boolean per almeno un pagamento
bool nopags = TRUE;
// inizializzo totale compenso e spese
real tot_compenso = ZERO;
real tot_spesa = ZERO;
// controllo se i pagamenti sono azzerabili
for (int err = rpag.read(_isgteq);
err == NOERR && rpag.curr() == dummyrec;
err = rpag.next(), nopags = FALSE)
{
// data pagamento superiore al 31/12/AAAA
if (rpag.get_date("DATAPAG") > dummydate)
return FALSE; // scheda da non azzerare
// pagamento non versato
if (rpag.get_long("NUMVERS") <= 0L)
return 2; // scheda da loggare
// totalizzo compenso e spese
tot_compenso += rpag.get_real("COMPENSO");
tot_spesa += rpag.get_real("SPESA");
}
// se ci sono pagamenti controllo che la scheda sia totalmente pagata
if (!nopags)
if (tot_compenso != rec.get_real("COMPENSO") ||
tot_spesa != rec.get_real("SPESE"))
return 2; // scheda da loggare
// se non ci sono pagamenti controllo la data documento
if (nopags)
// data documento minore del 01/01/AAAA
if (rec.get_date("DATADOC") < dummydate2)
return 2; // scheda da loggare
else
return FALSE; // scheda da non azzerare
return TRUE;
}
// implementazione funzione virtuale TRelation_application
void TAzzeramento_archivi::init_modify_mode(TMask& m)
{
TDate dateazz;
// disabilito checkbox azzeramento schede
dateazz = m.get_date(F_DATASCH);
if (dateazz.year() != 0)
{
m.set(F_AZZSCH,TRUE);
m.disable(F_AZZSCH);
}
// disabilito checkbox azzeramento quadri
dateazz = m.get_date(F_DATAQUA);
if (dateazz.year() != 0)
{
m.set(F_AZZQUA,TRUE);
m.disable(F_AZZQUA);
}
}
// implementazione funzione virtuale TRelation_application
int TAzzeramento_archivi::write(const TMask& m)
{
bool azzsch = m.get_bool(F_AZZSCH);
bool azzqua = m.get_bool(F_AZZQUA);
// azzeramento di tutte le dichiarazioni
elab_tutte(azzsch, azzqua);
return TRelation_application::write(m);
}
// implementazione funzione virtuale TRelation_application
int TAzzeramento_archivi::rewrite(const TMask& m)
{
TDate datasch = _rel->lfile().get_date("DATASCH");
TDate dataqua = _rel->lfile().get_date("DATAQUA");
bool azzsch = m.get_bool(F_AZZSCH) && datasch.year() == 0;
bool azzqua = m.get_bool(F_AZZQUA) && dataqua.year() == 0;
// azzeramento di tutte le dichiarazioni
elab_tutte(azzsch, azzqua);
return TRelation_application::rewrite(m);
}
// handler del campo maschera F_AZZSCH
bool TAzzeramento_archivi::F_AZZSCH_hnd(TMask_field& f, KEY k)
{
if (f.to_check(K_TAB))
{
TMask& m = f.mask();
// compila in automatico l'utente e la data di azzeramento
// delle schede percipiente
if (m.get_bool(F_AZZSCH) == TRUE)
{
TDate today(TODAY);
m.set(F_DATASCH,today);
m.set(F_USERSCH,user());
}
else
{
m.reset(F_DATASCH);
m.reset(F_USERSCH);
}
}
return TRUE;
}
// handler del campo maschera F_AZZQUA
bool TAzzeramento_archivi::F_AZZQUA_hnd(TMask_field& f, KEY k)
{
if (f.to_check(K_TAB))
{
TMask& m = f.mask();
// compila in automatico l'utente e la data di azzeramento
// delle schede percipiente
if (m.get_bool(F_AZZQUA) == TRUE)
{
TDate today(TODAY);
m.set(F_DATAQUA,today);
m.set(F_USERQUA,user());
}
else
{
m.reset(F_DATAQUA);
m.reset(F_USERQUA);
}
}
return TRUE;
}
// handler del bottone maschera DLG_SAVEREC
bool TAzzeramento_archivi::DLG_SAVEREC_hnd(TMask_field& f, KEY k)
{
if (k == K_SPACE)
{
TMask& m = f.mask();
TDate datasch = app()._rel->lfile().get_date("DATASCH");
TDate dataqua = app()._rel->lfile().get_date("DATAQUA");
bool azzsch = m.get_bool(F_AZZSCH) && datasch.year() == 0;
bool azzqua = m.get_bool(F_AZZQUA) && dataqua.year() == 0;
if (azzsch || azzqua)
{
TString testo;
testo << "Conferma azzeramento ";
if (azzsch)
testo << "schede percipienti, ";
if (azzqua)
testo << "quadri dichiarazione, ";
testo << "per l'anno " << m.get(F_ANNODIC) << " ?";
return f.yesno_box(testo);
}
}
return TRUE;
}
// funzione principale di lancio applicazione
int Azzeramento_archivi(int argc, char* argv[])
{
TAzzeramento_archivi a(*argv[2]);
a.run(argc, argv, "Azzeramento archivi");
return 0;
}

11
m770/774300a.h Executable file
View File

@ -0,0 +1,11 @@
// 774300a.h - Storico azzeramenti
#define F_ANNODIC 201
#define F_AZZSCH 202
#define F_USERSCH 203
#define F_DATASCH 204
#define F_AZZQUA 205
#define F_USERQUA 206
#define F_DATAQUA 207
#define LF_STAZZ 109

82
m770/774300a.uml Executable file
View File

@ -0,0 +1,82 @@
#include "774300a.h"
TOOLBAR "" 0 18 0 4
#include <toolbar.h>
ENDPAGE
PAGE "Storico azzeramenti" -1 -1 78 21
NUMBER F_ANNODIC 4
BEGIN
PROMPT 1 3 "Anno dichiarazione "
FIELD LF_STAZZ->ANNODIC
KEY 1
USE LF_STAZZ KEY 1
INPUT ANNODIC F_ANNODIC
DISPLAY "Anno" ANNODIC
DISPLAY "Azzeramento schede" DATASCH
DISPLAY "Azzeramento quadri" DATAQUA
OUTPUT F_ANNODIC ANNODIC
OUTPUT F_USERSCH USERSCH
OUTPUT F_DATASCH DATASCH
OUTPUT F_USERQUA USERQUA
OUTPUT F_DATAQUA DATAQUA
CHECKTYPE REQUIRED
FLAGS "R"
MESSAGE ENABLE,F_AZZSCH|ENABLE,F_AZZQUA
END
GROUPBOX DLG_NULL -1 3
BEGIN
PROMPT 1 7 "@bAzzeramento schede percipienti"
FLAGS "R"
END
BOOLEAN F_AZZSCH
BEGIN
PROMPT 2 8 ""
END
STRING F_USERSCH 8
BEGIN
PROMPT 6 8 "Utente "
FIELD LF_STAZZ->USERSCH
FLAGS "D"
END
DATE F_DATASCH
BEGIN
PROMPT 25 8 "Data azzeramento "
FIELD LF_STAZZ->DATASCH
FLAGS "D"
END
GROUPBOX DLG_NULL -1 3
BEGIN
PROMPT 1 12 "@bAzzeramento quadri dichiarazione"
FLAGS "R"
END
BOOLEAN F_AZZQUA
BEGIN
PROMPT 2 13 ""
END
STRING F_USERQUA 8
BEGIN
PROMPT 6 13 "Utente "
FIELD LF_STAZZ->USERQUA
FLAGS "D"
END
DATE F_DATAQUA
BEGIN
PROMPT 25 13 "Data azzeramento "
FIELD LF_STAZZ->DATAQUA
FLAGS "D"
END
ENDPAGE
ENDMASK

176
m770/resetfil.cpp Executable file
View File

@ -0,0 +1,176 @@
#include "resetfil.h"
///////////////////////////////////////////////////////////
// TResetfile
///////////////////////////////////////////////////////////
TResetfile::TResetfile(int logicnum, bool remove)
: _file_num(logicnum), _removerec(remove),
_validate_record_function(NULL),
_validate_field_function(NULL),
_before_reset_function(NULL),
_after_reset_function(NULL)
{
// oggetto file da azzerare
_file = new TSystemisamfile(_file_num);
}
TResetfile::~TResetfile()
{
// pack file se richiesto rimozione record
if(_removerec)
_file->pack();
delete _file;
}
// @doc INTERNAL
// @mfunc ritorna se il campo <p fd> è un campo chiave
bool TResetfile::iskeyfield(const RecDes& recd, const int fd) const
{
// inizializzo risultato da restituire
bool found = FALSE;
// loop di scansione delle chiavi del file
for (int i = 0; i < recd.NKeys && !found; i++)
{
// Elenco dei campi della chiave
const KeyDes& keyd = recd.Ky[i];
// loop di scansione dei campi della chiave
for (int j = 0; j < keyd.NkFields && !found; j++)
if (fd == keyd.FieldSeq[j] % MaxFields)
found = TRUE;
}
return found;
}
// @doc INTERNAL
// @mfunc carica l'array <p resetable_fields> con i campi da azzerare
// @rfunc ritorna il numero di campi caricati
int TResetfile::load_resetable_fields(const RecDes& recd,
TString_array& resetable_fields)
{
// inizializzo numero campi da restituire
int numfld = 0;
for (int i = 0; i < recd.NFields; i++)
{
// non azzero i campi chiave
if (iskeyfield(recd, i))
continue;
// Descrittore campo
RecFieldDes& fieldd = recd.Fd[i];
// non azzero i campi indefiniti
if (fieldd.TypeF == _nullfld)
continue;
// aggiungo campo da azzerare all'array
resetable_fields.add(fieldd.Name,numfld++);
}
return numfld;
}
// @doc EXTERNAL
// @mfunc esegue l'azzeramento del file
// @rfunc ritorna il codice errore relativo ad operazioni sul file
int TResetfile::run()
{
// codice errore
int err;
// numero campi da azzerare
int num_resetable_fields;
// Apertura file con bloccaggio
err = _file->open(_excllock);
if (err != NOERR)
return err;
// riferimento a record corrente
TRectype& rec = _file->curr();
// Descrittore record
const RecDes* recd = rec.rec_des();
// array dei campi da azzerare
TString_array resetable_fields(recd->NFields);
// riempimento array dei campi da azzerare
if (!_removerec)
num_resetable_fields = load_resetable_fields(*recd, resetable_fields);
// reperimento nome file file
const char* desfile = _file->description();
// composizione testo per indicatore progressivo
TString testo;
testo.format("Azzeramento %s", desfile);
// inizializzazione indice massimo e parziale per indicatore progressivo
const long pmax = _file->items();
long pi = 0L;
// istanza indicatore progressivo per avanzamento azzeramento
TProgind p(pmax, testo, FALSE, TRUE);
// loop di scansione file da azzerare
for (err = _file->first(); err == NOERR; err = _file->next())
{
// incremento indicatore progressivo
p.addstatus(1);
pi++;
// richiamo handler VALIDATE_RECORD
if (_validate_record_function)
if (!_validate_record_function(rec))
continue;
// richiamo handler BEFORE_RESET
if (_before_reset_function)
_before_reset_function(rec);
// rimozione del record
if(_removerec)
_file->remove();
// azzeramento del record
else
{
// loop di scansione campi da azzerare
for (int i = 0; i < num_resetable_fields; i++)
{
// richiamo handler VALIDATE_FIELD
if (_validate_field_function)
if (!_validate_field_function(rec, resetable_fields.row(i)))
continue;
// azzeramento campi
rec.zero(resetable_fields.row(i));
}
}
// richiamo handler AFTER_RESET
if (_after_reset_function)
_after_reset_function(rec);
// registrazione record
if(!_removerec)
_file->rewrite();
}
// rabbocco indicatore progressivo
p.addstatus(pmax-pi);
// chiusura file
_file->close();
return err;
}

79
m770/resetfil.h Executable file
View File

@ -0,0 +1,79 @@
#ifndef __RESETFIL_H
#define __RESETFIL_H
#ifndef __ISAM_H
#include <isam.h>
#include <progind.h>
#endif
///////////////////////////////////////////////////////////
// TResetfile
///////////////////////////////////////////////////////////
// @doc EXTERNAL
// @type VALIDATE_RECORD | Prototipo funzione per validare se un record e' da azzerare.
typedef bool (*VALIDATE_RECORD)(const TRectype& rec);
// @type VALIDATE_FIELD | Prototipo funzione per validare se un campo e' da azzerare.
typedef bool (*VALIDATE_FIELD)(const TRectype& rec, const TString& fld);
// @type BEFORE_RESET | Prototipo funzione richiamata prima dell'azzeramento di un record.
typedef void (*BEFORE_RESET)(TRectype& rec);
// @type AFTER_RESET | Prototipo funzione richiamata dopo l'azzeramento di un record.
typedef void (*AFTER_RESET)(TRectype& rec);
// @class TResetfile | Classe per l'azzeramento di un file
//
// @base public | TObject
class TResetfile : public TObject
// @author:(INTERNAL) Luciano
// @access:(INTERNAL) Private Member
{
// @cmember:(INTERNAL) numero logico del file da azzerare
int _file_num;
// @cmember:(INTERNAL) file da azzerare
TSystemisamfile* _file;
// @cmember:(INTERNAL) effettuare remove dei record (default FALSE)
bool _removerec;
// @cmember:(INTERNAL) funzione di validate per azzerare un record
VALIDATE_RECORD _validate_record_function;
// @cmember:(INTERNAL) funzione di validate per azzerare un campo
VALIDATE_FIELD _validate_field_function;
// @cmember:(INTERNAL) funzione richiamata prima dell'azzeramento di un record
BEFORE_RESET _before_reset_function;
// @cmember:(INTERNAL) funzione richiamata dopo l'azzeramento di un record
AFTER_RESET _after_reset_function;
// @cmember:(INTERNAL) ritorna se il campo <p fd> è un campo chiave
bool iskeyfield(const RecDes& recd, const int fd) const;
// @cmember:(INTERNAL) ritorna e carica il numero campi da azzerare
int TResetfile::load_resetable_fields(const RecDes& recd,TString_array& resetable_fields);
// @access Public Member
public:
// @cmember setta la funzione di validate se record da azzerare
void set_validate_record_function(VALIDATE_RECORD fun)
{_validate_record_function = fun;}
// @cmember setta la funzione di validate se campo da azzerare
void set_validate_field_function(VALIDATE_FIELD fun)
{_validate_field_function = fun;}
// @cmember setta la funzione richiamata prima dell'azzeramento di un record
void set_before_reset_function(BEFORE_RESET fun)
{_before_reset_function = fun;}
// @cmember setta la funzione richiamata dopo l'azzeramento di un record
void set_after_reset_function(AFTER_RESET fun)
{_after_reset_function = fun;}
// @cmember esegue l'azzeramento del file
int run();
// @cmember Costruttore
TResetfile(int logicnum, bool remove = FALSE);
// @cmember Distruttore
virtual ~TResetfile();
};
#endif

105
m770/scandich.cpp Executable file
View File

@ -0,0 +1,105 @@
#include "scandich.h"
///////////////////////////////////////////////////////////
// TScandich
///////////////////////////////////////////////////////////
TScandich::TScandich(scantype type)
: _type(type),
_lasterr(NOERR)
{
// salvo codice dichiarazione in manutenzione
_dich_prec = get_firm_770();
switch (_type)
{
case _sel_dich:
_cnf_user = new TConfig(CONFIG_USER);
break;
case _all_dich:
_base_file = new TLocalisamfile(LF_BASE);
_base_file->setkey(1);
break;
default:
break;
}
}
TScandich::~TScandich()
{
switch (_type)
{
case _sel_dich:
delete _cnf_user;
break;
case _all_dich:
delete _base_file;
break;
default:
break;
}
// ripristino codice dichiarazione in manutenzione
set_firm_770(_dich_prec);
}
// @doc EXTERNAL
// @mfunc ritorna il codice della prima dichiarazione da elaborare
long TScandich::first()
{
// codice dichiarazione da restituire
long coddich = 0L;
// primo codice se richiesto _sel_dich
if (_type == _sel_dich)
{
_num_dich = 0;
coddich = _cnf_user->get_long(DITTE_SEL, "77", _num_dich++);
if (coddich == 0L)
_lasterr = _iseof;
}
// primo codice se richiesto _all_dich
if (_type == _all_dich)
{
_lasterr = _base_file->first();
if (_lasterr == NOERR)
coddich = _base_file->get_long("CODDITTA");
}
return coddich;
}
// @doc EXTERNAL
// @mfunc ritorna il codice della successiva dichiarazione da elaborare
long TScandich::next()
{
// codice dichiarazione da restituire
long coddich = 0L;
// codice successivo se richiesto _sel_dich
if (_type == _sel_dich)
{
coddich = _cnf_user->get_long(DITTE_SEL, "77", _num_dich++);
if (coddich == 0L)
_lasterr = _iseof;
}
// codice successivo se richiesto _all_dich
if (_type == _all_dich)
{
_lasterr = _base_file->next();
if (_lasterr == NOERR)
// se dichiarazione "dichiarante" forzo fine file
if (_base_file->get_char("TIPOQUA") == 'D')
_lasterr = _iseof;
else
coddich = _base_file->get_long("CODDITTA");
}
return coddich;
}

57
m770/scandich.h Executable file
View File

@ -0,0 +1,57 @@
#ifndef __SCANDICH_H
#define __SCANDICH_H
#include <isam.h>
#include "77lib.h"
///////////////////////////////////////////////////////////
// TScandich
///////////////////////////////////////////////////////////
// @doc EXTERNAL
// @enum scantype | Tipo di scansione da effettuare
enum scantype {
_sel_dich, // @emem Dichiarazioni selezionate
_all_dich }; // @emem Tutte le dichiarazioni
// @class TScandich | Classe per la scansione delle dichiarazioni da elaborare
//
// @base public | TObject
class TScandich : public TObject
// @author:(INTERNAL) Luciano
// @access:(INTERNAL) Private Member
{
// @cmember:(INTERNAL) tipo di scansione richiesta
scantype _type;
// @cmember:(INTERNAL) configurazione utente per dichiarazioni selezionate
TConfig* _cnf_user;
// @cmember:(INTERNAL) file base dichiarazioni
TLocalisamfile* _base_file;
// @cmember:(INTERNAL) codice dichiarazione in manutenzione da ripristinare
long _dich_prec;
// @cmember:(INTERNAL) indice della dichiarazione selezionata
int _num_dich;
// @cmember:(INTERNAL) codice ultimo errore
int _lasterr;
// @access Public Member
public:
// @cmember ritorna il codice della prima dichiarazione da elaborare
long first();
// @cmember ritorna il codice della successiva dichiarazione da elaborare
long next();
// @cmember ritorna se l'ultimo codice restituito era valido
bool good()
{return _lasterr == NOERR;}
// @cmember Costruttore
TScandich(scantype type = _sel_dich);
// @cmember Distruttore
virtual ~TScandich();
};
#endif