campo-sirio/at/at0200.cpp

#include <applicat.h>
#include <execp.h>
#include <mask.h>
#include <msksheet.h>
#include <mailbox.h>
#include <prefix.h>
#include <progind.h>
#include <recarray.h>
#include <relation.h>
#include <tabutil.h>
#include <urldefid.h>
#include <validate.h>

#include "at0.h"
#include "lf.h"				// se non lo metto non riesco a usare gli LF

// nomi campi maschera
#include "at0200a.h"
          
// nomi dei campi
#include "soggetti.h"
#include "donaz.h"
#include "contsan.h"
#include "rconvoc.h"

#include "atlib.h"

#define ALIAS_CTD		100

class TDonaz_app : public TApplication
{
	TMask*					_msk;
	TRelation*   		_rel;
	
  TLocalisamfile* _soggetti;
	TLocalisamfile* _donaz;
	TLocalisamfile* _contsan;
	TLocalisamfile*	_rconvoc;
	TRecord_array*	_sdonazioni; 
	TRecord_array*	_scontrolli;
	TAssoc_array*		_asoggetti;	// array dei soggetti inseriti per controllare doppio ins.
	bool						_modified;
	
	
protected:
	virtual bool create();
	virtual bool destroy();
  virtual bool menu(MENU_TAG m);
	virtual TMask& get_mask() { return *_msk; }
	virtual TRelation* get_relation() const { return _rel; }
	
	TAssoc_array& get_array_sogg() { return *_asoggetti; }
	int write(TSheet_field& s);

	bool check_sog_sheet(const char* codsog);	
	static bool nome_handler(TMask_field& f, KEY k);
	static bool soggetti_notify(TSheet_field& s, int r, KEY k);
	void add_rows_soggetti(TSheet_field& s, int count = 20, int start = 0);
	static bool ins_controlli_handler(TMask_field& f, KEY k);

public:
	TDonaz_app() {}
	
};

HIDDEN inline TDonaz_app& app() { return (TDonaz_app&) main_app(); }

bool TDonaz_app::ins_controlli_handler(TMask_field& f, KEY  k)
{
	if (k == K_SPACE)
	{
		TMask& m = f.mask();
		TSheet_field& s = (TSheet_field&)m.field(F_SOGGETTI);
		const bool ins_controlli = m.get_bool(F_INS_CONTROLLI);
		s.enable_column(3,ins_controlli);
	}		
	return TRUE;	
}

void TDonaz_app::add_rows_soggetti(TSheet_field& s, int count, int start)
{
	if (start == 0)
		s.destroy();
	for (int r=start; r<=start+count-1; r++)
		TToken_string& row = s.row(r);
}
	
bool TDonaz_app::create()
{
	_modified = FALSE;
	_msk = new TMask("at0200a");
	_rel = new TRelation(LF_SOGGETTI);
  _rel->add("CTD", "CODTAB==CATDON",1,0,ALIAS_CTD);
	_donaz = new TLocalisamfile(LF_DONAZ);
	_contsan = new TLocalisamfile(LF_CONTSAN);
	_rconvoc = new TLocalisamfile(LF_RCONVOC);
	_sdonazioni = new TRecord_array(LF_DONAZ,DON_PROGDON);
	_scontrolli = new TRecord_array(LF_CONTSAN,CON_PROGCON);
	_asoggetti = new TAssoc_array();
	
	_msk->set_handler(F_INS_CONTROLLI,ins_controlli_handler);
	TSheet_field& ss = (TSheet_field&)_msk->field(F_SOGGETTI);
	ss.set_notify(soggetti_notify);
	
	ss.sheet_mask().set_handler(F_S_NOME,nome_handler);
  
  dispatch_e_menu(BAR_ITEM(1));
  
	return TRUE;
}	

bool TDonaz_app::destroy()	
{
	delete _rel;
	delete _msk;
	delete _donaz;
	delete _contsan;
	delete _rconvoc;
	delete _sdonazioni;
	delete _scontrolli;
	delete _asoggetti;
	return TRUE;
}

