campo-sirio/ve/ve2200.cpp

#include <relapp.h>
#include <config.h>
#include <tabutil.h>

#include "ve2200.h"



class TCondizioni_vendita: public TRelation_application {
	  TMask *_msk; // maschera principale
  	TRelation *_rel; // relazione principale

		TString16 _condven; // stringa che indica il tipo di archivio
		TBit_array _tohide; // vettore degli identificatori di campi che devono essere nascosti
    bool _catven_on; // booleano di abilitazione del campo CATVEN
    
	  virtual bool user_create();
  	virtual bool user_destroy();                        
	  virtual TMask *get_mask(int) { return _msk; }
  	virtual bool changing_mask(int) { return FALSE; }
	  virtual TRelation *get_relation() const { return _rel; }

		static bool handler_datacam(TMask_field &, KEY); // handler del campo DATACAM (data cambio)
		static bool handler_valfin(TMask_field &, KEY); // handler del campo VALFIN (data fine validità)
		static bool handler_codlissucc(TMask_field &, KEY); // handler del campo CODLISSUCC (codice listino successivo)
		static bool handler_seqric(TMask_field &, KEY); // handler del campo SEQRIC (sequenza di ricerca)

	  virtual int write(const TMask &); // metodo usato per scrivere il record sul file
  	virtual int rewrite(const TMask &); // metodo usato per aggiornare il record sul file
	
	  virtual void init_query_mode(TMask &); // handler chiamato quando la maschera passa in modo ricerca
  
  public:
	  TCondizioni_vendita() {}
  	virtual ~TCondizioni_vendita() {}
};



bool TCondizioni_vendita::user_create() {
	bool gotcha= FALSE; // booleano di avvenuta inizializzazione
	
	_condven= "*"; // inizializzazione dell'indicatore del tipo di archivio
	if (argc()>2) _condven= argv(2); // se c'è, prende il tipo di archivio dalla linea di comando
	else {
		TMask choose("VE2200"); // istanzia la maschera di scelta del tipo di archivio
		if (choose.run() == K_ENTER) _condven= choose.get(F_TIPOCV); // prende il tipo di archivio dalla maschera
	}
	_condven.upper(); // rende la stringa upper-case
	_msk= new TMask("VE2200X");
	switch (_condven[0]) {
		case 'L': { // listini
			// settaggio dei campi da eliminare
			_tohide.set(F_C_COD);
			_tohide.set(F_O_COD);
			_tohide.set(F_C_TIPOCF);
			_tohide.set(F_C_CODCF);
			_tohide.set(F_C_OBBLIG);
      set_search_field(F_L_COD); // impostazione del campo di ricerca
			TConfig prassid(CONFIG_DITTA, "ve"); // apre il file di configurazione della ditta corrente
			_catven_on= (toupper(prassid.get("CATVEN_ON")[0])!='T'); // setta il booleano di abilitazione di CATVEN
			_msk->set_handler(F_L_CODLISSUCC, handler_codlissucc); // setta l'handler per il campo di codice successivo
 			gotcha= TRUE;
			break;
		}
		case 'C': // contratti
			// settaggio dei campi da eliminare
			_tohide.set(F_L_COD);
			_tohide.set(F_O_COD);
			_tohide.set(F_L_CATVEN);
			_tohide.set(F_L_CODLISSUCC);
      set_search_field(F_C_COD); // impostazione del campo di ricerca
 			gotcha= TRUE;
			break;
		case 'O': // offerte
			// settaggio dei campi da eliminare
			_tohide.set(F_L_COD);
			_tohide.set(F_C_COD);
			_tohide.set(F_L_CATVEN);
			_tohide.set(F_C_TIPOCF);
			_tohide.set(F_C_CODCF);
			_tohide.set(F_C_OBBLIG);
			_tohide.set(F_L_CODLISSUCC);
			set_search_field(F_O_COD); // impostazione del campo di ricerca
 			gotcha= TRUE;
			break;		
		default: // messaggio di errore se si indica un archivio non valido
			error_box("Indicare l'archivio sulla linea di comando (L, C o O) oppure selezionarla dalla maschera di partenza");
			break;
	}
	if (gotcha) { // se è stato selezionato correttamente un archivio completa l'inizializzazione
		_rel= new TRelation(LF_CONDV); // apre la relazione (un unico file)
		_msk->set_handler(F_DATACAM, handler_datacam); // imposta l'handler per il campo della data del cambio
		_msk->set_handler(F_VALFIN, handler_valfin); // imposta l'handler per il campo di fine validità
		_msk->set_handler(F_SEQRIC, handler_seqric); // imposta l'handler per il campo di sequenza di ricerca
	}
	return (gotcha);
}

bool TCondizioni_vendita::user_destroy() {
  delete _rel;
  delete _msk;
  return TRUE;
}

