#include "cg6900.h"
#include "cg6900a.h"
#include <math.h>  

bool TInv_cont::invio_contabilita_PC()
{
  char    sigla;
  TString nrec,files;               
  bool    header = TRUE;
  int     size = 1024;
  
  _numrec_cau   = 0;
  _numrec_clifo = 0;
  _numrec_pcon  = 0;
  _numrec_pn    = 0;
  _numrec_iva   = 0;
  
  _tras_file.open(_header);
  
  leggi_record_controllo();

  files  = _tras_file.sigle_file();
  nrec   = _tras_file.nrec_file();
  files.trim();

  _tras_file.open(_trasf,TRUE);  
  
  for (int i = 0; i < files.len();i++)
  {                 
    sigla    = files[i];
    //_numrec  = atol(nrec.mid(i * 6,6));

    if (header)
    {  
      _control_rec.cut(size);          
      
      _control_rec.overwrite("     ",300); //Nel caso di invio a PC pulisco la ditta aggiuntiva dal record di controllo
      
      _tras_file.write_control_rec(_control_rec,size);      
      header = FALSE;
    }
    
    switch (sigla)        
    {
      case 'W':
      { 
        long cicli = _tcaus->items() + _trcaus->items();    
        _prog = new TProgind(cicli,"Tabella Causali: generazione file TRASFER per PC\nPrego attendere.",FALSE);      
        invio_testata_causali();
        invio_righe_causali();
        delete _prog;                               
        break;
      }
      case 'A':
        invio_clienti_fornitori();
        break;
      
      case 'P':
        invio_piano_conti();
        break;
      
      case 'Z': 
      {
        long cicli = _tmov->items() + _trmov->items();
        _prog = new TProgind(cicli,"Movimenti di Prima nota: generazione file TRASFER per PC\nPrego attendere.",FALSE);
        invio_testata_movimenti();
        invio_righe_contabili();
        delete _prog;
        break;
      }  
      case 'U':
        invio_righe_IVA();
        break;
      
      default:
        break;
    };             
  }
   
  aggiorna_header(files);
  aggiorna_trasfer(files);
  
  TString str;
  
  calcola_totale_record();
  str.format("%06ld", _tot_rec);
  aggiorna_marker(str,26);  
    
  return TRUE;
}

void TInv_cont::invio_testata_causali()
{                      
  int size = 1024;
  TString record(size);
  TString cod;

  _tras_file.open(_trasf,TRUE);
      
  for (_tcaus->first(); !_tcaus->eof(); _tcaus->next())
  { 
    TString str;
    
    _prog->addstatus(1);
    
    record.spaces();                                                     
    
    const char* codcau = _tcaus->get(CAU_CODCAUS);
    if (real::is_natural(codcau))
      str.format("%03s", (const char*) codcau);
    else
      str.format("%-3s", (const char*) codcau);
    record.overwrite("W1",0);                    //Tipo record
    record.overwrite(str,2);                     //Codice causale
    
    TString descr = _tcaus->get(CAU_DESCR);
    descr.format("%-50s", (const char*) descr); 
    record.overwrite(descr,60);                  //Descrizione
    
    TString tipodoc = _tcaus->get(CAU_TIPODOC);
    str.format("%-2s", (const char*) tipodoc);
    record.overwrite(tipodoc,110);               //Tipo documento
    
    TString movap = _tcaus->get(CAU_MOVAP);
    if (movap.not_empty())
      record.overwrite(movap,112);
      
    bool alleg = _tcaus->get_bool(CAU_ALLEG);
    if (alleg)
      record.overwrite("X",113);    
    else
      record.overwrite(" ",113);
                              
    bool intracom = _tcaus->get_bool(CAU_INTRACOM);
    if (intracom)
      record.overwrite("X",114);
    else 
      record.overwrite(" ",114);      
                                
    TString reg = _tcaus->get(CAU_REG); 
    if (real::is_natural(reg))
    {
      int app = atoi(reg);
      reg.format("%03d", app);
    }                
    else
      reg.format("%-3s", (const char*) reg);
    record.overwrite(reg,115);                   //Registro IVA
    
    bool movval = _tcaus->get_bool(CAU_MOVVAL);
    if (movval)
      record.overwrite("X",118);
    else
      record.overwrite(" ",118);      

    int tipomov = _tcaus->get_int(CAU_TIPOMOV);
    str.format("%d", tipomov);
    record.overwrite(str,119);
    
    bool datadoc = _tcaus->get_bool(CAU_DATADOC);
    if (datadoc)
      record.overwrite("X",120);
    else                                         //Flag immissione data documento
      record.overwrite(" ",120);                                                 

    bool numdoc = _tcaus->get_bool(CAU_NUMDOC);
    if (numdoc)
      record.overwrite("X",121);
    else                                         //Flag immissione numero documento
      record.overwrite(" ",121);

    bool autofatt = _tcaus->get_bool(CAU_AUTOFATT);
    if (autofatt)
      record.overwrite("X",122);
    else                                         //Autofattura art.34
      record.overwrite(" ",122);  

    bool ritfatt = _tcaus->get_bool(CAU_RITFATT);
    if (ritfatt)
      record.overwrite("X",123);
    else                                         //Flag causale per fattura ricevuta in ritardo
      record.overwrite(" ",123);                                                               

    TString cespiti = _tcaus->get(CAU_COLLCESP);
    if (cespiti.not_empty())
      record.overwrite(cespiti,124);             //Collegamento cespiti
      
    TString m770 = _tcaus->get(CAU_M770);
    if (m770.not_empty())  
      record.overwrite(m770,125);                //Collegamento modello 770
    
    const char* codcausim = _tcaus->get(CAU_CODCAUSIM);
    if (real::is_natural(codcausim))
      str.format("%03s", (const char*) codcausim);
    else
      str.format("%-3s", (const char*) codcausim);
    record.overwrite(str,126);                   //Codice causale per incasso immediato
    
    bool sospeso = _tcaus->get_bool(CAU_SOSPESO);
    if (sospeso)
      record.overwrite("X",129);
    else
      record.overwrite(" ",129);
      
    bool valintra = _tcaus->get_bool(CAU_VALINTRA);
    if (valintra)
      record.overwrite("X",130);
    else                                         //Gestione valuta per oper. intracomunitarie
      record.overwrite(" ",130);                                                             
    
    _numrec_cau++;            

    _tras_file.write_control_rec(record,size);
  }
  
  _tras_file.close();  
}

