campo-sirio/lv/lv1200.cpp

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

#include "lvlib.h"
#include "lv1200a.h"
#include "../ve/velib07.h"
#include "../ve/velib.h"

///////////////////////////////////////////////////////////
// TStampa_a_kg_msk
///////////////////////////////////////////////////////////

class TStampa_a_kg_msk: public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
	TStampa_a_kg_msk();
};

TStampa_a_kg_msk::TStampa_a_kg_msk() : TAutomask("lv1200a")  {}

bool TStampa_a_kg_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  return true;
}

///////////////////////////////////////////////////////////
// TStampa_a_kg_rep
///////////////////////////////////////////////////////////

class TStampa_a_kg_rep : public TLV_report
{
	TString4 _umkg;

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

public:
	TStampa_a_kg_rep();
	virtual ~TStampa_a_kg_rep() {}
};

TStampa_a_kg_rep::TStampa_a_kg_rep()
{
	_umkg = ini_get_string(CONFIG_DITTA, "lv", "UmKg");
}

bool TStampa_a_kg_rep::get_usr_val(const TString& name, TVariant& var) const
{
	var = 0;
	if (name == "#PESO")
	{
		const TLV_recordset& recset = (TLV_recordset &) *recordset();
    const TString4 umri = recset.get(RDOC_UMQTA).as_string();
    //se la riga è già espressa in kg non devo fare niente
    if (umri == _umkg)
			var = recset.get(RDOC_QTA);
		// altrimenti
		else 
		{
		  const TString & codart = recset.get(RDOC_CODARTMAG).as_string();
			TArticolo & art = cached_article(codart);
			const real qta = art.convert_to_um(recset.get(RDOC_QTA).as_real(), NULL, umri, false);

			if (art.is_first_um(_umkg))
				var = qta;
			else
			{
				//leggo e controllo l'unità di misura del peso
				//leggo e controllo il peso dell'articolo
				const TString4 ump = art.get(ANAMAG_UMP);
				const real peso = art.get_real(ANAMAG_PESO);
		
				if (ump.full() && peso != ZERO)
				{
					//preparo una cache sulla tabella delle unità di misura
					const TRectype& unita = cache().get("%UMS", ump);     
					//leggo e controllo se esiste l'unità di misura di riferimento
					const TString4 umrif = unita.get("S7");
					real fatconv = UNO;

					if (umrif == _umkg)
					{
						//leggo e controllo il fattore di conversione
						fatconv = unita.get_real("R10");
					}
					if (fatconv != ZERO)
					{
						//se tutti i controlli sono andati a buon fine, converto la quantità e la restituisco
						const real qtaconv = qta * fatconv * peso;
						var = qtaconv;
					}					
				}
/*				else  da decidere se gestire
				{
					//preparo una cache sulla tabella delle unità di misura
					const TRectype& unita = cache().get("%UMS", art.first_um());     
					//leggo e controllo se esiste l'unità di misura di riferimento
					const TString4 umrif = unita.get("S7");

					if (umrif == _umkg)
					{
						//leggo e controllo il fattore di conversione
						const real fatconv = unita.get_real("R10");
						if (fatconv != ZERO)
						{
							//se tutti i controlli sono andati a buon fine, converto la quantità e la restituisco
							const real qtaconv = qta * fatconv * peso;
							var = qtaconv;
						}
					} 
				} */
			}
    }
		return true;
	}
	else
		return TReport::get_usr_val(name, var);
}

///////////////////////////////////////////////////////////
// TStampa_a_kg_app
///////////////////////////////////////////////////////////

class TStampa_a_kg_app: public TSkeleton_application
{
  TStampa_a_kg_msk* _msk;

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

  void prepara_recordset(TStampa_a_kg_rep & rep) const;

public:
  virtual void main_loop();
};

//CREATE: metodo costruttore
bool TStampa_a_kg_app::create()
{
  _msk = new TStampa_a_kg_msk; 
  return TSkeleton_application::create();
}

//DESTROY: metodo distruttore
bool TStampa_a_kg_app::destroy()
{	
  delete _msk;
  return TApplication::destroy();
}

