campo-sirio/cg/cg6803.cpp

#include "cglib04.h"            
#include "cg6803.h"

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

bool TVis_ric::create()
{
  TApplication::create();

  _tab_tra   = new TTable ("%TRA");
  
  _registra  = FALSE;
  _ftrasfer  = TRUE;
  
  dispatch_e_menu (BAR_ITEM(1));

  return TRUE;
}

bool TVis_ric::destroy()
{ 
  delete _tab_tra;
  
  return TApplication::destroy();
}                                

bool TVis_ric::baipassa(TMask& m, KEY k)
{
  if (k == K_SHIFT+K_F12)
  { 
    m.enable(F_NULTRAS);
    m.enable(F_DATAULTRAS);
    m.enable(F_STD);
    m.enable(F_USELAB);
    m.enable(F_STATO);
    m.enable(F_AGGCAUSALI);
    m.enable(F_AGGCLIFO);
    m.enable(F_AGGPCON);
    m.enable(F_AGGIVD);
    m.enable(F_FATTEM);
    m.enable(F_FATTRIC);
    
    app()._registra = TRUE;
  }
  
  return TRUE;
}

bool TVis_ric::stato_hnd (TMask_field& f, KEY k)
{
  if (k == K_ENTER)
  {
    TString std    = f.get();
    TString uselab = f.mask().get(F_USELAB);                                 
    TString chiave = f.mask().get(F_STATO);
    
    if (!app()._ftrasfer) //_ftrasfer dice se esiste il file trasfer o il suo record di controllo
    {
      if (std != "" && std != "*")
        return warning_box(TR("Valore non valido per stato ultima ricezione"));  
    }
    else
    {
      if (std != "" && std != "T" && std != "C" && std != "M" && std != "*")
        return warning_box(TR("Valore non valido per stato ultima ricezione"));  
      
      if (uselab != "" && (std == "" || std == "C" || std == "*") )
        return warning_box(TR("Valore non valido per stato ultima ricezione"));    
      
      if (chiave != "" && (std == "" || std == "C" || std == "*") )
        return warning_box(TR("Valore non valido per stato ultima ricezione"));    
      
    }
  }                                       
  return TRUE;
}

bool TVis_ric::uselab_hnd (TMask_field& f, KEY k)
{
  if (k == K_ENTER)
  {
    TString std    = f.mask().get(F_STD);
    TString uselab = f.get();
    
    if (std == "" && uselab != "")
      return warning_box(TR("Lo stato ultima ricezione non e' significativo: la sigla ultimo file elaborato non puo' essere significativa"));  
  }           
  return TRUE;
}

bool TVis_ric::chiave_hnd (TMask_field& f, KEY k)
{
  if (k == K_ENTER)
  {
    TString std    = f.mask().get(F_STD);
    TString uselab = f.mask().get(F_USELAB);
    TString chiave = f.get();
    
    if (std == "" && chiave != "")
      return warning_box(TR("Lo stato ultima ricezione non e' significativo: la chiave ultimo file elaborato non puo' essere significativa"));  
    
    if (uselab == "" && chiave != "")  
      return warning_box(TR("La sigla ultimo file elaborato non e' significativa: la chiave ultimo file elaborato non puo' essere significativa"));  
  }           
  return TRUE;
}

bool TVis_ric::video()
{                    
  if (!esegui_controlli())
    return FALSE;
  
  TMask* msk = new TMask("cg6803a");
  KEY  tasto;
  
  ditta_ricevente();       // Cerca la ragione sociale della ditta.     
  
  setta_campi_video(msk);  // Setta i campi della maschera con i dati relativi
                           // alla ditta e alla tabella trasferimenti.
  msk->set_handler(baipassa); 
  msk->set_handler(F_STD,      stato_hnd);
  msk->set_handler(F_USELAB,   uselab_hnd);
  msk->set_handler(F_STATO,    chiave_hnd);
  
  tasto = msk->run();
  
  if (tasto != K_ENTER)
  {
    delete msk;
    return FALSE;
  }
  
  registra(*msk);

  delete msk;
  return FALSE;
}