void TInv_cont::invio_righe_causali()
{                      
  int size = 1024;
  TString record(size);
  TString cod;
  
  _tras_file.open(_trasf,TRUE);
      
  for (_trcaus->first(); !_trcaus->eof(); _trcaus->next())
  { 
    TString str;
    
    _prog->addstatus(1);
    
    record.spaces();                                                     
    
    const char* codcau = _trcaus->get(CAU_CODCAUS);
    if (real::is_natural(codcau))
      str.format("%03s", (const char*) codcau);
    else
      str.format("%-3s", (const char*) codcau);
    record.overwrite("W2",0);                    //Tipo record
    record.overwrite(str,2);                     //Codice causale

    int  nriga = _trcaus->get_int(RCA_NRIGA);
    str.format("%03d", nriga);
    record.overwrite(str,5);
        
    int  g = _trcaus->get_int (RCA_GRUPPO);
    str.format("%03d", g);
    record.overwrite(str,60);      //Gruppo

    int  c = _trcaus->get_int (RCA_CONTO);  
    str.format("%03d", c);
    record.overwrite(str,63);      //Conto
        
    long s = _trcaus->get_long(RCA_SOTTOCONTO);
    str.format("%06ld", s);
    record.overwrite(str,66);      //Sottoconto

    TString coddesc = _trcaus->get(RCA_CODDESC);
    str.format("%-5s", (const char*) coddesc);
    record.overwrite(str,72);     //Codice descrizione
    
    TString sez = _trcaus->get(RCA_SEZIONE);
    record.overwrite(sez,77);     //Sezione
                                                       
    _tras_file.write_control_rec(record,size);
  } 
  _tras_file.close();  
}

