root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg6400.cpp
guy 32a4b4de3d Patch level : 10.0 
Files correlati     : cg2100o.msk cg6.exe
Ricompilazione Demo : [ ]
Commento            :
Corretta importazione codice fiscale da trasfer (cliente CRPE)


git-svn-id: svn://10.65.10.50/trunk@20264 c028cbd2-c16b-5b4b-a496-9718f37d4682
2010-03-23 16:32:03 +00:00

835 lines
22 KiB
C++
Executable File
Raw Blame History

// Ricezione dati da sistema e da PC
#include <applicat.h>
#include <config.h>
#include <mask.h>
#include <prefix.h>
#include <progind.h>
#include <tabutil.h>
#include <utility.h>
#include <nditte.h>
#include "cg6400.h"
#include "cglib04.h"
#include "cgsaldac.h"
class TRic_archivi : public TSkeleton_application
{
TTransfer_file* _tras_file;
TLocalisamfile* _caus;
TLocalisamfile* _rcaus;
TLocalisamfile* _clifo;
TLocalisamfile* _pcon;
TLocalisamfile* _mov;
TLocalisamfile* _rmov;
TLocalisamfile* _rmoviva;
TLocalisamfile* _occas;
TLocalisamfile* _part;
TLocalisamfile* _scad;
TLocalisamfile* _pagsca;
TString80 TEMP;
char _scelta, _ric_auto;
int _numtotdisk,_progdisk,_numdisk,_numinv,_numinvp,_nultras;
int _stato_ripartenza,_nultras_tab;
bool _sequenza,_disketto;
bool _prima_volta,_baipassa;
TString _nomeid,_nomeidp,_ragsoc_dittar;
TFilename _marker,_trasf,_trasfer,_pathname,_trasfhard;
long _dittainv,_dittainvp,_dittaric,_totrectras,_totrectrasp;
TDate _datatras,_datatrasp,_dataultras_tab,_dataultras;
TString _sigle_file,_nrec_file;
char _agg_cau,_agg_pcon,_agg_cls,_agg_clifo,_agg_fatatt,_agg_fatpas;
bool _agg_pcc_com, _agg_cfc_com;
public:
TString _titolo;
virtual bool create();
virtual bool destroy();
virtual bool check_autorization() const
{return false;}
virtual void main_loop();
bool leggi_marker();
bool leggi_marker_rep();
void leggi_trasfer(const char* nome);
void ripristina_trasfer();
void trasfer2tempfile();
long leggi_tabella_tras();
bool componi_path(const TMask&);
bool video_ripartenza();
void ditta_ricevente();
bool ripartenza();
bool set_flag();
void aggiorna_tabella();
int controllo_ripartenza();
static bool baipassa(TMask& m,KEY k);
TRic_archivi(char ric_trasfer,char ric_auto = '\0');
};
HIDDEN TRic_archivi& app() { return (TRic_archivi &) main_app(); }
TRic_archivi::TRic_archivi(char ric_trasfer,char ric_auto) :
_scelta(toupper(ric_trasfer)), _ric_auto(toupper(ric_auto))
{
if (_scelta == 'S')
_titolo = TR("Ricezione archivi da sistema");
else
{
_scelta = 'P';
_titolo = TR("Ricezione archivi da PC");
}
}
bool TRic_archivi::create()
{
open_files(LF_TABCOM, 0);
_tras_file = new TTransfer_file(_scelta);
_caus = new TLocalisamfile (LF_CAUSALI);
_rcaus = new TLocalisamfile (LF_RCAUSALI);
_clifo = new TLocalisamfile (LF_CLIFO);
_pcon = new TLocalisamfile (LF_PCON);
_mov = new TLocalisamfile (LF_MOV);
_rmov = new TLocalisamfile (LF_RMOV);
_rmoviva = new TLocalisamfile (LF_RMOVIVA);
_occas = new TLocalisamfile (LF_OCCAS);
_part = new TLocalisamfile (LF_PARTITE);
_scad = new TLocalisamfile (LF_SCADENZE);
_pagsca = new TLocalisamfile (LF_PAGSCA);
_numdisk = 1;
_prima_volta = true;
_nultras = 0;
_nultras_tab = 0;
_baipassa = false;
return TSkeleton_application::create();
}
bool TRic_archivi::destroy()
{
delete _tras_file;
delete _caus;
delete _rcaus;
delete _clifo;
delete _pcon;
delete _mov;
delete _rmov;
delete _rmoviva;
delete _occas;
delete _part;
delete _scad;
delete _pagsca;
return TApplication::destroy();
}
bool TRic_archivi::componi_path(const TMask& msk)
{
TFilename path = msk.get(F_PATHNAME);
const TString& drive = msk.get(F_DRIVE);
_disketto = xvt_fsys_is_floppy_drive(drive) != 0;
const int pos = path.find(':');
if (pos)
path = path.mid(pos+1);
if (path.full())
{
_marker << drive << SLASH << path << SLASH << "marker";
_trasfer << drive << SLASH << path << SLASH << "trasfer";
if (!_disketto)
_pathname << drive << SLASH << path;
}
else
{
_marker << drive << SLASH << "marker";
_trasfer << drive << SLASH << "trasfer";
if (!_disketto)
_pathname << drive << SLASH;
}
return _disketto;
}
bool TRic_archivi::leggi_marker()
{
if (!_marker.exist())
{
if (_disketto)
return error_box(FR("File marker non presente sul dischetto %d: impossibile proseguire"), _numdisk);
else
return error_box(FR("File marker non presente in %s: impossibile proseguire"), (const char*)_pathname);
}
const int size = 64;
TString80 buffer;
FILE* i = fopen(_marker,"r+t"); // Perche' non semplicemente "rb"?
if (i != NULL)
{
const size_t letti = fread(buffer.get_buffer(),1,size,i);
fclose(i);
if (letti < size)
return error_box(TR("Errore di lettura del MARKER: impossibile proseguire"));
_progdisk = atoi(buffer.sub(31,33));
_numtotdisk = atoi(buffer.sub(29,31));
if (_numtotdisk == 0)
{
message_box(TR("Il numero totale dischi su marker non e' significativo: impossibile proseguire"));
return false;
}
if (_progdisk != _numdisk)
{
message_box(FR("Il dischetto inserito (%d) non rispecchia la giusta sequenza (%d)"), _numdisk, _progdisk);
_sequenza = false;
return true;
}
else
_sequenza = true;
_nomeid = buffer.sub(0,10);
_dittainv = atol(buffer.sub(10,14));
_numinv = atoi(buffer.sub(14,17));
const TString8 tmp = buffer.sub(17,23);
_datatras = converti_data(tmp, false);
_totrectras = atol(buffer.sub(23,29));
if (_numdisk > 1) //Va fatto solo dal disco 2 in poi
if (_nomeid != _nomeidp || _dittainv != _dittainvp || _totrectras != _totrectrasp
|| _numinv != _numinvp || _datatras != _datatrasp)
return error_box(FR("I dati del marker del disco %d, non corrispondono ai dati del marker del disco 1"), _numdisk);
_nomeidp = _nomeid;
_dittainvp = _dittainv;
_totrectrasp = _totrectras;
_numinvp = _numinv;
_datatrasp = _datatras;
if (_numdisk == 1) // Va fatto solo per il primo disco
{
_dittaric = leggi_tabella_tras();
if (_dittaric != 0)
{
if (!prefix().exist(_dittaric))
return error_box(FR("Libreria archivi ditta %ld non presente su disco"), _dittaric);
}
else
return error_box(FR("Codici NON PRESENTI in tabella ricezione:\ncaricare %s %ld e riprovare"),
(const char*)_nomeid, _dittainv);
}
return true;
}
return false;
}
bool TRic_archivi::leggi_marker_rep()
{
if (!_marker.exist())
{
if (_disketto)
return error_box(FR("File marker non presente sul dischetto %d: impossibile proseguire"), _numdisk);
else
return error_box(FR("File marker non presente in %s: impossibile proseguire"), (const char*)_pathname);
}
const word size = 64;
TString buffer(size);
FILE* inmark = fopen(_marker,"r");
if (inmark != NULL)
{
const word letti = fread(buffer.get_buffer(),1,size,inmark);
fclose(inmark);
_progdisk = atoi(buffer.sub(34,36));
_numtotdisk = atoi(buffer.sub(32,34));
if (_progdisk != _numdisk)
{
message_box(FR("Il dischetto inserito (%d) non rispecchia la giusta sequenza (%d)"), _numdisk, _progdisk);
_sequenza = false;
return true;
}
else
_sequenza = true;
if (letti == 0)
return error_box(TR("Impossibile leggere il file MARKER: %s"), (const char*)_marker);
_nomeid = buffer.sub(0,10);
_dittainv = atol(buffer.sub(10,15));
_totrectras = atol(buffer.sub(26,32));
_numinv = atoi(buffer.sub(15,18));
TString16 tmp = buffer.sub(18,26);
_datatras = converti_data(tmp,true);
if (_numdisk > 1) //Va fatto solo dal disco 2 in poi
if (_nomeid != _nomeidp || _dittainv != _dittainvp || _totrectras != _totrectrasp
|| _numinv != _numinvp || _datatras != _datatrasp)
return error_box(FR("I dati del marker del disco %d, non corrispondono ai dati del marker del disco 1"), _numdisk);
_nomeidp = _nomeid;
_dittainvp = _dittainv;
_totrectrasp = _totrectras;
_numinvp = _numinv;
_datatrasp = _datatras;
if (_numdisk == 1) // Va fatto solo per il primo disco
{
_dittaric = leggi_tabella_tras();
if (_dittaric != 0)
{
if (!prefix().exist(_dittaric))
return error_box(FR("Gli archivi della ditta %ld non sono presenti su disco"), _dittaric);
}
else
return error_box(FR("Codici NON PRESENTI in tabella ricezione:\nStudio %s Ditta inviante %ld"),
(const char*)_nomeid, _dittainv);
}
return true;
}
return error_box(FR("Impossibile accedere al file %s"), (const char*)_marker);
}
void TRic_archivi::main_loop()
{
if (_ric_auto == 'A')
{
_dittaric = get_firm();
_trasf = _tras_file->path(_dittaric);
_trasf.add("trasfer");
_tras_file->open(_trasf);
if (_scelta == 'S')
{
trasfer2tempfile();
_tras_file->close(); // Chiude il trasfer letto dalla directory della ditta
::remove(_trasf);
TFilename tab = _tras_file->path(_dittaric);
TFilename tabcdx = tab;
TFilename tabdbf = tab;
tabcdx.add("ttab.cdx");
tabdbf.add("ttab.dbf");
::remove(tabcdx);
::remove(tabdbf);
}
else
if (_scelta == 'P')
{
trasfer2tempfile();
_tras_file->close(); // Chiude il trasfer letto dalla directory della ditta
::remove(_trasf);
}
}
else
{
if (_scelta == 'S')
{
TMask maskera("cg6400b");
KEY tasto = maskera.run();
if (tasto == K_ENTER)
{
componi_path(maskera);
do
{
if (_disketto)
{
char drive = maskera.get(F_DRIVE)[0];
if (yesno_box(FR("Inserire il dischetto %d nell' unita' %c"), _numdisk,drive))
{
if (!leggi_marker())
return;
if (_sequenza)
{
if (video_ripartenza())
ripristina_trasfer();
else
return;
_numdisk++;
}
}
else
return;
}
else
{
if (!leggi_marker())
return;
if (_sequenza)
{
if (video_ripartenza())
ripristina_trasfer();
else
return;
_numdisk++;
}
else
return;
}
}
while (_numdisk <= _numtotdisk);
trasfer2tempfile();
set_flag();
aggiorna_tabella();
_tras_file->close(); // Chiude il trasfer letto dalla directory della ditta
::remove(_trasf);
TFilename tab = _tras_file->path(_dittaric);
TFilename tabcdx = tab; tabcdx.add("ttab.cdx");
TFilename tabdbf = tab; tabdbf.add("ttab.dbf");
tabcdx.fremove();
tabdbf.fremove();
}
}
else
if (_scelta == 'P')
{
TMask maskera("cg6400b");
KEY tasto = maskera.run();
if (tasto == K_ENTER)
{
componi_path(maskera);
do
{
if (_disketto)
{
char drive = maskera.get(F_DRIVE)[0];
if (yesno_box(FR("Inserire il dischetto %d nell' unita' %c"), _numdisk,drive))
{
if (!leggi_marker_rep())
return;
if (_sequenza)
{
if (video_ripartenza())
ripristina_trasfer();
else
return;
_numdisk++;
}
}
else
return;
}
else
{
if (!leggi_marker_rep())
return;
if (_sequenza)
{
if (video_ripartenza())
ripristina_trasfer();
else
return;
_numdisk++;
}
else
return;
}
}
while (_numdisk <= _numtotdisk);
trasfer2tempfile();
set_flag();
aggiorna_tabella();
_tras_file->close(); // Chiude il trasfer letto dalla directory della ditta
::remove(_trasf);
}
}
}
}
void TRic_archivi::leggi_trasfer(const char* nome)
{
_nultras = 0;
_trasf = _tras_file->path(_dittaric);
_trasf.add(nome);
_tras_file->open(_trasf);
if (_tras_file->exist())
{
if (_scelta == 'S')
{
if (_tras_file->read_control_rec_t())
{
_nultras = _tras_file->nultras();
_dataultras = _tras_file->dataultras();
}
}
else
if (_scelta == 'P')
{
if (_tras_file->read_control_rec())
{
_nultras = _tras_file->nultras();
_dataultras = _tras_file->dataultras();
}
}
}
}
// 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 TRic_archivi::controllo_ripartenza()
{
set_firm(_dittaric);
TFilename trasfer = _tras_file->path(_dittaric);
trasfer << HEADER;
_tras_file->open(trasfer);
const TString4 std = ini_get_string(CONFIG_DITTA, "cg", "FlStTra");
const bool flag = _tras_file->read_control_rec();
int var = 0;
if (std.empty() && flag)
var = 1;
if (std == "*" && flag)
{
const TString16 ult_file = _tras_file->ult_file();
const TString16 key = _tras_file->key();
if (ult_file.full() || key.full())
var = 1;
}
if (std != "" && std != "*")
var = 2;
_tras_file->close();
return var;
}
bool TRic_archivi::ripartenza()
{
if (_stato_ripartenza == 1)
return error_box(TR("Rilevato stato di RIPARTENZA CON DATI CONTRADDITORI:\n"
"presente file HEADER nei dati ditta e FlgStTra=* o nullo"));
if (_stato_ripartenza == 2)
return error_box(TR("Trasferimento precedente NON COMPLETATO: completarlo prima di questo"));
return true;
}
bool TRic_archivi::video_ripartenza()
{
TDate dataultras;
if (_prima_volta)
{
leggi_trasfer("\\trasfer");
_prima_volta = false;
TMask maskera("cg6400a");
TMask* msk = &maskera;
KEY tasto;
ditta_ricevente();
_stato_ripartenza = controllo_ripartenza();
msk->set(F_NOMEID, _nomeid);
msk->set(F_CODDITTAINV, _dittainv);
msk->set(F_CODDITTARIC, _dittaric);
msk->set(F_RAGSOC, _ragsoc_dittar);
msk->set(F_NULTRASDSK, _numinv);
TString16 data1 = _datatras.string();
msk->set(F_DATAULTRASDSK, data1);
if (_nultras != 0)
{
msk->set(F_NULTRASTAB, _nultras);
TString16 data2 = _dataultras.string();
msk->set(F_DATAULTRASTAB, data2);
}
else
{
msk->set(F_NULTRASTAB, _nultras_tab);
TString16 data2 = _dataultras_tab.string();
msk->set(F_DATAULTRASTAB, data2);
}
if (_stato_ripartenza == 0)
msk->set(F_STATO, "COMPLETO");
else
msk->set(F_STATO, "NON COMPLETO");
if (_numdisk == 1) // Va fatto solo per il primo disco
{
do
{
msk->set_handler(baipassa);
tasto = msk->run();
if (tasto != K_ENTER)
return false;
if (_baipassa)
return true;
if (!ripartenza())
return false;
if (_numinv > (_nultras_tab + 1))
warning_box(FR("Trasferimento FUORI SEQUENZA: manca un trasferimento intermedio.\n"
"Numero invio n. %d, ultimo trasferimento n. %d."), _numinv, _nultras_tab);
else
if (_numinv < (_nultras_tab +1))
warning_box(FR("I dischetti risultano GIA' TRASFERITI.\n"
"Numero invio n. %d, ultimo trasferimento n. %d."), _numinv, _nultras_tab);
else
return true;
}
while (tasto == K_ENTER);
}
}
return true;
}
bool TRic_archivi::baipassa(TMask& m,KEY k)
{
if ( (k == K_SHIFT+K_F7) && (app()._stato_ripartenza == 0) )
app()._baipassa = true;
return true;
}
void TRic_archivi::ripristina_trasfer()
{
TProgind prg (1,TR("Trasferimento archivi"),false, false);
if (_numdisk == 1)
fcopy(_trasfer,_trasf,false);
else
fcopy(_trasfer,_trasf,true);
}
void TRic_archivi::trasfer2tempfile()
{
_trasfhard = _tras_file->path(_dittaric);
_trasfhard.add(HEADER);
switch (_scelta)
{
case 'S': _tras_file->fcopytemp(_trasf,_trasfhard); break;
case 'P': _tras_file->fcopytemp_PC(_trasf,_trasfhard); break;
default: break;
}
}
void TRic_archivi::ditta_ricevente()
{
_ragsoc_dittar = cache().get(LF_NDITTE, _dittaric).get(NDT_RAGSOC);
}
long TRic_archivi::leggi_tabella_tras()
{
long ditta = 0;
TTable tab_tra("%TRA");
TString16 dep; dep.format("%10s%05ld", (const char*)_nomeid, _dittainv);
tab_tra.put("CODTAB", dep);
if (tab_tra.read() == NOERR)
{
ditta = tab_tra.get_long("I0");
_nultras_tab = tab_tra.get_int ("I1");
_dataultras_tab = tab_tra.get_date("D0");
_agg_cau = tab_tra.get_char("S0");
_agg_clifo = tab_tra.get_char("S1");
_agg_pcon = tab_tra.get_char("S2");
_agg_cls = tab_tra.get_char("S3");
const bool agg_fatatt = tab_tra.get_bool("B0");
_agg_fatatt = agg_fatatt ? 'X' : ' ';
const bool agg_fatpas = tab_tra.get_bool("B1");
_agg_fatpas = agg_fatpas ? 'X' : ' ';
_agg_pcc_com = tab_tra.get_bool("B2"); // Aggiorna comunque piano dei conti in comune
_agg_cfc_com = tab_tra.get_bool("B3"); // Aggiorna comunque clienti/fornitori in comune
}
return ditta;
}
bool TRic_archivi::set_flag()
{
int k = 0;
TString4 flag;
TString record;
TString4 uselab;
bool fatto = true;
TConfig conf(CONFIG_DITTA, "cg");
const bool ana_com = conf.get_bool("AnCfCm") && !_agg_cfc_com;
const bool pcon_cau = conf.get_bool("PcTcCm") && !_agg_pcc_com;
_tras_file->open(_trasfhard);
if (_tras_file->exist())
{
if (_tras_file->read_control_rec())
{
_nultras = _tras_file->nultras();
_dataultras = _tras_file->dataultras();
_sigle_file = _tras_file->sigle_file();
_nrec_file = _tras_file->nrec_file();
record = _tras_file->record();
}
for (int j = 0; j < _sigle_file.len(); j++)
{
const char sigla = _sigle_file[j];
const long nrec = atol(_nrec_file.mid(k,6));
if (fatto)
{
if (sigla == 'W' || sigla == 'P')
{
if (nrec > 0 && !pcon_cau)
{
flag = "T";
fatto = false;
}
}
else
if (sigla == 'A')
{
if (nrec > 0 && !ana_com)
{
flag = "T";
fatto = false;
}
}
else
if (sigla == 'Z' || sigla == 'U' || sigla == 'B')
{
if (nrec > 0)
{
flag = "C";
fatto = false;
}
}
else
{
flag = "*";
fatto = false;
}
if (flag == "T")
uselab = sigla;
else
uselab = "";
}
if (sigla == 'W' || sigla == 'P')
{
if (pcon_cau)
{
_sigle_file.overwrite(" ",j);
_nrec_file.overwrite("000000",k);
}
}
if (sigla == 'A')
{
if (ana_com)
{
_sigle_file.overwrite(" ",j);
_nrec_file.overwrite("000000",k);
}
}
k += 6;
}
record.overwrite(_sigle_file, 86);
record.overwrite(_nrec_file, 95);
char agg[8];
agg[0] = _agg_cls;
agg[1] = _agg_cau;
agg[2] = _agg_clifo;
agg[3] = _agg_pcon;
agg[4] = _agg_fatatt;
agg[5] = _agg_fatpas;
agg[6] = '\0';
record.overwrite(agg,234);
record.overwrite(uselab,240);
TString80 str; str.spaces(60);
record.overwrite(str,241);
const int size = 1024;
if (!_tras_file->write_control_rec(record, size))
return false;
}
conf.set("FlStTra", flag);
return true;
}
void TRic_archivi::aggiorna_tabella()
{
TTable tab_tra("%TRA");
TString16 dep;
dep.format("%10s%05ld", (const char*)_nomeid, _dittainv);
tab_tra.put("CODTAB", dep);
if (tab_tra.read() == NOERR)
{
tab_tra.put("I1", _nultras);
tab_tra.put("D0", _dataultras);
tab_tra.rewrite();
}
}
int cg6400 (int argc, char* argv[])
{
char p3 = '\0';
if (argc > 4)
p3 = *argv[3];
TRic_archivi* main_app = new TRic_archivi(*argv[2],p3);
main_app->run(argc, argv,main_app->_titolo);
delete main_app;
return 0;
}
Reference in New Issue View Git Blame Copy Permalink