#include <applicat.h>
#include <automask.h>
#include <isam.h>
#include <mask.h>
#include <prefix.h>
#include <progind.h>
#include <relation.h>
#include <sheet.h>
#include <tabutil.h>

#include <nditte.h>

#include "ce0.h"
#include "ce0900a.h"
#include "../cg/cglib01.h"

#define CAMPODITTA "CAMPODITTA"

class TConversione_ce_mask : public TAutomask
{
  TRelation*      _rel;
  TCursor*        _cur;
  TCursor_sheet*  _sheet;
     
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  bool already_converted(long ditta);
     
public:
  TCursor_sheet& sheet() {return *_sheet;}
  void lista_ditte(TAssoc_array& ditte);
  TConversione_ce_mask(); 
  ~TConversione_ce_mask();
};  
                                                          
static bool esiste_ditta(const TRelation* rel)
{                        
  const long ditta = rel->curr().get_long(NDT_CODDITTA);
  return prefix().exist(ditta);
}                                                                              
   
bool TConversione_ce_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case F_SCELTADITTE:
    if (e == fe_button)
    {
      sheet().run();
      set(F_DITTESELEZ, sheet().checked());
    } 
    if (e == fe_close)
      if (sheet().checked() == 0)
        return error_box(TR("Non sono state selezionate ditte da convertire"));
    break;
  case F_DITTESELEZ:
    if (e == fe_init)
      o.set(sheet().checked());
    break;    
  case F_MINISTERIALI:
    if (e == fe_init)
    {
      TTable cgr("%CGR");     
      const bool empty = cgr.first() != NOERR;
      o.set(empty ? "X": " ");
    }
    break;    
  default:
    break;
  }     
  return TRUE;
}  

bool TConversione_ce_mask::already_converted(long ditta)
{
  prefix().set_codditta(ditta);
  TTable cce("CCE");
  int err = cce.first();
  if (err != NOERR)
    return FALSE;

  TFilename ditce = prefix().get_studio();
  ditce.add("cesp/ditce");
  TExternisamfile oldfile(ditce,(bool) FALSE,(bool) FALSE);

  for (err = oldfile.first(); err == NOERR; err = oldfile.next())
  {
    long d = oldfile.get_long("CACDD");
    if (d == ditta)
      return TRUE;
  }
  return FALSE;
}

void TConversione_ce_mask::lista_ditte(TAssoc_array& ditte)
{
  ditte.destroy();
  for (long i = sheet().items()-1; i >= 0; i--)
  {                                           
    if (sheet().checked(i))
    {
      const TString16 codditta = sheet().row(i).get(1);
      bool add = TRUE;
      if (already_converted(atol(codditta)))
        add = yesno_box(FR("La ditta %s potrebbe già essere stata converita:\n"
                        "Si desidera continuare ugualmente, azzerando gli archivi attuali?"),
                        (const char*)codditta);
      if (add)
        ditte.add(codditta);
    }  
  }
}    
   
TConversione_ce_mask::TConversione_ce_mask()
: TAutomask("ce0900a")
{
  _rel = new TRelation(LF_NDITTE);
  _cur = new TCursor(_rel); 
  _cur->set_filterfunction(esiste_ditta);
  _sheet = new TCursor_sheet(_cur, " |CODDITTA|RAGSOC", TR("Selezione ditte"), HR("@1|Codice|Ragione sociale@50"), 0, 1);
  _sheet->check(-1);
}

TConversione_ce_mask::~TConversione_ce_mask()
{
  delete _sheet;
  delete _cur;
  delete _rel;
}