void TInv_cont::invio_clienti_fornitori()
{
  int size = 1024;
  TString record(size);

  long cicli = _tclifo->items();
  _prog = new TProgind(cicli,"Anagrafica Clienti/Fornitori: generazione file TRASFER per PC\nPrego attendere.",FALSE);

  _tras_file.open(_trasf,TRUE);      
  
  for (_tclifo->first(); !_tclifo->eof(); _tclifo->next())
  { 
    TString str;
    
    _prog->addstatus(1);
    
    record.spaces();                                                     
    
    TString tipo = _tclifo->get(CLI_TIPOCF);
    record.overwrite("A1",0);                  //Tipo record
    record.overwrite(tipo,2);                  //Tipo cliente/fornitore
    
    long codice = _tclifo->get_long(CLI_CODCF);
    str.format("%06ld", codice);
    record.overwrite(str,3);                   //Codice cliente/fornitore    
    
    TString ragsoc = _tclifo->get(CLI_RAGSOC);
    str.format("%-50s", (const char*) ragsoc);
    record.overwrite(str,60);                  //Ragione sociale
    
    TString indcf = _tclifo->get(CLI_INDCF);
    str.format("%-35s", (const char*) indcf);
    record.overwrite(str,110);                 //Indirizzo
    
    TString civcf = _tclifo->get(CLI_CIVCF);
    str.format("%-10s", (const char*) civcf);
    record.overwrite(str,145);                 //Numero civico
    
    TString localita = _tclifo->get(CLI_LOCCF);
    str.format("%-35s", (const char*) localita);
    record.overwrite(str,155);                 //Localita'

    TString stato = _tclifo->get(CLI_STATOCF);
    str.format("%-3s", (const char*) stato);
    record.overwrite(str,190);                 //Stato

    TString comcf = _tclifo->get(CLI_COMCF);  
    str.format("%-4s", (const char*) comcf);
    record.overwrite(str,193);                 //Comune
    
    TString capcf = _tclifo->get(CLI_CAPCF);
    str.format("%-5s", (const char*) capcf);
    record.overwrite(str,247);                 //Codice di avviamento postale

    TString cofi = _tclifo->get(CLI_COFI);
    str.format("%-16s", (const char*) cofi);
    record.overwrite(str,252);                 //Codice fiscale
                            
    TString statopaiv = _tclifo->get(CLI_STATOPAIV);
    str.format("%-2s", (const char*) statopaiv);
    record.overwrite(str,268);                 //Stato partita iva
    
    TString paiv = _tclifo->get(CLI_PAIV);
    str.format("%-12s", (const char*) paiv);
    record.overwrite(str,270);                 //Partita IVA    

    TString tipop = _tclifo->get(CLI_TIPOPERS);
    record.overwrite(tipop,282);               //Tipo persona

    TString alleg = _tclifo->get(CLI_ALLEG);
    record.overwrite(alleg,283);               //Flag gestione allegato

    long codalleg = _tclifo->get_long(CLI_CODALLEG);
    str.format("%06ld", codalleg);
    record.overwrite(str,284);

    int  gruppo = _tclifo->get_int (CLI_GRUPPO);
    int  conto  = _tclifo->get_int (CLI_CONTO);
    str.format("%03d", gruppo);
    record.overwrite(str,290);                 //Gruppo prevalente
    str.format("%03d", conto);     
    record.overwrite(str,293);                 //Conto prevalente

    int  gruppor = _tclifo->get_int (CLI_GRUPPORIC);
    int  contor  = _tclifo->get_int (CLI_CONTORIC);
    long sottocr = _tclifo->get_long(CLI_SOTTOCRIC);
    str.format("%03d", gruppor);
    record.overwrite(str,296);                 //Gruppo di costo/ricavo
    str.format("%03d", contor);
    record.overwrite(str,299);                 //Conto di costo/ricavo
    str.format("%06ld", sottocr);
    record.overwrite(str,302);                 //Sottoconto di costo/ricavo
    
    TString ptel = _tclifo->get(CLI_PTEL);
    str.format("%-10s", (const char*) ptel);
    record.overwrite(str,308);
    
    TString tel = _tclifo->get(CLI_TEL);
    str.format("%-30s", (const char*) tel);
    record.overwrite(str,318);
    
    TString ptel2 = _tclifo->get(CLI_PTEL2);
    str.format("%-10s", (const char*) ptel2);
    record.overwrite(str,348);
    
    TString tel2 = _tclifo->get(CLI_TEL2);
    str.format("%-30s", (const char*) tel2);
    record.overwrite(str,358);

    TString ptel3 = _tclifo->get(CLI_PTEL3);
    str.format("%-10s", (const char*) ptel3);
    record.overwrite(str,388);
    
    TString tel3 = _tclifo->get(CLI_TEL3);
    str.format("%-30s", (const char*) tel3);
    record.overwrite(str,398);

    TString pfax = _tclifo->get(CLI_PFAX);
    str.format("%-10s", (const char*) pfax);
    record.overwrite(str,428);
    
    TString fax = _tclifo->get(CLI_FAX);
    str.format("%-30s", (const char*) fax);
    record.overwrite(str,438);

    TString ptelex = _tclifo->get(CLI_PTELEX);
    str.format("%-10s", (const char*) ptelex);
    record.overwrite(str,468);
    
    TString telex = _tclifo->get(CLI_TELEX);
    str.format("%-30s", (const char*) telex);
    record.overwrite(str,478);
  
    TString data = _tclifo->get(CLI_DATANASC);
    TString app  = riconverti(data,TRUE); 
    str.format("%08s", (const char*) app);
    record.overwrite(str,508);                    //Data di registrazione
                        
    int statonasc = _tclifo->get_int(CLI_STATONASC);
    str.format("%03d", statonasc);
    record.overwrite(str,516);
    
    TString comnasc = _tclifo->get(CLI_COMNASC);   
    str.format("%-4s", (const char*) comnasc);
    record.overwrite(str,519);
    
    TString codstat = _tclifo->get(CLI_CODSTAT);
    str.format("%-7s", (const char*) codstat);
    record.overwrite(str,573);
    
    long codabi = _tclifo->get_long(CLI_CODABI);
    str.format("%05ld", codabi);
    record.overwrite(str,580);
    
    long codcab = _tclifo->get_long(CLI_CODCAB);
    str.format("%05ld", codcab);
    record.overwrite(str,585);
    
    bool occas = _tclifo->get_bool(CLI_OCCAS);
    if (occas)
      record.overwrite("X", 590);
    else
      record.overwrite(" ", 590);
      
    TString codval = _tclifo->get(CLI_CODVAL);
    str.format("%-3s", (const char*) codval);
    record.overwrite(str,591);
    
    TString codlin = _tclifo->get(CLI_CODLIN);
    record.overwrite(codlin,594);
    
    real fido (_tclifo->get_real(CLI_FIDO));
    str.format("%015s", (const char*) fido.string());
    record.overwrite(str,595);

    TString codpag = _tclifo->get(CLI_CODPAG);
    str.format("%-4s", (const char*) codpag);
    record.overwrite(str,610);
    
    bool sospeso = _tclifo->get_bool(CLI_SOSPESO);
    if (sospeso)
      record.overwrite("X",614);
    else
      record.overwrite(" ",614);
      
    _numrec_clifo++;            

    _tras_file.write_control_rec(record,size);
  } 
  delete _prog;  

  _tras_file.close();  
}

