campo-sirio/cg/cg6400.cpp

// Ricezione dati da sistema e da PC

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

#include <nditte.h>

#include "cg6400.h"
#include "cglib04.h"
#include "cgsaldac.h"

class TRic_archivi : public TSkeleton_application
{
  TTransfer_file*   _tras_file;  
  TLocalisamfile*   _caus;
  TLocalisamfile*   _rcaus;  
  TLocalisamfile*   _clifo;
  TLocalisamfile*   _pcon;      
  TLocalisamfile*   _mov;
  TLocalisamfile*   _rmov;
  TLocalisamfile*   _rmoviva;  
  TLocalisamfile*   _occas;     
  TLocalisamfile*   _part;
  TLocalisamfile*   _scad;
  TLocalisamfile*   _pagsca;  
  
  TString80 TEMP;                
  
  char    _scelta, _ric_auto;     
  
  int     _numtotdisk,_progdisk,_numdisk,_numinv,_numinvp,_nultras;
  int     _stato_ripartenza,_nultras_tab;
  bool    _sequenza,_disketto;
  bool    _prima_volta,_baipassa;
  TString _nomeid,_nomeidp,_ragsoc_dittar;
  TFilename _marker,_trasf,_trasfer,_pathname,_trasfhard;
  long    _dittainv,_dittainvp,_dittaric,_totrectras,_totrectrasp;      
  TDate   _datatras,_datatrasp,_dataultras_tab,_dataultras;
  TString _sigle_file,_nrec_file;
  char    _agg_cau,_agg_pcon,_agg_cls,_agg_clifo,_agg_fatatt,_agg_fatpas;
  bool    _agg_pcc_com, _agg_cfc_com;
  
public: 
  TString _titolo;
  
  virtual bool create();
  virtual bool destroy();
  virtual bool check_autorization() const 
  {return false;}
  virtual void main_loop();
  bool    leggi_marker();                 
  bool    leggi_marker_rep();
  void    leggi_trasfer(const char* nome);
  void    ripristina_trasfer();
  void    trasfer2tempfile();
  long    leggi_tabella_tras();
  bool    componi_path(const TMask&);
  bool    video_ripartenza();
  void    ditta_ricevente();
  bool    ripartenza();
  bool    set_flag();
  void    aggiorna_tabella();                               
  int     controllo_ripartenza();
  
  static bool baipassa(TMask& m,KEY k);             
  
  TRic_archivi(char ric_trasfer,char ric_auto = '\0');
};

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

TRic_archivi::TRic_archivi(char ric_trasfer,char ric_auto) : 
_scelta(toupper(ric_trasfer)), _ric_auto(toupper(ric_auto))
{   
  if (_scelta == 'S')
    _titolo = TR("Ricezione archivi da sistema");
  else
  {
    _scelta = 'P';
    _titolo = TR("Ricezione archivi da PC");
  }  
}

bool TRic_archivi::create()
{
  open_files(LF_TABCOM, 0);
  _tras_file  = new TTransfer_file(_scelta);

  _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);
  _part    = new TLocalisamfile (LF_PARTITE);
  _scad    = new TLocalisamfile (LF_SCADENZE);
  _pagsca  = new TLocalisamfile (LF_PAGSCA);  
  
  _numdisk     = 1;       
  _prima_volta = true;
  _nultras     = 0;
  _nultras_tab = 0;     
  _baipassa    = false;
  
  return TSkeleton_application::create();
}

bool TRic_archivi::destroy()
{
  delete _tras_file;                         

  delete _caus;
  delete _rcaus;
  delete _clifo;
  delete _pcon;
  delete _mov;
  delete _rmov;
  delete _rmoviva;
  delete _occas;  
  delete _part;
  delete _scad;
  delete _pagsca;  
  
  return TApplication::destroy();
}                                

