campo-sirio/lv/lv4200.cpp

#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <relation.h>
#include <reputils.h>
#include <utility.h>

#include "../cg/cglib01.h"
#include "../cg/cg2103.h"
#include "../cg/cgsaldac.h"

#include "lv4.h"
#include "lv4100.h"
#include "lv4200a.h"

#include <causali.h>
#include <rcausali.h>
#include <clifo.h>
#include <pconti.h>
#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>

enum CGC_SALDAC { CGC_NULL,      CGC_TIPOCF,  CGC_ANNO,       CGC_NUMPART, CGC_CODCF,
                  CGC_NUMEROREC, CGC_CAMBIO,  CGC_VALUTA,     CGC_TIPODOC, CGC_DATADOC,
                  CGC_SCADENZA,  CGC_IMPORTO,	CGC_IMPORTO_VAL };

class TCausali_cache : public TCache
{
  TString4 _cln, _frn;

protected:
  virtual TObject* key2obj(const char* key);

public:
  const TCausale& causale(char tipocf, tipo_movimento tm, const TDate& datadoc);
  void init(const char* cln, const char* frn) { _cln = cln; _frn = frn; }
};

TObject* TCausali_cache::key2obj(const char* key)
{
  const char tipocf = key[0];
  const tipo_movimento tm = tipo_movimento(key[1]-'0');
  int anno = atoi(key + 2);
  if (anno <= 0)
    anno = TDate(TODAY).year();

  TString4 codcaus;
  if (tm == tm_fattura)
    codcaus = tipocf == 'F' ? _frn : _cln;
  if (codcaus.blank())
  {
    TString query;
    query << "USE CAUS\nSELECT (TIPOMOV='" << tm << "')&&(RCAUS->TIPOCF='" << tipocf << "')"
          << "\nJOIN RCAUS INTO CODCAUS=CODCAUS NRIGA=1";
    TISAM_recordset caus(query);
    if (caus.move_first())
      codcaus = caus.get(CAU_CODCAUS).as_string();
  }
  TCausale* pcaus = new TCausale(codcaus, anno);
  return pcaus;
}

const TCausale& TCausali_cache::causale(const char tipocf, tipo_movimento tm, const TDate& datadoc)
{
  // Metodo bastardo per evitare TToken_string temporanee "a randa"
  // creo chiave a lunghezza fissa TIPOCF+TIPOMOV = C1
  TString8 key;
  key.format("%c%1d%4d" , tipocf, tm, datadoc.year());
  return *(const TCausale*)objptr(key);
}

///////////////////////////////////////////////////////////
// TAutomask
///////////////////////////////////////////////////////////

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

public:
  TImporta_sc_mask();
};
  
TImporta_sc_mask::TImporta_sc_mask() :TAutomask ("lv4200a")
{
}  

bool TImporta_sc_mask::on_field_event(TOperable_field& f, TField_event e, long jolly)
{ 
	switch (f.dlg())
	{
		//giochetto per avere la lista dei files validi nella directory di trasferimento!
		case F_NAME:
			if (e == fe_button)
			{
				TArray_sheet as(-1, -1, 72, 20, TR("Selezione file"), "File@32");
				TFilename path = get(F_PATH);
				path.add("*.txt");	//file da importare
				list_files(path, as.rows_array());
				TFilename name;
				FOR_EACH_ARRAY_ROW(as.rows_array(), i, row)
				{
					name = *row;
					*row = name.name();
				}
				if (as.run() == K_ENTER)
				{
					f.set(as.row(as.selected()));
				}
			}
			break;
		default:
			break;
	}
  return true;
}

///////////////////////////////////////
// TSkeleton_application
///////////////////////////////////////
class TImporta_sc : public TSkeleton_application
{
	TImporta_sc_mask*	_msk;
	