void TInv_cont::invio_piano_conti()
{
  int size = 1024;
  TString record(size);

  long cicli = _tpcon->items();
  _prog = new TProgind(cicli,"Anagrafica Piano Conti: generazione file TRASFER per PC\nPrego attendere.",FALSE);

  _tras_file.open(_trasf,TRUE);
      
  for (_tpcon->first(); !_tpcon->eof(); _tpcon->next())
  { 
    TString str;
    
    _prog->addstatus(1);
        
    record.spaces();                                                     
    
    int  g = _tpcon->get_int (PCN_GRUPPO); 
    int  c = _tpcon->get_int (PCN_CONTO);
    long s = _tpcon->get_long(PCN_SOTTOCONTO);

    // Se si tratta di un GRUPPO 

    if (g != 0 && c == 0 && s == 0)
    {                                                
      record.overwrite("P1",0);                  //Tipo record
      str.format("%03d", g);
      record.overwrite(str,2);                   //Gruppo
      
      TString descr (_tpcon->get(PCN_DESCR));
      str.format("%-50s", (const char*) descr);
      record.overwrite(str,60);                  //Descrizione gruppo   
    }
    
    // Se si tratta di un CONTO

    if (g != 0 && c != 0 && s == 0)
    {
      record.overwrite("P2",0);                  //Tipo record
      str.format("%03d", g);
      record.overwrite(str,2);                   //Gruppo
      
      str.format("%03d", c);
      record.overwrite(str,5);                   //Conto
      
      TString descr (_tpcon->get(PCN_DESCR));
      str.format("%-50s", (const char*) descr);
      record.overwrite(str,60);                  //Descrizione conto
      
      int indbil = _tpcon->get_int(PCN_INDBIL);
      str.format("%d", indbil);
      record.overwrite(str,110);                  //Indicatore di bilancio
      
      TString tmcf = _tpcon->get(PCN_TMCF);
      record.overwrite(tmcf,111);                 //Flag conto cliente/fornitore
      
      bool stsottbil = _tpcon->get_bool(PCN_STSOTTBIL);
      if (stsottbil)
        record.overwrite("X",112);
      else
        record.overwrite(str,112);                //Flag stampa dettaglio sottoconti su bilancio

      bool compens = _tpcon->get_bool(PCN_COMPENS);
      if (compens)
        record.overwrite("X",113);
      else
        record.overwrite(" ",113);
        
      // Classe IV direttiva CEE
      
      TString sez = _tpcon->get(PCN_SEZIVD);
      if (sez == "0")
        sez = " ";
      record.overwrite(sez,114);                  //Sezione IV dir
      
      TString let = _tpcon->get(PCN_LETTIVD);
      record.overwrite(let,115);                  //Lettera IV dir
      
      int numrom = atoi(_tpcon->get(PCN_NUMRIVD));
      str.format("%8d", numrom);
      record.overwrite(str,116);                  //Numero romano IV dir
      
      int num = _tpcon->get_int(PCN_NUMIVD);
      str.format("%02d", num);
      record.overwrite(str,124);                  //Numero arabo IV dir

      // Classe IV direttiva CEE di segno opposto
      
      TString sezop = _tpcon->get(PCN_SEZIVDOPP);
      if (sezop == "0")
        sezop = " ";
      record.overwrite(sezop,126);                //Sezione IV dir
      
      TString letop = _tpcon->get(PCN_LETTIVDOPP);
      record.overwrite(letop,127);                //Lettera IV dir
      
      int numromop = atoi(_tpcon->get(PCN_NUMRIVDOPP));
      str.format("%8d", numromop);
      record.overwrite(str,128);                  //Numero romano IV dir
      
      int numop = _tpcon->get_int(PCN_NUMIVDOPP);
      str.format("%02d", numop);
      record.overwrite(str,136);                  //Numero arabo IV dir      
    }
    
    // Se si tratta di un SOTTOCONTO

    if (g != 0 && c != 0 && s != 0)
    {
      record.overwrite("P3",0);                  //Tipo record
      str.format("%03d", g);
      record.overwrite(str,2);                   //Gruppo
      
      str.format("%03d", c);
      record.overwrite(str,5);                   //Conto
      
      str.format("%06ld", s);
      record.overwrite(str,8);                   //Sottoconto
      
      TString descr (_tpcon->get(PCN_DESCR));
      str.format("%-50s", (const char*) descr);
      record.overwrite(str,60);                  //Descrizione sottoconto
      
      int tipospric = _tpcon->get_int(PCN_TIPOSPRIC);
      str.format("%d", tipospric);
      record.overwrite(str,110);                  //Tipo costo/ricavo

      TString sezsaldi = _tpcon->get(PCN_SEZSALDI);
      record.overwrite(sezsaldi,111);
      
      bool sospeso = _tpcon->get_bool(PCN_SOSPESO);
      if (sospeso)
        record.overwrite("X",112);
      else
        record.overwrite(" ",112);

      // Classe IV direttiva CEE
      
      TString sez = _tpcon->get(PCN_SEZIVD);
      if (sez == "0")
        sez = " ";
      record.overwrite(sez,113);                  //Sezione IV dir
      
      TString let = _tpcon->get(PCN_LETTIVD);
      record.overwrite(let,114);                  //Lettera IV dir
      
      int numrom = atoi(_tpcon->get(PCN_NUMRIVD));
      str.format("%8d", numrom);
      record.overwrite(str,115);                  //Numero romano IV dir
      
      int num = _tpcon->get_int(PCN_NUMIVD);
      str.format("%02d", num);
      record.overwrite(str,123);                  //Numero arabo IV dir

      // Classe IV direttiva CEE di segno opposto
      
      TString sezop = _tpcon->get(PCN_SEZIVDOPP);
      if (sezop == "0")
        sezop = " ";
      record.overwrite(sezop,125);                //Sezione IV dir
      
      TString letop = _tpcon->get(PCN_LETTIVDOPP);
      record.overwrite(letop,126);                //Lettera IV dir
      
      int numromop = atoi(_tpcon->get(PCN_NUMRIVDOPP));
      str.format("%8d", numromop);
      record.overwrite(str,127);                  //Numero romano IV dir
      
      int numop = _tpcon->get_int(PCN_NUMIVDOPP);
      str.format("%02d", numop);
      record.overwrite(str,135);                  //Numero arabo IV dir      
      
      int ricser = _tpcon->get_int(PCN_RICSER);
      str.format("%d", ricser);                      
      record.overwrite(str,137);                    //Tipo attivita'      
    }

    _numrec_pcon++;            

    _tras_file.write_control_rec(record,size);
  } 
  delete _prog;      
  
  _tras_file.close();  
}

