// Invio contabilita'

#include "cg6900.h"
#include "cg6900a.h"

TInv_cont::TInv_cont(char mov) : _scelta(toupper(mov))
{
  switch (_scelta)
  {       
  case 'S':
    _titolo = "Invio a Sistema";
    break;
  case 'P':
    _titolo = "Invio a PC";
    break;    
  default:
    break;
  }
}
                                   
bool TInv_cont::messaggio_hnd(TMask_field& f, KEY k)
{
  if (k == K_TAB)
    return message_box("Rilevato STATO DI RIPARTENZA: il trasferimento ripartira' automaticamente");
  
  return TRUE;
}
                                   
bool TInv_cont::main_loop()
{                     
  TString str;
  bool ripartenza = FALSE;
  
  if (!esiste_tabella_studio()) return FALSE;
  
  if (!esegui_controlli()) return FALSE;
  
  TMask msk ("cg6900a");
  KEY tasto;
  
  if (_ditta != 0)       
  {
    msk.set(F_DITTAINV, _ditta);
    msk.disable(F_DITTAINV);
    codifica_ditta(msk);
    msk.set(F_NUMULINV, _num);
    msk.set(F_DATAULIN, _data.string());
    msk.set(F_STATO,    _stato);
    
    TString uselab = _tras_file.ult_file();
    TString chiave = _tras_file.key();
    msk.set(F_USELAB,   uselab);
    msk.set(F_CHIAVE,   chiave);
    msk.set(F_DATALIM,  _data.string());
    msk.disable(F_DATALIM);
    
    ripartenza = TRUE;
  }
  
  msk.disable(F_NUMULINV);
  msk.disable(F_DATAULIN);
  msk.disable(F_STATO);
  msk.disable(F_USELAB);
  msk.disable(F_CHIAVE);

  if (!ripartenza)
    msk.set_handler(F_DITTAINV, setta_maschera_hnd);
  else
    msk.set_handler(F_NUMULINV, messaggio_hnd);  
  
  tasto = msk.run();
  
  if (tasto != K_ENTER) return FALSE;
            
// Nel caso di invio PC --> SISTEMA eseguo prima la
// Lista controllo archivi per rilevare eventuali
// differenze.
  
  long ditta = msk.get_long(F_DITTAINV);
  set_firm(ditta);

  TConfig conf(CONFIG_DITTA);           
  TString std = conf.get("FlStInv");
  
  if (_scelta == 'S' && std != "D")
  {  
     TString appname = "cg6 -8 L";
     TString corpo   = "";
     
     TDate data = msk.get(F_DATALIM);
     
     corpo << data.string();
  
     TMessage mess (appname,"",(const char*)corpo);
     TMailbox mb;
     mb.send(mess);
     
     TExternal_app a (appname);
     a.run();
     
     TMailbox m;
     TMessage* msg = m.next_s("");
     int subj;
     
     if (msg != NULL)
     {
       subj = atoi(msg->body());
       if (subj)
         return FALSE;
     }
  }  
  
  _datalimsk = msk.get(F_DATALIM);
  
  if (!ripartenza)
  {                                
    crea_marker(msk);                 //Crea il record con le informazioni sul marker                 
    setta_parametri_record(msk,"F");  //Aggiorna parametri contabili ditta           
    setta_tabella_studio(msk);        //Aggiorna la tabella studio per invio
    setta_tabella_ditta(msk,"F");     //Aggiorna la tabella ditta per invio
    crea_record_controllo(msk);       //Crea il record di controllo sul file header
  }                
  else
  { 
    TString str,app;
    
    int num = msk.get_int(F_NUMULINV);
    TString data (msk.get(F_DATALIM));
    app = riconverti(data,FALSE);
    str.format("%03d%6s", num, (const char*) app);
    aggiorna_marker(str,14);
  }

  apri_file_temp();
    
  if (!invio_tempfile(msk))
    return FALSE;
  
//  calcola_totale_record();
//  str.format("%06ld", _tot_rec);

  if (_scelta == 'S')
  {                             
//    aggiorna_marker(str,23);  
    
    _trasf = ""; 
    _trasf = firm2dir(0);
    _trasf << "\\trasfer"; 
    fremove(_trasf);
    _tras_file.open(_trasf,TRUE);
                            
//    if (std != "D")
      invio_contabilita();              //Costruisce il trasfer nella directory comune
    
    TMask mask ("cg6900b");
    KEY k;
  
    k = mask.run();
   
    if (k == K_ENTER)
    {
      int  num_disk = calcola_numero_dischi(mask);
      char floppy   = mask.get(F_FLOPPY)[0];
    
      str.format("%02d", num_disk);
      aggiorna_marker(str,29);

      const TFilename from(_trasf);          // File da splittare

      TFilename work;
      work << floppy << ":/" << from.name();   // File su dischetto
    
      FILE* i = fopen(from, "rb");                                             
    
      if (i == NULL) return error_box("Impossibile aprire il file '%s'", from);
    
      TProgind w(_dim_tot, "Trasferimento su dischetti in corso... Prego attendere", TRUE, TRUE, 60);
    
      for (int j = 0; j < num_disk; j++)
      {
        scrivi_disco(floppy,j+1,work,i,w);
      }
      fclose(i);
    
      setta_tabella_studio(msk,FALSE);    //Aggiorna la tabella studio per invio
      setta_tabella_ditta(msk," ",FALSE); //Aggiorna la tabella ditta per invio
      setta_parametri_record(msk," ");    //Aggiorna parametri contabili ditta           
    
      _tras_file.open(_header);
      leggi_record_controllo();
      TString record(256);  
      record.format("%-256s",(const char*) record);
      _control_rec.overwrite(record,0);
      _tras_file.write_control_rec(_control_rec,256);

      chiudi_file_temp();      
    }                
    else
      return FALSE;
  }
  else
    if (_scelta == 'P')
    {
      aggiorna_marker(str,24);
      
      TMask mask ("cg6900b");
      KEY k;
      
      mask.disable(F_DIM);
      
      k = mask.run();
   
      if (k == K_ENTER)
      {
        char floppy  = mask.get(F_FLOPPY)[0];
        TString flp  = mask.get(F_FLOPPY);
        TFilename firm;
        firm.tempdir();
        firm << "\\ftemp";
        TString desc = "";
        
        make_dir(firm);
        _tras_file.open(_header);
        TString sigle = _tras_file.sigle_file();
        sigle.trim();
        
        TString dir = firm2dir(0);

        chiudi_file_temp();                     
         
        _tras_file.temp_dir(dir,firm,sigle);
         
        _arc.backup(firm, floppy, desc);  

        TString orig = dir;        orig << "\\marker";
        TString dest = flp << ":"; dest << "\\marker";
        fcopy(orig,dest);          

        setta_tabella_studio(msk,FALSE);     //Aggiorna la tabella studio per invio
        setta_tabella_ditta(msk," ",FALSE);  //Aggiorna la tabella ditta per invio
        setta_parametri_record(msk," ");     //Aggiorna parametri contabili ditta           
        _tras_file.canc_file_dir_temp(firm); //Cancella i file della directory temporanea ftemp
      }
      else
        return FALSE;
    }
                       
  _tras_file.remove_all(FALSE);                        
  fremove(_marker);
  _trasf = ""; 
  _trasf = firm2dir(0);
  _trasf << "\\trasfer";  
  fremove(_trasf);
  
  return FALSE;
}

