// 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 <rcausali.h> 
#include <causali.h>
#include <occas.h>

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

#include "cg6600.h"

class TRic_tab : public TApplication
{
  
  TTable*           _tab_tra;                    
  TLocalisamfile*   _caus,*_rcaus,*_clifo,*_pcon,*_mov,*_rmov,*_rmoviva,*_saldi,*_occas;
  TIsamtempfile*    _tcaus,*_trcaus,*_tclifo,*_tpcon,*_tmov,*_trmov,*_triva,*_toccas;                 
  TTable*           _reg;
  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,_nprot_att,_nprot_pas;             
  long    _protiva,_uprotiva,_nprotiva,_nuprotiva,_numreg,_numreg_p,_numreg_piva,_nuovareg;
  char    _sez;
  real    _importo,_totdoc;
  TString _tmpcaus,_tmprcaus,_tmpclifo,_tmpcon,_tmpmov,_tmprmov,_tmpriva,_tmpoccas;
  
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    apri_file_temp();
  void    chiudi_file_temp();

  void    setta_parametri_record(const TString& sigla,const TString& flag);
  
  void    trasferimento();
  
  void    ricevi_causali(TString& key, char sigla);    
  void    cancella_righe_causali(TString& codcaus);  
  void    scrivi_righe_causali(TString& codcaus, char sigla);
  void    ricevi_clifo(TString& key, char sigla);
  void    ricevi_pcon(TString& key, char sigla);  
  void    conto(TRectype& pcon,char flag,bool esiste);
  void    sottoconto(TRectype& pcon,char flag,bool esiste);
  void    scrivi_pcon(TRectype& pcon,bool esiste);
  
  void    ricevi_movPN(TString& key, char sigla);
  void    scrivi_righePN(long numreg);
  void    ricevi_movIVA(TString& key, char sigla);
  void    scrivi_righeIVA(long numreg);
  long    esiste_numreg(long nreg);                     
  void    num_protocollo();
  long    controlli_primanota();
  long    ulnumprot_reg(int anno,TString& codreg);             
  long    ultima_registrazione();
  void    aggiorna_reg(int anno,TString& codreg,long ulnum);
  char    ricerca_causale(TString& field);
  
  bool    occasionali(const TString& ocfpi);
  
  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");
  
  _reg      = new TTable ("REG");

  if (_scelta == 'T')
  {
    _caus     = new TLocalisamfile (LF_CAUSALI);
    _rcaus    = new TLocalisamfile (LF_RCAUSALI);
    _clifo    = new TLocalisamfile (LF_CLIFO);
    _pcon     = new TLocalisamfile (LF_PCON);
  }
  else
  {
    _mov      = new TLocalisamfile (LF_MOV);
    _rmov     = new TLocalisamfile (LF_RMOV);
    _rmoviva  = new TLocalisamfile (LF_RMOVIVA);       
    _saldi    = new TLocalisamfile (LF_SALDI);       
    _occas    = new TLocalisamfile (LF_OCCAS);
  }
  
  _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 _reg;
  
  if (_scelta == 'T')
  {
    delete _caus;
    delete _rcaus;
    delete _clifo;
    delete _pcon;
  }               
  else
  {
    delete _mov;
    delete _rmov;
    delete _rmoviva;
    delete _saldi;                           
    delete _occas;  
  }
  
  return TApplication::destroy();
}                                

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

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

      apri_file_temp();
      
      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
      {
        chiudi_file_temp();
        message_box("Trasferimento interamente completato: proseguire per cancellare il file");
        setta_parametri_record(" ","*");
        _tras_file.remove_all();
        setta_parametri_record(" "," ");
      }
    }
  }
  else
    if (_scelta == 'M')
    {
      if (video())
      { 
        apri_file_temp();
        
        trasferimento();   
        chiudi_file_temp();
        message_box("Trasferimento interamente completato: proseguire per cancellare il file");
        setta_parametri_record(" ","*");
        _tras_file.remove_all();
        setta_parametri_record(" "," ");  
      }
    }
  
  return FALSE;
}