class TConversione_cespiti: public TSkeleton_application
{
  FILE * _log;
  TAssoc_array  _ditte;
  
protected:
  virtual bool create(void);
  virtual void main_loop();
  virtual bool destroy(void) ;
  void open_log();
  void write_log(const char * line);
  void close_log();
  int zap_file(int lf) const;
  void zap_table(const char* tab) const;

public:
  bool daconvertire(const long ditta);
  int conv_file(const TFilename& ofname, int nflogicnum);
  int conv_inifile(const TFilename& ofname, const char* ofpar, int nflogicnum);
  int conv_tab(const TFilename& ofname, const char* cod);
  int conv_par(const TFilename& ofname, const char* ofpar, int which_config);
  int get_codesc(const TDate& date, const bool fatal = FALSE);
  const char conv_imptmc(int cod);
  TConversione_cespiti() {}
  virtual ~TConversione_cespiti() {}
};

bool TConversione_cespiti::create()
{
  return TSkeleton_application::create();
}

bool TConversione_cespiti::destroy()
{
  return TSkeleton_application::destroy();
}
                                      
bool TConversione_cespiti::daconvertire(const long ditta)
{
  TString16 strditta;
  strditta.format("%ld", ditta);
  return _ditte.is_key(strditta); 
}                                      
                                      
void TConversione_cespiti::main_loop()
{  
  TConversione_ce_mask msk;                   
  if (msk.run() == K_ENTER && yesno_box(TR("Confermare la conversione dei cespiti?"))) 
  {                      
    msk.lista_ditte(_ditte);
    if (_ditte.items() == 0)
    {
      warning_box(TR("Nessuna ditta selezionata"));
      return;
    }  
    open_log();
    TString80 s;
    write_log("");        
    write_log("**********************************");        
    s.format(TR("Conversione cespiti del %s"), (const char *) TDate(TODAY).string());
    write_log(s);
    write_log("**********************************");        
    write_log("");        
    
    const char* studio = prefix().get_studio();
    const bool converti_ministeriali  = msk.get_bool(F_MINISTERIALI);
    // conversione archivi
    TFilename file = studio;
    file << "cesp/ammce";
    conv_file(file, 136);
    file = studio;
    file << "cesp/ammmv";
    conv_file(file, 137);
    file = studio;
    file << "cesp/catdi";
    conv_file(file, 138);
    file = studio;
    file << "cesp/cespi";
    conv_file(file, 139);
    file = studio;
    file << "cesp/movam";
    conv_file(file, 141);
    file = studio;
    file << "cesp/movce";
    conv_file(file, 142);
    file = studio;
    file << "cesp/salce";
    conv_file(file, 143); 
    file = studio;
    file << "cesp/coll01";
    conv_inifile(file, "COLL01", 140); 
    // conversione tabelle
    file = studio;
    file << "cesp/ditcb";
    conv_tab(file, "CCB"); 
    file = studio;
    file << "cesp/ditce";
    conv_tab(file, "CCE"); 
    file = studio;
    file << "cesp/tabimp";
    conv_tab(file, "CIM"); 
    file = studio;
    file << "cesp/tabloc";
    conv_tab(file, "LOC"); 
    if (converti_ministeriali)
    { 
      file = studio;
      file << "cesp/tabat";
      conv_tab(file, "%CAT"); 
      file = studio;
      file << "cesp/tabca";
      conv_tab(file, "%CAC"); 
      file = studio;
      file << "cesp/tabgr";
      conv_tab(file, "%CGR"); 
      file = studio;
      file << "cesp/limit";
      conv_tab(file, "%CLM"); 
      file = studio;
      file << "cesp/tmvce";
      conv_tab(file, "%TMC"); 
    }
    // conversione parametri
    file = studio;
    file << "cesp/ditc01";
    conv_par(file, "DITC01", CONFIG_DITTA);
    file = studio;
    file << "cesp/ditca";
    conv_par(file, "DITCA", CONFIG_DITTA);
    message_box("Conversione completata");
    close_log();        
  }    
}

void TConversione_cespiti::open_log() 
{                  
  TFilename log;
  
  log << "ceconv.log";
  _log = fopen(log,"w");
  if (_log == NULL)
    fatal_box(FR("Non posso aprire il file di log della conversione(%s)"), (const char *) log);
}

void TConversione_cespiti::write_log(const char * line)
{         
  fprintf(_log,"%s\n", line);
}

