campo-sirio/ca/ca3100.cpp

#include <applicat.h>
#include <execp.h>
#include <reprint.h>

#include "movana.h"
#include "rmovana.h"

#include "ca3.h"
#include "ca3100.h"
#include "calib01.h"
#include "calib02.h"

////////////////////////////////////////////////////////
//	MASCHERA
////////////////////////////////////////////////////////
class TPrint_movimenti_ca_mask : public TAutomask
{
protected:
  bool on_field_event(TOperable_field& o, TField_event e, long jolly);
	const TString& get_compatible_library() const; 
  bool test_compatible_report();
	void create_page2();
	int create_page2_sheet(int lf, int& y, short& dlg, bool required);
public:
  TPrint_movimenti_ca_mask();
  virtual ~TPrint_movimenti_ca_mask() {}
};

const TString& TPrint_movimenti_ca_mask::get_compatible_library() const
{
  TString& lib = get_tmp_string();
  lib = "ca3100";
  const int stp = get_int(F_TIPOSTAMPA);
  lib << (stp == 1 ? 'a' : 'b');   // tipo di report da usare
  return lib;
}

bool TPrint_movimenti_ca_mask::test_compatible_report()
{
  TFilename lib = get_compatible_library();
  const TString& name = get(F_REPORT);
  bool ok = name.not_empty();
  if (ok)
  {
    TReport rep; 
    ok = rep.load(name);
    if (ok)
    {
      TToken_string& libraries = rep.get_libraries();
      ok = libraries.get_pos(lib) >= 0;
    }
  }
  if (!ok)
  {
    set(F_REPORT, lib);
    lib.ext("rep");
    ok = lib.custom_path();
  }
  return ok;
}

bool TPrint_movimenti_ca_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
	case F_TIPOSTAMPA:
		if (e == fe_init || e == fe_modify)
		{
			test_compatible_report();	//in base al tipo stampa setta i report compatibili
		}
		break;
  case F_REPORT:
    if (e == fe_button)
    {
      const TString8 lib = get_compatible_library();
      TFilename path = o.get();
      if (select_custom_file(path, "rep", lib))
      {
        path = path.name();
        path.ext("");
        o.set(path);
      }
    } else
    if (e == fe_close)
    {
      if (!test_compatible_report())
        return error_box(TR("Impossibile trovare un report compatibile"));
    }
    break;
	case F_DATAINI:
	case F_DATAFIN:
		if (e == fe_close)
		{
			const TString& anno = get(F_ANNO);
			if (anno.not_empty())	//se l'anno esercizio esiste...
			{
				const TRectype& esc = cache().get("ESC", anno);
				const TDate datainiesc = esc.get("D0");
				const TDate datafinesc = esc.get("D1");
				if (o.empty())
				{
					const TDate dataesc = o.dlg() == F_DATAINI ? datainiesc : datafinesc;
					o.set(dataesc.string());
				}
				else
				{
					const TDate d = o.get();
					if (d < datainiesc || d > datafinesc)
						return error_box(TR("La data deve essere compresa nell'esercizio selezionato"));
				}
			}
		}
		break;

  default: break;
  }
	return true;
}

int TPrint_movimenti_ca_mask::create_page2_sheet(int lf, int& y, short& dlg, bool required)
{
	TSheet_field& sf = sfield(F_RIGHE);
  TMask& sm = sf.sheet_mask();

  const int h = ca_create_fields(sm, 0, lf, 1, y, dlg, dlg+50);

  for (int i = 0; i < h; i++)
  {
    TEdit_field& fld = sm.efield(dlg+i);
    int logic = lf;
    if (logic == LF_FASI)
    {
      const TMultilevel_code_info& fasinfo = ca_multilevel_code_info(LF_FASI);
      if (fasinfo.parent() != 0)
      {
        const TMultilevel_code_info& parinfo = ca_multilevel_code_info(fasinfo.parent());
        if (i < parinfo.levels())
          logic = fasinfo.parent();
      }
    }

    const char* fieldname = NULL;
    switch(logic)
    {
    case LF_CDC     : fieldname = RMOVANA_CODCCOSTO; break;
    case LF_COMMESSE: fieldname = RMOVANA_CODCMS;   break;
    case LF_FASI    : fieldname = RMOVANA_CODFASE;  break;
    default         : fieldname = RMOVANA_CODCONTO; break;
    }
    TFieldref* f = (TFieldref*)fld.field();
    f->set_name(fieldname);
    
    fld.check_type(required ? CHECK_REQUIRED : CHECK_NORMAL);

    TEdit_field& dfld = sm.efield(dlg+50+i);
    dfld.set_field(EMPTY_STRING); // Toglie campi che fan saltare gli output!
  }

  y += h+1;
  dlg += h;

  return h;
}