void TRic_tab::trasferimento()
{
  char    uselab;
  TString key = "";
  int     posiz,i;
  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++)
  {                 
    long nrec = ((_tras_file.nrec(i))+1);    
    sigla = _tras_file.name(i)[0];
    long cicli; 
    
    switch (sigla)
    {
      case 'W': 
        message = "Ricezione tabella causali in corso... Prego attendere.";
        cicli   = _tcaus->items();
        break;
      case 'A': 
        message = "Ricezione anagrafica Clienti / Fornitori in corso... Prego attendere.";
        cicli   = _tclifo->items();
        break;
      case 'P': 
        message = "Ricezione anagrafica Piano dei Conti in corso... Prego attendere.";
        cicli   = _tpcon->items();
        break;
      case 'Z': 
        message = "Ricezione Movimenti di primanota in corso... Prego attendere."; 
        cicli   = _tmov->items();
        break;
      case 'U': 
        message = "Ricezione Movimenti iva in corso... Prego attendere."; 
        cicli   = _tmov->items();
        break;                      
      default: break;
    }
    _prog = new TProgind(cicli,message,FALSE);
    
    if (_scelta == 'T')
    { 
      if (sigla == 'W')
        ricevi_causali(key,sigla);
      if (sigla == 'A')
        ricevi_clifo(key,sigla);
      if (sigla == 'P')
        ricevi_pcon(key,sigla);
    } 
    else
      if (_scelta == 'M')
      { 
        if (sigla == 'Z')
        {
          ricevi_movPN(key,sigla);
          _sld.registra();
        }
        else
          if (sigla == 'U')
            ricevi_movIVA(key,sigla);
      }
    delete _prog;  
    key = ""; //Altrimenti in caso di ripartenza mi ripristina sempre la situazione
  }
}

void TRic_tab::ricevi_causali(TString& key, char uselab)
{
  TString str;
                                       
  char flag = _tras_file.flg_agg(uselab);                                     
  
  _tcaus->setkey(1);
                    
  if (key.empty())
    _tcaus->first();
  else
  {             
    TString causale (key.mid(0,3));
    _tcaus->zero();
    _tcaus->put(CAU_CODCAUS, causale);
    _tcaus->read();
  }
  
  for(; !_tcaus->eof(); _tcaus->next())
  { 
    _prog->addstatus(1);
                               
    TString codcaus = _tcaus->get(CAU_CODCAUS);
    
    _caus->curr() = _tcaus->curr(); 
    
    if (_caus->read() == NOERR)  // Esiste la testata
    {
      if (flag == 'N') 
      {
        leggi_record_controllo();
        TString chiave;
        chiave.format("%3s",(const char*) codcaus);      
        TString sigla (format("%c", uselab));
        str = _record.overwrite(sigla,240);
        str = _record.overwrite(chiave,241);
        _tras_file.write_control_rec(str,256);
        continue;
      }
      else
        if (flag == 'D')
        {
          TString descr = _tcaus->get(CAU_DESCR);
          
          _caus->put(CAU_DESCR, descr);
          _caus->rewrite();
        }                  
        else
          if (flag == 'T')
          {
            scrivi_righe_causali(codcaus,uselab);
            
            _caus->zero();
            _caus->curr() = _tcaus->curr();
            _caus->rewrite();
          }
    }  
    else
    {
      scrivi_righe_causali(codcaus,uselab);
            
      _caus->zero();
      _caus->curr() = _tcaus->curr();
      _caus->write();
    }
          
    leggi_record_controllo();
    TString chiave;
    chiave.format("%3s",(const char*) codcaus);      
    TString sigla (format("%c", uselab));
    str = _record.overwrite(sigla,240);
    str = _record.overwrite(chiave,241);
    _tras_file.write_control_rec(str,256);          
  }
}

void TRic_tab::cancella_righe_causali(TString& 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;
    
    _rcaus->remove();
  }
}

void TRic_tab::scrivi_righe_causali(TString& codcaus, char uselab)
{
  TString str;
  
  cancella_righe_causali(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;
      
    _rcaus->curr() = _trcaus->curr();
    _rcaus->write();
      
    leggi_record_controllo();
    TString chiave;
    chiave.format("%3s",(const char*) codcaus);
    TString sigla (format("%c", uselab));
    str = _record.overwrite(sigla,240);
    str = _record.overwrite(chiave,241);
    _tras_file.write_control_rec(str,256);      
  }
}

