campo-sirio/cg/cg6700.cpp

//
// Ricezione dati: lista controllo movimenti
//       

#include <config.h>
#include <mask.h>
#include <prefix.h>
#include <printapp.h>
#include <progind.h>
#include <tabutil.h>
#include <utility.h> 
#include <mailbox.h>

#include <nditte.h>
#include <mov.h>
#include <rmov.h>
#include <rmoviva.h> 
#include <causali.h> 
#include <clifo.h> 
#include <nditte.h> 
#include <pconti.h> 
#include <partite.h>
#include <scadenze.h>
#include <pagsca.h>

#include "cglib01.h"
#include "cglib04.h" 
#include "cg6700.h"


class TRic_ListaMov : public TPrintapp
{
  TTable*              _tab_tra,* _tab_pag,* _tab_tpd,* _tab_iva, *_tab_ese;
  TIsamtempfile*       _tmov,* _trmov,* _tiva,* _tpart,* _tscad,* _tpagsca;
  TLocalisamfile*      _caus,* _ditte,* _clifo,* _pcon, *_mov, *_rmov, *_rmoviva;
  TLocalisamfile*      _part,* _scad,* _pagsca;
  TRelation*           _rel, *_relSC;
  //TCursor*           _cur, *_curSC;
  int                  _cur, _curSC;
  TTransfer_file*      _trasfer;
  TLibro_giornale*     _giornale;                
  TEsercizi_contabili  _ec;
  char                 _ric_auto,_tipo_lista;
  
  TFilename        _pathfile;
  TString          _descr_causale, _descr_conto;
  TString16        _causale, _registro, _numdoc, _tipodoc, _codval;
  TString16        _codpag, _codiva, _tipo_conto;
  TString          _record, _numpart, _descr_anag, _descr_pag, _tipom_cau, _codval_part, _codpag_scad,_reg;
  bool             _mov_sez, _errore_grave, _esiste_conto, _seconda_volta, _errore_grave_SC;
  bool             _is_iva, _is_salda, _risposta, _continua, _intestaSC, _errore_grave_totale;
  bool             _prima_volta,_calcola,_prima_rata_pag,_ho_stampato;
  char             _sdt, _sezione, _tipocf, _sez, _tipocf_p;
  int              _ae, _anno, _gruppo, _conto, _tipocr, _tipod, _tiporeg, _tipomov, _tipopag, _nriga;
  int              _gruppoc, _contoc, _gruppocr, _contocr, _annoiva, _gruppocl, _contocl, _numrig, _annoese;
  int              _gruppo_p, _conto_p, _anno_prec;
  TDate            _datacomp, _datadoc, _datareg, _data74tr, _datacam, _datacam_part,_datapag;
  real             _importo, _impo, _impos, _tot_dare, _tot_avere, _tot_doc, _tot_val;
  real             _cambio, _cambio_part, _impo_print, _impos_print;
  long             _codcf, _numero, _protiva, _sottoconto, _numreg;
  long             _sottocontoc, _sottocontocr, _codcf_p;
  TBit_array       _err;   
  byte             _controllo;   
  real             _imp,_impval;   
  TString          _numpart_prec;
  int              _tipopag_pag;                

protected:
  char sezione_ritsoc(const TRectype& part) const;
  real segno_ritsoc(const TRectype& part) const;
    
public:
  virtual bool check_autorization() const 
  {return FALSE;}
  virtual          bool set_print(int m);
  virtual          bool user_create() ;
  virtual          bool user_destroy();
  virtual          bool preprocess_page(int,int);
  virtual          bool preprocess_print(int,int);  
  virtual          print_action postprocess_page(int,int);
  virtual          print_action postprocess_print(int file, int counter);  
  virtual          void postclose_print();
  char             look_sdt();
  const char*      get_codiva_des(const char*);
  bool             DescrConto(int,int,long);
  bool             check_archivi();
  bool             look_pag();
  bool             errori_partita(int,int,long);
  bool             controlla_mov();
  bool             controlla_rmov();
  bool             controlla_riva();
  void             stampa_errori_mov(int);
  void             stampa_errori_rmov(int);
  void             stampa_errori_riva(int);
  void             aggiorna_mov();                        
  void             aggiorna_rmov(char tipoc, char tipocc);
  void             aggiorna_iva(char tipo);
  void             setta_parametri(const TString&, const TString&);
  void             setta_intestazione();          
  char             TipoConto(int g, int c);   
// Funzioni per lista controllo movimenti saldaconto  
  bool             controlla_partite(); 
  void             stampa_errori_partite(int riga);
  bool             controlla_scadenze();            
  void             stampa_errori_scadenze(int riga);  
  bool             controlla_pagsca();                
  void             stampa_errori_pagsca(int riga);    
  bool             controlla_anaCF_Pcon(char tipocf,int gruppo,int conto,long codcf);
  bool             controlla_anagrafica(char tipo, int gruppo, int conto);
  bool             cerca_codpag(TString& codpag);                     
  bool             cerca_tipopag_codpag(TString& codpag, int tipopag);
  bool             ulteriore_classificazione(int tipopag, TString& ultclass); 
  bool             banca(long abi,long cab);
  bool             agente(const char* codag) const; 
  bool             record_partite(int nriga);
  bool             record_scadenze(int nriga,int nrata);  
  void             descrizione_pagamento(TString& descr,int tipopag,TString& ultclass,TString& codpag);
  void             esamina_partite();
  
  void             aggiorna_partite();
  bool             solo_SC(long numreg);

  void             calcola_imposta(long numreg, real& imposta);  
  bool             calcola_impdocval(long nreg,int nrig,char tipo,int g,int c, long s,int anno,TString& numpart,int nriga,real& doc,real& val);    
  void             calcola_importo(char tipo,int g,int c,long s,int anno,TString& numpart,int nriga);  
  void             aggiorna_partita(real& importo,real& importoval,real& abbuoni,real& diffcam,
                                    real& ritfis,real& ritsoc,TString& sez,TString& sezabb,TString& sezdc);  
  void             azzera_impdocval();
  int              cerca_anno_solare_esercizio(int codice_esercizio);  
  bool             esiste_rata();
  const char * get_error(int err);

		void             apri_file_SC();
  void             chiudi_file_SC();
  
  TLibro_giornale& giornale() { return *_giornale; }
  TTransfer_file&  trasfer() { return *_trasfer; }
  
  TRic_ListaMov(char ric_auto = '\0',char tipo_lista = '\0');
  virtual ~TRic_ListaMov() {}
};                  

HIDDEN inline TRic_ListaMov& app() { return (TRic_ListaMov&)main_app();}

TRic_ListaMov::TRic_ListaMov(char ric_auto,char tipo_lista):
_ric_auto(toupper(ric_auto)), _tipo_lista(toupper(tipo_lista)), _err(80)
{}


char TRic_ListaMov::look_sdt()
{
  TConfig conf(CONFIG_DITTA);
  return conf.get("FlStTra")[0];
}

bool TRic_ListaMov::look_pag()
{
  TTable t ("%CPG");
  t.zero();
  t.put("CODTAB",_codpag);
  if (t.read() != NOERR) return FALSE;
  return TRUE;
}

const char* TRic_ListaMov::get_codiva_des(const char* codiva)
{
  TTable iva ("%IVA");
  
  iva.zero();
  iva.put("CODTAB", codiva);
  if (iva.read() == NOERR)
    return iva.get("S0");
  else
    return NULL;             
}

bool TRic_ListaMov::DescrConto(int g, int c, long s)
{
  TString80 ragsoc;
  const char* descr = NULL;
  TLocalisamfile pconti (LF_PCON);
  pconti.setkey(1);
  pconti.zero();
  pconti.put(PCN_GRUPPO, g);
  pconti.put(PCN_CONTO,  c);
  pconti.put(PCN_SOTTOCONTO, 0L);
  if (pconti.read() == NOERR)
  {
    _tipo_conto = pconti.get(PCN_TMCF);
    if (_tipo_conto == "C" || _tipo_conto == "F")
    {
     TLocalisamfile clifo (LF_CLIFO);
     clifo.setkey(1);
     clifo.zero();
     clifo.put(CLI_TIPOCF, _tipo_conto);
     clifo.put(CLI_CODCF, s);
     if (clifo.read() != NOERR)
     {
       _descr_conto = ""; 
       return FALSE;
     }
     else
     {
       char tipoa = clifo.get_char("TIPOAPER");
       if (tipoa == 'F') //persona fisica
       { 
         TString80 cognome, nome;
         ragsoc = clifo.get("RAGSOC");
         cognome = ragsoc.mid(0,30);
         nome = ragsoc.mid(30,20);
         cognome.trim(); nome.trim();
         ragsoc = cognome;
         ragsoc << " " << nome;
         _descr_conto = ragsoc;
       } 
       else _descr_conto = clifo.get("RAGSOC");
     }   
    } 
    else
    {
     pconti.zero();
     pconti.put(PCN_GRUPPO, g);
     pconti.put(PCN_CONTO,  c);
     pconti.put(PCN_SOTTOCONTO, s);
     if (pconti.read() != NOERR)
     {
       _descr_conto = "";
       return FALSE;
     }
     else _descr_conto = pconti.get(PCN_DESCR);  
    }
  }
  else 
  {
    _descr_conto = "";
    return FALSE;
  }
  return TRUE;
}

bool TRic_ListaMov::user_create()
{                              
  TToken_string exp;                      
  TToken_string exp1;
  
  _trasfer  = new TTransfer_file();

  _tab_tra = new TTable ("%TRA");
  _tab_tpd = new TTable ("%TPD");
  _tab_pag = new TTable ("%CPG"); 
  _tab_iva = new TTable ("%IVA");
  _tab_ese = new TTable ("ESC");
  
  _caus    = new TLocalisamfile (LF_CAUSALI);
  _ditte   = new TLocalisamfile (LF_NDITTE);
  _clifo   = new TLocalisamfile (LF_CLIFO);
  _pcon    = new TLocalisamfile (LF_PCON);
  _mov     = new TLocalisamfile (LF_MOV);
  _rmov    = new TLocalisamfile (LF_RMOV);
  _rmoviva = new TLocalisamfile (LF_RMOVIVA);  
  
  _part    = NULL;
  _scad    = NULL;
  _pagsca  = NULL;
  _tpart   = NULL;
  _tscad   = NULL;
  _tpagsca = NULL;
  
//  _part    = new TLocalisamfile (LF_PARTITE);  
//  _scad    = new TLocalisamfile (LF_SCADENZE);  
//  _pagsca  = new TLocalisamfile (LF_PAGSCA);  
  
  if (_ric_auto != 'A')
  {
    TIndwin pnd(0,TR("Controllo archivi..."),FALSE, FALSE);
    if (!check_archivi())
      return FALSE;
  }
  
  TFilename tmpmov = "%";
  tmpmov  << get_firm_dir();
  tmpmov << SLASH << TEMP_MOV;
  TFilename tmprmov = "%";
  tmprmov << get_firm_dir();         
  tmprmov << SLASH << TEMP_RMOV;  
  TFilename tmprmoviva = "%";
  tmprmoviva << get_firm_dir();     
  tmprmoviva << SLASH << TEMP_RMOVIVA;

  _tmov  = new TIsamtempfile(LF_MOV, tmpmov, 0);
  _trmov = new TIsamtempfile(LF_RMOV, tmprmov, 0);

  _is_iva = FALSE;
  TFilename tmp = tmprmoviva.mid(1); tmp.ext("dbf");
  if (tmp.exist())  
  {
    _tiva  = new TIsamtempfile(LF_RMOVIVA, tmprmoviva, 0);
    _is_iva = TRUE;
  }
  else
    _tiva = NULL;

  _rel = new TRelation(_tmov);
  _rel->add(_trmov,"NUMREG=NUMREG",1,0,0,FALSE);
  if (_is_iva)
    _rel->add(_tiva, "NUMREG=NUMREG",1,0,0,FALSE);
  _cur = add_cursor(new TCursor (_rel, "", 1));    // Cursore definito sui file dei movimenti contabili e iva

// *************************************************
// *** Parte riguardante il Saldaconto se esiste *** 
// *************************************************
  TFilename tmppart = "%";
  tmppart  << get_firm_dir();
  tmppart << SLASH << TEMP_PART;

  tmp = tmppart.mid(1);
  tmp << ".dbf";
  _is_salda = tmp.exist();
  
  _giornale = new TLibro_giornale();

  printer().footerlen(5);
   
  _tipom_cau       = "";  
  _codpag_scad     = "";
  _risposta        = FALSE;     
  _continua        = TRUE;
  _intestaSC       = FALSE;
  _seconda_volta   = FALSE;
  _errore_grave_SC = FALSE;
  _prima_volta     = TRUE;      
  _gruppo_p        = -1;
  _conto_p         = -1;
  _codcf_p         = -1;
  _prima_rata_pag  = FALSE;      
  _numpart_prec    = ""; 
  _ho_stampato     = FALSE;
  
  return TRUE;
}

void TRic_ListaMov::apri_file_SC()
{ 
  TToken_string exp;                      
  TToken_string exp1;
  TFilename tmp;
// *************************************************
// *** Parte riguardante il Saldaconto se esiste *** 
// *************************************************
  TFilename tmppart = "%";
  tmppart  << get_firm_dir();
  tmppart << "\\" << TEMP_PART;
  TFilename tmpscad = "%";
  tmpscad << get_firm_dir();         
  tmpscad << "\\" << TEMP_SCAD;  
  TFilename tmppagsca = "%";
  tmppagsca << get_firm_dir();     
  tmppagsca << "\\" << TEMP_PAGSCA;

  tmp = tmppart.mid(1);
  tmp << ".dbf";
  _is_salda = tmp.exist();
  if (_is_salda)
  { 
    _part    = new TLocalisamfile (LF_PARTITE);
    _scad    = new TLocalisamfile (LF_SCADENZE);
    _pagsca  = new TLocalisamfile (LF_PAGSCA);      

    _tpart   = new TIsamtempfile(LF_PARTITE,  tmppart, 0);
    _tscad   = new TIsamtempfile(LF_SCADENZE,  tmpscad, 0);
    _tpagsca = new TIsamtempfile(LF_PAGSCA,tmppagsca, 0);
    
    _relSC = new TRelation(_tpart);
    exp.add("TIPOC=TIPOC");
    exp.add("GRUPPO=GRUPPO");
    exp.add("CONTO=CONTO");
    exp.add("SOTTOCONTO=SOTTOCONTO");
    exp.add("ANNO=ANNO");
    exp.add("NUMPART==NUMPART");
    exp.add("NRIGA=NRIGA");
    _relSC->add(_tscad,exp,1,0,0,FALSE);
    exp1.add("TIPOC=TIPOC");
    exp1.add("GRUPPO=GRUPPO");
    exp1.add("CONTO=CONTO");
    exp1.add("SOTTOCONTO=SOTTOCONTO");
    exp1.add("ANNO=ANNO");
    exp1.add("NUMPART==NUMPART");
    _relSC->add(_tpagsca,exp1,1,0,0,FALSE);
    _curSC = add_cursor(new TCursor (_relSC, "", 1));   // Cursore definito sui movimenti del saldaconto 
  }
}

