campo-sirio/ha/hacnv500.cpp

#include "halib.h"
#include "hacnvlib.h"
#include "hacnv500a.h"

#include <applicat.h>
#include <automask.h>
#include <defmask.h>
#include <execp.h>
#include <progind.h>
#include <reprint.h>
#include <reputils.h>
#include <tabutil.h>
#include <utility.h>

#include "../ce/cespi.h"
#include "../ce/salce.h"
#include "../ce/ammce.h"

const char* const APPNAME = TR("Conversione cespiti"); 

///////////////////////////////////////////////////////////
// Cespiti
///////////////////////////////////////////////////////////

class THardy_cespiti : public THardy_transfer
{
  int _anno;              // parametri per la query
public:
  virtual bool trasferisci();
  THardy_cespiti(const int anno);
};

// procedura principale di conversione
bool THardy_cespiti::trasferisci()
{
  // trasferisce anagrafica cespiti (cespi)
  TString query = 
    "SELECT * "
		"FROM dbo.SchedeCespiti ";
  TRecordset& recset = create_recordset(query);
  TSystemisamfile cespi(LF_CESPI);
  cespi.open(_lock); 
  TRectype& rec = cespi.curr();

	TConfig& ini = config();
	TString_array lista_campi;
	THardy_iterator hi(this);

  while (++hi)
  {
		rec.zero();
		rec.put(CESPI_IDCESPITE, recset.get("IdScheda").as_string());
		rec.put(CESPI_DESC, recset.get("DsScheda1").as_string());
		rec.put(CESPI_DTFUNZ, recset.get("DataInizioAmm").as_string());
		rec.put(CESPI_DTALIEN, recset.get("DataCessione").as_string());
		TString8 idcat = recset.get("IdCategoriaF").as_string();
		const int codcat = ini.get_int("CategorieCespiti", idcat);
		rec.put(CESPI_CODCAT, codcat);

		if (codcat <= 40)
		{
			rec.put(CESPI_CODCGRA, ini.get("CODCGRA", "Cespiti"));
			TString8 codsp = ini.get("CODSPA", "Cespiti");
			codsp.lpad(4);
			rec.put(CESPI_CODSPA, codsp);
			rec.put(CESPI_CODCGR, ini.get("CODCGR", "Cespiti"));
			codsp = ini.get("CODSP", "Cespiti");
			codsp.lpad(4);
			rec.put(CESPI_CODSP, codsp);
		}
    test_write(cespi);
  }
  cespi.close();

	// trasferisce saldi cespiti (SALCE)
  if (write_enabled())
  {
    TString query = 
      "SELECT * "
		  "FROM dbo.TotaliCespiti "
			"WHERE Esercizio = ";
		query << _anno;

		TRecordset& recset = create_recordset(query);
    TSystemisamfile salce(LF_SALCE);
    salce.open(_lock); 
    TRectype& rec = salce.curr();
    THardy_iterator hi(this);
    while (++hi)
    {
			rec.zero();
			rec.put(SALCE_IDCESPITE, recset.get("IdScheda").as_string());
			rec.put(SALCE_CODES, recset.get("Esercizio").as_string());
			rec.put(SALCE_TPSALDO, 1);
			rec.put(SALCE_NUMELE, 1);
			rec.put(SALCE_CSTO, recset.get("Totale01").as_real() - recset.get("Totale02").as_real());
			rec.put(SALCE_VNONAMM, recset.get("Totale13").as_real());
			rec.put(SALCE_RIVGF, recset.get("Totale07").as_real());
			rec.put(SALCE_RIVGC, recset.get("Totale07C").as_real());
			rec.put(SALCE_VNONAMMC, recset.get("Totale13C").as_real());
      test_write(salce);
    }
    salce.close();
  }
  return write_enabled();
}

THardy_cespiti::THardy_cespiti(const int anno) : _anno(anno)
{
}

///////////////////////////////////////////////////////////
// TConvCespitiHardy_mask
///////////////////////////////////////////////////////////

class TConvCespitiHardy_mask : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  void serialize(bool bSave);

public:
  void trasferisci();

  TConvCespitiHardy_mask();
  virtual ~TConvCespitiHardy_mask();
};

// Funzione di trasferimento dati da/verso file .ini con lo stesso nome della maschera
// Andrebbe messo in libreria
void TConvCespitiHardy_mask::serialize(bool bSave)
{
  TFilename n = source_file(); n.ext("ini");  // Construisce il nome del .ini in base al .msk
  TConfig cfg(n, "Main");                     // Crea il file di configurazione
  TString4 id; 
  for (int i = fields()-1; i >= 0; i--)       // Scandisce tutti i campi della maschera ...   
  {
    TMask_field& f = fld(i);
    if (f.active() && f.is_loadable())        // ... selezionando solo quelli editabili
    {
      id.format("%d", f.dlg());
      if (bSave)                              // A seconda del flag di scrittura ... 
        cfg.set(id, f.get());                 // ... o scrive sul .ini 
      else 
        f.set(cfg.get(id));                   // ... o legge dal .ini
    }
  }
}

void TConvCespitiHardy_mask::trasferisci()
{
  TString query_header;
  query_header << "ODBC(" << get(F_DSN) << ',' << get(F_USR) << ',' << get(F_PWD) << ")\n";

  const int anno = get_int(F_ANNO);
  if (anno!=0)
  {
    THardy_log log;
    THardy_cespiti pc(anno);
    pc.init(TR("Cespiti"), query_header, log);
    pc.trasferisci();
  }
}

bool TConvCespitiHardy_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case DLG_OK:
    if (e == fe_button)
      serialize(true);
    break;
  default:
    break;
  }
  return true;
}

TConvCespitiHardy_mask::TConvCespitiHardy_mask() : TAutomask("hacnv500a")
{
  serialize(false);
}

TConvCespitiHardy_mask::~TConvCespitiHardy_mask()
{ 
}

///////////////////////////////////////////////////////////
// TConvCespitiHardy
///////////////////////////////////////////////////////////

class TConvCespitiHardy : public TSkeleton_application
{
protected:
  virtual void main_loop();
};

void TConvCespitiHardy::main_loop()
{
  TConvCespitiHardy_mask mask;
  while (mask.run() == K_ENTER)
    mask.trasferisci();
}

int hacnv500(int argc, char* argv[])
{
  TConvCespitiHardy ih;
  ih.run(argc, argv, APPNAME);
  return 0;
}