void TInv_cont::invio_testata_movimenti()
{                                         
  int     size = 1024;
  TString record(size);
  TString datastr;

  _tras_file.open(_trasf,TRUE);

  for (_tmov->first(); !_tmov->eof(); _tmov->next())
  { 
    TString str;
    
    _prog->addstatus(1);
        
    record.spaces();
  
    record.overwrite("Z1",0);                    //Tipo record

    long nreg = _tmov->get_long(MOV_NUMREG);
    str.format("%07ld", nreg);
    record.overwrite(str,2);                     //Numero di registrazione

    TString datareg = _tmov->get(MOV_DATAREG);   
    datastr = riconverti(datareg,TRUE); 
    str.format("%08s", (const char*) datastr);
    record.overwrite(str,60);                    //Data di registrazione

    TString datacomp = _tmov->get(MOV_DATACOMP);   
    datastr = riconverti(datacomp,TRUE); 
    str.format("%08s", (const char*) datastr);
    record.overwrite(str,68);                    //Data di registrazione

    TString datadoc = _tmov->get(MOV_DATADOC);
    datastr = riconverti(datadoc,TRUE); 
    str.format("%08s", (const char*) datastr);
    record.overwrite(str,76);                    //Data di registrazione
  
    TString data74ter = _tmov->get(MOV_DATA74TER);
    datastr = riconverti(data74ter,TRUE); 
    str.format("%08s", (const char*) datastr);
    record.overwrite(str,84);                    //Data di registrazione

    TString numdoc = _tmov->get(MOV_NUMDOC);    
    str.format("%-7s", (const char*) numdoc);
    record.overwrite(str,92);    
    
    const char* codcaus = _tmov->get(MOV_CODCAUS);
    if (real::is_natural(codcaus))
      str.format("%03s", (const char*) codcaus);
    else
      str.format("%-3s", (const char*) codcaus);
    record.overwrite(str,99);                     //Codice causale

    TString descr = _tmov->get(MOV_DESCR);
    str.format("%-50s", (const char*) descr);
    record.overwrite(str,102);
    
    const char* reg = _tmov->get(MOV_REG);
    TString registro;
    if (real::is_natural(reg))
    {
      int app = atoi(reg);
      registro.format("%03d", app);
    }  
    else
      registro.format("%-3s", (const char*) reg);
    record.overwrite(registro,152);                   //Codice registro IVA

    long protiva = _tmov->get_long(MOV_PROTIVA);    
    str.format("%05ld", protiva);
    record.overwrite(str,155);                    //Numero protocollo IVA

    long uprotiva = _tmov->get_long(MOV_UPROTIVA);    
    str.format("%05ld", uprotiva);
    record.overwrite(str,160);                   //Ultimo numero di protocollo IVA
    
    bool regst = _tmov->get_bool(MOV_REGST);
    if (regst)
      record.overwrite("X",165);
    else
      record.overwrite(" ",165);

    bool stampato = _tmov->get_bool(MOV_STAMPATO);
    if (stampato)
      record.overwrite("X",166);
    else
      record.overwrite(" ",166);

    long numgio = _tmov->get_long(MOV_NUMGIO);
    str.format("%07ld", numgio);
    record.overwrite(str,167);
    
    long codcf = _tmov->get_long(MOV_CODCF);
    str.format("%06ld", codcf);
    record.overwrite(str,174);

    real totdoc (_tmov->get_real(MOV_TOTDOC));   
    if (totdoc.sign() < 0) 
    {
      record.overwrite("-",180);
      totdoc = totdoc * -1;
    }
    else
      record.overwrite("+",180);  
    str.format("%014s", (const char*) totdoc.string());
    record.overwrite(str,181);
                    
    real ritfis (_tmov->get_real(MOV_RITFIS));
    if (ritfis.sign() < 0)
    {
      record.overwrite("-",195);
      ritfis = ritfis * -1;
    }
    else
      record.overwrite("+",195);    
    str.format("%014s", (const char*) ritfis.string());
    record.overwrite(str,196);

    real ritsoc (_tmov->get_real(MOV_RITSOC));
    if (ritsoc.sign() < 0)
    {
      record.overwrite("-",210);
      ritsoc = ritsoc * -1;
    }
    else
      record.overwrite("+",210);
    str.format("%014s", (const char*) ritsoc.string());
    record.overwrite(str,211);

    TString codvali = _tmov->get(MOV_CODVALI);
    str.format("%-3s", (const char*) codvali);
    record.overwrite(str,225);

    real cambioi (_tmov->get_real(MOV_CAMBIOI));  
    dec2integer(cambioi,100000);                                          
    str.format("%014s", (const char*) cambioi.string());
    record.overwrite(str,228);
      
    real corrlire (_tmov->get_real(MOV_CORRLIRE));                        
    if (corrlire.sign() < 0)
    {
      record.overwrite("-",242);
      corrlire = corrlire * -1;
    }
    else
      record.overwrite("+",242);                                                    
    str.format("%014s", (const char*) corrlire.string());
    record.overwrite(str,243);

    real corrvaluta (_tmov->get_real(MOV_CORRVALUTA));                        
    if (corrvaluta.sign() < 0)
    {
      record.overwrite("-",257);
      corrvaluta = corrvaluta * -1;
    }
    else
      record.overwrite("+",257);    
    dec2integer(corrvaluta,100);                                                
    str.format("%016s", (const char*) corrvaluta.string());
    record.overwrite(str,258);

    TString ocfpi = _tmov->get(MOV_OCFPI);
    str.format("%-16s", (const char*) ocfpi);
    record.overwrite(str,274);

    if (ocfpi.not_empty())  
      invio_occasionali(record,ocfpi);                 
      
    _tras_file.write_control_rec(record,size);               
  }                                        
  _tras_file.close();                        
}