bool TInv_cont::create()
{
  TApplication::create();
  
  _caus     = new TLocalisamfile (LF_CAUSALI);
  _rcaus    = new TLocalisamfile (LF_RCAUSALI);
  _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);       
  _occas    = new TLocalisamfile (LF_OCCAS);

  dispatch_e_menu (BAR_ITEM(1));

  return TRUE;
}

bool TInv_cont::destroy()
{                                           
  delete _caus;
  delete _rcaus;
  delete _clifo;
  delete _pcon;
  delete _mov;
  delete _rmov;
  delete _rmoviva;
  delete _occas;  

  return TApplication::destroy();
}                                

void TInv_cont::apri_file_temp()
{ 
  _tras_file.open(_header);
  leggi_record_controllo();
  _sigle = _tras_file.sigle_file();
  _sigle.trim();
  
  for (int i = 0; i < _sigle.len(); i++)
  {                       
    TString80 tmp;
    char sigla = _sigle[i];
    
    if (sigla == 'W')
    {
      TString80 tmpcaus = "%";
      tmpcaus << firm2dir(0);
      tmpcaus << "\\" << TEMP_CAUS;          
      tmp = tmpcaus.mid(1);
      tmp << ".dbf";
      if (fexist(tmp))
        _tcaus    = new TIsamtempfile(LF_CAUSALI, tmpcaus, FALSE);  
      else
        _tcaus    = new TIsamtempfile(LF_CAUSALI, tmpcaus, TRUE);  
      TString80 tmprcaus = "%";
      tmprcaus << firm2dir(0);
      tmprcaus << "\\" << TEMP_RCAUS;
      tmp = tmprcaus.mid(1);
      tmp << ".dbf";
      if (fexist(tmp))
        _trcaus   = new TIsamtempfile(LF_RCAUSALI, tmprcaus, FALSE);
      else
        _trcaus   = new TIsamtempfile(LF_RCAUSALI, tmprcaus, TRUE);
    }
    if (sigla == 'A')
    {
      TString80 tmpclifo = "%";
      tmpclifo << firm2dir(0);
      tmpclifo << "\\" << TEMP_CLIFO;
      tmp = tmpclifo.mid(1);
      tmp << ".dbf";
      if (fexist(tmp))
        _tclifo    = new TIsamtempfile(LF_CLIFO, tmpclifo, FALSE);
      else
        _tclifo    = new TIsamtempfile(LF_CLIFO, tmpclifo, TRUE);
    }
    if (sigla == 'P')
    {
      TString80 tmppcon = "%";
      tmppcon << firm2dir(0);
      tmppcon << "\\" << TEMP_PCON;
      tmp = tmppcon.mid(1);
      tmp << ".dbf";
      if (fexist(tmp))                                 
        _tpcon    = new TIsamtempfile(LF_PCON, tmppcon, FALSE);
      else
        _tpcon    = new TIsamtempfile(LF_PCON, tmppcon, TRUE);
    }
    if (sigla == 'Z')
    {
      TString80 tmpmov = "%";
      tmpmov << firm2dir(0);
      tmpmov << "\\" << TEMP_MOV;
      tmp = tmpmov.mid(1);
      tmp << ".dbf";
      if (fexist(tmp))
        _tmov     = new TIsamtempfile(LF_MOV, tmpmov, FALSE);
      else
        _tmov     = new TIsamtempfile(LF_MOV, tmpmov, TRUE);
      TString80 tmprmov = "%";
      tmprmov << firm2dir(0);
      tmprmov << "\\" << TEMP_RMOV;
      tmp = tmprmov.mid(1);
      tmp << ".dbf"; 
      if (fexist(tmp))
        _trmov    = new TIsamtempfile(LF_RMOV, tmprmov, FALSE);
      else
        _trmov    = new TIsamtempfile(LF_RMOV, tmprmov, TRUE);
    }
    if (sigla == 'U')
    {
      TString80 tmpriva = "%";
      tmpriva << firm2dir(0);
      tmpriva << "\\" << TEMP_RMOVIVA;
      tmp = tmpriva.mid(1);
      tmp << ".dbf";
      if (fexist(tmp))
        _triva    = new TIsamtempfile(LF_RMOVIVA, tmpriva, FALSE);
      else
        _triva    = new TIsamtempfile(LF_RMOVIVA, tmpriva, TRUE);
      TString80 tmpoccas = "%";
      tmpoccas << firm2dir(0);
      tmpoccas << "\\" << TEMP_OCC;
      tmp = tmpoccas.mid(1);
      tmp << ".dbf";
      if (fexist(tmp))
        _toccas   = new TIsamtempfile(LF_OCCAS, tmpoccas, FALSE);
      else
        _toccas   = new TIsamtempfile(LF_OCCAS, tmpoccas, TRUE);
    }
  }
}