bool TRic_ListaMov::check_archivi()
{
  long ditta_ric = get_firm();
  
  if (!prefix().exist(ditta_ric))
    return error_box(FR("Non esistono gli archivi della ditta %05ld: procedura interrotta"), ditta_ric);
  
  TTransfer_file& tr = trasfer();
  
  _pathfile = tr.path();         
  
  _pathfile = _pathfile << HEADER;
  
  if (!tr.open(_pathfile))
     return error_box(TR("Al momento non ci sono trasferimenti attivi sulla ditta selezionata"));
  
  if (!tr.read_control_rec())
    return error_box(TR("Rilevati errori gravi negli archivi: procedura interrotta"));
  else 
    _record = tr.record();
  
  const char sd = look_sdt();
  if (sd <= ' ')
    return error_box(TR("Ricezione tabelle non effettuata: richiamare il programma relativo"));

  _sdt = sd;
  if (_sdt == 'T')
     return error_box(TR("Ricezione tabelle non effettuata: richiamare il programma relativo"));
     
  if (_sdt == 'M')
     return yesno_box(TR("Controllo gia' effettuato: si desidera ripeterlo ?"));
     
  if (_sdt != '*' && _sdt != 'C')
     return error_box(TR("Rilevati errori gravi negli archivi: procedura interrotta"));
  
  TString16 ult = tr.ult_file();
  TString16 key = tr.key();
  
  ult.strip_spaces(); 
  key.strip_spaces();

  if (_sdt == 'C')
     if ( ult.not_empty() || key.not_empty() )
        return error_box(TR("Rilevati errori gravi negli archivi: procedura interrotta"));

  if (_sdt == '*')
  {
    tr.remove_all();
    return warning_box(TR("Trasferimento interamente completato: proseguire per cancellare i file")); 
  }
  
  return TRUE;        
}
 
void TRic_ListaMov::stampa_errori_mov(int riga)
{
  long i = _err.first_one();
  if (i != -1)
  {
    for (; i <= _err.last_one(); i++)
      if (_err[i])
        set_row(++riga, "@8g%s",  get_error(i));
  }  
} 

int  TRic_ListaMov::cerca_anno_solare_esercizio(int codice)
{      
  TTable ese ("ESC");
  TDate datafine;
  int anno = 0;                        
  TString dep (format("%04d", codice)); 
  
  ese.zero();
  ese.put("CODTAB", dep);   
  if (ese.read() == NOERR)
    datafine = ese.get_date("D1");
    
  if (datafine != botime)
    anno = datafine.year();
    
  return anno;
}

bool TRic_ListaMov::controlla_mov()
{
  bool check_reg = TRUE;
  TString16 causreg;
  TDate udata;
  char tipocf = ' ';
  TTransfer_file& tr = trasfer();
    
  _tiporeg = 0;
  
  if ( !TDate::isdate(_datareg.string()) )
  {
    _errore_grave = TRUE;
    _err.set(0L);
  }

  TString app (_datacomp.string());
  if (app.empty())
    tr.datafine_esprec(_anno,_datacomp);
  
  if ( TDate::isdate(_datareg.string()) )
  { 
    int pr;
    const int ar = date2esc(_datareg);    // Esercizio in corso
    pr = _ec.pred(ar);                    // Esercizio precedente
    if (ar == 0)    
    {
       _err.set(1);
       _errore_grave = TRUE;
    }
    if ( TDate::isdate(_datacomp.string()) )
    {  
      const int ae = date2esc(_datacomp);
      if (ae == 0)
      {
         _err.set(3);
         _errore_grave = TRUE;
      }
      else if (ae != ar && ae != pr && ar)
             _err.set(4);
    }
  }
  
  int pp;
  _annoese = date2esc(_datacomp);    // Esercizio in corso  
  pp = _ec.pred(_annoese);
  
  if ( !TDate::isdate(_datacomp.string()) )
  {
    _errore_grave = TRUE;
    _err.set(2);
  }
    
  TLibro_giornale& gio = giornale();
  bool ok = gio.read(_ae);  //se _ae e' zero la read considera come anno quello corrente
  if (_datareg < gio.last_print())
  {
    _errore_grave = TRUE;
    _err.set(5);
  } 
  
  TString16 dd = _datadoc.string();
  if (dd.not_empty()) 
    if ( !TDate::isdate(_datadoc.string()) )
      _err.set(6);
     
  //if (_causale.not_empty()) 
  //{
    TLocalisamfile caus(LF_CAUSALI);
    caus.setkey(1);
    caus.zero();
    caus.put(CAU_CODCAUS,_causale);
    if (caus.read() == NOERR)
    {   
      _tipodoc   = caus.get(CAU_TIPODOC); 
      if (_is_salda)
        _tipom_cau = caus.get(CAU_TIPOMOV);
    }
    else
    {
      caus.zero();
      if (_causale.not_empty())  //se la causale e' significativa
      {
       _errore_grave = TRUE;
       _err.set(7); 
      } 
    } 
    //_tipodoc = caus.get(CAU_TIPODOC);  ho sempre quello letto sul movimento!
    causreg = caus.get(CAU_REG); 
    _descr_causale = caus.get(CAU_DESCR); 
    _mov_sez = caus.get_bool(CAU_MOVSEZ);
  //}      
  
  if (!_codpag.blank())
  {
    bool ok = look_pag(); 
    if (!ok)
      _err.set(8);
  }   
   
  if (!_registro.blank()) //movimento iva (fattura)
  {
    if (_causale.empty())  //se la causale non e' significativa
    {
      _errore_grave = TRUE;
      check_reg = FALSE;
      _err.set(9);
    }
    if (check_reg && _ae)
    { 
      int anno = cerca_anno_solare_esercizio(_ae);
      TRegistro rg (_registro, anno);   
      if (rg.name().empty())
      {
        _errore_grave = TRUE;
        check_reg = FALSE;
        _err.set(9);
      }
      else
      {
       _tiporeg = rg.tipo();
       udata = rg.last_print();
      }    
    }
  }
  else if (!causreg.blank() && _ae)
  {                                               
    int anno = cerca_anno_solare_esercizio(_ae);  
    TRegistro rg (causreg, anno);   
    if (rg.name().empty())
    {
      _errore_grave = TRUE;
      check_reg = FALSE;
      _err.set(9);
    }
    else 
    {
      _tiporeg = rg.tipo();
      udata = rg.last_print();
    }   
    _registro = causreg;   
  }
/*  
  if (!_registro.blank())
  {
    if (_tiporeg == 1) _tipocf = tipocf = 'C';
    else if (_tiporeg == 2) _tipocf = tipocf = 'F';
//    if (_tiporeg != 0)    //se esiste, uso quello della causale!!!
//    {   
      TTable tabtpd("%TPD");
      tabtpd.put("CODTAB", _tipodoc);
      if (tabtpd.read() == NOERR) 
      {
        bool cor = tabtpd.get_bool("B0");
        if (!cor)
          if (_codcf != 0l)
          { 
            TLocalisamfile clifo(LF_CLIFO);
            clifo.zero();
            clifo.put(CLI_CODCF, _codcf);
            clifo.put(CLI_TIPOCF,tipocf);
            if (clifo.read() != NOERR)    
            {
              _errore_grave = TRUE;
              _err.set(10);
            }
          }
          else 
          {
            _errore_grave = TRUE;
            _err.set(10);
          }
      }
      else
      {
        if (_codcf != 0l)
        { 
          TLocalisamfile clifo(LF_CLIFO);
          clifo.zero();
          clifo.put(CLI_CODCF, _codcf);
          clifo.put(CLI_TIPOCF,tipocf);
          if (clifo.read() != NOERR)    
          {
            _errore_grave = TRUE;
            _err.set(10);
          }
        }
        else 
        {
          _errore_grave = TRUE;
          _err.set(10);
        }
      }
//    }
  }
*/  
  TString16 d74 = _data74tr.string();
  if (d74.not_empty())
    if ( !TDate::isdate(_data74tr.string()) ) 
      _err.set(11);
     
  if (!_registro.blank() && check_reg)
     if (_datareg < udata) 
     {
       _errore_grave = TRUE;
       _err.set(12);
     } 
  
  if (_err.ones())
    return TRUE;
  
  return FALSE;   
} 

bool TRic_ListaMov::errori_partita(int g, int c, long s)
{
  TLocalisamfile pconti (LF_PCON);
  pconti.setkey(1);
  pconti.zero();
  pconti.put(PCN_GRUPPO, g);
  pconti.put(PCN_CONTO,  c);
  pconti.put(PCN_SOTTOCONTO, 0L);
  if (pconti.read() == NOERR)
  {
    char tipo = pconti.get(PCN_TMCF)[0];
    if (tipo == 'C' || tipo == 'F')
    {
     TLocalisamfile clifo (LF_CLIFO);
     clifo.setkey(1);
     clifo.zero();
     clifo.put(CLI_TIPOCF, tipo);
     clifo.put(CLI_CODCF, s);
     if (clifo.read() != NOERR)
        return FALSE; 
    } 
    else
    {
     pconti.zero();
     pconti.put(PCN_GRUPPO, g);
     pconti.put(PCN_CONTO,  c);
     pconti.put(PCN_SOTTOCONTO, s);
     if (pconti.read() != NOERR)
        return FALSE;
    }
  }
  else return FALSE;
  
  return TRUE;
}

void TRic_ListaMov::stampa_errori_partite(int riga)
{
  long i = _err.first_one();
  if (i != -1)
  {
    for (; i <= _err.last_one(); i++)
      if (_err[i])
        set_row(++riga, "@22g%s", get_error(i));
  }  
} 

char TRic_ListaMov::TipoConto(int g, int c)
{
  TLocalisamfile pcon (LF_PCON);
  char tipo = ' ';
  
  pcon.setkey(1);
  pcon.zero();
  pcon.put(PCN_GRUPPO,     g);
  pcon.put(PCN_CONTO,      c);
  pcon.put(PCN_SOTTOCONTO, 0l);
  if (pcon.read() == NOERR)
    tipo = pcon.get_char(PCN_TMCF);
    
  return tipo;
}

bool TRic_ListaMov::controlla_rmov()
{
  TLocalisamfile& rmov = current_cursor()->file(LF_RMOV);
  int gruppo, conto, gruppoc, contoc;
  long sottoconto, sottocontoc;
  char sezione;
  real importo, dare, avere;
  
  if (current_cursor()->is_first_match(LF_RMOV))
  {
    dare = avere = ZERO;
    TRecnotype nrec = rmov.recno();
    rmov.zero();
    rmov.setkey(1);
    rmov.put(RMV_NUMREG, _numero);
    for (rmov.read(_isgteq); !rmov.eof() ;rmov.next())
    {
      const TRectype& rec = rmov.curr();
      if (rec.get_long(RMV_NUMREG) != _numero) 
        break;
      gruppo = rec.get_int(RMV_GRUPPO);
      conto  = rec.get_int(RMV_CONTO);
      sottoconto = rec.get_long(RMV_SOTTOCONTO);
      gruppoc = rec.get_int(RMV_GRUPPOC);
      contoc  = rec.get_int(RMV_CONTOC);
      sottocontoc = rec.get_long(RMV_SOTTOCONTOC);
      sezione = rec.get_char(RMV_SEZIONE);
      importo = rec.get_real(RMV_IMPORTO); 
            
       _tipo_conto = "";

      char tipo  = TipoConto(gruppo,conto);
      char tipoc = TipoConto(gruppoc,contoc);
      aggiorna_rmov(tipo,tipoc);                
     
      if (gruppo != 0 && conto != 0 && sottoconto != 0l)
        _esiste_conto = DescrConto(gruppo,conto,sottoconto);
      else
      {
       _esiste_conto = FALSE;
       _descr_conto = "";
      } 
      
      //_num_rec = rec.get_long(RMV_ANNOES);
      
      if (sezione == 'D') 
        dare += importo;
      if (sezione == 'A')
        avere += importo;
      
      if (gruppo == 0 || conto == 0 || sottoconto == 0l)
      { 
        rmov.readat(nrec);
        return TRUE; 
      }
      else
      { 
        bool ok = errori_partita(gruppo,conto,sottoconto);
        if (!ok) 
        {
          rmov.readat(nrec);
          return TRUE;
        }
      }
  
      if ( (importo != ZERO && sezione == '\0') || 
           (sezione != 'D' && sezione != 'A' && sezione != '\0') )
      {
        rmov.readat(nrec);
        return TRUE;
      }
  
      if (gruppoc != 0 || contoc != 0 || sottocontoc != 0l)
      { 
        bool ok = errori_partita(gruppoc,contoc,sottocontoc);
        if (!ok)
        {
          rmov.readat(nrec);
          return TRUE;
        }
      } 
      
      if (!_mov_sez && importo == ZERO)
      {
        rmov.readat(nrec);
        return TRUE;
      }
    }
    if (dare.round(2) != avere.round(2))
    {
      rmov.readat(nrec);
      return TRUE;
    }                           
    rmov.readat(nrec);
  }
  return FALSE;  
}

void TRic_ListaMov::stampa_errori_rmov(int riga)
{
  if (_gruppo == 0 || _conto == 0 || _sottoconto == 0l) 
  {
    _errore_grave = TRUE;
    set_row(++riga, FR("@8g*** Sottoconto partita non valido o non presente in archivio"));
  }
  else
  { 
    if (!_esiste_conto)
    {    
      _errore_grave = TRUE;
      set_row(++riga, FR("@8g*** Sottoconto partita non valido o non presente in archivio"));
    }
  }
                                        
  if ( (_importo != ZERO && _sezione == '\0') || 
       (_sezione != 'D' && _sezione != 'A' && _sezione != '\0') )
  {     
    _errore_grave = TRUE;
    set_row(++riga, FR("@8g*** Segnale dare/avere non valido"));
  }
  
  if (_sezione == 'D')
     _tot_dare += _importo;
  if (_sezione == 'A')
     _tot_avere += _importo;       
  
  if (_gruppoc != 0 || _contoc != 0 || _sottocontoc != 0l)
  { 
    bool ok = errori_partita(_gruppoc,_contoc,_sottocontoc);
    if (!ok)
      set_row(++riga, FR("@8g--- Sottoconto contropartita non valido o non presente in archivio"));
  } 
  
  if (!_mov_sez && _importo == ZERO)
    set_row(++riga, FR("@8g--- Importo riga uguale a zero"));
} 