void TInv_cont::invio_occasionali(TString& record, TString& ocfpi)
{    
  TString str;
  
  _toccas->setkey(1);
  _toccas->zero();
  _toccas->put(OCC_CFPI, ocfpi);
  if (_toccas->read() == NOERR)
  {
    TString ragsoc = _toccas->get(OCC_RAGSOC);
    str.format("%-50s", (const char*) ragsoc);
    record.overwrite(str,290);
    
    TString ind = _toccas->get(OCC_INDIR);
    str.format("%-50s", (const char*) ind);
    record.overwrite(str,340);
    
    TString civ = _toccas->get(OCC_CIV);
    str.format("%-6s", (const char*) civ);
    record.overwrite(str,390);
    
    TString stato = _toccas->get(OCC_STATO);
    str.format("%-3s", (const char*) stato);
    record.overwrite(str,396);
    
    TString com = _toccas->get(OCC_COM);
    str.format("%-4s", (const char*) com);
    record.overwrite(str,399);
    
    TString cap = _toccas->get(OCC_CAP);
    str.format("%-5s", (const char*) cap);
    record.overwrite(str,453);
    
    TString datanasc = _toccas->get(OCC_DNASC);
    TString app      = riconverti(datanasc,TRUE); 
    str.format("%08s", (const char*) app);
    record.overwrite(str,458);                    
    
    TString statonasc = _toccas->get(OCC_STATONASC);
    str.format("%-3s", (const char*) statonasc);
    record.overwrite(str,466);
    
    TString comnasc = _toccas->get(OCC_COMNASC);
    str.format("%-4s", (const char*) comnasc);
    record.overwrite(str,469);    
  }                         
}