bool TCondizioni_vendita::handler_datacam(TMask_field &fld, KEY k) {
	if (k==K_TAB) { // ad ogni perdita di fuoco viene tentato un accoppiamento tra valuta e data per ottenere il cambio preciso
		TString datacam(fld.get()); // legge la data di cambio nel campo corrente
		if (datacam.not_empty()) {
			TMask &m= fld.mask(); // prende la maschera principale
			TString codval(m.get(F_CODVAL)); // prende il codice della valuta
			if (codval.not_empty()) {
				TTable cam("CAM"); // apre la tabella cambi
				cam.put("CODTAB", codval << datacam); // riempie la chiave
				if (cam.read() == NOERR) m.set(F_CAMBIO, cam.get("R10")); // se la lettura riesce il valore del cambio viene posto nel campo CAMBIO della maschera
			}
		}
	}
	return TRUE;
}

bool TCondizioni_vendita::handler_valfin(TMask_field &fld, KEY k) {
	if (k==K_TAB) {
		if (fld.get().not_empty()) {
			TMask &m= fld.mask(); // prende la maschera principale
			if (m.get(F_VALIN).not_empty()) {
				TDate valfin(fld.get()); // prende la data di fine validità
				TDate valin(m.get(F_VALIN)); // prende la data di inizio validità
				if (valfin<valin) {
					error_box("La data di inizio validità deve essere minore della data di fine");
					return FALSE;
				} else return TRUE;
			} else return TRUE;
		} else return TRUE;
	} else return TRUE;
}

bool TCondizioni_vendita::handler_codlissucc(TMask_field &fld, KEY k) {
	if (k==K_TAB) {
		TString codlissucc(fld.get()); // prende il codice listino successivo dal campo corrente
		if (codlissucc.not_empty()) {
			TMask &m= fld.mask(); // prende la maschera principale
			TString cod(m.get(F_L_COD)); // prende il codice listino corrente dalla maschera
			if (codlissucc == cod) {
				error_box("Il codice del listino successivo deve essere diverso dal codice del listino corrente");
				return FALSE;
			} else return TRUE;
   	} else return TRUE;
	} else return TRUE;
}

bool TCondizioni_vendita::handler_seqric(TMask_field &fld, KEY k) {
	if (k==K_TAB) {
		TString &seqric= fld.get(); // prende la stringa contenenta la sequenza di ricerca dal campo corrente
		if (seqric.not_empty()) {
			bool gotcha= TRUE; // flag di validità della sequenza
			for (int i=0; i<seqric.len(); i++) {
				char c= toupper(seqric[i]); // prende la lettera corrente della sequenza
				if ((c!='A') && (c!='G') && (c!='R')) gotcha= FALSE; // se la lettera non rientra tra quelle possibili abbassa il flag di validità
				for (int j= i+1; j<seqric.len(); j++) if (c== toupper(seqric[j])) gotcha= FALSE; // se la lettera compare anche più avanti nella sequenza abbassa il flag di validitià
				if (!gotcha) break; // se il flag di validità è basso esce anticipatamente
			}
			if (!gotcha) error_box("La sequenza di ricerca deve essere una combinazine di 'A' (Articoli), 'G' (Gruppi merceologici) e 'R' (Raggruppamenti fiscali), in cui ogni lettera compare al massimo una volta");
			return (gotcha);
	  } else return TRUE;
	} else return TRUE;
}
		
int TCondizioni_vendita::write(const TMask &m) {
  m.autosave(_rel); // scrive il contenuto della maschera nel record della relazione
	if (_condven != "C") { // se non si sta lavorando sui contratti il campo TIPOCF deve essere svuotato sul file
 		TLocalisamfile &f= _rel->lfile(); // prende il file principale della relazione
		TRectype &r= f.curr(); // prende il record corrente del file principale
		f.zero("TIPOCF"); // svuota il campo TIPOCF
	}
  _rel->write(); // invoca la scrittura della relazione
  return (_rel->status()); // ritorna lo stato della relazione
}

int TCondizioni_vendita::rewrite(const TMask &m) {
  m.autosave(_rel); // scrive il contenuto della maschera nel record della relazione
	if (_condven != "C") { // se non si sta lavorando sui contratti il campo TIPOCF deve essere svuotato sul file
 		TLocalisamfile &f= _rel->lfile(); // prende il file principale della relazione
		TRectype &r= f.curr(); // prende il record corrente del file principale
		f.zero("TIPOCF"); // svuota il campo TIPOCF
	}
  _rel->rewrite(); // invoca la riscrittura della relazione
  return (_rel->status()); // ritorna lo stato della relazione
}

void TCondizioni_vendita::init_query_mode(TMask &m) {
	for (short i=(short)_tohide.first_one(); i<=(short)_tohide.last_one(); i++) {
		if (_tohide[i]) {
			if (_msk->field(i).is_edit()) _msk->efield(i).check_type(CHECK_NORMAL); // disabilita il checking sul campo se è editabile
			_msk->hide(i); // rende invisibile il campo
		}
	}
	if (!_catven_on) { // se il booleano di abil. di CATVEN è falso...
		_msk->efield(F_L_CATVEN).check_type(CHECK_NONE); // ...viene rimosso dal checking...
		_msk->disable(F_L_CATVEN); // ...e disabilitato
	}
	_msk->set(F_TIPO, _condven); // settaggio del campo di tipo archivio
}

int ve2200(int argc, char* argv[]) {
  TCondizioni_vendita a;
  
  a.run(argc, argv, "Condizioni di vendita ");
  return 0;
}