void TConversione_cespiti::close_log()
{
  fclose(_log);
}

int TConversione_cespiti::conv_file(const TFilename& ofname, int nflogicnum)
{       
  long oldditta = -1;
  TDir d;
  d.get(nflogicnum);
  d.eod() = 0L;
  d.put(nflogicnum);

  TExternisamfile oldfile(ofname,(bool) FALSE,(bool) FALSE);

  TLocalisamfile* newfile = NULL; 
  const TRectype& oldrec = oldfile.curr();
  TString s;
  s.format(FR("Conversione tabella %s"), (const char*) ofname);
  TProgind pi(oldfile.eod(), s, FALSE, TRUE);
  
  TAssoc_array converted;
      
  bool to_convert = FALSE;
  for (int err = oldfile.first(); err == NOERR; err = oldfile.next())
  {                 
    pi.addstatus(1);
    // mi posiziono sulla ditta indicata
    const long ditta = oldfile.get_long("CODDITTA");               
    // i record sono ordinati per ditta!                                        
    if (oldditta != ditta)
    {
      oldditta = ditta;
      to_convert = daconvertire(ditta);
      if (to_convert)
      {        
        if (newfile) 
          delete newfile;
        set_firm(ditta); 
        
        TString16 str_ditta; str_ditta.format("%ld", ditta);
        if (!converted.is_key(str_ditta))
        {
          zap_file(nflogicnum);
          converted.add(str_ditta);
        }
        
        newfile = new TLocalisamfile(nflogicnum);
      }
      else                                                      
      {
        s.format(FR("La ditta %ld indicata nel file %s non é stata selezionata per la conversione"), ditta, (const char*) ofname);
        write_log(s);
      } 
    } 
    if (!to_convert)
      continue;
        
    // creo nuovo record        
    CHECK(newfile, "Miii");
    TRectype& newrec = newfile->curr();
    newrec.zero();    
    // setto i campi con lo stesso nome
    for (int i = 0; i < oldrec.items(); i++)
    {                                                          
      const char* fieldname = oldrec.fieldname(i);
      if (newrec.exist(fieldname))  
      {
        newrec.put(fieldname, oldfile.get(fieldname));
        if ((newrec.type(fieldname) != oldrec.type(fieldname)) && (newrec.type(fieldname)==_alfafld))
        {                       
          s = newrec.get(fieldname);
          if (s.not_empty())   // Non riempire di zeri i campi vuoti!
            s.right_just(newrec.length(fieldname),'0');
          newrec.put(fieldname, s);
        } 
      } 
    }
    // setto i campi che vanno elaborati pirsunalmente di pirsuna (nomi diversi)
    switch (nflogicnum)
    {
      case 136:
        s.format("%04d",get_codesc(oldfile.get_date("DTINES")));
        newrec.put("CODES", s);
        break;
      case 138:
        s.format("%04d",get_codesc(oldfile.get_date("DTINES")));
        newrec.put("CODES", s);
        newrec.put("CODCGRA", oldfile.get("AG0CGR"));
        newrec.put("CODSPA", oldfile.get("ATACSP"));
        newrec.put("CODCGR", oldfile.get("G0CGR"));
        newrec.put("CODSP", oldfile.get("TACSP"));
        newrec.put("CODCAT", oldfile.get("G0CCT"));
        break;
      case 139:
        newrec.put("CODCGRA", oldfile.get("AG0CGR"));
        newrec.put("CODSPA", oldfile.get("ATACSP"));
        newrec.put("CODCGR", oldfile.get("G0CGR"));
        newrec.put("CODSP", oldfile.get("TACSP"));
        newrec.put("CODCAT", oldfile.get("G0CCT"));
        break;
      case 142:
        newrec.put("CODMOV", oldfile.get("TPMOV"));
        newrec.put("STAMPATO", oldfile.get("STBOLLATO"));
        break;
      case 143:
        s.format("%04d",get_codesc(oldfile.get_date("DTINES")));
        newrec.put("CODES", s);
        break;
    } 
    // scrivo il record sul nuovo file
    newfile->write();
  }  
  if (newfile) 
    delete newfile;
  return 0;
}