  TCausali_cache _cache_causali;
  TBill _clienti, _fornitori;

private:
  void nuovo_pagamento_o_nota(const TImporta_cogeco_recset& recset, TPartita& game, tipo_movimento tm);
  bool paga_rata(TPartita& game, int nrata, int nrigp, real& importo) const;

protected:
  bool log_error(TLog_report& log, const char* msg, const TRecordset& recset);
  const TCausale& causale(char tipocf, tipo_movimento tm, const TDate& datadoc);
  char get_tmcf(int gruppo, int conto) const;
  bool find_clifo_bill(char tipocf, int& gruppo, int& conto, long sottoconto);

  TRiga_partite& nuova_fattura(const TImporta_cogeco_recset& recset, TPartita& game);
  void nuova_scadenza(const TImporta_cogeco_recset& recset, TPartita& game);
  void nuova_riba(const TImporta_cogeco_recset& recset, TPartita& game);
  void nuovo_pagamento(const TImporta_cogeco_recset& recset, TPartita& game);
  void nuova_nota_credito(const TImporta_cogeco_recset& recset, TPartita& game);
  bool nuovo_insoluto(const TImporta_cogeco_recset& recset, TPartita& game, TLog_report& log);
  void salva_partita(TPartita*& game);

public:           
  virtual bool create();
  virtual bool destroy();
  virtual void main_loop();
	void transfer(const TFilename& file);
};

// Cerca una causale appropriata in base a TIPOCF (C o F) e TIPOMOV (1, 2, 3, ...)
const TCausale& TImporta_sc::causale(char tipocf, tipo_movimento tm, const TDate& datadoc)
{ return _cache_causali.causale(tipocf, tm, datadoc); }

// Ricava il campo TMCF (Cliente o Fornitore) di un dato conto
char TImporta_sc::get_tmcf(int gruppo, int conto) const
{
  char tmcf = ' ';
  if (gruppo > 0 && conto > 0)
  {
    TString8 key; key.format("%d|%d", gruppo, conto);
    const TRectype& pcon = cache().get(LF_PCON, key);
    tmcf = pcon.get_char(PCN_TMCF);
  }
  return tmcf;
}

// Trova il conto cliente di una certa anagrafica
bool TImporta_sc::find_clifo_bill(char tipocf, int& gruppo, int& conto, long sottoconto)
{
  bool found = false;
  
  TString8 key;
  gruppo = conto = 0;
  
  // Prima lo cerca sull'anagrafica stessa
  key.format("%c|%ld", tipocf, sottoconto);
  const TRectype& clifo = cache().get(LF_CLIFO, key);
  gruppo = clifo.get_int(CLI_GRUPPO);
  conto = clifo.get_int(CLI_CONTO);

  // Controlla che il conto esista
  found = get_tmcf(gruppo, conto) == tipocf;

  if (!found)
  {
    // Cerca sulla prima riga dellla causale
    const TDate datadoc(TODAY);
    const TCausale& caus = causale(tipocf, tm_fattura, datadoc);
    TBill bill; caus.bill(1, bill);
		gruppo = bill.gruppo();
		conto = bill.conto();
    found = get_tmcf(gruppo, conto) == tipocf;
  }

  if (!found)
  {
    // Usa un conto C/F trovato preventivamente in fase di inizializzazione
    if (tipocf == 'C')
    {
      gruppo = _clienti.gruppo();
      conto = _clienti.conto();
    }
    else
    {
      gruppo = _fornitori.gruppo();
      conto = _fornitori.conto();
    }
    found = gruppo > 0 && conto > 0;
  }

  return found;
}