bool TRic_ListaMov::controlla_riva()
{
  TLocalisamfile& rmoviva = current_cursor()->file(LF_RMOVIVA);
  TTable  tab_iva("%IVA");
  TString16 codiva;
  int tipodet, tipocr, gruppocr, contocr;
  long sottocontocr;  
  real impo, impos;
  bool testata  = TRUE; 
  bool no_grave = FALSE;
  
  if (current_cursor()->is_first_match(LF_RMOVIVA))
  {
    TRecnotype nrec = rmoviva.recno();
    rmoviva.setkey(1);
    rmoviva.zero();
    rmoviva.put(RMI_NUMREG, _numero);
    TRectype recc (rmoviva.curr());
    for (rmoviva.read(_isgteq); !rmoviva.eof() ;rmoviva.next())
    {
      TRectype rec (rmoviva.curr());
      if (rec > recc) break;
      //_n_rec = rec.get_int(RMI_ANNOES);
      codiva = rec.get(RMI_CODIVA);
      tipodet = rec.get_int(RMI_TIPODET);
      tipocr  = rec.get_int(RMI_TIPOCR);
      gruppocr = rec.get_int(RMI_GRUPPO);
      contocr = rec.get_int(RMI_CONTO);
      sottocontocr = rec.get_long(RMI_SOTTOCONTO);
      impo  = rec.get_real(RMI_IMPONIBILE);
      impos = rec.get_real(RMI_IMPOSTA);
      
      if (testata)
      {                            
        char tipocf = ' ';      
        if (!_registro.blank())
        {
          if (_tiporeg == 1) _tipocf = tipocf = 'C';
          else if (_tiporeg == 2) _tipocf = tipocf = 'F';
          TTable tabtpd("%TPD");
          tabtpd.put("CODTAB", _tipodoc);
          if (tabtpd.read() == NOERR) 
          {
            bool cor = tabtpd.get_bool("B0");
            if (!cor)
              if (_codcf != 0l)
              { 
                TLocalisamfile clifo(LF_CLIFO);
                clifo.zero();
                clifo.put(CLI_CODCF, _codcf);
                clifo.put(CLI_TIPOCF,tipocf);
                if (clifo.read() != NOERR)    
                {
                  _errore_grave = TRUE;
                  _err.set(10);
                }
              }
              else 
              {
                _errore_grave = TRUE;
                _err.set(10);
              }
          }
          else
          {
            if (_codcf != 0l)
            { 
              TLocalisamfile clifo(LF_CLIFO);
              clifo.zero();
              clifo.put(CLI_CODCF, _codcf);
              clifo.put(CLI_TIPOCF,tipocf);
              if (clifo.read() != NOERR)    
              {
                _errore_grave = TRUE;
                _err.set(10);
              }
            }
            else 
            {
              _errore_grave = TRUE;
              _err.set(10);
            }
          }
        }
        testata = FALSE;
      }
      
      //TString impostr = impo.string();
      //TString impostastr = impos.string();
      
      _tot_doc += impo + impos;
      
      //TString totdocstr = _tot_doc.string();
      
      _impo = impo;
      _impos = impos; 

      char tipo = TipoConto(gruppocr,contocr);
      aggiorna_iva(tipo);
     
      if (!_tipodoc.blank())
      {   
        TTable tabtpd("%TPD");
        tabtpd.put("CODTAB", _tipodoc);
        if (tabtpd.read() == NOERR) 
        {
         bool cor = tabtpd.get_bool("B0");
         if (cor)
         {
          _impo  = impo + impos;
          _impos = ZERO;
         }
        }  
      }
      
      TTable iva ("%IVA");
      iva.zero();
      iva.put("CODTAB", codiva);
      if (iva.read() != NOERR)
      {                 
        no_grave = TRUE;
      }
    
      if ( tipocr != 0 && tipocr != 1 && tipocr != 2 && tipocr != 3 && 
           tipocr != 4 && tipocr != 5 && tipocr != 8 && tipocr != 9    )
      { 
        no_grave = TRUE;
      }
      if (gruppocr == 0 || contocr == 0 || sottocontocr == 0l)
      {                 
        no_grave = TRUE;
      }
      else if (gruppocr != 0 && contocr != 0 && sottocontocr != 0l)
      {
        bool ok = errori_partita(gruppocr,contocr,sottocontocr);
        if (!ok) 
        {               
          no_grave = TRUE;
        }
      }  
      if (tipodet != 0 && tipodet != 1 && tipodet != 3 && tipodet != 9)
      {                   
        no_grave = TRUE;
      } 
    }                   
    if (no_grave)
    {
      rmoviva.readat(nrec);
      return TRUE;
    }
    rmoviva.readat(nrec);    
  }
  return FALSE; 
}       

void TRic_ListaMov::stampa_errori_riva(int riga)
{
  TTable iva ("%IVA");
  
  iva.zero();
  iva.put("CODTAB", _codiva);
  if (iva.read() != NOERR)
    set_row(++riga, FR("@8g--- Codice IVA non valido o non presente in tabella"));

  if ( _tipocr != 0 && _tipocr != 1 && _tipocr != 2 && _tipocr != 3 && 
       _tipocr != 4 && _tipocr != 5 && _tipocr != 8 && _tipocr != 9    )
    set_row(++riga, FR("@8g--- Tipo costo/ricavo non valido"));

  if (_gruppocr == 0 || _contocr == 0 || _sottocontocr == 0l)
    set_row(++riga, FR("@8g--- Sottoconto costo/ricavo non valido o non presente in archivio"));
  else if (_gruppocr != 0 && _contocr != 0 && _sottocontocr != 0l)
  {
    bool ok = errori_partita(_gruppocr,_contocr,_sottocontocr);
    if (!ok) 
     set_row(++riga, FR("@8g--- Sottoconto costo/ricavo non valido o non presente in archivio"));
  }  

  if (_tipod != 0 && _tipod != 1 && _tipod != 3 && _tipod != 9)
    set_row(++riga, FR("@8g--- Tipo indetraibilita' non valido"));
}

bool TRic_ListaMov::controlla_anaCF_Pcon(char tipocf,int gruppo,int conto,long codcf)
{                      
  if (codcf == 0)
    return TRUE;
    
  if (tipocf == 'C' || tipocf == 'F')
  {
    TLocalisamfile clifo (LF_CLIFO);
    
    clifo.setkey(1);
    clifo.zero();
    clifo.put(CLI_TIPOCF, tipocf);
    clifo.put(CLI_CODCF,  codcf);
    if (clifo.read() == NOERR)
    {         
      TString descr = clifo.get(CLI_RAGSOC);
      TString app1  = descr.mid(0,30); 
      app1.trim();
      TString app2  = descr.mid(30,20);  
      app2.trim();
      _descr_anag = app1 << " " << app2;
      return TRUE;
    }
    else
    { 
      _descr_anag = "";
      return FALSE;
    }
  } 
  else
  {
    TLocalisamfile pcon (LF_PCON);
    
    pcon.setkey(1);
    pcon.zero();
    pcon.put(PCN_GRUPPO,     gruppo);
    pcon.put(PCN_CONTO,      conto);
    pcon.put(PCN_SOTTOCONTO, codcf);
    if (pcon.read() == NOERR)
    {              
      _descr_anag = pcon.get(PCN_DESCR);
      return TRUE;
    }
    else
    { 
      _descr_anag = "";
      return FALSE;
    }  
  }
  
  return TRUE;
}                  

bool TRic_ListaMov::controlla_anagrafica(char tipo, int gruppo, int conto)
{
  TLocalisamfile pcon (LF_PCON);
  
  pcon.setkey(1);
  pcon.zero();
  pcon.put(PCN_GRUPPO, gruppo);
  pcon.put(PCN_CONTO,  conto);
  pcon.read();
  if (pcon.get_int(PCN_GRUPPO) == gruppo && pcon.get_int(PCN_CONTO) == conto)
    if (pcon.get_char(PCN_TMCF) == tipo)
      return TRUE;

  return FALSE;
}

bool TRic_ListaMov::esiste_rata()
{
  TLocalisamfile& scad = current_cursor()->file(LF_SCADENZE);
  TRecnotype record = scad.recno();
  
  scad.zero();
  scad.put(SCAD_TIPOCF,     _tipocf);
  if (_gruppo != 0)
  scad.put(SCAD_GRUPPO,     _gruppo);
  if (_conto != 0)
    scad.put(SCAD_CONTO,      _conto);
  if (_codcf != 0)
    scad.put(SCAD_SOTTOCONTO, _codcf);
  scad.put(SCAD_ANNO,       _anno);
  scad.put(SCAD_NUMPART,    _numpart);
  scad.put(SCAD_NRIGA,      _nriga);  
    
  TRectype recscad (scad.curr());
    
  for (scad.read(_isgteq); !scad.eof(); scad.next())
  {                                              
    TString rec  = recscad.get(SCAD_NUMPART);
    TString file = scad.get(SCAD_NUMPART);
          
    if (scad.curr() != recscad || file != rec) break;
    
    return TRUE;  
  }    
  scad.readat(record);
  
  return FALSE;
}

const char * TRic_ListaMov::get_error(int err)
{
	switch (err)
	{
		case 0:
			return TR("*** Data operazione non valida");
		break;
		case 1:
      return TR("*** Data operazione non compresa in alcun esercizio");
		break;
		case 2:
      return TR("*** Data competenza non valida");
		break;
		case 3:
      return TR("*** Data competenza non compresa in alcun esercizio");
		break;
		case 4:
      return TR("--- Data competenza incompatibile con data operazione");
		break;
		case 5:
      return TR("*** Data operazione antecedente ad ultima stampa giornale");
		break;
		case 6:
      return TR("--- Data documento non valida");
		break;
		case 7:
      return TR("*** Codice causale non valido o non presente in archivio");
		break;
		case 8:
      return TR("--- Codice pagamento non valido o non presente in tabella");
		break;
		case 9:
      return TR("*** Codice registro IVA non valido o non presente in tabella");
		break;
		case 10:
      return TR("*** Codice cliente/fornitore non valido o non presente in anagrafica");
		break;
		case 11:
      return TR("--- Data 74 ter non valida");
		break;
		case 12:
      return TR("*** Data operazione antecedente ad ultima stampa registro IVA");
		break;
		case 13:
      return TR("*** Tipo anagrafico C/F errato");
		break;
		case 14:
      return TR("*** Codice anagrafico C/F/Piano Conti errato");
		break;
		case 15:
      return TR("*** Rif. partite saldaconto errato");                                     
		break;
		case 16:
      return TR("--- Codice valuta errato");
		break;
		case 17:
      return TR("*** Data cambio non valida");
		break;
		case 18:
      return TR("*** Data pagamento/incasso non valida");
		break;
		case 19:
      return TR("*** Tipo pagamento errato");
		break;
		case 20:
      return TR("*** Segno D/A errato");                                                   
		break;
		case 21:
      return TR("*** Cambio mancante");
		break;
		case 22:
      return TR("*** Gruppo/Conto errato");                    
		break;
		case 23:
      return TR("*** Rif. rata partite saldaconto errato");
		break;
		case 24:
      return TR("*** Data scadenza non valida");
		break;
		case 25:
      return TR("--- Ulteriore classificazione non valida o non presente in archivio");
		break;
		case 26:
      return TR("*** Importo rata in lire mancante");
		break;
		case 27:
      return TR("*** Importo rata in valuta mancante");
		break;
		case 28:
      return TR("--- Codice Nostra banca non valido o non presente in archivio");
		break;
		case 29:
      return TR("--- Codice Vostra banca non valido o non presente in archivio");
		break;
		case 30:
      return TR("--- Codice agente non valido o non presente in archivio");          
		break;
		case 31:
      return TR("--- Data sollecito non valida");
		break;
		case 32:
      return TR("*** Rif. fattura errato");
		break;
		case 33:
      return TR("*** Rif. rata fattura errato");
		break;
		case 34:
      return TR("*** In acconto/a saldo errato");
		break;
		case 35:
      return TR("*** Importo inc./pag. in lire mancante");
		break;
		case 36:
      return TR("*** Importo inc./pag. in valuta mancante");
		break;
		case 37:
      return TR("*** Flag abbuono attivo/passivo errato");
		break;
		case 38:
      return TR("*** Codice valuta errato");
		break;
		case 39:
      return TR("*** Tipo movimento causale non congruo con tipo movimento saldaconto");
		break;
		case 40:
      return TR("--- Tipo pagamento del codice di pagamento non congruo con tipo pagamento del saldaconto");
		break;
		default:
			return "";
		break;
	}
}

bool TRic_ListaMov::controlla_partite()
{
  if (_tipocf != 'C' && _tipocf != 'F' && _tipocf != '\0')
  {
    _errore_grave_SC = TRUE;
    _err.set(13);
  }
  
  if (!controlla_anaCF_Pcon(_tipocf,_gruppo,_conto,_codcf))
  {
    _errore_grave_SC = TRUE;
    _err.set(14);
  }
  
  if (_anno == 0 || _numpart.empty() || _nriga == 0)
  {
    _errore_grave_SC = TRUE;
    _err.set(15);
  }
  
  if ( !TDate::isdate(_datareg.string()) )
  {
    _errore_grave_SC = TRUE;
    _err.set(0L);
  }
  
  TString16 dd = _datadoc.string();
  if (dd.not_empty()) 
    if ( !TDate::isdate(_datadoc.string()) )
      _err.set(6);
  
  if (_causale.empty())
  {                   
    _descr_causale = "";
    if (_numreg != 0)
    {
      _errore_grave_SC = TRUE;
      _err.set(7); 
    } 
  }
  else
  {   
    TLocalisamfile caus(LF_CAUSALI);
    caus.setkey(1);
    caus.zero();
    caus.put(CAU_CODCAUS,_causale);
    if (caus.read() != NOERR)   
    {
      caus.zero();
      _errore_grave_SC = TRUE;
      _err.set(7); 
    } 
    _descr_causale = caus.get(CAU_DESCR);     
    int tipomov_caus   = caus.get_int(CAU_TIPOMOV);
    if (_tipomov != tipomov_caus)
    {
      _errore_grave_SC = TRUE;
      _err.set(39);
    }
  }
                 
  if (_codval.not_empty())
  {
    TTable val ("%VAL");
    
    TString dep (format("%-3s", (const char*) _codval));
    
    val.zero();
    val.put("CODTAB", dep);
    if (val.read() != NOERR)
    {
     _errore_grave_SC = TRUE;
     _err.set(38);    
    }   

    if (_cambio == ZERO)
    {
     _errore_grave_SC = TRUE;
     _err.set(21);
    }
    
    TString16 dcam = _datacam.string();
      if (dcam.empty() || !TDate::isdate(_datacam.string()) ) 
        _err.set(17);
  }
  
  if (_tipomov != 1)
  {       
    if (esiste_rata())
    {
      if (_tipopag < 1 || _tipopag > 9)
      {
        _errore_grave_SC = TRUE;
        _err.set(19);    
      }    
      TString datapag_str = _datapag.string();
      if ( datapag_str.empty() || !TDate::isdate(_datapag.string()) )     
      {
       _errore_grave_SC = TRUE;
       _err.set(18);
      }  
    }
  }

  if (_gruppocl != 0 && _contocl != 0)
  {
    if (!controlla_anagrafica(_tipocf,_gruppocl,_contocl))    
    {
      _errore_grave_SC = TRUE;
      _err.set(22);
    }
  }

  if (_sez != 'D' && _sez != 'A')
  {
    _errore_grave_SC = TRUE;
    _err.set(20);    
  }
  
  if (_err.ones())
    return TRUE;
  
  return FALSE;   
}
                     
