// Ricezione dati da sistema

#include <mask.h>
#include <printapp.h>
#include <relation.h>
#include <tabutil.h>
#include <utility.h>
#include <config.h>
#include <urldefid.h> 
#include <mailbox.h>
#include <execp.h>                       
#include <prefix.h>
#include <scanner.h>
#include <lffiles.h>  
#include <progind.h>
#include <nditte.h>  
#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>
#include <pconti.h> 
#include <comuni.h>
#include <clifo.h>

#include "cglib04.h"
#include "cglib.h"
#include "cg2103.h"

#include "cg2600.h"

const int   CAMPI_RCAUS = 6;
HIDDEN      TString80 TEMP;

HIDDEN int date2esc(const TDate& d, int* prevesc = NULL);

class TRic_tab : public TApplication
{
  
  TTable*           _tab_tra;                    
  TLocalisamfile*   _mov, *_rmov, *_rmoviva;
  TTransfer_file    _tras_file;
  TArray            _aggiorna;
  char              _scelta;     
  TSaldo_agg        _sld;  
  TProgind*         _prog;
  
  int     _numinv,_nultras,_annoes,_g,_c;
  TString _trasf,_ragsoc_dittar,_sigle_file,_std,_key,_nomeid,_dittainv;
  long    _dittaric,_numrec,_nreg,_s,_ndoc,_npiva,_nupiva;      
  TDate   _dataultras,_datareg,_dreg,_ddoc;                  
  TString _uselab,_record,_nrec_file,_creg,_ccau,_tdoc,_cod_com;         
  bool    _prima_volta;             
  long    _protiva,_uprotiva,_nprotiva,_nuprotiva,_numreg,_numreg_p,_numreg_piva;
  char    _sez;
  real    _importo,_totdoc;
  
public:        
  TString     _titolo;
  
  virtual bool create();
  virtual bool destroy();
  virtual bool menu(MENU_TAG m);         
  bool    main_loop();
  bool    video();
  bool    leggi_trasfer();
  bool    controlli();
  void    ditta_ricevente();
  bool    controllo_pre_ricezione();  
  void    leggi_record_controllo();

  void    setta_parametri_record(const TString& sigla,const TString& flag);
  
  const char* numero_civico(TString& field);
  const char* cerca_comune_cap(TString& field);
  const char* cerca_comune_den(TString& field);                        
  
  void    trasferimento();
  
  void    scrivi_record_tab(TString& record,long rec);  
  int     trasfer_data_tab(TLocalisamfile& file, TRectype& dep, const TString& sigla);
  int     trasfer_data_conto(TLocalisamfile& file, TRectype& dep);
  int     trasfer_data_sottoc(TLocalisamfile& file, TRectype& dep);
  void    decimali(TString& campo, int dec);
  
  void    scrivi_record_mov(TString& record,long rec);
  int     trasfer_data_mov(TLocalisamfile& file, TRectype& dep);
  long    esiste_numreg(long nreg);                     
  void    num_protocollo(TString& record);
  void    controlli_prima_nota(TString& record,TString& codreg);
  long    ulnumprot_reg(int anno,TString& codreg);             
  long    ultima_registrazione();
  void    aggiorna_reg(int anno,TString& codreg,long ulnum);
  int     annoes_datacomp(const TString& record,TDate& datacomp);
  void    datafine_esprec(const int annop,TDate& datacomp);
  char    ricerca_causale(TString& field);
  void    prepara_saldi(const TString& fname,const TString& field);
  
  void    scrivi_record_moviva(TString& record,long rec);            
  void    aggiorna_temp_file(long numreg, long nreg);
  long    numreg_PN(long numreg);
  long    numrec_PN(long numreg);                
  void    recupera_dati_testata(long numreg);
  bool    occasionali(const TString& record);
  void    scrivi_occasionali(const TString& record, long num);
  void    ricerca_comune(const TString& com);  
  int     cerca_annoes(long numreg);
  int     trasfer_data_moviva(TLocalisamfile& file, TRectype& dep, int ln);
  void    salva_dati_testata();
  
  const char* converti  (TString& data_AS400);
  const char* riconverti(TString& data_PC);  
  
  TRic_tab(char ric_tab_mov);
};                                      

HIDDEN TRic_tab& app() { return (TRic_tab &) main_app(); }

TRic_tab::TRic_tab(char ric_tab_mov) : _scelta(toupper(ric_tab_mov))
{
  if (_scelta == 'T')
    _titolo = "Ricezione tabelle";

  if (_scelta == 'M')      
    _titolo = "Ricezione movimenti";
}

bool TRic_tab::create()
{
  TApplication::create();
  
  _tab_tra  = new TTable ("%TRA");
  _mov      = new TLocalisamfile (LF_MOV);
  _rmov     = new TLocalisamfile (LF_RMOV);
  _rmoviva  = new TLocalisamfile (LF_RMOVIVA);
  
  _numrec      = 1;
  _prima_volta = TRUE;   
  _aggiorna.destroy();
  _numreg_p    = 0;                
  _numreg_piva = 0;                
  _nreg        = 0;
  _sld.reset();
  
  dispatch_e_menu (BAR_ITEM(1));

  return TRUE;
}

bool TRic_tab::destroy()
{
  delete _tab_tra;                            
  delete _mov;
  delete _rmov;
  delete _rmoviva;
  
  return TApplication::destroy();
}                                

HIDDEN int date2esc(const TDate& d, int* prevesc)
{                   
  if (prevesc) *prevesc = 0;
  TTable esc("ESC");
  for (int err = esc.first(); err == NOERR; err = esc.next())
  {
    const TDate ia(esc.get("D0"));   // Data inizio esercizio
    const TDate fa(esc.get("D1"));   // Data fine esercizio
    const anno = esc.get_int("CODTAB");  
    if (d >= ia && d <= fa)
      return anno;
    if (prevesc) *prevesc = anno; 
  } 
  return 0;
}

void TRic_tab::leggi_record_controllo()
{
  _tras_file.read_control_rec();
  _record = _tras_file.record();
}

const char* TRic_tab::converti (TString& data_AS400)
{
  TEMP = data_AS400.mid(4,2);
  TEMP << "-" <<data_AS400.mid(2,2);
  TEMP << "-" <<data_AS400.mid(0,2);
  return TEMP;
}

const char* TRic_tab::riconverti (TString& data_PC)
{
  TEMP = data_PC.mid(8,2);
  TEMP << data_PC.mid(3,2);
  TEMP << data_PC.mid(0,2);
  return TEMP;
}

const char* TRic_tab::numero_civico(TString& indirizzo)
{
  int i;
  
  for (i = indirizzo.len(); (indirizzo[i] != ' ' && indirizzo[i] != ',' && i > 0); i--);
  
  if (i > 0)
  {
    TEMP = indirizzo.mid(i+1);
    indirizzo = indirizzo.sub(0,i);
  }                                
  else
    TEMP = "";
  
  return TEMP;
}

