// Variazione movimenti di prima nota e movimenti iva

#include <mask.h>
#include <relation.h>
#include <tabutil.h>
#include <utility.h>
#include <config.h>
#include <mailbox.h>
#include <prefix.h>

#include <nditte.h>  
#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>

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

#include "cg2800.h"
#include "cg2801.h"
#include "cg2802.h"
#include "cg2803.h"

HIDDEN      TString80 TEMP;

//HIDDEN int date2esc(const TDate& d, int* prevesc = NULL);

class TVar_mov : public TApplication
{
  TIsamtempfile*   _tmov,* _trmov,* _tiva;
  TLocalisamfile*  _pcon,* _clifo, *_mov, *_rmov, *_rmoviva;
  TTable*          _tab_reg;
  TRectype*        _rec_mov,* _rec_rmov,* _rec_riva;
  TTransfer_file   _tras_file;
  char             _scelta;
  
  TString _trasf,_std,_descr_civa;
  long    _dittaric,_numreg;      
  TString _control_rec,_record;         
  bool    _righe,_corrisp;          
  int     _numrig,_tiporeg;
  
public:        
  TString     _titolo;
  
  virtual bool create();
  virtual bool destroy();
  virtual bool menu(MENU_TAG m);         
  bool    main_loop();
  bool    esegui_controlli();
  bool    leggi_trasfer();
  bool    controlli();
  void    leggi_record_controllo();
  bool    video_PN();
  bool    video_IVA();  
  void    registra_PN(TMask& m);                
  void    registra_IVA(TMask& m);                  
  bool    esiste_testata_mov(TMask& m);
  bool    ricerca_movimento(TMask& m);

  bool    esiste_riga_mov(TMask& m);
  bool    esiste_riga_iva(TMask& m);  

  void    ricerca_codcaus(const TString& codcaus);
  void    setta_campi_maschera(TMask& m);                                  
  bool    setta_campi_maschera_iva(TMask& m);                                    

  void    registra_file_temp_mov(long,const TDate&,const TDate&,const TString&,TString&,long,long,const TString&,TString&);
  void    registra_file_trasfer_t(long,int,const TDate&,const TDate&,const TString&,TString&,long,long,const TString&,const TString&);  
  void    registra_file_temp_rmov(long,int,int,int,long,char,const TString&,int,int,long,const real&);
  void    registra_file_trasfer_r(long,int,int,int,long,char,const TString&,int,int,long,const real&);
  void    registra_file_trasfer_t_iva(long,const TDate&,long,const TString&,const TString&,const TString&,const TString&,const TString&);
  void    registra_file_temp_riva(long,int,const real&,const TString&,const real&,int,int,int,int,long);
  void    registra_file_trasfer_r_iva(long,int,const real&,const TString&,const real&,int,int,int,int,long);

  void    setta_parametri_record(const TString& sigla,const TString& flag);
  
  const char* converti  (TString& data_AS400);
  const char* riconverti(TString& data_PC);
  
  static bool codice_registro_hnd   (TMask_field& f, KEY k);
  static bool codice_causale_hnd    (TMask_field& f, KEY k);
  static bool numero_protocollo_hnd (TMask_field& f, KEY k);
  static bool ultimo_protocollo_hnd (TMask_field& f, KEY k);
  static bool codice_pagamento_hnd  (TMask_field& f, KEY k);  
  static bool data_stampa           (TMask_field& f, KEY k);  
  
  static bool controllo_partita       (TMask_field& f, KEY k);    
  static bool controllo_contropartita (TMask_field& f, KEY k);    
  static bool controllo_importo       (TMask_field& f, KEY k);    
  
  static bool codice_clifo_hnd      (TMask_field& f, KEY k);
  static bool codice_iva_hnd        (TMask_field& f, KEY k);  
  static bool imposta_hnd           (TMask_field& f, KEY k);  
  static bool detraibilita_hnd      (TMask_field& f, KEY k);  
  static bool tipocr_hnd            (TMask_field& f, KEY k);        

  bool   decodifica_codiva(const TString& codiva);
  
  TVar_mov(char mov);
};                                      

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

HIDDEN int date2esc(const TDate& d, int* prevesc)
{                   
  if (prevesc) *prevesc = 0;
  TTable esc("ESC");
  for (int err = esc.first(); err == NOERR; err = esc.next())
  {
    const TDate ia(esc.get("D0"));   // Data inizio esercizio
    const TDate fa(esc.get("D1"));   // Data fine esercizio
    const anno = esc.get_int("CODTAB");  
    if (d >= ia && d <= fa)
      return anno;
    if (prevesc) *prevesc = anno; 
  } 
  return 0;
}

TVar_mov::TVar_mov(char mov) : _scelta(toupper(mov))
{
  switch (_scelta)
  {
  case 'P':
    _titolo = "Variazione movimenti prima nota";
    break;
    
  case 'I':
    _titolo = "Variazione movimenti iva";
    break;
    
  default:
    break;
  }
}

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

  _pcon     = new TLocalisamfile (LF_PCON);
  _clifo    = new TLocalisamfile (LF_CLIFO);
  _rec_mov  = new TRectype (LF_MOV);
  _mov      = new TLocalisamfile (LF_MOV);
  _rmov     = new TLocalisamfile (LF_RMOV);
  _rmoviva  = new TLocalisamfile (LF_RMOVIVA); 
  _tab_reg  = new TTable ("REG");
  
  if (_scelta == 'P')
  {
    TString80 tmpmov = "%";
    tmpmov  << get_firm_dir();
    tmpmov << "\\" << TEMP_MOV;
    TString80 tmprmov = "%";
    tmprmov << get_firm_dir();         
    tmprmov << "\\" << TEMP_RMOV;  
    
    _tmov     = new TIsamtempfile(LF_MOV, tmpmov, 0);
    _trmov    = new TIsamtempfile(LF_RMOV, tmprmov, 0);
    _rec_rmov = new TRectype (LF_RMOV);
  }
  else
    if (_scelta == 'I')
    {
      TString80 tmpmov = "%";
      tmpmov  << get_firm_dir();
      tmpmov << "\\" << TEMP_MOV;
      TString80 tmprmoviva = "%";
      tmprmoviva << get_firm_dir();     
      tmprmoviva << "\\" << TEMP_RMOVIVA;                     
      
      _tmov     = new TIsamtempfile(LF_MOV, tmpmov, 0);
      _tiva     = new TIsamtempfile(LF_RMOVIVA, tmprmoviva, 0);
      _rec_riva = new TRectype (LF_RMOVIVA);
    }
  
  dispatch_e_menu (BAR_ITEM(1));

  return TRUE;
}