void TConversione_cespiti::zap_table(const char* tab) const
{   
  if (tab && *tab)
  { 
    TTable newtab(tab);
    for (newtab.first(); !newtab.eof(); newtab.next()) 
      newtab.remove();
  }
  if (tab && *tab)
  { 
    const bool tabella_comune = (tab[0] == '%');
    if (tabella_comune)
    {
      TSystemisamfile f(LF_TABCOM);
      f.pack();
    }
    else  
    {
      TSystemisamfile f(LF_TAB);
      f.pack();
    }
  }
}

int TConversione_cespiti::conv_tab(const TFilename& ofname, const char* tab)
{       
  long oldditta = -1, ditta = -1;
  TExternisamfile oldfile(ofname,(bool)FALSE,(bool)FALSE);



  TTable* newfile = NULL;  
  TConfig config("ce0900.ini", tab);
  TAssoc_array& fieldlist = config.list_variables();
  const TString16 campoditta = config.get(CAMPODITTA);
  TString fieldname, fieldvalue;
  TAssoc_array converted;
 
  const bool tabella_comune = (tab[0] == '%');
    
  TString80 message;
  message.format(FR("Conversione tabella %s"), (const char*)ofname);
  TProgind pi(oldfile.eod(), message, FALSE, TRUE);
  
  bool to_convert = TRUE;
  for (int err = oldfile.first(); err == NOERR; err = oldfile.next())
  {                 
    pi.addstatus(1);
    if (!tabella_comune)
      ditta = oldfile.get_long(campoditta);               
    // mi posiziono sulla ditta indicata
    // i record sono ordinati per ditta!                                        
    if (oldditta != ditta)
    {
      oldditta = ditta;
      to_convert = daconvertire(ditta);
      if (to_convert)
      {
        if (newfile)
          delete newfile;
        set_firm(ditta); 
          
        TString16 str_ditta; str_ditta.format("%ld", ditta);
        if (!converted.is_key(str_ditta)) 
        {
          zap_table(tab);
          converted.add(str_ditta);
        }
        newfile = new TTable(tab);
      }
      else                                                      
      {
        TString256 s;
        s.format(FR("La ditta %ld indicata nel file %s non è stata selezionata per la conversione"), ditta, (const char*)ofname);
        write_log(s);
        continue;
      } 
    }
    if (!to_convert)
      continue;

    // creo nuovo record (Serve per tabelle comuni!)
    if (newfile == NULL)
      newfile = new TTable(tab);
    TRectype newrec = newfile->curr();
    newrec.zero();    
    // setto i campi indicati                   
    FOR_EACH_ASSOC_STRING(fieldlist, obj, key, str)
    {                 
      fieldname = key;
      fieldvalue = str;
      if ((fieldname != CAMPODITTA) && (fieldvalue[0]!='!') && (fieldvalue[0]!='?'))
        newrec.put(key, oldfile.get(str));
      else
      {
        if (fieldvalue[0] == '?')
          newrec.put(key,fieldvalue.sub(1));
        else if (fieldvalue == "!_ESERCIZIO2")
        {
          TString16 codtab, tmp;
          codtab.format("%04d",get_codesc(oldfile.get_date("CBDTI"), TRUE));
          tmp = oldfile.get("CBCGR");
          tmp.right_just(2,'0');
          codtab << tmp;
          tmp = oldfile.get("CBCSP");
          codtab << tmp;
          newrec.put(key, codtab);
        }
        else if (fieldvalue == "!_ESERCIZIO")
        {
          TString8 codtab;
          codtab.format("%04d",get_codesc(oldfile.get_date("CADTI")));
          newrec.put(key, codtab);
        }
        else if (fieldvalue == "!_CODIMP")
        {
          TString80 codtab;
          const TString& codimp = oldfile.get("CODIMP");
          if (!real::is_null(codimp))
          {
            codtab = codimp;
            codtab.right_just(10,'0');
          }
          newrec.put(key, codtab);
        }
        else if (fieldvalue == "!_CODLOC")
        {
          TString80 codtab;
          const TString& codloc = oldfile.get("CODLOC");
          if (!real::is_null(codloc))
          {
            codtab = codloc;
            codtab.right_just(10,'0');
          }
          newrec.put(key, codtab);
        }
        else if (fieldvalue == "!_CAT1")
        {
          TString16 codtab;
          const int gruppo = oldfile.get_int("TACGR");
          const TString16 specie(oldfile.get("TACSP"));
          codtab.format("%02d%s", gruppo,(const char*) specie);
          newrec.put(key, codtab);
        }
        else if (fieldvalue == "!_CAC1")
        {
          TString16 codtab;
          const int gruppo = oldfile.get_int("G0CGR");
          const TString16 specie(oldfile.get("TACSP"));
          const int categoria(oldfile.get_int("G0CCT"));
          if (gruppo == 0)
            codtab.format("      %02d",categoria);
          else
            codtab.format("%02d%-4s%02d", gruppo,(const char*) specie, categoria);
          newrec.put(key, codtab);
        }
        else if (fieldvalue == "!_CAC2")
        {
          TString80 codtab;
          int cod = oldfile.get_int("G0TCS");
          newrec.put(key, cod - 1);
        }
        else if (fieldvalue == "!_CLM1")
        {
          TString80 codtab;
          TDate data = oldfile.get_date("DTVALIM");
          codtab.format("%04d%2d%02d",data.year(),data.month(),data.day());
          newrec.put(key, codtab);
        }
        else if (fieldvalue == "!_CGR1")
        {
          TString80 codtab;
          codtab.format("%02d",oldfile.get_int("G0CGR"));
          newrec.put(key, codtab);
        }
        else if (fieldvalue == "!_TMC1")
        {
          TString80 cod = "";
          cod << conv_imptmc(oldfile.get_int("IMP01"));
          cod << " ";
          cod << conv_imptmc(oldfile.get_int("IMP03"));
          cod << conv_imptmc(oldfile.get_int("IMP04"));
          cod << conv_imptmc(oldfile.get_int("IMP05"));
          cod << conv_imptmc(oldfile.get_int("IMP06"));
          cod << conv_imptmc(oldfile.get_int("IMP07"));
          cod << conv_imptmc(oldfile.get_int("IMP08"));
          cod << conv_imptmc(oldfile.get_int("IMP09"));
          cod << conv_imptmc(oldfile.get_int("IMP10"));
          cod << conv_imptmc(oldfile.get_int("IMP11"));
          cod << conv_imptmc(oldfile.get_int("IMP12"));
          cod << conv_imptmc(oldfile.get_int("IMP13"));
          newrec.put(key, cod);
        }        
        else if (fieldvalue == "!_TMC2")
        {
          int num = oldfile.get_int("M0TTBL");
          TString16 cod;
          switch (num)
          {
            case 1:  
              cod = "I";
            break;  
            case 2:  
              cod = "E";
            break;  
            case 3:  
              cod = "P";
            break;  
            case 4:  
              cod = "R";
            break;  
            case 5:  
              cod = " ";
            break;  
            default:  
              cod = " ";
          }
          newrec.put(key, cod);
        }
        else if (fieldvalue == "!_TMC3")
        {
          TString16 cod;
          int num = oldfile.get_int("M0SEGN");
          switch (num)
          {
          case 1: 
            cod = "=";
          break;
          case 2:
            cod = "+";
          break;
          case 3:
            cod = "-";
          break;
          default:
          cod = " ";
          }
          newrec.put(key, cod);
        }  
        else if (fieldvalue == "!_CCE1")
        {
          TString16 cod;
          int num = oldfile.get_int("CATAR");
          switch (num)
          {
          case 1: 
            cod = "+";
          break;
          case 2:
            cod = "-";
          break;
          case 3:
            cod = "/";
          break;
          default:
          cod = " ";
          }
          newrec.put(key, cod);
        }
      } 
    }  
    // scrivo il record sul nuovo file
    newrec.write(*newfile);
  }  
  if (newfile)
    delete newfile;
  return 0;
}