void TVis_ric::setta_campi_video(TMask* msk)
{ 
  if (_ftrasfer)
  {
    msk->set(F_CODDITTARIC, _dittaric);
    msk->set(F_RAGSOC,      _ragsoc_dittar);
    msk->set(F_NULTRAS,     _nultras);
    
    if (_nultras != 0)
    {
      TString data1 = _dataultras.string();
      msk->set(F_DATAULTRAS,  data1);
    }
    msk->set(F_USELAB,      _uselab);
    msk->set(F_STATO,       _key);
    msk->set(F_AGGCAUSALI,  _agg_cau);
    msk->set(F_AGGCLIFO,    _agg_clifo);
    msk->set(F_AGGPCON,     _agg_pcon);
    msk->set(F_AGGIVD,      _agg_IVdir);
    msk->set(F_FATTEM,      _riatt_att);
    msk->set(F_FATTRIC,     _riatt_pas);       
  }
  
  msk->set(F_STD,         _std);  
  
  msk->disable(F_CODDITTARIC);
  msk->disable(F_RAGSOC);
  msk->disable(F_NULTRAS);
  msk->disable(F_DATAULTRAS);
  msk->disable(F_STD);
  msk->disable(F_USELAB);
  msk->disable(F_STATO);
  msk->disable(F_AGGCAUSALI);
  msk->disable(F_AGGCLIFO);
  msk->disable(F_AGGPCON);
  msk->disable(F_AGGIVD);
  msk->disable(F_FATTEM);
  msk->disable(F_FATTRIC);
}

void TVis_ric::registra(TMask& m)
{
  if (_registra)
  {                
    TString str;
    
    str             = m.get(F_NULTRAS);   
    TString nultras = format("%03s", (const char*) str);
    str             = m.get(F_DATAULTRAS);
    TString datault = riconverti(str,TRUE);
    char    agg_cau = m.get(F_AGGCAUSALI)[0];
    char    agg_clf = m.get(F_AGGCLIFO)[0];
    char    agg_pco = m.get(F_AGGPCON)[0];
    char    agg_IV  = m.get(F_AGGIVD)[0];
    char    riat_at = m.get(F_FATTEM)[0];
    char    riat_pa = m.get(F_FATTRIC)[0]; 
    if (riat_at =='\0')
      riat_at = ' ';
      
    if (riat_pa == '\0')
      riat_pa = ' ';
      
    TString flags (7);
    flags[0] = agg_IV;
    flags[1] = agg_cau;
    flags[2] = agg_clf;
    flags[3] = agg_pco;
    flags[4] = riat_at;
    flags[5] = riat_pa;
    flags[6] = '\0';
    
    TString uselab  = m.get(F_USELAB);
    if (uselab == "")
      uselab = " ";
    
    str             = m.get(F_STATO);
    TString chiave  = format("%-60s", (const char*) str);
    
    _control_rec.overwrite(nultras,75);
    _control_rec.overwrite(datault,78);    
    _control_rec.overwrite(flags,234);
    _control_rec.overwrite(uselab,240);
    _control_rec.overwrite(chiave,241);   
    //_control_rec.format("%-1024s", (const char*) _control_rec);
    
    const int size = 1024;
    
    _tras_file.write_control_rec(_control_rec, size);
    
    TString std = m.get(F_STD);
    
    setta_std(std);     
  }
}

void TVis_ric::setta_std(const TString& flag)
{ 
  TConfig conf (CONFIG_DITTA);
  
  conf.set("FlStTra", flag);
}

void TVis_ric::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);
}
/*
long TVis_ric::leggi_tabella_tras()
{               
  TString dep;                               
  long    ditta = 0;
  
  _tab_tra->zero();
  dep = format("%10s%05d", (const char*) _nomeid, _dittainv);
  _tab_tra->put("CODTAB", (const char*) dep);
  if (_tab_tra->read() == NOERR)    
    ditta           = _tab_tra->get_long("I0");

  return ditta;
}
*/
bool TVis_ric::leggi_trasfer()
{     
  TString data,tmp;
  
  _trasf = _tras_file.path(_dittaric);
  _trasf << HEADER;
  
  _tras_file.open(_trasf);
  
  if (_tras_file.exist())
  {  
    if (_tras_file.read_control_rec())
    {
      _control_rec = _tras_file.record();
      _nomeid      = _tras_file.nome_simb();
      _dittainv    = _tras_file.ditta();
      _nultras     = _tras_file.nultras();
      _dataultras  = _tras_file.dataultras();
      _uselab      = _tras_file.ult_file();
      _key         = _tras_file.key();
      _agg_cau     = _control_rec.sub(235,236);
      _agg_clifo   = _control_rec.sub(236,237);
      _agg_pcon    = _control_rec.sub(237,238);
      _agg_IVdir   = _control_rec.sub(234,235);
      _riatt_att   = _control_rec.sub(238,239);
      _riatt_pas   = _control_rec.sub(239,240);
    }
    else
      _ftrasfer = FALSE;
  } 
  else
    _ftrasfer = FALSE;
  
  return TRUE; 
}

bool TVis_ric::esegui_controlli()
{                    
  TConfig conf(CONFIG_DITTA);           
  
  _std = conf.get("FlStTra");
  
  _dittaric = get_firm();
  
  if (!prefix().exist(_dittaric))
    return error_box(TR("Rilevati GRAVI ERRORI negli archivi: procedura interrotta"));

  if (!leggi_trasfer())
    return FALSE;      

  return TRUE;
}

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