void TInv_cont::chiudi_file_temp()
{
  for (int i = 0; i < _sigle.len(); i++)
  {
    char sigla = _sigle[i];

    if (sigla == 'W')
    {
      delete _tcaus;
      delete _trcaus;
    }
    if (sigla == 'A')
      delete _tclifo;
    if (sigla == 'P')
      delete _tpcon;
    if (sigla == 'Z')
    {
      delete _tmov;
      delete _trmov;
    }
    if (sigla == 'U')
    {
      delete _triva;
      delete _toccas;
    }
  }
}

void TInv_cont::leggi_record_controllo()
{
  _tras_file.read_control_rec();
  _control_rec = _tras_file.record();
}

bool TInv_cont::esiste_tabella_studio()
{
  TTable ins ("%INS");
  
  ins.zero();        
  
  if (ins.first() == NOERR)
  {
    if (ins.empty())
      return error_box("Codice STUDIO NON ATTIVATO in tabella invii");
    else
    { 
      _nome_simbolico = ins.get("S0");
      long ditta = ins.get_long("I0");
      if (ditta != 0)
      {
        _esiste_ditta = TRUE;
        _ditta = ditta;
      }
      else
      {             
        _esiste_ditta = FALSE;
        _ditta = 0;
      }
    }
  }
  else
    return error_box("Codice STUDIO NON ATTIVATO in tabella invii");  
  
  return TRUE;  
}  

bool TInv_cont::leggi_header()
{ 
  _header = ""; 
  _header = firm2dir(0);
  _header << HEADER;
  
  _tras_file.open(_header);
  
  if (_tras_file.exist())           
  {  
    if (_tras_file.read_control_rec())
    {
      _control_rec = _tras_file.record();
      if (!record_controllo())
        return FALSE;
    }
    else
      return FALSE;
  } 
  else
    return FALSE;
  
  return TRUE; 
}

bool TInv_cont::record_controllo()
{
  TString tiporecord = _control_rec.sub(0,2);
  
  if (tiporecord != " 1")
    return FALSE;
  
  return TRUE;
}

bool TInv_cont::esegui_controlli()
{  
  _esiste_record = leggi_header();
  
  if (!controlli()) return FALSE;

  return TRUE;
}

void TInv_cont::setta_parametri_record(TMask& m,const TString& flag)
{  
  TConfig conf (CONFIG_DITTA);
  conf.set("FlStInv", flag);
}

bool TInv_cont::controlli()
{ 
  if (!_esiste_ditta && !_esiste_record) return TRUE; //Mi trovo in una condizione normale
  
  if (_esiste_ditta && !_esiste_record)
    return error_box("Rilevato stato di ripartenza con dati contradditori: programma interrotto");
  
  if (!_esiste_ditta && _esiste_record)
    return error_box("Rilevato stato di ripartenza con dati contradditori: programma interrotto");
  
  if (_esiste_ditta && _esiste_record)
  {
    if (!sub_controlli())
      return error_box("Rilevato stato di ripartenza con dati contradditori: programma interrotto");
  }
  
  return TRUE;
}   

bool TInv_cont::sub_controlli()
{
  long ditta_trasfer = _tras_file.ditta();
  
  if (_ditta == ditta_trasfer)
  {
    if (!prefix().exist(_ditta))
      return FALSE;
    
    if (!tabella_ditta())
      return FALSE;
  }          
  else
    return FALSE;

  if (!controlla_stato_invio())  
    return FALSE;
  
  if (!numero_data())
    return FALSE;    
  
  return TRUE;  
}

bool TInv_cont::tabella_ditta()
{
  TTable ind ("%IND");
  TString dep;
  
  dep.format("%05d", _ditta);
  
  ind.zero();
  ind.put("CODTAB", dep);
  if (ind.read() == NOERR) 
  {
    _stato = ind.get("S6");
    _num   = ind.get_int("I0");
    _data  = ind.get_date("D0");
    
    _files = "";
    if (ind.get_bool("B0"))
      _files << "W";
    
    if (ind.get_bool("B1"))
      _files << "A";
    
    if (ind.get_bool("B2"))
      _files << "P";        
    
    if (ind.get_bool("B3"))
      _files << "Z";
    
    if (ind.get_bool("B4"))
      _files << "U";
    
    if (ind.get_bool("B5"))
      _files << "B";
      
    _flag_bollato = ind.get_bool("B7");
    
    return TRUE;
  }  
  
  return FALSE;  
}