bool TRic_ListaMov::cerca_codpag(TString& codpag)
{             
  TTable cpg ("%CPG"); 
  
  _descr_pag = "";
  
  cpg.zero();
  cpg.put("CODTAB", codpag);
  if (cpg.read() == NOERR)      
  { 
    _descr_pag   = cpg.get("S0");  
//    _tipopag_pag = atoi(cpg.get("S4"));
    return TRUE;
  }                            
    
  return FALSE;
}

bool TRic_ListaMov::cerca_tipopag_codpag(TString& codpag, int tipopag)
{             
  TTable rpg ("%RPG");
  TString16 dep; 
   
  for (int i = 0; ; i++)
  { 
    dep.format("%-s%3d", (const char*) codpag, i);
    rpg.put("CODTAB", dep);
    if (rpg.read() == NOERR)      
    {         
      const int tipo = rpg.get_int("I1");
      if (tipo == tipopag) 
      {
        _tipopag_pag = tipo;
        return TRUE;  
      }
    } 
    else
      break;
  }                            
    
  return FALSE;
}

bool TRic_ListaMov::ulteriore_classificazione(int tipopag, TString& ultclass)
{
  TTable clr ("%CLR");
  
  TString dep (format("%d%s", tipopag, (const char*) ultclass));
  
  clr.zero();
  clr.put("CODTAB", dep);
  if (clr.read() == NOERR)
    return TRUE;
    
  return FALSE;
}

bool TRic_ListaMov::banca(long abi,long cab)
{ 
  if (abi == 0 && cab == 0)
    return TRUE;
              
  TTable ban ("%BAN");
  TString dep;
  
  if (abi != 0 && cab != 0)
    dep.format("%05ld%05ld", abi,cab);
  if (abi != 0 && cab == 0)           
    dep.format("%05ld", abi);
                       
  ban.zero();
  ban.put("CODTAB", dep);
  if (ban.read() == NOERR)
    return TRUE;
    
  return FALSE;
}

bool TRic_ListaMov::agente(const char* codag) const
{   
  static int test_file = -1;

  bool ok = TRUE;
  if (codag && *codag)
  {                         
    if (test_file < 0)
    {
      TDir d; d.get(LF_AGENTI);
      test_file = fexist(d.filename());        // Controlla l'esistenza del file
    }
    if (test_file)
    {
      const TRectype& age = cache().get(LF_AGENTI, codag);
      ok = !age.empty();
    }
  }
  return ok;
}

bool TRic_ListaMov::controlla_scadenze()
{       
  int     tipopag,nrata;
  TString codpag,ultclass,codag;                     
  TDate   datascad,datasoll;
  real    importo,importoval;
  long    abins,cabns,abivs,cabvs;
  
  importo    = ZERO;
  importoval = ZERO;
  
  TLocalisamfile& scad = current_cursor()->file(LF_SCADENZE);
  
  if (current_cursor()->is_first_match(LF_SCADENZE))
  {
    TRecnotype nrec = scad.recno();
    scad.zero();
    scad.setkey(1);
    scad.put(SCAD_TIPOCF,     _tipocf);  
    if (_gruppo != 0)
      scad.put(SCAD_GRUPPO,     _gruppo);
    if (_conto != 0)
      scad.put(SCAD_CONTO,      _conto);
    if (_codcf != 0)  
      scad.put(SCAD_SOTTOCONTO, _codcf);
    scad.put(SCAD_ANNO,       _anno);
    scad.put(SCAD_NUMPART,    _numpart);
    scad.put(SCAD_NRIGA,      _nriga);
    TRectype recc (scad.curr());
    for (scad.read(_isgteq); !scad.eof() ;scad.next())
    {
      TRectype rec (scad.curr()); 
      
      TString filea = recc.get(SCAD_NUMPART);
      TString file  = rec.get(SCAD_NUMPART);
      
      if (rec != recc || file != filea) break;
      
      nrata      = rec.get_int (SCAD_NRATA);
      tipopag    = rec.get_int (SCAD_TIPOPAG);
      codpag     = rec.get     (SCAD_CODPAG);
      ultclass   = rec.get     (SCAD_ULTCLASS);
      datascad   = rec.get_date(SCAD_DATASCAD);
      datasoll   = rec.get_date(SCAD_DATASOLL); 
      importo    = rec.get_real(SCAD_IMPORTO);
      importoval = rec.get_real(SCAD_IMPORTOVAL); 
      abins      = rec.get_long(SCAD_CODABIPR);
      cabns      = rec.get_long(SCAD_CODCABPR);
      abivs      = rec.get_long(SCAD_CODABI);
      cabvs      = rec.get_long(SCAD_CODCAB);
      codag      = rec.get     (SCAD_CODAG);
      
      if (nrata == 0)
      {
        scad.readat(nrec);
        return TRUE;
      }  
      if ( !TDate::isdate(datascad.string()) )
      {
        scad.readat(nrec);
        return TRUE;
      }   
      if (codpag.not_empty())        // Modifica 01-10-96 chiesta da Patrizia: se il codice di 
      {                              // pagamento non e' significativo non va controllato,
        if (!cerca_codpag(codpag))   // altrimenti si presenta l'errore su quelle partite 
        {                            // generate in automatico dove non e' possibile indicare
          scad.readat(nrec);         // il codice di pagamento.
          return TRUE;      
        }
        if (tipopag < 1 || tipopag > 9)
        {
          scad.readat(nrec);
          return TRUE;
        }
        if (!cerca_tipopag_codpag(codpag,tipopag))
        {
          scad.readat(nrec);
          return TRUE;
        } 
      }
      if (ultclass.not_empty())
      {
        if (!ulteriore_classificazione(tipopag,ultclass))
        {
          scad.readat(nrec);
          return TRUE;
        }
      }  
      if (importo == ZERO)
      {
        scad.readat(nrec);
        return TRUE;
      }             
      if (_codval.not_empty() && importoval == ZERO)
      {
        scad.readat(nrec);
        return TRUE;
      }          
      if (!banca(abins,cabns))
      {
        scad.readat(nrec);
        return TRUE;
      }             
      if (!banca(abivs,cabvs))
      {
        scad.readat(nrec);
        return TRUE;
      }             
      if (!agente(codag))
      {
        scad.readat(nrec);
        return TRUE;
      }    
      TString datasoll_str = datasoll.string();
      if ( datasoll_str.not_empty() && !TDate::isdate(datasoll.string()) )
      {
        scad.readat(nrec);
        return TRUE;
      }
    }
    scad.readat(nrec);
  }
  return FALSE;  
}

void TRic_ListaMov::descrizione_pagamento(TString& descr,int tipopag,TString& ultclass,TString& codpag)
{  
  TString dep;
  
  if (ultclass.not_empty())
  {
    TTable clr ("%CLR");
    
    dep.format("%d%s", tipopag,(const char*) ultclass);
    
    clr.zero();
    clr.put("CODTAB", dep);
    if (clr.read() == NOERR)
      descr = clr.get("S0");
    else 
      descr = "";
  }
  else
  {
    TTable rpg ("%RPG");
    int tipo;
    
    for (int i = 0; !rpg.eof(); rpg.next(), i++)
    {
      dep.format("%-s%3d", (const char*) codpag, i);
    
      rpg.zero();
      rpg.put("CODTAB", dep);
      if (rpg.read() == NOERR)   
      {
        tipo = rpg.get_int("I1");
        if (tipo == tipopag)
        {
          switch(tipo)
          {
            case 1: descr = TR("Rimessa diretta");
                    break;
            case 2: descr = TR("Tratta");
                    break;
            case 3: descr = TR("Ricevuta bancaria");
                    break;
            case 4: descr = TR("Cessione");
                    break;
            case 5: descr = TR("Paghero'");
                    break;
            case 6: descr = TR("Lettera di credito");
                    break;
            case 7: descr = TR("Tratta accettata");
                    break;
            case 8: descr = TR("Rapporti interbancari diretti");
                    break;
            case 9: descr = TR("Bonifico");
                    break;
            case 10: descr = TR("Altro");
                     break;
            default: break;
          };
          break;
        }
      }  
      else
      {
        descr = ""; 
        break;
      }
    }    
  }
}

void TRic_ListaMov::stampa_errori_scadenze(int riga)
{                                 
  TCursor* cur = current_cursor();
  
  TString numpart    = cur->curr(LF_SCADENZE).get     (SCAD_NUMPART);
  int     nriga      = cur->curr(LF_SCADENZE).get_int (SCAD_NRIGA);
  int     nrata      = cur->curr(LF_SCADENZE).get_int (SCAD_NRATA);
  int     tipopag    = cur->curr(LF_SCADENZE).get_int (SCAD_TIPOPAG);
  TString codpag     = cur->curr(LF_SCADENZE).get     (SCAD_CODPAG);
  TString ultclass   = cur->curr(LF_SCADENZE).get     (SCAD_ULTCLASS);
  TDate   datascad   = cur->curr(LF_SCADENZE).get_date(SCAD_DATASCAD);
  TDate   datasoll   = cur->curr(LF_SCADENZE).get_date(SCAD_DATASOLL);
  real    importo    = cur->curr(LF_SCADENZE).get_real(SCAD_IMPORTO);
  real    importoval = cur->curr(LF_SCADENZE).get_real(SCAD_IMPORTOVAL);
  long    abins      = cur->curr(LF_SCADENZE).get_long(SCAD_CODABIPR);
  long    cabns      = cur->curr(LF_SCADENZE).get_long(SCAD_CODCABPR);
  long    abivs      = cur->curr(LF_SCADENZE).get_long(SCAD_CODABI);
  long    cabvs      = cur->curr(LF_SCADENZE).get_long(SCAD_CODCAB);
  TString codag      = cur->curr(LF_SCADENZE).get     (SCAD_CODAG);
  
  TString descr_pagamento;
  descrizione_pagamento(descr_pagamento,tipopag,ultclass,codpag);

  if (_prima_rata_pag)
  {
    set_row(riga,FR("@26gN.rata      Data scad.  Sez          Importo  Importo valuta"));
    set_row(riga++,FR("@88gCond.pagamento                                                        Nostra banca  Vostra banca    Agente"));
    _prima_rata_pag = FALSE;
  }
  set_row(riga,"@27g%4d", nrata);
  set_row(riga,"@38g%10s", (const char*) datascad.string());
  set_row(riga,"@51g%c", _sez);
  set_row(riga,"@55g%r", &importo);
  if (importoval != ZERO)
    set_row(riga,"@71g%15s", importoval.string("###.###.###,@@@"));  
  set_row(riga,"@88g%-4s", (const char*) codpag);
  set_row(riga,"@92g/@93g%d", tipopag);
  set_row(riga,"@94g/@95g%s", (const char*) ultclass);
  set_row(riga,"@100g%-50s", (const char*) descr_pagamento);
  if (abins != 0)
    set_row(riga,"@158g%ld", abins);
  if (cabns != 0)
    set_row(riga,"@165g%ld", cabns);
  if (abivs != 0)
    set_row(riga,"@172g%ld", abivs);
  if (cabvs != 0)
    set_row(riga,"@179g%ld", cabvs);
  set_row(riga,"@189g%-5s", (const char*) codag);
  
  if (nrata == 0)
  {
    _errore_grave_SC = TRUE;
    set_row(++riga, "@30g%s", get_error(23));
  }  
  if ( !TDate::isdate(datascad.string()) )
  {
    _errore_grave_SC = TRUE;
    set_row(++riga, "@30g%s", get_error(24));
  }
  if (codpag.not_empty())          // Modifica 01-10-96 chiesta da Patrizia: per spiegazione vedi
  {                                // funzione controlla_scadenze();
    if (!cerca_codpag(codpag)) 
    {
      _errore_grave_SC = TRUE;
      set_row(++riga, "@30g*** Codice pagamento non valido o non presente in tabella");
    }
    if (tipopag < 1 || tipopag > 9)
    {
      _errore_grave_SC = TRUE;
      set_row(++riga, "@30g%s", get_error(19));
    }
    
    if (!cerca_tipopag_codpag(codpag,tipopag))
    {
      // _errore_grave_SC = TRUE;   // CM700491
      set_row(++riga, "@30g%s",  get_error(40));
    } 
  }
  if (ultclass.not_empty())
  {
    if (!ulteriore_classificazione(tipopag,ultclass))
      set_row(++riga, "@30g%s", get_error(25));
  }  
  if (importo == ZERO)
  {
    _errore_grave_SC = TRUE;
    set_row(++riga, "@30g%s", get_error(26));
  }             
  if (_codval.not_empty() && importoval == ZERO)
  {
    _errore_grave_SC = TRUE;
    set_row(++riga, "@30g%s", get_error(27));
  }          
  if (!banca(abins,cabns))
    set_row(++riga, "@30g%s", get_error(28));
             
  if (!banca(abivs,cabvs))
    set_row(++riga, "@30g%s", get_error(29));
             
  if (!agente(codag))
    set_row(++riga, "@30g%s", get_error(30));
  
  TString datasoll_str = datasoll.string();
  if ( datasoll_str.not_empty() && !TDate::isdate(datasoll.string()) )
    set_row(++riga, "@30g%s", get_error(31));
}

bool TRic_ListaMov::record_partite(int nriga)
{         
  bool ok = FALSE;
  for (int p = 0; p < 2 && !ok; p++)
  {                         
    TLocalisamfile* fpart = p == 0 ? _tpart : _part;
    TLocalisamfile& part = *fpart;
    const TRecnotype nrec = part.recno();
    part.zero();
    part.put(PART_TIPOCF,     _tipocf);
    part.put(PART_GRUPPO,     _gruppo);
    part.put(PART_CONTO,      _conto);
    part.put(PART_SOTTOCONTO, _codcf);
    part.put(PART_ANNO,       _anno);
    part.put(PART_NUMPART,    _numpart);
    part.put(PART_NRIGA,      nriga);
    ok = part.read() == NOERR;
    part.readat(nrec);
  }  
  return ok;
}