void TRic_tab::ricevi_clifo(TString& key, char uselab)
{
  TString str;
                                       
  char flag = _tras_file.flg_agg(uselab);                                     
  
  _tclifo->setkey(1);
                    
  if (key.empty())
    _tclifo->first();
  else
  {         
    char tipo   = (key.mid(0,1))[0];     
    long codice = atol(key.mid(1,6));
    _tclifo->zero();
    _tclifo->put(CLI_TIPOCF, tipo);
    _tclifo->put(CLI_CODCF,  codice);
    _tclifo->read();
  }
  
  for(; !_tclifo->eof(); _tclifo->next())
  { 
    _prog->addstatus(1);
    
    char tipocf = _tclifo->get_char(CLI_TIPOCF);                            
    long codcf  = _tclifo->get_long(CLI_CODCF);
    
    _clifo->curr() = _tclifo->curr(); 
    
    if (_clifo->read() == NOERR)  // Esiste gia' il cliente
    {
      if (flag == 'N') 
      {
        leggi_record_controllo();
        TString chiave;
        chiave.format("%c%06ld", tipocf,codcf);      
        TString sigla (format("%c", uselab));
        str = _record.overwrite(sigla,240);
        str = _record.overwrite(chiave,241);
        _tras_file.write_control_rec(str,256);
        continue;
      }
      else
        if (flag == 'D')
        {
          TString ragsoc = _tclifo->get(CLI_RAGSOC);
          TString ind    = _tclifo->get(CLI_INDCF);
          TString civ    = _tclifo->get(CLI_CIVCF);
          TString com    = _tclifo->get(CLI_COMCF);
          TString cap    = _tclifo->get(CLI_CAPCF);
          TString cofi   = _tclifo->get(CLI_COFI);
          TString paiv   = _tclifo->get(CLI_PAIV);
          TString ptel   = _tclifo->get(CLI_PTEL);
          TString tel    = _tclifo->get(CLI_TEL);
          
          _clifo->put(CLI_RAGSOC, ragsoc);
          _clifo->put(CLI_INDCF,  ind);
          _clifo->put(CLI_CIVCF,  civ);
          _clifo->put(CLI_COMCF,  com);
          _clifo->put(CLI_CAPCF,  cap);
          _clifo->put(CLI_COFI,   cofi);
          _clifo->put(CLI_PAIV,   paiv);
          _clifo->put(CLI_PTEL,   ptel);
          _clifo->put(CLI_TEL,   tel);
          
          _clifo->rewrite();
        }                  
        else
          if (flag == 'T')
          {
            _clifo->zero();
            _clifo->curr() = _tclifo->curr();
            _clifo->rewrite();
          }
    }  
    else
    {
      _clifo->zero();
      _clifo->curr() = _tclifo->curr();
      _clifo->write();
    }
          
    leggi_record_controllo();
    TString chiave;
    chiave.format("%c%06ld", tipocf, codcf);      
    TString sigla (format("%c", uselab));
    str = _record.overwrite(sigla,240);
    str = _record.overwrite(chiave,241);
    _tras_file.write_control_rec(str,256);          
  }
}

void TRic_tab::ricevi_pcon(TString& key, char uselab)
{
  TString str;            
  bool esiste;
  TRectype pcon (LF_PCON);
                                       
  char flag = _tras_file.flg_agg(uselab);                
  char f_IV = _tras_file.flg_agg_IV(uselab);
  
  _tpcon->setkey(1);
                    
  if (key.empty())
    _tpcon->first();
  else
  {             
    int  gruppo = atoi(key.mid(0,3));
    int  conto  = atoi(key.mid(3,3));
    long sottoc = atol(key.mid(6,6));
    
    _tpcon->zero();
    _tpcon->put(PCN_GRUPPO, gruppo);
    if (conto != 0)
      _tpcon->put(PCN_CONTO, conto);
    if (sottoc != 0)
      _tpcon->put(PCN_SOTTOCONTO, sottoc);
    _tpcon->read();
  }
  
  for(; !_tpcon->eof(); _tpcon->next())
  { 
    _prog->addstatus(1);
                               
    int  g = _tpcon->get_int (PCN_GRUPPO);
    int  c = _tpcon->get_int (PCN_CONTO);
    long s = _tpcon->get_long(PCN_SOTTOCONTO);
    
    _pcon->curr() = _tpcon->curr(); 
    
    if (_pcon->read() == NOERR)      // Esiste gia' sul Piano dei Conti
    {         
      esiste = TRUE;
      
      if (flag == 'N') 
      { 
        leggi_record_controllo();
        TString chiave;
        chiave.format("%3d%3d%6ld", g, c, s);      
        TString sigla (format("%c", uselab));
        str = _record.overwrite(sigla,240);
        str = _record.overwrite(chiave,241);
        _tras_file.write_control_rec(str,256);
        continue;
      }
      else
        if (flag == 'D')
        {
          TString descr = _tpcon->get(PCN_DESCR);
  
          _pcon->put(PCN_DESCR, descr);
          _pcon->rewrite();
        }
        else                  
          if (flag == 'T')
            scrivi_pcon(pcon,esiste);
    }  
    else                             // Non esiste sull'archivio effettivo
    { 
      esiste = FALSE;      
      scrivi_pcon(pcon,esiste);
    }          
    
    TRecnotype rec;
    if (esiste)
      rec = _pcon->recno();
    
    if (f_IV == 'T')
    {
      if (g != 0 && c == 0)
        conto(pcon,flag,esiste);
      if (g != 0 && c != 0 && s != 0)
        sottoconto(pcon,flag,esiste);
    }
    
    if (esiste)
      _pcon->readat(rec);
    
    if ( (flag == 'T' && esiste) || !esiste)  
      _pcon->curr() = pcon;  
    
    if (esiste)
      _pcon->rewrite();
    else
      _pcon->write();
    
    leggi_record_controllo();
    TString chiave;
    chiave.format("%3d%3d%6ld", g, c, s);      
    TString sigla (format("%c", uselab));
    str = _record.overwrite(sigla,240);
    str = _record.overwrite(chiave,241);
    _tras_file.write_control_rec(str,256);          
  }
}