bool TRic_archivi::componi_path(const TMask& msk)
{
  TFilename path  = msk.get(F_PATHNAME);

  const TString& drive = msk.get(F_DRIVE);
  _disketto = xvt_fsys_is_floppy_drive(drive) != 0;
  
  const int pos = path.find(':');
  if (pos)
    path = path.mid(pos+1);
  
  if (path.full())
  {  
    _marker << drive << SLASH << path << SLASH << "marker";
    _trasfer << drive << SLASH << path << SLASH << "trasfer";
    if (!_disketto)
      _pathname << drive << SLASH << path;
  }
  else
  {
    _marker << drive << SLASH << "marker";
    _trasfer << drive << SLASH << "trasfer";
    if (!_disketto)
      _pathname << drive << SLASH;
  }
  
  return _disketto;
}

bool TRic_archivi::leggi_marker()
{ 
  if (!_marker.exist())
  {
    if (_disketto)
      return error_box(FR("File marker non presente sul dischetto %d: impossibile proseguire"), _numdisk);
    else
      return error_box(FR("File marker non presente in %s: impossibile proseguire"), (const char*)_pathname);  
  }
  
  const int size = 64;
  TString80 buffer;
  
  FILE* i = fopen(_marker,"r+t");   // Perche' non semplicemente "rb"?
  if (i != NULL)
  {  
    const size_t letti = fread(buffer.get_buffer(),1,size,i);
    fclose(i);
    if (letti < size)
      return error_box(TR("Errore di lettura del MARKER: impossibile proseguire"));
    
    _progdisk   = atoi(buffer.sub(31,33));
    _numtotdisk = atoi(buffer.sub(29,31));
    
    if (_numtotdisk == 0) 
    {
      message_box(TR("Il numero totale dischi su marker non e' significativo: impossibile proseguire"));
      return false;
    }
      
    if (_progdisk != _numdisk)
    {
      message_box(FR("Il dischetto inserito (%d) non rispecchia la giusta sequenza (%d)"), _numdisk, _progdisk);
      _sequenza = false;
      return true;
    }                   
    else
      _sequenza = true;
    
    _nomeid     = buffer.sub(0,10);
    _dittainv   = atol(buffer.sub(10,14));
    _numinv     = atoi(buffer.sub(14,17));

    const TString8 tmp = buffer.sub(17,23);
    _datatras   = converti_data(tmp, false);
    
    _totrectras = atol(buffer.sub(23,29));
        
    if (_numdisk > 1)  //Va fatto solo dal disco 2 in poi
      if (_nomeid != _nomeidp || _dittainv != _dittainvp || _totrectras != _totrectrasp
          || _numinv != _numinvp || _datatras != _datatrasp)
        return error_box(FR("I dati del marker del disco %d, non corrispondono ai dati del marker del disco 1"), _numdisk);           
    
    _nomeidp      = _nomeid;
    _dittainvp    = _dittainv;
    _totrectrasp  = _totrectras;
    _numinvp      = _numinv;
    _datatrasp    = _datatras;
    
    if (_numdisk == 1) // Va fatto solo per il primo disco
    {
      _dittaric   = leggi_tabella_tras();
      
      if (_dittaric != 0)
      {
        if (!prefix().exist(_dittaric))
          return error_box(FR("Libreria archivi ditta %ld non presente su disco"), _dittaric);
      }   
      else
        return error_box(FR("Codici NON PRESENTI in tabella ricezione:\ncaricare %s %ld e riprovare"), 
                         (const char*)_nomeid, _dittainv);
    }
    
    return true;
  }    
  
  return false;
}