bool TRic_ListaMov::record_scadenze(int nrigp,int nrata)
{
  bool ok = FALSE;
  for (int p = 0; p < 2 && !ok; p++)
  {                         
    TLocalisamfile* fscad = p == 0 ? _tscad : _scad;
    TLocalisamfile& scad = *fscad;

    const TRecnotype nrec = scad.recno();
  
    scad.zero();
    scad.put(SCAD_TIPOCF,     _tipocf);
    scad.put(SCAD_GRUPPO,     _gruppo);
    scad.put(SCAD_CONTO,      _conto);
    scad.put(SCAD_SOTTOCONTO, _codcf);
    scad.put(SCAD_ANNO,       _anno);
    scad.put(SCAD_NUMPART,    _numpart);
    scad.put(SCAD_NRIGA,      nrigp); 
    scad.put(SCAD_NRATA,      nrata);
    ok = scad.read() == NOERR;
    scad.readat(nrec);
  }
  return ok;
}

bool TRic_ListaMov::controlla_pagsca()
{                                   
  char    tipoc,accsaldo,passat;
  int     nriga,nrata,gruppoc,contoc;
  TString codag;                     
  real    importo,importoval,abbuoni;
  long    abins,cabns,abivs,cabvs,sottocc;
  bool    errore_non_grave = FALSE;
  
  importo    = ZERO;
  importoval = ZERO;
  
  TLocalisamfile& pagsca = current_cursor()->file(LF_PAGSCA);
  
  if (current_cursor()->is_first_match(LF_PAGSCA))
  {
    TRecnotype nrec = pagsca.recno();
    pagsca.zero();
    pagsca.setkey(1);
    pagsca.put(PAGSCA_TIPOC,     _tipocf);  
    if (_gruppo != 0)
      pagsca.put(PAGSCA_GRUPPO,     _gruppo);
    if (_conto != 0)
      pagsca.put(PAGSCA_CONTO,      _conto);
    if (_codcf != 0)  
      pagsca.put(PAGSCA_SOTTOCONTO, _codcf);
    pagsca.put(PAGSCA_ANNO,       _anno);
    pagsca.put(PAGSCA_NUMPART,    _numpart);
    
    TRectype recc (pagsca.curr());
    for (pagsca.read(_isgteq); !pagsca.eof() ;pagsca.next())
    {                               
      int nrigp  = pagsca.get_int(PAGSCA_NRIGP);
      TRectype rec (pagsca.curr());
      
      TString filea = recc.get(PAGSCA_NUMPART);
      TString file  = rec.get(PAGSCA_NUMPART);
      
      if (rec != recc || file != filea) break;
      if (nrigp != _nriga) continue;
      
      nriga      = rec.get_int (PAGSCA_NRIGA);
      nrata      = rec.get_int (PAGSCA_NRATA);
      accsaldo   = rec.get_char(PAGSCA_ACCSAL);
      importo    = rec.get_real(PAGSCA_IMPORTO);
      importoval = rec.get_real(PAGSCA_IMPORTOVAL);  
      abbuoni    = rec.get_real(PAGSCA_ABBUONI);
      passat     = rec.get_char(PAGSCA_PASSATT);
      abins      = rec.get_long(PAGSCA_CODABIPR);
      cabns      = rec.get_long(PAGSCA_CODCABPR);
      abivs      = rec.get_long(PAGSCA_CODABI);
      cabvs      = rec.get_long(PAGSCA_CODCAB);
      codag      = rec.get     (PAGSCA_CODAG); 
      tipoc      = rec.get_char(PAGSCA_TIPOCC);
      gruppoc    = rec.get_int (PAGSCA_GRUPPOC);
      contoc     = rec.get_int (PAGSCA_CONTOC);
      sottocc    = rec.get_long(PAGSCA_SOTTOCONTC);
      
      if (nriga != 9999)
      { 
        if (!record_partite(nriga))
        {
          pagsca.readat(nrec);
          return TRUE;
        }
      }  
      if (nrata != 9999)
      {
        if (!record_scadenze(nriga,nrata))
        {
          pagsca.readat(nrec);
          return TRUE;
        }
      }               
      if (accsaldo != 'A' && accsaldo != 'S')
      {
        pagsca.readat(nrec);
        return TRUE;
      }
      if (importo == ZERO) 
      {
        pagsca.readat(nrec);
        return TRUE;      
      }
      if (_codval.not_empty() && importoval == ZERO)
      {
        pagsca.readat(nrec);
        return TRUE;
      }
      if (abbuoni != ZERO && (passat != 'A' && passat != 'P') )
      {
        pagsca.readat(nrec);
        return TRUE;
      }  
      if (!banca(abins,cabns))
        errore_non_grave = TRUE;
      if (!banca(abivs,cabvs))
        errore_non_grave = TRUE;
      if (!agente(codag))
        errore_non_grave = TRUE;
      if (!controlla_anaCF_Pcon(tipoc,gruppoc,contoc,sottocc))
        errore_non_grave = TRUE;
    }
    pagsca.readat(nrec);        
    if (errore_non_grave )
      return TRUE;
  }
  return FALSE;  
}

void TRic_ListaMov::stampa_errori_pagsca(int riga)
{                                 
  TCursor* cur = current_cursor();
  const TRectype& pagsca = cur->curr(LF_PAGSCA);
  
  int nrigp = pagsca.get_int (PAGSCA_NRIGP);
  if (nrigp == _nriga)
  {
    int     nriga      = pagsca.get_int (PAGSCA_NRIGA);
    int     nrata      = pagsca.get_int (PAGSCA_NRATA);
    char    accsaldo   = pagsca.get_char(PAGSCA_ACCSAL);
    real    importo    = pagsca.get_real(PAGSCA_IMPORTO);
    real    importoval = pagsca.get_real(PAGSCA_IMPORTOVAL);
    real    abbuoni    = pagsca.get_real(PAGSCA_ABBUONI);
    real    ritenute   = pagsca.get_real(PAGSCA_RITENUTE);
    real    ritsoc     = pagsca.get_real(PAGSCA_RITSOC);
    real    diffcam    = pagsca.get_real(PAGSCA_DIFFCAM);
    char    passat     = pagsca.get_char(PAGSCA_PASSATT);
    long    abins      = pagsca.get_long(PAGSCA_CODABIPR);
    long    cabns      = pagsca.get_long(PAGSCA_CODCABPR);
    long    abivs      = pagsca.get_long(PAGSCA_CODABI);
    long    cabvs      = pagsca.get_long(PAGSCA_CODCAB);
    TString codag      = pagsca.get     (PAGSCA_CODAG);  
    char    tipoc      = pagsca.get_char(PAGSCA_TIPOCC);
    int     gruppoc    = pagsca.get_int (PAGSCA_GRUPPOC);
    int     contoc     = pagsca.get_int (PAGSCA_CONTOC);
    long    sottocc    = pagsca.get_long(PAGSCA_SOTTOCONTC);
  
    controlla_anaCF_Pcon(tipoc,gruppoc,contoc,sottocc);
  
    if (_prima_rata_pag)
    {                   
      set_row(riga,FR("@22gRif. rata       acc./saldo  Sez          Importo  Importo valuta  Contropartita"));
      set_row(riga++,FR("@158gNostra banca  Vostra banca    Agente"));
      _prima_rata_pag = FALSE;
    }     
    else
      set_row(riga++, "");
    
    set_row(riga,"@22g%4d", nriga);
    set_row(riga,"@26g/@27g%4d", nrata);
    set_row(riga,"@42g%c", accsaldo);
    set_row(riga,"@51g%c", _sez);
    set_row(riga,"@55g%r", &importo);
    if (importoval != ZERO)
      set_row(riga,"@71g%15s", (const char*) importoval.string("###.###.###,@@@"));  
    set_row(riga,"@88g%c", tipoc); 
    if (gruppoc != 0)
      set_row(riga,"@90g%3d", gruppoc);
    if (contoc != 0)
      set_row(riga,"@94g%3d", contoc);
    if (sottocc != 0)         
    {
      set_row(riga,"@98g%6ld", sottocc); 
      set_row(riga,"@105g%-50s", (const char*) _descr_anag);
    }
    if (abins != 0)
      set_row(riga,"@158g%ld", abins);
    if (cabns != 0)
      set_row(riga,"@165g%ld", cabns);
    if (abivs != 0)
      set_row(riga,"@172g%ld", abivs);
    if (cabvs != 0)
      set_row(riga,"@179g%ld", cabvs);
    set_row(riga,"@189g%-5s", (const char*) codag);
    if (ritenute != ZERO)
    { 
      riga++;
      set_row(riga,"@51g%c", _sez);
      set_row(riga,"@55g%r", &ritenute);
      set_row(riga,FR("@88gRitenute professionali"));
    }
    if (abbuoni != ZERO)
    {             
      riga++;
      char sezione;
      if (passat == 'A')
        sezione = 'D';
      else
        if (passat == 'P')
          sezione = 'A';
    
      if (sezione != _sez)
        abbuoni = abbuoni * -1;
          
      set_row(riga,"@51g%c", sezione);  
      if (_codval.not_empty())
        set_row(riga,"@71g%15s", (const char*) abbuoni.string("###.###.###,@@@"));
      else
        set_row(riga,"@55g%r", &abbuoni);
      if (passat == 'A')
        set_row(riga,"@88gAbbuoni attivi");
      else
        if (passat == 'P')
          set_row(riga,FR("@88gAbbuoni passivi"));
    }                                    
    if (diffcam != ZERO)
    {             
      riga++;
      char sezione = _sez;
      if (diffcam < ZERO)
      {
        diffcam = diffcam * -1;
        if (_sez == 'D')
          sezione = 'A';
        else
          if (_sez == 'A')
            sezione = 'D';
      }
      set_row(riga,"@51g%c", sezione);
      set_row(riga,"@55g%r", &diffcam);
      set_row(riga,FR("@88gDifferenza cambio"));
    }

    if (nriga != 9999)
    { 
      if (!record_partite(nriga))
      {
        _errore_grave_SC = TRUE;
        set_row(++riga, "@30g%s", get_error(32));
      }
    }  
    if (nrata != 9999)
    {
      if (!record_scadenze(nriga,nrata))
      {
        _errore_grave_SC = TRUE;
        set_row(++riga, "@30g%s", get_error(33));
      }
    }               
    if (accsaldo != 'A' && accsaldo != 'S')
    {
      _errore_grave_SC = TRUE;
      set_row(++riga, "@30g%s", get_error(34));
    }
    if (importo == ZERO)
    {
      _errore_grave_SC = TRUE;
      set_row(++riga, "@30g%s", get_error(35));
    }             
    if (_codval.not_empty() && importoval == ZERO)
    {
      _errore_grave_SC = TRUE;
      set_row(++riga, "@30g%s", get_error(36));
    }          
    if (abbuoni != ZERO && (passat != 'A' && passat != 'P') )
    {
      _errore_grave_SC = TRUE;
      set_row(++riga, "@30g%s", get_error(37));
    }  
    if (!banca(abins,cabns))
      set_row(++riga, "@30g%s", get_error(28));
             
    if (!banca(abivs,cabvs))
      set_row(++riga, "@30g%s", get_error(29));
             
    if (!agente(codag))
      set_row(++riga, "@30g%s", get_error(30));

    if (!controlla_anaCF_Pcon(tipoc,gruppoc,contoc,sottocc))
      set_row(++riga, FR("@30g--- Codice contropartita errato"));
  }  
}

void TRic_ListaMov::azzera_impdocval()
{
  TRecnotype recn = _tpart->recno();
  TIsamtempfile& part = *_tpart;
   
  part.setkey(1);
  part.zero();
   
  for (part.first(); !part.eof(); part.next())
  {
    int tipomov = part.get_int(PART_TIPOMOV);
    
    if (tipomov != 1 && tipomov != 4)
    {
      part.zero(PART_IMPTOTDOC);
      part.zero(PART_IMPTOTVAL);   
      
      part.rewrite();
    }
  }      
  _tpart->readat(recn);
}

bool TRic_ListaMov::preprocess_print(int file, int counter)
{
  if (file == LF_PARTITE)
    azzera_impdocval();
  
  return TRUE;
}
 