void TRic_tab::scrivi_pcon(TRectype& pcon,bool esiste)
{
  int     g         = _tpcon->get_int (PCN_GRUPPO);
  int     c         = _tpcon->get_int (PCN_CONTO);
  long    s         = _tpcon->get_long(PCN_SOTTOCONTO);
  TString descr     = _tpcon->get     (PCN_DESCR);
  int     indbil    = _tpcon->get_int (PCN_INDBIL);
  char    tmcf      = _tpcon->get_char(PCN_TMCF);
  bool    stsottbil = _tpcon->get_bool(PCN_STSOTTBIL);
  bool    compens   = _tpcon->get_bool(PCN_COMPENS);
  int     tipospric = _tpcon->get_int (PCN_TIPOSPRIC);
  TString codcbl    = _tpcon->get     (PCN_CODCBL);
  bool    stsottab  = _tpcon->get_bool(PCN_STSOTTAB);
  char    sezsaldi  = _tpcon->get_char(PCN_SEZSALDI);
  bool    sospeso   = _tpcon->get_bool(PCN_SOSPESO);
  int     ricser    = _tpcon->get_int (PCN_RICSER); 
  
  pcon.zero();
  pcon.put(PCN_GRUPPO, g);
  if (c != 0)
    pcon.put(PCN_CONTO, c);
  if (s != 0)
    pcon.put(PCN_SOTTOCONTO, s);
  pcon.put(PCN_DESCR,     descr);
  pcon.put(PCN_INDBIL,    indbil);
  pcon.put(PCN_TMCF,      tmcf);
  pcon.put(PCN_STSOTTBIL, stsottbil);
  pcon.put(PCN_COMPENS,   compens);
  pcon.put(PCN_TIPOSPRIC, tipospric);
  pcon.put(PCN_CODCBL,    codcbl);
  pcon.put(PCN_STSOTTAB,  stsottab);
  pcon.put(PCN_SEZSALDI,  sezsaldi);
  pcon.put(PCN_SOSPESO,   sospeso);
  pcon.put(PCN_RICSER,    ricser);
}

void TRic_tab::conto(TRectype& pcon,char flag,bool esiste)
{
  int g = _tpcon->get_int(PCN_GRUPPO);
  int c = _tpcon->get_int(PCN_CONTO);
   
  TString sez  = _tpcon->get    (PCN_SEZIVD);
  TString let  = _tpcon->get    (PCN_LETTIVD);
  TString numr = _tpcon->get    (PCN_NUMRIVD);
  int     num  = _tpcon->get_int(PCN_NUMIVD);
  
  if (sez.not_empty())
  {  
    if (!esiste || (esiste && flag == 'T') )
    {
      pcon.put (PCN_SEZIVD,  sez);
      pcon.put (PCN_LETTIVD, let);
      pcon.put (PCN_NUMRIVD, numr);
      pcon.put (PCN_NUMIVD,  num);
      pcon.zero(PCN_SEZIVDOPP);
      pcon.zero(PCN_LETTIVDOPP);
      pcon.zero(PCN_NUMRIVDOPP);
      pcon.zero(PCN_NUMIVDOPP);
      
      _tras_file.annulla_classi(g,c,TRUE);
    }
  }
  else
  {
    if (esiste && flag == 'T')
    {
      pcon.put (PCN_SEZIVD,  sez);
      pcon.put (PCN_LETTIVD, let);
      pcon.put (PCN_NUMRIVD, numr);
      pcon.put (PCN_NUMIVD,  num);
      pcon.zero(PCN_SEZIVDOPP);
      pcon.zero(PCN_LETTIVDOPP);
      pcon.zero(PCN_NUMRIVDOPP);
      pcon.zero(PCN_NUMIVDOPP);
      
      _tras_file.annulla_classi(g,c,TRUE);  
    }
  }
}