bool TInv_cont::controlla_stato_invio()
{ 
  set_firm(_ditta);
  
  TConfig conf(CONFIG_DITTA);           
  _std = conf.get("FlStInv");
  
  if (_stato != _std)
    return FALSE;
  else
  {                  
    TString uselab = _tras_file.ult_file();
    
    if (_stato == "D" && uselab != "")
      return FALSE;
  }                
  
  return TRUE;
}

bool TInv_cont::numero_data()
{                                        
  int     num  = _tras_file.nultras();
  TString str  = _tras_file.dataultras();
  TDate data (str);
  
  if (_num != num || data != _data)
    return FALSE;
  
  return TRUE;
}

void TInv_cont::codifica_ditta(TMask& m)
{
  TLocalisamfile ditte (LF_NDITTE);
  
  long ditta = m.get_long(F_DITTAINV);
  
  ditte.setkey(1);
  ditte.zero();
  ditte.put(NDT_CODDITTA, ditta);
  if (ditte.read() == NOERR)
  {
    TString ragsoc = ditte.get(NDT_RAGSOC);
    m.set(F_RAGSOC, ragsoc);
  }
}

bool TInv_cont::setta_maschera_hnd(TMask_field& f, KEY k)
{
  if ( (k == K_TAB || k == K_ENTER) && f.mask().is_running())
  {    
    app()._ditta = f.mask().get_long(F_DITTAINV);
    if (!prefix().exist(app()._ditta))
      return error_box("La ditta indicata non e' abilitata alla contabilita'");

    if (!app().tabella_ditta())
      return error_box("La ditta indicata non e' presente sulla tabella ditta per invio");
   
    if (app()._stato != "")
      return error_box("Rilevato STATO DI RIPARTENZA NON RECUPERABILE sulla ditta richiesta");
    
    f.mask().set(F_DITTAINV, app()._ditta);
    app().codifica_ditta(f.mask());
    f.mask().set(F_NUMULINV, app()._num);
    f.mask().set(F_DATAULIN, app()._data.string());
    f.mask().set(F_STATO,    app()._stato);    
  }
  
  return TRUE;
}

void TInv_cont::crea_marker(TMask& m)
{
  TString str;
  
  _marker = ""; 
  _marker = firm2dir(0);
  _marker << "\\marker";
  
  FILE* i;

  const word size = 64;
  TString buffer(size); 
  buffer.spaces();
  
  if ( (i = fopen(_marker,"w+t")) != NULL)
  { 
    if (_scelta == 'S')
    {
      str = format("%-10s", (const char*) _nome_simbolico);
      buffer.overwrite(str,0);
      long ditta = m.get_long(F_DITTAINV);
      str = format("%04d", ditta);
      buffer.overwrite(str,10);
      int num = m.get_int(F_NUMULINV);
      num++;
      str = format("%03d", num);
      buffer.overwrite(str,14);
      TString data (m.get(F_DATALIM));
      str = riconverti(data,FALSE);
      buffer.overwrite(str,17);               
    }
    else
      if (_scelta == 'P')
      {
        str = format("%-10s", (const char*) _nome_simbolico);
        buffer.overwrite(str,0);
        long ditta = m.get_long(F_DITTAINV);
        str = format("%05d", ditta);
        buffer.overwrite(str,10);
        int num = m.get_int(F_NUMULINV);
        num++;
        str = format("%03d", num);
        buffer.overwrite(str,15);
        TString data (m.get(F_DATALIM));
        str = riconverti(data,FALSE);
        buffer.overwrite(str,18);      
      }
      
    buffer.cut(64); //Sicurezza: le stringhe dimensionate in realta' sono
                    //leggermente piu' lunghe della dimensione specificata
    const word scritti = fwrite((char*)(const char*)buffer,sizeof(char),size,i);
    
    fclose(i);
  }    
}

void TInv_cont::aggiorna_marker(TString& token, int pos)
{   
  TString str;
  
  _marker = ""; 
  _marker = firm2dir(0);
  _marker << "\\marker";
  
  FILE* i;

  const word size = 64;
  TString buffer(size); 
  //buffer.spaces();
  
  if ( (i = fopen(_marker,"r+t")) != NULL)
  { 
    const word letti = fread((char*)(const char*)buffer,sizeof(char),size,i);
    buffer.overwrite(token,pos);

    buffer.cut(64); //Sicurezza: le stringhe dimensionate in realta' sono
                    //leggermente piu' lunghe della dimensione specificata    
    fseek(i, 0L, SEEK_SET);
    const word scritti = fwrite((char*)(const char*)buffer,sizeof(char),size,i);
    
    fclose(i);
  }    
}

void TInv_cont::calcola_totale_record()
{
  _tras_file.open(_header);
  leggi_record_controllo();
  
  TString sigle = _tras_file.sigle_file();
  sigle.trim();
  
  _tot_rec = 0;
  
  for (int i = 0; i < sigle.len(); i++)
  {
    long tot_rec = atol(_control_rec.mid((i * 6) + 50,6));
    _tot_rec += tot_rec;
  }             
  _tot_rec += 1;
}