// Aggiunge una nuova riga fattura a 'game' in base ai dati in 'recset'
TRiga_partite& TImporta_sc::nuova_fattura(const TImporta_cogeco_recset& recset, TPartita& game)
{
  int nriga = game.prima_fattura();
  if (game.prima_fattura() <= 0)
  {
		TRiga_partite& fattura = game.new_row();

    const TDate datadoc = recset.get_date(CGC_DATADOC);
		fattura.put(PART_DATAREG, datadoc); 
		fattura.put(PART_DATADOC, datadoc);
    fattura.put(PART_DESCR, TR("*** Fattura gnerata da COGECO ***"));

    const char tipocf = game.conto().tipo();
    const TCausale& caus = causale(tipocf, tm_fattura, datadoc);
    if (caus.ok())
    {
  		fattura.put(PART_CODCAUS, caus.codice());
	  	fattura.put(PART_REG, caus.reg().name());
      fattura.put(PART_TIPOMOV, caus.tipomov());
  		fattura.put(PART_SEZ, caus.sezione(1));
    }
    else
    {
      fattura.put(PART_TIPOMOV, tm_fattura);
      fattura.put(PART_SEZ, tipocf == 'C' ? 'D' : 'A');
    }
    nriga = fattura.get_int(PART_NRIGA);
  }

  TRiga_partite& fattura = game.riga(nriga);
  const real importo = recset.get_real(CGC_IMPORTO);

  fattura.add(PART_IMPTOTDOC, importo);
  fattura.add(PART_IMPORTO, importo);

  return fattura;
}

// Aggiunge una nuova rata alla UNICA fattura di 'game'.
// Attenzione: in assenza di fattura ne viene creata una "al volo" di pari importo.
void TImporta_sc::nuova_scadenza(const TImporta_cogeco_recset& recset, TPartita& game)
{
  int nriga = game.prima_fattura(); // PART_NRIGA della fattura (solitamente = 1)
  if (nriga <= 0) // Se non ci sono fattura in questa partita ...
  {
    nuova_fattura(recset, game);  // Creo una nuova fattura
    nriga = game.prima_fattura(); // Aggiorno PART_NRIGA che valeva -1
  }
  TRiga_partite& fattura = game.riga(nriga);    // Accedo alla riga di fattura, che ora DEVE esistere!
	TRiga_scadenze& scadenza = fattura.new_row(); // Creo nuova rata, alla faccia di SCAD_CODPAG

  const real importo = recset.get_real(CGC_IMPORTO);
  scadenza.put(SCAD_DATASCAD, recset.get_date(CGC_SCADENZA));
  scadenza.put(SCAD_IMPORTO, importo);
  scadenza.put(SCAD_DESCR, TR("*** Rata generata da COGECO ***"));
}

bool TImporta_sc::paga_rata(TPartita& game, int nrata, int nrigp, real& importo) const
{
  const int nriga = game.prima_fattura();
  if (nriga > 0)
  {
    const TRiga_partite& fattura = game.riga(nriga);
    TRiga_scadenze& scadenza = fattura.rata(nrata);
    const real residuo = scadenza.residuo(false).valore();
    if (!residuo.is_zero()) // Considera solo rate aperte
    {
      // Elenco dei campi chiave da riportare dalla rata al pagamento
      const char* const field[] = { PAGSCA_TIPOC, PAGSCA_SOTTOCONTO, PAGSCA_ANNO, PAGSCA_NUMPART, 
                                    PAGSCA_NRIGA, PAGSCA_NRATA, NULL };
      const real pagare = residuo > importo ? importo : residuo; // Importo da pagare sulla rata
      TRectype rpag(LF_PAGSCA);
      for (int k = 0; field[k]; k++)
        rpag.put(field[k], scadenza.get(field[k]));
      rpag.put(PAGSCA_NRIGP, nrigp); // Completa la chiave di PAGSCA col numero riga di partita
      rpag.put(PAGSCA_IMPORTO, pagare);
      const TValuta euro;
      game.modifica_pagamento(rpag, euro, true); // Speriamo che faccia tutto lei :-)
      importo -= pagare;
      return true;
    }
  }
  return false;
}