//PREPARA_RECORDSET: metodo che estre tutte le righe documento in base ai criteri selezionati
void TStampa_a_kg_app::prepara_recordset(TStampa_a_kg_rep & rep) const
{
  const TString4 codnum = ini_get_string(CONFIG_DITTA, "lv", "NUM_GEN");
  
  const int  raggruppa = _msk->get_int(F_RAGX);
  const bool datadog   = _msk->get_int(F_DATADOG) == 0 ? true : false;  

  const TDate dadata = _msk->get_date(F_DADATA);
  const TDate adata  = _msk->get_date(F_ADATA);

  const long daanno = dadata.year();
  const long aanno  = adata.year();

  TString query;
  query << "USE RDOC\n";
  if(datadog)
    query << "SELECT (BETWEEN(33.DATADOC,#DADATA,#ADATA))";
  else
    query << "SELECT (BETWEEN(33.G1:DATAGEN,#DADATA,#ADATA))";
 // query << "&&(TIPORIGA!=\"05\")&&(33.TIPOCF=\"C\")";
		query << "&&(33.TIPOCF=\"C\")";
  switch(raggruppa)
  {
  case 1: query << "&&(STR(BETWEEN(33.CODCF,#DACODCF,#ACODCF)))\nBY 33.CODCF CODART\n";           break;
  case 2: query << "&&(STR(BETWEEN(33.G1:CODITI,#DAITI,#AITI)))\nBY 33.G1:CODITI[1,3] CODART\n";  break;
  case 3: query << "&&(STR(BETWEEN(33.CODAG,#DAAUT,#AAUT)))\nBY 33.CODAG CODART\n";               break;
  default: query << "\nBY CODART\n";																								              break;
  }
  query << "JOIN DOC INTO CODNUM==CODNUM ANNO==ANNO PROVV==PROVV NDOC==NDOC\n"
				<< "JOIN ANAMAG INTO CODART==CODART\n"
				<< "FROM CODNUM=#CODNUM ANNO=#DAANNO\n"
				<< "TO CODNUM=#CODNUM ANNO=#AANNO\n";

  rep.set_recordset(query);
	
	TRecordset * righedoc = rep.recordset();
  
	righedoc->set_var("#DADATA", dadata);
  righedoc->set_var("#ADATA", adata);
	righedoc->set_var("#DAANNO", daanno);
  righedoc->set_var("#AANNO", aanno);
  righedoc->set_var("#CODNUM", codnum);  

	switch(raggruppa)
  {
  case 1:
    righedoc->set_var("#DACODCF", _msk->get_long(F_DACODCF));
    righedoc->set_var("#ACODCF",  _msk->get_long(F_ACODCF));    
    break;
  case 2:
    righedoc->set_var("#DAITI",   _msk->get(F_DACODITI));
    righedoc->set_var("#AITI",    _msk->get(F_ACODITI));    
    break;
  case 3:
    righedoc->set_var("#DAAUT",   _msk->get(F_DACODAUT).right(5));
    righedoc->set_var("#AAUT",    _msk->get(F_ACODAUT).right(5));    
    break;
  default:
		break;
  }
}

void TStampa_a_kg_app::main_loop()
{
  KEY k;
  while ((k = _msk->run()) == K_ENTER || k == 'A')
	{
		TStampa_a_kg_rep rep;
	  const int  raggruppa = _msk->get_int(F_RAGX);
		bool ok;
		switch (raggruppa)
		{
		case 1:
			ok = rep.load("lv1200b");
		break;
		case 2:
			ok = rep.load("lv1200c");
		break;
		case 3:
			ok = rep.load("lv1200d");
		break;
		default:
			ok = rep.load("lv1200e");
		break;
		}
	  prepara_recordset(rep);
		TReport_book book;
		ok = book.add(rep);
		if (ok)
    {
      if (k == 'A')
        book.preview();
      else
			  book.print();
    }
	}
}

int lv1200(int argc, char *argv[])
{
  TStampa_a_kg_app a;
  a.run (argc, argv, "Stampa a Kg");
  return TRUE;
}