bool TVar_mov::destroy()
{ 
  delete _rec_mov;
  delete _pcon;
  delete _clifo;
  delete _mov;
  delete _rmov;
  delete _rmoviva;               
  delete _tab_reg;
  
  if (_scelta == 'P')
  {
    delete _trmov;
    delete _rec_rmov;                         
  }
  else
    if (_scelta == 'I')
    {
      delete _tiva;
      delete _rec_riva;
    }
  
  delete _tmov;                               
  
  return TApplication::destroy();
}                                

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

const char* TVar_mov::converti (TString& data_AS400)
{
  TEMP = data_AS400.mid(4,2);
  TEMP << "-" <<data_AS400.mid(2,2);
  TEMP << "-" <<data_AS400.mid(0,2);
  return TEMP;
}

const char* TVar_mov::riconverti (TString& data_PC)
{
  TEMP = data_PC.mid(8,2);
  TEMP << data_PC.mid(3,2);
  TEMP << data_PC.mid(0,2);
  return TEMP;
}

bool TVar_mov::main_loop()
{      
  _dittaric = get_firm();
  
  if (!esegui_controlli()) return FALSE;
  
  if (_scelta == 'P')
  {
    if (!video_PN())
      return FALSE;
  }
  else
  {
    if (_scelta == 'I')
      if (!video_IVA())
        return FALSE;  
  }
  
  setta_parametri_record(" ","C");
  leggi_record_controllo();
  TString str (_control_rec.overwrite("               ",241));
  _tras_file.write_control_rec(str,256);
  
  return FALSE;
}

bool TVar_mov::video_PN()
{   
  TMask msk ("cg2800a");
  KEY     tasto;
  
  do
  { 
    tasto = msk.run();
    
    if (tasto != K_ENTER) return FALSE;
    
    if (ricerca_movimento(msk))
    {
      TMask mask ("cg2800b");
      
      mask.set_handler(F_REGIVA,    codice_registro_hnd);
      mask.set_handler(F_CODCAUS,   codice_causale_hnd);  
      mask.set_handler(F_PROTIVA,   numero_protocollo_hnd);
      mask.set_handler(F_NUPROTIVA, ultimo_protocollo_hnd);
      mask.set_handler(F_CODPAG,    codice_pagamento_hnd);
      mask.set_handler(F_DATAREG,   data_stampa);      
      
      if (_righe)                    
      {
        mask.set_handler(F_SOTTOCONTO, controllo_partita);
        mask.set_handler(F_SOTTOC,     controllo_contropartita);
        mask.set_handler(F_IMPORTO   , controllo_importo);
      }
      
      setta_campi_maschera(mask);
      
      tasto = mask.run();
      
      switch (tasto)
      {
      case K_ESC :
        break;
        
      case K_QUIT :
        break;       
        
      case K_SAVE :
      {
        registra_PN(mask);
      }
        break;
        
      default:
        break;
      }
    }
  }
  while (tasto != K_QUIT);                              //K_ENTER
  
  return TRUE;
}

void TVar_mov::ricerca_codcaus(const TString& codcaus)
{
  TLocalisamfile cau (LF_CAUSALI);
  TString tipodoc;
  
  cau.setkey(1);
  cau.zero();
  cau.put("CODCAUS", (const char*) codcaus);
  if (cau.read() == NOERR)
    tipodoc = cau.get_char("TIPODOC");
  
  TTable tpd ("%TPD");
  
  tpd.zero();
  tpd.put("CODTAB", (const char*) tipodoc);
  if (tpd.read() == NOERR)
    _corrisp = tpd.get_bool("B0");
}

bool TVar_mov::video_IVA()
{   
  TMask msk ("cg2800a");
  KEY     tasto;
  
  do
  { 
    tasto = msk.run();
    
    if (tasto != K_ENTER) return FALSE;
    
    if (ricerca_movimento(msk))
    {
      TMask mask ("cg2800c");                    
      
      TString regiva = _rec_mov->get     (MOV_REG);
      
      if (!setta_campi_maschera_iva(mask))
        return FALSE;
      
      mask.set_handler(F_CODCF,    codice_clifo_hnd);              

      if (_righe)                    
      {
        mask.set_handler(F_SOTTOCONTO, controllo_partita);
        mask.set_handler(F_CODIVA,     codice_iva_hnd);
        mask.set_handler(F_IMPOSTA,    imposta_hnd);
        mask.set_handler(F_TIPODET,    detraibilita_hnd);
        mask.set_handler(F_TIPOCR,     tipocr_hnd);
      }
      
      tasto = mask.run();
      
      switch (tasto)
      {
      case K_ESC :
        break;
        
      case K_QUIT :
        break;       
        
      case K_SAVE :
      {
        registra_IVA(mask);
      }
        break;
        
      default:
        break;
      }
    }
  }
  while (tasto != K_QUIT);                              //K_ENTER
  
  return TRUE;
}

bool TVar_mov::ricerca_movimento(TMask& m)
{   
  _numrig = atoi(m.get(F_NUMRIG));
  
  if (_numrig == 0)
  {
    _righe = FALSE;
    return esiste_testata_mov(m);
  }
  else
  {
    _righe = TRUE;               
    esiste_testata_mov(m);
    if (_scelta == 'P')
      return esiste_riga_mov(m);
    else
      return esiste_riga_iva(m);
  }
  
  return TRUE;
}

