campo-sirio/src/fp/fp0500.cpp

#include <automask.h>
#include <defmask.h>
#include <relapp.h>
#include <tabutil.h>

#include "fp0.h"
#include "fp0500a.h"
#include "fplib.h"
#include "fpccaus.h"
#include "fpcart.h"
#include "fpcadg.h"
#include "fpcust.h"


//-------------------------------------------------------------------
//  MASCHERA (fp0500a)
//-------------------------------------------------------------------
class TFpcust_mask : public TAutomask
{      
protected:
	bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
public:

  TFpcust_mask();
};

bool TFpcust_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
	case F_GLOBAL:
		if(e == fe_modify)
		{
			const bool global = get_bool(F_GLOBAL);
			// Se <20> globale controllo che effettivamente non ce ne siano altri
			if(global)
			{
				TLocalisamfile fpcust(LF_FPCUST);
				fpcust.read(_isfirst);
				bool ok = true;
				for(;!fpcust.eof(); fpcust.next())
				{
					if (fpcust.get_bool(FPCUST_GLOBAL) && fpcust.get(FPCUST_CODICE) != get(F_CODICE))
					{
						ok = false;
						break;
					}
				}

				if(!ok)
				{
					warning_box("Esiste gi<67> un'altra configurazione globale");
					set(F_GLOBAL, "");
				}
			}
		}
  default:
    break;
  }  
  return true;
}

TFpcust_mask::TFpcust_mask() : TAutomask("fp0500a")
{
}

//--------------------------------------------------------------
//  APPLICAZIONE
//--------------------------------------------------------------
class TFpcust : public TRelation_application
{ 
  TFpcust_mask* _mask{ nullptr };
  TRelation* _rel{ nullptr };
	TFP_custom* _fpcust{ nullptr };

private:
	void init_insert_mode(TMask& m) override;

protected:
  int read(TMask& m) override;
  int write(const TMask& m) override;
  int rewrite(const TMask& m) override;

	void load_cust(const TMask& m) const;

  bool user_create() override;
  bool user_destroy() override;
  TMask* get_mask(int mode) override { return _mask; }
  bool changing_mask(int mode) override { return false; }

public:
  // @cmember Disabilita la verifica del modulo : essendo una anagrafica, va sempre abilitata
  bool check_autorization() const override { return true; }
  TRelation* get_relation() const override { return static_cast<TRelation*>(_rel); }
};


void TFpcust::init_insert_mode(TMask& m)
{
	// Presetto delle righe di default

	// Causale
	TToken_string& row_causale = m.sfield(F_CAUSALI).row(-1);
	row_causale.add("READ(%TIP, S0)");

	// Articoli
	TToken_string& row_articolo_interno = m.sfield(F_ARTICOLI).row(-1);
	row_articolo_interno.add("Codice articolo interno");
	row_articolo_interno.add("READ(34, CODARTMAG)");
	row_articolo_interno.add("READ(34, CODARTMAG) != \"\" && READ(34, CODART) != \"\"");

	TToken_string& row_articolo = m.sfield(F_ARTICOLI).row(-1);
	row_articolo.add("Codice articolo cliente");
	row_articolo.add("READ(34, CODART)");
	row_articolo.add("READ(34, CODARTMAG) != READ(34, CODART) && READ(34, CODART) != \"\"");
}

int TFpcust::read(TMask& m)
{
	TRelation_application::read(m);
	
	// Carico tutti gli sheet
	TFP_custom& fp_custom = dynamic_cast<TFP_custom&>(get_relation()->lfile().curr());

	TSheet_field& sheet_causali = m.sfield(F_CAUSALI);
	sheet_causali.destroy();
	FOR_EACH_FPCAUS_ROW(fp_custom, r, rcaus)
	{
		TToken_string& row = sheet_causali.row(-1);
		row.add(rcaus->get(FPCCAUS_VALORE), xvtil_cid2index(S_CAUS_VALORE));
		row.add(rcaus->get(FPCCAUS_COND), xvtil_cid2index(S_CAUS_COND));
	}

	TSheet_field& sheet_articoli = m.sfield(F_ARTICOLI);
	sheet_articoli.destroy();
	FOR_EACH_FPART_ROW(fp_custom, r, rart)
	{
		TToken_string& row = sheet_articoli.row(-1);
		row.add(rart->get(FPCART_TIPO), xvtil_cid2index(S_ART_TIPO));
		row.add(rart->get(FPCART_VALORE), xvtil_cid2index(S_ART_VALORE));
		row.add(rart->get(FPCART_COND), xvtil_cid2index(S_ART_COND));
	}

	TSheet_field& sheet_adg = m.sfield(F_ADG);
	sheet_adg.destroy();
	FOR_EACH_FPADG_ROW(fp_custom, r, radg)
	{
		TToken_string& row = sheet_adg.row(-1);
		row.add(radg->get(FPCADG_TIPODATO), xvtil_cid2index(S_ADG_TIPODATO));
		row.add(radg->get(FPCADG_RTESTO), xvtil_cid2index(S_ADG_RTESTO));
		row.add(radg->get(FPCADG_RNUMERO), xvtil_cid2index(S_ADG_RNUMERO));
		row.add(radg->get_date(FPCADG_RDATA), xvtil_cid2index(S_ADG_RDATA));
		row.add(radg->get(FPCADG_TIPORIGA), xvtil_cid2index(S_ADG_TIPORIGA));
		row.add(radg->get(FPCADG_COND), xvtil_cid2index(S_ADG_COND));
		row.add(radg->get(FPCADG_SPLIT), xvtil_cid2index(S_ADG_SPLIT));
	}

	return NOERR;
}

int TFpcust::write(const TMask& m)
{
	load_cust(m);
	return TRelation_application::write(m);
}

int TFpcust::rewrite(const TMask& m)
{
	load_cust(m);
	return TRelation_application::rewrite(m);
}

void TFpcust::load_cust(const TMask& m) const
{
	_fpcust->set_codcust(m.get(F_CODICE), false);
	_fpcust->autoload(m.sfield(F_CAUSALI), LF_FPCCAUS);
	_fpcust->autoload(m.sfield(F_ARTICOLI), LF_FPCART);
	_fpcust->autoload(m.sfield(F_ADG), LF_FPCADG);
}


bool TFpcust::user_create()
{
	open_files(LF_FPCUST, LF_FPCADG, LF_FPCART, LF_FPCCAUS, 0);
	_fpcust = new TFP_custom();
  _rel = new TRelation(LF_FPCUST);
	_rel->lfile().set_curr(_fpcust);
  _mask = new TFpcust_mask;

  return true;
}

bool TFpcust::user_destroy()
{             
  delete _mask;
  return true;
}

int fp0500(int argc, char* argv[])
{
  TFpcust a;
  a.run(argc, argv, TR("Personalizzazioni FP"));
  return 0;
}