void TRic_tab::sottoconto(TRectype& pcon,char flag,bool esiste)
{
  int g = _tpcon->get_int(PCN_GRUPPO);
  int c = _tpcon->get_int(PCN_CONTO);

  TString sez    = _tpcon->get    (PCN_SEZIVD);
  TString let    = _tpcon->get    (PCN_LETTIVD);
  TString numr   = _tpcon->get    (PCN_NUMRIVD);
  int     num    = _tpcon->get_int(PCN_NUMIVD);
  TString sezop  = _tpcon->get    (PCN_SEZIVDOPP);
  TString letop  = _tpcon->get    (PCN_LETTIVDOPP);
  TString numrop = _tpcon->get    (PCN_NUMRIVDOPP);
  int     numop  = _tpcon->get_int(PCN_NUMIVDOPP);
  
  if (sez.not_empty())
  {  
    if (!esiste || (esiste && flag == 'T') )
    {
      pcon.put(PCN_SEZIVD,     sez);
      pcon.put(PCN_LETTIVD,    let);
      pcon.put(PCN_NUMRIVD,    numr);
      pcon.put(PCN_NUMIVD,     num);
      pcon.put(PCN_SEZIVDOPP,  sezop);
      pcon.put(PCN_LETTIVDOPP, letop);
      pcon.put(PCN_NUMRIVDOPP, numrop);
      pcon.put(PCN_NUMIVDOPP,  numop);

      _tras_file.annulla_classi(g,c,FALSE);
    }
  }
  else
  {
    if (sezop.not_empty())
    {
      if (!esiste || (esiste && flag == 'T') )
      {
        pcon.put(PCN_SEZIVDOPP,  sezop);
        pcon.put(PCN_LETTIVDOPP, letop);
        pcon.put(PCN_NUMRIVDOPP, numrop);
        pcon.put(PCN_NUMIVDOPP,  numop);      
      }
    }
    else
    {
      pcon.zero(PCN_SEZIVDOPP);
      pcon.zero(PCN_LETTIVDOPP);
      pcon.zero(PCN_NUMRIVDOPP);
      pcon.zero(PCN_NUMIVDOPP);
    }  
  }
}

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;
}

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

void TRic_tab::num_protocollo()
{
  _protiva  = _tmov->get_long(MOV_PROTIVA);
  _uprotiva = _tmov->get_long(MOV_UPROTIVA);
  
  if (_protiva == 0)
    _uprotiva = 0;
  
  _nprotiva  = _protiva;
  _nuprotiva = _uprotiva;
}                        

long TRic_tab::ulnumprot_reg(int anno,TString& cr)
{
  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 )
      reg.put("I5", _nprotiva);
    
    if (_nuprotiva > ulnum )
      reg.put("I5", _nuprotiva);
    
    reg.rewrite();
  }  
}