const char* TRic_tab::cerca_comune_cap(TString& field)
{             
  TLocalisamfile comuni (LF_COMUNI);
  TString cap = field;
  
  if (cap.sub(2,3) == "1")
  {
    cap = cap.sub(0,3);
    cap << "00";
  }
  
  comuni.setkey(3);
  comuni.zero();
  comuni.put(COM_CAPCOM, cap);
  if (comuni.read() == NOERR)
    TEMP = comuni.get(COM_COM);
  else
    TEMP = "";
  
  return TEMP;
}

const char* TRic_tab::cerca_comune_den(TString& field)
{   
  TLocalisamfile comuni (LF_COMUNI);
  
  comuni.setkey(2);
  comuni.zero();
  comuni.put(COM_DENCOM, field);
  if (comuni.read() == NOERR)
    TEMP = comuni.get(COM_COM);
  else
    TEMP = "";
  
  return TEMP;
}

bool TRic_tab::main_loop()
{      
  int posiz;
  
  _dittaric = get_firm();
  
  if (_scelta == 'T')
  {  
    if (video())
    { 
      if (_std == "")
        if (!controllo_pre_ricezione())
          return FALSE;

      trasferimento();
      posiz  = _tras_file.num('Z'); //Ritorna la posizione della sigla all'interno dell'indice
      
      if (posiz >= 0)                 
      {   
        setta_parametri_record(" ","C");
        message_box("Aggiornamento tabelle terminato: proseguire con controllo movimenti");
        leggi_record_controllo();
        TString str (_record.overwrite("               ",241));
        _tras_file.write_control_rec(str,256);
      }
      else
      {
        setta_parametri_record(" ","*");
        fremove(_trasf);
        setta_parametri_record(" "," ");
      }
    }
  }
  else
    if (_scelta == 'M')
    {
      if (video())
      {
        trasferimento();
        setta_parametri_record(" ","*");
        fremove(_trasf);
        setta_parametri_record(" "," ");  
      }
    }
  
  return FALSE;
}

void TRic_tab::trasferimento()
{
  char    uselab;
  TString record(256),key;
  int     posiz,i;
  long    rec;
  int     last_tab; 
  char    sigla;               
  TString message;
  
  uselab = (_tras_file.ult_file())[0];
  posiz  = _tras_file.num(uselab); //Ritorna la posizione della sigla all'interno dell'indice
  key    = _tras_file.key(); 
  key.trim();
  
  if (_scelta == 'T')
    last_tab = _tras_file.last_tab();  
  else
    if (_scelta == 'M')
      last_tab = _tras_file.last_mov();        
  
  for (i = posiz; i < last_tab;i++)
  {                 
    if (key == "")                  
      rec   = _tras_file.rec(i);
    else
      rec = atol(key.mid(2,6));
    
    long nrec = ((_tras_file.nrec(i))+1);    
    sigla = _tras_file.name(i)[0];
    long cicli = nrec - rec;
    
    switch (sigla)
    {
    case 'W': message = "Ricezione tabella causali in corso... Prego attendere.";
              break;
            case 'A': message = "Ricezione anagrafica Clienti / Fornitori in corso... Prego attendere.";
              break;
            case 'P': message = "Ricezione anagrafica Piano dei Conti in corso... Prego attendere.";
              break;
            case 'Z': message = "Ricezione Movimenti di primanota in corso... Prego attendere."; 
              break;
            case 'U': message = "Ricezione Movimenti iva in corso... Prego attendere."; 
              break;                      
            default: break;
            }
    _prog = new TProgind(cicli,message,FALSE);
    
    for (long j = rec; j < nrec; j++)
    { 
      _tras_file.read_rec_trasfer(j);
      record = _tras_file.read_rec();
      
      if (_scelta == 'T')
        scrivi_record_tab(record,j);
      else
        if (_scelta == 'M')
        { 
          if (sigla == 'Z')
          {
            scrivi_record_mov(record,j);
            if (j == (nrec - 1))
              _sld.registra();
          }
          else
            if (sigla == 'U')
            {
              scrivi_record_moviva(record,j);
            }
        }
      
    } 
    delete _prog;  
    key = ""; //Altrimenti in caso di ripartenza mi ripristina sempre la situazione
  }
}