bool TRic_archivi::leggi_marker_rep()
{ 
  if (!_marker.exist())
  {
    if (_disketto)
      return error_box(FR("File marker non presente sul dischetto %d: impossibile proseguire"), _numdisk);
    else
      return error_box(FR("File marker non presente in %s: impossibile proseguire"), (const char*)_pathname);  
  }
  
  const word size = 64;
  TString buffer(size);
  
  FILE* inmark = fopen(_marker,"r");
  if (inmark != NULL)
  {  
    const word letti = fread(buffer.get_buffer(),1,size,inmark);
    fclose(inmark);
    
    _progdisk   = atoi(buffer.sub(34,36));
    _numtotdisk = atoi(buffer.sub(32,34));
    
    if (_progdisk != _numdisk)
    {
      message_box(FR("Il dischetto inserito (%d) non rispecchia la giusta sequenza (%d)"), _numdisk, _progdisk);
      _sequenza = false;
      return true;
    }                   
    else
      _sequenza = true;
    
    if (letti == 0)
      return error_box(TR("Impossibile leggere il file MARKER: %s"), (const char*)_marker);
    
    _nomeid     = buffer.sub(0,10);
    _dittainv   = atol(buffer.sub(10,15));
    _totrectras = atol(buffer.sub(26,32));
    _numinv     = atoi(buffer.sub(15,18));
    TString16 tmp = buffer.sub(18,26);
    _datatras   = converti_data(tmp,true);
    
    if (_numdisk > 1)  //Va fatto solo dal disco 2 in poi
      if (_nomeid != _nomeidp || _dittainv != _dittainvp || _totrectras != _totrectrasp
          || _numinv != _numinvp || _datatras != _datatrasp)
        return error_box(FR("I dati del marker del disco %d, non corrispondono ai dati del marker del disco 1"), _numdisk);           
    
    _nomeidp      = _nomeid;
    _dittainvp    = _dittainv;
    _totrectrasp  = _totrectras;
    _numinvp      = _numinv;
    _datatrasp    = _datatras;
    
    if (_numdisk == 1) // Va fatto solo per il primo disco
    {
      _dittaric   = leggi_tabella_tras();
      
      if (_dittaric != 0)
      {
        if (!prefix().exist(_dittaric))
          return error_box(FR("Gli archivi della ditta %ld non sono presenti su disco"), _dittaric);
      }   
      else
        return error_box(FR("Codici NON PRESENTI in tabella ricezione:\nStudio %s Ditta inviante %ld"), 
                         (const char*)_nomeid, _dittainv);
    }
    
    return true;
  }            
  
  return error_box(FR("Impossibile accedere al file %s"), (const char*)_marker);
}

void TRic_archivi::main_loop()
{ 
  if (_ric_auto == 'A')
  {
    _dittaric = get_firm();
    _trasf    = _tras_file->path(_dittaric);
    _trasf.add("trasfer");
    _tras_file->open(_trasf);

    if (_scelta == 'S')
    {
      trasfer2tempfile();
      _tras_file->close(); // Chiude il trasfer letto dalla directory della ditta
      ::remove(_trasf);
      TFilename tab = _tras_file->path(_dittaric);
      TFilename tabcdx = tab; 
      TFilename tabdbf = tab; 
      tabcdx.add("ttab.cdx");
      tabdbf.add("ttab.dbf");
      ::remove(tabcdx);
      ::remove(tabdbf);
    }                                
    else
      if (_scelta == 'P')
      {
        trasfer2tempfile();
        _tras_file->close(); // Chiude il trasfer letto dalla directory della ditta
        ::remove(_trasf);
      }
  }
  else
  {
    if (_scelta == 'S')
    {
      TMask maskera("cg6400b"); 
      KEY tasto = maskera.run();            
      if (tasto == K_ENTER)
      { 
        componi_path(maskera);  

        do
        {  
          if (_disketto)
          { 
            char drive = maskera.get(F_DRIVE)[0];
            if (yesno_box(FR("Inserire il dischetto %d nell' unita' %c"), _numdisk,drive))
            {      
              if (!leggi_marker())
                return;
          
              if (_sequenza)
              {  
                if (video_ripartenza())
                  ripristina_trasfer();
                else
                  return;
                _numdisk++;  
              }
            }
            else
              return;
          }
          else
          {
            if (!leggi_marker())
              return;
        
            if (_sequenza)
            {  
              if (video_ripartenza())
                ripristina_trasfer();
              else
                return;
              _numdisk++;  
            }
            else
              return;
          }
        }
        while (_numdisk <= _numtotdisk);  

        trasfer2tempfile();
        set_flag();
        aggiorna_tabella();
        _tras_file->close(); // Chiude il trasfer letto dalla directory della ditta
        ::remove(_trasf);
        TFilename tab = _tras_file->path(_dittaric);
        TFilename tabcdx = tab; tabcdx.add("ttab.cdx");
        TFilename tabdbf = tab; tabdbf.add("ttab.dbf");
        tabcdx.fremove();
        tabdbf.fremove();
      }
    }  
    else
      if (_scelta == 'P')
      {
        TMask maskera("cg6400b");
  
        KEY tasto = maskera.run();            
  
        if (tasto == K_ENTER)
        { 
          componi_path(maskera);  

          do
          {  
            if (_disketto)
            { 
              char drive = maskera.get(F_DRIVE)[0];
              if (yesno_box(FR("Inserire il dischetto %d nell' unita' %c"), _numdisk,drive))
              {      
                if (!leggi_marker_rep())
                  return;
          
                if (_sequenza)
                {  
                  if (video_ripartenza())
                    ripristina_trasfer();
                  else
                    return;
                  _numdisk++;  
                }
              }
              else
                return;
            }
            else
            {
              if (!leggi_marker_rep())
                return;
        
              if (_sequenza)
              {  
                if (video_ripartenza())
                  ripristina_trasfer();
                else
                  return;
                _numdisk++;  
              }
              else
                return;
            }
          }
          while (_numdisk <= _numtotdisk);  

          trasfer2tempfile();
          set_flag();
          aggiorna_tabella();
          _tras_file->close(); // Chiude il trasfer letto dalla directory della ditta
          ::remove(_trasf);
        }
      }
  }
}