bool TDonaz_app::menu(MENU_TAG m)
{ 
	TMask& msk = get_mask();
	const TDate oggi(TODAY);
	KEY tasto;
	do
	{
		TSheet_field& s = (TSheet_field&)msk.field(F_SOGGETTI);
		s.reset();
		add_rows_soggetti(s);
		_asoggetti->destroy();
		msk.set(F_DATADON,oggi);
  	tasto = msk.run();
  	switch (tasto)
  	{
  		case K_ESC:		// annulla
  		{
  			if (_modified)
  				if (yesno_box("Registrare le modifiche?"))
  					TDonaz_app::write(s);
				_modified = FALSE;  					
				msk.reset();
			}	
  		break;
  		case K_SAVE:	// registra
  		{
  			TDonaz_app::write(s);
				_modified = FALSE;  					
  			msk.reset();
  		}  			
  		break;
  		case K_INS:		// nuovo
  		{
				TDonaz_app::write(s);  			
				_modified = FALSE;
				msk.reset();
			}	
  		break;
  		case K_QUIT:	// fine
  		{                   
  			if (_modified)
  				if (yesno_box("Registrare le modifiche?"))
  					TDonaz_app::write(s);
				msk.reset();
				_modified = FALSE;  					
  		}
  		break;
  	}	
  }	
	while (tasto != K_QUIT);
  return FALSE;
}  