void TRic_tab::scrivi_record_tab(TString& record,long rec)
{
  TString sigla,key,str,numero,comune;
  int     numfield = 2;  //Per le tabelle il primo campo della mappa non e' significativo
  //ai fini del trasferimento (flag di record gia trasferito).
  TMappa_trc&       trc = _tras_file.mappa();
  TLocalisamfile*   file = NULL; 
  TRectype*         dep         = NULL;
  char              gia_trasf;
  int               logicnum;
  int               campi_righe = 0;
  int               num_riga    = 1;
  TToken_string     data;
  TString cap = "";
  
  sigla     = record.mid(0,2);
  gia_trasf = record.mid(255,1)[0];
  
  if (gia_trasf == ' ')
  {   
    key.format("%2s%d", (const char*)sigla,numfield);
    
    if (trc.is_key((const char *) key)) 
    {    
      int logicnum_p = 0;
      
      do
      {  
        logicnum = trc.logicnum(key);
        
        if (logicnum != logicnum_p)
        {
          if (logicnum_p)
          {              
            _prog->addstatus(1);
            trasfer_data_tab(*file, *dep, sigla);            
            delete file;
            delete dep;
          }           
          
          if ( (logicnum == LF_RCAUSALI) && (_tras_file.flg_agg() == 'D') )
            break;
          
          file = new TLocalisamfile(logicnum);
          dep  = new TRectype (logicnum);
          dep->zero();
        }                                                 
        
        logicnum_p = logicnum;

        if (logicnum == LF_RCAUSALI) 
        {
          campi_righe++;

          if (campi_righe == CAMPI_RCAUS)
          {
            TString16 gruppo(dep->get("GRUPPO"));     
            //          
            // scarta le righe non significative
            // --------------------  NB  -----------------------
            // supponiamo il GRUPPO INDISPENSABILE !!!!!!!!!!!!!
            //
            if (gruppo.not_empty()) 
            {
              dep->put("NRIGA", num_riga++);
              
              trasfer_data_tab(*file, *dep, sigla);
            }
            else
              num_riga++;
            
            campi_righe   = 1;
          } 
        }

        int     from  = trc.from(key);
        int     to    = trc.to(key);
        TString fname = trc.field_name(key); 
        int     flag  = trc.flag(key);
        TString field = record.sub(from-1,to); 
        
        //Il nostro codice registro IVA e' lungo 3: se il loro registro (lungo 1) e' alfanumerico
        //devo allinearlo a sinistra, mentre se e' numerico devo allinearlo a destra riempendolo con degli zero.      
        if (logicnum == LF_CAUSALI)
        {                          
          if (fname == "REG")
          {
            char f = field[0];
            if (isdigit(f))
              field.format("%03c", f);
            else
              field.format("%-3c", f);
          }
          
          if (fname == "M770")
            if (field == "0")
              field = " ";

          if (fname == "NUMDOC" || fname == "DATADOC")
          {
            if (field == "0")
              field = " ";
            else
              if (field == "1")
                field = "X";
          }
          
          if (fname == "CODCAUSIM")
            if (field == "000")
              field = "   ";                 
        }                           
        
        //Il tipo cliente/fornitore presente su AS400 puo' assumere come valori 1 o 2
        //mentre quello su PC C o F; devo fare la conversione.
        if (sigla == "A1") 
        {
          if (fname == "TIPOCF")
          {
            if (field == "1")
              field = "C"; 
            
            if (field == "2")
              field = "F";
          }
          //Il tipo persona (fisica/giuridica) su AS400 puo' assumere come valori 1 e 0
          //mentre quello su PC F o G; devo fare la conversione.
          if (fname == "TIPOPERS")
          {
            if (field == "1")
              field = "F";
            
            if (field == "0")
              field = "G";
          }        
          
          //Il codice pagamento su AS400 e' un alfanumerico di due, mentre su PC e' un
          //alfanumerico di 4 trattato con il flag Z. Dunque in ricezione se si tratta
          //di un numero va riempito con degli 0. Se si tratta di un alfa va allineato a destra.                       
          if (fname == "CODPAG")
          { 
            TString f = field;
            if (real::is_natural(f))
              field.format("%04s", (const char*) f);
            else
              field.format("%-4s", (const char*) f);
          }
          
          if (fname == "INDCF")
          {            
            field = field.rtrim();
            if (field != "")
            {
              numero = numero_civico(field);
              dep->put(CLI_CIVCF, (const char*)numero);
            }
          }
          
          if (fname == "CAPCF")
          {
            if (field == "00000")
              field = "     ";
            else
              cap = field;
          }
          
          if (fname == "LOCALITACF")
          {
            comune = "";
            
            if (cap.not_empty())
              comune = cerca_comune_cap(cap);
            if (comune.empty())
              comune = cerca_comune_den(field);
            if (comune.not_empty())
            {
              dep->put(CLI_COMCF, comune);
              field = "";
            }
          } 
          
          if (fname == "ALLEG")
            if (field == "0")
              field = " "; 
          
          if (fname == "PAIV")
            if (field == "00000000000")
              field = " ";    
        }
        
        if (flag && (_tras_file.flg_agg() == 'D') )       
        {              
          data = "";
          data.add(fname);
          data.add(field);
          
          _aggiorna.add(data);

          if (sigla == "A1" && fname == "INDCF")
          {            
            data = "";
            data.add("CIVCF");
            data.add(numero);
            
            _aggiorna.add(data);
          }                                     
          
          if (sigla == "A1" && fname == "LOCALITACF")
          {
            data = "";
            data.add("COMCF");
            data.add(comune);
            
            _aggiorna.add(data);
          }
        }

        //Quando ricevo la IV direttiva del piano dei conti per evitare che nell'archivio,
        //in caso di numero romano vuoto, venga memorizzato la stringa letta sul trasfer ("000"),
        //vuoto la stringa prima di fare la put.
        if (sigla == "P2" || sigla == "P3")
        {             
          if (fname == "STSOTTBIL")
          {
            if (field == "0")
              field = "X";
            else
              if (field == "1")
                field = " ";
          }
          
          if (fname == "NUMRIVD" || fname == "NUMRIVDOPP")
          {
            if (field == "000")
              field = "";
          }
          if (fname == "SEZIVD" || fname == "SEZIVDOPP")
          {
            if (field == " ")
              field = "0";
          }
        } 
        
        dep->put(fname, (const char*)field);                      

        numfield++;
        key.format("%2s%d", (const char*) sigla,numfield);
      }
      while (trc.is_key((const char*) key));
      
      if (logicnum == LF_RCAUSALI) 
      { 
        if (_tras_file.flg_agg() != 'D')
        {
          campi_righe++;

          if (campi_righe == CAMPI_RCAUS)
          {
            TString16 gruppo(dep->get("GRUPPO"));     
            //          
            // scarta le righe non significative
            // --------------------  NB  -----------------------
            // supponiamo il GRUPPO INDISPENSABILE !!!!!!!!!!!!!
            //
            if (gruppo.not_empty()) 
            {
              dep->put("NRIGA", num_riga++);
              trasfer_data_tab(*file, *dep, sigla);
            }                                                
            else
              num_riga++;
            
            campi_righe   = 1;
          }  
        } 
      }
      else                      
      {
        _prog->addstatus(1);
        trasfer_data_tab(*file, *dep, sigla);  
      }
      
      delete file;
      delete dep;
      
      _tras_file.writeat("*",1,1,sigla); 
      leggi_record_controllo();
      TString chiave;
      chiave.format("%2s%d", (const char*) sigla,rec);
      str = _record.overwrite(sigla,240);
      str = _record.overwrite(chiave,241);
      _tras_file.write_control_rec(str,256);
      
    } // if (trc.is_key((const char*) key))
  } // if (gia_trasf == ' ')
}

int TRic_tab::trasfer_data_tab(TLocalisamfile& file, TRectype& dep, const TString& sigla)
{ 
  char  flag;
  
  if (sigla == "P2")     
  { 
    trasfer_data_conto(file,dep);
  }
  else
    if (sigla == "P3")
    {                
      trasfer_data_sottoc(file,dep);
    }
    else
    {  
      file.zero();
      file.curr() = dep;
      
      if (file.read() == NOERR)     
      {   
        flag    = _tras_file.flg_agg();
        
        if (flag == 'T')
        { 
          file.zero();
          file.curr() = dep;
          file.rewrite();
        }
        if (flag == 'D')
        {                     
          if (file.num() != LF_RCAUSALI)
          {
            for (int i = 0; i < _aggiorna.items(); i++)
            {
              TToken_string& data = (TToken_string&)_aggiorna[i];
              TString fname = data.get(0);
              TString field = data.get(1);  
              file.put(fname,field);
            }
            file.rewrite();
            _aggiorna.destroy();
          }
        }
      }
      else
      {
        file.zero();
        file.curr() = dep;     
        file.write();    
      }
    }
  
  return 0;
}