bool TVar_mov::esiste_testata_mov(TMask& m)
{
  long nprog;
  
  _numreg = m.get_long(F_NUMREG);
  
  _tmov->setkey(1);
  _tmov->zero();
  _tmov->put(MOV_NUMREG, _numreg);
  
  if (_tmov->read() == NOERR)
  { 
    if (_scelta == 'P')
    {
      nprog = _tmov->get_long(MOV_NUMGIO);
      nprog += _tras_file.start('Z');
    }
    else
      if (_scelta == 'I')
      { 
        _tiva->setkey(1);
        _tiva->zero();
        _tiva->put(RMI_NUMREG, _numreg);
        _tiva->read();  
        long nr = _tiva->get_long(RMI_NUMREG);
        if (_numreg != nr)
          return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
        
        nprog = _tmov->get_long(MOV_ANNOIVA);
        nprog += _tras_file.start('U');
      }
    
    _tras_file.read_rec_trasfer(nprog);
    _record = _tras_file.read_rec();
    
    char annullato = _record.sub(248,249)[0];
    
    if (annullato == 'A')
      return error_box("Registrazione presente ma ANNULLATA: impossibile variarla");
    
    *_rec_mov = _tmov->curr();  
  }
  else
    return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
  
  return TRUE;
}

bool TVar_mov::esiste_riga_mov(TMask& m)
{
  _numreg = m.get_long(F_NUMREG);
  _numrig = m.get_int (F_NUMRIG);
  
  _trmov->setkey(1);
  _trmov->zero();
  _trmov->put(RMV_NUMREG, _numreg);
  _trmov->put(RMV_NUMRIG, _numrig);  
  
  if (_trmov->read() == NOERR)
  {
    long nprog = _trmov->get_long(RMV_ANNOES);
    nprog += _tras_file.start('Z');
    
    _tras_file.read_rec_trasfer(nprog);
    _record = _tras_file.read_rec();
    
    char annullato = _record.sub(248,249)[0];
    
    if (annullato == 'A')
      return error_box("Registrazione presente ma ANNULLATA: impossibile variarla");
    
    *_rec_rmov = _trmov->curr();  
  }
  else
    return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
  
  return TRUE;
}

bool TVar_mov::esiste_riga_iva(TMask& m)
{
  _numreg = m.get_long(F_NUMREG);
  _numrig = m.get_int (F_NUMRIG);
  
  _tiva->setkey(1);
  _tiva->zero();
  _tiva->put(RMI_NUMREG, _numreg);
  _tiva->put(RMI_NUMRIG, _numrig);  
  
  if (_tiva->read() == NOERR)
  {
    long nprog = _tiva->get_long(RMI_ANNOES);
    nprog += _tras_file.start('U');
    
    _tras_file.read_rec_trasfer(nprog);
    _record = _tras_file.read_rec();
    
    char annullato = _record.sub(248,249)[0];
    
    if (annullato == 'A')
      return error_box("Registrazione presente ma ANNULLATA: impossibile variarla");
    
    *_rec_riva = _tiva->curr();  
  }
  else
    return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
  
  return TRUE;
}

void TVar_mov::setta_campi_maschera(TMask& m)
{  
  int     annorif   = atoi(_record.sub(21,22));
  TDate   datareg (_rec_mov->get_date(MOV_DATAREG));
  TDate   datadoc (_rec_mov->get_date(MOV_DATADOC));
  TString numdoc    = _rec_mov->get     (MOV_NUMDOC);
  TString regiva    = _rec_mov->get     (MOV_REG);
  regiva.trim();
  long    protiva   = _rec_mov->get_long(MOV_PROTIVA);
  long    nuprotiva = _rec_mov->get_long(MOV_UPROTIVA);
  TString codcaus   = _rec_mov->get     (MOV_CODCAUS);
  TString codpag    = _rec_mov->get     (MOV_CODPAG);
  codpag.trim();
  
  m.set(F_NUMREG,    _numreg);
  m.set(F_NUMRIG,    _numrig); 
  m.set(F_DATAREG,   datareg.string());
  m.set(F_ANNO,      annorif);
  m.set(F_DATADOC,   datadoc.string());
  m.set(F_NUMDOC,    numdoc);
  m.set(F_REGIVA,    regiva);
  m.set(F_PROTIVA,   protiva);
  m.set(F_NUPROTIVA, nuprotiva);
  m.set(F_CODCAUS,   codcaus);
  m.set(F_CODPAG,    codpag);

  m.disable(F_NUMREG);
  m.disable(F_NUMRIG);       
  
  if (!_righe)
  {    
    m.enable(F_DATAREG);
    m.enable(F_ANNO);
    m.enable(F_DATADOC);
    m.enable(F_NUMDOC);
    m.enable(F_REGIVA);
    m.enable(F_PROTIVA);
    m.enable(F_NUPROTIVA);
    m.enable(F_CODCAUS);
    m.enable(F_CODPAG);
    m.disable(F_GRUPPO);
    m.disable(F_CONTO);
    m.disable(F_SOTTOCONTO);
    m.disable(F_SEZIONE);
    m.disable(F_IMPORTO);
    m.disable(F_DESCR);
    m.disable(F_GRUPPOC);
    m.disable(F_CONTOC);
    m.disable(F_SOTTOC);
  }
  else
    if (_righe)
    {
      int     gruppo   = _trmov->get_int (RMV_GRUPPO);
      int     conto    = _trmov->get_int (RMV_CONTO);
      long    sottocon = _trmov->get_long(RMV_SOTTOCONTO);
      TString sezione  = _trmov->get     (RMV_SEZIONE);
      TString descr    = _trmov->get     (RMV_DESCR);
      int     gruppoc  = _trmov->get_int (RMV_GRUPPOC);
      int     contoc   = _trmov->get_int (RMV_CONTOC);
      long    sottoc   = _trmov->get_long(RMV_SOTTOCONTOC);
      real    importo  = _trmov->get_real(RMV_IMPORTO);  
      
      m.set(F_GRUPPO,     gruppo);
      m.set(F_CONTO,      conto);
      m.set(F_SOTTOCONTO, sottocon);
      m.set(F_SEZIONE,    sezione);
      m.set(F_DESCR,      descr);
      m.set(F_GRUPPOC,    gruppoc);
      m.set(F_CONTOC,     contoc);
      m.set(F_SOTTOC,     sottoc);
      m.set(F_IMPORTO,    importo.string());
      
      m.disable(F_DATAREG);
      m.disable(F_ANNO);
      m.disable(F_DATADOC);
      m.disable(F_NUMDOC);
      m.disable(F_REGIVA);
      m.disable(F_PROTIVA);
      m.disable(F_NUPROTIVA);
      m.disable(F_CODCAUS);
      m.disable(F_CODPAG);
      
      m.enable(F_GRUPPO);
      m.enable(F_CONTO);
      m.enable(F_SOTTOCONTO);
      m.enable(F_SEZIONE);
      m.enable(F_IMPORTO);
      m.enable(F_DESCR);
      m.enable(F_GRUPPOC);
      m.enable(F_CONTOC);
      m.enable(F_SOTTOC);
    }
}

