#include <fstream.h>       

#include <applicat.h>
#include <mask.h>                     
#include <progind.h>
#include <recarray.h>
#include <relation.h> 
#include <scanner.h>
#include <sheet.h>                    
#include <tabutil.h>
#include <text.h>
#include <mask.h>                     
#include <sheet.h>
#include <utility.h>

#include "quadrif.h"
#include "quadroe2.h"
#include "quadrog.h"
#include "quadrogp.h" 
#include "77cnva.h"

#define usage "Errore - uso : 77cnv [0|1|2|3|4|5|6|7|8|9] 0"
#define G_DUMP "quadrog.dmp" // File di scarico del quadro G 
#define CNV_LOG "C770log.txt" // File di log della conversione

// struttura completa riga di pagamento
struct Pag_struct
{
  TDate datapag;
  real imponibile;
  real perc;
  real ritenuta;
  real compenso;
  real netto;
  long numvers;
  real spesa;
  real ctssnperc;
  real ctssncomp;
  real ritlorda;
  real controbb;
  real detfamil;
  real detlavdip;
  real totdet;
  int giolavdip;
  real impcpa;
  real somregconv;
  real alqimp10;
  TString16 cod10;
  real utpagati;
  real utspett;
  real ritutpag;
  real ritutspe; 
  real nquote;  
  real somnsrit;
  real ammlordo;
  real quotaprov;
  real impnetto;
  real comnetto;
};    

// posizione flag quadri compilati 
enum {A,A1,A2,A3,B,B1,C,D,D1,E,E1,E2,F,F1,F2,G,G1,H,I,L,N,P,Q,R,S,T,AB,DB,U};
  
// Items per causale quadro D
const int NUM_ITEMS_D = 1;  
const char* ITEMS_D[] = {          
  "L|prestaz. di lavoro autonomo non esercitate abitualmente"};
  
// Items per causale quadro Dbis
const int NUM_ITEMS_DB = 2;  
const char* ITEMS_DB[] = {
  "A|prestaz. di lav. auton. ..... iscritti in albi senza cassa",
  "T|altro titolo diverso dai precedenti"};    
  
// Items per causale quadro E
const int NUM_ITEMS_E = 5;  
const char* ITEMS_E[] = {
  "A|redditi di capitale corrisp. a sogg. resid. non eserc......",
  "B|prov. corrisp. a stabili organiz. estere di impr. resid....",
  "C|comp. per avviamento commerc. assogg. alla rit. a tit. acc.",
  "D|contrib. degli enti pubbl. e premi corrisp. dall'Unione....", 
  "E|interessi, premi e altri frutti dei tit. obbligaz. emessi.."};   

// Items per causale quadro E1
const int NUM_ITEMS_E1 = 4;  
const char* ITEMS_E1[] = {
  "A|somme deriv. dal riscatto di contratti di assic. sulla vita",
  "B|capitali corrisp. in dipend... per i quali rit. del 12,50..",
  "C|capitali corrisp. in dipend. di contr. di assic. sulla vita",
  "D|capitali corrisp. in dipend. di contr. di capitalizzazione"};     

class TConvert_app : public TApplication
{      
  int _conv;                          
  TTextfile* _M770_log;
  
protected:
  virtual bool create();
  
  bool dump_quadro_f1() const; // Funzioni per convertire quadro F/F1
  bool load_quadro_f1() const;  
  bool convert_e2() const;
  bool convert_f() const;
  bool convert_f2() const;
  bool dump_quadro_g() const; // Funzioni per convertire quadro G
  bool load_quadro_g() const;  
  bool cnv_ca7_971() const; // conversione causali
  bool cnv_quadroA_971() const; // conversione quadro A
  bool cnv_quadroAB_971() const; // conversione quadro Abis  
  bool cnv_quadroA2_971() const; // conversione quadro A2 
  bool cnv_basebis_971() const; // conversione basebis     
  bool cnv_schede_971() const; // conversione schede percipiente 
  bool cnv_schede_man1_971() const; // conversione manuale schede percipiente 
  bool cnv_schede_man2_971() const; // conversione manuale schede percipiente
  
  // azzera struttura pagamento
  Pag_struct& clear_struct(Pag_struct& s) const; 
  
  // calcola una riga di pagamento dove <s> è la struttura con i dati,
  // <c> è la struttura con i calcolati per eventuali controlli,
  // <force> consente di forzare la sostituzione dei valori di riga
  // con i calcolati anche se sono diversi da zero
  Pag_struct& calcola_riga_pag(Pag_struct& s,
                               Pag_struct& c,
                               bool force,
                               const real h_PercAssImp,
                               const real h_PercCassaPrev,
                               const real h_PercRitenuta,
                               const real h_PercInps,
                               const real h_PercAssImpInps,
                               const real h_PercCommitInps) const;   
  
  // costruisce sheet con schede aventi prerequisiti di conversione
  bool choicesheet(const long codditta, const TString& codcaus, const TString& codqua, const TString& causqua) const;
  
  // handler maschera principale conversione cnv_schede_man2_971
  static bool F_CODCAUS_handler(TMask_field& f, KEY k);
  
  // ricalcolo complessivo schede
  void totalrecalc() const;

public:
  TConvert_app(int conv) : _conv(conv) { }
  virtual ~TConvert_app() { }
};

inline TConvert_app& app() { return (TConvert_app&) main_app(); }

bool TConvert_app::create()
{
  const long f = (argc() > 2) ? atol(argv(2)) : -1;
  if (f != 0)
    return FALSE;

  // istanza file di log
  _M770_log = new TTextfile(CNV_LOG);  

  switch(_conv)
  {
  // Numeri liberi per conversioni di Luciano;          
  case 0 : cnv_ca7_971(); cnv_basebis_971(); break; 
  case 1 : cnv_quadroA_971(); cnv_quadroAB_971();  cnv_quadroA2_971(); break;
  case 2 : cnv_schede_971(); break;    
  case 4 : convert_e2(); convert_f(); convert_f2(); break;
  case 5 : dump_quadro_g(); break; // Scarica alcuni campi del quadro G da trasportare sulle righe
  case 6 : load_quadro_g(); break; // Ricarica gli stessi sulle righe del quadro G
  case 7 : cnv_schede_man1_971(); break;             
  case 8 : cnv_schede_man2_971(); break;      
  case 9 : dump_quadro_f1(); break;
  default:break;
  }   
  
  // libera istanza file di log
  delete _M770_log;

  return FALSE;
}

bool TConvert_app::convert_e2() const
{                      
  TLocalisamfile righe_e2(LF_QUAE2);
  TProgind pi(righe_e2.items(), "Conversione quadro E2", FALSE, TRUE, 60);
  
  TDecoder causali("%CA7");

  TRectype& cur =  righe_e2.curr();
  for (int err = righe_e2.first(); err == NOERR; err = righe_e2.next())
  {                              
    pi.addstatus(1);
    const TString& desc = causali.decode(cur.get(QE2_CODCAUS));
    cur.put(QE2_DENCAUS, desc.left(50));       
    int ee = righe_e2.rewrite();
    if (ee != NOERR)
    {
      const long ditta = cur.get_long(QE2_CODDITTA);
      const int riga = cur.get_int(QE2_NPROG);
      error_box("Impossibile aggiornare la riga %d del quadro E2\n"
                "della ditta %ld: errore %d", riga, ditta, ee);    
    }            
  }
  
  return TRUE;
}

bool TConvert_app::dump_quadro_f1() const 
{   
  TToken_string str;
  TLocalisamfile quadrof1(LF_QUAF1);

  TFilename f; f.tempdir(); f.add("quaf1.txt");
  ofstream ofs(f);
  
  TProgind pi(quadrof1.items(), "Conversione quadro F1 - Scarico dati in corso...", FALSE, TRUE, 60);
  for (int err = quadrof1.first(); err == NOERR; err = quadrof1.next())
  {
    pi.addstatus(1);
    str.cut(0);
    str.add(quadrof1.get("CODDITTA"));
    str.add(quadrof1.get("F1_A1"));
    str.add(quadrof1.get("F1_A2"));
    ofs << str << endl;
  } 
  return TRUE; 
}

bool TConvert_app::load_quadro_f1() const 
{   
  TFilename f; f.tempdir(); f.add("quaf1.txt");
  if (!fexist(f))
    return FALSE;
    
  TProgind pi(1, "Conversione quadro F - Caricamento prospetto F...", FALSE, FALSE, 60);
  TScanner osf(f);

  TToken_string str;
  TLocalisamfile righef(LF_RIGHEF);

  while (osf.line().not_empty())
  {
    str = osf.token();
    righef.zero();
    long ditta = str.get_long(0);
    righef.put("CODDITTA", ditta);
    righef.put("TIPOPRO", "F");
    righef.put("NPROG", "1");
    righef.put("SOGRIT", str.get());
    righef.put("ROPE", str.get());
    int err = righef.write();
    if (err != NOERR)
        error_box("Impossibile creare la riga del prospetto F\n"
                  "della ditta %ld: errore %d", ditta, err);    
  }  
  remove(f);
  return TRUE;
}