// Aggiunge una nuova riga tipo 2 (n.c.) o 3 (pag.) alla partita
void TImporta_sc::nuovo_pagamento_o_nota(const TImporta_cogeco_recset& recset, TPartita& game, tipo_movimento tm)
{
  // Crea una nuova riga di partita
  TRiga_partite& pagamento = game.new_row();
  const int nrigp = pagamento.get_int(PART_NRIGA); // Ricorda numero da mettere in PAGSCA_NRIGP

  const TDate datadoc = recset.get_date(CGC_DATADOC);
	pagamento.put(PART_DATAREG, datadoc); 
	pagamento.put(PART_DATADOC, datadoc);
  if (tm == tm_nota_credito)
    pagamento.put(PART_DESCR, TR("*** Nota di credito generata da COGECO ***"));
  else
    pagamento.put(PART_DESCR, TR("*** Pagamento generato da COGECO ***"));

  // Cerca di inizlizzare la riga con una causale appropriata
  const char tipocf = game.conto().tipo();
  const TCausale& caus = causale(tipocf, tm, datadoc);
  if (caus.ok())
  {
		pagamento.put(PART_CODCAUS, caus.codice());
  	pagamento.put(PART_REG, caus.reg().name());
    pagamento.put(PART_TIPOMOV, caus.tipomov());
		pagamento.put(PART_SEZ, caus.sezione(1));
  }
  else
  {
    pagamento.put(PART_TIPOMOV, tm);
    pagamento.put(PART_SEZ, tipocf == 'F' ? 'D' : 'A');
  }

  // Somma da distribuire sulle rate aperte
  real importo = recset.get_real(CGC_IMPORTO);
  pagamento.put(PART_IMPTOTDOC, importo);

  // Se esiste una fattura cerca di saldare il residuo delle rate aperte
  const int nriga = game.prima_fattura();
  if (nriga > 0)
  {
    const TRiga_partite& fattura = game.riga(nriga);
    
    // Si assicura che la sezione sia inversa rispetto alla fattura
    pagamento.put(PART_SEZ, fattura.sezione() == 'D' ? 'A' : 'D'); 

    while (true)
    {
      int best_rata = 0, best_score = 0;
      for (int nrata = 1; nrata <= fattura.rate() && !importo.is_zero(); nrata++)
      {
        const TRiga_scadenze& rata = fattura.rata(nrata);
        const real residuo = rata.residuo(false).valore();
				if (!residuo.is_zero())
				{
					const TDate data_scad = rata.get(SCAD_DATASCAD);
					int score = data_scad == datadoc ? 2 : 0;
					if (score == 0 && datadoc == data_scad+1L)
						score++;
					if (residuo >= importo)
					{
						score++;
						if (residuo == importo)
							score++;
					}
					if (score > best_score)
					{
						best_rata = nrata;
						best_score = score;
					}
				}
      }
      if (best_rata > 0)
        paga_rata(game, best_rata, nrigp, importo);
      else
        break;
    }
  }

  // Se ci rimane qualcosa o non e' stata trovata una rata aperta allora crea un pagamento non assegnato
  if (!importo.is_zero())
  {
    TRectype rpag(LF_PAGSCA);
    const char* const field[] = { PAGSCA_TIPOC, PAGSCA_SOTTOCONTO, PAGSCA_ANNO, PAGSCA_NUMPART, NULL };
    for (int k = 0; field[k]; k++)
      rpag.put(field[k], pagamento.get(field[k]));
    rpag.put(PAGSCA_NRIGA, 9999);  // Questo 9999 significa "fattura ignota"
    rpag.put(PAGSCA_NRATA, 9999);  // Questo 9999 significa "rata ignota"
    rpag.put(PAGSCA_NRIGP, nrigp); // Completa la chiave di PAGSCA col numero riga di partita
    rpag.put(PAGSCA_IMPORTO, importo);
    const TValuta euro;
    game.modifica_pagamento(rpag, euro, true);
  }
}

// In COGECO le riba si intendono pagate automaticamente, 
// per cui in CAMPO viene aperta una scadenza ed immediatamente chiusa col relativo pagamento
void TImporta_sc::nuova_riba(const TImporta_cogeco_recset& recset, TPartita& game)
{
  nuova_scadenza(recset, game);
  nuovo_pagamento(recset, game);
}

// Creo una nuova riga partita corrispondente ad una riga pagamento in PAGSCA
void TImporta_sc::nuovo_pagamento(const TImporta_cogeco_recset& recset, TPartita& game)
{ nuovo_pagamento_o_nota(recset, game, tm_pagamento); }