void TInv_cont::setta_tabella_studio(TMask& m,bool flag_ditta)
{
  TTable ins ("%INS");
  TString dep;
  long ditta;
  
  if (flag_ditta)
    ditta = m.get_long(F_DITTAINV);
  else
    ditta = 0;
  
  dep.format("%-3s", (const char*) "INS");
  
  ins.zero();
  ins.put("CODTAB", dep);
  if (ins.read() == NOERR)
  {
    ins.put("I0", ditta);
    ins.rewrite();
  }
  else
    warning_box("Tabella studio per invio NON AGGIORNATA");
}

void TInv_cont::setta_tabella_ditta(TMask& m,const char* flag, bool comp)
{
  TTable ind ("%IND");
  TString dep;
  
  long ditta = m.get_long(F_DITTAINV);
  
  dep.format("%05d", ditta);
  
  ind.zero();
  ind.put("CODTAB", dep);
  if (ind.read() == NOERR) 
  {                    
    int num = m.get_int(F_NUMULINV);
    num++;
    TDate data (m.get(F_DATALIM)); 
    
    ind.put("S6", flag);                                
    if (comp)
    {
      ind.put("I0", (long)num);
      ind.put("D0", data);
    }
    ind.rewrite();
  }  
  else
    warning_box("Tabella ditta per invio NON AGGIORNATA");  
}

void TInv_cont::crea_record_controllo(TMask& m)
{            
  int size = 256;
  TString buffer(256);
  TString str;
  
  if (_tras_file.exist())
    _tras_file.open(_header);
  else 
  {
    _tras_file.open(_header,TRUE);   //Metto il parametro TRUE (che di default e' FALSE), perche' voglio creare un file che non e' ancore esistente
    
    buffer.spaces();   
    buffer.overwrite(" 1",0);                             //Tipo record
    
    str = format("%-10s", (const char*) _nome_simbolico);
    buffer.overwrite(str,15);                             //Nome studio
    
    long ditta = m.get_long(F_DITTAINV);
    str = format("%05d", ditta);
    buffer.overwrite(str,25);                             //Ditta inviante
    
    int num = m.get_int(F_NUMULINV);
    num++;
    str = format("%03d", num);
    buffer.overwrite(str,30);                             //Numero progr. invio
    
    TString data (m.get(F_DATALIM));
    str = riconverti(data,TRUE);
    buffer.overwrite(str,33);                             //Data limite invio
    
    str = format("%-9s", (const char*) _files);
    buffer.overwrite(str,41);
    
    str = _files.sub(0,1);
    buffer.overwrite(str,240); 
    
    str = "";
    str.format("%054d", 0);
    buffer.overwrite(str,50);
    
    if (!_tras_file.write_control_rec(buffer, size))   
      warning_box("Il record di controllo del file trasfer non e' stato aggiornato correttamente");
  }  
  _tras_file.close();  
} 

const char* TInv_cont::cerca_provincia(const TString& comcf)
{
  TLocalisamfile comuni(LF_COMUNI);
  
  comuni.setkey(1);
  comuni.zero();
  comuni.put(COM_COM, comcf);
  if (comuni.read() == NOERR)
    TEMP = comuni.get(COM_PROVCOM);
  else
    TEMP = "";

  return TEMP;
}

bool TInv_cont::invio_tempfile(TMask& m)
{
  char    uselab;
  TString record(256),key,nrec;
  int     posiz,i;
  char    sigla;               

  _tras_file.open(_header);
  
  leggi_record_controllo();
  
  uselab = (_tras_file.ult_file())[0];
  
  if (uselab == '\0')            //Significa che sono in caso di ripartenza ma ho
    return TRUE;                //gia' trasferito tutti gli archivi e devo solo fare la copia su dischi
  
  posiz  = _files.find(uselab); //Ritorna la posizione della sigla all'interno della schiera
  key    = _tras_file.key(); 
  key.trim();                 
  nrec   = _tras_file.nrec_file();
  
  for (i = posiz; i < _files.len();i++)
  {                 
    sigla    = _files[i];
    _numrec  = atol(nrec.mid(i * 6,6));
    
    switch (sigla)        
    {
    case 'W': 
        causali2tempfile(key,m);
      break;
      
    case 'A':
        clifo2tempfile(key,m);
      break;
      
    case 'P':
        pcon2tempfile(key,m);
      break;
      
    case 'Z':
        movPN2tempfile(key,m);
      break;
      
    case 'U':
        movIVA2tempfile(key,m);
      break;
      
    default:
      break;
    };             
    key = "";
  }                    

  // Finito di trasferire tutti gli archivi pulisco la sigla ultimo file da elaborare  
  _tras_file.open(_header);
  leggi_record_controllo();
  _control_rec.overwrite(" ",240);
  _tras_file.write_control_rec(_control_rec,256);
  _tras_file.close();

  setta_tabella_ditta(m,"D",FALSE);
  setta_parametri_record(m,"D");  
  
  return TRUE;
}                         