bool TVar_mov::setta_campi_maschera_iva(TMask& m)
{  
  TDate   datareg   (_rec_mov->get_date(MOV_DATAREG));
  TDate   data74ter (_rec_mov->get_date(MOV_DATA74TER));
  TString regiva    = _rec_mov->get     (MOV_REG);
  regiva.trim();
  TString codcaus   = _rec_mov->get     (MOV_CODCAUS);
  long    codcf     = _rec_mov->get_long(MOV_CODCF);
  
  TString ragsoc    = _record.sub(61,86);
  TString ind       = _record.sub(86,108);
  TString localita  = _record.sub(108,126);
  TString cap       = _record.sub(126,131);
  TString prov      = _record.sub(131,133);

  if (codcaus.not_empty())
    ricerca_codcaus(codcaus);
  
  int anno = date2esc(datareg);
  
  char cr = regiva[0];
  TString codreg;
  
  if (isdigit(cr))
    codreg.format("%03c", cr);
  else
    codreg.format("%-3c", cr);
  
  TRegistro rg (codreg, anno); 
  _tiporeg = rg.tipo();
  
  if (regiva.not_empty())
  {
    if (!rg.ok())  
      return error_box("Registrazione presente ma con PRIMANOTA ERRATA: correggerla prima");
  }
  else
    return error_box("Campo NON VALIDO o codice NON PRESENTE in archivio");    
  
  m.set(F_NUMREG,    _numreg);
  m.set(F_NUMRIG,    _numrig); 
  m.set(F_DATA74TER, data74ter.string());
  m.set(F_CODCF,     codcf);       
  m.set(F_RAGSOCOCC, ragsoc);
  m.set(F_INDOCC,    ind);
  m.set(F_LOCALITA,  localita);
  m.set(F_CAPOCC,    cap);
  m.set(F_PROVOCC,   prov);

  m.disable(F_NUMREG);
  m.disable(F_NUMRIG);       
  
  if (!_righe)
  {    
    m.enable(F_DATA74TER);
    m.enable(F_CODCF);
    m.enable(F_RAGSOCOCC);
    m.enable(F_INDOCC);
    m.enable(F_LOCALITA);
    m.enable(F_CAPOCC);
    m.enable(F_PROVOCC);
    m.disable(F_IMPONIBILE);
    m.disable(F_CODIVA);
    m.disable(F_IMPOSTA);
    m.disable(F_TIPODET);
    m.disable(F_TIPOCR);
    m.disable(F_GRUPPO);
    m.disable(F_CONTO);
    m.disable(F_SOTTOCONTO);
  }
  else
    if (_righe)
    {
      real    imponibile (_tiva->get_real(RMI_IMPONIBILE));
      TString codiva     (_tiva->get     (RMI_CODIVA));
      real    imposta    (_tiva->get_real(RMI_IMPOSTA));
      int     tipodet   = _tiva->get_int (RMI_TIPODET);
      int     tipocr    = _tiva->get_int (RMI_TIPOCR);
      int     gruppo    = _tiva->get_int (RMI_GRUPPO);
      int     conto     = _tiva->get_int (RMI_CONTO);
      long    sottoc    = _tiva->get_long(RMI_SOTTOCONTO);
      
      m.set(F_IMPONIBILE, imponibile.string());
      m.set(F_CODIVA,     codiva);
      m.set(F_IMPOSTA,    imposta.string());
      m.set(F_TIPODET,    tipodet);
      m.set(F_TIPOCR,     tipocr);
      m.set(F_GRUPPO,     gruppo);
      m.set(F_CONTO,      conto);
      m.set(F_SOTTOCONTO, sottoc);
      
      m.disable(F_DATA74TER);
      m.disable(F_CODCF);
      m.disable(F_RAGSOCOCC);
      m.disable(F_INDOCC);
      m.disable(F_LOCALITA);
      m.disable(F_CAPOCC);
      m.disable(F_PROVOCC);
      
      m.enable(F_IMPONIBILE);
      m.enable(F_CODIVA);
      m.enable(F_IMPOSTA);
      m.enable(F_TIPODET);
      m.enable(F_TIPOCR);
      m.enable(F_GRUPPO);
      m.enable(F_CONTO);
      m.enable(F_SOTTOCONTO);
    }
  
  return TRUE;
}

bool TVar_mov::codice_registro_hnd(TMask_field& f, KEY k)
{ 
  TTable reg ("REG");
  TString descr,dep;
  
  if (k == K_TAB || k == K_ENTER)
  {              
    TString codreg = f.get();
    char    cr     = codreg[0];
    TDate   datareg (f.mask().get(F_DATAREG));
    int     anno   = date2esc(datareg);
    
    if (isdigit(cr)) 
      dep.format("%04d%03c", anno, cr);
    else
      dep.format("%04d%-3c", anno, cr);
    
    reg.zero();
    reg.put("CODTAB", dep);
    if (reg.read() == NOERR)
    {
      descr = reg.get("S0");
      f.mask().set(F_DESCRREG, descr);
    }
    else
      if (codreg.not_empty() && f.mask().is_running())
        return warning_box("Codice registro IVA non presente in tabella");                               
  } 
  
  return TRUE;
}