bool TRic_ListaMov::preprocess_page(int file,int counter)
{
  TCursor* cur = current_cursor();

  if (counter) return TRUE;
  
  reset_print();
  
  if (file == LF_MOV)
  {
    _anno     = cur->curr(LF_MOV).get_int(MOV_ANNOES);
    _datacomp = cur->curr(LF_MOV).get_date(MOV_DATACOMP);
    _datadoc  = cur->curr(LF_MOV).get_date(MOV_DATADOC);
    _data74tr = cur->curr(LF_MOV).get_date(MOV_DATA74TER);
    _causale  = cur->curr(LF_MOV).get(MOV_CODCAUS);
    _registro = cur->curr(LF_MOV).get(MOV_REG);  
    format_if_zero(_registro, 3);
    _tipodoc  = cur->curr(LF_MOV).get(MOV_TIPODOC);
    _numdoc   = cur->curr(LF_MOV).get(MOV_NUMDOC);
    _datareg  = cur->curr(LF_MOV).get_date(MOV_DATAREG);
    _codcf    = cur->curr(LF_MOV).get_long(MOV_CODCF);
    _numero   = cur->curr(LF_MOV).get_long(MOV_NUMREG);
    _protiva  = cur->curr(LF_MOV).get_long(MOV_PROTIVA);
    _codval   = cur->curr(LF_MOV).get(MOV_CODVALI);
    _codpag   = cur->curr(LF_MOV).get(MOV_CODPAG);
    _annoiva  = _datareg.year();
    
    _tot_dare = _tot_avere = ZERO;
    _tot_doc  = ZERO;
    _tipodoc  = "";
    _tipocf   = ' ';
    
    _ae = date2esc(_datareg);
    
    //_num_rec = cur->curr(LF_MOV).get_long(MOV_NUMGIO);
    
    bool controlla = controlla_mov(); //se TRUE => ci sono errori nella testata
    bool veriva = FALSE;
    if (_is_iva)                      //Va fatto solo se ho ricevuto anche l'iva
      veriva = controlla_riva();
    bool verrmov   = controlla_rmov();
    bool verifica  = (veriva || verrmov);
    
    aggiorna_mov();
    
    if ( (_controllo == 1 && controlla) || _controllo == 2 ||
         (_controllo == 1 && verifica) ) 
    {
      TString16 datareg_str = _datareg.string();
      // "Fai vedere lo stesso ..-..-.... anche se non c'e' la data..."    
      if (datareg_str.empty())
        datareg_str = "  -  -    ";
      TString16 datadoc_str = _datadoc.string();
      if (datadoc_str.empty())
        datadoc_str = "  -  -    "; 
      int r = 1;
      set_row(r++, ""); 
      set_row(r,FR("Operazione n. %-7ld"), _numero);
      set_row(r,FR(" del %s"), (const char*)datareg_str);
      set_row(r,FR(" doc. n. %-7s"), (const char*)_numdoc);
      set_row(r,FR(" del %s"), (const char*)datadoc_str);
      if (!_registro.blank())  //e' una fattura
      {
       set_row(r,FR(" registro IVA %-3s"), (const char*)_registro);
       set_row(r,FR(" protocollo n. %-5ld"), _protiva);
      } 
      set_row(r, FR(" comp. %d"), _anno); 

      // Guy: Aggiunta stampa mese di liquidazione se presente
      const int meseliq = cur->curr(LF_MOV).get_int(MOV_MESELIQ);
      if (meseliq > 0)
        set_row(r, FR(" mese liq. %d"), meseliq);
     
      stampa_errori_mov(r);  
                          
      _ho_stampato = TRUE;                    
      return TRUE;
    }
    return FALSE;
  }   
  else if (file == LF_RMOV)
  {
    _gruppo = cur->curr(LF_RMOV).get_int(RMV_GRUPPO);
    _conto  = cur->curr(LF_RMOV).get_int(RMV_CONTO);
    _sottoconto = cur->curr(LF_RMOV).get_long(RMV_SOTTOCONTO); 
    _gruppoc = cur->curr(LF_RMOV).get_int(RMV_GRUPPOC);
    _contoc  = cur->curr(LF_RMOV).get_int(RMV_CONTOC);
    _sottocontoc = cur->curr(LF_RMOV).get_long(RMV_SOTTOCONTOC);     
    _importo = cur->curr(LF_RMOV).get_real(RMV_IMPORTO);
    _sezione = cur->curr(LF_RMOV).get(RMV_SEZIONE)[0];
    TString80 descr = cur->curr(LF_RMOV).get(RMV_DESCR);
    int numrig = cur->curr(LF_RMOV).get_int(RMV_NUMRIG); 
    
    _tipo_conto = "";
    
    if (_gruppo != 0 && _conto != 0 && _sottoconto != 0l)
      _esiste_conto = DescrConto(_gruppo,_conto,_sottoconto);
    else
    {
     _esiste_conto = FALSE;
     _descr_conto = "";
    } 

    int r = 1;          
    set_row(r, "P%d", numrig);
    set_row(r, "@5g%3s %-.20s @30g%-.24s @56g%03d %03d %06ld @71g%-.28s", (const char*) _causale, 
           (const char*) _descr_causale, (const char*) descr, _gruppo, _conto, _sottoconto, 
           (const char*) _descr_conto);
    if (_sezione == 'D')
      set_row(r, "@99g%r", &_importo);
    else if (_sezione == 'A')
           set_row(r, "@116g%r", &_importo);
         else set_row(r, "@107g%r", &_importo);

    stampa_errori_rmov(r);
//    TLocalisamfile& rmov = current_cursor()->file(LF_RMOV); 
    
//    rmov.put(RMV_ANNOES, _annoese);
    
//    rmov.rewrite();
  }
  else if (file == LF_RMOVIVA)
  {
    real impo = cur->curr(LF_RMOVIVA).get_real(RMI_IMPONIBILE);
    real impos = cur->curr(LF_RMOVIVA).get_real(RMI_IMPOSTA);
    int numrig = cur->curr(LF_RMOVIVA).get_int(RMI_NUMRIG); 
    _tipocr = cur->curr(LF_RMOVIVA).get_int(RMI_TIPOCR);
    _tipod  = cur->curr(LF_RMOVIVA).get_int(RMI_TIPODET);
    _codiva = cur->curr(LF_RMOVIVA).get(RMI_CODIVA);  
    //_n_rec  = cur->curr(LF_RMOVIVA).get_int(RMI_ANNOES); 
    _gruppocr = cur->curr(LF_RMOVIVA).get_int(RMI_GRUPPO); 
    _contocr  = cur->curr(LF_RMOVIVA).get_int(RMI_CONTO);
    _sottocontocr = cur->curr(LF_RMOVIVA).get_long(RMI_SOTTOCONTO);
    
    TString80 codiva_des(get_codiva_des(_codiva));
    
    //_tot_doc += impo + impos;
    
    _impo = impo;
    _impos = impos; 
    if (!_tipodoc.blank())
    {   
      TTable tabtpd("%TPD");
      tabtpd.put("CODTAB", _tipodoc);
      if (tabtpd.read() == NOERR) 
      {
        bool cor = tabtpd.get_bool("B0");
        if (cor)
        {
          _impo  = impo + impos;
          _impos = ZERO;
        }
      }
    }  

    int r = 1;
    // Cambia segno se si tratta di note di credito o storni
    if (_tipodoc == "NC" || _tipodoc == "ST")
    {
      _impo_print = _impo * (-1);
      _impos_print = _impos * (-1);
    }
    else 
    {
      _impo_print = _impo;
      _impos_print = _impos;
    }
     
    set_row(r, "I%d", numrig);
    set_row(r, FR("@5gImponibile@16g%r"),&_impo_print);
    set_row(r, FR("@32gImposta@40g%r"), &_impos_print);      
    set_row(r, FR("@56gCodice@63g%4s"), (const char*) _codiva);
    set_row(r, "@68g%s", (const char*) codiva_des);
             
    if (_tipod != 0)
      set_row(r," %d", _tipod);
              
    stampa_errori_riva(r);        
  }          
  if (file == LF_PARTITE)
  {  
    _err.reset();                             
    _tipomov    = cur->curr(LF_PARTITE).get_int (PART_TIPOMOV);
    _tipocf     = cur->curr(LF_PARTITE).get_char(PART_TIPOCF);
    _gruppo     = cur->curr(LF_PARTITE).get_int (PART_GRUPPO);
    _conto      = cur->curr(LF_PARTITE).get_int (PART_CONTO);
    _codcf      = cur->curr(LF_PARTITE).get_long(PART_SOTTOCONTO);  
    _anno       = cur->curr(LF_PARTITE).get_int (PART_ANNO);
    _numpart    = cur->curr(LF_PARTITE).get     (PART_NUMPART);  
    _nriga      = cur->curr(LF_PARTITE).get_int (PART_NRIGA);
    _numreg     = cur->curr(LF_PARTITE).get_long(PART_NREG);
    _numrig     = cur->curr(LF_PARTITE).get_int (PART_NUMRIG);
    _datareg    = cur->curr(LF_PARTITE).get_date(PART_DATAREG);
    _datadoc    = cur->curr(LF_PARTITE).get_date(PART_DATADOC);
    _numdoc     = cur->curr(LF_PARTITE).get     (PART_NUMDOC);
    _reg        = cur->curr(LF_PARTITE).get     (PART_REG);
    _protiva    = cur->curr(LF_PARTITE).get_long(PART_PROTIVA);                                    
    _causale    = cur->curr(LF_PARTITE).get     (PART_CODCAUS);
    _tipopag    = cur->curr(LF_PARTITE).get_int (PART_TIPOPAG);  
    _datapag    = cur->curr(LF_PARTITE).get_date(PART_DATAPAG);
    _codval     = cur->curr(LF_PARTITE).get     (PART_CODVAL);                                                               
    _cambio     = cur->curr(LF_PARTITE).get_real(PART_CAMBIO);    
    _datacam    = cur->curr(LF_PARTITE).get     (PART_DATACAM);
    _sez        = cur->curr(LF_PARTITE).get_char(PART_SEZ);
    _gruppocl   = cur->curr(LF_PARTITE).get_int (PART_GRUPPOCL);
    _contocl    = cur->curr(LF_PARTITE).get_int (PART_CONTOCL);                              
    
    aggiorna_partite();
                                   
    bool verpagsca = controlla_pagsca();
    bool verscad   = controlla_scadenze();
    bool controlla = controlla_partite(); //se TRUE => ci sono errori nella testata
    bool verifica  = (verpagsca || verscad);

    if ( (_controllo == 1 && controlla) || _controllo == 2 ||
         (_controllo == 1 && verifica) ) 
    {
      TString16 datareg_str = _datareg.string();
      // "Fai vedere lo stesso ..-..-.... anche se non c'e' la data..."    
      if (datareg_str.empty())
        datareg_str = "  -  -    ";
      TString16 datadoc_str = _datadoc.string();
      if (datadoc_str.empty())
        datadoc_str = "  -  -    "; 
      TString16 datapag_str = _datapag.string();
      if (datapag_str.empty())
        datapag_str = "  -  -    "; 
      TString16 datacam_str = _datacam.string();
      if (datacam_str.empty())
        datacam_str = "  -  -    "; 
      
      TString ccf;
      if (_tipocf == 'C')
        ccf = TR("Cliente:  ");
      else
        if (_tipocf == 'F')
          ccf = TR("Fornitore:");
        else
          ccf = TR("Conto:    ");
      
      // I riga di testata      
      int r = 1;
      set_row(r++, "");
      if (_tipocf != _tipocf_p || _gruppo != _gruppo_p || _conto != _conto_p || _codcf != _codcf_p)
      {  
        set_row(r++, "");         
        set_row(r,"@b%s", (const char*) ccf);  
        if (_gruppo != 0)
          set_row(r,"@b%3d", _gruppo);
        if (_conto != 0)
          set_row(r,"@b%3d", _conto);
        set_row(r,"@b%6ld", _codcf);
        set_row(r++," @b%-50s", (const char*) _descr_anag);
      }
      // II riga di testata (L'intestazione viene stampata solo a rottura di partita)
      if (_tipocf != _tipocf_p || _gruppo != _gruppo_p || _conto != _conto_p || 
          _codcf != _codcf_p || _numpart != _numpart_prec || _anno != _anno_prec)
        set_row(r,FR("@0g@rRif. partita"));
      set_row(r,FR("@14gN.riga@22gN.operaz./riga  Data oper.  Data doc.   N.doc.   Reg  Prot.  Causale"));
      set_row(r++,FR("@142gTipo/Data pag.  Cod.val          Cambio  Data cambio Sez"));
      if (_tipocf != _tipocf_p || _gruppo != _gruppo_p || _conto != _conto_p || 
          _codcf != _codcf_p || _numpart != _numpart_prec || _anno != _anno_prec)
      {  
        set_row(r,"%4d", _anno);
        set_row(r,"@4g/%-7s", (const char*) _numpart);
      }  
      set_row(r,"@15g%4d", _nriga);   
      if (_numreg != 0)
        set_row(r,"@23g%7ld", _numreg);
      else
        set_row(r,"@23g-");
      if (_numrig != 0)
        set_row(r,"@32g%4d", _numrig);
      else
        set_row(r,"@32g-");
      set_row(r,"@38g%10s", (const char*) datareg_str);
      set_row(r,"@50g%10s", (const char*) datadoc_str);
      set_row(r,"@62g%-7s", (const char*) _numdoc);
      if (_tipomov == 1 || _tipomov == 2)
      {
        set_row(r,"@71g%-3s", (const char*) _reg);
        if (_protiva != 0)
          set_row(r,"@76g%05ld", _protiva);
      }  
      set_row(r,"@83g%-3s", (const char*) _causale);
      set_row(r,"@88g%-50s", (const char*) _descr_causale);
      if (_tipopag != 0)
        set_row(r,"@144g%d", _tipopag);
      set_row(r,"@147g%10s", (const char*) datapag_str);   
      set_row(r,"@160g%-3s", (const char*) _codval);  
      if (_cambio != ZERO)
        set_row(r,"@166g%15s",(const char*) _cambio.string("#.###.###,@@@@@"));
      set_row(r,"@183g%10s", (const char*) datacam_str);
      set_row(r,"@196g%c", _sez);
      
      _tipocf_p = _tipocf;
      _gruppo_p = _gruppo;
      _conto_p  = _conto;
      _codcf_p  = _codcf;
      
      stampa_errori_partite(r);  
      
      _prima_rata_pag = TRUE; 
      _numpart_prec   = _numpart; 
      _anno_prec      = _anno;
      
      _ho_stampato = TRUE;
      return TRUE;
    }
    return FALSE;
  }
  if (file == LF_SCADENZE)
  {                           
    int r = 1; 
    stampa_errori_scadenze(r);  
  }  
  if (file == LF_PAGSCA)
  {                           
    int r = 1; 
    stampa_errori_pagsca(r);  
  }
  
  return TRUE;
}

print_action TRic_ListaMov::postprocess_page(int file,int count)
{
  if (count) return NEXT_PAGE;  
  
  if (file == LF_MOV)
  {       
    reset_print();
    _err.reset();
    int n = 1;     
    
    const TCurrency sbil(real(_tot_dare - _tot_avere));
    if (!sbil.is_zero())
    {
       _errore_grave = TRUE;
       set_row(n++, FR("@8g*** Il movimento risulta sbilanciato. Totali rilevati:@99g%r@116g%r"),
               &_tot_dare, &_tot_avere);
       return REPEAT_PAGE;           
    }   
  }
  if (file == LF_PARTITE)
  {       
    reset_print();
    _err.reset();
  }
  return NEXT_PAGE;
}       

print_action TRic_ListaMov::postprocess_print(int file, int counter)
{                  
  if (file == LF_MOV || file == LF_PARTITE) 
    if (_ho_stampato)
      printer().formfeed();
    
  return NEXT_PAGE;
}