void TInv_cont::causali2tempfile(TString& key, TMask& m)
{
  int     size = 256;

  _tras_file.open(_header);
                                         
  long items = _caus->items();
  _prog = new TProgind(items,"Invio tabella causali in corso... Prego attendere.",FALSE);
  
  _caus->setkey(1);
                    
  if (key.empty())
    _caus->first();
  else
  {             
    TString causale (key.mid(0,3));
    _caus->zero();
    _caus->put(CAU_CODCAUS, causale);
    _caus->read();
  }
  
  for(; !_caus->eof(); _caus->next())
  { 
    _prog->addstatus(1);
                               
    TString codcaus = _caus->get(CAU_CODCAUS);
    
    _tcaus->curr() = _caus->curr(); 
    
    if (_tcaus->read() == NOERR)  // Esiste la testata
    {
      scrivi_righe_causali(codcaus,'W');
            
      _tcaus->zero();
      _tcaus->curr() = _caus->curr();
      _tcaus->rewrite();
    }  
    else
    {
      scrivi_righe_causali(codcaus,'W');
            
      _tcaus->zero();
      _tcaus->curr() = _caus->curr();
      _tcaus->write();
    }
          
    leggi_record_controllo();
    TString chiave;
    chiave.format("%3s",(const char*) codcaus);      
    _control_rec.overwrite("W",240);
    _control_rec.overwrite(chiave,241);

    _tras_file.write_control_rec(_control_rec,size);
  }
  delete _prog;
  
  //Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare
  //e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di 
  //ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche'
  //la chiave e' compilata con i dati del file precedente.

  leggi_record_controllo();
  TString chiave,app,sigla;
  app.format("%-15s", (const char*) chiave);
  char sigla_p = _tras_file.ult_file()[0];
  int posiz    = _files.find(sigla_p);
  TString nuova_sigla = " ";
  if (posiz < _files.len())
    nuova_sigla = _files.mid(posiz+1,1);
  
  _control_rec.overwrite(nuova_sigla,240);
  _control_rec.overwrite(app,241);
  _tras_file.write_control_rec(_control_rec,size);
  _tras_file.close();
  
//  setta_tabella_ditta(m,"D",FALSE);
//  setta_parametri_record(m,"D");  
}

void TInv_cont::cancella_righe_causali(TString& codcaus)
{
  _trcaus->setkey(1);
  _trcaus->zero();
  _trcaus->put(RCA_CODCAUS, codcaus);
  TRectype rcau (LF_RCAUSALI);
  rcau = _trcaus->curr();
  for (_trcaus->read(); !_trcaus->eof(); _trcaus->next())
  {
    if (_trcaus->curr() > rcau) break;
    
    _trcaus->remove();
  }
}

void TInv_cont::scrivi_righe_causali(TString& codcaus, char uselab)
{
  cancella_righe_causali(codcaus);
                                   
  _rcaus->setkey(1);
  _rcaus->zero();
  _rcaus->put(RCA_CODCAUS, codcaus);
  TRectype rcau (LF_RCAUSALI);                               
  rcau = _rcaus->curr();
  for (_rcaus->read(); !_rcaus->eof(); _rcaus->next())
  {
    if (_rcaus->curr() > rcau) break;
      
    _trcaus->curr() = _rcaus->curr();
    _trcaus->write();
      
    leggi_record_controllo();
    TString chiave;
    chiave.format("%3s",(const char*) codcaus);
    TString sigla (format("%c", uselab));
    _control_rec.overwrite(sigla,240);
    _control_rec.overwrite(chiave,241);
    _tras_file.write_control_rec(_control_rec,256);      
  }
}

void TInv_cont::clifo2tempfile(TString& key, TMask& m)
{
  int     size = 256;
  
  _tras_file.open(_header);
    
  long items = _clifo->items();
  _prog = new TProgind(items,"Invio Clienti / Fornitori in corso... Prego attendere.",FALSE);
                                       
  _clifo->setkey(1);
                    
  if (key.empty())
    _clifo->first();
  else
  {         
    char tipo   = (key.mid(0,1))[0];     
    long codice = atol(key.mid(1,6));
    _clifo->zero();
    _clifo->put(CLI_TIPOCF, tipo);
    _clifo->put(CLI_CODCF,  codice);
    _clifo->read();
  }
  
  for(; !_clifo->eof(); _clifo->next())
  { 
    _prog->addstatus(1);
    
    char tipocf = _clifo->get_char(CLI_TIPOCF);                            
    long codcf  = _clifo->get_long(CLI_CODCF);
    
    _tclifo->curr() = _clifo->curr(); 
    
    if (_tclifo->read() == NOERR)  // Esiste gia' il cliente
    {
      _tclifo->zero();
      _tclifo->curr() = _clifo->curr();
      _tclifo->rewrite();
    }  
    else
    {
      _tclifo->zero();
      _tclifo->curr() = _clifo->curr();
      _tclifo->write();
    }
          
    leggi_record_controllo();
    TString chiave;
    chiave.format("%c%06ld", tipocf, codcf);      
    TString sigla (format("%c", 'A'));
    _control_rec.overwrite(sigla,240);
    _control_rec.overwrite(chiave,241);

    _tras_file.write_control_rec(_control_rec,size);          
  }     
  delete _prog;  

  //Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare
  //e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di 
  //ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche'
  //la chiave e' compilata con i dati del file precedente.
  
  leggi_record_controllo();
  TString chiave,app,sigla;
  app.format("%-15s", (const char*) chiave);
  char sigla_p = _tras_file.ult_file()[0];
  int posiz    = _files.find(sigla_p);
  TString nuova_sigla = " ";
  if (posiz < _files.len())
    nuova_sigla = _files.mid(posiz+1,1);
  
  _control_rec.overwrite(nuova_sigla,240);
  _control_rec.overwrite(app,241);
  _tras_file.write_control_rec(_control_rec,size);
  _tras_file.close();

//  setta_tabella_ditta(m,"D",FALSE);
//  setta_parametri_record(m,"D");  
}