void TRic_archivi::leggi_trasfer(const char* nome)
{ 
  _nultras = 0;
  
  _trasf = _tras_file->path(_dittaric);
  _trasf.add(nome);
  
  _tras_file->open(_trasf);
  
  if (_tras_file->exist())
  { 
    if (_scelta == 'S')
    {
      if (_tras_file->read_control_rec_t())
      {
        _nultras    = _tras_file->nultras();
        _dataultras = _tras_file->dataultras();
      }
    }
    else
      if (_scelta == 'P')
      {
        if (_tras_file->read_control_rec())
        {
          _nultras    = _tras_file->nultras();
          _dataultras = _tras_file->dataultras();
        }
      }      
  }  
}

// Questa funzione ritorna:
// - 0 se non vengono rilevate condizioni di ripartenza o di trasferimento
//   non completato.                                                      
// - 1 se viene rilevato uno stato di RIPARTENZA CON DATI CONTRADDITORI
// - 2 se viene rilevato un trasferimento precedente NON COMPLETATO

int TRic_archivi::controllo_ripartenza()
{
  set_firm(_dittaric);
  
  TFilename trasfer = _tras_file->path(_dittaric);
  trasfer << HEADER;
  _tras_file->open(trasfer);
         
  const TString4 std = ini_get_string(CONFIG_DITTA, "cg", "FlStTra");
  const bool flag = _tras_file->read_control_rec();
  
  int var = 0;
  if (std.empty() && flag)
    var = 1;
  
  if (std == "*" && flag)   
  {
    const TString16 ult_file = _tras_file->ult_file();
    const TString16 key      = _tras_file->key();
    if (ult_file.full() || key.full())
      var = 1;
  }
  
  if (std != "" && std != "*")
    var = 2;
  
  _tras_file->close();
  
  return var;
}

bool TRic_archivi::ripartenza()
{  
  if (_stato_ripartenza == 1)
    return error_box(TR("Rilevato stato di RIPARTENZA CON DATI CONTRADDITORI:\n"
                        "presente file HEADER nei dati ditta e FlgStTra=* o nullo"));

  if (_stato_ripartenza == 2)
    return error_box(TR("Trasferimento precedente NON COMPLETATO: completarlo prima di questo"));    

  return true;
}

