821 lines
18 KiB
C++
Executable File
821 lines
18 KiB
C++
Executable File
// cglib04.cpp
|
|
|
|
#include <utility.h>
|
|
#include <progind.h>
|
|
#include <stdlib.h>
|
|
#include "cglib04.h"
|
|
|
|
HIDDEN TString80 TMP;
|
|
|
|
const int size = 256;
|
|
|
|
const char* tracciato = "trc.txt";
|
|
|
|
#if XVT_OS == XVT_OS_WIN
|
|
#include <io.h>
|
|
int fremove(const char* path)
|
|
{ return _unlink(path); }
|
|
#endif
|
|
|
|
//ritorna falso se la causale non e' significativa
|
|
bool look_causale (const char* codcaus)
|
|
{
|
|
TString16 caus = codcaus;
|
|
if (caus == "000")
|
|
return FALSE;
|
|
return !caus.blank();
|
|
}
|
|
|
|
bool format_if_zero(TString& field, int len)
|
|
{
|
|
if (real::is_natural(field))
|
|
field.right_just(len, '0');
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
TTransfer_file::TTransfer_file()
|
|
{
|
|
_trasfer = NULL;
|
|
_tot_rec = 0L;
|
|
_trc.leggi_modulo();
|
|
}
|
|
|
|
TTransfer_file::~TTransfer_file()
|
|
{
|
|
if (_trasfer)
|
|
fclose (_trasfer);
|
|
}
|
|
|
|
void TTransfer_file::close()
|
|
{
|
|
if (_trasfer)
|
|
fclose(_trasfer);
|
|
}
|
|
|
|
bool TTransfer_file::open(const char* path)
|
|
{
|
|
if (_trasfer) fclose(_trasfer);
|
|
|
|
_trasfer = fopen (path, "r+t");
|
|
return _trasfer != NULL;
|
|
}
|
|
|
|
const char* TTransfer_file::path(long codditta)
|
|
{
|
|
if (codditta)
|
|
return firm2dir(codditta);
|
|
else
|
|
return main_app().get_firm_dir();
|
|
}
|
|
|
|
// Questa funzione ritorna:
|
|
// - 0 se non vengono rilevate condizioni di ripartenza o di trasferimento
|
|
// non completato.
|
|
// - 1 se viene rilevato uno stato di RIPARTENZA CON DATI CONTRADDITORI
|
|
// - 2 se viene rilevato un trasferimento precedente NON COMPLETATO
|
|
|
|
int TTransfer_file::controllo_ripartenza()
|
|
{
|
|
TString std;
|
|
bool flag = FALSE;
|
|
int var = 0;
|
|
|
|
TConfig conf(CONFIG_DITTA);
|
|
|
|
std = conf.get("FlStTra");
|
|
|
|
if (read_control_rec())
|
|
flag = TRUE;
|
|
|
|
if (std == "" && flag)
|
|
var = 1;
|
|
|
|
if (std == "*" && flag)
|
|
if (_ult_file != "" || _key != "")
|
|
var = 1;
|
|
|
|
if (std != "" && std != "*")
|
|
var = 2;
|
|
|
|
return var;
|
|
}
|
|
|
|
const char* converti (TString& data_AS400)
|
|
{
|
|
TMP = data_AS400.mid(4,2);
|
|
TMP << "-" << data_AS400.mid(2,2);
|
|
TMP << "-" << data_AS400.mid(0,2);
|
|
return TMP;
|
|
}
|
|
|
|
bool TTransfer_file::read_control_rec()
|
|
{
|
|
TString16 tmp;
|
|
|
|
if (!exist()) return FALSE;
|
|
|
|
// va all'inizio del file
|
|
fseek (_trasfer, 0L, SEEK_SET);
|
|
const word letti = fread((char*)(const char*)_control_rec,sizeof(char),size,_trasfer);
|
|
|
|
TString tiporec = _control_rec.sub(0,2);
|
|
|
|
if (tiporec == " 1")
|
|
{
|
|
_nultras = atoi(_control_rec.sub(29,32));
|
|
tmp = _control_rec.sub(32,38);
|
|
_dataultras = converti(tmp);
|
|
|
|
_sigle_file = _control_rec.sub(38,47);
|
|
_nrec_file = _control_rec.sub(47,101);
|
|
_ult_file = _control_rec.sub(240,241);
|
|
_key = _control_rec.sub(241,256);
|
|
fill_index(_sigle_file,_nrec_file);
|
|
}
|
|
else
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TTransfer_file::write_control_rec(const char* str, const int size)
|
|
{
|
|
if (!exist()) return FALSE;
|
|
|
|
fseek(_trasfer, 0, SEEK_SET);
|
|
const int nscritti = fwrite (str,1,size,_trasfer);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
const char* TTransfer_file::name(int i)
|
|
{
|
|
TToken_string data = (TToken_string&)_index[i];
|
|
return data.get(0);
|
|
}
|
|
|
|
long TTransfer_file::nrec(int i)
|
|
{
|
|
TToken_string data = (TToken_string&)_index[i];
|
|
return data.get_long(1);
|
|
}
|
|
|
|
int TTransfer_file::lenrec(int i)
|
|
{
|
|
TToken_string data = (TToken_string&)_index[i];
|
|
return data.get_int(2);
|
|
}
|
|
|
|
int TTransfer_file::lenrec(char sigla)
|
|
{
|
|
const int i = num(sigla);
|
|
return lenrec(i);
|
|
}
|
|
|
|
long TTransfer_file::start(char sigla)
|
|
{
|
|
const int i = num(sigla);
|
|
return start(i);
|
|
}
|
|
|
|
long TTransfer_file::start(int i)
|
|
{
|
|
if (i == 0)
|
|
return 0;
|
|
else
|
|
{
|
|
TToken_string data = (TToken_string&)_index[i-1];
|
|
return data.get_long(1) + 1;
|
|
}
|
|
}
|
|
|
|
long TTransfer_file::end(int i)
|
|
{
|
|
TToken_string data = (TToken_string&)_index[i];
|
|
return data.get_long(4);
|
|
}
|
|
|
|
long TTransfer_file::rec(int i)
|
|
{
|
|
long rec = 1;
|
|
|
|
if (i > 0)
|
|
{
|
|
TToken_string data = (TToken_string&)_index[i-1];
|
|
rec = (data.get_long(1)) + 1;
|
|
}
|
|
|
|
return rec;
|
|
}
|
|
|
|
int TTransfer_file::num(char sigla)
|
|
{
|
|
int items = _index.items();
|
|
TString16 dep;
|
|
|
|
for (int i = 0; i < items; i++)
|
|
{
|
|
dep = name(i);
|
|
if ( dep[0] == sigla)
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
void TTransfer_file::go2rec(const long recnum)
|
|
{
|
|
readat(recnum);
|
|
}
|
|
|
|
void TTransfer_file::readat(long recnum)
|
|
{
|
|
long pos,offset;
|
|
|
|
// name_file | numrec | lenrec | start | end ESEMPIO
|
|
// w | 100 | 82 | 0 | 8199 DI
|
|
// p | 130 | 40 | 8200 | 9399 INDICE
|
|
|
|
int items = _index.items();
|
|
|
|
for (int i = 0;i < items;i++)
|
|
{
|
|
if (recnum <= nrec(i))
|
|
{
|
|
if (i > 0)
|
|
{
|
|
pos = end(i-1) + 1;
|
|
offset = recnum - nrec(i-1);
|
|
pos += offset * lenrec(i);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
pos = recnum * lenrec(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
_curpos = recnum;
|
|
_curfile = name(i);
|
|
fseek(_trasfer,pos,SEEK_SET);
|
|
}
|
|
|
|
int TTransfer_file::read_rec_trasfer(long numrec, int size)
|
|
{
|
|
go2rec(numrec);
|
|
const word letti = fread((char*)(const char*)_record,sizeof(char),size,_trasfer);
|
|
return letti;
|
|
}
|
|
|
|
char TTransfer_file::flg_agg()
|
|
{
|
|
char flag;
|
|
|
|
char sigla = _record.sub(0,1)[0];
|
|
|
|
if (sigla == 'W')
|
|
flag = _control_rec.sub(235,236)[0];
|
|
|
|
if (sigla == 'A')
|
|
flag = _control_rec.sub(236,237)[0];
|
|
|
|
if (sigla == 'P')
|
|
flag = _control_rec.sub(237,238)[0];
|
|
|
|
return flag;
|
|
}
|
|
|
|
bool TTransfer_file::numprot_att()
|
|
{
|
|
char flag;
|
|
|
|
flag = _control_rec.sub(238,239)[0];
|
|
if (flag == 'X')
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TTransfer_file::numprot_pas()
|
|
{
|
|
char flag;
|
|
|
|
flag = _control_rec.sub(239,240)[0];
|
|
if (flag == 'X')
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
char TTransfer_file::flg_agg_IV()
|
|
{
|
|
char flag = ' ';
|
|
|
|
char sigla = _record.sub(0,1)[0];
|
|
|
|
if (sigla == 'P')
|
|
flag = _control_rec.sub(234,235)[0];
|
|
|
|
return flag;
|
|
}
|
|
|
|
void TTransfer_file::put(const char* val, const char* file, int fieldnum,long recnum)
|
|
{
|
|
int da = go2field(fieldnum,file,recnum,FALSE);
|
|
_record.overwrite(val, da);
|
|
}
|
|
|
|
int TTransfer_file::write(long numrec, int size)
|
|
{
|
|
go2rec(numrec);
|
|
const word scritti = fwrite((char*)(const char*)_record,sizeof(char),size,_trasfer);
|
|
return scritti;
|
|
}
|
|
|
|
void TTransfer_file::writeat(const char* str,int size,int fieldnum,const char* file)
|
|
{
|
|
go2field(fieldnum,file);
|
|
|
|
const int nscritti = fwrite (str,1,size,_trasfer);
|
|
}
|
|
|
|
void TTransfer_file::writeat(const char* str,int size,int fieldnum,const char* file, const long nrec)
|
|
{
|
|
go2field(fieldnum,file,nrec);
|
|
|
|
const int nscritti = fwrite (str,1,size,_trasfer);
|
|
}
|
|
|
|
int TTransfer_file::go2field(int fieldnum, const char* file, const long nrec, bool seek)
|
|
{
|
|
TString key;
|
|
int pos_campo;
|
|
const int size = 256;
|
|
|
|
if (nrec < 0)
|
|
readat(_curpos); // Mi posiziono all' inizio del record
|
|
else
|
|
readat(nrec);
|
|
|
|
if (!file)
|
|
key.format("%2s%d",(const char*)_curfile,fieldnum);
|
|
else
|
|
key.format("%2s%d", file, fieldnum);
|
|
|
|
if (_trc.is_key((const char *) key))
|
|
{
|
|
TToken_string * data = (TToken_string *) _trc.objptr(key);
|
|
|
|
pos_campo = data->get_int(2);
|
|
// NB
|
|
// Nel tracciato parto da 1 (per compatibilita'),
|
|
// la fseek() conta da 0
|
|
pos_campo -= 1;
|
|
|
|
if (seek)
|
|
{
|
|
//pos_campo -= 1;
|
|
fseek(_trasfer,pos_campo,SEEK_CUR);
|
|
}
|
|
}
|
|
return pos_campo;
|
|
}
|
|
|
|
void TTransfer_file::fill_index(TString& sigle_file,TString& nrec_file)
|
|
{
|
|
TToken_string data;
|
|
char sigla;
|
|
long nrec,nrecp,start,end;
|
|
int i;
|
|
int k = 0;
|
|
int lrec = 256;
|
|
|
|
start = end = 0;
|
|
|
|
nrecp = 0L;
|
|
|
|
_index.destroy();
|
|
|
|
_last_tab = 0;
|
|
_last_mov = 0;
|
|
|
|
for (i = 0; i < sigle_file.len(); i++)
|
|
{
|
|
data = "";
|
|
sigla = sigle_file.mid(i,1)[0];
|
|
nrec = atol(nrec_file.mid(k,6));
|
|
|
|
if (sigla == 'W' || sigla == 'P' || sigla == 'A')
|
|
{
|
|
_last_tab++;
|
|
_last_mov++;
|
|
}
|
|
|
|
if (sigla == 'Z' || sigla == 'U' || sigla == 'B')
|
|
_last_mov++;
|
|
|
|
if (sigla != ' ' && nrec != 0)
|
|
{
|
|
data.add(sigla);
|
|
data.add(nrec + nrecp);
|
|
data.add(lrec);
|
|
nrecp += nrec;
|
|
|
|
end = (nrecp * lrec) -1;
|
|
data.add(start);
|
|
data.add(end);
|
|
start = end + 1;
|
|
|
|
_index.add(data);
|
|
}
|
|
k += 6;
|
|
}
|
|
|
|
_tot_rec = nrecp;
|
|
|
|
}
|
|
|
|
void TTransfer_file::annulla_classi(int g, int c,bool conto)
|
|
{
|
|
TLocalisamfile pcon (LF_PCON);
|
|
|
|
pcon.setkey(1);
|
|
pcon.zero();
|
|
pcon.put("GRUPPO", g);
|
|
pcon.put("CONTO", c);
|
|
|
|
for (pcon.read(); !pcon.eof(); pcon.next())
|
|
{
|
|
if (conto)
|
|
{
|
|
long sottoc = pcon.get_long("SOTTOCONTO");
|
|
if (sottoc == 0) continue;
|
|
}
|
|
|
|
int gruppo = pcon.get_int("GRUPPO");
|
|
int conto = pcon.get_int("CONTO");
|
|
|
|
if (gruppo != g || conto != c) break;
|
|
|
|
pcon.zero("SEZIVD");
|
|
pcon.zero("LETTIVD");
|
|
pcon.zero("NUMRIVD");
|
|
pcon.zero("NUMIVD");
|
|
pcon.zero("SEZIVDOPP");
|
|
pcon.zero("LETTIVDOPP");
|
|
pcon.zero("NUMRIVDOPP");
|
|
pcon.zero("NUMIVDOPP");
|
|
|
|
pcon.rewrite();
|
|
}
|
|
}
|
|
|
|
int TTransfer_file::dataes(const TDate& d, int* prevesc, TDate& finesp)
|
|
{
|
|
*prevesc = 0;
|
|
|
|
TTable esc("ESC");
|
|
for (int err = esc.first(); err == NOERR; err = esc.next())
|
|
{
|
|
const TDate ia(esc.get("D0")); // Data inizio esercizio
|
|
const TDate fa(esc.get("D1")); // Data fine esercizio
|
|
const anno = esc.get_int("CODTAB");
|
|
if (d >= ia && d <= fa)
|
|
return anno;
|
|
*prevesc = anno;
|
|
finesp = fa;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void TTransfer_file::write_tmp_mov(TIsamtempfile& tmp_mov, TIsamtempfile& tmp_rmov, const TString& buffer,const int nprog_mov)
|
|
{
|
|
TString16 datareg = buffer.sub(15,21);
|
|
long numreg = atol(buffer.sub(2,8));
|
|
int numrig = atoi(buffer.sub(8,10));
|
|
char sezione = buffer.sub(84,85)[0];
|
|
TString16 importo = buffer.sub(97,108);
|
|
int gruppo = atoi(buffer.sub(74,76));
|
|
int conto = atoi(buffer.sub(76,78));
|
|
long sconto = atol(buffer.sub(78,84));
|
|
int gruppoc = atoi(buffer.sub(85,87));
|
|
int contoc = atoi(buffer.sub(87,89));
|
|
long scontoc = atol(buffer.sub(89,95));
|
|
TString16 datadoc = buffer.sub(22,28);
|
|
TString16 numdoc = buffer.sub(28,35);
|
|
TString16 codcaus = buffer.sub(41,44);
|
|
TString80 descr = buffer.sub(44,74);
|
|
TString16 reg = buffer.sub(35,36);
|
|
//format_if_zero(reg, 3);
|
|
format_if_zero(codcaus, 3);
|
|
long protiva = atol(buffer.sub(36,41));
|
|
long nuprotiva = atol(buffer.sub(108,113));
|
|
TString16 codpag = buffer.sub(95,97);
|
|
|
|
TDate datar(converti(datareg));
|
|
TDate datad(converti(datadoc));
|
|
|
|
int pr;
|
|
TDate df;
|
|
const int ar = dataes(datar, &pr, df);
|
|
int sign = atoi(buffer.sub(21,22));
|
|
TString16 tipodoc = buffer.sub(220,222);
|
|
|
|
tmp_mov.zero();
|
|
|
|
TString16 anno;
|
|
if (sign)
|
|
{
|
|
anno.format("%04d", pr);
|
|
tmp_mov.put(MOV_ANNOES, anno);
|
|
tmp_mov.put(MOV_DATACOMP, df);
|
|
}
|
|
else
|
|
{
|
|
anno.format("%04d", ar);
|
|
tmp_mov.put(MOV_ANNOES, anno);
|
|
tmp_mov.put(MOV_DATACOMP, datar);
|
|
}
|
|
|
|
// Scrivo testata
|
|
tmp_mov.put(MOV_DATAREG, datar);
|
|
tmp_mov.put(MOV_NUMREG, numreg);
|
|
tmp_mov.put(MOV_DATADOC, datad);
|
|
tmp_mov.put(MOV_NUMDOC, numdoc);
|
|
tmp_mov.put(MOV_CODCAUS, codcaus);
|
|
tmp_mov.put(MOV_REG, reg);
|
|
tmp_mov.put(MOV_PROTIVA, protiva);
|
|
tmp_mov.put(MOV_UPROTIVA, nuprotiva);
|
|
tmp_mov.put(MOV_TIPODOC, tipodoc);
|
|
tmp_mov.put(MOV_CODPAG, codpag);
|
|
|
|
// Scrivo numero progressivo del transfer
|
|
tmp_mov.put(MOV_NUMGIO, (long)nprog_mov);
|
|
|
|
tmp_mov.write();
|
|
|
|
tmp_rmov.zero();
|
|
// Scrivo riga
|
|
tmp_rmov.put(RMV_NUMREG, numreg);
|
|
tmp_rmov.put(RMV_NUMRIG, numrig);
|
|
tmp_rmov.put(RMV_SEZIONE,sezione);
|
|
tmp_rmov.put(RMV_DATAREG,datar);
|
|
tmp_rmov.put(RMV_GRUPPO, gruppo);
|
|
tmp_rmov.put(RMV_CONTO, conto);
|
|
tmp_rmov.put(RMV_SOTTOCONTO, sconto);
|
|
tmp_rmov.put(RMV_GRUPPOC, gruppoc);
|
|
tmp_rmov.put(RMV_CONTOC, contoc);
|
|
tmp_rmov.put(RMV_SOTTOCONTOC, scontoc);
|
|
tmp_rmov.put(RMV_DESCR, descr);
|
|
tmp_rmov.put(RMV_IMPORTO,importo);
|
|
|
|
// Scrivo numero progressivo del transfer
|
|
tmp_rmov.put(RMV_ANNOES, nprog_mov);
|
|
|
|
tmp_rmov.write();
|
|
}
|
|
|
|
//
|
|
// NB
|
|
// Utilizza ANNO_IVA per metterci il numero progressivo sul transfer
|
|
//
|
|
void TTransfer_file::scrivi_nprog_testata(long numreg, long nprog_iva, TIsamtempfile& mov)
|
|
{
|
|
mov.zero();
|
|
mov.put("NUMREG", numreg);
|
|
if (mov.read() == NOERR)
|
|
{
|
|
mov.put(MOV_ANNOIVA, (long)nprog_iva);
|
|
mov.rewrite();
|
|
}
|
|
}
|
|
|
|
void TTransfer_file::look_mov(long numreg, const char* d, long cf, TIsamtempfile& mov)
|
|
{
|
|
mov.zero();
|
|
mov.put("NUMREG", numreg);
|
|
if (mov.read() == NOERR)
|
|
{
|
|
mov.put(MOV_DATA74TER, d);
|
|
mov.put(MOV_CODCF, cf);
|
|
mov.rewrite();
|
|
}
|
|
}
|
|
|
|
void TTransfer_file::write_tmp_rmoviva(TIsamtempfile& tmp_rmoviva, TIsamtempfile& tmp_mov, const TString& buffer, const int nprog_iva)
|
|
{
|
|
static long numreg = -1L;
|
|
long numreg_curr = 0L;
|
|
|
|
TString16 datareg = buffer.sub(15,21);
|
|
numreg_curr = atol(buffer.sub(2,8));
|
|
|
|
const char* data74 = buffer.sub(55,61);
|
|
long codcf = atol(buffer.sub(15,21));
|
|
|
|
if (numreg < 0L)
|
|
{
|
|
if (numreg_curr > 0L)
|
|
{
|
|
numreg = numreg_curr;
|
|
scrivi_nprog_testata(numreg, nprog_iva, tmp_mov);
|
|
}
|
|
}
|
|
else
|
|
if (numreg_curr != numreg)
|
|
{
|
|
numreg = numreg_curr;
|
|
scrivi_nprog_testata(numreg, nprog_iva, tmp_mov);
|
|
}
|
|
|
|
look_mov(numreg, data74, codcf, tmp_mov);
|
|
|
|
int numrig = atoi(buffer.sub(8,10));
|
|
TString16 codiva = buffer.sub(32,34);
|
|
TString16 impo = buffer.sub(21,32);
|
|
TString16 impos = buffer.sub(34,43);
|
|
int tipocr = atoi(buffer.sub(43,44));
|
|
int tipodet = atoi(buffer.sub(44,45));
|
|
int gruppo = atoi(buffer.sub(45,47));
|
|
int conto = atoi(buffer.sub(47,49));
|
|
long sottoconto = atol(buffer.sub(49,55));
|
|
int tipoatt = atoi(buffer.sub(133,134));
|
|
|
|
tmp_rmoviva.zero();
|
|
tmp_rmoviva.put(RMI_NUMREG, numreg);
|
|
tmp_rmoviva.put(RMI_NUMRIG, numrig);
|
|
tmp_rmoviva.put(RMI_CODIVA, codiva);
|
|
tmp_rmoviva.put(RMI_IMPONIBILE, impo);
|
|
tmp_rmoviva.put(RMI_IMPOSTA, impos);
|
|
tmp_rmoviva.put(RMI_TIPOCR, tipocr);
|
|
tmp_rmoviva.put(RMI_TIPODET, tipodet);
|
|
tmp_rmoviva.put(RMI_TIPOATT, tipoatt);
|
|
tmp_rmoviva.put(RMI_GRUPPO, gruppo);
|
|
tmp_rmoviva.put(RMI_CONTO, conto);
|
|
tmp_rmoviva.put(RMI_SOTTOCONTO, sottoconto);
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Scrivo il numero di record del transfer
|
|
// per aggiornare il transfer nella lista movimenti
|
|
//
|
|
tmp_rmoviva.put(RMI_ANNOES, (long)nprog_iva);
|
|
|
|
tmp_rmoviva.write();
|
|
}
|
|
|
|
//oltre a fare una copia del trasfer scarica su tre file temp i movimenti di prima nota, ecc.
|
|
bool TTransfer_file::fcopytemp(const char* orig, const char* dest, bool append)
|
|
{
|
|
// conto i dischetti per l'apertura
|
|
static int disk_num = 0;
|
|
long totr = 0L;
|
|
const char* wflag;
|
|
#if XVT_OS == XVT_OS_SCOUNIX
|
|
const char* const rflag = "r";
|
|
if (append)
|
|
wflag = "a";
|
|
else
|
|
wflag = "w";
|
|
#else
|
|
const char* const rflag = "rb";
|
|
if (append)
|
|
wflag = "ab";
|
|
else
|
|
wflag = "wb";
|
|
#endif
|
|
|
|
// Legge numero di rec. del transfer (per la progind)
|
|
open(orig);
|
|
if (read_control_rec())
|
|
totr = tot_rec();
|
|
close();
|
|
|
|
FILE* i = fopen(orig, rflag);
|
|
if (!i) return error_box("Impossibile leggere il file %s", orig);
|
|
|
|
FILE* o = fopen(dest, wflag);
|
|
CHECKS(o, "Impossibile scrivere il file ", dest);
|
|
|
|
const word size = 256;
|
|
TString buffer(size);
|
|
TString16 trec;
|
|
|
|
TString80 tmpmov = "%";
|
|
tmpmov << path();
|
|
tmpmov << "\\" << TEMP_MOV;
|
|
TString80 tmprmov = "%";
|
|
tmprmov << path();
|
|
tmprmov << "\\" << TEMP_RMOV;
|
|
TString80 tmprmoviva = "%";
|
|
tmprmoviva << path();
|
|
tmprmoviva << "\\" << TEMP_RMOVIVA;
|
|
|
|
TIsamtempfile tmp_mov (LF_MOV, tmpmov, disk_num ? FALSE : TRUE);
|
|
TIsamtempfile tmp_rmov(LF_RMOV, tmprmov, disk_num ? FALSE : TRUE);
|
|
TIsamtempfile tmp_rmoviva(LF_RMOVIVA, tmprmoviva, disk_num ? FALSE : TRUE);
|
|
|
|
disk_num++;
|
|
|
|
// Numero le righe iva
|
|
int nprog_iva = 0;
|
|
// e le testate
|
|
int nprog_mov = 0;
|
|
|
|
bool ok = TRUE;
|
|
long offset = 0L;
|
|
|
|
TProgind pnd (totr,"Trasferimento archivi in corso\nPrego attendere",
|
|
FALSE, TRUE, 30);
|
|
|
|
while (ok)
|
|
{
|
|
const word letti = fread((char*)(const char*)buffer, 1, size, i);
|
|
|
|
trec = buffer.sub(0,2);
|
|
|
|
if (trec == "Z1") //movimento di prima nota
|
|
{
|
|
write_tmp_mov(tmp_mov, tmp_rmov, buffer, nprog_mov);
|
|
nprog_mov++;
|
|
}
|
|
|
|
// Righe iva
|
|
if (trec == "U1")
|
|
{
|
|
write_tmp_rmoviva(tmp_rmoviva, tmp_mov, buffer, nprog_iva);
|
|
nprog_iva++;
|
|
}
|
|
|
|
ok = fwrite((char*)(const char*)buffer, 1, letti, o) == letti;
|
|
|
|
pnd.addstatus (1);
|
|
|
|
if (letti < size) break;
|
|
}
|
|
if (!ok) error_box("Errore di scrittura: probabile disco pieno!");
|
|
|
|
fclose(o);
|
|
fclose(i);
|
|
|
|
return ok;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Mappa dei campi da trasferire
|
|
// -----------------------------------------------------------------------
|
|
|
|
void TMappa_trc::leggi_modulo()
|
|
{
|
|
TScanner s(tracciato);
|
|
TString16 key;
|
|
TToken_string record;
|
|
|
|
while (s.ok())
|
|
{
|
|
record = s.line();
|
|
|
|
TString sigla = record.get(0);
|
|
long numrec = record.get_long(1);
|
|
key.format("%2s%d", (const char*)sigla,numrec);
|
|
|
|
add(key, record);
|
|
}
|
|
long item = items();
|
|
}
|
|
|
|
int TMappa_trc::from(const char* key)
|
|
{
|
|
TToken_string * data = (TToken_string *) objptr(key);
|
|
return data->get_int(2);
|
|
}
|
|
|
|
int TMappa_trc::to(const char* key)
|
|
{
|
|
TToken_string * data = (TToken_string *) objptr(key);
|
|
return data->get_int(3);
|
|
}
|
|
|
|
int TMappa_trc::logicnum(const char* key)
|
|
{
|
|
TToken_string * data = (TToken_string *) objptr(key);
|
|
return data->get_int(4);
|
|
}
|
|
|
|
const char* TMappa_trc::field_name(const char* key)
|
|
{
|
|
TToken_string * data = (TToken_string *) objptr(key);
|
|
return data->get(5);
|
|
}
|
|
|
|
int TMappa_trc::flag(const char* key)
|
|
{
|
|
TToken_string * data = (TToken_string *) objptr(key);
|
|
return data->get_int(6);
|
|
}
|