void TPrint_movimenti_ca_mask::create_page2()
{
	TSheet_field& sf = sfield(F_RIGHE);
  TMask& sm = sf.sheet_mask();
  sm.hide(-1);

  const TMultilevel_code_info& fasinfo = ca_multilevel_code_info(LF_FASI);

  TConfig_anal ini;
  const bool fsc_req = ini.get_bool("FscRequired");

  int y = 1;
  short dlg = S_CDC1 + 100; // id del primo campo da generare

  for (int i = 0; i < 2; i++)
  {
    const TString& level = ini.get("Level", NULL, i+1);  // Legge il livello 1 o 2
    if (level == "CDC")                                  // Crea centro di costo 
    {
      if (fasinfo.parent() == LF_CDC)
        create_page2_sheet(LF_FASI, y, dlg, fsc_req);
      else
      {
        const bool cdc_req = ini.get_bool("CdcRequired");
        create_page2_sheet(LF_CDC, y, dlg, cdc_req);
      }
    } else
    if (level == "CMS")                                   // Crea commessa
    {
      if (fasinfo.parent() == LF_COMMESSE)
        create_page2_sheet(LF_FASI, y, dlg, fsc_req);
      else
      {
        const bool cms_req = ini.get_bool("CmsRequired");
        create_page2_sheet(LF_COMMESSE, y, dlg, cms_req);
      }
    }
  }

  if (fasinfo.levels() > 0 && fasinfo.parent() <= 0)
    create_page2_sheet(LF_FASI, y, dlg, fsc_req);

	for (short id = S_CDC12+100; id >= S_CDC1+100; id--)
  {
    const int pos = sm.id2pos(id);
    if (pos >= 0)
    {
      TMask_field& f = sm.fld(pos);
      const int size = f.size();
      const TString& prompt = f.prompt();
      sf.set_column_header(id, prompt);
      sf.set_column_justify(id, f.is_kind_of(CLASS_REAL_FIELD));
      sf.set_column_width(id, (max(3+size, prompt.len()+1)) * CHARX);
    }
    else
      sf.delete_column(id);
	}
}


TPrint_movimenti_ca_mask::TPrint_movimenti_ca_mask()
								:TAutomask("ca3100")
{
	TConfig_anal cfg;
	const bool use_pdcc = cfg.get_bool("UsePdcc");

	const int logicnum = use_pdcc ? LF_PCON : LF_PCONANA;

	// creazione dei campi della seconda pagina della maschera
	create_page2();
}


///////////////////////////////////////////////////////////
//	RECORDSET
///////////////////////////////////////////////////////////

class TPrint_movimenti_ca_recordset : public TISAM_recordset
{
	int _anno;
  TDate _dadata, _adata;
  char _tipomov;
	long _danumreg, _anumreg;
	TString4 _dacaus, _acaus;
  TString _codcosto, _codcms, _codfas;

protected:
  static bool mov_filter(const TRelation* rel);
  bool valid_record(const TRelation& rel) const;

  virtual void set_custom_filter(TCursor& cur) const;

public:
  void set_filter(const TPrint_movimenti_ca_mask& msk, int cms_row);
  TPrint_movimenti_ca_recordset(const TString& sql) : TISAM_recordset(sql) { }
};

static const TPrint_movimenti_ca_recordset* myself = NULL;

//metodo per riconoscere se il record corrente soddisfa i filtri della maschera...strafighissimo!
bool TPrint_movimenti_ca_recordset::valid_record(const TRelation& rel) const
{
	//prima controlla la testata...
  const TRectype& mov = rel.curr(LF_MOVANA);
  
	const char* datefld = _anno > 0 ? MOVANA_DATACOMP : MOVANA_DATAREG;
  const TDate data = mov.get(datefld);
  if (data < _dadata || (_adata.ok() && data > _adata))
    return false;

	const TString& codcaus = mov.get(MOVANA_CODCAUS);
  if (codcaus < _dacaus || (_acaus.not_empty() && codcaus > _acaus))
    return false;

	if (_tipomov > ' ')
	{
		const char tipomov = mov.get_char(MOVANA_TIPOMOV);
		if (tipomov != _tipomov)
			return false;
	}

	//..poi le righe (devono comparire solo le righe con cdc/cms/fsc che appaiono nello sheet)
	const TRectype& rmov = rel.curr(LF_RMOVANA);

  if (_codcosto.not_empty())
  {
    const TString& cos = rmov.get(RMOVANA_CODCCOSTO);
    if (cos != _codcosto)
      return false;
  }
  if (_codcms.not_empty())
  {
    const TString& cms = rmov.get(RMOVANA_CODCMS);
    if (cms != _codcms)
      return false;
  }
  if (_codfas.not_empty())
  {
    const TString& fas = rmov.get(RMOVANA_CODFASE);
    if (fas != _codfas)
      return false;
	}

  return true;
}