int TRic_tab::trasfer_data_conto(TLocalisamfile& file, TRectype& dep)
{ 
  char flag,flag_IV;
  int  g,c;
  
  flag_IV = _tras_file.flg_agg_IV();
  
  file.zero();
  file.curr() = dep;
  
  if (file.read() == NOERR)     
  {   
    flag    = _tras_file.flg_agg();
    flag_IV = _tras_file.flg_agg_IV();
    
    if (flag == 'T')
    { 
      g = dep.get_int(PCN_GRUPPO);
      c = dep.get_int(PCN_CONTO);
      
      if (flag_IV == 'T')
      {
        file.zero();
        file.curr() = dep;
        file.rewrite();
      }
      else
      {    
        dep.put(PCN_SEZIVD, "0");
        dep.zero(PCN_LETTIVD);
        dep.zero(PCN_NUMRIVD);
        dep.zero(PCN_NUMIVD);
        dep.put(PCN_SEZIVDOPP, "0");
        dep.zero(PCN_LETTIVDOPP);
        dep.zero(PCN_NUMRIVDOPP);
        dep.zero(PCN_NUMIVDOPP);
        file.curr() = dep;
        file.rewrite();
      }                
      _tras_file.annulla_classi(g,c,TRUE);
    }
    if (flag == 'D')
    { 
      for (int i = 0; i < _aggiorna.items(); i++)
      {
        TToken_string& data = (TToken_string&)_aggiorna[i];
        TString fname = data.get(0);
        TString field = data.get(1);
        file.put(fname,field);
      }
      file.rewrite();
    }
  }
  else
  { 
    g = dep.get_int(PCN_GRUPPO);
    c = dep.get_int(PCN_CONTO);
    
    if (flag_IV == 'T')
    {
      file.zero();
      file.curr() = dep;
      file.write();
    }
    else
    {    
      g = dep.get_int(PCN_GRUPPO);
      c = dep.get_int(PCN_CONTO);
      
      dep.put(PCN_SEZIVD, "0");
      dep.zero(PCN_LETTIVD);
      dep.zero(PCN_NUMRIVD);
      dep.zero(PCN_NUMIVD);
      dep.put(PCN_SEZIVDOPP, "0");
      dep.zero(PCN_LETTIVDOPP);
      dep.zero(PCN_NUMRIVDOPP);
      dep.zero(PCN_NUMIVDOPP);
      file.curr() = dep;
      file.write();
    }                
    _tras_file.annulla_classi(g,c,TRUE);
  }
  return 0;
}

int TRic_tab::trasfer_data_sottoc(TLocalisamfile& file, TRectype& dep)
{ 
  char flag,flag_IV;
  int  g,c;
  char sez;
  
  sez     = dep.get_char(PCN_SEZIVD);                                    
  flag_IV = _tras_file.flg_agg_IV();
  
  file.zero();
  file.curr() = dep;
  
  if (file.read() == NOERR)     
  {   
    flag    = _tras_file.flg_agg();
    flag_IV = _tras_file.flg_agg_IV();
    
    if (flag == 'T')
    { 
      g = dep.get_int(PCN_GRUPPO);
      c = dep.get_int(PCN_CONTO);
      
      if (flag_IV == 'T')
      {   
        if (sez != '0')
          _tras_file.annulla_classi(g,c,FALSE);
        
        file.zero();
        file.curr() = dep;
        file.rewrite();
      }
      else
      {    
        dep.put(PCN_SEZIVD, "0");
        dep.zero(PCN_LETTIVD);
        dep.zero(PCN_NUMRIVD);
        dep.zero(PCN_NUMIVD);
        dep.put(PCN_SEZIVDOPP, "0");
        dep.zero(PCN_LETTIVDOPP);
        dep.zero(PCN_NUMRIVDOPP);
        dep.zero(PCN_NUMIVDOPP);
        file.curr() = dep;
        file.rewrite();
      }
    }
    if (flag == 'D')
    { 
      for (int i = 0; i < _aggiorna.items(); i++)
      {
        TToken_string& data = (TToken_string&)_aggiorna[i];
        TString fname = data.get(0);
        TString field = data.get(1);
        file.put(fname,field);
      }
      file.rewrite();
    }
  }
  else
  { 
    g = dep.get_int(PCN_GRUPPO);
    c = dep.get_int(PCN_CONTO);
    
    if (flag_IV == 'T')
    { 
      if (sez != '0')
        _tras_file.annulla_classi(g,c,FALSE);
      
      file.zero();
      file.curr() = dep;
      file.write();
    }
    else
    {    
      g = dep.get_int(PCN_GRUPPO);
      c = dep.get_int(PCN_CONTO);
      
      dep.put(PCN_SEZIVD, "0");
      dep.zero(PCN_LETTIVD);
      dep.zero(PCN_NUMRIVD);
      dep.zero(PCN_NUMIVD);
      dep.put(PCN_SEZIVDOPP, "0");
      dep.zero(PCN_LETTIVDOPP);
      dep.zero(PCN_NUMRIVDOPP);
      dep.zero(PCN_NUMIVDOPP);
      file.curr() = dep;
      file.write();
    }                
  }
  return 0;
}                                

long TRic_tab::esiste_numreg(long numulreg)
{ 
  TLocalisamfile mov (LF_MOV);
  
  do
  {
    numulreg++;
    
    mov.setkey(1);
    mov.zero();
    mov.put(MOV_NUMREG, numulreg);
  }
  while (mov.read() == NOERR);
  
  return numulreg;
}

void TRic_tab::num_protocollo(TString& record)
{
  _protiva  = atol(record.sub(36,41));
  _uprotiva = atol(record.sub(108,113));
  
  if (_protiva == 0)
    _uprotiva = 0;
  
  _nprotiva  = _protiva;
  _nuprotiva = _uprotiva;
}                        

long TRic_tab::ulnumprot_reg(int anno,TString& cr)
{
  //TString cr = format("%c", codreg);
  TRegistro rg (cr, anno);   
  
  return rg.protocol();
}

void TRic_tab::aggiorna_reg(int anno,TString& codreg,long ulnum)
{
  TTable reg ("REG");
  TString16 dep;
  
  if (real::is_natural(codreg)) 
    dep.format("%04d%03s", anno,(const char*) codreg);
  else
    dep.format("%04d%-3s", anno,(const char*) codreg);
  
  reg.zero();
  reg.put("CODTAB", (const char*) dep);
  if (reg.read() == NOERR)
  {
    if (_nprotiva > (ulnum + 1) )
      reg.put("I5", _nprotiva);
    
    if (_nuprotiva > (ulnum + 1) )
      reg.put("I5", _nuprotiva);
    
    reg.rewrite();
  }  
}