bool TConvert_app::convert_f() const
{
  TLocalisamfile quadro_f(LF_QUAF);
  TLocalisamfile righe_f(LF_RIGHEF);
  TRectype& cur = righe_f.curr();
  
  TProgind pi(quadro_f.items(), "Conversione quadro F", FALSE, TRUE, 60);

  TDecoder causali("%CA7");
  
  for (int err = quadro_f.first(); err == NOERR; err = quadro_f.next())
  {
    pi.addstatus(1);
    const real e_aliq = quadro_f.get("E_ALIQUOTA");
    
    if (e_aliq < 0.0)
    {
      // gia' stata convertita!
      continue;
    }
    
    const long ditta = quadro_f.get_long(QUF_CODDITTA);
    cur.zero();
    cur.put(QUF_CODDITTA, ditta);
    for (int e = righe_f.read(_isgteq); e == NOERR; e = righe_f.next())
    {
      if (cur.get_long(QUF_CODDITTA) != ditta)
        break;

      const TString& desc = causali.decode(cur.get("CODCAUS"));
      cur.put("DENCAUS", desc.left(50));       

      const char prosp = toupper(cur.get_char("TIPOPRO"));
      const int riga = cur.get_int("NPROG");

      if (prosp >= 'B' && prosp <= 'D')
      {                        
        const char newprosp = prosp-1;
        cur.put("TIPOPRO", newprosp);
        err = righe_f.write();
        if (err != NOERR)
        {
          error_box("Impossibile creare la riga %d del prospetto %c\n"
                    "della ditta %ld: errore %d", riga, newprosp, ditta, err);    
        }
      }
      cur.put("TIPOPRO", prosp);
      if (err == NOERR)
      {
        int err = righe_f.remove(); 
        if (err != NOERR)
        {
          error_box("Impossibile eliminare la riga %d del prospetto %c\n"
                    "della ditta %ld: errore %d", riga, prosp, ditta, err);    
          break;          
        }
      }
      else
        err = righe_f.reread();
    }
    
    const real e_cambiali = quadro_f.get("E_CAMBIALI");
    const real e_sogrit =   quadro_f.get("E_SOGRIT");
    const real e_rope =     quadro_f.get("E_ROPE");
    if (e_cambiali != ZERO || e_sogrit != ZERO || 
        e_aliq != ZERO || e_rope != ZERO)
    {    
      righe_f.zero();
      righe_f.put("CODDITTA", ditta);
      righe_f.put("TIPOPRO", "D");
      righe_f.put("NPROG", "1");
      righe_f.put("IMPCAMB", e_cambiali);
      righe_f.put("ALIQUOTA", e_aliq);
      righe_f.put("SOGRIT", e_sogrit);
      righe_f.put("ROPE", e_rope);
      int ed = righe_f.write();
      if (ed != NOERR)         
        error_box("Impossibile creare la riga del prospetto D\n"
                  "della ditta %ld: errore %d", ditta, ed);    
    }
    
    const real f_aliq = quadro_f.get("F_ALIQUOTA");
    const real f_sogrit = quadro_f.get("F_SOGRIT");
    const real f_rope =   quadro_f.get("F_ROPE");
    if (f_aliq != ZERO || f_sogrit != ZERO || f_rope != ZERO)
    {
      righe_f.zero();
      righe_f.put("CODDITTA", ditta);
      righe_f.put("TIPOPRO", "E");
      righe_f.put("NPROG", "1");
      righe_f.put("ALIQUOTA", f_aliq);
      righe_f.put("SOGRIT", f_sogrit);
      righe_f.put("ROPE", f_rope);
      int ee = righe_f.write();
      if (ee != NOERR)         
        error_box("Impossibile creare la riga del prospetto E\n"
                  "della ditta %ld: errore %d", ditta, ee);    
    } 
                     
    // Marca la ditta come convertita
    quadro_f.put("E_ALIQUOTA", -1);
    quadro_f.rewrite();
  }        

  // Carica nel prospetto f le testate del vecchio quadro f1 
  // Vale per tutte le ditte contemporaneamente
  load_quadro_f1();
  
  return TRUE;
}

bool TConvert_app::convert_f2() const
{                      
  TLocalisamfile righe_f2(LF_RIGHEF2);
  TProgind pi(righe_f2.items(), "Conversione quadro F2", FALSE, TRUE, 60);
  
  TDecoder causali("%CA7");

  TRectype& cur =  righe_f2.curr();
  for (int err = righe_f2.first(); err == NOERR; err = righe_f2.next())
  {
    pi.addstatus(1);
    const long ditta = cur.get_long("CODDITTA");
    
    const char oldtipo = cur.get_char("TIPOPRO");
    if (oldtipo != 'A')
    {                                   
      const int riga = cur.get_int("NPROG");

      cur.put("TIPOPRO", "A");
      const TString& desc = causali.decode(cur.get("CODCAUS"));
      cur.put("DENCAUS", desc.left(50));       
      int ee = righe_f2.write();
      if (ee == NOERR)
      {   
        cur.put("TIPOPRO", oldtipo);
        ee = righe_f2.remove();   
        if (ee != NOERR)
        {
          error_box("Impossibile eliminare la riga %d del quadro F2\n"
                    "della ditta %ld: errore %d", riga, ditta, ee);    
        }
      }
      else
      {                       
          error_box("Impossibile creare la riga %d del quadro F2\n"
                    "della ditta %ld: errore %d", riga, ditta, ee);    
      }
    }
  }
  
  return TRUE;
}

/////////////////////////////////////////////////////////////////////////////////
// Scarico dei campi del prospetto 1 sez I e II da riportare sulle righe quadro G
/////////////////////////////////////////////////////////////////////////////////
bool TConvert_app::dump_quadro_g() const 
{
  TFilename f;
  TLocalisamfile quadrog(LF_QUAG);
  TToken_string t;
  TString16 fld1,fld2,fld3,fld4;
  TString s1,s2,s3,s4;
  int err;

  f.tempdir();
  f << "/" << G_DUMP;
  ofstream ofs(f);
  
  TProgind pi(quadrog.items(), "Conversione quadro G - Scarico dati in corso...", FALSE, TRUE, 60);
  for (err = quadrog.first(); err == NOERR; err = quadrog.next())
  {
    pi.addstatus(1);
    const long ditta = quadrog.get_long("CODDITTA");
    int riga_1 = 1, riga_2 = 1;
    fld3 = "P1AMMQx"; fld4 = "P1AMMx";
    for (int i = 1; i<=4; i++)
    {
      fld1 = "P1DATADx"; fld2 = "P1NUMQx";      // Prospetto 1 sez I
      fld1.rtrim(1);  fld1 << i;
      fld2.rtrim(1);  fld2 << i;
      fld3.rtrim(1);  fld3 << i;
      fld4.rtrim(1);  fld4 << i;
      s1 = quadrog.get(fld1);
      s2 = quadrog.get(fld2);
      s3 = quadrog.get(fld3);
      s4 = quadrog.get(fld4); 
      if (s1.not_empty() || s2.not_empty() || s3.not_empty() || s4.not_empty())
      { // Se tutti vuoti non scrive la riga
        t = "";
        t.add(ditta);
        t.add("1"); t.add("1");t.add(riga_1++);
        t.add(s1);
        t.add(s2);
        t.add(s3);
        t.add(s4);
        t << "\n";
        ofs << t;
      }
      
      if (i < 4)
      {
        fld1 = "P2DESCx"; fld2 = "P2VALx"; // Prospetto 1 sez II
        fld1.rtrim(1);  fld1 << i;
        fld2.rtrim(1);  fld2 << i;
        s1 = quadrog.get(fld1);
        s2 = quadrog.get(fld2);
        if (s1.not_empty() || s2.not_empty())
        { // Se tutti vuoti non scrive la riga
          t = "";
          t.add(ditta);
          t.add("1"); t.add("2");t.add(riga_2++);
          t.add(s1);
          t.add(s2);
          t << "\n";
          ofs << t;
        }
      }
    }
  }
  return TRUE;
}

/////////////////////////////////////////////////////////////////////////////////
// Carico dei campi del prospetto 1 sez I e II da riportare sulle righe quadro G
/////////////////////////////////////////////////////////////////////////////////
bool TConvert_app::load_quadro_g() const
{
  TFilename f;
  f.tempdir();
  f << "/" << G_DUMP;
  if (fexist(f))
  {
    TLocalisamfile quadrogp(LF_QUAGP);
    TToken_string t;
    char buffer[256];
    ifstream ifs(f);
    int err;
    TProgind pi(1, "Conversione quadro G - Caricamento righe in corso...", FALSE, FALSE, 60);
    while (ifs.good())
    {
      ifs.getline(buffer,256,'\n');
      t = buffer;
      if (t.empty_items()) break;
      quadrogp.zero();
      quadrogp.put(QGP_CODDITTA,t.get(0));
      quadrogp.put(QGP_PROSPETTO,t.get(1));
      const char sez = t.get_char(2);
      quadrogp.put(QGP_SEZIONE,sez);
      quadrogp.put(QGP_NPROG,t.get(3));
      if (sez ==  '1')
      {
        quadrogp.put(QGP_DATADEL,t.get(4));
        quadrogp.put(QGP_NUMQUOTE,t.get(5));
        quadrogp.put(QGP_UTILI1S,t.get(6));
        quadrogp.put(QGP_UTILI2S,t.get(7));
      }
      else
      {
        quadrogp.put(QGP_DESCRBENI,t.get(4));
        quadrogp.put(QGP_UTILI1S,t.get(5));
      }
      err = quadrogp.write();
      if (err == _isreinsert)
        err = quadrogp.rewrite();
      if (err != NOERR)
        error_box("Errore %d cercando di caricare le righe del quadro G.",err);
    }
  }
  remove(f); // Let's ignore if the file exists or not
  return TRUE;
}