bool TVar_mov::codice_causale_hnd(TMask_field& f, KEY k)
{
  if (k == K_TAB || k == K_ENTER)
  {         
    TString codcau = f.get();
    
    if (f.mask().is_running())
    {
      TString codreg = f.mask().get(F_REGIVA);
      
      if (codreg.not_empty())
        if (codcau.empty())
          return warning_box("Il codice registro IVA e' significativo: deve essere significativo anche il codice causale");
    }
    
    TLocalisamfile cau (LF_CAUSALI);
    cau.setkey(1);
    cau.zero();
    cau.put("CODCAUS", codcau);
    if (cau.read() == NOERR)
    {
      const TString& descr = cau.get("DESCR");
      f.mask().set(F_DESCRCAU, descr);
    }                                 
    else           
      if (f.mask().is_running())
        return warning_box("Codice causale non presente in tabella");
  }            
  return TRUE;
}

bool TVar_mov::numero_protocollo_hnd(TMask_field& f, KEY k)
{
  if (k != K_ENTER) return FALSE;
  
  TString codreg   = f.mask().get(F_REGIVA);
  long    protiva  = atol(f.mask().get(F_PROTIVA));
  long    uprotiva = atol(f.mask().get(F_NUPROTIVA));
  
  if (codreg.empty())
    if (protiva != 0)
      return warning_box("Il codice registro IVA non e' significativo: non e' possibile compilare il numero protocollo IVA");
  
  return TRUE;    
}

bool TVar_mov::ultimo_protocollo_hnd(TMask_field& f, KEY k)
{
  if (k != K_ENTER) return FALSE;
  
  TString codreg   = f.mask().get(F_REGIVA);
  long    protiva  = atol(f.mask().get(F_PROTIVA));
  long    uprotiva = atol(f.mask().get(F_NUPROTIVA));
  
  if (codreg.empty())
    if (uprotiva != 0)  
      return warning_box("Il codice registro IVA non e' significativo: non e' possibile compilare l' ultimo numero protocollo IVA");
  
  if (protiva == 0)
    if (uprotiva != 0)
      return warning_box("Numero protocollo IVA non significativo: non e' possibile compilare il numero protocollo IVA riepilogato"); 
  
  return TRUE;    
}

bool TVar_mov::codice_pagamento_hnd(TMask_field& f, KEY k)
{ 
  TTable pag ("%CPG");
  TString descr,codpag,dep;
  
  if (k == K_TAB || k == K_ENTER)
  {              
    codpag = f.get();
    dep.format("%04s", (const char*)codpag);
    
    pag.zero();
    pag.put("CODTAB", dep);
    if (pag.read() == NOERR)
    {
      descr = pag.get("S0");
      f.mask().set(F_DESCRPAG, descr);
    }
    else
      if (codpag.not_empty() && k == K_ENTER)
        return warning_box("Codice pagamento non presente in tabella");                               
  } 
  
  return TRUE;
}

bool TVar_mov::data_stampa(TMask_field& f, KEY k)
{
  if (k != K_ENTER) return FALSE;
  
  TDate datareg (f.mask().get(F_DATAREG));                               
  const int ae = date2esc(datareg);         
  
  TLibro_giornale gio;
  gio.read(ae);  //se _ae e' zero la read considera come anno quello corrente
  
  if (datareg < gio.last_print())
    return warning_box("La data di registrazione e' minore della data di stampa del Libro Giornale");  

  TString codreg = f.mask().get(F_REGIVA);

  if (!codreg.blank()) //movimento iva (fattura)
  {
    TRegistro rg (codreg, ae);   
    
    if (datareg < rg.last_print())
      return error_box("La data di registrazione e' minore della data stampa del registro IVA");
  }
  
  return TRUE;
}

bool TVar_mov::controllo_partita(TMask_field& f, KEY k)
{
  if (k == K_TAB || k == K_ENTER)
  {
    int  gruppo = f.mask().get_int (F_GRUPPO);
    int  conto  = f.mask().get_int (F_CONTO);
    long sottoc = f.mask().get_long(F_SOTTOCONTO);
    
    TConto tc (gruppo,conto,sottoc); 
    
    TString descr = tc.descrizione();          
    f.mask().set(F_DESCRPARTITA, descr);
    
    if (k == K_ENTER)
      if (!tc.find())
        return warning_box("Sottoconto partita non presente in anagrafica Piano dei Conti oppure anagrafica Clienti / Fornitori");
  }     
  
  return TRUE; 
}

bool TVar_mov::controllo_contropartita(TMask_field& f, KEY k)
{
  if (k == K_TAB || k == K_ENTER)
  {
    int  gruppo = f.mask().get_int (F_GRUPPOC);
    int  conto  = f.mask().get_int (F_CONTOC);
    long sottoc = f.mask().get_long(F_SOTTOC);
    
    TConto tc (gruppo,conto,sottoc); 
    
    TString descr = tc.descrizione();          
    f.mask().set(F_DESCRCPARTITA, descr);
    
    if (k == K_ENTER)
      if (gruppo != 0 && conto != 0 && sottoc != 0)
        if (!tc.find())
          return warning_box("Sottoconto contropartita non presente in anagrafica Piano dei Conti oppure anagrafica Clienti / Fornitori");
  }     
  
  return TRUE; 
}

bool TVar_mov::controllo_importo(TMask_field& f, KEY k)
{
  if (k == K_ENTER)
  {
    real importo (f.mask().get(F_IMPORTO));
    char sezione = f.mask().get(F_SEZIONE)[0];
    
    if (importo == ZERO && (sezione == 'A' || sezione == 'D') )
      return warning_box("L' importo deve essere significativo");
    if (sezione == '\0' && importo != ZERO)
      return warning_box("La sezione e' nulla: l'importo non puo' essere significativo");
  }     
  
  return TRUE; 
}

bool TVar_mov::codice_clifo_hnd(TMask_field& f, KEY k)
{   
  char tipo;
  
  if (k == K_TAB || k == K_ENTER) 
  {
    long codcf = atol(f.get());
    if (app()._tiporeg == 1)
      tipo = 'C';
    else
      if (app()._tiporeg == 2)
        tipo = 'F';
    
    TConto tc (0,0,codcf,tipo);
    
    if (tc.find())
    {
      TString descr = tc.descrizione();
      f.mask().set(F_RAGSOCCF, descr);
    }                                 
    else
      if (k == K_ENTER)
        return warning_box("Campo NON VALIDO o codice non presente in archivio");
  }
  
  return TRUE;  
}