int TDonaz_app::write(TSheet_field& s)
{ 
	
	const TMask& m = s.mask();
	const TDate data = m.get(F_DATADON);
	
  int items = s.items();
  TProgind *pi;
  pi = new TProgind(items,"Registrazione donazioni e controlli", FALSE, TRUE, 10);
  pi->setstatus(1);
	TLocalisamfile& sog = get_relation()->lfile();
	TLocalisamfile& rconv(LF_RCONVOC);
	for (int r=1; r<=s.items(); r++)
	{	
		
    pi->addstatus(1);
    
		TToken_string& row = s.row(r-1);
		const long codsog = row.get_long(0);
		if (codsog != 0)
		{
			//TLocalisamfile& sog = get_relation()->lfile();
			sog.setkey(1);
			sog.zero();
			sog.put(SOG_CODICE, codsog);
			int err = sog.read();
			if (err == NOERR)
			{ 
				const TString16 tipocon = row.get(3);
				if (!tipocon.blank())
				{
					TRectype* recc = new TRectype(LF_CONTSAN);
					recc->put(CON_CODICE, row.get(0));
					recc->put(CON_DATACON, m.get(F_DATADON));
					recc->put(CON_TIPOCON, row.get(3));
					bool insert = FALSE;
					bool exist =  FALSE;
					TRectype* keyc = new TRectype(LF_CONTSAN);
					keyc->put(CON_CODICE, row.get(0));
					int err = _scontrolli->read(keyc);
					if (err == NOERR)
					{
						int r=_scontrolli->rows();
						while (r>=1 && !insert && !exist)
						{
							const TRectype& riga = _scontrolli->row(r);
							const TDate d = riga.get(CON_DATACON);
							if (data==d)	// esiste gi<67> un controllo in questa data
							{
								exist=TRUE;
								r=0;
							}	 
							else
								if (data > d)
								{                            
									recc->put(CON_PROGCON,r+1);
									_scontrolli->insert_row(recc);
									insert=TRUE;
								}
							r--;						
						}
						if (!exist && !insert)
						{
							recc->put(CON_PROGCON,1);
							_scontrolli->insert_row(recc);
						}
					}	
					else
			  		if (err == _iseof || err == _isemptyfile)
			  		{
							recc->put(CON_PROGCON,1);
							_scontrolli->insert_row(recc);		  	
						}
					if (!exist)					
						_scontrolli->write(TRUE);
				}						
				
				TRectype* rec = new TRectype(LF_DONAZ);
				rec->put(DON_CODICE, row.get(0));
				rec->put(DON_DATADON, m.get(F_DATADON));
				rec->put(DON_TIPODON, m.get(F_TIPODON));
				rec->put(DON_LUOGODON, m.get(F_LUOGODON));
				rec->put(DON_ETICHETTA, row.get(4));
				
				rec->put(DON_CODSEZ,sog.get(SOG_CODSEZ));
				rec->put(DON_CODSOT,sog.get(SOG_CODSOT));

				bool insert = FALSE;
				bool exist = FALSE;
			
				TRectype* key = new TRectype(LF_DONAZ);
				key->put(DON_CODICE, row.get(0));
				err = _sdonazioni->read(key);
				if (err == NOERR)
				{
					int r=_sdonazioni->rows();
					while (r>=1 && !insert && !exist)
					{
						const TRectype& riga = _sdonazioni->row(r);
						const TDate d = riga.get(DON_DATADON);
						if (data==d)	// esiste gia' una donazione in questa data
						{
							exist=TRUE;
							r=0;
						}	 
						else
							if (data > d)
							{                            
								rec->put(DON_PROGDON,r+1);
								_sdonazioni->insert_row(rec);
								insert=TRUE;
							}
						r--;						
					}
					if (!exist && !insert)
					{
						rec->put(DON_PROGDON,1);
						_sdonazioni->insert_row(rec);
					}	
				}	
				else
			  	if (err == _iseof || err == _isemptyfile)
			  	{
						rec->put(DON_PROGDON,1);
						_sdonazioni->insert_row(rec);		  	
					}
				if (!exist)					
				{				
					_sdonazioni->write(TRUE);
									
					// se ha una convocazione successiva alla donazione,
					// va cancellata, anche dall'archivio convocazioni
					TDate dataultdon = sog.get_date(SOG_DATAULTDON);
					TDate dataconv = sog.get_date(SOG_DATACONV);
					if (dataultdon >= dataconv)
					{
						rconv.setkey(2);
						rconv.zero();
						rconv.put(RCV_DATACONV, dataconv);
						rconv.put(RCV_CODICE, codsog);
						int err = rconv.read();
						if (err == NOERR)
						{
							rconv.put(RCV_ANNULLATO,TRUE)						
							rconv.rewrite();
						}							
						sog.put(SOG_DATACONV, NULLDATE);
						sog.put(SOG_DATAULTSOL, NULLDATE);
						const int zeroconv = 0;
						sog.put(SOG_NUMCONV, zeroconv);
					}
				  // controllo se <20> idoneo
					
					const TString16 tipo = m.get(F_TIPODON);
					int totdon = sog.get_int(SOG_TOTDON);
					sog.put(SOG_TOTDON,totdon+1);
					if (data > dataultdon)
					{            
						sog.put(SOG_DATAULTDON,data);
						sog.put(SOG_TIPOULTDON,tipo);
					} 
 					if (is_donaz(tipo,IDON_SI))
 					{
 						totdon = sog.get_int(SOG_TOTDONSI);
 						sog.put(SOG_TOTDONSI,totdon+1);
 						dataultdon = sog.get_date(SOG_DATAULTSI);
 						if (data>dataultdon)
 							sog.put(SOG_DATAULTSI,data);
					}
 					if (is_donaz(tipo,IDON_AF))
 					{
 						totdon = sog.get_int(SOG_TOTDONAF);
 						sog.put(SOG_TOTDONAF,totdon+1);
 						dataultdon = sog.get_date(SOG_DATAULTAF);
 						if (data>dataultdon)
 							sog.put(SOG_DATAULTAF,data);
					}
					char modstato = ' ';     
					const TString16 stato = sog.get(SOG_STATO);	// stato attuale
					const TString16 id1 = sog.get(SOG_IDON1);		// idon. 1
					const TString16 id2 = sog.get(SOG_IDON2);		// idon. 2
					const TString16 id3 = sog.get(SOG_IDON3);		// idon. 3
					const TString16 id4 = sog.get(SOG_IDON4);	  // idon. 4
					const int intsi = sog.get_int(SOG_INTSI);		// intervallo per SI
					const int intaf = sog.get_int(SOG_INTAF);		// intervallo per AF
					dataultdon = sog.get_date(SOG_DATAULTDON);	// data ultima donazione
					const TString16 tipoultdon(sog.get(SOG_TIPOULTDON));	// tipo ultima donazione
					TDate datasi(NULLDATE);		// data prossima si calcolata
					TDate dataaf(NULLDATE);		// data prossima af calcolata
					TDate dataultsi(NULLDATE);	// data ultima donazione si
					
					bool id_si = FALSE;		// il soggetto <20> idoneo per si?
					bool id_af = FALSE;		// il soggetto <20> idoneo per af?
					
				  modstato = modstato_tcs(stato);
					if (modstato == 'I' || modstato == 'F')	// il soggetto <20> idoneo
					{ 
						id_si = (is_idon(id1,id2,id3,id4,IDON_SI) && intsi != 0);		// il soggetto <20> idoneo SI
						id_af = (is_idon(id1,id2,id3,id4,IDON_AF) && intaf != 0);		// il soggetto <20> idoneo AF
						
						if (dataultdon.ok())		// se ha fatto almeno una donazione
						{
							if (is_donaz(tipoultdon,IDON_SI))	// se l'ultima donazione <20> una SI
							{
								if (id_si) 
								{
									datasi=dataultdon;
									datasi+=intsi;
								}	
				  			if (id_af) 
				  			{
				  				dataaf=dataultdon;
				  				dataaf+=intaf;
				  			}	
				      }
				      if (is_donaz(tipoultdon,IDON_AF))	// se l'ultima donazione <20> una AF
				      {
				      	dataultsi = sog.get_date(SOG_DATAULTSI);
								if (id_si)
								{
									if (intaf != 0)
									{
										datasi=dataultdon; 
										datasi+=intaf;
									}	
									else
									{
										datasi=dataultdon;
									  datasi+=intsi;    
									}  
									if (dataultsi.ok())
										dataultsi+=intsi;
									if (dataultsi > datasi)
										datasi = dataultsi;
								}
								if (id_af)
								{
									dataaf=dataultdon;
									dataaf+=intaf;
								}					
				      }	
				 		}
				 		else
				 		{
				 			if (id_si)
				 				datasi=sog.get_date(SOG_DATAULTID);
				 			if (id_af)
				 				dataaf=sog.get_date(SOG_DATAULTID); 				
				 		}
					}	
					sog.put(SOG_DATAPROSSI,datasi);
					sog.put(SOG_DATAPROSAF,dataaf);
				  
				  // controllo la sua categoria
				  // se dimesso diventa della categoria collegata
				  // se non c'e' la categoria collegata ???
				  
    			TTable ctd("CTD"); 
    			TString16 catdon = sog.get(SOG_CATDON);
    			ctd.put("CODTAB",catdon);
    			if (ctd.read() == NOERR)
    			{
    				bool dimissione = ctd.get_bool("B0");
						if (dimissione)
							sog.put(SOG_CATDON,ctd.get("S6"));		    				
				  }
				  
				  // aggiorno data e utente ultimo aggiornamento
				  sog.put(SOG_DATAULTAGG,TODAY);
				  sog.put(SOG_UTENULTAGG,user());
				  
					sog.rewrite();
				}					
			}				
		}														
	}

  delete pi;
	
	return NOERR;	
}