int TConversione_cespiti::conv_inifile(const TFilename& ofname, const char* ofpar, int nflogicnum)
{       
  long oldditta = -1;
  long ditta;
  TDir d;
  d.get(nflogicnum);
  d.eod() = 0L;
  d.put(nflogicnum);
  TSystemisamfile f(nflogicnum);
  int err = f.pack();
  if (err == NOERR)
  {
    TExternisamfile oldfile(ofname,(bool)FALSE,(bool)FALSE);

    TLocalisamfile* newfile = new TLocalisamfile(nflogicnum);   
    TConfig config("ce0900.ini", (const char*) ofpar);
    TAssoc_array& fieldlist = config.list_variables();
    TString& campoditta = (TString&) config.get(CAMPODITTA);
    TString fieldname, fieldvalue;
    TRectype oldrec = oldfile.curr();
    TRectype newrec = newfile->curr();
    TString80 message;
    message.format(FR("Conversione tabella %s"), (const char*) ofname);
    TProgind pi(oldfile.eod(),message, FALSE, TRUE, 10);
    for (int err = oldfile.first(); err == NOERR; err = oldfile.next())
    {                 
      pi.addstatus(1);
      // mi posiziono sulla ditta indicata
      ditta = oldfile.get_long(campoditta);               
      // i record sono ordinati per ditta!                                        
      if (oldditta != ditta)
      {
        oldditta = ditta;
        if (daconvertire(ditta))
          set_firm(ditta);                                        
        else            
        {
          TString256 s;
          s.format(FR("La ditta %ld indicata nel file %s non é stata selezionata per la conversione"), ditta, (const char*) ofname);
          write_log(s);
          continue;
        } 
      }  
      // creo nuovo record        
      newrec.zero();    
      // setto i campi indicati                   
      FOR_EACH_ASSOC_STRING(fieldlist, obj, key, str)
      {                 
        fieldname = key;
        fieldvalue = str;
        if ((fieldname != CAMPODITTA) && (fieldvalue[0]!='!'))
          newrec.put(key, oldfile.get(str));
        else
        {
          if (fieldvalue.mid(0,4) == "!_GR")
          {
            TString80 tmp;
            tmp = oldfile.get(fieldvalue.mid(5));
            newrec.put(key,atoi(tmp.mid(0,3)));
          }
          else if (fieldvalue.mid(0,4) == "!_CO")
          {
            TString80 tmp;
            tmp = oldfile.get(fieldvalue.mid(5));
            newrec.put(key,atoi(tmp.mid(3,3)));
          }
          else if (fieldvalue.sub(0,4) == "!_SO")
          {
            TString80 tmp;
            tmp = oldfile.get(fieldvalue.mid(5));
            newrec.put(key,atol(tmp.mid(6,6)));
          }
        } 
      } 
      // scrivo il record sul nuovo file
      newrec.write(*newfile);
    }
    delete newfile;
  }
  else  
    error_box(FR("Errore in compattamento dati.\nFile %d : %d"), nflogicnum,err);
  return 0;
}