void TInv_cont::pcon2tempfile(TString& key, TMask& m)
{
  int     size = 256;

  _tras_file.open(_header);
  
  long items = _pcon->items();
  _prog = new TProgind(items,"Invio Piano dei Conti in corso... Prego attendere.",FALSE);
                                       
  _pcon->setkey(1);
                    
  if (key.empty())
    _pcon->first();
  else
  {             
    int  gruppo = atoi(key.mid(0,3));
    int  conto  = atoi(key.mid(3,3));
    long sottoc = atol(key.mid(6,6));
    
    _pcon->zero();
    _pcon->put(PCN_GRUPPO, gruppo);
    if (conto != 0)
      _pcon->put(PCN_CONTO, conto);
    if (sottoc != 0)
      _pcon->put(PCN_SOTTOCONTO, sottoc);
    _pcon->read();
  }
  
  for(; !_pcon->eof(); _pcon->next())
  { 
    _prog->addstatus(1);
    
    int  g = _pcon->get_int (PCN_GRUPPO);
    int  c = _pcon->get_int (PCN_CONTO);
    long s = _pcon->get_long(PCN_SOTTOCONTO);
    
    _tpcon->curr() = _pcon->curr(); 
    
    if (_tpcon->read() == NOERR)  // Esiste gia' il cliente
    {
      _tpcon->zero();
      _tpcon->curr() = _pcon->curr();
      _tpcon->rewrite();
    }  
    else
    {
      _tpcon->zero();
      _tpcon->curr() = _pcon->curr();
      _tpcon->write();
    }

    leggi_record_controllo();
    TString chiave;
    chiave.format("%3d%3d%6ld", g, c, s);      
    TString sigla (format("%c", 'P'));
    _control_rec.overwrite(sigla,240);
    _control_rec.overwrite(chiave,241);

    _tras_file.write_control_rec(_control_rec,size);
  }     
  delete _prog;  

  //Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare
  //e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di 
  //ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche'
  //la chiave e' compilata con i dati del file precedente.
  
  leggi_record_controllo();
  TString chiave,app,sigla;
  app.format("%-15s", (const char*) chiave);
  char sigla_p = _tras_file.ult_file()[0];
  int posiz    = _files.find(sigla_p);
  TString nuova_sigla = " ";
  if (posiz < _files.len())
    nuova_sigla = _files.mid(posiz+1,1);
  
  _control_rec.overwrite(nuova_sigla,240);
  _control_rec.overwrite(app,241);
  _tras_file.write_control_rec(_control_rec,size);
  _tras_file.close();

//  setta_tabella_ditta(m,"D",FALSE);
//  setta_parametri_record(m,"D");  
}

void TInv_cont::primanota_inviata(long numreg)
{
  _mov->setkey(1);
  _mov->zero();
  _mov->put(MOV_NUMREG, numreg);
  if (_mov->read() == NOERR)
  {
    _mov->put(MOV_INVIATO, "X");
    if (_flag_bollato)
      _mov->put(MOV_STAMPATO, "X");
      
    _mov->rewrite();
  }
}

void TInv_cont::scrivi_righePN(long numreg)
{
  int     size = 256;    
                   
  _tras_file.open(_header);
                                   
  _rmov->setkey(1);
  _rmov->zero();
  _rmov->put(RMV_NUMREG, numreg);
  TRectype rmov (LF_RMOV);                               
  rmov = _rmov->curr();
  for (_rmov->read(); !_rmov->eof(); _rmov->next())
  {
    if (_rmov->curr() > rmov) break;
      
    _trmov->zero();                               
    _trmov->curr() = _rmov->curr();
    _trmov->write();    
  } 
}

void TInv_cont::movPN2tempfile(TString& key, TMask& m)
{
  int     size = 256;                                       

  _tras_file.open(_header);
  
  long items = _mov->items();
  _prog = new TProgind(items,"Invio movimenti di Primanota in corso... Prego attendere.",FALSE);

  _mov->setkey(1);
                    
  if (key.empty())
    _mov->first();
  else
  {             
    long numreg = atol(key.mid(0,7));
    _mov->zero();
    _mov->put(MOV_NUMREG, numreg);
    _mov->read();
  }
  
  for(; !_mov->eof(); _mov->next())
  { 
    _prog->addstatus(1);
                               
    long nreg      = _mov->get_long(MOV_NUMREG);

    TDate datareg (_mov->get_date(MOV_DATAREG)); 
    
    if ( _mov->get_bool(MOV_INVIATO) || datareg > _datalimsk ) continue; 
    
    _tmov->curr() = _mov->curr();
    
    if (_tmov->read() == NOERR)  
    {                  
      _tmov->zero();
      _tmov->curr() = _mov->curr();
      _tmov->rewrite();
      
      scrivi_righePN(nreg);
    }
    else
    {
      _tmov->zero();
      _tmov->curr() = _mov->curr();
      _tmov->write();
      
      scrivi_righePN(nreg);
    }
          
    leggi_record_controllo();
    TString chiave;
    chiave.format("%07ld", nreg);      
    TString sigla (format("%c", 'Z'));
    _control_rec.overwrite(sigla,240);
    _control_rec.overwrite(chiave,241);
    _tras_file.write_control_rec(_control_rec,size);
    
    primanota_inviata(nreg);
  }                                
  delete _prog;  

  //Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare
  //e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di 
  //ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche'
  //la chiave e' compilata con i dati del file precedente.
  
  leggi_record_controllo();
  TString chiave,app,sigla;
  app.format("%-15s", (const char*) chiave);
  char sigla_p = _tras_file.ult_file()[0];
  int posiz    = _files.find(sigla_p);
  TString nuova_sigla = " ";
  if (posiz < _files.len())
    nuova_sigla = _files.mid(posiz+1,1);
  
  _control_rec.overwrite(nuova_sigla,240);
  _control_rec.overwrite(app,241);
  _tras_file.write_control_rec(_control_rec,size);
  _tras_file.close();
  
//  setta_tabella_ditta(m,"D",FALSE);
//  setta_parametri_record(m,"D");  
}