bool TRic_archivi::video_ripartenza()
{                    
  TDate dataultras;
  
  if (_prima_volta)
  {      
    leggi_trasfer("\\trasfer");
    
    _prima_volta = false;
    
    TMask maskera("cg6400a");
    TMask* msk = &maskera;
    
    KEY  tasto;
    
    ditta_ricevente();       
    _stato_ripartenza = controllo_ripartenza();
    
    msk->set(F_NOMEID,        _nomeid);
    msk->set(F_CODDITTAINV,   _dittainv);
    msk->set(F_CODDITTARIC,   _dittaric);
    msk->set(F_RAGSOC,        _ragsoc_dittar);
    msk->set(F_NULTRASDSK,    _numinv);
    TString16 data1 = _datatras.string();
    msk->set(F_DATAULTRASDSK, data1);         

    if (_nultras != 0)
    {
      msk->set(F_NULTRASTAB,    _nultras);    
      TString16 data2 = _dataultras.string();
      msk->set(F_DATAULTRASTAB, data2);            
    }
    else    
    {
      msk->set(F_NULTRASTAB,    _nultras_tab);
      TString16 data2 = _dataultras_tab.string();
      msk->set(F_DATAULTRASTAB, data2);      
    }
    
    if (_stato_ripartenza == 0)
      msk->set(F_STATO, "COMPLETO");
    else 
      msk->set(F_STATO, "NON COMPLETO");
    
    if (_numdisk == 1)  // Va fatto solo per il primo disco
    {
      do
      { 
        msk->set_handler(baipassa);
        
        tasto = msk->run();
        
        if (tasto != K_ENTER)
          return false;
        
        if (_baipassa)
          return true;
        
        if (!ripartenza())
          return false;
        
        if (_numinv > (_nultras_tab + 1))
          warning_box(FR("Trasferimento FUORI SEQUENZA: manca un trasferimento intermedio.\n"
                      "Numero invio n. %d, ultimo trasferimento n. %d."), _numinv, _nultras_tab);
        else
          if (_numinv < (_nultras_tab +1))
            warning_box(FR("I dischetti risultano GIA' TRASFERITI.\n"
                        "Numero invio n. %d, ultimo trasferimento n. %d."), _numinv, _nultras_tab);  
          else
            return true;
      }
      while (tasto == K_ENTER);
    }
  }
  
  return true;
}

bool TRic_archivi::baipassa(TMask& m,KEY k)
{
  if ( (k == K_SHIFT+K_F7) && (app()._stato_ripartenza == 0)  )
    app()._baipassa = true;

  return true;
}

void TRic_archivi::ripristina_trasfer()                       
{ 
  TProgind prg (1,TR("Trasferimento archivi"),false, false);
  
   if (_numdisk == 1)           
    fcopy(_trasfer,_trasf,false);
  else
    fcopy(_trasfer,_trasf,true);
}

void TRic_archivi::trasfer2tempfile()                       
{ 
  _trasfhard = _tras_file->path(_dittaric);
  _trasfhard.add(HEADER);
  switch (_scelta)
  {
  case 'S': _tras_file->fcopytemp(_trasf,_trasfhard); break;
  case 'P': _tras_file->fcopytemp_PC(_trasf,_trasfhard); break;
  default: break;
  }
}

void TRic_archivi::ditta_ricevente()
{
  _ragsoc_dittar = cache().get(LF_NDITTE, _dittaric).get(NDT_RAGSOC);
}

long TRic_archivi::leggi_tabella_tras()
{               
  long ditta = 0;                    
                               
  TTable tab_tra("%TRA");
  TString16 dep; dep.format("%10s%05ld", (const char*)_nomeid, _dittainv);
  tab_tra.put("CODTAB", dep);
  if (tab_tra.read() == NOERR)    
  {
    ditta           = tab_tra.get_long("I0");
    _nultras_tab    = tab_tra.get_int ("I1");
    _dataultras_tab = tab_tra.get_date("D0");
    _agg_cau        = tab_tra.get_char("S0");
    _agg_clifo      = tab_tra.get_char("S1");
    _agg_pcon       = tab_tra.get_char("S2");
    _agg_cls        = tab_tra.get_char("S3");

    const bool agg_fatatt = tab_tra.get_bool("B0");
    _agg_fatatt = agg_fatatt ? 'X' : ' ';
    
    const bool agg_fatpas = tab_tra.get_bool("B1");
    _agg_fatpas = agg_fatpas ? 'X' : ' ';

    _agg_pcc_com = tab_tra.get_bool("B2"); // Aggiorna comunque piano dei conti in comune
    _agg_cfc_com = tab_tra.get_bool("B3"); // Aggiorna comunque clienti/fornitori in comune
  }
  
  return ditta;
}