void TRic_ListaMov::postclose_print()
{ 
  bool esegui;  // La variabile esegui mi permette di visualizzare il messaggio se non c'e il
                // saldaconto, oppure se c'e' il saldaconto ma e' gia' stato eseguito il controllo
                // su quest'ultimo
  if ( (_is_salda && _seconda_volta) || !_is_salda)
    esegui = TRUE;
  else
    esegui = FALSE; 
  
  if (_is_salda)     
    if (_seconda_volta)
      _seconda_volta = FALSE;
    else
      _seconda_volta = TRUE;
    
  _errore_grave_totale = _errore_grave || _errore_grave_SC;
  
  if (esegui)
  {  
    if (_errore_grave_totale)
    {  
       if (_ric_auto == 'A')
       { 
         _risposta = TRUE;
         _continua = yesno_box(TR("Rilevati ERRORI GRAVI durante il controllo movimenti: \n Controllare gli errori sulla lista dei movimenti stampata per eseguire le correzioni. \n Continuare ugualmente?"));
         TTransfer_file& tr = trasfer();
         if (!_continua)
           _record.overwrite(" ",240);  //_record e' letto nella read_control_rec()
         else 
         {
           TConfig conf (CONFIG_DITTA);
           conf.set("FlStTra", "M"); 
           _record.overwrite("Z",240);  
         }
         const int size = 1024;
         tr.write_control_rec(_record, size); 
         tr.read_control_rec();
       }
       else 
       {
         message_box(TR("Rilevati errori gravi durante il controllo movimenti:\n trasferimento interrotto"));
         TTransfer_file& tr = trasfer();
         _record.overwrite(" ",240);  //_record e' letto nella read_control_rec()
         const int size = 1024;
         tr.write_control_rec(_record, size); 
         tr.read_control_rec();
         chiudi_file_SC();
       }
    }                        
    else 
    { 
      if (_ric_auto == 'A')                  
        _risposta = TRUE;
      else
        message_box(TR("CONTROLLO MOVIMENTI terminato: \n proseguire con RICEZIONE movimenti"));
      TConfig conf (CONFIG_DITTA);
      conf.set("FlStTra", "M"); 
   
      TTransfer_file& tr = trasfer();
      _record.overwrite("Z",240);  //_record e' letto nella read_control_rec()
      const int size = 1024;
      tr.write_control_rec(_record, size);    
      tr.read_control_rec();
      chiudi_file_SC();
    }
  }  // if (esegui)
}

char TRic_ListaMov::sezione_ritsoc(const TRectype& part) const 
{
  TString16 key; key << part.get(PART_CODCAUS) << "|14";  // Riga ritenute sociali
  const char sezrs = cache().get(LF_RCAUSALI, key, RCA_SEZIONE)[0];
  return sezrs > ' ' ? (sezrs == 'D' ? 'A' : 'D') : part.get_char(PART_SEZ);
}

real TRic_ListaMov::segno_ritsoc(const TRectype& part) const
{
  return part.get_char(PART_SEZ) == sezione_ritsoc(part) ? UNO : -UNO;
}

void TRic_ListaMov::esamina_partite()
{   
  bool prima_volta = TRUE;
  int  numrigp = -1;
  TRecnotype recp = _tpart->recno();
  TIsamtempfile& part = *_tpart;
  
  part.setkey(2);
  part.zero();
  part.put(PART_NREG, _numero);
  const TRectype partita (part.curr());
  
  for (part.read(_isgteq); !part.eof(); part.next())
  {
    if (part.curr() != partita) break;
    
    int tipomov = part.get_int(PART_TIPOMOV);
    int numrig  = part.get_int(PART_NUMRIG);
    
//    if (numrig != numrigp)
//    {
      real doc = ZERO;
      real val = ZERO;

      if (tipomov != 1 && tipomov != 2)
      {  
        TIsamtempfile& pagsca = *_tpagsca;
        
        pagsca.zero();
        pagsca.put(PAGSCA_TIPOC,      part.get_char(PART_TIPOCF));
        pagsca.put(PAGSCA_GRUPPO,     part.get_int (PART_GRUPPO));
        pagsca.put(PAGSCA_CONTO,      part.get_int (PART_CONTO));
        pagsca.put(PAGSCA_SOTTOCONTO, part.get_long(PART_SOTTOCONTO));
        pagsca.put(PAGSCA_ANNO,       part.get_int (PART_ANNO));
        pagsca.put(PAGSCA_NUMPART,    part.get     (PART_NUMPART));
        int nriga = part.get_int(PART_NRIGA);
        TRectype pagamenti (pagsca.curr());
  
        for (pagsca.read(_isgteq); !pagsca.eof(); pagsca.next())
        {                                           
          TString rec  = pagamenti.get(PAGSCA_NUMPART);
          TString file = pagsca.get(PAGSCA_NUMPART);
          
          if (pagsca.curr() != pagamenti || file != rec) break;
    
          int nrigp = pagsca.get_int(PAGSCA_NRIGP);
    
          if (nrigp != nriga) continue;
    
          doc += pagsca.get_real(PAGSCA_IMPORTO) + pagsca.get_real(PAGSCA_RITENUTE);
          doc += pagsca.get_real(PAGSCA_RITSOC) * segno_ritsoc(part.curr());

          val += pagsca.get_real(PAGSCA_IMPORTOVAL);
        }
      
        if (prima_volta) 
          _tot_doc = ZERO;
        _tot_doc += doc;  
      }
      if (tipomov == 1)
      {                                   
        TRecnotype recs = _tscad->recno();      
        TIsamtempfile& scad = *_tscad;
        
        scad.zero();
        scad.put(SCAD_TIPOCF,     part.get_char(PART_TIPOCF));
        scad.put(SCAD_GRUPPO,     part.get_int (PART_GRUPPO));
        scad.put(SCAD_CONTO,      part.get_int (PART_CONTO));
        scad.put(SCAD_SOTTOCONTO, part.get_long(PART_SOTTOCONTO));
        scad.put(SCAD_ANNO,       part.get_int (PART_ANNO));
        scad.put(SCAD_NUMPART,    part.get     (PART_NUMPART));
        scad.put(SCAD_NRIGA,      part.get_int (PART_NRIGA));
        TRectype scadenze (scad.curr());
  
        for (scad.read(_isgteq); !scad.eof(); scad.next())
        {  
          TString rec  = scadenze.get(SCAD_NUMPART);
          TString file = scad.get(SCAD_NUMPART);
          
          if (scad.curr() != scadenze || file != rec) break;
    
          val += scad.get_real(SCAD_IMPORTOVAL);
        }
        _tscad->readat(recs);
      }                                           
      if (prima_volta)
        _tot_val = ZERO;
      _tot_val += val;  
//    }
//    numrigp = numrig;
    
    if (prima_volta)
    {
      _codval_part  = part.get     (PART_CODVAL);
      _datacam_part = part.get_date(PART_DATACAM);
      _cambio_part  = part.get_real(PART_CAMBIO);   
      if (tipomov == 1)
      { 
        TRecnotype recs = _tscad->recno();
        TIsamtempfile& scad = *_tscad;
      
        char    tipo    = part.get_char(PART_TIPOCF);
        int     gruppo  = part.get_int (PART_GRUPPO);
        int     conto   = part.get_int (PART_CONTO);
        long    sottoc  = part.get_long(PART_SOTTOCONTO);
        int     anno    = part.get_int (PART_ANNO);
        TString numpart = part.get     (PART_NUMPART);
        int     nriga   = part.get_int (PART_NRIGA);
        
        scad.setkey(1);
        scad.zero();
        scad.put(SCAD_TIPOCF,     tipo);
        scad.put(SCAD_GRUPPO,     gruppo);
        scad.put(SCAD_CONTO,      conto);
        scad.put(SCAD_SOTTOCONTO, sottoc);
        scad.put(SCAD_ANNO,       anno);
        scad.put(SCAD_NUMPART,    numpart);
        scad.put(SCAD_NRIGA,      nriga);
        TRectype scadenza (scad.curr());
        
        _codpag_scad = "";
        
        for (scad.read(_isgteq); !scad.eof(); scad.next())
        {       
          TString rec  = scadenza.get(SCAD_NUMPART);
          TString file = scad.get(SCAD_NUMPART);
          
          if (scad.curr() != scadenza || file != rec) break;
          
          _codpag_scad = scad.get(SCAD_CODPAG);
          break;
        }  
        _tscad->readat(recs);
      }
      prima_volta = FALSE;
    }                                            
  }
  _tpart->readat(recp);
}

void TRic_ListaMov::aggiorna_mov()
{
  TLocalisamfile& mov = current_cursor()->file(LF_MOV);

  if (_is_salda)
    esamina_partite();

  if (_anno == 0)
    mov.put(MOV_ANNOES, _annoese);
  mov.put(MOV_DATACOMP, _datacomp);
  mov.put(MOV_ANNOIVA,  _annoiva);
  mov.put(MOV_REG,      _registro);
  mov.put(MOV_TIPODOC,  _tipodoc); 
  mov.put(MOV_TIPO,     _tipocf);  
  if (mov.get(MOV_TIPOMOV).empty())
    mov.put(MOV_TIPOMOV,  _tipom_cau); 
  mov.put(MOV_CODPAG,   _codpag_scad);
  const bool first_time = mov.get("TOCFP")!="X";
  if ((_tipodoc == "NC" || _tipodoc == "ST") && first_time)  // swap sign only if it's first time
  {
    _tot_doc = -_tot_doc;
    mov.put("TOCFP","X");
  }
  
  // NB In caso di ricezione da sistema ritsoc e ritfis valgono sempre 0  
  // quindi in caso di ricezione da PC ripristina il totale documento corretto.
  real ritsoc = mov.get(MOV_RITSOC);
  real ritfis = mov.get(MOV_RITFIS);
  _tot_doc = _tot_doc - ritsoc - ritfis;
  
  mov.put(MOV_TOTDOC,   _tot_doc);    
  if (_is_salda)
  { 
    if (mov.get_real(MOV_TOTDOCVAL) == ZERO)
      mov.put(MOV_TOTDOCVAL, _tot_val);
    if (mov.get(MOV_CODVAL).empty())  
      mov.put(MOV_CODVAL,    _codval_part);
    if (mov.get(MOV_DATACAM).empty())  
      mov.put(MOV_DATACAM,   _datacam_part);
    if (mov.get_real(MOV_CAMBIO) == ZERO)  
      mov.put(MOV_CAMBIO,    _cambio_part);
  }
  mov.rewrite();
}

void TRic_ListaMov::aggiorna_rmov(char tipoc, char tipocc)
{
  TLocalisamfile& rmov = current_cursor()->file(LF_RMOV); 

  if (_anno == 0)
    rmov.put(RMV_ANNOES, _annoese);

  rmov.put(RMV_TIPOC,  tipoc);
  rmov.put(RMV_TIPOCC, tipocc);
  
  rmov.rewrite();
}

void TRic_ListaMov::aggiorna_iva(char tipo)
{                                                       
  TLocalisamfile& riva = current_cursor()->file(LF_RMOVIVA); 
  TLocalisamfile& mov = current_cursor()->file(LF_MOV); 
  
  if (_anno == 0)
    riva.put(RMI_ANNOES, _annoese);
  
  const bool first_time = mov.get("TOCFP") != "X";
  if ((_tipodoc == "NC" || _tipodoc == "ST") && first_time) // swap sign only if it is the first time
  {
    _impo  = _impo * -1;
    _impos = _impos * -1;
  }  
  riva.put(RMI_IMPONIBILE, _impo);
  riva.put(RMI_IMPOSTA,    _impos);  
  riva.put(RMI_TIPOC,      tipo);
  
  riva.rewrite();
}

bool TRic_ListaMov::solo_SC(long numreg)
{               
  TIsamtempfile& tmov = *_tmov;
  
  tmov.setkey(1);              
  tmov.zero();   
  tmov.put(MOV_NUMREG, numreg);
  if (tmov.read() == NOERR)
    return FALSE;      
  
  return TRUE;  
}

void TRic_ListaMov::calcola_imposta(long nreg, real& imposta)
{                             
  TRecnotype recn = _tiva->recno();
  TIsamtempfile& riva = *_tiva; 
    
  riva.zero();
  riva.put(RMI_NUMREG, nreg);

  TRectype recriva (riva.curr());
    
  for (riva.read(_isgteq); !riva.eof(); riva.next())
  {
    if (riva.curr() > recriva) break;
    
    real imp (riva.get_real(RMI_IMPOSTA));
    imposta += imp;                              
  }                                
  _tiva->readat(recn);
}

bool TRic_ListaMov::calcola_impdocval(long nreg,int nrig,char tipoc,int gruppo,int conto,long sottoc,
                                      int anno,TString& numpart,int nriga,real& doc,real& val)
{ 
  TRecnotype recn = _tpagsca->recno();
  TIsamtempfile& pagsca = *_tpagsca;
  bool prima_volta = TRUE;
  
  doc = ZERO;
  val = ZERO;

  pagsca.zero();
  pagsca.put(PAGSCA_TIPOC,      tipoc);
  pagsca.put(PAGSCA_GRUPPO,     gruppo);
  pagsca.put(PAGSCA_CONTO,      conto);
  pagsca.put(PAGSCA_SOTTOCONTO, sottoc);
  pagsca.put(PAGSCA_ANNO,       anno);
  pagsca.put(PAGSCA_NUMPART,    numpart);
//  pagsca.put(PAGSCA_NRIGA,      nriga);
  
  const TRectype pagamenti (pagsca.curr());
  
  for (pagsca.read(_isgteq); !pagsca.eof(); pagsca.next())
  {                                           
    TString rec  = pagamenti.get(PAGSCA_NUMPART);
    TString file = pagsca.get(PAGSCA_NUMPART);
    
    if (pagsca.curr() != pagamenti || file != rec) break;
    
    int nrigp = pagsca.get_int(PAGSCA_NRIGP);
    
    if (nrigp != nriga) continue;
    
    doc += pagsca.get_real(PAGSCA_IMPORTO) + pagsca.get_real(PAGSCA_RITENUTE);
    const real ritsoc = pagsca.get(PAGSCA_RITSOC);
    if (!ritsoc.is_zero())
    {
      TToken_string key;
      key.add(tipoc); key.add(gruppo); key.add(conto); key.add(sottoc);
      key.add(anno); key.add(numpart);
      const TRectype& part = cache().get(LF_PARTITE, key);
      doc += ritsoc * segno_ritsoc(part);
    }

    val += pagsca.get_real(PAGSCA_IMPORTOVAL);
  }
  _tpagsca->readat(recn);
  
  if (nreg != 0 && nrig != 0)
  {
    int key = _tpart->getkey();      
    TRecnotype rec = _tpart->recno();
    TIsamtempfile& part = *_tpart;

    part.setkey(2);
    part.zero();
    part.put(PART_NREG,   nreg);
    part.put(PART_NUMRIG, nrig);
      
    TRectype partita (part.curr());
      
    for (part.read(); !part.eof(); part.next())
    {
      if (part.curr() > partita) break;
      
      real imp    = part.get_real(PART_IMPTOTDOC) + doc;
      real impval = part.get_real(PART_IMPTOTVAL) + val;
      part.put(PART_IMPTOTDOC, imp);
      part.put(PART_IMPTOTVAL, impval);  
      part.setkey(1);
      part.rewrite();
      part.setkey(2);
    }                
    _tpart->readat(rec);
    _tpart->setkey(key);  
  }           
  else
    return TRUE;
  
  return FALSE;
}