void TRic_tab::controlli_prima_nota(TString& record,TString& codreg)
{ 
  TTable tpd ("%TPD");
  bool      corrisp;
  TDate     datareg;  
  int       anno;
  long      ulnum = 0;
  TString16 tmp;
  TString   tipodoc;
  
  int     tiporeg = atoi(record.sub(222,223));                  

  TString80 tmpmov = "%";
  tmpmov  << _tras_file.path(_dittaric);
  tmpmov << "\\" << TEMP_MOV;
  
  TIsamtempfile tmp_mov (LF_MOV, tmpmov, FALSE);
  
  tmp_mov.zero();
  tmp_mov.put(MOV_NUMREG, _numreg);
  if (tmp_mov.read() == NOERR)
  {
    codreg  = tmp_mov.get(MOV_REG);  
    tipodoc = tmp_mov.get(MOV_TIPODOC);                   
  }

  tmp             = record.sub(15,21);
  TString data    = converti(tmp);
  datareg         = data;
  anno            = datareg.year();
  
  bool numprot_att = _tras_file.numprot_att(); 
  bool numprot_pas = _tras_file.numprot_pas(); 
  
  tpd.zero();
  tpd.put("CODTAB", (const char*) tipodoc);
  if (tpd.read() == NOERR)
    corrisp = tpd.get_bool("B0");
  
  if (codreg != "" && !corrisp)
  {
    if ( ( (tiporeg == 1 && (numprot_att || _protiva == 0) ) )
        || ( (tiporeg == 2 && (numprot_pas || _protiva == 0) ) ) )
    {              
      ulnum = ulnumprot_reg(anno,codreg);
      _nprotiva = ulnum + 1;
      if (_uprotiva != 0)
        _nuprotiva = (_nprotiva - ulnum) + _uprotiva;
    }                                     
  }
  
  aggiorna_reg(anno,codreg,ulnum);
}

void TRic_tab::datafine_esprec(const int aep, TDate& datacomp)
{
  TTable esc("ESC");
  for (int err = esc.first(); err == NOERR; err = esc.next())
  {
    const anno = esc.get_int("CODTAB");  
    if (anno == aep)
      datacomp = esc.get("D1");
  } 
}

int TRic_tab::annoes_datacomp(const TString& record, TDate& datacomp)
{ 
  TString tmp;   
  int     segn;
  int     ae = 0;
  
  tmp          = record.sub(15,21);
  TString data = converti(tmp);
  _datareg      = data;
  segn         = atoi(record.sub(21,22));  
  
  ae = date2esc(_datareg);
  if (segn == 0)
    datacomp = _datareg;
  
  if (segn == 1)
  {
    ae -= 1;
    datafine_esprec(ae,datacomp);
  }
  return ae;
}

long TRic_tab::ultima_registrazione()
{ 
  if (_nreg == 0)
  {
    TLocalisamfile mov (LF_MOV);
    
    mov.last();
    return (mov.get_long(MOV_NUMREG));
  }                                
  else
    return _nreg;
}

char TRic_tab::ricerca_causale(TString& causale)
{  
  TLocalisamfile cau (LF_CAUSALI);
  char    movap = ' ';
  
  if (real::is_natural(causale))
    causale.format("%03s", (const char*) causale);
  else
    causale.format("%-3s", (const char*) causale);
  
  cau.setkey(1);
  cau.zero();
  cau.put("CODCAUS", causale);
  if (cau.read() == NOERR)
    movap = cau.get_char("MOVAP");
  
  return movap;
}

void TRic_tab::prepara_saldi(const TString& fname,const TString& field)
{
  if (fname == "GRUPPO")
    _g = atoi(field);
  
  if (fname == "CONTO")
    _c = atoi(field);
  
  if (fname == "SOTTOCONTO")
    _s = atol(field);
  
  if (fname == "SEZIONE")
    _sez = field[0];
  
  if (fname == "IMPORTO")
  {
    real imp = real::ita2eng(field);  
    _importo = imp;
    TString i = _importo.string();
  }
}

void TRic_tab::scrivi_record_mov(TString& record,long rec)
{
  TString sigla,key,str,codreg;
  int     numfield = 3; //Per i movimenti i primi due campi della mappa non sono significativi
  //ai fini del trasferimento (flag record gia trasferito e nuovo ultimo numero di registrazione). 
  TMappa_trc&       trc  = _tras_file.mappa();
  TLocalisamfile*   file = NULL; 
  TRectype*         dep  = NULL;
  char              gia_trasf,annullato;
  int               logicnum;
  long              numulreg;   
  TDate             datacomp;
  TString           nreg;
  int               fnrmov = 14;
  
  sigla     = record.mid(0,2);
  annullato = record.mid(248,1)[0];
  
  if (annullato == ' ')   
  {   
    key.format("%2s%d", (const char*)sigla,numfield);
    
    if (trc.is_key((const char *) key)) 
    {    
      int logicnum_p = 0;             
      
      _numreg = atol(record.sub(2,8));
      
      if (_numreg != _numreg_p)
      { 
        if (_numreg_p != 0)             
        {
          _sld.registra();
          _sld.reset();
        }
        
        long nuovareg = atol(record.sub(250,256));
        
        if (nuovareg == 0)
        {
          numulreg = ultima_registrazione(); //reperisco il numero ultima registrazione
          _nreg = esiste_numreg(numulreg);
          num_protocollo(record);
          controlli_prima_nota(record,codreg);
        }
        else
        {
          _nreg = nuovareg;
          numfield = fnrmov;
          key.format("%2s%d", (const char*)sigla,numfield);
        }
      }
      else
      {
        numfield = fnrmov;
        key.format("%2s%d", (const char*)sigla,numfield);
      }
      
      _annoes = annoes_datacomp(record,datacomp); 
      _numreg_p = _numreg;   
      gia_trasf = record.sub(249,250)[0];
      
      if (gia_trasf == ' ')
      {
        do
        {  
          logicnum = trc.logicnum(key);
          
          if (logicnum != logicnum_p)
          {
            if (logicnum_p)
            {
              trasfer_data_mov(*file, *dep);
              nreg.format("%6d",_nreg);
              _tras_file.writeat(nreg,6,2,sigla); 
              aggiorna_temp_file(_numreg,_nreg);
              delete file;
              delete dep;
            }

            file = new TLocalisamfile(logicnum);
            dep  = new TRectype (logicnum);
            dep->zero();
          }                                                 
          
          logicnum_p = logicnum;                                                
          
          if (logicnum == 24 && numfield == 26)
          {
            numfield++;
            key.format("%2s%d", (const char*) sigla,numfield);
            continue;
          }
          
          int     from  = trc.from(key);
          int     to    = trc.to(key);
          TString fname = trc.field_name(key); 
          TString field = record.sub(from-1,to); 
          int     flag  = trc.flag(key);
          int     dec   = trc.flag_bis(key);
          
          if (flag == 3)
          { 
            if (dec > 0)
              decimali(field,dec);
            
            real appoggio (field);
            field = appoggio.string();
          }
          
          if (logicnum == LF_MOV)
          {
            if (fname == "REG")
            {                         
              if (real::is_natural(codreg))
                field.format("%03s", (const char*) codreg);
              else
                field.format("%-3s", (const char*) codreg);
            }                           

            //Il codice pagamento su AS400 e' un alfanumerico di due, mentre su PC e' un
            //alfanumerico di 4 trattato con il flag Z. Dunque in ricezione se si tratta
            //di un numero va riempito con degli 0. Se si tratta di un alfa va allineato a destra.                       
            if (fname == "CODPAG")
            { 
              TString f = field;
              if (real::is_natural(f))
                field.format("%04s", (const char*) f);
              else
                field.format("%-4s", (const char*) f);
            }
          }

          if (logicnum == LF_RMOV)
            prepara_saldi(fname,field);
          
          if (fname == "PROTIVA") 
          { 
            char var[6];
            sprintf(var,"%5d",_nprotiva);
            field = var;
          }  
          if (fname == "UPROTIVA")  
          {
            char var[6];
            sprintf(var,"%5d",_nuprotiva);
            field = var;
          }
          
          
          if (logicnum == LF_MOV && fname == "CODCAUS")
          {
            _sld.set_anno_es(_annoes);
            _sld.set_movprovv(FALSE);
            _sld.set_num_ulmov(_nreg);
            _sld.set_data_ulmov(_datareg);
            char movap = ricerca_causale(field);
            if (movap == 'A')
              _sld.set_movap(TRUE);
          }
          
          if (logicnum == LF_MOV && (fname == "NUMREG" || flag == 2) ) 
          {                       
            if (fname == "NUMREG") 
            {
              dep->put(MOV_ANNOES,   _annoes);                                     
              dep->put(MOV_NUMREG,   _nreg);
              dep->put(MOV_DATAREG,  _datareg);
              dep->put(MOV_DATACOMP, datacomp);
            }
            if (flag == 2)
            {
              TString f = converti(field);
              dep->put(fname,f);
            }
          }
          else  
            if (logicnum == LF_RMOV && (fname == "NUMREG" || fname == "NUMRIG") ) 
            {                        
              if (fname == "NUMREG")
              {   
                dep->put(RMV_ANNOES,  _annoes);                                     
                dep->put(RMV_NUMREG,  _nreg);
              }

              if (fname == "NUMRIG")
              {
                dep->put(RMV_NUMRIG,  field);  
                dep->put(RMV_DATAREG, _datareg);
              }
            }
            else
              dep->put(fname, field);
          
          numfield++;
          key.format("%2s%d", (const char*) sigla,numfield);
        }
        while (trc.is_key((const char*) key));
        
        _prog->addstatus(1);                                  
        trasfer_data_mov(*file, *dep);      
        TString impor = _importo.string();
        _sld.aggiorna(_g,_c,_s,_importo,_sez);
        
        delete file;
        delete dep;
        
        _tras_file.writeat("*",1,1,sigla);        
        nreg.format("%6d",_nreg);
        _tras_file.writeat(nreg,6,2,sigla);  
        //aggiorna_temp_file(_numreg,_nreg);
        leggi_record_controllo();
        TString chiave;
        chiave.format("%2s%d", (const char*) sigla,rec);
        str = _record.overwrite(sigla,240);
        str = _record.overwrite(chiave,241);
        _tras_file.write_control_rec(str,256);
      } // if (gia_trasf == ' ')
    } // if (trc.is_key((const char*) key))
  } // if (gia_trasf == ' ')
}