bool TDonaz_app::check_sog_sheet(const char* codsog)
{ 
	TAssoc_array& array_sogg = app().get_array_sogg();
	if (array_sogg.is_key(codsog))
		return FALSE;
	else
		return TRUE;
}		

bool TDonaz_app::soggetti_notify(TSheet_field& s, int r, KEY k)
{              
	bool ok = TRUE;
	switch (k)
	{ 
		case K_CTRL+K_DEL:
		// avvenuta cancellazione riga
		break;
		case K_SPACE:
		// inizio modifica riga
		break;
		case K_TAB:
		// entrata riga			
		{
			if ((r == s.items()-1) && (r == s.first_empty()))
			{
				app().add_rows_soggetti(s,10,r+1);
				s.select(r);
			} 
			TToken_string& row = s.row(r);
			if (row.empty_items())
				s.set_focus_cell(r,1);
		}
	  break;
		case K_ENTER:
		// uscita da riga modificata
		case K_CTRL+K_TAB:
		// uscita riga
		{
			app()._modified = TRUE;
			TToken_string& row = s.row(r);
			const long codsog = row.get_long(0);
			if (codsog != 0)
				for (int i=s.items()-1; i>=0; i--)
				{
					if (i != r)
					{
						TToken_string& row = s.row(i); 
						if (codsog == row.get_long(0))
							return s.sheet_mask().field(F_S_CODICE).error_box("Soggetto gia' inserito");
					}					
				}				
			else
			{
				const char* cognome = row.get(1);
				if ((cognome != NULL) && (cognome != "\0"))
				{
					s.sheet_mask().field(F_S_NOME).set_focusdirty();
					s.set_focus_cell(r,2);
				}						
			}
			s.force_update(r);
			if (r == s.items()-1)
			{
				app().add_rows_soggetti(s,10,r+1);
				s.select(r);
			}
		}
	  break;  	
	}  
  return ok;  
}

bool TDonaz_app::nome_handler(TMask_field& f, KEY k)
{
	bool ok = TRUE;
  //if (k == K_TAB && f.focusdirty())
  if (f.to_check(k))
  {
  	TMask& m = f.mask();
  	long codsog = m.get_long(F_S_CODICE);
  	if (codsog == 0)
      f.on_key(K_F9);
  }	
  return ok;
}

		
int at0200(int argc, char* argv[])
{
	TDonaz_app a;
	a.run(argc, argv, "Giornaliero donazioni/controlli");
	return 0;
}