///////////////////////////////////////////////////////////
// Conversione tabella causali versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_ca7_971() const
{  
  // titolo log                                    
  char now[9];
  TDate today(TODAY);  
  TString log_title("[Log Conversione Causali : ");
  log_title << today << " " << _strtime(now) << "]  Prassi SpA";               
  _M770_log->append(log_title); 
  TString log_space(" ");
  _M770_log->append(log_space); 

  // conversione tabella
  TTable ca7("%CA7");  
  TProgind pi(ca7.items(), "Conversione tabella causali", FALSE, FALSE, 60);
  for (ca7.first(); ca7.good(); ca7.next())
  {    
    // lettura campi soggetti a modifica
    TString old_cod = ca7.get("CODTAB"); 
    TString cod_qua = ca7.get("S1");// codice quadro
    bool fl_Inps = ca7.get_bool("B4");// soggetto contributo Inps     
    bool fl_CT = ca7.get_bool("B2");// flag C.T.
    bool fl_TS = ca7.get_bool("B3");// flag T.S.
    char caus_C = ca7.get_char("S6");// causale quadro C
    char caus_D = ca7.get_char("S2");// causale quadro D
    char caus_D1 = ca7.get_char("S3");// causale quadro D1
    char caus_DB = ca7.get_char("S7");// causale quadro DB    
    char caus_E = ca7.get_char("S8");// causale quadro E    
    char caus_E1 = ca7.get_char("S9");// causale quadro E1
    real ass_imp_Inps = ca7.get_real("R2");// assoggettamento imponibile Inps 
    real Perc_Inps = ca7.get_real("R1");// percentuale contributo Inps 
    real Perc_Comm_Inps = ca7.get_real("R3");// percentuale contributo Inps committente
    
    // salvo flag Inps per sapere se pulire i campi ad esso legato
    bool old_fl_Inps = fl_Inps;
    
    // conversione causale quadro D
    switch(caus_D)
    {
      case 'A':
        if (fl_Inps)
        {
          cod_qua = "DB";
          caus_DB = 'A';
          caus_D = ' ';
        }
        break;
      case 'T':
        if (fl_Inps)
        {
          cod_qua = "DB";
          caus_DB = 'T';
          caus_D = ' ';
        }
        break;    
      case 'E':
        if (!fl_Inps)       
          caus_D = 'M';  
        else   
        {
          TString log_line; 
          log_line << old_cod << ": ";
          log_line << "causale quadro D: -E- con flag contributo Inps";
          _M770_log->append(log_line);  
        }
        break;
      case 'G':
        if (!fl_Inps)       
          caus_D = 'B';
        else   
        {
          TString log_line; 
          log_line << old_cod << ": ";
          log_line << "causale quadro D: -G- con flag contributo Inps";
          _M770_log->append(log_line);  
        } 
        break;
      case 'H':
        if (!fl_Inps)       
          caus_D = 'C';
        else   
        {
          TString log_line; 
          log_line << old_cod << ": ";
          log_line << "causale quadro D: -H- con flag contributo Inps";
          _M770_log->append(log_line);  
        }
        break;      
      case 'I':
        if (!fl_Inps)       
          caus_D = 'D';
        else   
        {
          TString log_line; 
          log_line << old_cod << ": ";
          log_line << "causale quadro D: -I- con flag contributo Inps";
          _M770_log->append(log_line);  
        }
        break;       
      case 'L':
        if (!fl_Inps)       
          caus_D = 'E';
        else   
        {
          TString log_line; 
          log_line << old_cod << ": ";
          log_line << "causale quadro D: -L- con flag contributo Inps";
          _M770_log->append(log_line);  
        }
        break;       
      case 'M':
        if (!fl_Inps)       
          caus_D = 'F';
        else   
        {
          TString log_line; 
          log_line << old_cod << ": ";
          log_line << "causale quadro D: -M- con flag contributo Inps";
          _M770_log->append(log_line);  
        }
        break;       
      case 'P':
        if (!fl_Inps)       
          caus_D = 'G';
        else   
        {
          TString log_line; 
          log_line << old_cod << ": ";
          log_line << "causale quadro D: -P- con flag contributo Inps";
          _M770_log->append(log_line);  
        }
        break;       
      case 'Q':
        if (!fl_Inps)       
          caus_D = 'H';
        else   
        {
          TString log_line; 
          log_line << old_cod << ": ";
          log_line << "causale quadro D: -Q- con flag contributo Inps";
          _M770_log->append(log_line);  
        }
        break;       
      case 'R':
        if (!fl_Inps)       
          caus_D = 'N';
        else   
        {
          TString log_line; 
          log_line << old_cod << ": ";
          log_line << "causale quadro D: -R- con flag contributo Inps";
          _M770_log->append(log_line);  
        }
        break;         
      case 'S':
        if (!fl_Inps)       
          caus_D = 'I';
        else   
        {
          TString log_line; 
          log_line << old_cod << ": ";
          log_line << "causale quadro D: -S- con flag contributo Inps";
          _M770_log->append(log_line);  
        }
        break;       
      case 'F':
        cod_qua = "DB";
        caus_DB = 'E';
        caus_D = ' '; 
        fl_Inps = TRUE;
        break;
      case 'N':
        cod_qua = "DB";
        caus_DB = 'F';
        caus_D = ' '; 
        fl_Inps = TRUE;
        break;
      case 'B':
        cod_qua = "DB";
        caus_DB = 'B';
        caus_D = ' '; 
        fl_Inps = TRUE;
        break;
      case 'C':
        cod_qua = "DB";
        caus_DB = 'C';
        caus_D = ' '; 
        fl_Inps = TRUE;
        break;      
      case 'D':
        cod_qua = "DB";
        caus_DB = 'D';
        caus_D = ' '; 
        fl_Inps = TRUE;
    		break;	
    	default:	    
    		if (fl_Inps && cod_qua == "D")
    		{
    			TString log_line;	
    			log_line << old_cod << ": ";                                 
    			log_line << "causale quadro D: -senza causale";
    			log_line << "- con flag contributo Inps";
    			_M770_log->append(log_line);	
    		}	   
    		break; 		  
    }
    
    // conversione causale quadro D1
    switch(caus_D1)
    {
    	case 'F':        
    		cod_qua = "DB";
    		caus_DB = 'G';
        caus_D1 = ' '; 
        fl_Inps = TRUE;
    		break;
    	case 'A':
    	case 'B': 
    	case 'C':
    	case 'D': 
    	case 'E':
    		if (fl_Inps)
    		{
    			TString log_line;	
    			log_line << old_cod << ": ";                                 
    			log_line << "causale quadro D1: -" << caus_D1;
    			log_line << "- con flag contributo Inps";
    			_M770_log->append(log_line);	
    		}	    
    		break;
    	default:	    
    		if (fl_Inps && cod_qua == "D1")
    		{
    			TString log_line;	
    			log_line << old_cod << ": ";                                 
    			log_line << "causale quadro D1: -senza causale";
    			log_line << "- con flag contributo Inps";
    			_M770_log->append(log_line);	
    		}	   
    		break; 
    }
    
    // flag C.T.
    if (fl_CT)  
      caus_C = 'A';
                   
    // flag T.S.
    if (fl_TS)  
    { 
      fl_TS = FALSE;
      TString log_line; 
      log_line << old_cod << ": ";
      log_line << "era indicato il flag T.S.";
      _M770_log->append(log_line);  
    }           
    
    // reset campi contributo Inps se disattivati
    if (!old_fl_Inps) 
    { 
      ass_imp_Inps = ZERO;
      Perc_Inps = ZERO; 
      Perc_Comm_Inps = ZERO;
    }     
      
    // clear campi eliminati
    ca7.zero("B0");
    ca7.zero("B2");         
    
    // update campi modificati
    ca7.put("S1",cod_qua);// codice quadro  
    ca7.put("B4",fl_Inps);// soggetto contributo Inps
    ca7.put("B3",fl_TS);// flag T.S.
    ca7.put("S6",caus_C);// causale quadro C
    ca7.put("S2",caus_D);// causale quadro D
    ca7.put("S3",caus_D1);// causale quadro D1
    ca7.put("S7",caus_DB);// causale quadro DB    
    ca7.put("S8",caus_E);// causale quadro E    
    ca7.put("S9",caus_E1);// causale quadro E1
    ca7.put("R2",ass_imp_Inps);// assoggettamento imponibile Inps
    ca7.put("R1",Perc_Inps);// percentuale contributo Inps 
    ca7.put("R3",Perc_Comm_Inps);// percentuale contributo Inps committente
    
    // riscrittura record 
    ca7.rewrite();
  }
  // fine log
  _M770_log->append(log_space);  
  
  return TRUE;              
}                               
                                                           
                                                           
///////////////////////////////////////////////////////////
// Conversione quadro A 770 versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_quadroA_971() const
{
  // titolo log
  char now[9];
  TDate today(TODAY);  
  TString log_title("[Log Conversione quadro A : ");
  log_title << today << " " << _strtime(now) << "]  Prassi SpA";               
  _M770_log->append(log_title); 
  TString log_space(" ");
  _M770_log->append(log_space); 
  
  TLocalisamfile dip(LF_DIPEND);
  TLocalisamfile qa(LF_QUAA); 
  TProgind pi(qa.items(), "Conversione quadro A", FALSE, TRUE, 60);
  for (qa.first(); qa.good(); qa.next())
  {                                            
    pi.addstatus(1);
  
    // lettura campi soggetti a modifica
    long cod_ditta = qa.get_long("CODDITTA"); 
    long cod_dip = qa.get_long("CODDIP");
    int A18 = qa.get_int("CAUSA");// causa
    real A29 = qa.get_real("DENARO");// retribuzioni e pensioni       
    real EX_A21 = qa.get_real("NATURA");// ex in denaro  
    real A21 = qa.get_real("COBBDIP");// contr.prev.obblig.lav.dip.
    real EX_A25 = qa.get_real("IACOBBCD");// ex contr.obbl.carico lav.dip.            
    real A24 = qa.get_real("NORIT");// somme a valori non assogg. a rit.
    real EX_A27 = qa.get_real("TOTIMP");// ex totale imponibile 
    real EX_A50 = qa.get_real("SVNASSRI");// ex altre somme e valori non ass.rit.
    int A11 = qa.get_int("QAQUALIF");// qualifica
    
    // lettura campi dall'anagrafica dipendenti
    int ana_qualifica = 0;// qualifica anagrafica
    dip.setkey(1);
    dip.zero();
    dip.put("CODDITTA",cod_ditta); 
    dip.put("CODDIP",cod_dip);
    if (dip.read() == NOERR)
      ana_qualifica = dip.get_int("QUALIFICA"); 
    else 
    { 
      TString log_line;  
      log_line.format("Anagrafica inesistente per il dipendente :%06ld, della ditta :%05ld",cod_dip,cod_ditta);
      _M770_log->append(log_line);
    }   
    
    // conversione causa
    switch(A18)
    {
      case 6:
        A18 = 0;
        break;
      case 7:
        A18 = 0;
        break;      
    }                              
    
    // retribuzioni e pensioni
    A29 = A29 + EX_A21 - A21 + EX_A27;
    
    // contributi previd.assist.obbl.lav.dip.
    A21 = A21 + EX_A25;
    
    // somme e valori non assoggettati a ritenuta
    A24 = A24 + EX_A50;
      
    // qualifica
    A11 = ana_qualifica;
    
    // update campi modificati
    qa.put("CAUSA",A18);// causa
    qa.put("DENARO",A29);// retribuzioni e pensioni        
    qa.put("COBBDIP",A21);// contr.prev.obblig.lav.dip. 
    qa.put("NORIT",A24);// somme a valori non assogg. a rit.
    qa.put("QAQUALIF",A11);// qualifica
    
    // riscrittura record 
    qa.rewrite();
  }
  // fine log
  _M770_log->append(log_space);
  
  return TRUE;              
}