int TRic_tab::trasfer_data_mov(TLocalisamfile& file, TRectype& dep)
{  
  file.zero();
  file.curr() = dep;
  
  if (file.read() == NOERR)     
  { 
    file.zero();
    file.curr() = dep;
    file.rewrite();
  }
  else
  {
    file.zero();
    file.curr() = dep;     
    file.write();    
  }
  return 0;
}

void TRic_tab::aggiorna_temp_file(long numreg, long nreg)
{
  TString80 tmpmov = "%";
  tmpmov  << _tras_file.path(_dittaric);
  tmpmov << "\\" << TEMP_MOV;
  
  TIsamtempfile tmp_mov (LF_MOV, tmpmov, FALSE);
  
  tmp_mov.zero();
  tmp_mov.put(MOV_NUMREG, numreg);
  if (tmp_mov.read() == NOERR)
  {
    tmp_mov.put(MOV_CODCF, nreg);
    tmp_mov.rewrite();
  }
}

long TRic_tab::numrec_PN(long numreg)
{   
  long num = 0;
  
  TString80 tmpmov = "%";
  tmpmov  << _tras_file.path(_dittaric);
  tmpmov << "\\" << TEMP_MOV;
  
  TIsamtempfile tmp_mov (LF_MOV, tmpmov, FALSE);
  
  tmp_mov.zero();
  tmp_mov.put(MOV_NUMREG, numreg);
  if (tmp_mov.read() == NOERR)
    num = tmp_mov.get_long(MOV_NUMGIO);
  
  return num;
}                           

long TRic_tab::numreg_PN(long numreg)
{   
  long num = 0;
  
  TString80 tmpmov = "%";
  tmpmov  << _tras_file.path(_dittaric);
  tmpmov << "\\" << TEMP_MOV;
  
  TIsamtempfile tmp_mov (LF_MOV, tmpmov, FALSE);
  
  tmp_mov.zero();
  tmp_mov.put(MOV_NUMREG, numreg);
  if (tmp_mov.read() == NOERR)
    num = tmp_mov.get_long(MOV_CODCF);
  
  return num;
}                           

void TRic_tab::recupera_dati_testata(long numreg)
{
  TLocalisamfile mov (LF_MOV);
  
  mov.setkey(1);
  mov.zero();
  mov.put(MOV_NUMREG, numreg);
  if (mov.read() == NOERR)
  {
    _dreg   = mov.get_date(MOV_DATAREG);
    _ddoc   = mov.get_date(MOV_DATADOC);
    _ndoc   = mov.get_long(MOV_NUMDOC);
    _creg   = mov.get     (MOV_REG);
    _ccau   = mov.get     (MOV_CODCAUS);
    _tdoc   = mov.get     (MOV_TIPODOC);
    _npiva  = mov.get_long(MOV_PROTIVA);
    _nupiva = mov.get_long(MOV_UPROTIVA);
    _totdoc = mov.get_real(MOV_TOTDOC);
  }
}

bool TRic_tab::occasionali(const TString& record)
{
  TLocalisamfile occas (LF_OCCAS);
  TString ragsoc;        
  long    num;
  
  ragsoc = record.sub(61,86);
  ragsoc.trim();
  
  if (ragsoc == "") return FALSE;
  
  occas.setkey(1);
  occas.zero();
  occas.put("CFPI", "RIC999999");
  if (occas.read() == NOERR)
    num = 0;
  else
    if ( (occas.get("CFPI")).len() > 9)
    {
      occas.prev();
      if ( (occas.get("CFPI")).len() > 9)
        num = 0;
      else
      {
        TString cfpi = occas.get("CFPI");
        
        if (cfpi.mid(0,3) == "RIC" && cfpi.len() == 9)
        {
          num = atol(cfpi.mid(3,6));
          num += 1;
        }
        else
          num = 0;
      }
    }         
    else
    {
      TString cfpi = occas.get("CFPI");
      
      if (cfpi.mid(0,3) == "RIC" && cfpi.len() == 9)
      {
        num = atol(cfpi.mid(3,6));
        num += 1;
      }
      else
        num = 0;
    }
  
  scrivi_occasionali(record,num);
  
  return TRUE;  
}