bool TVar_mov::codice_iva_hnd(TMask_field& f, KEY k)
{   
  if (k == K_TAB || k == K_ENTER) 
  {
    TString codiva = f.get();
    
    bool ok = app().decodifica_codiva(codiva);
    
    f.mask().set(F_DESCRCODIVA, app()._descr_civa);
    
    if (k == K_ENTER)
    {
      real imponibile (f.mask().get(F_IMPONIBILE));
      real imposta    (f.mask().get(F_IMPOSTA));
      
      if ( (imponibile != ZERO || imposta != ZERO) && codiva.empty() )
        return warning_box("Il codice IVA deve essere indicato obbligatoriamente");
      
      if (codiva.not_empty())
        if (!ok)
          return warning_box("Codice non presente in tabella");  
    }
  }
  
  return TRUE;  
}

bool TVar_mov::decodifica_codiva(const TString& codiva)
{
  TTable iva ("%IVA");
  TString dep;
  
  dep.format("%-4s", (const char*)codiva);
  
  iva.zero();
  iva.put("CODTAB", dep);
  if (iva.read() == NOERR)
  {
    _descr_civa = iva.get("S0");
    return TRUE;
  }  
  else        
  {
    _descr_civa = "";
    return FALSE;
  }
  
  return TRUE;
}

bool TVar_mov::imposta_hnd(TMask_field& f, KEY k)
{   
  if (k == K_ENTER) 
  {
    real imposta    (f.mask().get(F_IMPOSTA));
    
    if (app()._corrisp && imposta != ZERO)
      return warning_box("Il movimento e' relativo ad un corrispettivo: l'imposta deve essere uguale a 0");
  }
  
  return TRUE;  
}

bool TVar_mov::detraibilita_hnd(TMask_field& f, KEY k)
{   
  if (k == K_ENTER) 
  {
    int det = atoi(f.get());
    
    if (det != 0 && det != 1 && det != 3 && det != 9)
      return warning_box("Valore non ammesso per il tipo detraibilita'");
  }
  
  return TRUE;  
}

bool TVar_mov::tipocr_hnd(TMask_field& f, KEY k)
{   
  if (k == K_ENTER) 
  {
    int tcr = atoi(f.get());
    
    if (tcr != 0 && tcr != 1 && tcr != 2 && tcr != 3 
        && tcr != 4 && tcr != 5 && tcr != 8 && tcr != 9)
      return warning_box("Valore non ammesso per il tipo costo/ricavo");
  }
  
  return TRUE;  
}

void TVar_mov::registra_PN(TMask& m)
{ 
  if (!_righe)
  {
    long    numreg    = m.get_long(F_NUMREG);
    int     annorif   = m.get_int (F_ANNO);
    TDate   datareg (m.get(F_DATAREG));
    TDate   datadoc (m.get(F_DATADOC));
    TString numdoc    = m.get     (F_NUMDOC);
    TString regiva    = m.get     (F_REGIVA);
    long    protiva   = m.get_long(F_PROTIVA);
    long    nuprotiva = m.get_long(F_NUPROTIVA);
    TString codcaus   = m.get     (F_CODCAUS);
    TString codpag    = m.get     (F_CODPAG);
    
    registra_file_temp_mov(numreg,datareg,datadoc,numdoc,regiva,protiva,nuprotiva,codcaus,codpag);
    registra_file_trasfer_t(numreg,annorif,datareg,datadoc,numdoc,regiva,protiva,nuprotiva,codcaus,codpag);
  }
  else
    if (_righe)
    {                                    
      long    numreg   = m.get_long(F_NUMREG);
      int     numrig   = m.get_int (F_NUMRIG);
      int     gruppo   = m.get_int (F_GRUPPO);
      int     conto    = m.get_int (F_CONTO);      
      long    sottoc   = m.get_long(F_SOTTOCONTO);
      char    sezione  = m.get     (F_SEZIONE)[0];
      TString descr    = m.get     (F_DESCR);
      int     gruppoc  = m.get_int (F_GRUPPOC);
      int     contoc   = m.get_int (F_CONTOC);
      long    sottocc  = m.get_long(F_SOTTOC);
      real    importo  (m.get(F_IMPORTO));  
      
      registra_file_temp_rmov(numreg,numrig,gruppo,conto,sottoc,sezione,descr,gruppoc,contoc,sottocc,importo);
      registra_file_trasfer_r(numreg,numrig,gruppo,conto,sottoc,sezione,descr,gruppoc,contoc,sottocc,importo);
    }
}

void TVar_mov::registra_file_temp_mov(long nr,const TDate& dr,const TDate& dd,const TString& nd,TString& ri,
                                      long pi,long upi,const TString& cc,TString& cp)
{
  _tmov->setkey(1);
  _tmov->zero();
  _tmov->put(MOV_NUMREG, nr);
  if (_tmov->read() == NOERR)
  {
    _tmov->put(MOV_DATAREG,  dr);
    _tmov->put(MOV_DATADOC,  dd);
    _tmov->put(MOV_NUMDOC,   nd);  
    _tmov->put(MOV_REG,      ri);
    _tmov->put(MOV_PROTIVA,  pi);
    _tmov->put(MOV_UPROTIVA, upi);
    _tmov->put(MOV_CODCAUS,  cc);
    _tmov->put(MOV_CODPAG,   cp);
    
    _tmov->rewrite();
  }
}