// Creo una nuova riga partita corrispondente ad una riga nota di credito in PAGSCA
void TImporta_sc::nuova_nota_credito(const TImporta_cogeco_recset& recset, TPartita& game)
{ nuovo_pagamento_o_nota(recset, game, tm_nota_credito); }

// Creo una nuova riga partita corrispondente ad una riga di insoluto PAGSCA
bool TImporta_sc::nuovo_insoluto(const TImporta_cogeco_recset& recset, TPartita& game, TLog_report& log)
{
  const int nriga = game.prima_fattura();  // Cerco la fattura insoluta
  if (nriga <= 0)     // Non e' carino creare un insoluto non assegnato
    return log_error(log, TR("Impossibile associare insoluto"), recset);

  const TDate datadoc = recset.get_date(CGC_DATADOC);
  real importo = recset.get_real(CGC_IMPORTO);

  // Cerca la miglior rata possibile da mandare insoluta
  // Per fare cio', si assegna un punteggio ad ogni rata, basato sulla data e sull'importo
  int best_rata = 0, best_score = 0;
  const TRiga_partite& fattura = game.riga(nriga);
  for (int nrata = fattura.rate(); nrata > 0; nrata--)
  {
    const TRiga_scadenze& scadenza = fattura.rata(nrata);
		const real imp = scadenza.importo_pagato(false).valore();
		if (!imp.is_zero())
		{
			const TDate data = scadenza.get(SCAD_DATASCAD);
			int score = datadoc == data ? 2 : 0;
			if (score == 0 && datadoc == data+1L)
				 score++;
			if (imp >= importo)
			{
				score++;
				if (imp == importo)
					score++;
			}
			if (score > best_score)
			{
				best_rata = nrata;
				best_score = score;
			}
		}
  }

  if (best_rata > 0) // Se ho trovato almeno una rata compatibile con l'insoluto...
  {
    const TRiga_scadenze& scadenza = fattura.rata(best_rata);
    TRiga_partite& insoluto = game.new_row();
    const int nrigp = insoluto.get_int(PART_NRIGA);

  	insoluto.put(PART_DATAREG, datadoc); 
  	insoluto.put(PART_DATADOC, datadoc);
    insoluto.put(PART_DESCR, TR("*** Insoluto trasferito da COGECO ***"));
    insoluto.put(PART_IMPTOTDOC, importo); 

    const char tipocf = game.conto().tipo();
    const TCausale& caus = causale(tipocf, tm_insoluto, datadoc);
    if (caus.ok())
    {
      insoluto.put(PART_CODCAUS, caus.codice());
    	insoluto.put(PART_REG, caus.reg().name());
      insoluto.put(PART_TIPOMOV, caus.tipomov());
  		insoluto.put(PART_SEZ, caus.sezione(1));
    }
    else
    {
      insoluto.put(PART_TIPOMOV, tm_insoluto);
      insoluto.put(PART_SEZ, fattura.sezione());
    }
    paga_rata(game, best_rata, nrigp, importo);
  }
  else
    log_error(log, TR("Impossibile associare insoluto"), recset);
  
  return best_rata > 0;
}

bool TImporta_sc::log_error(TLog_report& log, const char* msg, const TRecordset& recset)
{
  TString message;
  message << recset.get(CGC_TIPOCF) << recset.get(CGC_CODCF) << '-' 
          << recset.get(CGC_ANNO) << '/' << recset.get(CGC_NUMPART) 
          << '.' << recset.get(CGC_NUMEROREC) << " : " << msg;
  log.log(2, message);
  return false;
}