void TRic_tab::scrivi_occasionali(const TString& record, long num)
{
  TLocalisamfile occas (LF_OCCAS);
  TString cfpi,ragsoc,ind,com,cap,app; 
  int     err;
  
  app = "RIC";
  cfpi.format("%3s%6d", (const char*)app,num);
  ragsoc = record.sub(61,86);
  ind    = record.sub(86,108);
  com    = record.sub(108,126);
  cap    = record.sub(126,131);
  
  ricerca_comune(com);
  
  occas.setkey(1);
  occas.zero();
  occas.put("CFPI", cfpi);
  occas.put("RAGSOC", ragsoc);
  occas.put("INDIR", ind);
  occas.put("CAP", cap);  
  if (_cod_com != "")
    occas.put("COM", _cod_com);
  
  err = occas.write();
  
  if (err == _isreinsert)
    err = occas.rewrite();
}

void TRic_tab::ricerca_comune(const TString& com)
{
  TLocalisamfile comuni (LF_COMUNI);
  
  comuni.setkey(2);
  comuni.zero();
  comuni.put(COM_DENCOM, com);
  if (comuni.read() == NOERR)
    _cod_com = comuni.get(COM_COM);
  else
    _cod_com = "";
}

int TRic_tab::cerca_annoes(long numreg)
{
  TLocalisamfile mov (LF_MOV);
  int anno = 0;
  
  mov.setkey(1);
  mov.zero();
  mov.put(MOV_NUMREG, numreg);
  if (mov.read() == NOERR)
    anno = mov.get_int(MOV_ANNOES);
  
  return anno;
}

void TRic_tab::salva_dati_testata()
{
  TString str,app;
  long    numrec;
  
  numrec =  numrec_PN(_numreg);
  numrec += _tras_file.start('Z');
  
  _tras_file.read_rec_trasfer(numrec); //Leggo il record della prima nota
  
  app = _dreg.string();
  str = riconverti(app);
  _tras_file.put(str,"Z1",0,numrec);
  app = _ddoc.string();
  str = riconverti(app);
  _tras_file.put(str,"Z1",4,numrec);
  str = format("%ld", _ndoc);
  _tras_file.put(str,"Z1",5,numrec);
  _tras_file.put(_creg,"Z1",6,numrec);
  _tras_file.put(_ccau,"Z1",8,numrec);
  _tras_file.put(_tdoc,"Z1",12,numrec);
  str = format("%ld", _npiva);
  _tras_file.put(str,"Z1",7,numrec);
  str = format("%ld", _nupiva);
  _tras_file.put(str,"Z1",10,numrec);
  str = _totdoc.string();
  _tras_file.put(str,"Z1",13,numrec);
  _tras_file.write(numrec);
}

void TRic_tab::decimali(TString& campo, int dec)
{
  int l = campo.len();
  int p = l - dec;
  campo.insert(".",p);
}

void TRic_tab::scrivi_record_moviva(TString& record,long rec)
{
  TString sigla,key,str;
  int     numfield = 3; //Per i movimenti i primi due campi della mappa non sono significativi
  //ai fini del trasferimento (flag record gia trasferito e nuovo ultimo numero di registrazione).  
  TMappa_trc&       trc  = _tras_file.mappa();
  TLocalisamfile*   file = NULL; 
  TRectype*         dep  = NULL;
  char              gia_trasf,annullato;
  int               logicnum;
  TString           nreg;
  int               fnrmiva = 11;
  
  sigla     = record.mid(0,2);
  annullato = record.mid(248,1)[0];
  
  if (annullato == ' ')   
  {   
    key.format("%2s%d", (const char*)sigla,numfield);
    
    if (trc.is_key((const char *) key)) 
    {    
      int logicnum_p = 0;             
      
      _numreg = atol(record.sub(2,8));
      
      if (_numreg != _numreg_piva)
      { 
        long nuovareg = atol(record.sub(250,256));
        
        if (nuovareg == 0)
          _nreg = numreg_PN(_numreg);
        else
        {
          _nreg = nuovareg;
          //recupera_dati_testata(_nreg);
          numfield = fnrmiva;
          key.format("%2s%d", (const char*)sigla,numfield);
        }   
        recupera_dati_testata(_nreg);
      }
      else
      {
        numfield = fnrmiva;
        key.format("%2s%d", (const char*)sigla,numfield);
      }
      
      _numreg_piva = _numreg;   
      gia_trasf = record.sub(249,250)[0];
      
      if (gia_trasf == ' ' || _ccau != "000")
      {
        
        occasionali(record);
        
        do
        {  
          logicnum = trc.logicnum(key);
          
          if (logicnum != logicnum_p)
          {
            if (logicnum_p)
            {
              trasfer_data_moviva(*file, *dep, logicnum_p);
              nreg.format("%6d",_nreg);
              _tras_file.writeat(nreg,6,2,sigla);     
              salva_dati_testata();
              delete file;
              delete dep;
            }

            file = new TLocalisamfile(logicnum);
            dep  = new TRectype (logicnum);
            dep->zero();
          }                                                 
          
          logicnum_p = logicnum;                                                
          
          int     from  = trc.from(key);
          int     to    = trc.to(key);
          TString fname = trc.field_name(key); 
          TString field = record.sub(from-1,to); 
          int     flag  = trc.flag(key);
          int     dec   = trc.flag_bis(key);
          
          if (logicnum == LF_MOV && fname == "TOTDOC")
          {
            numfield++;
            key.format("%2s%d", (const char*) sigla,numfield);
            continue;
          }
          
          if (flag == 3)
          {
            if (dec > 0)
              decimali(field,dec);
            
            real appoggio (field);
            field = appoggio.string();  
          }                           
          
          if (logicnum == LF_MOV && ( fname == "NUMREG" || flag == 1 ) ) 
          {  
            if (fname == "NUMREG")
              dep->put("NUMREG",   _nreg);
            
            if (flag == 1)
            {
              TString f = converti(field);
              dep->put(fname,f);
            }                                       
          }
          else
            if (logicnum == LF_RMOVIVA && fname == "NUMREG")
            {
              int annoes = cerca_annoes(_nreg);                    
              dep->put("ANNOES",   annoes);                                     
              dep->put("NUMREG",   _nreg);
            }
            else
              dep->put(fname, field);          
          
          numfield++;
          key.format("%2s%d", (const char*) sigla,numfield);
        }
        while (trc.is_key((const char*) key));
        
        _prog->addstatus(1);                                  
        trasfer_data_moviva(*file, *dep, logicnum_p);      
        TString impor = _importo.string();
        
        delete file;
        delete dep;
        
        _tras_file.read_rec_trasfer(rec); //Per essere sicuro di essere posizionato sul record giusto dell'iva sul trasfer
        _tras_file.writeat("*",1,1,sigla);        
        nreg.format("%6d",_nreg);
        _tras_file.writeat(nreg,6,2,sigla);  
        leggi_record_controllo();
        TString chiave;
        chiave.format("%2s%d", (const char*) sigla,rec);
        str = _record.overwrite(sigla,240);
        str = _record.overwrite(chiave,241);
        _tras_file.write_control_rec(str,256);
      } // if (gia_trasf == ' ')
    } // if (trc.is_key((const char*) key))
  } // if (gia_trasf == ' ')
}