long TRic_tab::controlli_primanota()
{ 
  TTable tpd ("%TPD");
  bool      corrisp;
  TDate     datareg;  
  int       anno;
  long      ulnum = 0;
  TString16 tmp;
  TString   tipodoc,codreg;
  
  char tipocf = _tmov->get_char(MOV_TIPO);  
  int  tiporeg;                           
  if (tipocf == 'C')
    tiporeg = 1;
  else          
    if (tipocf == 'F')
      tiporeg = 2;

  codreg  = _tmov->get(MOV_REG);  
  tipodoc = _tmov->get(MOV_TIPODOC);                   

  datareg = _tmov->get_date(MOV_DATAREG);
  anno    = datareg.year();
  
  tpd.zero();
  tpd.put("CODTAB", (const char*) tipodoc);
  if (tpd.read() == NOERR)
    corrisp = tpd.get_bool("B0");
  
  if (codreg.not_empty() && !corrisp)
  {
    if ( ( (tiporeg == 1 && (_nprot_att || _protiva == 0) ) )
        || ( (tiporeg == 2 && (_nprot_pas || _protiva == 0) ) ) )
    {              
      ulnum = ulnumprot_reg(anno,codreg);
      _nprotiva = ulnum + 1;
      if (_uprotiva != 0)
        _nuprotiva = (_nprotiva - ulnum) + _uprotiva;
    }                                     
  }            
  
  return ulnum;
}

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::scrivi_righePN(long numreg)
{
  TString str;                         
                                   
  _trmov->setkey(1);
  _trmov->zero();
  _trmov->put(RMV_NUMREG, numreg);
  TRectype rmov (LF_RMOV);                               
  rmov = _trmov->curr();
  for (_trmov->read(); !_trmov->eof(); _trmov->next())
  {
    if (_trmov->curr() > rmov) break;
                                   
    int  g   = _trmov->get_int (RMV_GRUPPO);
    int  c   = _trmov->get_int (RMV_CONTO);
    long s   = _trmov->get_long(RMV_SOTTOCONTO);                                
    char sez = _trmov->get_char(RMV_SEZIONE);
    real imp ( _trmov->get_real(RMV_IMPORTO) );
    
    _trmov->put(RMV_NUMREG, _nreg);  
    _rmov->curr() = _trmov->curr();
    _rmov->write();        
    
    _sld.aggiorna(g,c,s,imp,sez);    
  }
}

void TRic_tab::ricevi_movPN(TString& key, char uselab)
{
  TString str;
  long    numulreg;
  TRectype recmov (LF_MOV);
                                       
  char flag  = _tras_file.flg_agg(uselab);                                     
  
  _nprot_att = _tras_file.numprot_att();
  _nprot_pas = _tras_file.numprot_pas();
  
  _tmov->setkey(1);
                    
  if (key.empty())
    _tmov->first();
  else
  {             
    long numreg = atol(key.mid(0,7));
    _tmov->zero();
    _tmov->put(MOV_NUMREG, numreg);
    _tmov->read();
  }
  
  for(; !_tmov->eof(); _tmov->next())
  { 
    _prog->addstatus(1);
                               
    long nreg      = _tmov->get_long(MOV_NUMREG);
    long nuova_reg = _tmov->get_long("TNUMREG" );
    
    if (nuova_reg == 0)
    {
      numulreg = ultima_registrazione(); // reperisco il numero ultima registrazione
      _nreg = esiste_numreg(numulreg);
    }                                 
    else
      _nreg = nuova_reg;

    TRecnotype rec = _tmov->recno();     // Salvo il nuovo numero di 
    _tmov->put("TNUMREG", _nreg);      // registrazione sul file di lavoro
    _tmov->rewrite();               
    _tmov->readat(rec);
                          
    int annoes = _tmov->get_int(MOV_ANNOES);
                          
    recmov = _tmov->curr();
    
    _mov->setkey(1);
    _mov->zero();
    _mov->put(MOV_NUMREG, _nreg);
    
    if (_mov->read() != NOERR)  // Se non esiste la testata
    {                  
      num_protocollo();          // Riattribuzione numero di protocollo
      long ulnum = controlli_primanota();
                           
      recmov.put(MOV_NUMREG,   _nreg);                     
      recmov.put(MOV_PROTIVA,  _nprotiva);
      recmov.put(MOV_UPROTIVA, _nuprotiva);
      
      _mov->zero();
      _mov->curr() = recmov;
      _mov->write();
             
      TString codreg  (_tmov->get     (MOV_REG));
      TString codcaus (_tmov->get     (MOV_CODCAUS));      
      TDate   datareg (_tmov->get_date(MOV_DATAREG));
      int     anno    = datareg.year();

      aggiorna_reg(anno,codreg,ulnum); // Aggiorna il registro

      _sld.set_anno_es(annoes);
      _sld.set_movprovv(FALSE);
      _sld.set_num_ulmov(_nreg);
      _sld.set_data_ulmov(datareg);
      char movap = ricerca_causale(codcaus);
      if (movap == 'A')
        _sld.set_movap(TRUE); 

      scrivi_righePN(nreg);

      _sld.registra();
      _sld.reset();
    }  
          
    leggi_record_controllo();
    TString chiave;
    chiave.format("%07ld", nreg);      
    TString sigla (format("%c", uselab));
    str = _record.overwrite(sigla,240);
    str = _record.overwrite(chiave,241);
    _tras_file.write_control_rec(str,256);          
  }
}