void TInv_cont::invio_righe_contabili()
{
  int     size = 1024;
  TString record(size);

  _tras_file.open(_trasf,TRUE);
   
  for (_trmov->first(); !_trmov->eof(); _trmov->next())
  { 
    TString str;
    
    _prog->addstatus(1);      
        
    record.spaces();                                                     

    record.overwrite("Z2",0);                    //Tipo record

    long nreg = _trmov->get_long(RMV_NUMREG);
    str.format("%07ld", nreg);
    record.overwrite(str,2);                     //Numero di registrazione

    int  nrig = _trmov->get_int (RMV_NUMRIG);        
    str.format("%03d", nrig);
    record.overwrite(str,9);
    
    TString sezione = _trmov->get(RMV_SEZIONE);
    record.overwrite(sezione,60);
      
    TString datareg = _trmov->get(RMV_DATAREG);   
    TString app     = riconverti(datareg,TRUE); 
    str.format("%08s", (const char*) app);
    record.overwrite(str,61);                    //Data di registrazione
    
    int gruppo = _trmov->get_int(RMV_GRUPPO);
    str.format("%03d", gruppo);
    record.overwrite(str,69);                     //Gruppo di partita
    
    int conto = _trmov->get_int(RMV_CONTO);
    str.format("%03d", conto);
    record.overwrite(str,72);                     //Conto di partita
    
    long sottoc = _trmov->get_long(RMV_SOTTOCONTO);
    str.format("%06ld", sottoc);
    record.overwrite(str,75);                     //Sottoconto di partita

    TString descr = _trmov->get(RMV_DESCR);
    str.format("%-50s", (const char*) descr);
    record.overwrite(str,81);                     //Descrizione riga di movimento

    int gruppoc = _trmov->get_int(RMV_GRUPPOC);
    str.format("%03d", gruppoc);
    record.overwrite(str,131);                     //Gruppo di contropartita
    
    int contoc = _trmov->get_int(RMV_CONTOC);
    str.format("%03d", contoc);
    record.overwrite(str,134);                     //Conto di contropartita
    
    long sottocc = _trmov->get_long(RMV_SOTTOCONTOC);
    str.format("%06ld", sottocc);
    record.overwrite(str,137);                     //Sottoconto di contropartita
    
    real importo (_trmov->get_real(RMV_IMPORTO));
    if (importo.sign() < 0)
    {
      record.overwrite("-",143);
      importo = importo * -1;
    }
    else
      record.overwrite("+",143);    
    str.format("%014s", (const char*) importo.string());
    record.overwrite(str,144);                     //Importo riga di movimento
    
    TString rowtype = _trmov->get(RMV_ROWTYPE);
    record.overwrite(rowtype,158);
                            
    _tras_file.write_control_rec(record,size);         
    _numrec_pn++;            
  }

  _tras_file.close();                      
}