int TRic_tab::trasfer_data_moviva(TLocalisamfile& file, TRectype& dep, int ln)
{   
  file.zero();
  file.curr() = dep;
  
  if (file.read() == NOERR)     
  { 
    if (ln == LF_MOV)
    { 
      TDate   data74ter (dep.get_date(MOV_DATA74TER));
      TString codval    (dep.get     (MOV_CODVAL));
      long    codcf     = dep.get_long(MOV_CODCF);
      real    cambioi   (dep.get_real(MOV_CAMBIOI));
      real    corrlire  (dep.get_real(MOV_CORRLIRE));
      real    corrvaluta(dep.get_real(MOV_CORRVALUTA));
      
      file.put(MOV_DATA74TER, data74ter);
      file.put(MOV_CODVAL,    codval);
      file.put(MOV_CODCF,     codcf);
      file.put(MOV_CAMBIOI,   cambioi);
      file.put(MOV_CORRLIRE,  corrlire);
      file.put(MOV_CORRVALUTA,corrvaluta);
      
      file.rewrite();
    }
    else
    {
      file.zero();
      file.curr() = dep;
      file.rewrite();
    }
  }
  else
  {
    file.zero();
    file.curr() = dep;     
    file.write();    
  }
  
  return 0;
}

bool TRic_tab::leggi_trasfer()
{ 
  _nultras = 0;
  
  _trasf = _tras_file.path(_dittaric);
  _trasf << "\\trasfer";
  
  _tras_file.open(_trasf);
  
  if (_tras_file.exist())
  {  
    if (_tras_file.read_control_rec())
    {
      _nultras    = _tras_file.nultras();
      _dataultras = _tras_file.dataultras();
      _sigle_file = _tras_file.sigle_file();
      _nrec_file  = _tras_file.nrec_file();             
      // La fill_index e' richiamata dentro a read_control_rec      
      //      _tras_file.fill_index(_sigle_file,_nrec_file);  
      _uselab     = _tras_file.ult_file();
      _key        = _tras_file.key();
      _record     = _tras_file.record();
    }         
else
  return error_box("Rilevati gravi errori negli archivi:procedura interrotta");
  } 
else
  return error_box("Al momento non presenti trasferimenti attivi sulla ditta selezionata");
  
  return TRUE; 
}

bool TRic_tab::video()
{                    
  TConfig conf(CONFIG_DITTA);           
  
  _std = conf.get("FlStTra");
  
  if (!leggi_trasfer())
    return FALSE;
  
  TMask msk ("cg2600a");
  KEY  tasto;
  
  ditta_ricevente();       
  
  msk.set(F_CODDITTA,   _dittaric);
  msk.set(F_RAGSOC,     _ragsoc_dittar);
  msk.set(F_NULTRAS,    _nultras);
  TString data1 = _dataultras.string();
  msk.set(F_DATAULTRAS, data1);         
  msk.set(F_STD,        _std);
  msk.set(F_USELAB,     _uselab);
  msk.set(F_STATO,      _key);

  tasto = msk.run();
  
  if (tasto != K_ENTER)
    return FALSE;
  
  if (!prefix().exist(_dittaric))
    return error_box("Rilevati gravi errori negli archivi: procedura interrotta");

  if (!controlli())
    return FALSE;     
  
  return TRUE;
}

void TRic_tab::setta_parametri_record(const TString& sigla,const TString& flag)
{ 
  TConfig conf (CONFIG_DITTA);
  
  conf.set("FlStTra", flag);
  
  leggi_record_controllo();
  _record.overwrite(sigla,240);
  
  const int size = 256;
  
  _tras_file.write_control_rec(_record, size);
}

bool TRic_tab::controllo_pre_ricezione()
{ 
  TString flag;
  
  TString sigla = _sigle_file.mid(0,1);
  
  if (sigla == " ")
  {
    flag   = "*";
    setta_parametri_record(sigla,flag);
    fremove(_trasf);
    return FALSE;
  }              
  
  if (sigla == "Z")
  {
    flag   = "C";
    setta_parametri_record(sigla,flag);
    return error_box("Aggiornamento tabelle terminato: proseguire con controllo movimenti");
  }             
  
  if (sigla != "Z")
  {
    flag   = "T";
    setta_parametri_record(sigla,flag);
    return TRUE;
  }
  
  return TRUE;
}

void TRic_tab::ditta_ricevente()
{
  TLocalisamfile nditte (LF_NDITTE);
  
  nditte.setkey(1);
  nditte.zero();
  nditte.put(NDT_CODDITTA, _dittaric);
  if (nditte.read() == NOERR)
    _ragsoc_dittar = nditte.get(NDT_RAGSOC);
}

bool TRic_tab::controlli()
{ 
  if (_scelta == 'T')
  {
    if (_std == "C")
      return error_box("Aggiornamento tabelle gia' effettuato: richiamare Controllo movimenti");
    
    if (_std == "M")
      return error_box("Aggiornamento tabelle gia' effettuato: richiamare Trasferimento movimenti");           
    
    if (_std != "" && _std != "T")
      return error_box("Rilevati gravi errori negli archivi: procedura interrotta");
    
    if ( (_std == "" || _std == "T") && (_uselab == "Z" || _uselab == "U") )  
      return error_box("Rilevati gravi errori negli archivi: procedura interrotta");
  }
  else
    if (_scelta == 'M')
    {
      if (_std == "" || _std == "T")
        return error_box("Aggiornamento tabelle NON EFFETTUATO: richiamare il programma relativo");
      
      if (_std == "C")
        return error_box("Controllo movimenti non effettuato o rilevati errori gravi");
      
      if (_std == "M" && (_uselab != "Z" && _uselab != "U" && _uselab != "B") ) 
        return error_box("Rilevati GRAVI ERRORI negli archivi: procedura interrotta");
      
      if (_std != "" && _std != "M")
        error_box("Rilevati GRAVI ERRORI negli archivi: procedura interrotta");  
    }
  
  if (_std == "*") 
  {
    warning_box("Trasferimento interamente completato: proseguire per cancellare il file");    
    fremove(_trasf);
    return FALSE;
  }
  
  return TRUE;
}

bool TRic_tab::menu(MENU_TAG m)
{
  if (m == BAR_ITEM(1))
    return main_loop(); 
  return FALSE;
}

int cg2600 (int argc, char* argv[])
{                                
  TRic_tab main_app(*argv[2]);
  main_app.run(argc, argv,main_app._titolo);
  return TRUE;
}