bool TRic_tab::occasionali(const TString& ocfpi)
{  
  TString chiave;
  long    prog = 1;
  bool    esiste = FALSE;
  
  TString nocfpi = _tmov->get("TOCFP"); 
  nocfpi.trim();
  
  if (nocfpi.empty())
  {
    _occas->setkey(1);
    _occas->zero();
    _occas->put("CFPI", "RIC9999999999999");
    _occas->read();
    _occas->prev();
    TString cfpi = _occas->get(OCC_CFPI);
    if (cfpi.mid(0,3) == "RIC")
    {          
      prog   = atol(cfpi.mid(3,13));
      prog++;
      chiave = format("%3s%13ld", (const char*) "RIC", prog);
    }                                                        
    else                                                     
      chiave = format("%3s%13ld", (const char*) "RIC", prog);
      
    esiste = FALSE;  
  }
  else
  {
    _occas->setkey(1);
    _occas->zero();
    _occas->put("CFPI", nocfpi);
    _occas->read();
      
    esiste = TRUE;
  }
  
  _toccas->setkey(1);
  _toccas->zero();
  _toccas->put(OCC_CFPI, ocfpi);
  _toccas->read();

  _occas->curr() = _toccas->curr();
  
  if (esiste)
    _occas->rewrite();
  else
    _occas->write();

  return TRUE;  
}

void TRic_tab::scrivi_righeIVA(long numreg)
{
  TString str;                         
                                   
  _triva->setkey(1);
  _triva->zero();
  _triva->put(RMI_NUMREG, numreg);
  TRectype riva (LF_RMOVIVA);                               
  riva = _triva->curr();
  for (_triva->read(); !_triva->eof(); _triva->next())
  {
    if (_triva->curr() > riva) break;
                                   
    _triva->put(RMI_NUMREG, _nuovareg);  
    _rmoviva->curr() = _triva->curr();
    _rmoviva->write();        
  }
}

void TRic_tab::ricevi_movIVA(TString& key, char uselab)
{
  TString str;
  TRectype recmov (LF_MOV);
                                       
  char flag  = _tras_file.flg_agg(uselab);                                     
  
  _tmov->setkey(1);
                    
  if (key.empty())
    _tmov->first();
  else
  {             
    long numreg = atol(key.mid(0,7));
    _tmov->zero();
    _tmov->put(MOV_NUMREG, numreg);
    _tmov->read();
  }
  
  for(; !_tmov->eof(); _tmov->next())
  { 
    _prog->addstatus(1);
                               
    long nreg      = _tmov->get_long(MOV_NUMREG);
    
    TString codreg = _tmov->get(MOV_REG);
    TString codcau = _tmov->get(MOV_CODCAUS);
    
    if (codreg.empty() || codcau.empty()) continue;
                                                   
    _nuovareg = _tmov->get_long("TNUMREG");
    TString ocfpi = _tmov->get(MOV_OCFPI);
    
    if (ocfpi.not_empty())
      occasionali(ocfpi);
                                                     
    TDate   data74ter ( _tmov->get_date(MOV_DATA74TER) );
    TString codval    ( _tmov->get     (MOV_CODVALI) );
    long    codcf     = _tmov->get_long(MOV_CODCF);
    real    totdoc    ( _tmov->get_real(MOV_TOTDOC) );
    real    cambioi   ( _tmov->get_real(MOV_CAMBIOI) );
    real    corrlire  ( _tmov->get_real(MOV_CORRLIRE) );
    real    corrval   ( _tmov->get_real(MOV_CORRVALUTA) );
    int     annoiva   = _tmov->get_int (MOV_ANNOIVA);
      
    _mov->setkey(1);
    _mov->zero();
    _mov->put(MOV_NUMREG, _nuovareg);
    
    if (_mov->read() == NOERR)   // Se non esiste la testata
    {                            
      _mov->put(MOV_DATA74TER,  data74ter);
      _mov->put(MOV_CODVALI,    codval);
      _mov->put(MOV_CODCF,      codcf);
      _mov->put(MOV_TOTDOC,     totdoc);
      _mov->put(MOV_CAMBIOI,    cambioi);
      _mov->put(MOV_CORRLIRE,   corrlire);
      _mov->put(MOV_CORRVALUTA, corrval);
      _mov->put(MOV_ANNOIVA,    annoiva);
      _mov->rewrite();             

      scrivi_righeIVA(nreg);
    }  
          
    leggi_record_controllo();
    TString chiave;
    chiave.format("%07ld", nreg);      
    TString sigla (format("%c", uselab));
    str = _record.overwrite(sigla,240);
    str = _record.overwrite(chiave,241);
    _tras_file.write_control_rec(str,256);          
  }
}