void TRic_ListaMov::calcola_importo(char tipoc,int gruppo,int conto,long sottoc,
                                     int anno,TString& numpart,int nriga)
{ 
  TRecnotype recn = _tscad->recno();                            
  TIsamtempfile& scad = *_tscad;
  
  scad.setkey(1);
  scad.zero();
  scad.put(SCAD_TIPOCF,     tipoc);
  scad.put(SCAD_GRUPPO,     gruppo);
  scad.put(SCAD_CONTO,      conto);
  scad.put(SCAD_SOTTOCONTO, sottoc); 
  scad.put(SCAD_ANNO,       anno);
  scad.put(SCAD_NUMPART,    numpart);
  scad.put(SCAD_NRIGA,      nriga);
  
  TRectype scadenza (scad.curr());
  
  for (scad.read(_isgteq); !scad.eof(); scad.next())
  {       
    TString rec  = scadenza.get(SCAD_NUMPART);
    TString file = scad.get(SCAD_NUMPART);
                                           
    if (scad.curr() != scadenza || file != rec) break;
    
    _imp    += scad.get_real(SCAD_IMPORTO);
    _impval += scad.get_real(SCAD_IMPORTOVAL);
  }
  _tscad->readat(recn);    
}

void TRic_ListaMov::aggiorna_partita(real& importo,real& importoval,real& abbuoni,real& diffcam,
                                     real& ritfis,real& ritsoc, TString& sez,TString& sezabb,TString& sezdc)
{                  
  TRecnotype recn = _tpagsca->recno();
  TIsamtempfile& pagsca = *_tpagsca;
  real    abb,diff;

  abb  = ZERO;
  diff = ZERO;
  
  pagsca.setkey(1);
  pagsca.zero();
  pagsca.put(PAGSCA_TIPOC,      _tipocf);
  pagsca.put(PAGSCA_GRUPPO,     _gruppo);
  pagsca.put(PAGSCA_CONTO,      _conto);
  pagsca.put(PAGSCA_SOTTOCONTO, _codcf); 
  pagsca.put(PAGSCA_ANNO,       _anno);
  pagsca.put(PAGSCA_NUMPART,    _numpart);
  
  TRectype pagamento (pagsca.curr());
  
  for (pagsca.read(_isgteq); !pagsca.eof(); pagsca.next())
  {            
    TString rec  = pagamento.get(PAGSCA_NUMPART);
    TString file = pagsca.get(PAGSCA_NUMPART);
                  
    if (pagsca.curr() != pagamento || file != rec) break;
    
    int nrigp = pagsca.get_int(PAGSCA_NRIGP);
    
    if (_nriga != nrigp) continue;
    
    importo    += pagsca.get_real(PAGSCA_IMPORTO);
    importoval += pagsca.get_real(PAGSCA_IMPORTOVAL);
    ritfis     += pagsca.get_real(PAGSCA_RITENUTE);
    ritsoc     += pagsca.get_real(PAGSCA_RITSOC);
    
    abb = pagsca.get_real(PAGSCA_ABBUONI);
    if (abb != ZERO)
    {  
      if (sezabb.empty())  
      {
        abbuoni += abb;
        sezabb = sez;
      }
      else
        if (sez == sezabb)
          abbuoni += abb;        
        else
          abbuoni -= abb;                
    }
    diff = pagsca.get_real(PAGSCA_DIFFCAM);
    if (diff != ZERO)
    {
      if (sezdc.empty())  
      {
        diffcam += diff;
        sezdc = sez;
      }
      else
        if (sez == sezdc)
          diffcam += diff;        
        else
          diffcam -= diff;                
    }
  }
  if (abbuoni < ZERO)
  {
    abbuoni = abbuoni * -1;
    if (sezabb == "D")
      sezabb = "A";
    else          
      if (sezabb == "A")
        sezabb = "D";
  }            
  if (diffcam < ZERO)
  {
    diffcam = diffcam * -1;
    if (sezdc == "D")
      sezdc = "A";
    else          
      if (sezdc == "A")
        sezdc = "D";      
  } 
  _tpagsca->readat(recn);               
}

void TRic_ListaMov::aggiorna_partite()
{
  TLocalisamfile& part = current_cursor()->file(LF_PARTITE); 
  
  real imposta = ZERO;
  
  if (!solo_SC(_numreg) && _tipomov == 1) // && (part.get_real(PART_IMPOSTA) == ZERO) )         
  { 
    if (_is_iva)
    {
      calcola_imposta(_numreg,imposta);
      part.put(PART_IMPOSTA, imposta);
    }
  }                       
  if (_tipomov != 1 && _tipomov != 4)   
  {  
/*    if (_prima_volta)
    {
      _prima_volta = FALSE;
      if (part.get_real(PART_IMPTOTDOC) == ZERO)
        _calcola = TRUE;
      else
        _calcola = FALSE;
    }  */
//    if (_calcola)
//    {
      real doc;
      real val;
      if (calcola_impdocval(_numreg,_numrig,_tipocf,_gruppo,_conto,_codcf,_anno,_numpart,_nriga,doc,val))
      {
        part.put(PART_IMPTOTDOC, doc);
        part.put(PART_IMPTOTVAL, val);  
      } 
//    }
  }        
  if (_tipomov == 1 ) //&& (part.get_real(PART_IMPORTO) == ZERO) )
  {
    calcola_importo(_tipocf,_gruppo,_conto,_codcf,_anno,_numpart,_nriga);
  
    part.put(PART_IMPORTO,    _imp);
    part.put(PART_IMPORTOVAL, _impval);
    
    _imp    = ZERO;
    _impval = ZERO;
  }
  if (_tipomov != 1) // && (part.get_real(PART_IMPORTO) == ZERO) )
  {
    real    importo    = ZERO;
    real    importoval = ZERO;
    real    ritfis     = ZERO;
    real    ritsoc     = ZERO;
    real    abbuoni    = ZERO;
    real    diffcam    = ZERO;
    TString sez        = part.get(PART_SEZ);
    TString sezabb     = part.get(PART_SEZABB);
    TString sezdc      = part.get(PART_SEZDIFCAM);

    aggiorna_partita(importo,importoval,abbuoni,diffcam,ritfis,ritsoc,sez,sezabb,sezdc);  

    part.put(PART_IMPORTO,    importo);
    part.put(PART_IMPORTOVAL, importoval);
    part.put(PART_RITENUTE,   ritfis);
    part.put(PART_RITSOC,     ritsoc);
    part.put(PART_SEZABB,     sezabb);   
    part.put(PART_ABBUONI,    abbuoni);  
    part.put(PART_SEZDIFCAM,  sezdc);   
    part.put(PART_DIFFCAM,    diffcam);
  }
  part.rewrite();
}

bool TRic_ListaMov::user_destroy()
{
  delete _giornale;
  delete _trasfer;
  delete _rel; 
  
  // Sono gia' distrutti in quanto parte di _rel
  // delete _tmov;  
  // delete _trmov;
  // if (_is_iva) delete _tiva;
  
  delete _caus;
  delete _ditte; 
  delete _clifo; 
  delete _pcon;    
  delete _mov;
  delete _rmov;
  delete _rmoviva;
  delete _part;
  delete _scad;
  delete _pagsca;
  
  delete _tab_pag;
  delete _tab_tpd;
  delete _tab_iva;
  delete _tab_ese;      
  delete _tab_tra;
  
  return TRUE;
}                                

void TRic_ListaMov::chiudi_file_SC()
{
  if (_is_salda)
  { 
    delete _relSC;   _relSC   = NULL;
    // Non cancellare: Gia' contenuti in _relSC
    // delete _tpart;   _tpart   = NULL;  
    // delete _tscad;   _tscad   = NULL;
    // delete _tpagsca; _tpagsca = NULL;

    delete _part;    _part = NULL;
    delete _scad;    _scad = NULL;
    delete _pagsca;  _pagsca = NULL;
  }
}
                                    
bool TRic_ListaMov::set_print(int m)
{ 
  if (_ric_auto == 'A')
  {   
    if (_risposta)    // Metto questa variabile booleana per uscire, altrimenti
    {                 // il programma andrebbe in loop andando ancora in stampa
      TString appname = "cg6 -0";
      TString body    = "";
  
      if (_continua)
        body = "1";
      else
        body = "0";
        
      TMessage msg (appname,"",(const char*)body);
      TMailbox mb;
      mb.send(msg);
    
      return FALSE;   
    }

    if (_seconda_volta && _is_salda)
    { 
      reset_files();           // Resetta l'albero di stampa precedente relativo ai movimenti contabili e iva
      select_cursor(_curSC);   // Seleziona il cursore relativo ai movimenti del saldaconto
    
      add_file (LF_PARTITE);
      add_file (LF_SCADENZE, LF_PARTITE);
      add_file (LF_PAGSCA, LF_PARTITE);  
      _errore_grave_SC = FALSE;   
      _intestaSC       = TRUE;  
      _prima_volta     = TRUE;
      _ho_stampato     = FALSE;      
    }
    else
    {
      TString80 nome;
      long ditta_ric = get_firm();
  
      TTransfer_file& tr = trasfer(); // Nella lista controllo movimenti lanciata da menu il record di  
                                      // controllo dell'header viene letto nella funzione check_archivi
                                      // Nella ricezione in automatico devo leggerlo in questo punto
      _pathfile = tr.path();         
  
      _pathfile = _pathfile << HEADER;
  
      if (!tr.open(_pathfile))
        return error_box(TR("Al momento non presenti trasferimenti attivi sulla ditta selezionata"));

      if (!tr.read_control_rec())
        return error_box(TR("Rilevati errori gravi negli archivi: procedura interrotta"));
      else _record = tr.record();     
                                    
      if (_tipo_lista == 'A')
        _controllo = 2;
      else
        _controllo = 1;

      apri_file_SC(); 
      
      reset_files();           // Resetta l'albero di stampa precedente relativo ai movimenti del saldaconto
      select_cursor(_cur);     // Seleziona il cursore relativo ai movimenti contabili e iva
  
      add_file (LF_MOV);
      add_file (LF_RMOV, LF_MOV);
      if (_is_iva)
        add_file (LF_RMOVIVA, LF_MOV);
           
      _errore_grave = FALSE;   
      _errore_grave_totale = FALSE;  
      _intestaSC           = FALSE;
    
      _err.reset();  
    }
    setta_parametri(" ", "C");   
  
    set_real_picture("###.###.###.###");
    set_magic_currency(TRUE);

    printer().footerlen(5);
  
    setta_intestazione();

    _err.reset();
  }
  else
  { 
    if (_seconda_volta && _is_salda)
    { 
      reset_files();           // Resetta l'albero di stampa precedente relativo ai movimenti contabili e iva
      select_cursor(_curSC);   // Seleziona il cursore relativo ai movimenti del saldaconto
    
      add_file (LF_PARTITE);
      add_file (LF_SCADENZE, LF_PARTITE);
      add_file (LF_PAGSCA, LF_PARTITE);  
      _errore_grave_SC = FALSE;   
      _intestaSC       = TRUE;  
      _prima_volta     = TRUE;
      _ho_stampato     = FALSE;
    }
    else
    {
      TMask msk ("cg6700a");
  
      TTransfer_file& tr = trasfer();
  
      apri_file_SC(); 
      
      msk.set(F_NUMERO, tr.nultras());
      msk.set(F_DATALIMITE, tr.dataultras());
      const char sdt[2] = { look_sdt(), '\0' };
      msk.set(F_SDT, sdt);
      msk.set(F_SIGLA, tr.ult_file());
      msk.set(F_CHIAVE, tr.key());
  
      if (msk.run() != K_ENTER) return FALSE;
  
      _controllo = msk.get_int(F_LISTA);
      
      reset_files();           // Resetta l'albero di stampa precedente relativo ai movimenti del saldaconto
      select_cursor(_cur);     // Seleziona il cursore relativo ai movimenti contabili e iva
  
      add_file (LF_MOV);
      add_file (LF_RMOV, LF_MOV);
      if (_is_iva)
        add_file (LF_RMOVIVA, LF_MOV);
           
      _errore_grave        = FALSE; 
      _errore_grave_totale = FALSE;  
      _intestaSC           = FALSE;
    }
    
    if (_sdt == '*')
      ::remove(_pathfile);
  
    setta_parametri(" ", "C");   
  
    set_real_picture("###.###.###.###");
    set_magic_currency(TRUE);
  
    printer().footerlen(5);
  
    setta_intestazione();
              
    _err.reset();
  }
  
  return TRUE;
}

void TRic_ListaMov::setta_intestazione()
{
  int soh = 1;       
  TString sep(132);
  TString sep1(198);
  TString ragsoc(50);
 
  TLocalisamfile nditte(LF_NDITTE); 
  nditte.zero();
  nditte.put(NDT_CODDITTA, get_firm());   
  if (nditte.read() == NOERR) 
    ragsoc = nditte.get(NDT_RAGSOC);
  
  reset_header();

  if (_intestaSC)
  {
    sep1 << TR("Ditta  ") << get_firm();
    sep1 << " " << ragsoc;
    sep1.left_just(198);
  
    set_header (soh++, (const char*) sep1);
  
    sep1 = "";
    sep1 << FR("Data @< Pag. @#");
  
    sep1.right_just(193);
    sep1.overwrite (TR("LISTA DI CONTROLLO MOVIMENTI DI SALDACONTO"));
    set_header (soh++, (const char*)sep1);
    sep1.fill('-');
    set_header (soh++, (const char *) sep1);
  }
  else
  {
    sep << TR("Ditta  ") << get_firm();
    sep << " " << ragsoc;
    sep.left_just(132);
  
    set_header (soh++, (const char*) sep);
  
    sep = "";
    sep << FR("Data @< Pag. @#");
  
    sep.right_just(127);
    sep.overwrite (TR("LISTA DI CONTROLLO MOVIMENTI IN TRASFERIMENTO"));
    set_header (soh++, (const char*)sep);
    sep.fill('-');
    set_header (soh++, (const char *) sep);
    set_header (soh++, FR("Rig  Cod.causale  @30gDescriz.aggiuntiva  @56gCod.conto  @71gDescriz.conto  @99gDare  @116gAvere"));
    set_header (soh, (const char *) sep);
  }
}

void TRic_ListaMov::setta_parametri(const TString& sigla, const TString& flag)
{ 
  TTransfer_file& tr = trasfer();
  
  TConfig conf (CONFIG_DITTA);
  conf.set("FlStTra", flag);
  
  TString rec = tr.record();
  rec.overwrite(sigla,240);
    
  const int size = 1024;
  tr.write_control_rec(rec, size);
}

int cg6700 (int argc, char* argv[])
{ 
  char p1 = '\0';
  char p2 = '\0';
  
  if (argc >= 4)
    p1 = *argv[2];
  if (argc >= 5)  
    p2 = *argv[3];
  
  TRic_ListaMov* a = new TRic_ListaMov(p1,p2);
  a->run(argc, argv,TR("Lista controllo movimenti"));
  delete a;
  return TRUE;
}