void TInv_cont::invio_righe_IVA()
{
  int     size = 1024;
  TString record(size);
  
  long cicli = _triva->items();
  _prog = new TProgind(cicli,"Movimenti Iva: generazione file TRASFER per PC\nPrego attendere.",FALSE);
                        
  _tras_file.open(_trasf,TRUE);
                        
  for (_triva->first(); !_triva->eof(); _triva->next())
  { 
    TString str;
    
    _prog->addstatus(1);    
        
    record.spaces();                                                     
    
    long nreg = _triva->get_long(RMI_NUMREG);
    int  nrig = _triva->get_int (RMI_NUMRIG);

    record.overwrite("U1",0);                    //Tipo record
    
    str.format("%07ld", nreg);
    record.overwrite(str,2);                     //Numero di registrazione
    
    str.format("%03d", nrig);
    record.overwrite(str,9);                     //Numero di riga

    TString codiva = _triva->get(RMI_CODIVA);
    str.format("%-4s", (const char*) codiva);
    record.overwrite(str,60);
    
    real imponibile (_triva->get_real(RMI_IMPONIBILE));
    if (imponibile.sign() < 0)
    {
      record.overwrite("-",64);
      imponibile = imponibile * -1;
    }
    else
      record.overwrite("+",64);    
    str.format("%014s", (const char*) imponibile.string());
    record.overwrite(str,65);                    //Imponibile

    real imposta (_triva->get_real(RMI_IMPOSTA));
    if (imposta.sign() < 0)
    {
      record.overwrite("-",79);
      imposta = imposta * -1;
    }
    else
      record.overwrite("+",79);
    str.format("%014s", (const char*) imposta.string());
    record.overwrite(str,80);                    //Imposta

    int tipodet = _triva->get_int(RMI_TIPODET);
    str.format("%d", tipodet);
    record.overwrite(str,94);                    //Tipo detraibilita'
    
    int tipocr = _triva->get_int(RMI_TIPOCR);
    str.format("%d", tipocr);
    record.overwrite(str,95);                    //Tipo costo/ricavo

    bool intra = _triva->get_bool(RMI_INTRA);
    if (intra)
      record.overwrite("X",96);
    else                                         
      record.overwrite(" ",96);                  //Flag causale x acquisti intracomunitari

    int tipoatt = _triva->get_int(RMI_TIPOATT);
    str.format("%d", tipoatt);
    record.overwrite(str,97);                   //Tipo attivita'
    
    int gruppo = _triva->get_int(RMI_GRUPPO);
    str.format("%03d", gruppo);
    record.overwrite(str,98);                    //Gruppo
    
    int conto = _triva->get_int(RMI_CONTO);
    str.format("%03d", conto);
    record.overwrite(str,101);                    //Conto
    
    long sottoc = _triva->get_long(RMI_SOTTOCONTO);
    str.format("%06ld", sottoc);
    record.overwrite(str,104);                    //Sottoconto

    int rigaimp = _triva->get_int(RMI_RIGAIMP);
    str.format("%03d", rigaimp);
    record.overwrite(str,110);
    
    int rigaiva = _triva->get_int(RMI_RIGAIVA);
    str.format("%03d", rigaiva);
    record.overwrite(str,113);
    
    _numrec_iva++;            

    _tras_file.write_control_rec(record,size);    
  } 
  delete _prog;  

  _tras_file.close();
}