void TVar_mov::registra_file_trasfer_t(long nr,int ar,const TDate& dr,const TDate& dd,const TString& nd,TString& ri,
                                       long pi,long upi,const TString& cc,const TString& cp)
{   
  TString app,str;
  TRectype* rec;
  rec = new TRectype (LF_RMOV);
  
  _trmov->setkey(1);
  _trmov->zero();
  _trmov->put(RMV_NUMREG, nr); 
  *rec = _trmov->curr();
  
  for (_trmov->read(); !_trmov->eof(); _trmov->next())
  {
    if (_trmov->curr() > *rec) break;
    
    long numrec = _trmov->get_int(RMV_ANNOES);
    numrec += _tras_file.start('Z');
    
    _tras_file.read_rec_trasfer(numrec); //Leggo il record della prima nota
    
    app = dr.string();
    str = riconverti(app);
    _tras_file.put(str,"Z1",0,numrec);
    app = dd.string();
    str = riconverti(app);
    _tras_file.put(str,"Z1",4,numrec);
    str = format("%d", ar);
    _tras_file.put(str,"Z1",50,numrec);
    str = format("%-7s", (const char*) nd);
    _tras_file.put(str,"Z1",5,numrec);
    if (ri == "")
      ri = " ";
    _tras_file.put(ri,"Z1",6,numrec);
    _tras_file.put(cc,"Z1",8,numrec);
    str = format("%05ld", pi);
    _tras_file.put(str,"Z1",7,numrec);
    str = format("%05ld", upi);
    _tras_file.put(str,"Z1",10,numrec);  
    str = format("%2s", (const char*) cp);
    _tras_file.put(str,"Z1",9,numrec);
    
    _tras_file.write(numrec);
  }
  
  delete rec;
}

void TVar_mov::registra_file_temp_rmov(long nr,int nri,int g,int c,long s,char sez,const TString& desc,
                                       int gc,int cc,long sc,const real& imp)
{
  _trmov->setkey(1);
  _trmov->zero();
  _trmov->put(RMV_NUMREG, nr);
  _trmov->put(RMV_NUMRIG, nri);  
  if (_trmov->read() == NOERR)
  {
    _trmov->put(RMV_GRUPPO,      g);
    _trmov->put(RMV_CONTO,       c);
    _trmov->put(RMV_SOTTOCONTO,  s);
    _trmov->put(RMV_SEZIONE,     sez);
    _trmov->put(RMV_DESCR,       desc);
    _trmov->put(RMV_GRUPPOC,     gc);
    _trmov->put(RMV_CONTOC,      cc);
    _trmov->put(RMV_SOTTOCONTOC, sc);
    _trmov->put(RMV_IMPORTO,     imp);     
    
    _trmov->rewrite();
  }
}

void TVar_mov::registra_file_trasfer_r(long nr,int nri,int g,int c,long s,char sez,const TString& desc,
                                       int gc,int cc,long sc,const real& imp)
{
  TString app,str;
  
  _trmov->setkey(1);
  _trmov->zero();
  _trmov->put(RMV_NUMREG, nr); 
  _trmov->put(RMV_NUMRIG, nri);
  
  if (_trmov->read() == NOERR)
  {
    long numrec = _trmov->get_int(RMV_ANNOES);
    numrec += _tras_file.start('Z');
    
    _tras_file.read_rec_trasfer(numrec); //Leggo il record della prima nota
    
    str = format("%02d", g);                     
    _tras_file.put(str,"Z1",17,numrec);
    str = format("%02d", c);
    _tras_file.put(str,"Z1",18,numrec);
    str = format("%06ld", s);
    _tras_file.put(str,"Z1",19,numrec);
    str = format("%c", sez);
    _tras_file.put(str,"Z1",20,numrec);
    str = format("%-30s", (const char*)desc);
    _tras_file.put(str,"Z1",16,numrec);
    str = format("%02d", gc);
    _tras_file.put(str,"Z1",21,numrec);
    str = format("%02d", cc);
    _tras_file.put(str,"Z1",22,numrec);
    str = format("%06ld", sc);
    _tras_file.put(str,"Z1",23,numrec);
    str = format("%011s", (const char*) imp.string());
    _tras_file.put(str,"Z1",24,numrec);
    
    _tras_file.write(numrec);
  }
}

void TVar_mov::registra_IVA(TMask& m)
{ 
  if (!_righe)
  {
    long    numreg    = m.get_long(F_NUMREG);
    TDate   data74ter  (m.get(F_DATA74TER));
    long    codcf     = m.get_long(F_CODCF);
    TString ragsococc = m.get     (F_RAGSOCOCC);
    TString indocc    = m.get     (F_INDOCC);
    TString localita  = m.get     (F_LOCALITA);
    TString capocc    = m.get     (F_CAPOCC);
    TString provocc   = m.get     (F_PROVOCC);
    
    _tmov->setkey(1);
    _tmov->zero();
    _tmov->put(MOV_NUMREG, numreg);
    if (_tmov->read() == NOERR)
    {
      _tmov->put(MOV_DATA74TER, data74ter);
      _tmov->put(MOV_CODCF,     codcf);
      
      _tmov->rewrite();
    }

    registra_file_trasfer_t_iva(numreg,data74ter,codcf,ragsococc,indocc,localita,capocc,provocc);
  }
  else
    if (_righe)
    {                                    
      long    numreg    = m.get_long(F_NUMREG);
      int     numrig    = m.get_int (F_NUMRIG);
      real    imponibile (m.get     (F_IMPONIBILE));
      TString codiva    = m.get     (F_CODIVA);      
      real    imposta    (m.get     (F_IMPOSTA));
      int     tipodet   = m.get_int (F_TIPODET);
      int     tipocr    = m.get_int (F_TIPOCR);
      int     gruppo    = m.get_int (F_GRUPPO);
      int     conto     = m.get_int (F_CONTO);
      long    sottoc    = m.get_long(F_SOTTOCONTO);
      
      registra_file_temp_riva(numreg,numrig,imponibile,codiva,imposta,tipodet,tipocr,gruppo,conto,sottoc);
      registra_file_trasfer_r_iva(numreg,numrig,imponibile,codiva,imposta,tipodet,tipocr,gruppo,conto,sottoc);
    }
}