int TConversione_cespiti::conv_par(const TFilename& ofname, const char* ofpar, int which_config)
{       
  long oldditta = -1;
  long ditta;
  TExternisamfile oldfile(ofname,(bool)FALSE,(bool)FALSE);

  TConfig newconfig(which_config, "ce");
  TConfig config("ce0900.ini", (const char*) ofpar);
  TAssoc_array& fieldlist = config.list_variables();
  TString& campoditta = (TString&) config.get(CAMPODITTA);
  TString fieldname, fieldvalue;
  TRectype oldrec = oldfile.curr();
  TString80 message;
  message.format(FR("Conversione tabella %s"), (const char*) ofname);
  TProgind pi(oldfile.eod(),message, FALSE, TRUE);
  for (int err = oldfile.first(); err == NOERR; err = oldfile.next())
  {                 
    pi.addstatus(1);
    if (campoditta.not_empty())
    {
      // mi posiziono sulla ditta indicata
      ditta = oldfile.get_long(campoditta);               
      // i record sono ordinati per ditta!                                        
      if (oldditta != ditta)
      {
        oldditta = ditta;
        if (daconvertire(ditta))
        {
          set_firm(ditta);                                        
          newconfig.set_paragraph("cg");
          newconfig = TConfig(which_config, "ce");
        } 
        else                                                      
        {
          TString256 s;
          s.format(FR("La ditta %ld indicata nel file %s non é stata selezionata per la conversione"), ditta, (const char*) ofname);
          write_log(s);
          continue;
        } 
      } 
    } 
    // setto i campi indicati                   
    FOR_EACH_ASSOC_STRING(fieldlist, obj, key, str)
    {                 
      fieldname = key;
      fieldvalue = str;
      if ((fieldname != CAMPODITTA) && (fieldvalue[0]!='!'))
        newconfig.set(key,  oldfile.get(str));
      else
      {
        if (fieldvalue.mid(0,4) == "!_GR")
        {
          TString80 tmp;
          tmp = oldfile.get(fieldvalue.mid(5));
          newconfig.set(key,atoi(tmp.mid(0,3)));
        }
        else if (fieldvalue.mid(0,4) == "!_CO")
        {
          TString80 tmp;
          tmp = oldfile.get(fieldvalue.mid(5));
          newconfig.set(key,atoi(tmp.mid(3,3)));
        }
        else if (fieldvalue.sub(0,4) == "!_SO")
        {
          TString80 tmp;
          tmp = oldfile.get(fieldvalue.mid(5));
          newconfig.set(key,atol(tmp.mid(6,6)));
        }
        else if (fieldvalue.sub(0,4) == "!_ES")
          newconfig.set(key,get_codesc(oldfile.get_date(fieldvalue.mid(5))));
        else if (fieldvalue.sub(0,4) == "!_AN")
        {
          TString80 tmp;
          tmp = oldfile.get(fieldvalue.mid(5));
          newconfig.set(key,tmp.mid(6));
        } 
      } 
    } 
    // verificare se occorre registrare (di solito si cambia paragrafo)
  }
  return 0;
}