bool TPrint_movimenti_ca_recordset::mov_filter(const TRelation* rel)
{
  return myself->valid_record(*rel);
}

void TPrint_movimenti_ca_recordset::set_custom_filter(TCursor& cur) const
{
  myself = this;
  cur.set_filterfunction(mov_filter, true);
}

//metodo per caricare i valori nel recordset dalla maschera...fighissimo!!
void TPrint_movimenti_ca_recordset::set_filter(const TPrint_movimenti_ca_mask& msk, int cms_row)
{
  _codcosto = _codcms = _codfas = "";
  if (cms_row >= 0)
  {
    TSheet_field& sf = msk.sfield(F_RIGHE);
    TMask& sm = sf.sheet_mask();
    sf.update_mask(cms_row);
    TRelation rel(LF_RMOVANA);
    sm.autosave(rel);
    _codcosto = rel.curr().get(RMOVANA_CODCCOSTO);
    _codcms = rel.curr().get(RMOVANA_CODCMS);
    _codfas = rel.curr().get(RMOVANA_CODFASE);
  }

  _dadata = msk.get_date(F_DATAINI);
  _adata = msk.get_date(F_DATAFIN);

	_dacaus = msk.get(F_CAUSALEINI);
	_acaus = msk.get(F_CAUSALEFIN);

	_tipomov = msk.get(F_TIPOMOV)[0];
}



////////////////////////////////////////////////////////
//	REPORT
////////////////////////////////////////////////////////
class TPrint_movimenti_ca_rep : public TAnal_report
{
	int _anno;

protected:
	virtual bool set_recordset(const TString& sql);
	virtual bool get_usr_val(const TString& name, TVariant& var) const;

public:
	void set_filter(const TPrint_movimenti_ca_mask& msk, int cms_row);
};

bool TPrint_movimenti_ca_rep::get_usr_val(const TString& name, TVariant& var) const
{
	if (name == "#ESERCIZIO")
	{
		var.set(_anno);
		return true;
	}
	return TAnal_report::get_usr_val(name, var);
}

bool TPrint_movimenti_ca_rep::set_recordset(const TString& sql)
{
  TPrint_movimenti_ca_recordset* rs = new TPrint_movimenti_ca_recordset(sql);
  return TReport::set_recordset(rs);
}

void TPrint_movimenti_ca_rep::set_filter(const TPrint_movimenti_ca_mask& msk, int cms_row)
{
	_anno = msk.get_int(F_ANNO);
  TPrint_movimenti_ca_recordset* rs = (TPrint_movimenti_ca_recordset*)recordset();
  rs->set_filter(msk, cms_row);
}


////////////////////////////////////////////////////////
//	APPLICAZIONE
////////////////////////////////////////////////////////
class TPrint_movimenti_ca : public TSkeleton_application
{
	TPrint_movimenti_ca_mask * _mask;

protected:
	bool create();
	bool destroy();

public:
  virtual void main_loop();
};

bool TPrint_movimenti_ca::create()
{
  _mask = new TPrint_movimenti_ca_mask;  
  return TSkeleton_application::create();
}

bool TPrint_movimenti_ca::destroy()
{
  delete _mask;
  return TSkeleton_application::destroy();
}

void TPrint_movimenti_ca::main_loop()
{
  while (_mask->run() == K_ENTER)
  {
		//costruzione della query x il report in base ai parametri della maschera
		TSheet_field& sheet = _mask->sfield(F_RIGHE);
		const int n_righe_sheet = sheet.items();
		//se lo sheet <20> vuoto aggiunge una riga vuota
		if (n_righe_sheet == 0)
			sheet.insert();

		//report e book
		TReport_book book;	//book dei report

		TPrint_movimenti_ca_rep rep;
		rep.load(_mask->get(F_REPORT));

		FOR_EACH_SHEET_ROW(sheet, r, row)
		{
			rep.set_filter(*_mask, r);
			book.add(rep);			
		}

		book.print_or_preview();	//stampa il book dei report
	}
}

int ca3100(int argc, char* argv[])
{
  TPrint_movimenti_ca a;
  a.run(argc, argv, TR("Stampa movimenti"));
  return 0;
}