bool TInv_cont::occasionali(const TString& cfpi)
{  
  TString chiave;
  
  _occas->setkey(1);
  _occas->zero();
  _occas->put("CFPI", cfpi);
  _occas->read();

  _toccas->zero();
  _toccas->curr() = _occas->curr();
  
  if (_toccas->read() == NOERR)
  { 
    _toccas->zero();
    _toccas->curr() = _occas->curr();
    _toccas->rewrite();               
  }
  else
  {
    _toccas->zero();
    _toccas->curr() = _occas->curr();
    _toccas->write();
  }

  return TRUE;  
}

void TInv_cont::iva_inviata(long numreg)
{
  _mov->setkey(1);
  _mov->zero();
  _mov->put(MOV_NUMREG, numreg);
  if (_mov->read() == NOERR)
  {
    _mov->put(MOV_INVIVA, "X");
    if (_flag_bollato)
      _mov->put(MOV_REGST, "X");
    
    _mov->rewrite();
  }
}

void TInv_cont::movIVA2tempfile(TString& key, TMask& m)
{
  TString ocfpi;
  TDate   datareg;
  bool    inviva;
  int     size = 256;

  _tras_file.open(_header);
                                         
  long items = _rmoviva->items();
  _prog = new TProgind(items,"Invio movimenti Iva in corso... Prego attendere.",FALSE);

  _rmoviva->setkey(1);
                    
  if (key.empty())
    _rmoviva->first();
  else
  {             
    long numreg = atol(key.mid(0,7));
    _rmoviva->zero();
    _rmoviva->put(RMI_NUMREG, numreg);
    _rmoviva->put(RMI_NUMRIG, 1);
    _rmoviva->read();
  }

  long nreg_p = -1;
  
  for(; !_rmoviva->eof(); _rmoviva->next())
  { 
    _prog->addstatus(1);
                               
    long nreg      = _rmoviva->get_long(RMI_NUMREG);

    if (nreg != nreg_p)
    {
      _mov->setkey(1);
      _mov->zero();
      _mov->put(MOV_NUMREG, nreg);
      if (_mov->read() == NOERR)
      {
        datareg = _mov->get_date(MOV_DATAREG);
        inviva  = _mov->get_bool(MOV_INVIVA);        
        ocfpi   = _mov->get     (MOV_OCFPI);
      } 
    }
    else
      inviva = FALSE;
    
    if ( inviva || datareg > _datalimsk ) continue;
    
    if (ocfpi.not_empty())
      occasionali(ocfpi);
                                                     
    _triva->zero();
    _triva->curr() = _rmoviva->curr();
    
    if (_triva->read() == NOERR) 
    {                            
      _triva->zero();
      _triva->curr() = _rmoviva->curr();
      _triva->rewrite();             
    }
    else
    {
      _triva->zero();
      _triva->curr() = _rmoviva->curr();
      _triva->write();    
    }  
          
    leggi_record_controllo();
    TString chiave;
    chiave.format("%07ld", nreg);      
    TString sigla (format("%c", 'U'));
    _control_rec.overwrite(sigla,240);
    _control_rec.overwrite(chiave,241);

    _tras_file.write_control_rec(_control_rec,size);          
    
    if (nreg != nreg_p)
      iva_inviata(nreg);
    
    nreg_p = nreg;
  }                                
  delete _prog;  

  //Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare
  //e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di 
  //ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche'
  //la chiave e' compilata con i dati del file precedente.
  
  leggi_record_controllo();
  TString chiave,app,sigla;
  app.format("%-15s", (const char*) chiave);
  char sigla_p = _tras_file.ult_file()[0];
  int posiz    = _files.find(sigla_p);
  TString nuova_sigla = " ";
  if (posiz < _files.len())
    nuova_sigla = _files.mid(posiz+1,1);
  
  _control_rec.overwrite(nuova_sigla,240);
  _control_rec.overwrite(app,241);
  _tras_file.write_control_rec(_control_rec,size);
  _tras_file.close();
  
//  setta_tabella_ditta(m,"D",FALSE);
//  setta_parametri_record(m,"D");  
}

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

int cg6900 (int argc, char* argv[])
{         
  switch (*argv[2])
  {
    case 'S':
    {
      TInv_cont main_app(*argv[2]);       
      main_app.run(argc, argv,main_app._titolo);
    }
    break;
    case 'P':
    {
      TInv_cont main_app(*argv[2]);       
      main_app.run(argc, argv,main_app._titolo);
    }
    break;
    case 'L':
    {   
      TLista_archivi a;       
      a.run(argc, argv,"Lista controllo archivi");
    }         
    break;
    case 'R':
    {   
      TRip_flag a;       
      a.run(argc, argv,"Ripristino flag movimenti");
    }         
    break;
    default:
    break;
  }

  return TRUE;
}