// Ordina le righe di partita per TIPOCF+CODCF+ANNO+NUMPART+SCADENZA+TIPODOC
static int game_sorter(const TObject** o1, const TObject** o2)
{
  TToken_string& r1 = *(TToken_string*)*o1;
  TToken_string& r2 = *(TToken_string*)*o2;

  if (r1.get_int(0) != 1)
    return -1; // Riga testata!
  if (r2.get_int(0) != 1)
    return +1; // Riga testata!

  const char tipocf1 = r1.get_char(CGC_TIPOCF);
  const char tipocf2 = r2.get_char(CGC_TIPOCF);
  int cmp = tipocf1 - tipocf2;
  if (cmp != 0)
    return cmp;

  const long codice1 = r1.get_long(CGC_CODCF);
  const long codice2 = r2.get_long(CGC_CODCF);
  cmp = codice1 - codice2;
  if (cmp != 0)
    return cmp;
  
  const int anno1 = r1.get_int(CGC_ANNO);
  const int anno2 = r2.get_int(CGC_ANNO);
  cmp = anno1 - anno2;
  if (cmp != 0)
    return cmp;

  const int part1 = r1.get_int(CGC_NUMPART);
  const int part2 = r2.get_int(CGC_NUMPART);
  cmp = part1 - part2;
  if (cmp != 0)
    return cmp;

  const TString datadoc1 = r1.get(CGC_DATADOC);
  if (datadoc1.blank() || datadoc1 == "00/00/0000")
    return -1;
  const TString datadoc2 = r2.get(CGC_DATADOC);
  if (datadoc2.blank() || datadoc2 == "00/00/0000")
    return +1;
  cmp = TDate(datadoc1)-TDate(datadoc2);
  if (cmp != 0)
    return cmp;

  const TString data1 = r1.get(CGC_SCADENZA);
  if (data1.blank() || data1 == "00/00/0000")
    return -1;
  const TString data2 = r2.get(CGC_SCADENZA);
  if (data2.blank() || data2 == "00/00/0000")
    return +1;

  cmp = TDate(data1)-TDate(data2);
  if (cmp != 0)
    return cmp;

  // I tipi documento vanno ordinati in base alla sequenza sequente, non in base al valore numerico!
  TToken_string priority = "1|3|15|2|4|5|6|7|8|9|10|11";
  const int tipodoc1 = r1.get_int(CGC_TIPODOC);
  const int tipodoc2 = r2.get_int(CGC_TIPODOC);
  int pri1 = priority.get_pos(tipodoc1); 
  if (pri1 < 0) pri1 = 100+tipodoc1;
  int pri2 = priority.get_pos(tipodoc2); 
  if (pri2 < 0) pri2 = 100+tipodoc2;
  cmp = pri1 - pri2;
  
  return cmp;
}

void TImporta_sc::salva_partita(TPartita*& game)
{
  if (game != NULL)
  {
		game->write();
    delete game;
    game = NULL;
  }
}