bool TRic_archivi::set_flag()
{
  int        k = 0;
  TString4   flag;
  TString    record;
  TString4   uselab;  
  bool       fatto = true;
  
  TConfig conf(CONFIG_DITTA, "cg");           
  const bool ana_com  = conf.get_bool("AnCfCm") && !_agg_cfc_com;
  const bool pcon_cau = conf.get_bool("PcTcCm") && !_agg_pcc_com;
  
  _tras_file->open(_trasfhard);
  
  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();
      record      = _tras_file->record();   
    }
    
    for (int j = 0; j < _sigle_file.len(); j++)
    {                      
      const char sigla = _sigle_file[j];     
      const long nrec  = atol(_nrec_file.mid(k,6));
      
      if (fatto)
      {
        if (sigla == 'W' || sigla == 'P')
        {
          if (nrec > 0 && !pcon_cau)
          {
            flag  = "T";
            fatto = false;
          }
        }
        else
          if (sigla == 'A')
          {
            if (nrec > 0 && !ana_com)
            {
              flag  = "T";
              fatto = false;
            }
          }              
          else
            if (sigla == 'Z' || sigla == 'U' || sigla == 'B')
            {
              if (nrec > 0)
              {
                flag  = "C";
                fatto = false;
              }
            }
            else 
            {
              flag = "*";  
              fatto = false;
            }
        
        if (flag == "T")
          uselab = sigla; 
        else 
          uselab = "";                               
      }
      
      if (sigla == 'W' || sigla == 'P')
      {  
        if (pcon_cau)
        {
          _sigle_file.overwrite(" ",j);   
          _nrec_file.overwrite("000000",k);
        }  
      }
      
      if (sigla == 'A')
      {
        if (ana_com)
        {
          _sigle_file.overwrite(" ",j);   
          _nrec_file.overwrite("000000",k);
        }
      }            
      k += 6;
    } 
    
    record.overwrite(_sigle_file, 86);
    record.overwrite(_nrec_file,  95);
    
    char agg[8];
    agg[0] = _agg_cls;
    agg[1] = _agg_cau;
    agg[2] = _agg_clifo;
    agg[3] = _agg_pcon;
    agg[4] = _agg_fatatt;
    agg[5] = _agg_fatpas;    
    agg[6] = '\0';
    
    record.overwrite(agg,234);
    record.overwrite(uselab,240);  
    TString80 str; str.spaces(60);
    record.overwrite(str,241);
    
    const int size = 1024;
    if (!_tras_file->write_control_rec(record, size)) 
      return false;
  }  
  
  conf.set("FlStTra", flag);
  
  return true;
}

void TRic_archivi::aggiorna_tabella()
{
  TTable tab_tra("%TRA");
  TString16 dep;
  dep.format("%10s%05ld", (const char*)_nomeid, _dittainv);
  tab_tra.put("CODTAB", dep);
  if (tab_tra.read() == NOERR)    
  {
    tab_tra.put("I1", _nultras);
    tab_tra.put("D0", _dataultras);
    tab_tra.rewrite();
  }
}

int cg6400 (int argc, char* argv[])
{ 
  char p3 = '\0';
  
  if (argc > 4)
    p3 = *argv[3];
  
  TRic_archivi* main_app = new TRic_archivi(*argv[2],p3);
  main_app->run(argc, argv,main_app->_titolo);
  delete main_app;
  return 0;
}