int TConversione_cespiti::get_codesc(const TDate& date, const bool fatal)
{
  TEsercizi_contabili esercizi;
  int esc = esercizi.date2esc(date);
  if (esc <= 0)
  {
    TString s;
    s << TR("La ditta ") << get_firm() << TR(" non ha un esercizio con data iniziale ");
    s << date.string();
    write_log(s);
    if (fatal)
      fatal_box(s);
    else
      esc = date.year();
  }          
  return esc;
}

const char TConversione_cespiti::conv_imptmc(int cod)
{
  switch (cod)
  {
    case 1:
      return 'S';
    break;
    case 2:
      return 'N';
    break;
    case 3:
      return 'O';
    break;
    default:
      return ' ';
  }
  return ' ';   
}

//funzione che ritorna il nome del file dei dati da resettare con la zap_file
HIDDEN const TString& build_name(int logicnum)
{
  TDir d; d.get(logicnum, _nolock, _nordir, _sysdirop);
  static TFilename _filename;
  _filename = d.filename();  
  return _filename;
}

//funzione per resettare i files e gli indici
int TConversione_cespiti::zap_file(int lf) const
{ 
  TFilename name = build_name(lf);
  if (name[0] == '%') name.ltrim(1);
  TExternisamfile f(name);
  return f.zap();
}


int ce0900(int argc, char* argv[])
{
  TConversione_cespiti a ;
  a.run(argc, argv, TR("Conversione cespiti"));
  return 0;
}