void TImporta_sc::transfer(const TFilename& file)
{
  TImporta_cogeco_recset recset(file);
  recset.sort(game_sorter);
  
  TString caption; _msk->get_caption(caption);
  TProgind pi(recset.items(), caption, true, true);

  TConfig* conf = NULL;
	int anno = 0;
	long part = 0;
	char tipocf = ' ';
	long sottoconto = 0L;
	TPartita* game = NULL;
	TToken_string key;
	const TString& codcausc = _msk->get(F_CODCAUSC);
	const TString& codcausf = _msk->get(F_CODCAUSF);

  TLog_report log(caption);

  for (bool ok = recset.move_to(0); ok; ok = recset.move_next())
  {
    if (!pi.addstatus(1)) 
      break;
    const int chk = recset.get(CGC_NULL).as_int(); 
    if (chk != 1) // Prende solo righe buone!
      continue;

    const char t = recset.get(CGC_TIPOCF).as_string()[0]; 
		const long s = recset.get(CGC_CODCF).as_int();
		const int  a = recset.get(CGC_ANNO).as_int();
	  const long p = recset.get(CGC_NUMPART).as_int();
	
		if (tipocf != t || sottoconto != s || anno != a || p != part)
		{
      salva_partita(game); // Salva parita corrente se non nulla

      TToken_string key; key.format("%c|%ld", t, s);
  		const TRectype& clifo = cache().get(LF_CLIFO, key);
      if (clifo.empty())
      {
        log_error(log, TR("Codice Cliente/Fornitore non valido"), recset);
        continue;
      }
      if (a < 2000)
      {
        log_error(log, TR("Anno partita non valido"), recset);
        continue;
      }
      if (p <= 0)
      {
        log_error(log, TR("Numero partita non valido"), recset);
        continue;
      }

 			tipocf = t;
			sottoconto = s;
			anno = a;
			part = p;

      if (game == NULL)
      {
        int gruppo = 0, conto = 0;
        if (find_clifo_bill(tipocf, gruppo, conto, sottoconto))
        {
          const TBill codclifo(gruppo, conto, sottoconto, tipocf);
        	game = new TPartita(codclifo, anno, format("%ld", part));
        }
        else
        {
          log_error(log, TR("Impossibile determinare il conto cliente/fornitore"), recset);
          break; // Esce subito, probabilmente il piano dei conti non e' stato ancora importato
        }
      }
		}

    if (game != NULL)
    {
  		const int tipodoc = recset.get(CGC_TIPODOC).as_int();
      switch (tipodoc)
      {
      case  1: nuova_fattura(recset, *game); break;       // Fattura 
      case  2: nuova_nota_credito(recset, *game); break;  // Nota di credito
      case  3: nuova_fattura(recset, *game); break;       // Fattura in sospensione
      case  4: nuova_nota_credito(recset, *game); break;  // Reso su fattura in sospensione
      case  5: nuovo_pagamento(recset, *game); break;     // Pagamento fattura in sospeso
      case  6: nuovo_insoluto(recset, *game, log); break; // Insoluto
      case  8:                                            // Tratta 
      case  9:                                            // Ri.Ba.
      case 10: nuova_riba(recset, *game); break;          // Cambiale 
      case 11: nuovo_pagamento(recset, *game); break;     // Pagamento
      case 13: nuova_nota_credito(recset, *game); break;  // Nota di credito su RB clienti
      case 14: nuova_nota_credito(recset, *game); break;  // Abbuono
      case 15: nuova_scadenza(recset, *game); break;
      case 18: nuova_riba(recset, *game); break;          // Paghero' 
      case 19: nuova_riba(recset, *game); break;          // Avviso di scadenza
      case 20: nuova_riba(recset, *game); break;          // R.I.D.
      default: log_error(log, TR("Tipo documento non riconosciuto"), recset); break;
      }
    }
  }
  salva_partita(game); // Salva ultima partita se non nulla

  if (log.recordset()->items() > 0)
    log.preview();
}

bool TImporta_sc::create()
{
  // Determina i conti per clienti e fornitori nel caso non siano in anagrafica
  TString query; query << "USE PCON SELECT TMCF!=\'\'";
  TISAM_recordset pcon(query);
  for (bool ok = pcon.move_first(); ok; ok = pcon.move_next())
  {
    const TRectype& rec = pcon.cursor()->curr();
    const char tmcf = rec.get_char(PCN_TMCF);
    if (tmcf == 'C' && _clienti.gruppo() == 0)
      _clienti.get(rec);
    if (tmcf == 'F' && _fornitori.gruppo() == 0)
      _fornitori.get(rec);
  }
  _msk = new TImporta_sc_mask();     
  return TSkeleton_application::create();
}

bool TImporta_sc::destroy()
{
	delete _msk;
  return TApplication::destroy();
}

void TImporta_sc::main_loop()
{
  if (_msk->run() == K_ENTER)
  {
    _cache_causali.init(_msk->get(F_CODCAUSC), _msk->get(F_CODCAUSF));

    //genero il nome del file da caricare
    TFilename name = _msk->get(F_PATH);
    name.add(_msk->get(F_NAME));
		transfer(name);
  }   
}

int lv4200 (int argc, char* argv[])
{
  TImporta_sc main_app;
  main_app.run(argc, argv, TR("Importazione saldaconto COGECO"));
  return true;
}