root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg6400.cpp
alex 93e1a7e428 Patch level : 10.0 67 
Files correlati     :
Ricompilazione Demo : [ ]
Commento           :

RIportata la verione 3.2 1167


git-svn-id: svn://10.65.10.50/trunk@16723 c028cbd2-c16b-5b4b-a496-9718f37d4682
2008-06-11 11:19:53 +00:00

846 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;
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();
void componi_path(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();
}
void TRic_archivi::componi_path(TMask* msk)
{
TFilename path = msk->get(F_PATHNAME);
const TString8 drive = msk->get(F_DRIVE);
// Inizio cazzata - da sostituire con _disketto = ::os_is_removable_drive(drive)
if (drive == "A:" || drive == "B:")
_disketto = TRUE;
else
_disketto = false;
// Fine cazzata
const int pos = path.find(':');
if (pos)
path = path.mid(pos+1);
if (path.not_empty())
{
_marker << drive << "\\" << path << "\\marker";
_trasfer << drive << "\\" << path << "\\trasfer";
if (!_disketto)
_pathname << drive << "\\" << path;
}
else
{
_marker << drive << "\\marker";
_trasfer << drive << "\\trasfer";
if (!_disketto)
_pathname << drive << "\\";
}
}
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(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(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");
TMask* msk = &maskera;
KEY tasto = msk->run();
if (tasto == K_ENTER)
{
componi_path(msk);
do
{
if (_disketto)
{
char drive = msk->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;
TFilename tabdbf = tab;
tabcdx.add("ttab.cdx");
tabdbf.add("ttab.dbf");
::remove(tabcdx);
::remove(tabdbf);
}
}
else
if (_scelta == 'P')
{
TMask maskera("cg6400b");
TMask* msk = &maskera;
KEY tasto = msk->run();
if (tasto == K_ENTER)
{
componi_path(msk);
do
{
if (_disketto)
{
char drive = msk->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()
{
TString std;
bool flag = false;
int var = 0;
set_firm(_dittaric);
TString trasfer;
trasfer = _tras_file->path(_dittaric);
trasfer << HEADER;
_tras_file->open(trasfer);
TConfig conf(CONFIG_DITTA);
std = conf.get("FlStTra");
if (_tras_file->read_control_rec())
flag = TRUE;
if (std == "" && flag)
var = 1;
if (std == "*" && flag)
{
TString ult_file = _tras_file->ult_file();
TString key = _tras_file->key();
if (ult_file != "" || key != "")
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: procedura interrotta"));
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' : ' ';
}
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 TString4 ana_com = conf.get("AnCfCm");
const TString4 pcon_cau = conf.get("PcTcCm");
_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 == "X")
{
_sigle_file.overwrite(" ",j);
_nrec_file.overwrite("000000",k);
}
}
if (sigla == 'A')
{
if (ana_com == "X")
{
_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", (long)_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