///////////////////////////////////////////////////////////
// Conversione quadro Abis 770 versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_quadroAB_971() const
{
  // titolo log
  char now[9];
  TDate today(TODAY);  
  TString log_title("[Log Conversione quadro Abis : ");
  log_title << today << " " << _strtime(now) << "]  Prassi SpA";               
  _M770_log->append(log_title); 
  TString log_space(" ");
  _M770_log->append(log_space); 
  
  // istanza file basebis per riporto flag quadro compilato
  TLocalisamfile bb(LF_BASEBIS);
  
  // istanza file Abis e prepara chiave precedente
  // per rilevamento rottura del dipendente 
  TLocalisamfile qab(LF_QUAAB);  
  qab.setkey(1);
  qab.zero();
  TRectype prevkey(qab.curr());
  int prog = 0;
  
  // istanza conta rettifica di conguaglio
  int count_RettA = 0; 
  int count_RettB = 0;  
  int count_RettC = 0; 
  int count_RettX = 0;                    
  
  // istanza record per scrittura rettifica A
  TRectype rec_RettA(qab.curr());
  
  // elaborazione quadri A
  TLocalisamfile qa(LF_QUAA);
  TProgind pi(qa.items(), "Conversione quadro Abis", FALSE, TRUE, 60);
  for (qa.first(); qa.good(); qa.next())
  {
    pi.addstatus(1);
    
    // lettura campi da copiare su Abis
    long cod_ditta = qa.get_long("CODDITTA");// codice ditta 
    long cod_dip = qa.get_long("CODDIP");// codice dipendente 
    int rigo = qa.get_int("NPROG");// progressivo rigo
    char EX_A52 = qa.get_char("CONEFF");// conguagli non effettuati
    real EX_A53 = qa.get_real("IMPVERS");// imposta trattenuta
    real EX_A54 = qa.get_real("INTERE");// interessi
    real EX_A55 = qa.get_real("CSSN95CV");// contributo trattenuto
    real EX_A56 = qa.get_real("INTERE2");// interessi              
    char EX_A57 = qa.get_char("CNEFF");// conguagli non effettuati
    char EX_A58 = qa.get_char("RETCON");// rettifica conguaglio    
    real EX_A59 = qa.get_real("IMPRIMB");// imposta rimborsata
    real EX_A60 = qa.get_real("IMPVER");// imposta trattenuta                           
    real EX_A61 = qa.get_real("INTIRPEF");// interessi
    real EX_A62 = qa.get_real("IMPVER2");// imposta trattenuta
    real EX_A63 = qa.get_real("INTER");// interessi               
    real EX_A64 = qa.get_real("STSIRPEF");// soprattasse su Irpef
    real EX_A65 = qa.get_real("CONRIMB");// contributo a rimborso
    real EX_A66 = qa.get_real("CONVER");// contributo trattenuto
    real EX_A67 = qa.get_real("INTER2");// interessi              
    real EX_A68 = qa.get_real("CONVER2");// contributo trattenuto
    real EX_A69 = qa.get_real("INTER3");// interessi              
    real EX_A70 = qa.get_real("STSCSSN70");// soprattasse su Cssn
    int  EX_A71 = qa.get_int("M730NLIQ");// Mod.730 non liquidabile
    long EX_A72 = qa.get_long("CODCAAF");// codice CAAF
    
    real tot =ZERO;
    tot = tot+EX_A53+EX_A54+EX_A55+EX_A56+EX_A59+EX_A60+EX_A61+EX_A62;
    tot = tot+EX_A63+EX_A64+EX_A65+EX_A66+EX_A67+EX_A68+EX_A69+EX_A70;
    
    if (tot==ZERO && EX_A52==' ' && EX_A57==' ' && EX_A58==' ' && !EX_A71)
      continue;
    
    // preparazione chiave quadro Abis e istanza nuovo record per scrittura 
    qab.zero();
    qab.put("CODDITTA",cod_ditta); 
    qab.put("CODDIP",cod_dip);
    TRectype key(qab.curr());  
    TRectype newrec(qab.curr());      
    
    // controllo rottura dipendente 
    if (key > prevkey)
    {
      // creo record rettifica A + valori operazioni di conguaglio
      if (count_RettA)
      {
        long ditta_RettA = rec_RettA.get_long("CODDITTA");
        long dip_RettA = rec_RettA.get_long("CODDIP");
        rec_RettA.put("NPROG",++prog);
        qab.write(rec_RettA); 
        TString log_line;  
        log_line.format("Unificato quadro rettifica A con rettifica B per il dipendente :%06ld, della ditta :%05ld",dip_RettA,ditta_RettA);
        _M770_log->append(log_line);  
        // set flag quadro compilato
        bb.zero();
        bb.put("CODDITTA",ditta_RettA);
        if (bb.read() == NOERR)
        {
          TString qcomp(bb.get("QCOMP"));
          TString newqcomp;
          newqcomp.spaces(29);
          newqcomp.overwrite(qcomp,0);
          newqcomp[26] = 'X';
          bb.put("QCOMP",newqcomp);
          bb.rewrite();
        }   
      } 
      // reimposto variabili di controllo
      prevkey = key;
      count_RettA = 0; 
      count_RettB = 0;  
      count_RettC = 0; 
      count_RettX = 0; 
      // inizializzo record rettifica A
      rec_RettA = key;          
    }
    
    // reperisce ultimo progressivo assegnato 
    prog = 0;
    for (qab.read(_isgteq); qab.good() && qab.curr() == key; qab.next())
      prog = qab.get_int("NPROG");
   
    // non posso riportare un record con rettifica C,D,E oppure F,
    // se ho già riportato un qualsiasi altro record 
    if ((EX_A58 == 'C' || EX_A58 == 'D' || EX_A58 == 'E' || EX_A58 == 'F') && count_RettX > 0)
    { 
      TString log_line;  
      log_line.format("Non riportato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
      _M770_log->append(log_line);
      log_line.format("- era un quadro con rettifica %c, ed erano già stati riportati altri quadri",EX_A58);
      _M770_log->append(log_line);
      continue; 
    } 
    
    // se già riportato record con rettifica C,D,E oppure F
    // deve esistere solo quest'ultimo
    if (count_RettC)
    {                            
      TString log_line;  
      log_line.format("Non riportato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
      _M770_log->append(log_line);
      log_line.format("- erano già stati riportati quadri C,D,E oppure F");
      _M770_log->append(log_line);
      continue;                  
    } 
    
    // deve esistere un solo record con rettifica A 
    if (EX_A58 == 'A' && count_RettA)
    { 
      TString log_line;  
      log_line.format("Non riportato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
      _M770_log->append(log_line);
      log_line.format("- era un quadro con rettifica %c, ed era già stato riportato un quadro A",EX_A58);
      _M770_log->append(log_line);
      continue;                                     
    }
    
    // deve esistere un solo record con rettifica B 
    if (EX_A58 == 'B' && count_RettB)
    { 
      TString log_line;  
      log_line.format("Non riportato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
      _M770_log->append(log_line);
      log_line.format("- era un quadro con rettifica %c, ed era già stato riportato un quadro B",EX_A58);
      _M770_log->append(log_line);
      continue;
    }
                                                    
    // riporto valori su Abis
    switch (EX_A58)
    {
      // per record con rettifica A memorizzo valori su record rettifica A
      case 'A':
        rec_RettA.put("CONEFF",EX_A52);// conguagli non effettuati
        rec_RettA.put("IMPVERS",EX_A53);// imposta trattenuta
        rec_RettA.put("INTERE",EX_A54);// interessi
        rec_RettA.put("CSSN95CV",EX_A55);// contributo trattenuto
        rec_RettA.put("INTERE2",EX_A56);// interessi              
        rec_RettA.put("CNEFF",EX_A57);// conguagli non effettuati
        rec_RettA.put("RETCON",EX_A58);// rettifica conguaglio    
        rec_RettA.put("IMPRIMB",EX_A59);// imposta rimborsata
        rec_RettA.put("IMPVER",EX_A60);// imposta trattenuta                           
        rec_RettA.put("INTIRPEF",EX_A61);// interessi
        rec_RettA.put("IMPVER2",EX_A62);// imposta trattenuta
        rec_RettA.put("INTER",EX_A63);// interessi               
        rec_RettA.put("STSIRPEF",EX_A64);// soprattasse su Irpef
        rec_RettA.put("CONRIMB",EX_A65);// contributo a rimborso
        rec_RettA.put("CONVER",EX_A66);// contributo trattenuto
        rec_RettA.put("INTER2",EX_A67);// interessi              
        rec_RettA.put("CONVER2",EX_A68);// contributo trattenuto
        rec_RettA.put("INTER3",EX_A69);// interessi              
        rec_RettA.put("STSCSSN70",EX_A70);// soprattasse su Cssn
        rec_RettA.put("M730NLIQ",EX_A71);// Mod.730 non liquidabile               
        break;
      // per record con rettifica B memorizzo valori su record rettifica A
      case 'B':
        rec_RettA.put("QABRCB19",EX_A62); 
        rec_RettA.put("QABRCB20",EX_A63); 
        rec_RettA.put("QABRCB21",EX_A64);
        rec_RettA.put("QABRCB22",EX_A65);
        rec_RettA.put("QABRCB23",EX_A66);
        rec_RettA.put("QABRCB24",EX_A67);
        rec_RettA.put("QABRCB25",EX_A68);
        rec_RettA.put("QABRCB26",EX_A69);
        break;
      // per gli altri creo record Abis
      default:
        newrec.put("NPROG",++prog);
        newrec.put("CONEFF",EX_A52);// conguagli non effettuati
        newrec.put("IMPVERS",EX_A53);// imposta trattenuta
        newrec.put("INTERE",EX_A54);// interessi
        newrec.put("CSSN95CV",EX_A55);// contributo trattenuto
        newrec.put("INTERE2",EX_A56);// interessi              
        newrec.put("CNEFF",EX_A57);// conguagli non effettuati
        newrec.put("RETCON",EX_A58);// rettifica conguaglio    
        newrec.put("IMPRIMB",EX_A59);// imposta rimborsata
        newrec.put("IMPVER",EX_A60);// imposta trattenuta                           
        newrec.put("INTIRPEF",EX_A61);// interessi
        newrec.put("IMPVER2",EX_A62);// imposta trattenuta
        newrec.put("INTER",EX_A63);// interessi               
        newrec.put("STSIRPEF",EX_A64);// soprattasse su Irpef
        newrec.put("CONRIMB",EX_A65);// contributo a rimborso
        newrec.put("CONVER",EX_A66);// contributo trattenuto
        newrec.put("INTER2",EX_A67);// interessi              
        newrec.put("CONVER2",EX_A68);// contributo trattenuto
        newrec.put("INTER3",EX_A69);// interessi              
        newrec.put("STSCSSN70",EX_A70);// soprattasse su Cssn
        newrec.put("M730NLIQ",EX_A71);// Mod.730 non liquidabile  
        qab.write(newrec);                                      
        // set flag quadro compilato
        bb.zero();
        bb.put("CODDITTA",cod_ditta);
        if (bb.read() == NOERR)
        {
          TString qcomp(29);
          qcomp = bb.get("QCOMP");
          qcomp[(int)AB] = 'X';
          bb.put("QCOMP",qcomp);
          bb.rewrite();
        }   
    }  
    
    // aggiorno conta rettifica di conguaglio
    switch (EX_A58)
    {
      case 'A': 
        ++count_RettA;                       
        ++count_RettX;                             
        break;
      case 'B':
        ++count_RettB;
        ++count_RettX;
        break;        
      case 'C':
        ++count_RettC;
        ++count_RettX;
        break;  
      case 'D':
        ++count_RettC;
        ++count_RettX;
        break;
      case 'E':
        ++count_RettC;
        ++count_RettX;
        break;       
      case 'F':
        ++count_RettC;
        ++count_RettX;
        break;  
      default:   
        ++count_RettX;
    }           
  }
  // fine log
  _M770_log->append(log_space);  
  
  return TRUE;            
}                                                           
                                                           
///////////////////////////////////////////////////////////
// Conversione quadro A2 770 versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_quadroA2_971() const
{
  // titolo log
  char now[9];
  TDate today(TODAY);  
  TString log_title("[Log Conversione quadro A2 : ");
  log_title << today << " " << _strtime(now) << "]  Prassi SpA";               
  _M770_log->append(log_title); 
  TString log_space(" ");
  _M770_log->append(log_space); 
  
  // istanza file A2 e prepara chiave precedente
  // per rilevamento rottura del dipendente 
  TLocalisamfile qa2(LF_QUAA2);  
  qa2.setkey(1);
  qa2.zero();
  TRectype prevkey(qa2.curr());
  int prog = 0;
  
  // istanza conta rettifica di conguaglio
  int count_RettA = 0; 
  int count_RettB = 0;  
  int count_RettC = 0; 
  int count_RettX = 0;                    
  
  // istanza record per scrittura rettifica A
  TRectype rec_RettA(qa2.curr());
  
  // istanza cursore per scansione quadri A2
  TRelation rA2(LF_QUAA2);
  TCursor cA2(&rA2);
  
  // elaborazione quadri A2 (frizzati) 
  cA2.freeze();      
  cA2 = 0L;  
  TRectype& rc = cA2.curr();
  TRecnotype items = cA2.items();  
  TProgind pi(items, "Conversione quadro A2", FALSE, TRUE, 60);
  for (int i = 0; i < items; i++,++cA2)
  {
    pi.addstatus(1);
    
    // lettura campi da copiare su A2
    long cod_ditta = rc.get_long("CODDITTA");// codice ditta 
    long cod_dip = rc.get_long("CODDIP");// codice dipendente 
    int rigo = rc.get_int("NPROG");// progressivo rigo
    char A2_9 = rc.get_char("RETCON");// rettifica conguaglio    
    real A2_10 = rc.get_real("SIRPEFRIMB");
    real A2_11 = rc.get_real("VIRPEF");
    real A2_12 = rc.get_real("INTIRPEF");
    real A2_13 = rc.get_real("AIRPEFIV");
    real A2_14 = rc.get_real("AIRPEFINT");
    real A2_15 = rc.get_real("STASSA15");
    real A2_16 = rc.get_real("CONTR16");
    real A2_17 = rc.get_real("CONTRVER");
    
    // preparazione chiave quadro A2
    qa2.zero();
    qa2.put("CODDITTA",cod_ditta); 
    qa2.put("CODDIP",cod_dip);
    TRectype key(qa2.curr());
    
    // controllo rottura dipendente 
    if (key > prevkey)
    {
      // aggiorno record rettifica A + valori operazioni di conguaglio
      if (count_RettA)
      {
        long ditta_RettA = rec_RettA.get_long("CODDITTA");
        long dip_RettA = rec_RettA.get_long("CODDIP");
        qa2.rewrite(rec_RettA); 
        TString log_line;  
        log_line.format("Unificato quadro rettifica A con rettifica B per il dipendente :%06ld, della ditta :%05ld",dip_RettA,ditta_RettA);
        _M770_log->append(log_line);
      } 
      // reimposto variabili di controllo
      prevkey = key;
      count_RettA = 0; 
      count_RettB = 0;  
      count_RettC = 0; 
      count_RettX = 0;
    }
   
    // non posso riportare un record con rettifica C,D,E oppure F,
    // se ho già riportato un qualsiasi altro record 
    if ((A2_9 == 'C' || A2_9 == 'D' || A2_9 == 'E' || A2_9 == 'F') && count_RettX > 0)
    { 
      qa2.remove(rc);
      TString log_line;  
      log_line.format("Eliminato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
      _M770_log->append(log_line);
      log_line.format("- era un quadro con rettifica %c, ed erano già presenti altri quadri",A2_9);
      _M770_log->append(log_line);
      continue; 
    } 
    
    // se già riportato record con rettifica C,D,E oppure F
    // deve esistere solo quest'ultimo
    if (count_RettC)
    {                            
      qa2.remove(rc);
      TString log_line;  
      log_line.format("Eliminato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
      _M770_log->append(log_line);
      log_line.format("- erano già presenti quadri C,D,E oppure F");
      _M770_log->append(log_line);
      continue;                  
    } 
    
    // deve esistere un solo record con rettifica A 
    if (A2_9 == 'A' && count_RettA)
    { 
      qa2.remove(rc);
      TString log_line;  
      log_line.format("Eliminato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
      _M770_log->append(log_line);
      log_line.format("- era un quadro con rettifica %c, ed era già presente un quadro A",A2_9);
      _M770_log->append(log_line);
      continue;                                     
    }
    
    // deve esistere un solo record con rettifica B 
    if (A2_9 == 'B' && count_RettB)
    { 
      qa2.remove(rc);
      TString log_line;  
      log_line.format("Eliminato quadro per il dipendente :%06ld, della ditta :%05ld, rigo :%03d",cod_dip,cod_ditta,rigo);
      _M770_log->append(log_line);
      log_line.format("- era un quadro con rettifica %c, ed era già presente un quadro B",A2_9);
      _M770_log->append(log_line);
      continue;
    }
                                                    
    // riporto valori su A2
    switch (A2_9)
    {
      // per record con rettifica A memorizzo valori su record rettifica A
      case 'A':   
        rec_RettA = rc;               
        break;
      // per record con rettifica B memorizzo valori su record rettifica A  
      // ed elimino il record
      case 'B':
        rec_RettA.put("QA2RCB10",A2_10); 
        rec_RettA.put("QA2RCB11",A2_11); 
        rec_RettA.put("QA2RCB12",A2_12);
        rec_RettA.put("QA2RCB13",A2_13);
        rec_RettA.put("QA2RCB14",A2_14);
        rec_RettA.put("QA2RCB15",A2_15);
        rec_RettA.put("QA2RCB16",A2_16);
        rec_RettA.put("QA2RCB17",A2_17);
        qa2.remove(rc);
        break;
      // per gli altri non fò nulla
      default:  
        break;
    }  
    
    // aggiorno conta rettifica di conguaglio
    switch (A2_9)
    {
      case 'A': 
        ++count_RettA;                       
        ++count_RettX;                             
        break;
      case 'B':
        ++count_RettB;
        ++count_RettX;
        break;        
      case 'C':
        ++count_RettC;
        ++count_RettX;
        break;  
      case 'D':
        ++count_RettC;
        ++count_RettX;
        break;
      case 'E':
        ++count_RettC;
        ++count_RettX;
        break;       
      case 'F':
        ++count_RettC;
        ++count_RettX;
        break;  
      default:   
        ++count_RettX;
    }           
  }
  // fine log
  _M770_log->append(log_space); 
  
  return TRUE;             
}                                                           

///////////////////////////////////////////////////////////
// Conversione basebis 770 versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_basebis_971() const
{
  // titolo log
  char now[9];
  TDate today(TODAY);  
  TString log_title("[Log Conversione base : ");
  log_title << today << " " << _strtime(now) << "]  Prassi SpA";               
  _M770_log->append(log_title); 
  TString log_space(" ");
  _M770_log->append(log_space); 

  TLocalisamfile bb(LF_BASEBIS);
  TLocalisamfile ql(LF_QUAL);  
  TProgind pi(bb.items(), "Conversione modello base", FALSE, TRUE, 60);
  for (bb.first(); bb.good(); bb.next())
  {
    pi.addstatus(1);
    
    // lettura campi soggetti a modifica
    long codditta = bb.get_long("CODDITTA");
    TString qcomp = bb.get("QCOMP"); 
    
    // sistemazione flag quadri compilati come flag quadri inviati/ricevuti
    const int Lpos = L;
    TString newqcomp;
    newqcomp.spaces(29);
    int nchar = qcomp.len() < Lpos ? qcomp.len() : Lpos;
    for (int i=0; i<nchar; i++)
      newqcomp[i] = qcomp[i];      
    for (i=Lpos; i<qcomp.len(); i++)
      if ((i+1)<newqcomp.len())
        newqcomp[i+1] = qcomp[i]; 
    
    // set flag quadro L compilato
    ql.zero();
    ql.put("CODDITTA",codditta);
    ql.put("QLAP",1996);
    TRectype& currec = ql.curr();     
    TRectype keyrec = currec;
    if (ql.read(_isgteq) == NOERR && currec == keyrec) 
      newqcomp[(int)L] = 'X'; 
    
    // update campi modificati
    bb.put("QCOMP",newqcomp);// flag quadri compilati
    
    // riscrittura record 
    bb.rewrite();
  }
  // fine log
  _M770_log->append(log_space);  
  
  return TRUE;            
}                                                          

///////////////////////////////////////////////////////////
// Conversione schede percipienti versione 971
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_schede_971() const
{
  // titolo log
  char now[9];
  TDate today(TODAY);  
  TString log_title("[Log Conversione schede percipienti : ");
  log_title << today << " " << _strtime(now) << "]  Prassi SpA";               
  _M770_log->append(log_title); 
  TString log_space(" ");
  _M770_log->append(log_space); 
  
  TLocalisamfile sch(LF_SCPERC);
  TLocalisamfile pag(LF_RPAG);    
  TLocalisamfile ver(LF_RVER);   
  TTable ca7("%ca7");  
  TProgind pi(sch.items(), "Conversione Schede Percipienti", FALSE, TRUE, 60);
  for (sch.first(); sch.good(); sch.next())
  {                                            
    pi.addstatus(1);
    
    // lettura campi soggetti a modifica
    long codditta = sch.get_long("CODDITTA"); 
    TString16 tipoa = sch.get("TIPOA");
    long codanagr = sch.get_long("CODANAGR");
    int nprog = sch.get_int("NPROG");
    TString16 codcaus = sch.get("CODCAUS"); 
    TString16 causqua = sch.get("CAUSQUA"); 
    TString16 flagts = sch.get("FLAGTS");
    real ritope = sch.get_real("RITOPE"); 
    real ritver = sch.get_real("RITVER");
    
    // decodifica valori da tabella causali
    TString16 t_quadro = "";   
    TString16 t_causqc = "";   
    TString16 t_causqd = "";
    TString16 t_causqdb = ""; 
    TString16 t_causqd1 = ""; 
    TString16 t_causqe = "";
    TString16 t_causqe1 = "";         
    TString16 t_flagts = "";         
    real t_PercRit = ZERO;         
    real t_PercInps = ZERO;
    real t_PercAssInps = ZERO;
    real t_PercComInps = ZERO;
    real t_PercAssImp = ZERO;
    real t_PercCassaPrev = ZERO;
    bool t_FlagInps = FALSE;                                             
    ca7.zero();
    ca7.put("CODTAB", codcaus);
    if (ca7.read() == NOERR)  
    {
      t_quadro = ca7.get("S1");   
      t_causqc = ca7.get("S6");   
      t_causqd = ca7.get("S2");
      t_causqdb = ca7.get("S7"); 
      t_causqd1 = ca7.get("S3"); 
      t_causqe = ca7.get("S8");
      t_causqe1 = ca7.get("S9");         
      t_flagts = ca7.get("S4");         
      t_PercRit = ca7.get_real("R0");         
      t_PercInps = ca7.get_real("R1");
      t_PercAssInps = ca7.get_real("R2"); 
      t_PercComInps = ca7.get_real("R3"); 
      t_PercAssImp = ca7.get_real("R4");
      t_PercCassaPrev = ca7.get_real("R5"); 
      t_FlagInps = ca7.get_bool("B4");                                             
    }             
    
    // conversione pagamenti collegati
    pag.zero();
    pag.put("CODDITTA", codditta); 
    pag.put("TIPOA", tipoa);
    pag.put("CODANAGR", codanagr); 
    pag.put("NPROG", nprog); 
    TRectype& rec = pag.curr();
    TRectype keypag = rec;
    // azzero totali da riportare su scheda
    ritope = ZERO;
    // elaborazione pagamenti della scheda
    for (pag.read(_isgteq); pag.good() && rec == keypag; pag.next())
    {
      // elimina pagamenti di quadro diverso da C,D,DB,D1,E,E1,G
      if (t_quadro != "C" && t_quadro != "D" && t_quadro != "DB" && t_quadro != "D1" &&
          t_quadro != "E" && t_quadro != "E1" && t_quadro != "G") 
      {
        pag.remove();
        continue;
      }     
      
      // lettura campi soggetti a modifica 
      Pag_struct s;
      s.datapag = rec.get_date("DATAPAG");      
      s.imponibile = rec.get_real("IMPONIBILE");
      s.perc = rec.get_real("PERC");  
      s.ritenuta = rec.get_real("RITENUTA"); 
      s.compenso = rec.get_real("COMPENSO");  
      s.netto = rec.get_real("NETTO"); 
      s.numvers = rec.get_long("NUMVERS");    
      s.spesa = rec.get_real("SPESA");
      s.ctssnperc = rec.get_real("CTSSNPERC");
      s.ctssncomp = rec.get_real("CTSSNCOMP"); 
      s.ritlorda = rec.get_real("RITLORDA");
      s.controbb = rec.get_real("CONTROBB");
      s.detfamil = rec.get_real("DETFAMIL"); 
      s.detlavdip = rec.get_real("DETLAVDIP");
      s.totdet = rec.get_real("TOTDET");
      s.giolavdip = rec.get_int("GIOLAVDIP"); 
      s.impcpa = rec.get_real("IMPCPA"); 
      s.somregconv = rec.get_real("SOMREGCONV");
      s.alqimp10 = rec.get_real("ALQIMP10"); 
      s.cod10 = rec.get("COD10");
      s.utpagati = rec.get_real("UTPAGATI");
      s.utspett = rec.get_real("UTSPETT");
      s.ritutpag = rec.get_real("RITUTPAG");
      s.ritutspe = rec.get_real("RITUTSPE"); 
      s.nquote = rec.get_real("NQUOTE"); 
      s.somnsrit = rec.get_real("SOMNSRIT");
      s.ammlordo = rec.get_real("AMMLORDO");
      s.quotaprov = rec.get_real("QUOTAPROV");
      s.impnetto = rec.get_real("IMPNETTO");
      s.comnetto = rec.get_real("COMNETTO"); 
      
      // riporto contributi obbligatori
      if (t_quadro == "C")
        s.controbb = s.ctssnperc; 
        
      // riporto percentuale assogg.imp.Inps   
      if (t_quadro == "DB")
        s.alqimp10 = t_PercAssInps;             
      
      // codice contributo Inps
      if (t_quadro == "DB")    
      {
        s.cod10 = "B";
        if ((t_PercAssInps == 95.00 || t_PercAssInps == 100.00) && t_PercInps == 10.00) 
          s.cod10 = "A"; 
        if (t_PercAssInps == ZERO || t_PercInps == ZERO)
          s.cod10 = "C"; 
      }                                
      
      // azzero valori Inps per quadri che non li gestiscono
      if (t_quadro != "DB") 
      {
        s.ctssnperc = ZERO;  
        s.ctssncomp = ZERO;  
      }                                                     
      
      // azzero spesa per quadri che non la gestiscono
      if (t_quadro == "G")
        s.spesa = ZERO;                               
        
      // ricalcolo riga pagamento   
      Pag_struct c;
      calcola_riga_pag(s,
                       c, 
                       FALSE,  
                       t_PercAssImp,
                       t_PercCassaPrev,
                       t_PercRit,
                       t_PercInps,
                       t_PercAssInps,
                       t_PercComInps);  
                       
      // totalizzo ritenuta per scheda
      ritope += s.ritenuta;            
      
      // forzo -1 nel numero versamento collegato se uguale a zero
      // perchè da luogo poi a malfunzionamenti in gestione
      if (s.numvers == 0L)
        s.numvers = -1L;
      
      // update campi modificati
      rec.put("DATAPAG",s.datapag);      
      rec.put("IMPONIBILE",s.imponibile);
      rec.put("PERC",s.perc);  
      rec.put("RITENUTA",s.ritenuta); 
      rec.put("COMPENSO",s.compenso);  
      rec.put("NETTO",s.netto); 
      rec.put("NUMVERS",s.numvers);    
      rec.put("SPESA",s.spesa);
      rec.put("CTSSNPERC",s.ctssnperc);
      rec.put("CTSSNCOMP",s.ctssncomp); 
      rec.put("RITLORDA",s.ritlorda);
      rec.put("CONTROBB",s.controbb);
      rec.put("DETFAMIL",s.detfamil); 
      rec.put("DETLAVDIP",s.detlavdip);
      rec.put("TOTDET",s.totdet);
      rec.put("GIOLAVDIP",s.giolavdip); 
      rec.put("IMPCPA",s.impcpa); 
      rec.put("SOMREGCONV",s.somregconv);
      rec.put("ALQIMP10",s.alqimp10); 
      rec.put("COD10",s.cod10);
      rec.put("UTPAGATI",s.utpagati);
      rec.put("UTSPETT",s.utspett);
      rec.put("RITUTPAG",s.ritutpag);
      rec.put("RITUTSPE",s.ritutspe); 
      rec.put("NQUOTE",s.nquote); 
      rec.put("SOMNSRIT",s.somnsrit);
      rec.put("AMMLORDO",s.ammlordo);
      rec.put("QUOTAPROV",s.quotaprov);
      rec.put("IMPNETTO",s.impnetto);
      rec.put("COMNETTO",s.comnetto);
      
      // riscrittura record 
      pag.rewrite();        
    }
    
    // conversione versamenti collegati
    ver.zero();
    ver.put("CODDITTA", codditta); 
    ver.put("TIPOA", tipoa);
    ver.put("CODANAGR", codanagr); 
    ver.put("NPROG", nprog);
    TRectype keyver = ver.curr();
    // azzero totali da riportare su scheda
    ritver =ZERO;
    // elaborazione versamenti della scheda
    for (ver.read(_isgteq); ver.good() && ver.curr() == keyver; ver.next())
    {
      // elimina versamenti di quadro diverso da C,D,DB,D1,E,E1,G
      if (t_quadro != "C" && t_quadro != "D" && t_quadro != "DB" && t_quadro != "D1" &&
          t_quadro != "E" && t_quadro != "E1" && t_quadro != "G") 
      {
        ver.remove();
        continue;
      }
                       
      // totalizzo ritenuta per scheda
      ritver += ver.get_real("RITENUTA"); 
    } 
    
    // elimina scheda di quadro diverso da C,D,DB,D1,E,E1,G
    if (t_quadro != "C" && t_quadro != "D" && t_quadro != "DB" && t_quadro != "D1" &&
        t_quadro != "E" && t_quadro != "E1" && t_quadro != "G") 
    {
      sch.remove();
      TString log_line;  
      log_line.format("Eliminata scheda n.%04d di quadro %s per il percipiente :%s,%05ld, della ditta :%05ld",nprog,(const char*)t_quadro,(const char*)tipoa,codanagr,codditta);
      _M770_log->append(log_line);
      continue;
    }     
    
    // riporto casuale quadro
    if (t_quadro == "C")
      causqua = t_causqc; 
    if (t_quadro == "D")
      causqua = t_causqd;
    if (t_quadro == "DB")
      causqua = t_causqdb;
    if (t_quadro == "D1")
      causqua = t_causqd1;
    if (t_quadro == "E")
      causqua = t_causqe;
    if (t_quadro == "E1")
      causqua = t_causqe1;    
      
    // riporto flag TS
    if (t_quadro == "C")
      flagts = t_flagts;  
    
    // update campi modificati
    sch.put("CAUSQUA",causqua); 
    sch.put("FLAGTS",flagts);
    sch.put("RITOPE",ritope); 
    sch.put("RITVER",ritver);
    
    // riscrittura record   
    sch.rewrite();        
    
  }
  // fine log
  _M770_log->append(log_space);
  
  return TRUE;              
}

///////////////////////////////////////////////////////////
// Conversione manuale schede percipienti versione 971 
// calcolo valore CPA
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_schede_man1_971() const
{
  // conferma 
  if (!yesno_box("Conferma calcolo automatico del CPA in Schede Percipienti?"))
    return FALSE;
  
  // titolo log
  char now[9];
  TDate today(TODAY);  
  TString log_title("[Log Conversione schede percipienti : ");
  log_title << today << " " << _strtime(now) << "]  Prassi SpA";               
  _M770_log->append(log_title); 
  TString log_space(" ");
  _M770_log->append(log_space);   
  TString log_line("Eseguita conversione manuale di riporto valore CPA");
  _M770_log->append(log_line);
  
  // almeno una scheda convertita
  bool one_conv = FALSE;
  
  TLocalisamfile sch(LF_SCPERC);
  TLocalisamfile pag(LF_RPAG);
  TTable ca7("%ca7");  
  TProgind pi(sch.items(), "Riporto valore CPA delle schede percipienti", FALSE, TRUE, 60);
  for (sch.first(); sch.good(); sch.next())
  {                                            
    pi.addstatus(1);
    
    // lettura campi soggetti a modifica
    long codditta = sch.get_long("CODDITTA"); 
    TString16 tipoa = sch.get("TIPOA");
    long codanagr = sch.get_long("CODANAGR");
    int nprog = sch.get_int("NPROG");
    TString16 codcaus = sch.get("CODCAUS");
    
    // decodifica valori da tabella causali
    TString16 t_quadro = "";
    real t_PercCassaPrev = ZERO;
    ca7.zero();
    ca7.put("CODTAB", codcaus);
    if (ca7.read() == NOERR)  
    {
      t_quadro = ca7.get("S1");
      t_PercCassaPrev = ca7.get_real("R5");
    }             
    
    // conversione pagamenti collegati
    pag.zero();
    pag.put("CODDITTA", codditta); 
    pag.put("TIPOA", tipoa);
    pag.put("CODANAGR", codanagr); 
    pag.put("NPROG", nprog); 
    TRectype& rec = pag.curr();
    TRectype keypag = rec;
  
    // elaborazione pagamenti della scheda
    for (pag.read(_isgteq); pag.good() && rec == keypag; pag.next())
    {     
      // lettura campi soggetti a modifica 
      Pag_struct s;
      s.compenso = rec.get_real("COMPENSO");
      s.impcpa = rec.get_real("IMPCPA");               
        
      // calcolo CPA
      real c_impcpa = (s.compenso * t_PercCassaPrev) / (100.00 + t_PercCassaPrev);
      c_impcpa.round();
      if (s.impcpa == ZERO)
      {
        s.impcpa = c_impcpa;
        one_conv = TRUE;
      }  
        
      // update campi modificati
      rec.put("IMPCPA",s.impcpa);
      
      // riscrittura record 
      pag.rewrite();        
    }    
  }
  
  // ricalcolo totale schede
  if (one_conv)
    totalrecalc();
  
  // fine log
  _M770_log->append(log_space);
  
  return TRUE;              
}                                                          

///////////////////////////////////////////////////////////
// Conversione manuale schede percipienti versione 971 
// modifica causali in schede percipienti
///////////////////////////////////////////////////////////
bool TConvert_app::cnv_schede_man2_971() const
{
  // titolo log
  char now[9];
  TDate today(TODAY);  
  TString log_title("[Log Conversione schede percipienti : ");
  log_title << today << " " << _strtime(now) << "]  Prassi SpA";               
  _M770_log->append(log_title); 
  TString log_space(" ");
  _M770_log->append(log_space);
  
  // almeno una scheda convertita
  bool one_conv = FALSE;
  
  // istanza maschera principale
  TMask mainmsk("77cnva.msk");
  mainmsk.set_handler(F_CODCAUS, F_CODCAUS_handler);
  
  // prima escuzione maschera principale
  mainmsk.open_modal();
  KEY tasto = mainmsk.run();

  // gestione maschera principale
  while (tasto != K_ESC) 
  {                                     
    // gestione schede convertibili
    if (choicesheet(mainmsk.get_long(F_CODDITTA), mainmsk.get(F_CODCAUS), mainmsk.get(F_CODQUA), mainmsk.get(F_CAUSQUA))) 
      one_conv = TRUE;
    
    // riesecuzione maschera
    tasto = mainmsk.run();
  }
               
  // chiusura maschera principale
  mainmsk.close_modal();  
  
  // ricalcolo totale schede
  if (one_conv)
    totalrecalc();
  
  // fine log
  _M770_log->append(log_space);
  
  return TRUE;              
}

Pag_struct& TConvert_app::clear_struct(Pag_struct& s) const
{
  s.datapag = NULLDATE;
  s.imponibile = ZERO;
  s.perc = ZERO;
  s.ritenuta = ZERO;
  s.compenso = ZERO;
  s.netto = ZERO;
  s.numvers = -1L;
  s.spesa = ZERO;
  s.ctssnperc = ZERO;
  s.ctssncomp = ZERO;
  s.ritlorda = ZERO;
  s.controbb = ZERO;  
  s.detfamil = ZERO;
  s.detlavdip = ZERO;
  s.totdet = ZERO;
  s.giolavdip = 0;
  s.impcpa = ZERO;  
  s.somregconv = ZERO;   
  s.alqimp10 = ZERO;   
  s.cod10 = "";
  s.utpagati = ZERO;  
  s.utspett = ZERO;   
  s.ritutpag = ZERO;    
  s.ritutspe = ZERO;    
  s.nquote = ZERO;   
  s.somnsrit = ZERO;
  s.ammlordo = ZERO;  
  s.quotaprov = ZERO;   
  s.impnetto = ZERO;  
  s.comnetto = ZERO;        
  
  return s;
}    


Pag_struct& TConvert_app::calcola_riga_pag(Pag_struct& s,
                                           Pag_struct& c,
                                           bool force,
                                           const real h_PercAssImp,
                                           const real h_PercCassaPrev,
                                           const real h_PercRitenuta,
                                           const real h_PercInps,
                                           const real h_PercAssImpInps,
                                           const real h_PercCommitInps) const
{

  // azzera struttura di valori calcolati
  clear_struct(c);
    
  // calcolo imponibile
  c.imponibile = ((s.compenso - s.impcpa) * h_PercAssImp) / 100.00; 
  c.imponibile.round();
  if (s.imponibile == ZERO || force)
    s.imponibile = c.imponibile;                                 
      
  // percentuale ritenuta acconto
  if (s.perc == ZERO || force)
    s.perc = h_PercRitenuta;                                     
      
  // calcolo ritenuta lorda
  c.ritlorda = (s.imponibile * s.perc) / 100.00;  
  c.ritlorda.round();
  s.ritlorda = c.ritlorda; 
    
  // calcolo totale detrazioni
  c.totdet = s.detfamil + s.detlavdip;  
  if (c.totdet > s.ritlorda)
    c.totdet = s.ritlorda;
  s.totdet = c.totdet;        
    
  // calcolo ritenuta
  c.ritenuta = s.ritlorda - s.totdet;                            
  if (s.ritenuta == ZERO || force)
    s.ritenuta = c.ritenuta;     
      
  // percentuale assoggettamento Inps
  if (s.alqimp10 == ZERO || force)
    s.alqimp10 = h_PercAssImpInps;
      
  // calcolo contributo Inps complessivo
  c.ctssncomp = (((s.compenso * s.alqimp10) / 100.00) * h_PercInps) / 100.00;
  c.ctssncomp.round();
  if (s.ctssncomp == ZERO || force)
    s.ctssncomp = c.ctssncomp; 
    
  // calcolo contributo Inps del percipiente
  if (h_PercCommitInps == ZERO)
    c.ctssnperc = s.ctssncomp - ((s.ctssncomp * 2) / 3); 
  else
    c.ctssnperc = s.ctssncomp - ((s.ctssncomp * h_PercCommitInps) / 100.00);              
  c.ctssnperc.round();
  if (s.ctssnperc == ZERO || force)
    s.ctssnperc = c.ctssnperc; 
      
  // calcolo utili pagati
  c.utpagati = s.imponibile;
  if (s.utpagati == ZERO || force)
    s.utpagati = c.utpagati;
  if (abs(s.utpagati) > abs(s.imponibile))
    s.utpagati = s.imponibile;                          
      
  // calcolo ritenute utili pagati
  c.ritutpag = (s.utpagati * s.perc) / 100.00;
  c.ritutpag.round();
  if (s.ritutpag == ZERO || force)
    s.ritutpag = c.ritutpag;    
  if (abs(s.ritutpag) > abs(s.ritenuta))
    s.ritutpag = s.ritenuta;    
      
  // calcolo utili spettanti
  s.utspett = s.imponibile - s.utpagati;  
    
  // calcolo ritenute utili spettanti
  s.ritutspe = s.ritenuta - s.ritutpag; 
    
  // calcolo compenso netto
  s.netto = s.compenso + s.spesa - s.ritenuta - s.ctssnperc;      
    
  // calcolo somme non soggette a ritenuta
  s.somnsrit = s.compenso - s.imponibile + s.spesa - s.impcpa - s.somregconv; 
    
  // calcolo ammontare lordo
  s.ammlordo = s.imponibile + s.somnsrit + s.controbb + s.somregconv;
    
  // calcolo quota provvigioni
  s.quotaprov = s.somnsrit - s.spesa;
    
  // calcolo imponibile al netto delle ritenute
  s.impnetto = s.imponibile - s.ritenuta;      
    
  // calcolo compenso al netto delle ritenute
  s.comnetto = s.compenso - s.ritenuta;    
  
  return s;
}

///////////////////////////////////////////////////////////
// Conversione manuale schede percipienti versione 971 
// modifica causali in schede percipienti  
// Costruisce ed esegue sheet con schede selezionabili
///////////////////////////////////////////////////////////
bool TConvert_app::choicesheet(const long codditta, const TString& codcaus, const TString& codqua, const TString& causqua) const
{ 
  // almeno una scheda convertita
  bool one_conv = FALSE;
  
  // istanza relation
  TRelation* rel = new TRelation(LF_SCPERC); 
  rel->add(LF_ANAG, "TIPOA=TIPOA|CODANAGR=CODANAGR");
  rel->add("%CA7", "CODTAB=CODCAUS", 1, LF_SCPERC, 101);
  
  // costruisce range per cursor 
  TRectype fromto = rel->curr();
  fromto.zero();
  fromto.put("CODDITTA", codditta);                  
  
  // costruisce espressione filtro per cursor
  TString exprfilter;
  if (codqua == "DB" && causqua == "A")
    exprfilter = "(101@->S1==\"D\") && (CAUSQUA==\"A\")";
  if (codqua == "DB" && causqua == "T")
    exprfilter =  "(101@->S1==\"D\") && (CAUSQUA== \"T\")";
  if (codqua == "D" && causqua == "L")
    exprfilter =  "(101@->S1==\"D\") && (CAUSQUA== \"T\")";
  if (codqua == "E" || codqua == "E1")
    exprfilter.format("(101@->S1==\"%s\")", (const char*)codqua);
  
  // istanza cursor
  TCursor* cur = new TCursor(rel, "", 1, &fromto, &fromto); 
  
  // attiva espressione filtro + update (perchè uso campi non del file principale)
  cur->setfilter(exprfilter, TRUE);
  
  // caption dello sheet
  TString caption = "Schede percipienti convertibili";  
  
  // intestazione colonne dello sheet
  TString head = "@1|";
  head << "Percipiente@30|";
  head << "Data docum.@R|";
  head << "N°docum.|"; 
  head << "Quadro|";
  head << "Caus.|"; 
  head << "Rit.operate@15@R|";
  head << "Rit.versate@15@R|";
  head << "Tipo|";
  head << "Codice@R|";
  head << "Scheda@R|";

  // colonne dello sheet
  TString columns = " |"; 
  columns << LF_ANAG << "->RAGSOC|"; 
  columns << "DATADOC|";  
  columns << "NUMDOC|"; 
  columns << "101@->S1|"; 
  columns << "CAUSQUA|"; 
  columns << "RITOPE|"; 
  columns << "RITVER|";
  columns << "TIPOA|";
  columns << "CODANAGR|";
  columns << "NPROG";   
  
  // istanza cursor sheet
  TCursor_sheet* she = new TCursor_sheet(cur, columns, caption, head, 0, 3);
  
  // esecuzione sheet
  KEY retkey = she->run();   

  // conversione schede selezionate
  if (retkey == K_ENTER && she->one_checked())
  { 
    TString log_line;
    log_line.format("Eseguita conversione manuale di modifica causale, ditta:%05ld, nuova causale:%s, causale quadro:%s", codditta, (const char*)codcaus, (const char*)causqua);
    _M770_log->append(log_line);
    
    TLocalisamfile& scperc = cur->file();  
    TLocalisamfile pag(LF_RPAG);
    long items = she->items();
    // scansione schede convertibili
    for (long i=0; i<items; i++)
      if (she->checked(i))
      {
        // modifica valori su scheda selezionata
        TToken_string& t = she->row(i);
        TString16 tipoa = t.get(8);
        long codanagr = t.get_long(9);
        int nprog = t.get_int(10);       
        scperc.zero();
        scperc.put("CODDITTA", codditta);
        scperc.put("TIPOA", tipoa); 
        scperc.put("CODANAGR", codanagr); 
        scperc.put("NPROG", nprog);
        if (scperc.read() == NOERR)
        {
          log_line.format("- convertita scheda n.%04d per il percipiente :%s,%05ld",nprog,(const char*)tipoa,codanagr);
          _M770_log->append(log_line);
          scperc.put("CODCAUS", codcaus); 
          scperc.put("CAUSQUA", causqua); 
          scperc.rewrite(); 
          one_conv = TRUE; 
          // set codice 10% nelle righe pagamento
          // se causale nuova di quadro Dbis
          if (codqua == "DB")
          {
            pag.zero();
            pag.put("CODDITTA", codditta); 
            pag.put("TIPOA", tipoa);
            pag.put("CODANAGR", codanagr); 
            pag.put("NPROG", nprog); 
            TRectype& rec = pag.curr();
            TRectype keypag = rec;
            for (pag.read(_isgteq); pag.good() && rec == keypag; pag.next())
            {
              rec.put("COD10", "C");
              pag.rewrite();        
            }        
          }  
        } 
      }
  }
    
  delete she;
  delete cur;
  delete rel;
  
  return one_conv;
}

///////////////////////////////////////////////////////////
// Conversione manuale schede percipienti versione 971 
// modifica causali in schede percipienti  
// Handler codice causale su maschera principale
///////////////////////////////////////////////////////////
bool TConvert_app::F_CODCAUS_handler(TMask_field& f, KEY k)
{
  TMask& m = f.mask();
  TString16 cod_qua(m.get(F_CODQUA));
    
  // creo run-time gli items per la causale quadro
  TEdit_field& f_causqua = m.efield(F_CAUSQUA);
  // refernce allo sheet del campo causale quadro
  TString_array& Items = f_causqua.sheet()->rows_array();  
  // rimuovo tutti gli items
  Items.destroy();
  // genero i nuovi items
  if (cod_qua == "D")
    for (int i=0; i<NUM_ITEMS_D; i++)
      Items.add(ITEMS_D[i]);    
  if (cod_qua == "DB")
    for (int i=0; i<NUM_ITEMS_DB; i++)
      Items.add(ITEMS_DB[i]);
  if (cod_qua == "E")
    for (int i=0; i<NUM_ITEMS_E; i++)
      Items.add(ITEMS_E[i]);
  if (cod_qua == "E1")
    for (int i=0; i<NUM_ITEMS_E1; i++)
      Items.add(ITEMS_E1[i]);
  
  // cose da fare solo se viene modificato il codice causale
  if (f.to_check(k) && k != K_ENTER)
  {
    // forzo causale quadro con il valore in tabella
    f_causqua.reset();
    if (cod_qua == "D")
      f_causqua.set(m.get(F_TABCAUSQUAD));
    if (cod_qua == "DB")
      f_causqua.set(m.get(F_TABCAUSQUADB));
    if (cod_qua == "E")     
      f_causqua.set(m.get(F_TABCAUSQUAE));
    if (cod_qua == "E1")      
      f_causqua.set(m.get(F_TABCAUSQUAE1));
  }  
  
  return TRUE;
}

///////////////////////////////////////////////////////////
// Ricalcolo complessivo schede percipienti
///////////////////////////////////////////////////////////
void TConvert_app::totalrecalc() const
{
  TLocalisamfile sch(LF_SCPERC);
  TLocalisamfile pag(LF_RPAG);
  TTable ca7("%ca7");  
  TProgind pi(sch.items(), "Ricalcolo Schede Percipienti", FALSE, TRUE, 60);
  for (sch.first(); sch.good(); sch.next())
  {                                            
    pi.addstatus(1);
    
    // lettura campi soggetti a modifica
    long codditta = sch.get_long("CODDITTA"); 
    TString16 tipoa = sch.get("TIPOA");
    long codanagr = sch.get_long("CODANAGR");
    int nprog = sch.get_int("NPROG");       
    TString16 codcaus = sch.get("CODCAUS"); 
    real ritope = sch.get_real("RITOPE");
    
    // decodifica valori da tabella causali
    TString16 t_quadro = "";
    ca7.zero();
    ca7.put("CODTAB", codcaus);
    if (ca7.read() == NOERR)    
      t_quadro = ca7.get("S1");             
    
    // conversione pagamenti collegati
    pag.zero();
    pag.put("CODDITTA", codditta); 
    pag.put("TIPOA", tipoa);
    pag.put("CODANAGR", codanagr); 
    pag.put("NPROG", nprog); 
    TRectype& rec = pag.curr();
    TRectype keypag = rec;
    // azzero totali da riportare su scheda
    ritope = ZERO;
    // elaborazione pagamenti della scheda
    for (pag.read(_isgteq); pag.good() && rec == keypag; pag.next())
    { 
      // lettura campi soggetti a modifica 
      Pag_struct s;
      s.datapag = rec.get_date("DATAPAG");      
      s.imponibile = rec.get_real("IMPONIBILE");
      s.perc = rec.get_real("PERC");  
      s.ritenuta = rec.get_real("RITENUTA"); 
      s.compenso = rec.get_real("COMPENSO");  
      s.netto = rec.get_real("NETTO"); 
      s.numvers = rec.get_long("NUMVERS");    
      s.spesa = rec.get_real("SPESA");
      s.ctssnperc = rec.get_real("CTSSNPERC");
      s.ctssncomp = rec.get_real("CTSSNCOMP"); 
      s.ritlorda = rec.get_real("RITLORDA");
      s.controbb = rec.get_real("CONTROBB");
      s.detfamil = rec.get_real("DETFAMIL"); 
      s.detlavdip = rec.get_real("DETLAVDIP");
      s.totdet = rec.get_real("TOTDET");
      s.giolavdip = rec.get_int("GIOLAVDIP"); 
      s.impcpa = rec.get_real("IMPCPA"); 
      s.somregconv = rec.get_real("SOMREGCONV");
      s.alqimp10 = rec.get_real("ALQIMP10"); 
      s.cod10 = rec.get("COD10");
      s.utpagati = rec.get_real("UTPAGATI");
      s.utspett = rec.get_real("UTSPETT");
      s.ritutpag = rec.get_real("RITUTPAG");
      s.ritutspe = rec.get_real("RITUTSPE"); 
      s.nquote = rec.get_real("NQUOTE"); 
      s.somnsrit = rec.get_real("SOMNSRIT");
      s.ammlordo = rec.get_real("AMMLORDO");
      s.quotaprov = rec.get_real("QUOTAPROV");
      s.impnetto = rec.get_real("IMPNETTO");
      s.comnetto = rec.get_real("COMNETTO");
      
      // azzero CPA se quadro diverso da D
      if (t_quadro != "D")
        s.impcpa = ZERO;
      
      // calcolo ritenuta lorda
      s.ritlorda = (s.imponibile * s.perc) / 100.00; 
      s.ritlorda.round();
        
      // calcolo totale detrazioni
      s.totdet = s.detfamil + s.detlavdip;  
      if (s.totdet > s.ritlorda)
        s.totdet = s.ritlorda;
      
      // calcolo utili spettanti
      s.utspett = s.imponibile - s.utpagati;  
        
      // calcolo ritenute utili spettanti
      s.ritutspe = s.ritenuta - s.ritutpag; 
        
      // calcolo compenso netto
      s.netto = s.compenso + s.spesa - s.ritenuta - s.ctssnperc;      
        
      // calcolo somme non soggette a ritenuta
      s.somnsrit = s.compenso - s.imponibile + s.spesa - s.impcpa - s.somregconv; 
        
      // calcolo ammontare lordo
      s.ammlordo = s.imponibile + s.somnsrit + s.controbb + s.somregconv;
        
      // calcolo quota provvigioni
      s.quotaprov = s.somnsrit - s.spesa;
        
      // calcolo imponibile al netto delle ritenute
      s.impnetto = s.imponibile - s.ritenuta;      
        
      // calcolo compenso al netto delle ritenute
      s.comnetto = s.compenso - s.ritenuta; 
                       
      // totalizzo ritenuta per scheda
      ritope += s.ritenuta;
      
      // update campi modificati
      rec.put("NETTO",s.netto); 
      rec.put("RITLORDA",s.ritlorda);
      rec.put("TOTDET",s.totdet);
      rec.put("IMPCPA",s.impcpa);
      rec.put("UTSPETT",s.utspett);
      rec.put("RITUTSPE",s.ritutspe);
      rec.put("SOMNSRIT",s.somnsrit);
      rec.put("AMMLORDO",s.ammlordo);
      rec.put("QUOTAPROV",s.quotaprov);
      rec.put("IMPNETTO",s.impnetto);
      rec.put("COMNETTO",s.comnetto);
      
      // riscrittura record 
      pag.rewrite();        
    }
    
    // update campi modificati
    sch.put("RITOPE",ritope);
    
    // riscrittura record   
    sch.rewrite();        
    
  }                           
}  

///////////////////////////////////////////////////////////
// Programma di conversione archivi 770
///////////////////////////////////////////////////////////

int main(int argc,char** argv)
{
  const int r = (argc > 1) ? abs(atoi(argv[1])) : -1;
  
  if (r >= 0 && r <= 9)
  {
    TConvert_app a(r) ;
    a.run(argc, argv, "Conversione archivi 770");
  }
  else
    error_box(usage);
  exit(0);
  return 0;
}