// 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"

// definizione campi del form 
#define HODD_ANNODIC		1 
#define FODD_TODAY			1


// 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;    
  
  // 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;
	
  return TRUE;  
}

// creazione istanze d'azzeramento
void TAzzeramento_archivi::azzera_create(const bool azzsch, const bool azzqua)
{
  // richiesto azzeramento schede percipienti
	if (azzsch)
	{
  	_logschede 			= new TIsamtempfile(LF_SCPERC,"LOGAZZ",TRUE);
  	_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 _logschede;
		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()
{
	// istanza file di log
	TIsamtempfile* logschede = new TIsamtempfile(LF_SCPERC,"LOGAZZ",FALSE);
	
	// 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);
  }   
                               
  // rimozione istanza file di log
  delete logschede;
                               
  // 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()
{
	// istanza form
	TForm log_form("77logazz");
  // sostituisce lfile originale con lfile di log
  log_form.relation()->replace(new TIsamtempfile(LF_SCPERC,"LOGAZZ",FALSE));
	// set anno dichiarazione
	TForm_item& hodd_annodic = log_form.find_field('H',odd_page,HODD_ANNODIC);	
	hodd_annodic.set(_msk->get(F_ANNODIC));
	// set footer standard prassi
	TForm_item& fodd_today = log_form.find_field('F',odd_page,FODD_TODAY);	
	fodd_today.set(_msk->get(F_DATASCH));
	// stampa form
	log_form.print();
}

// elabora tutte le dichiarazioni
void TAzzeramento_archivi::elab_tutte(const bool azzsch, const bool azzqua)
{ 
  // esistono schede loggate
  bool logged_schede = FALSE;
  
  // 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();                       
  	
  	// esistono schede loggate!
  	logged_schede = !_logschede->empty();
  }	
  
  // 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);
  
  // handle log schede percipienti
  if (logged_schede)
  	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;
}