void TVar_mov::registra_file_trasfer_t_iva(long nr,const TDate& d74,long cf,const TString& rgo,const TString& io,
                                           const TString& lo,const TString& co,const TString& po)
{   
  TString app,str;
  TRectype* rec;
  rec = new TRectype (LF_RMOVIVA);
  
  _tiva->setkey(1);
  _tiva->zero();
  _tiva->put(RMI_NUMREG, nr); 
  *rec = _tiva->curr();
  
  for (_tiva->read(); !_tiva->eof(); _tiva->next())
  {
    if (_tiva->curr() > *rec) break;
    
    long numrec = _tiva->get_int(RMI_ANNOES);
    numrec += _tras_file.start('U');
    
    _tras_file.read_rec_trasfer(numrec); //Leggo il record della prima nota
    
    app = d74.string();
    str = riconverti(app);
    _tras_file.put(str,"U1",4,numrec);
    str = format("%06d", cf);
    _tras_file.put(str,"U1",6,numrec);
    str = format("%-25s", (const char*)rgo );
    _tras_file.put(str,"U1",50,numrec);
    str = format("%-22s", (const char*)io);
    _tras_file.put(str,"U1",51,numrec);
    str = format("%-18s", (const char*)lo);
    _tras_file.put(str,"U1",52,numrec);  
    str = format("%05s", (const char*)co );
    _tras_file.put(str,"U1",53,numrec);
    str = format("%-2s", (const char*)po);
    _tras_file.put(str,"U1",54,numrec);
    
    _tras_file.write(numrec);
  }
  
  delete rec;
}

void TVar_mov::registra_file_temp_riva(long nr,int nri,const real& imp,const TString& civa,const real& imposta,
                                       int tdet,int tcr,int g,int c,long s)
{
  _tiva->setkey(1);
  _tiva->zero();
  _tiva->put(RMI_NUMREG, nr);
  _tiva->put(RMI_NUMRIG, nri);  
  if (_tiva->read() == NOERR)
  {
    _tiva->put(RMI_IMPONIBILE, imp);
    _tiva->put(RMI_CODIVA,     civa);
    _tiva->put(RMI_IMPOSTA,    imposta);
    _tiva->put(RMI_TIPODET,    tdet);
    _tiva->put(RMI_TIPOCR,     tcr);
    _tiva->put(RMI_GRUPPO,     g);
    _tiva->put(RMI_CONTO,      c);
    _tiva->put(RMI_SOTTOCONTO, s);
    
    _tiva->rewrite();
  }
}                                       

void TVar_mov::registra_file_trasfer_r_iva(long nr,int nri,const real& imp,const TString& civa,const real& imposta,
                                           int tdet,int tcr,int g,int c,long s)
{
  TString app,str;
  
  _tiva->setkey(1);
  _tiva->zero();
  _tiva->put(RMI_NUMREG, nr); 
  _tiva->put(RMI_NUMRIG, nri);
  
  if (_tiva->read() == NOERR)
  {
    long numrec = _tiva->get_int(RMI_ANNOES);
    numrec += _tras_file.start('U');
    
    _tras_file.read_rec_trasfer(numrec); //Leggo il record dell' iva
    
    str = format("%011s", (const char*) imp.string());                     
    _tras_file.put(str,"U1",14,numrec);
    str = format("%02s", (const char*) civa);
    _tras_file.put(str,"U1",13,numrec);
    str = format("%09s", (const char*) imposta.string());
    _tras_file.put(str,"U1",15,numrec);
    str = format("%d", tdet);
    _tras_file.put(str,"U1",16,numrec);
    str = format("%d", tcr);
    _tras_file.put(str,"U1",17,numrec);
    str = format("%02d", g);
    _tras_file.put(str,"U1",19,numrec);
    str = format("%02d", c);
    _tras_file.put(str,"U1",20,numrec);
    str = format("%06ld", s);
    _tras_file.put(str,"U1",21,numrec);
    
    _tras_file.write(numrec);
  }
}                                           

bool TVar_mov::leggi_trasfer()
{ 
  _trasf = _tras_file.path(_dittaric);
  _trasf << "\\trasfer";
  
  _tras_file.open(_trasf);
  
  if (_tras_file.exist())
  {  
    if (_tras_file.read_control_rec())
      _control_rec = _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 TVar_mov::esegui_controlli()
{                    
  TConfig conf(CONFIG_DITTA);           
  
  _std = conf.get("FlStTra");

  if (!prefix().exist(_dittaric))
    return error_box("Rilevati gravi errori negli archivi: procedura interrotta");
  
  if (!leggi_trasfer())
    return FALSE;

  if (!controlli())
    return FALSE;     
  
  return TRUE;
}

void TVar_mov::setta_parametri_record(const TString& sigla,const TString& flag)
{ 
  TConfig conf (CONFIG_DITTA);
  
  conf.set("FlStTra", flag);
  
  leggi_record_controllo();
  _control_rec.overwrite(sigla,240);
  
  const int size = 256;
  
  _tras_file.write_control_rec(_control_rec, size);
}

bool TVar_mov::controlli()
{ 
  if (_std == "T")
    return error_box("Variazione NON POSSIBILE: eseguire prima la ricezione delle tabelle");           

  if (_std == "M")
    return error_box("Variazione NON POSSIBILE: trasferimento movimenti gia' iniziato");           
  
  if (_std == "*") 
  {
    warning_box("Trasferimento interamente completato: proseguire per cancellare il file");    
    fremove(_trasf);
    return FALSE;
  }
  
  return TRUE;
}

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

int cg2800 (int argc, char* argv[])
{                                
  switch (*argv[2])
  {
  case 'P':
  {
    TVar_mov main_app(*argv[2]);       
    main_app.run(argc, argv,main_app._titolo);
  }
  break;
 case 'I':
{
  TVar_mov main_app(*argv[2]);       
  main_app.run(argc, argv,main_app._titolo);
}
break;
 case 'S':
{   
  TDitta_ric a;       
  a.run(argc, argv,"Scelta ditta per ricezione");
}
break;
 case 'A':
{   
  TAnn_mov a;       
  a.run(argc, argv,"Annullamento movimenti da ricevere");
}
break;
 case 'V':
{   
  TVis_ric a;       
  a.run(argc, argv,"Visualizzazione stato ricezione");
}
break;    
default:
break;
}
//main_app.run(argc, argv,main_app._titolo);
return TRUE;
}