bool TRic_tab::leggi_trasfer()
{ 
  _nultras = 0;
  
  _trasf = _tras_file.path(_dittaric);
  _trasf << HEADER;
  
  _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();             
      _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 ("cg6600a");
  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 == "*") 
    {
      warning_box("Trasferimento interamente completato: proseguire per cancellare il file");    
      _tras_file.remove_all();
      setta_parametri_record(" "," ");
      return FALSE;
    }
    
    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");    
        _tras_file.remove_all();
        setta_parametri_record(" "," ");
        return FALSE;
      }
    }
  
  return TRUE;
}

void TRic_tab::apri_file_temp()
{ 
  if (_scelta == 'T')
  {
    TString80 tmpcaus = "%";
    tmpcaus << get_firm_dir();
    tmpcaus << "\\" << TEMP_CAUS;
    _tmpcaus = tmpcaus.mid(1);
    _tmpcaus << ".dbf";
    if(fexist(_tmpcaus))
      _tcaus    = new TIsamtempfile(LF_CAUSALI, tmpcaus, 0);  
    TString80 tmprcaus = "%";
    tmprcaus << get_firm_dir();
    tmprcaus << "\\" << TEMP_RCAUS;
    _tmprcaus = tmprcaus.mid(1);
    _tmprcaus << ".dbf";
    if (fexist(_tmprcaus))
      _trcaus   = new TIsamtempfile(LF_RCAUSALI, tmprcaus, 0);
    TString80 tmpclifo = "%";
    tmpclifo << get_firm_dir();
    tmpclifo << "\\" << TEMP_CLIFO;
    _tmpclifo = tmpclifo.mid(1);
    _tmpclifo << ".dbf";
    if (fexist(_tmpclifo))
      _tclifo    = new TIsamtempfile(LF_CLIFO, tmpclifo, 0);
    TString80 tmppcon = "%";
    tmppcon << get_firm_dir();
    tmppcon << "\\" << TEMP_PCON;
    _tmpcon = tmppcon.mid(1);
    _tmpcon << ".dbf";
    if (fexist(_tmpcon))
      _tpcon    = new TIsamtempfile(LF_PCON, tmppcon, 0);
  }
  else
  {
    TString80 tmpmov = "%";
    tmpmov << get_firm_dir();
    tmpmov << "\\" << TEMP_MOV;
    _tmpmov = tmpmov.mid(1);
    _tmpmov << ".dbf";
    if (fexist(_tmpmov))
      _tmov     = new TIsamtempfile(LF_MOV, tmpmov, 0);
    TString80 tmprmov = "%";
    tmprmov << get_firm_dir();
    tmprmov << "\\" << TEMP_RMOV;
    _tmprmov = tmprmov.mid(1);
    _tmprmov << ".dbf";
    if (fexist(_tmprmov))
      _trmov    = new TIsamtempfile(LF_RMOV, tmprmov, 0);
    TString80 tmpriva = "%";
    tmpriva << get_firm_dir();
    tmpriva << "\\" << TEMP_RMOVIVA;
    _tmpriva = tmpriva.mid(1);
    _tmpriva << ".dbf";
    if (fexist(_tmpriva))
      _triva    = new TIsamtempfile(LF_RMOVIVA, tmpriva, 0);
    TString80 tmpoccas = "%";
    tmpoccas << get_firm_dir();
    tmpoccas << "\\" << TEMP_OCC;
    _tmpoccas = tmpoccas.mid(1);
    _tmpoccas << ".dbf";
    if (fexist(_tmpoccas))
      _toccas   = new TIsamtempfile(LF_OCCAS, tmpoccas, 0);
  }
}

void TRic_tab::chiudi_file_temp()
{
  if (_scelta == 'T')
  {   
    if (fexist(_tmpcaus))
      delete _tcaus;
    if (fexist(_tmprcaus))
      delete _trcaus;
    if (fexist(_tmpclifo))
      delete _tclifo;
    if (fexist(_tmpcon))
      delete _tpcon;
  }               
  else
  {   
    if (fexist(_tmpmov))
      delete _tmov;
    if (fexist(_tmprmov))
      delete _trmov;
    if (fexist(_tmpriva))
      delete _triva;
    if (fexist(_tmpoccas))
      delete _toccas;
  }
}

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

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