root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg2900.cpp
guy d0483278e1 Gestione prima nota con TRecord_array 
Corretta contropartita fantasma della prima riga


git-svn-id: svn://10.65.10.50/trunk@1281 c028cbd2-c16b-5b4b-a496-9718f37d4682
1995-04-20 14:29:00 +00:00

2100 lines
63 KiB
C++
Executable File
Raw Blame History

// Invio contabilita'
#include <math.h>
#include <applicat.h>
#include <mask.h>
#include <relation.h>
#include <tabutil.h>
#include <utility.h>
#include <config.h>
#include <urldefid.h>
#include <prefix.h>
#include <lffiles.h>
#include <progind.h>
#include <nditte.h>
#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>
#include <causali.h>
#include <rcausali.h>
#include <clifo.h>
#include <pconti.h>
#include <comuni.h>
#include <occas.h>
#include "cg2900.h"
#include "cglib04.h"
HIDDEN TString80 TEMP;
HIDDEN int date2esc(const TDate& d, int* prevesc = NULL);
class TInv_cont : public TApplication
{
enum { BUFSIZE = 4096 };
TTransfer_file _tras_file;
TProgind* _prog;
TString _control_rec, _trasf, _std, _stato, _marker, _nome_simbolico;
TString _files, _codcaus, _numdoc, _reg, _codpag, _tipodoc, _codcausm;
TString _ocfpi, _ragsococc, _indocc, _capocc, _localocc, _provocc, _codvali;
bool _esiste_ditta, _esiste_record;
long _ditta, _protiva, _uprotiva, _codcf, _numrec, _tot_rec;
long _dim_tot, _dim_disk;
int _num;
TDate _data, _datadoc, _data74ter;
real _corrlire, _cambioi, _corrval;
public:
virtual bool create();
virtual bool destroy();
virtual bool menu(MENU_TAG m);
bool main_loop();
bool esiste_tabella_studio();
bool record_controllo();
bool esegui_controlli();
bool leggi_trasfer();
bool controlli();
bool sub_controlli();
bool tabella_ditta();
bool controlla_stato_invio();
bool numero_data();
void leggi_record_controllo();
void codifica_ditta (TMask& m);
bool testata_mov_PN (long numreg);
bool testata_mov_IVA(long numreg);
void cerca_occasionale();
void cerca_comune_occas(const TString& com);
void crea_marker(TMask& m);
void setta_parametri_record(TMask& m,const TString& flag);
void setta_tabella_studio(TMask& m, bool flag_ditta = TRUE);
void setta_tabella_ditta(TMask& m, const char* flag, bool comp = TRUE);
void crea_record_controllo(TMask& m);
bool invio_contabilita(TMask& m);
bool invio_tab_cau(TString& key,TMask& m);
bool invio_clifo (TString& key,TMask& m);
bool invio_pcon (TString& key,TMask& m);
bool invio_mov_PN (TString& key,TMask& m);
bool invio_mov_IVA(TString& key,TMask& m);
void aggiorna_marker(TString& token, int pos);
void calcola_totale_record();
const char* converti (TString& data_AS400);
const char* riconverti (TString& data_PC);
const char* cerca_provincia(const TString& comcf);
static bool setta_maschera_hnd(TMask_field& f, KEY k);
int calcola_numero_dischi(TMask& m);
FILE* chiedi_disco(const char* name, int disk, char floppy, bool lettura);
long determina_dimensione(FILE* f);
bool scrivi_disco(char floppy, int disk, const char* work, FILE* i, TProgind& w);
TInv_cont() {};
};
HIDDEN TInv_cont& app() { return (TInv_cont &) main_app(); }
FILE* TInv_cont::chiedi_disco(const char* name, int disk, char floppy, bool lettura)
{
message_box("Inserire il disco %d nel drive %c:", disk, floppy);
// name.ext(format("%03d", disk));
FILE* f = NULL;
bool retry = TRUE;
while (retry)
{
f = fopen(name, lettura ? "rb" : "wb");
if (f == NULL)
retry = yesno_box("Il file %s non e' accessibile: riprovare?", (const char*)name);
else
{
retry = FALSE;
fclose(f);
}
}
return f;
}
long TInv_cont::determina_dimensione(FILE* f)
{
CHECK(f, "Can't measure NULL file");
fseek(f, 0, SEEK_END);
const long s = ftell(f);
fseek(f, 0, SEEK_SET);
return s;
}
bool TInv_cont::scrivi_disco(char floppy, int disk, const char* work,
FILE* i, TProgind& w)
{
// const TFilename from(filename); // File da splittare
// TFilename work;
// work << floppy << ":/" << from.name(); // File su dischetto
chiedi_disco(work, disk, floppy, FALSE);
TString str;
str.format("%02d", disk);
aggiorna_marker(str,31); // Aggiorna il num. progr. disco su marker
TString path_m;
path_m << floppy << ":\\marker";
TString path_t;
path_t << floppy << ":\\trasfer";
fcopy(_marker,path_m); // Copia il marker su disco
//FILE* i = fopen(from, "rb");
FILE* o = fopen(path_t, "wb");
//if (i == NULL) return error_box("Impossibile aprire il file '%s'", from);
//TProgind w(_dim_disk, "Trasferimento su dischetti in corso... Prego attendere", TRUE, TRUE, 40);
TString buffer(BUFSIZE);
long tot_scritti = BUFSIZE;
while (tot_scritti <= _dim_disk)
{
const word letti = fread((char*)(const char*)buffer, 1, BUFSIZE, i);
long scritti = fwrite((char*)(const char*)buffer, letti, 1, o);
tot_scritti += letti;
if (letti < BUFSIZE) break;
w.addstatus(letti);
}
//fclose(i);
fclose(o);
return TRUE;
}
bool TInv_cont::main_loop()
{
TString str;
bool ripartenza = FALSE;
if (!esiste_tabella_studio()) return FALSE;
if (!esegui_controlli()) return FALSE;
TMask msk ("cg2900a");
KEY tasto;
if (_ditta != 0)
{
msk.set(F_DITTAINV, _ditta);
msk.disable(F_DITTAINV);
codifica_ditta(msk);
msk.set(F_NUMULINV, _num);
msk.set(F_DATAULIN, _data.string());
msk.set(F_STATO, _stato);
TString uselab = _tras_file.ult_file();
TString chiave = _tras_file.key();
msk.set(F_USELAB, uselab);
msk.set(F_CHIAVE, chiave);
msk.set(F_DATALIM, _data.string());
msk.disable(F_DATALIM);
ripartenza = TRUE;
}
msk.disable(F_NUMULINV);
msk.disable(F_DATAULIN);
msk.disable(F_STATO);
msk.disable(F_USELAB);
msk.disable(F_CHIAVE);
if (!ripartenza)
msk.set_handler(F_DITTAINV, setta_maschera_hnd);
tasto = msk.run();
if (tasto != K_ENTER) return FALSE;
if (!ripartenza)
{
crea_marker(msk); //Crea il record con le informazioni sul marker
setta_parametri_record(msk,"F"); //Aggiorna parametri contabili ditta
setta_tabella_studio(msk); //Aggiorna la tabella studio per invio
setta_tabella_ditta(msk,"F"); //Aggiorna la tabella ditta per invio
crea_record_controllo(msk); //Crea il record di controllo sul file trasfer
}
if (!invio_contabilita(msk))
return FALSE;
calcola_totale_record();
str.format("%06ld", _tot_rec);
aggiorna_marker(str,23);
TMask mask ("cg2900b");
KEY k;
k = mask.run();
if (k == K_ENTER)
{
int num_disk = calcola_numero_dischi(mask);
char floppy = mask.get(F_FLOPPY)[0];
str.format("%02d", num_disk);
aggiorna_marker(str,29);
const TFilename from(_trasf); // File da splittare
TFilename work;
work << floppy << ":/" << from.name(); // File su dischetto
FILE* i = fopen(from, "rb");
if (i == NULL) return error_box("Impossibile aprire il file '%s'", from);
TProgind w(_dim_tot, "Trasferimento su dischetti in corso... Prego attendere", TRUE, TRUE, 60);
for (int j = 0; j < num_disk; j++)
{
scrivi_disco(floppy,j+1,work,i,w);
}
fclose(i);
setta_tabella_studio(msk,FALSE); //Aggiorna la tabella studio per invio
setta_tabella_ditta(msk," ",FALSE); //Aggiorna la tabella ditta per invio
setta_parametri_record(msk," "); //Aggiorna parametri contabili ditta
_tras_file.open(_trasf);
leggi_record_controllo();
TString record(256);
record.format("%-256s",(const char*) record);
_control_rec.overwrite(record,0);
_tras_file.write_control_rec(_control_rec,256);
fremove(_marker);
fremove(_trasf);
}
return FALSE;
}
int TInv_cont::calcola_numero_dischi(TMask& msk)
{
int numdisc = 0;
FILE* t = fopen(_trasf, "rb");
if (t == NULL) return error_box("Impossibile aprire il file '%s'", _trasf);
long dim_t = determina_dimensione(t); //Determina la dimensione del trasfer
fclose(t);
FILE* m = fopen(_marker, "rb");
if (m == NULL) return error_box("Impossibile aprire il file '%s'", _marker);
long dim_m = determina_dimensione(m); // Determina la dimensione del marker
fclose(m);
_dim_tot = dim_t + dim_m; // Determina la dimensione totale
int item = msk.get_int(F_DIM);
switch (item)
{
case 1 :
_dim_disk = 1400000L;
break;
case 2 :
_dim_disk = 1200000L;
break;
case 3 :
_dim_disk = 720000L;
break;
case 4 :
_dim_disk = 360000L;
break;
default :
break;
};
if (_dim_tot < _dim_disk)
numdisc = 1;
else
{
//double dischi = _dim_tot / _dim_disk;
//numdisc = (int)ceil(dischi);
numdisc = int(_dim_tot / _dim_disk);
if ( (_dim_tot % _dim_disk) != 0)
numdisc += 1;
}
return numdisc;
}
HIDDEN int date2esc(const TDate& d, int* prevesc)
{
if (prevesc) *prevesc = 0;
TTable esc("ESC");
for (int err = esc.first(); err == NOERR; err = esc.next())
{
const TDate ia(esc.get("D0")); // Data inizio esercizio
const TDate fa(esc.get("D1")); // Data fine esercizio
const anno = esc.get_int("CODTAB");
if (d >= ia && d <= fa)
return anno;
if (prevesc) *prevesc = anno;
}
return 0;
}
bool TInv_cont::create()
{
TApplication::create();
dispatch_e_menu (BAR_ITEM(1));
return TRUE;
}
bool TInv_cont::destroy()
{
return TApplication::destroy();
}
void TInv_cont::leggi_record_controllo()
{
_tras_file.read_control_rec();
_control_rec = _tras_file.record();
}
const char* TInv_cont::converti (TString& data_AS400)
{
TEMP = data_AS400.mid(4,2);
TEMP << "-" <<data_AS400.mid(2,2);
TEMP << "-" <<data_AS400.mid(0,2);
return TEMP;
}
const char* TInv_cont::riconverti (TString& data_PC)
{
TEMP = data_PC.mid(8,2);
TEMP << data_PC.mid(3,2);
TEMP << data_PC.mid(0,2);
return TEMP;
}
bool TInv_cont::esiste_tabella_studio()
{
TTable ins ("%INS");
ins.zero();
if (ins.first() == NOERR)
{
if (ins.empty())
return error_box("Codice STUDIO NON ATTIVATO in tabella invii");
else
{
_nome_simbolico = ins.get("CODTAB");
long ditta = ins.get_long("I0");
if (ditta != 0)
{
_esiste_ditta = TRUE;
_ditta = ditta;
}
else
{
_esiste_ditta = FALSE;
_ditta = 0;
}
}
}
else
return error_box("Codice STUDIO NON ATTIVATO in tabella invii");
return TRUE;
}
bool TInv_cont::leggi_trasfer()
{
_trasf = "";
_trasf = firm2dir(0);
_trasf << "\\trasfer";
_tras_file.open(_trasf);
if (_tras_file.exist())
{
if (_tras_file.read_control_rec())
{
_control_rec = _tras_file.record();
if (!record_controllo())
return FALSE;
}
else
return FALSE;
}
else
return FALSE;
return TRUE;
}
bool TInv_cont::record_controllo()
{
TString tiporecord = _control_rec.sub(0,2);
if (tiporecord != " 1")
return FALSE;
return TRUE;
}
bool TInv_cont::esegui_controlli()
{
_esiste_record = leggi_trasfer();
if (!controlli()) return FALSE;
return TRUE;
}
void TInv_cont::setta_parametri_record(TMask& m,const TString& flag)
{
long ditta = m.get_long(F_DITTAINV);
set_firm(ditta);
TConfig conf (CONFIG_DITTA);
conf.set("FlStInv", flag);
}
bool TInv_cont::controlli()
{
if (!_esiste_ditta && !_esiste_record) return TRUE; //Mi trovo in una condizione normale
if (_esiste_ditta && !_esiste_record)
return error_box("Rilevato stato di ripartenza con dati contradditori: programma interrotto");
if (!_esiste_ditta && _esiste_record)
return error_box("Rilevato stato di ripartenza con dati contradditori: programma interrotto");
if (_esiste_ditta && _esiste_record)
{
if (!sub_controlli())
return error_box("Rilevato stato di ripartenza con dati contradditori: programma interrotto");
}
return TRUE;
}
bool TInv_cont::sub_controlli()
{
long ditta_trasfer = atol(_control_rec.sub(25,29));
if (_ditta == ditta_trasfer)
{
if (!prefix().exist(_ditta))
return FALSE;
if (!tabella_ditta())
return FALSE;
}
else
return FALSE;
if (!controlla_stato_invio())
return FALSE;
if (!numero_data())
return FALSE;
return TRUE;
}
bool TInv_cont::tabella_ditta()
{
TTable ind ("%IND");
TString dep;
dep.format("%05d", _ditta);
ind.zero();
ind.put("CODTAB", dep);
if (ind.read() == NOERR)
{
_stato = ind.get("S6");
_num = ind.get_int("I0");
_data = ind.get_date("D0");
_files = "";
if (ind.get_bool("B0"))
_files << "W";
if (ind.get_bool("B1"))
_files << "A";
if (ind.get_bool("B2"))
_files << "P";
if (ind.get_bool("B3"))
_files << "Z";
if (ind.get_bool("B4"))
_files << "U";
if (ind.get_bool("B5"))
_files << "B";
return TRUE;
}
return FALSE;
}
bool TInv_cont::controlla_stato_invio()
{
set_firm(_ditta);
TConfig conf(CONFIG_DITTA);
_std = conf.get("FlStInv");
if (_stato != _std)
return FALSE;
else
{
TString uselab = _tras_file.ult_file();
if (_stato == "D" && uselab != " ")
return FALSE;
}
return TRUE;
}
bool TInv_cont::numero_data()
{
int num = _tras_file.nultras();
TString str = _tras_file.dataultras();
TDate data (str);
if (_num != num || data != _data)
return FALSE;
return TRUE;
}
void TInv_cont::codifica_ditta(TMask& m)
{
TLocalisamfile ditte (LF_NDITTE);
long ditta = m.get_long(F_DITTAINV);
ditte.setkey(1);
ditte.zero();
ditte.put(NDT_CODDITTA, ditta);
if (ditte.read() == NOERR)
{
TString ragsoc = ditte.get(NDT_RAGSOC);
m.set(F_RAGSOC, ragsoc);
}
}
bool TInv_cont::setta_maschera_hnd(TMask_field& f, KEY k)
{
if ( (k == K_TAB || k == K_ENTER) && f.mask().is_running())
{
app()._ditta = f.mask().get_long(F_DITTAINV);
if (!app().tabella_ditta())
return error_box("La ditta indicata non e' presente sulla tabella ditta per invio");
if (!prefix().exist(app()._ditta))
return error_box("La ditta indicata non e' abilitata alla contabilita'");
if (app()._stato != "")
return error_box("Lo stato ultimo trasferimento non puo' essere significativo");
f.mask().set(F_DITTAINV, app()._ditta);
app().codifica_ditta(f.mask());
f.mask().set(F_NUMULINV, app()._num);
f.mask().set(F_DATAULIN, app()._data.string());
f.mask().set(F_STATO, app()._stato);
}
return TRUE;
}
void TInv_cont::crea_marker(TMask& m)
{
TString str;
_marker = "";
_marker = firm2dir(0);
_marker << "\\marker";
FILE* i;
const word size = 64;
TString buffer(size);
buffer.spaces();
if ( (i = fopen(_marker,"w+t")) != NULL)
{
str = format("%-10s", (const char*) _nome_simbolico);
buffer.overwrite(str,0);
long ditta = m.get_long(F_DITTAINV);
str = format("%04d", ditta);
buffer.overwrite(str,10);
int num = m.get_int(F_NUMULINV);
num++;
str = format("%03d", num);
buffer.overwrite(str,14);
TString data (m.get(F_DATALIM));
str = riconverti(data);
buffer.overwrite(str,17);
const word scritti = fwrite((char*)(const char*)buffer,sizeof(char),size,i);
fclose(i);
}
}
void TInv_cont::aggiorna_marker(TString& token, int pos)
{
TString str;
_marker = "";
_marker = firm2dir(0);
_marker << "\\marker";
FILE* i;
const word size = 64;
TString buffer(size);
//buffer.spaces();
if ( (i = fopen(_marker,"r+t")) != NULL)
{
const word letti = fread((char*)(const char*)buffer,sizeof(char),size,i);
buffer.overwrite(token,pos);
fseek(i, 0L, SEEK_SET);
const word scritti = fwrite((char*)(const char*)buffer,sizeof(char),size,i);
fclose(i);
}
}
void TInv_cont::calcola_totale_record()
{
_tras_file.open(_trasf);
leggi_record_controllo();
TString sigle = _control_rec.sub(38,47);
sigle.trim();
_tot_rec = 0;
for (int i = 0; i < sigle.len(); i++)
{
long tot_rec = atol(_control_rec.mid((i * 6) + 47,6));
_tot_rec += tot_rec;
}
}
void TInv_cont::setta_tabella_studio(TMask& m,bool flag_ditta)
{
TTable ins ("%INS");
TString dep;
long ditta;
if (flag_ditta)
ditta = m.get_long(F_DITTAINV);
else
ditta = 0;
dep.format("%-10s", (const char*) _nome_simbolico);
ins.zero();
ins.put("CODTAB", dep);
if (ins.read() == NOERR)
{
ins.put("I0", ditta);
ins.rewrite();
}
else
warning_box("Tabella studio per invio NON AGGIORNATA");
}
void TInv_cont::setta_tabella_ditta(TMask& m,const char* flag, bool comp)
{
TTable ind ("%IND");
TString dep;
long ditta = m.get_long(F_DITTAINV);
dep.format("%05d", ditta);
ind.zero();
ind.put("CODTAB", dep);
if (ind.read() == NOERR)
{
int num = m.get_int(F_NUMULINV);
num++;
TDate data (m.get(F_DATALIM));
ind.put("S6", flag);
if (comp)
{
ind.put("I0", (long)num);
ind.put("D0", data);
}
ind.rewrite();
}
else
warning_box("Tabella ditta per invio NON AGGIORNATA");
}
void TInv_cont::crea_record_controllo(TMask& m)
{
int size = 256;
TString buffer(256);
TString str;
if (_tras_file.exist())
_tras_file.open(_trasf);
else
{
_tras_file.open(_trasf,TRUE); //Metto il parametro TRUE (che di default e' FALSE), perche' voglio creare un file che non e' ancore esistente
buffer.spaces();
buffer.overwrite(" 1",0); //Tipo record
str = format("%-10s", (const char*) _nome_simbolico);
buffer.overwrite(str,15); //Nome studio
long ditta = m.get_long(F_DITTAINV);
str = format("%04d", ditta);
buffer.overwrite(str,25); //Ditta inviante
int num = m.get_int(F_NUMULINV);
num++;
str = format("%03d", num);
buffer.overwrite(str,29); //Numero progr. invio
TString data (m.get(F_DATALIM));
str = riconverti(data);
buffer.overwrite(str,32); //Data limite invio
str = format("%-9s", (const char*) _files);
buffer.overwrite(str,38);
str = _files.sub(0,1);
buffer.overwrite(str,240);
if (!_tras_file.write_control_rec(buffer, size))
warning_box("Il record di controllo del file trasfer non e' stato aggiornato correttamente");
}
_tras_file.close();
}
const char* TInv_cont::cerca_provincia(const TString& comcf)
{
TLocalisamfile comuni(LF_COMUNI);
comuni.setkey(1);
comuni.zero();
comuni.put(COM_COM, comcf);
if (comuni.read() == NOERR)
TEMP = comuni.get(COM_PROVCOM);
else
TEMP = "";
return TEMP;
}
bool TInv_cont::invio_contabilita(TMask& m)
{
char uselab;
TString record(256),key,nrec;
int posiz,i;
char sigla;
_tras_file.open(_trasf);
leggi_record_controllo();
uselab = (_tras_file.ult_file())[0];
if (uselab == ' ') //Significa che sono in caso di ripartenza ma ho
return TRUE; //gia' trasferito tutti gli archivi e devo solo fare la copia su dischi
posiz = _files.find(uselab); //Ritorna la posizione della sigla all'interno della schiera
key = _tras_file.key();
key.trim();
nrec = _control_rec.sub(47,101);
for (i = posiz; i < _files.len();i++)
{
sigla = _files[i];
_numrec = atol(nrec.mid(i * 6,6));
switch (sigla)
{
case 'W':
if (!invio_tab_cau(key,m))
return FALSE;
break;
case 'A':
if (!invio_clifo(key,m))
return FALSE;
break;
case 'P':
if (!invio_pcon(key,m))
return FALSE;
break;
case 'Z':
if (!invio_mov_PN(key,m))
return FALSE;
break;
case 'U':
if (!invio_mov_IVA(key,m))
return FALSE;
break;
default:
break;
};
key = "";
}
// Finito di trasferire tutti gli archivi pulisco la sigla ultimo file da elaborare
_tras_file.open(_trasf);
leggi_record_controllo();
_control_rec.overwrite(" ",240);
_tras_file.write_control_rec(_control_rec,256);
_tras_file.close();
return TRUE;
}
bool TInv_cont::invio_tab_cau(TString& key,TMask& m)
{
int size = 256;
TString record(size);
TString cod;
TLocalisamfile cau (LF_CAUSALI);
long cicli = cau.items();
cicli -= _numrec;
_prog = new TProgind(cicli,"Invio tabella causali in corso... Prego attendere.",FALSE);
if (key == "")
cau.first();
else
{
cod = key.mid(2,3);
cau.setkey(1);
cau.zero();
cau.put(CAU_CODCAUS, cod);
cau.read();
}
for (; !cau.eof(); cau.next())
{
TString str;
_prog->addstatus(1);
_tras_file.open(_trasf);
record.spaces();
// Se trovo un codice causale alfanumerico l'invio deve essere interrotto
const char* codcau = cau.get(CAU_CODCAUS);
if (!real::is_natural(codcau))
return error_box("Rilevato un codice causale alfanumerico nella causale %03s: impossibile proseguire",codcau);
str.format("%03s", codcau);
record.overwrite("W1",0); //Tipo record
record.overwrite(str,2); //Codice causale
//Salvataggio della sigla e della chiave sul record di controllo del file trasfer
leggi_record_controllo();
TString chiave,app;
chiave.format("%2s%03s", (const char*) "W1", codcau);
app.format("%-15s", (const char*) chiave);
_control_rec.overwrite("W",240);
_control_rec.overwrite(app,241);
//_tras_file.write_control_rec(_control_rec,size);
//_tras_file.close();
TString descr = cau.get(CAU_DESCR);
descr.format("%-.20s", (const char*) descr);
record.overwrite(descr,15); //Descrizione
TString tipodoc = cau.get(CAU_TIPODOC);
record.overwrite(tipodoc,35); //Tipo documento
//Se trovo un registro IVA con lunghezza maggiore di 1 l'invio deve essere interrotto
TString reg = cau.get(CAU_REG);
if (reg.len() > 1)
return error_box("Rilevato un registro IVA con lunghezza superiore a 1 nella causale %03s: impossibile proseguire", codcau);
record.overwrite(reg,37); //Registro IVA
bool alleg = cau.get_bool(CAU_ALLEG);
if (alleg)
record.overwrite("X",38);
else //Flag esclusione tipo documento da allegato
record.overwrite(" ",38);
int m770 = atoi(cau.get(CAU_M770));
str = format("%1d", m770);
record.overwrite(str,39); //Collegamento modello 770
TString cespiti = cau.get(CAU_COLLCESP);
record.overwrite(cespiti,40); //Collegamento cespiti
bool numdoc = cau.get_bool(CAU_NUMDOC);
if (numdoc)
record.overwrite("1",206);
else //Flag immissione numero documento
record.overwrite("0",206);
bool datadoc = cau.get_bool(CAU_DATADOC);
if (datadoc)
record.overwrite("1",207);
else //Flag immissione data documento
record.overwrite("0",207);
const char* codcausim = cau.get(CAU_CODCAUSIM);
if (!real::is_natural(codcausim))
return error_box("Rilevato un codice causale per incasso immediato alfanumerico nella causale %03s: impossibile proseguire",codcau);
str.format("%03s", codcausim);
record.overwrite(str,209); //Codice causale per incasso immediato
bool intracom = cau.get_bool(CAU_INTRACOM);
if (intracom)
record.overwrite("X",246);
else //Flag per operazioni intracomunitarie
record.overwrite(" ",246);
bool valintra = cau.get_bool(CAU_VALINTRA);
if (valintra)
record.overwrite("X",247);
else //Gestione valuta per oper. intracomunitarie
record.overwrite(" ",247);
bool ritfatt = cau.get_bool(CAU_RITFATT);
if (ritfatt)
record.overwrite("X",248);
else //Flag causale per fattura ricevuta in ritardo
record.overwrite(" ",248);
bool autofatt = cau.get_bool(CAU_AUTOFATT);
if (autofatt)
record.overwrite("X",249);
else //Autofattura art.34
record.overwrite(" ",249);
int num = 0;
int pos_gcs = 41;
int pos_sez = 191;
_codcaus = cau.get(CAU_CODCAUS);
TLocalisamfile rcau (LF_RCAUSALI);
do
{
num++;
rcau.setkey(1);
rcau.zero();
rcau.put(RCA_CODCAUS, _codcaus);
rcau.put(RCA_NRIGA, num);
if (rcau.read() == NOERR)
{
int g = rcau.get_int (RCA_GRUPPO);
int c = rcau.get_int (RCA_CONTO);
if (g > 99)
return error_box("Rilevato un gruppo composto da 3 cifre nella causale %03s riga %d: impossibile proseguire",codcau,num);
if (c > 99)
return error_box("Rilevato un conto composto da 3 cifre nella causale %03s riga %d: impossibile proseguire",codcau,num);
long s = rcau.get_long(RCA_SOTTOCONTO);
TString sez = rcau.get (RCA_SEZIONE);
str = format("%02d", g);
record.overwrite(str,pos_gcs); //Gruppo
pos_gcs += 2;
str = format("%02d", c);
record.overwrite(str,pos_gcs); //Conto
pos_gcs += 2;
str = format("%06ld", s);
record.overwrite(str,pos_gcs); //Sottoconto
pos_gcs += 6;
record.overwrite(sez,pos_sez); //Sezione
pos_sez++;
}
else
{
int g = 0;
int c = 0;
long s = 0;
TString sez = " ";
str = format("%02d", g);
record.overwrite(str,pos_gcs); //Gruppo
pos_gcs += 2;
str = format("%02d", c);
record.overwrite(str,pos_gcs); //Conto
pos_gcs += 2;
str = format("%06ld", s);
record.overwrite(str,pos_gcs); //Sottoconto
pos_gcs += 6;
record.overwrite(sez,pos_sez); //Sezione
pos_sez++;
}
if (num == 15)
{
TString cau_app;
rcau.next();
if (!rcau.eof())
cau_app = rcau.get(RCA_CODCAUS);
else
cau_app = "";
if (_codcaus == cau_app)
return error_box("Rilevata una causale con piu' di 15 righe: impossibile proseguire");
}
}
while (num < 15);
_numrec++;
TString stringa;
stringa.format("%06ld", _numrec);
int posiz = _files.find("W");
_control_rec.overwrite(stringa,((posiz * 6) + 47));
_tras_file.write_control_rec(_control_rec,size);
_tras_file.close();
_tras_file.open(_trasf,TRUE);
_tras_file.write_control_rec(record,size);
_tras_file.close();
}
delete _prog;
//Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare
//e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di
//ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche'
//la chiave e' compilata con i dati del file precedente.
_tras_file.open(_trasf);
leggi_record_controllo();
TString chiave,app,sigla;
app.format("%-15s", (const char*) chiave);
char sigla_p = _tras_file.ult_file()[0];
int posiz = _files.find(sigla_p);
TString nuova_sigla = " ";
if (posiz < _files.len())
nuova_sigla = _files.mid(posiz+1,1);
_control_rec.overwrite(nuova_sigla,240);
_control_rec.overwrite(app,241);
_tras_file.write_control_rec(_control_rec,size);
_tras_file.close();
setta_tabella_ditta(m,"D",FALSE);
setta_parametri_record(m,"D");
return TRUE;
}
bool TInv_cont::invio_clifo(TString& key,TMask& m)
{
int size = 256;
TString record(size);
char tipocf;
long codcf;
TLocalisamfile clifo (LF_CLIFO);
long cicli = clifo.items();
cicli -= _numrec;
_prog = new TProgind(cicli,"Invio anagrafica Clienti / Fornitori in corso... Prego attendere.",FALSE);
if (key == "")
clifo.first();
else
{
tipocf = (key.mid(2,1))[0];
codcf = atol(key.mid(3,6));
clifo.setkey(1);
clifo.zero();
clifo.put(CLI_TIPOCF, tipocf);
clifo.put(CLI_CODCF, codcf);
clifo.read();
}
for (; !clifo.eof(); clifo.next())
{
TString str;
_prog->addstatus(1);
_tras_file.open(_trasf);
record.spaces();
// Il tipocf su PC e' C = cliente F = fornitore.
// Il tipocf su AS400 e' 1 = cliente 2 = fornitore.
TString tipo_cod;
char tipo = clifo.get_char(CLI_TIPOCF);
if (tipo == 'C')
tipo_cod = "1";
else
if (tipo == 'F')
tipo_cod = "2";
record.overwrite("A1",0); //Tipo record
record.overwrite(tipo_cod,2); //Tipo cliente/fornitore
long codice = clifo.get_long(CLI_CODCF);
str.format("%06ld", codice);
record.overwrite(str,3); //Codice cliente/fornitore
//Salvataggio della chiave sul record di controllo del file trasfer
leggi_record_controllo();
TString chiave,app;
chiave.format("%2s%s%06ld", (const char*) "A1", (const char*) tipo_cod, codice);
app.format("%-15s", (const char*) chiave);
_control_rec.overwrite("A",240);
_control_rec.overwrite(app,241);
// _tras_file.write_control_rec(_control_rec,size);
// _tras_file.close();
//Il tipo persona su PC e' F = fisica G = giuridica
//Il tipo persona su AS400 e' 0 = giuridica 1 = fisica
char tipop = clifo.get_char(CLI_TIPOPERS);
TString tipopers;
if (tipop == 'F')
tipopers = "1";
else
if (tipop == 'G')
tipopers = "0";
record.overwrite(tipopers,15); //Tipo persona
TString ragsoc = clifo.get(CLI_RAGSOC);
TString cognome = ragsoc.mid(0,30);
TString nome = ragsoc.mid(30,20);
str.format("%-30s", (const char*) cognome); //Cognome o I ragione sociale
record.overwrite(str,16);
str.format("%-20s", (const char*) nome);
record.overwrite(str,46); //Nome o II ragione sociale
//Se la partita IVA e' maggiore di 11 il programma di invio viene fermato
TString paiv = clifo.get(CLI_PAIV);
if (paiv.len() > 11)
return error_box("Rilevata partita IVA con piu' di 11 caratteri in codice %c%d: impossibile proseguire",tipo,codice);
str.format("%-11s", (const char*) paiv);
record.overwrite(str,66); //Partita IVA
TString cofi = clifo.get(CLI_COFI);
str.format("%-16s", (const char*) cofi);
record.overwrite(str,77); //Codice fiscale
TString indcf = clifo.get(CLI_INDCF);
str.format("%-35s", (const char*) indcf);
record.overwrite(str,93); //Indirizzo
TString capcf = clifo.get(CLI_CAPCF);
record.overwrite(capcf,128); //Codice di avviamento postale
TString localita = clifo.get(CLI_LOCCF);
str.format("%-.20s", (const char*) localita);
record.overwrite(str,133); //Localita'
TString comcf = clifo.get(CLI_COMCF);
TString provincia = cerca_provincia(comcf);
str.format("%-2s", (const char*) provincia);
record.overwrite(str,153); //Provincia
TString ptel = clifo.get(CLI_PTEL);
TString tel = clifo.get(CLI_TEL);
TString appoggio;
appoggio << ptel << " " << tel;
if (appoggio.len() > 12)
warning_box("Rilevato numero telefonico troppo lungo in codice %c%d: impossibile inviare",tipo,codice);
else //Numero telefono
record.overwrite(appoggio,155);
TString alleg = clifo.get(CLI_ALLEG);
record.overwrite(alleg,167); //Flag gestione allegato
int gruppo = clifo.get_int(CLI_GRUPPORIC);
int conto = clifo.get_int(CLI_CONTORIC);
if (gruppo > 99)
return error_box("Rilevato gruppo costo/ricavo composto da 3 cifre in codice %c%d: impossibile proseguire",tipo,codice);
if (conto > 99)
return error_box("Rilevato conto costo/ricavo composto da 3 cifre in codice %c%d: impossibile proseguire",tipo,codice);
long sottoc = clifo.get_long(CLI_SOTTOCRIC);
str.format("%02d", gruppo);
record.overwrite(str,168); //Gruppo di costo/ricavo
str.format("%02d", conto);
record.overwrite(str,170); //Conto di costo/ricavo
str.format("%06ld", sottoc);
record.overwrite(str,172); //sottoconto di costo/ricavo
long codalleg = clifo.get_long(CLI_CODALLEG);
str.format("%06ld", codalleg);
record.overwrite(str,179);
//Se il codice di pagamento e' superiore alle 2 cifre l'invio deve essere interrotto
TString codpag = clifo.get(CLI_CODPAG);
if (codpag.len() > 2)
return error_box("Rilevato un codice di pagamento composto da 3 o piu' cifre in codice %c%d: impossibile proseguire",tipo,codice);
str.format("%-2s", (const char*) codpag);
_numrec++;
TString stringa;
stringa.format("%06ld", _numrec);
int posiz = _files.find("A");
_control_rec.overwrite(stringa,((posiz * 6) + 47));
_tras_file.write_control_rec(_control_rec,size);
_tras_file.close();
_tras_file.open(_trasf,TRUE);
_tras_file.write_control_rec(record,size);
_tras_file.close();
}
delete _prog;
//Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare
//e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di
//ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche'
//la chiave e' compilata con i dati del file precedente.
_tras_file.open(_trasf);
leggi_record_controllo();
TString chiave,app,sigla;
app.format("%-15s", (const char*) chiave);
char sigla_p = _tras_file.ult_file()[0];
int posiz = _files.find(sigla_p);
TString nuova_sigla = " ";
if (posiz < _files.len())
nuova_sigla = _files.mid(posiz+1,1);
_control_rec.overwrite(nuova_sigla,240);
_control_rec.overwrite(app,241);
_tras_file.write_control_rec(_control_rec,size);
_tras_file.close();
setta_tabella_ditta(m,"D",FALSE);
setta_parametri_record(m,"D");
return TRUE;
}
bool TInv_cont::invio_pcon(TString& key,TMask& m)
{
int size = 256;
TString record(size);
int gruppo,conto;
long sottoc;
TLocalisamfile pcon (LF_PCON);
long cicli = pcon.items();
cicli -= _numrec;
_prog = new TProgind(cicli,"Invio anagrafica Piano dei Conti in corso... Prego attendere.",FALSE);
if (key == "")
pcon.first();
else
{
gruppo = atoi(key.mid(2,2));
conto = atoi(key.mid(4,2));
sottoc = atol(key.mid(6,6));
pcon.setkey(1);
pcon.zero();
pcon.put(PCN_GRUPPO, gruppo);
pcon.put(PCN_CONTO, conto);
pcon.put(PCN_SOTTOCONTO, sottoc);
pcon.read();
}
for (; !pcon.eof(); pcon.next())
{
TString str;
_prog->addstatus(1);
_tras_file.open(_trasf);
record.spaces();
int g = pcon.get_int (PCN_GRUPPO);
if (g > 99)
return error_box("Rilevato un gruppo composto da 3 cifre in %03d: impossibile proseguire",g);
int c = pcon.get_int (PCN_CONTO);
if (c > 99)
return error_box("Rilevato un conto composto da 3 cifre in %03d: impossibile proseguire",c);
long s = pcon.get_long(PCN_SOTTOCONTO);
// Se si tratta di un GRUPPO
if (g != 0 && c == 0 && s == 0)
{
//Salvataggio della sigla e della chiave sul record di controllo del file trasfer
leggi_record_controllo();
TString chiave,app;
chiave.format("%2s%02d%02d%06ld", (const char*) "P1", g, c, s);
app.format("%-15s", (const char*) chiave);
_control_rec.overwrite("P",240);
_control_rec.overwrite(app,241);
// _tras_file.write_control_rec(_control_rec,size);
// _tras_file.close();
record.overwrite("P1",0); //Tipo record
str.format("%02d", g);
record.overwrite(str,2); //Gruppo
TString descr (pcon.get(PCN_DESCR));
str.format("%-.30s", (const char*) descr);
record.overwrite(str,15); //Descrizione gruppo
}
// Se si tratta di un CONTO
if (g != 0 && c != 0 && s == 0)
{
//Salvataggio della sigla e della chiave sul record di controllo del file trasfer
leggi_record_controllo();
TString chiave,app;
chiave.format("%2s%02d%02d%06ld", (const char*) "P2", g, c, s);
app.format("%-15s", (const char*) chiave);
_control_rec.overwrite("P",240);
_control_rec.overwrite(app,241);
// _tras_file.write_control_rec(_control_rec,size);
// _tras_file.close();
record.overwrite("P2",0); //Tipo record
str.format("%02d", g);
record.overwrite(str,2); //Gruppo
str.format("%02d", c);
record.overwrite(str,4); //Conto
TString descr (pcon.get(PCN_DESCR));
str.format("%-.30s", (const char*) descr);
record.overwrite(str,15); //Descrizione conto
int indbil = pcon.get_int(PCN_INDBIL);
str.format("%d", indbil);
record.overwrite(str,45); //Indicatore di bilancio
TString tmcf = pcon.get(PCN_TMCF);
record.overwrite(tmcf,46); //Flag conto cliente/fornitore
bool stsottbil = pcon.get_bool(PCN_STSOTTBIL);
if (stsottbil)
str = "0";
else
str = "1";
record.overwrite(str,47); //Flag stampa dettaglio sottoconti su bilancio
// Classe IV direttiva CEE
TString sez = pcon.get(PCN_SEZIVD);
if (sez == "0")
sez = " ";
record.overwrite(sez,48); //Sezione IV dir
TString let = pcon.get(PCN_LETTIVD);
record.overwrite(let,49); //Lettera IV dir
int numrom = atoi(pcon.get(PCN_NUMRIVD));
str.format("%03d", numrom);
record.overwrite(str,60); //Numero arabo corrispondente al numero romano
TString numr = itor(numrom);
str.format("%-8s", (const char*) numr);
record.overwrite(str,50); //Numero romano IV dir
int num = pcon.get_int(PCN_NUMIVD);
str.format("%02d", num);
record.overwrite(str,58); //Numero arabo IV dir
// Classe IV direttiva CEE di segno opposto
TString sezop = pcon.get(PCN_SEZIVDOPP);
if (sezop == "0")
sezop = " ";
record.overwrite(sezop,63); //Sezione IV dir
TString letop = pcon.get(PCN_LETTIVDOPP);
record.overwrite(letop,64); //Lettera IV dir
int numromop = atoi(pcon.get(PCN_NUMRIVDOPP));
str.format("%03d", numromop);
record.overwrite(str,75); //Numero arabo corrispondente al numero romano
TString numrop = itor(numromop);
str.format("%-8s", (const char*) numrop);
record.overwrite(str,65); //Numero romano IV dir
int numop = pcon.get_int(PCN_NUMIVDOPP);
str.format("%02d", numop);
record.overwrite(str,73); //Numero arabo IV dir
}
// Se si tratta di un SOTTOCONTO
if (g != 0 && c != 0 && s != 0)
{
//Salvataggio della sigla e della chiave sul record di controllo del file trasfer
leggi_record_controllo();
TString chiave,app;
chiave.format("%2s%02d%02d%06ld", (const char*) "P3", g, c, s);
app.format("%-15s", (const char*) chiave);
_control_rec.overwrite("P",240);
_control_rec.overwrite(app,241);
// _tras_file.write_control_rec(_control_rec,size);
// _tras_file.close();
record.overwrite("P3",0); //Tipo record
str.format("%02d", g);
record.overwrite(str,2); //Gruppo
str.format("%02d", c);
record.overwrite(str,4); //Conto
str.format("%06ld", s);
record.overwrite(str,6);
TString descr (pcon.get(PCN_DESCR));
str.format("%-.30s", (const char*) descr);
record.overwrite(str,15); //Descrizione sottoconto
int tipospric = pcon.get_int(PCN_TIPOSPRIC);
str.format("%d", tipospric);
record.overwrite(str,45); //Tipo costo/ricavo
int ricser = pcon.get_int(PCN_RICSER);
if (ricser == 0)
str = " ";
else
str.format("%d", ricser);
record.overwrite(str,46); //Tipo attivita'
// Classe IV direttiva CEE
TString sez = pcon.get(PCN_SEZIVD);
if (sez == "0")
sez = " ";
record.overwrite(sez,47); //Sezione IV dir
TString let = pcon.get(PCN_LETTIVD);
record.overwrite(let,48); //Lettera IV dir
int numrom = atoi(pcon.get(PCN_NUMRIVD));
str.format("%03d", numrom);
record.overwrite(str,59); //Numero arabo corrispondente al numero romano
TString numr = itor(numrom);
str.format("%-8s", (const char*) numr);
record.overwrite(str,49); //Numero romano IV dir
int num = pcon.get_int(PCN_NUMIVD);
str.format("%02d", num);
record.overwrite(str,57); //Numero arabo IV dir
// Classe IV direttiva CEE di segno opposto
TString sezop = pcon.get(PCN_SEZIVDOPP);
if (sezop == "0")
sezop = " ";
record.overwrite(sezop,62); //Sezione IV dir
TString letop = pcon.get(PCN_LETTIVDOPP);
record.overwrite(letop,63); //Lettera IV dir
int numromop = atoi(pcon.get(PCN_NUMRIVDOPP));
str.format("%03d", numromop);
record.overwrite(str,74); //Numero arabo corrispondente al numero romano
TString numrop = itor(numromop);
str.format("%-8s", (const char*) numrop);
record.overwrite(str,64); //Numero romano IV dir
int numop = pcon.get_int(PCN_NUMIVDOPP);
str.format("%02d", numop);
record.overwrite(str,72); //Numero arabo IV dir
}
_numrec++;
TString stringa;
stringa.format("%06ld", _numrec);
int posiz = _files.find("P");
_control_rec.overwrite(stringa,((posiz * 6) + 47));
_tras_file.write_control_rec(_control_rec,size);
_tras_file.close();
_tras_file.open(_trasf,TRUE);
_tras_file.write_control_rec(record,size);
_tras_file.close();
}
delete _prog;
//Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare
//e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di
//ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche'
//la chiave e' compilata con i dati del file precedente.
_tras_file.open(_trasf);
leggi_record_controllo();
TString chiave,app,sigla;
app.format("%-15s", (const char*) chiave);
char sigla_p = _tras_file.ult_file()[0];
int posiz = _files.find(sigla_p);
TString nuova_sigla = " ";
if (posiz < _files.len())
nuova_sigla = _files.mid(posiz+1,1);
_control_rec.overwrite(nuova_sigla,240);
_control_rec.overwrite(app,241);
_tras_file.write_control_rec(_control_rec,size);
_tras_file.close();
setta_tabella_ditta(m,"D",FALSE);
setta_parametri_record(m,"D");
return TRUE;
}
bool TInv_cont::testata_mov_PN(long numreg)
{
TLocalisamfile mov (LF_MOV);
mov.setkey(1);
mov.zero();
mov.put(MOV_NUMREG, numreg);
if (mov.read() == NOERR)
{
_datadoc = mov.get_date(MOV_DATADOC);
_numdoc = mov.get (MOV_NUMDOC);
_reg = mov.get (MOV_REG);
_codcausm = mov.get (MOV_CODCAUS);
_codpag = mov.get (MOV_CODPAG);
_tipodoc = mov.get (MOV_TIPODOC);
_protiva = mov.get_long(MOV_PROTIVA);
_uprotiva = mov.get_long(MOV_UPROTIVA);
}
else
return FALSE;
return TRUE;
}
bool TInv_cont::invio_mov_PN(TString& key,TMask& m)
{
int size = 256;
TString record(size);
long numreg,nreg_p;
int numrig;
TLocalisamfile rmov (LF_RMOV);
nreg_p = -1;
long cicli = rmov.items();
cicli -= _numrec;
_prog = new TProgind(cicli,"Invio Movimenti di primanota in corso... Prego attendere.",FALSE);
if (key == "")
rmov.first();
else
{
numreg = atol(key.mid(2,6));
numrig = atoi(key.mid(8,2));
rmov.setkey(1);
rmov.zero();
rmov.put(RMV_NUMREG, numreg);
rmov.put(RMV_NUMRIG, numrig);
rmov.read();
}
for (; !rmov.eof(); rmov.next())
{
TString str;
_prog->addstatus(1);
_tras_file.open(_trasf);
record.spaces();
long nreg = rmov.get_long(RMV_NUMREG);
int nrig = rmov.get_int (RMV_NUMRIG);
//Salvataggio della chiave sul record di controllo del file trasfer
leggi_record_controllo();
TString chiave,app;
chiave.format("%2s%06ld%02d", (const char*) "Z1", nreg, nrig);
app.format("%-15s", (const char*) chiave);
_control_rec.overwrite("Z",240);
_control_rec.overwrite(app,241);
// _tras_file.write_control_rec(_control_rec,size);
// _tras_file.close();
if (nreg > 999999)
return error_box("Rilevato un numero di registrazione composto da 7 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig);
if (nrig > 99)
return error_box("Rilevato un numero di riga composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig);
record.overwrite("Z1",0); //Tipo record
str.format("%06ld", nreg);
record.overwrite(str,2); //Numero di registrazione
str.format("%02d", nrig);
record.overwrite(str,8); //Numero di riga
if (nreg != nreg_p)
if (!testata_mov_PN(nreg))
return error_box("Rilevata riga mancante di testata: impossibile proseguire");
nreg_p = nreg;
TDate datareg (rmov.get(RMV_DATAREG));
TString dataregstr = datareg.string();
str = riconverti(dataregstr);
record.overwrite(str,15); //Data di registrazione
//Determino il segnalino della competenza
int segnalino;
int annoes = rmov.get_int(RMV_ANNOES);
int anno = date2esc(datareg);
if (annoes == anno)
segnalino = 0;
else
segnalino = 1;
str.format("%d", segnalino);
record.overwrite(str,21); //Segnalino della competenza
TString datadocstr = _datadoc.string();
str = riconverti(datadocstr);
record.overwrite(str,22); //Data documento
str.format("%-7s", (const char*) _numdoc);
record.overwrite(str,28);
if (_reg.len() > 1)
return error_box("Rilevato un codice registro IVA composto da 2 o piu' cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig);
record.overwrite(_reg,35); //Codice registro IVA
str.format("%05d", _protiva);
record.overwrite(str,36); //Numero protocollo IVA
// Se trovo un codice causale alfanumerico l'invio deve essere interrotto
const char* cod_causm = (const char*)_codcausm;
if (_codcausm != "")
if (!real::is_natural(cod_causm))
return error_box("Rilevato un codice causale alfanumerico in %07ld riga %03d: impossibile proseguire",nreg,nrig);
str.format("%03s", (const char*)_codcausm);
record.overwrite(str,41); //Codice causale
TString descr = rmov.get(RMV_DESCR);
str.format("%-.30s", (const char*) descr);
record.overwrite(str,44); //Descrizione riga di movimento
int gruppo = rmov.get_int(RMV_GRUPPO);
if (gruppo > 99)
return error_box("Rilevato un gruppo di partita composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig);
str.format("%02d", gruppo);
record.overwrite(str,74); //Gruppo di partita
int conto = rmov.get_int(RMV_CONTO);
if (conto > 99)
return error_box("Rilevato un conto di partita composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig);
str.format("%02d", conto);
record.overwrite(str,76); //Conto di partita
long sottoc = rmov.get_long(RMV_SOTTOCONTO);
str.format("%06ld", sottoc);
record.overwrite(str,78); //Sottoconto di partita
TString sez = rmov.get(RMV_SEZIONE);
str.format("%s", (const char*) sez);
record.overwrite(str,84); //Sezione importo
int gruppoc = rmov.get_int(RMV_GRUPPOC);
if (gruppoc > 99)
return error_box("Rilevato un gruppo di contropartita composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig);
str.format("%02d", gruppoc);
record.overwrite(str,85); //Gruppo di contropartita
int contoc = rmov.get_int(RMV_CONTOC);
if (contoc > 99)
return error_box("Rilevato un conto di contropartita composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig);
str.format("%02d", contoc);
record.overwrite(str,87); //Conto di contropartita
long sottocc = rmov.get_long(RMV_SOTTOCONTOC);
str.format("%06ld", sottocc);
record.overwrite(str,89); //Sottoconto di contropartita
if (_codpag.len() > 2)
return error_box("Rilevato un codice di pagamento composto da 3 o piu' cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig);
str.format("%-2s", (const char*) _codpag);
record.overwrite(str,95); //Codice di pagamento
real importo (rmov.get_real(RMV_IMPORTO));
str.format("%011s", (const char*) importo.string());
record.overwrite(str,97); //Importo riga di movimento
str.format("%05d", _uprotiva);
record.overwrite(str,108); //Ultimo numero di protocollo IVA
TString tipoc = rmov.get(RMV_TIPOC);
record.overwrite(tipoc,219); //Flag cliente/fornitore
record.overwrite(_tipodoc,220); //Tipo documento
_numrec++;
TString stringa;
stringa.format("%06ld", _numrec);
int posiz = _files.find("Z");
_control_rec.overwrite(stringa,((posiz * 6) + 47));
_tras_file.write_control_rec(_control_rec,size);
_tras_file.close();
_tras_file.open(_trasf,TRUE);
_tras_file.write_control_rec(record,size);
_tras_file.close();
}
delete _prog;
//Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare
//e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di
//ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche'
//la chiave e' compilata con i dati del file precedente.
_tras_file.open(_trasf);
leggi_record_controllo();
TString chiave,app,sigla;
app.format("%-15s", (const char*) chiave);
char sigla_p = _tras_file.ult_file()[0];
int posiz = _files.find(sigla_p);
TString nuova_sigla = " ";
if (posiz < _files.len())
nuova_sigla = _files.mid(posiz+1,1);
_control_rec.overwrite(nuova_sigla,240);
_control_rec.overwrite(app,241);
_tras_file.write_control_rec(_control_rec,size);
_tras_file.close();
setta_tabella_ditta(m,"D",FALSE);
setta_parametri_record(m,"D");
return TRUE;
}
bool TInv_cont::testata_mov_IVA(long numreg)
{
TLocalisamfile mov (LF_MOV);
mov.setkey(1);
mov.zero();
mov.put(MOV_NUMREG, numreg);
if (mov.read() == NOERR)
{
_codcf = mov.get_long(MOV_CODCF);
_data74ter = mov.get_date(MOV_DATA74TER);
_corrlire = mov.get_real(MOV_CORRLIRE);
_codvali = mov.get (MOV_CODVALI);
_cambioi = mov.get_real(MOV_CAMBIOI);
_corrval = mov.get_real(MOV_CORRVALUTA);
_ocfpi = mov.get (MOV_OCFPI);
if (_ocfpi.not_empty())
cerca_occasionale();
}
else
return FALSE;
return TRUE;
}
void TInv_cont::cerca_occasionale()
{
TLocalisamfile occas (LF_OCCAS);
occas.setkey(1);
occas.zero();
occas.put(OCC_CFPI, _ocfpi);
if (occas.read() == NOERR)
{
_ragsococc = occas.get(OCC_RAGSOC);
_indocc = occas.get(OCC_INDIR);
_capocc = occas.get(OCC_CAP);
TString com = occas.get(OCC_COM);
cerca_comune_occas(com);
}
else
{
_ragsococc = "";
_indocc = "";
_capocc = "";
_localocc = "";
_provocc = "";
}
}
void TInv_cont::cerca_comune_occas(const TString& com)
{
TLocalisamfile comuni (LF_COMUNI);
comuni.setkey(1);
comuni.zero();
comuni.put(COM_COM, com);
if (comuni.read() == NOERR)
{
_localocc = comuni.get(COM_DENCOM);
_provocc = comuni.get(COM_PROVCOM);
}
}
bool TInv_cont::invio_mov_IVA(TString& key,TMask& m)
{
int size = 256;
TString record(size);
long numreg,nreg_p;
int numrig;
int numero_righe = 0;
TLocalisamfile rmoviva (LF_RMOVIVA);
nreg_p = -1;
long cicli = rmoviva.items();
cicli -= _numrec;
_prog = new TProgind(cicli,"Invio Movimenti iva in corso... Prego attendere.",FALSE);
if (key == "")
rmoviva.first();
else
{
numreg = atol(key.mid(2,6));
numrig = atoi(key.mid(8,2));
rmoviva.setkey(1);
rmoviva.zero();
rmoviva.put(RMI_NUMREG, numreg);
rmoviva.put(RMI_NUMRIG, numrig);
rmoviva.read();
}
for (; !rmoviva.eof(); rmoviva.next())
{
TString str;
_prog->addstatus(1);
_tras_file.open(_trasf);
record.spaces();
long nreg = rmoviva.get_long(RMI_NUMREG);
int nrig = rmoviva.get_int (RMI_NUMRIG);
//Salvataggio della chiave sul record di controllo del file trasfer
leggi_record_controllo();
TString chiave,app;
chiave.format("%2s%06ld%02d", (const char*) "U1", nreg, nrig);
app.format("%-15s", (const char*) chiave);
_control_rec.overwrite("U",240);
_control_rec.overwrite(app,241);
// _tras_file.write_control_rec(_control_rec,size);
// _tras_file.close();
if (nreg > 999999)
return error_box("Rilevato un numero di registrazione composto da 7 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig);
if (nrig > 99)
return error_box("Rilevato un numero di riga composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig);
record.overwrite("U1",0); //Tipo record
str.format("%06ld", nreg);
record.overwrite(str,2); //Numero di registrazione
str.format("%02d", nrig);
record.overwrite(str,8); //Numero di riga
if (nreg != nreg_p)
{
numero_righe = 0;
if (!testata_mov_IVA(nreg))
return error_box("Rilevata riga mancante di testata: impossibile proseguire");
}
numero_righe++;
if (numero_righe > 9)
return error_box("Rilevata una registrazione IVA con piu' di 9 righe: impossibile proseguire");
nreg_p = nreg;
str.format("%06ld", _codcf);
record.overwrite(str,15); //Codice cliente/fornitore
real imponibile (rmoviva.get_real(RMI_IMPONIBILE));
str.format("%011s", (const char*) imponibile.string());
record.overwrite(str,21); //Imponibile
//Se trovo un codice iva composto da piu' di 2 cifre l'invio viene interrotto
TString codiva (rmoviva.get(RMI_CODIVA));
if (codiva.len() > 2)
return error_box("Rilevato un codice IVA composto da 3 o piu' cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig);
str.format("%02s", (const char*) codiva);
record.overwrite(str,32); //Codice iva
real imposta (rmoviva.get_real(RMI_IMPOSTA));
str.format("%09s", (const char*) imposta.string());
record.overwrite(str,34); //Imposta
int tipocr = rmoviva.get_int(RMI_TIPOCR);
str.format("%01d", tipocr);
record.overwrite(str,43); //Tipo costo/ricavo
int tipodet = rmoviva.get_int(RMI_TIPODET);
str.format("%01d", tipodet);
record.overwrite(str,44); //Tipo detraibilita'
int gruppo = rmoviva.get_int(RMI_GRUPPO);
if (gruppo > 99)
return error_box("Rilevato un gruppo composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig);
str.format("%02d", gruppo);
record.overwrite(str,45); //Gruppo
int conto = rmoviva.get_int(RMI_CONTO);
if (conto > 99)
return error_box("Rilevato un conto composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig);
str.format("%02d", conto);
record.overwrite(str,47); //Conto
long sottoc = rmoviva.get_long(RMI_SOTTOCONTO);
str.format("%06ld", sottoc);
record.overwrite(str,49); //Sottoconto
TString data74terstr = _data74ter.string();
str = riconverti(data74terstr);
record.overwrite(str,55); //Data per registri 74 TER
if (_ocfpi.not_empty())
{
str.format("%-.25s", (const char*) _ragsococc);
record.overwrite(str,61); //Ragione sociale cliente occasionale
str.format("%-.22s", (const char*) _indocc);
record.overwrite(str,86); //indirizzo cliente occasionale
str.format("%-.18s", (const char*) _localocc);
record.overwrite(str,108); //Localita cliente occasionale
str.format("%-5s", (const char*) _capocc);
record.overwrite(str,126); //Codice avviamento postale cliente occasionale
str.format("%-.2s", (const char*) _provocc);
record.overwrite(str,131); //Provincia cliente occasionale
}
int tipoatt = rmoviva.get_int(RMI_TIPOATT);
str.format("%01d", tipoatt);
record.overwrite(str,133); //Tipo attivita'
str.format("%011s", (const char*) _corrlire.string());
record.overwrite(str,135); //Corrispettivo in lire
record.overwrite(_codvali,146); //Codice valuta
str.format("%011s", (const char*) _cambioi.string());
record.overwrite(str,149); //Cambio
str.format("%014s", (const char*) _corrval.string());
record.overwrite(str,160); //Corrispettivo in valuta
_numrec++;
TString stringa;
stringa.format("%06ld", _numrec);
int posiz = _files.find("U");
_control_rec.overwrite(stringa,((posiz * 6) + 47));
_tras_file.write_control_rec(_control_rec,size);
_tras_file.close();
_tras_file.open(_trasf,TRUE);
_tras_file.write_control_rec(record,size);
_tras_file.close();
}
delete _prog;
//Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare
//e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di
//ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche'
//la chiave e' compilata con i dati del file precedente.
_tras_file.open(_trasf);
leggi_record_controllo();
TString chiave,app,sigla;
app.format("%-15s", (const char*) chiave);
char sigla_p = _tras_file.ult_file()[0];
int posiz = _files.find(sigla_p);
TString nuova_sigla = " ";
if (posiz < _files.len())
nuova_sigla = _files.mid(posiz+1,1);
_control_rec.overwrite(nuova_sigla,240);
_control_rec.overwrite(app,241);
_tras_file.write_control_rec(_control_rec,size);
_tras_file.close();
setta_tabella_ditta(m,"D",FALSE);
setta_parametri_record(m,"D");
return TRUE;
}
bool TInv_cont::menu(MENU_TAG m)
{
if (m == BAR_ITEM(1))
return main_loop();
return FALSE;
}
int cg2900 (int argc, char* argv[])
{
TInv_cont a;
a.run(argc,argv, "Invio contabilita'");
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink