258 lines
		
	
	
		
			5.3 KiB
		
	
	
	
		
			C++
		
	
	
		
			Executable File
		
	
	
	
	
			
		
		
	
	
			258 lines
		
	
	
		
			5.3 KiB
		
	
	
	
		
			C++
		
	
	
		
			Executable File
		
	
	
	
	
#include "cglib04.h"
 | 
						|
#include "cg6801.h"
 | 
						|
 | 
						|
bool TDitta_ric::create()
 | 
						|
{
 | 
						|
  TApplication::create();
 | 
						|
 | 
						|
  _nditte   = new TLocalisamfile (LF_PCON);
 | 
						|
  
 | 
						|
  dispatch_e_menu (BAR_ITEM(1));
 | 
						|
 | 
						|
  return TRUE;
 | 
						|
}
 | 
						|
 | 
						|
bool TDitta_ric::destroy()
 | 
						|
{ 
 | 
						|
  delete _nditte;
 | 
						|
  
 | 
						|
  return TApplication::destroy();
 | 
						|
}                                
 | 
						|
 | 
						|
bool TDitta_ric::set()
 | 
						|
{
 | 
						|
  TMask* msk = new TMask("cg6801a");
 | 
						|
  KEY     tasto;
 | 
						|
  
 | 
						|
  _old_ditta = get_firm();
 | 
						|
  
 | 
						|
  tasto = msk->run();
 | 
						|
  
 | 
						|
  if (tasto != K_ENTER)
 | 
						|
  {
 | 
						|
    delete msk;
 | 
						|
    return FALSE;
 | 
						|
  }
 | 
						|
 | 
						|
  _dittaric = msk->get_long(F_CODDITTA);
 | 
						|
  set_firm(_dittaric);
 | 
						|
  
 | 
						|
  if (!esegui_controlli()) 
 | 
						|
  {
 | 
						|
    set_firm(_old_ditta);
 | 
						|
    delete msk;
 | 
						|
    return FALSE;
 | 
						|
  }
 | 
						|
  
 | 
						|
  //set_firm(_dittaric);
 | 
						|
  delete msk;
 | 
						|
  return FALSE;
 | 
						|
}
 | 
						|
 | 
						|
bool TDitta_ric::leggi_trasfer()
 | 
						|
{
 | 
						|
  _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();
 | 
						|
      _uselab      = _tras_file.ult_file();
 | 
						|
      _key         = _tras_file.key();
 | 
						|
      _sigle_file  = _tras_file.sigle_file();
 | 
						|
      _nrec_file   = _tras_file.nrec_file();
 | 
						|
    }
 | 
						|
    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 TDitta_ric::esegui_controlli()
 | 
						|
{                    
 | 
						|
  TConfig conf(CONFIG_DITTA);           
 | 
						|
  
 | 
						|
  _std = conf.get("FlStTra");
 | 
						|
 | 
						|
  if (!prefix().exist(_dittaric))
 | 
						|
    return error_box("Codice ditta NON PRESENTE in archivio oppure NON ATTIVATO in contabilita' generale");
 | 
						|
 | 
						|
  if (_std == "")
 | 
						|
  {
 | 
						|
    if (!leggi_trasfer())  
 | 
						|
      return FALSE;        
 | 
						|
    
 | 
						|
    if (_uselab != "")
 | 
						|
      return error_box("Ultimo trasferimento NON COMPLETATO: completarlo");  
 | 
						|
    
 | 
						|
    if (!controlli())
 | 
						|
      return FALSE;
 | 
						|
  }
 | 
						|
 | 
						|
  TConfig cfd (CONFIG_DITTA);
 | 
						|
  
 | 
						|
  TString std = cfd.get("FlStTra"); 
 | 
						|
  if (std == "")
 | 
						|
    return error_box ("Non risultano TRASFERIMENTI ATTIVI sulla ditta richiesta"); 
 | 
						|
  
 | 
						|
  return TRUE;
 | 
						|
}
 | 
						|
 | 
						|
bool TDitta_ric::controlli()
 | 
						|
{ 
 | 
						|
  TString    ana_com,pcon_cau,uselab;
 | 
						|
  bool       fatto = FALSE;
 | 
						|
  
 | 
						|
  TConfig conf(CONFIG_DITTA);           
 | 
						|
  
 | 
						|
  ana_com  = conf.get("AnCfCm","cg");
 | 
						|
  pcon_cau = conf.get("PcTcCm","cg");
 | 
						|
  
 | 
						|
  if (ana_com == "X" || pcon_cau == "X")
 | 
						|
  {
 | 
						|
    if (ana_com == "X")
 | 
						|
    {
 | 
						|
      int p = _sigle_file.find('A');
 | 
						|
      if (p >= 0)
 | 
						|
      {
 | 
						|
        _sigle_file.overwrite(" ",p);
 | 
						|
        _nrec_file.overwrite("000000", p * 6);
 | 
						|
      }
 | 
						|
    }                                                            
 | 
						|
    
 | 
						|
    if (pcon_cau == "X")
 | 
						|
    {
 | 
						|
      int p = _sigle_file.find('W');
 | 
						|
      if (p >= 0)
 | 
						|
      {
 | 
						|
        _sigle_file.overwrite(" ",p);
 | 
						|
        _nrec_file.overwrite("000000", p * 6);
 | 
						|
      }       
 | 
						|
      
 | 
						|
      p = _sigle_file.find('P');
 | 
						|
      if (p >= 0)
 | 
						|
      {
 | 
						|
        _sigle_file.overwrite(" ",p);
 | 
						|
        _nrec_file.overwrite("000000", p * 6);
 | 
						|
      }       
 | 
						|
    }
 | 
						|
    
 | 
						|
    _control_rec.overwrite(_sigle_file,86);         
 | 
						|
    _control_rec.overwrite(_nrec_file,95);          
 | 
						|
    _tras_file.write_control_rec(_control_rec,1024); 
 | 
						|
    leggi_record_controllo();
 | 
						|
  }
 | 
						|
 | 
						|
  setta_parametri_record("","T",FALSE);  
 | 
						|
  
 | 
						|
  int k = 0;
 | 
						|
  
 | 
						|
  for ( int j = 0; j < _sigle_file.len(); j++)
 | 
						|
  {                      
 | 
						|
    TString sigla  = _sigle_file.mid(j,1);     
 | 
						|
    long    nrec   = atol(_nrec_file.mid(k,6));
 | 
						|
    
 | 
						|
    if (sigla != "Z" && sigla != "U" && sigla != "B")
 | 
						|
    {  
 | 
						|
      if (nrec != 0)
 | 
						|
      {  
 | 
						|
        uselab = sigla;
 | 
						|
        _control_rec.overwrite(uselab,240);  
 | 
						|
        TString str;
 | 
						|
        str.spaces(60);
 | 
						|
        _control_rec.overwrite(str,241);
 | 
						|
        fatto = TRUE;
 | 
						|
        break;
 | 
						|
      }  
 | 
						|
    } 
 | 
						|
    k += 6;
 | 
						|
  } 
 | 
						|
  
 | 
						|
  if (!fatto)
 | 
						|
  {
 | 
						|
    int p = _sigle_file.find('Z');
 | 
						|
    if (p >= 0) 
 | 
						|
    {
 | 
						|
      setta_parametri_record("","C",FALSE);      
 | 
						|
      _control_rec.overwrite(" ",240);
 | 
						|
      TString str;
 | 
						|
      str.spaces(60);
 | 
						|
      _control_rec.overwrite(str,241);
 | 
						|
    }
 | 
						|
    else
 | 
						|
    {
 | 
						|
      setta_parametri_record("","*",FALSE);      
 | 
						|
      _control_rec.overwrite(" ",240);
 | 
						|
      TString str;
 | 
						|
      str.spaces(60);
 | 
						|
      _control_rec.overwrite(str,241);   
 | 
						|
      fremove(_trasf);
 | 
						|
      setta_parametri_record(""," ",FALSE);      
 | 
						|
    }
 | 
						|
  }
 | 
						|
  
 | 
						|
  char agg_cau   = _control_rec.sub(235,236)[0];
 | 
						|
  char agg_clifo = _control_rec.sub(236,237)[0];
 | 
						|
  char agg_pcon  = _control_rec.sub(237,238)[0];
 | 
						|
  
 | 
						|
  if (agg_cau != ' ')
 | 
						|
    agg_cau = 'D';
 | 
						|
  if (agg_clifo != ' ')
 | 
						|
    agg_clifo = 'D';
 | 
						|
  if (agg_pcon != ' ')
 | 
						|
    agg_pcon = 'D';
 | 
						|
  
 | 
						|
  TString agg(4);
 | 
						|
  
 | 
						|
  agg[0] = agg_cau;
 | 
						|
  agg[1] = agg_clifo;
 | 
						|
  agg[2] = agg_pcon;
 | 
						|
  agg[3] = '\0';
 | 
						|
  
 | 
						|
  _control_rec.overwrite(agg,235);
 | 
						|
  
 | 
						|
  const int size = 1024;
 | 
						|
  
 | 
						|
  if (!_tras_file.write_control_rec(_control_rec, size)) 
 | 
						|
    return FALSE; 
 | 
						|
  
 | 
						|
  return TRUE;
 | 
						|
}
 | 
						|
 | 
						|
void TDitta_ric::leggi_record_controllo()
 | 
						|
{
 | 
						|
  _tras_file.read_control_rec();
 | 
						|
  _control_rec = _tras_file.record();
 | 
						|
}
 | 
						|
 | 
						|
void TDitta_ric::setta_parametri_record(const TString& sigla,const TString& flag,bool uselab)
 | 
						|
{ 
 | 
						|
  TConfig conf (CONFIG_DITTA);
 | 
						|
  
 | 
						|
  conf.set("FlStTra", flag);
 | 
						|
 | 
						|
  if (uselab)
 | 
						|
  {
 | 
						|
    leggi_record_controllo();
 | 
						|
    _control_rec.overwrite(sigla,240);
 | 
						|
    
 | 
						|
    const int size = 1024;
 | 
						|
    
 | 
						|
    _tras_file.write_control_rec(_control_rec, size);
 | 
						|
  }
 | 
						|
}
 | 
						|
 | 
						|
bool TDitta_ric::menu(MENU_TAG m)
 | 
						|
{
 | 
						|
  if (m == BAR_ITEM(1))
 | 
						|
    return set(); 
 | 
						|
  return FALSE;
 | 
						|
}
 |