1499 lines
37 KiB
C++
Executable File
1499 lines
37 KiB
C++
Executable File
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
#include <fcntl.h>
|
|
#include <share.h>
|
|
|
|
// Serve per GetFreeSpace
|
|
#define XVT_INCL_NATIVE
|
|
#define STRICT
|
|
|
|
#include <applicat.h>
|
|
#include <isam.h>
|
|
#include <mask.h>
|
|
#include <prefix.h>
|
|
#include <printer.h>
|
|
#include <progind.h>
|
|
#include <urldefid.h>
|
|
#include <utility.h>
|
|
#include <validate.h>
|
|
#include <extcdecl.h>
|
|
#include <execp.h>
|
|
|
|
#include "ba1.h"
|
|
#include "ba1100.h"
|
|
|
|
#if XVT_OS==XVT_OS_SCOUNIX
|
|
#define DIRSIZ 14
|
|
struct direct
|
|
{
|
|
unsigned short d_ino;
|
|
char d_name[DIRSIZ];
|
|
};
|
|
#else
|
|
#include <errno.h>
|
|
#include <dos.h>
|
|
#endif
|
|
|
|
#define History_file "conv.his"
|
|
#define Dir_file "dir.gen"
|
|
#define Trc_file "trc.gen"
|
|
|
|
class TManutenzione_app : public TApplication
|
|
{
|
|
TDir_sheet* _browse;
|
|
TArray _dirs;
|
|
TArray _recs;
|
|
TMask* _mask;
|
|
long _firm;
|
|
long _level;
|
|
long _history_firm;
|
|
TRec_sheet* _rec;
|
|
|
|
protected:
|
|
virtual bool menu (MENU_TAG);
|
|
virtual bool create () ;
|
|
virtual bool destroy();
|
|
void insert_riga(long, TToken_string&);
|
|
void edit_riga(long, TToken_string&);
|
|
void edit_riga(const TString&);
|
|
void delete_riga();
|
|
virtual bool extended_firm() const { return TRUE; }
|
|
void update();
|
|
void update_dir();
|
|
void convert_dir();
|
|
virtual void print();
|
|
virtual void do_print(TPrinter & p, TRec_sheet & r);
|
|
const char* dumpfilename(const FileDes& dep) const;
|
|
void load_des();
|
|
void open_history();
|
|
void put_history(const char* firm);
|
|
void close_history();
|
|
void dump_trc(const char * dir, const bool des_too, const long modules);
|
|
|
|
public:
|
|
|
|
TManutenzione_app();
|
|
};
|
|
|
|
HIDDEN bool browse_file_handler(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_F9)
|
|
{
|
|
FILE_SPEC fs; memset(&fs, 0, sizeof(FILE_SPEC));
|
|
strcpy(fs.type, "DBF");
|
|
strcpy(fs.name, f.get());
|
|
strcpy(fs.creator, "ba1");
|
|
xvt_fsys_get_default_dir(&fs.dir);
|
|
xvt_fsys_save_dir();
|
|
if (xvt_dm_post_file_open(&fs, "Selezione file") == FL_OK)
|
|
{
|
|
TFilename n;
|
|
xvt_fsys_convert_dir_to_str(&fs.dir, n.get_buffer(n.size()), n.size());
|
|
n.add(fs.name);
|
|
f.set(n);
|
|
xvt_fsys_restore_dir();
|
|
}
|
|
f.set_focus();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
HIDDEN void build_filelist(const char *path, TArray & list)
|
|
{
|
|
#if XVT_OS==XVT_OS_SCOUNIX
|
|
struct directx
|
|
{
|
|
ino_t d_ino;
|
|
char d_name[DIRSIZ + 1];
|
|
} dlink;
|
|
int fd;
|
|
|
|
if ((fd = open(path, 0)) == -1)
|
|
return;
|
|
dlink.d_name[DIRSIZ] = '\0';
|
|
while(read(fd, &dlink, sizeof(struct direct)) ==
|
|
sizeof(struct direct))
|
|
{
|
|
if (dlink.d_ino > 0)
|
|
{
|
|
TFixed_string dname(dlink.d_name);
|
|
|
|
if (dname.find(".des") > 0 && dname[0] == 'd' && !isdigit(dname[1]))
|
|
list.add(dname.mid(1,3));
|
|
}
|
|
}
|
|
close(fd);
|
|
#else
|
|
_find_t f;
|
|
|
|
if (_dos_findfirst("recdesc/d???.des", _A_NORMAL, &f) == 0)
|
|
{
|
|
bool one_to_add = TRUE;
|
|
while (one_to_add)
|
|
{
|
|
TString80 dname(f.name);
|
|
|
|
if (!isdigit(dname[1]))
|
|
list.add(dname.mid(1,3));
|
|
one_to_add = _dos_findnext(&f) == 0;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
TManutenzione_app::TManutenzione_app() : _browse(NULL), _rec(NULL), _mask(NULL), _firm(0), _level(0)
|
|
{
|
|
if (!fexist(Dir_file)) // controlla l'esistenza dei direttori standard (dir.gen e trc.gen)
|
|
{ // vengono creati se non esistono
|
|
TDir d;
|
|
FileDes* fd = d.filedesc();
|
|
int handle;
|
|
|
|
strcpy(fd->SysName,"$dir.gen");
|
|
fd->LenR =160;
|
|
fd->EOD = fd->EOX = 1L;
|
|
fd->Flags = 0;
|
|
strcpy(fd->Des ,"Directory");
|
|
strcpy(fd->FCalc,"0");
|
|
strcpy(fd->GenPrompt,"");
|
|
#if XVT_OS == XVT_OS_WIN
|
|
if ((handle = sopen(Dir_file, O_RDWR|O_BINARY|O_CREAT,SH_DENYNO,S_IREAD|S_IWRITE)) != -1)
|
|
#else
|
|
if ((handle = open(Dir_file, O_RDWR|O_BINARY|O_CREAT,0666)) != -1)
|
|
#endif
|
|
{
|
|
if (write( handle, (char*)fd, sizeof(FileDes)) == -1)
|
|
fatal_box("Impossibile scrivere il file dir.gen per dati standard: errore %d",errno);
|
|
close(handle);
|
|
}
|
|
else fatal_box("Impossibile creare il file dir.gen per dati standard: errore %d",errno);
|
|
}
|
|
if (!fexist(Trc_file))
|
|
{
|
|
TTrec r;
|
|
RecDes* rd = r.rec();
|
|
int handle;
|
|
#if XVT_OS == XVT_OS_WIN
|
|
if ((handle = sopen(Trc_file, O_RDWR|O_BINARY|O_CREAT,SH_DENYNO,S_IREAD|S_IWRITE)) != -1)
|
|
#else
|
|
if ((handle = open(Trc_file, O_RDWR|O_BINARY|O_CREAT,0666)) != -1)
|
|
#endif
|
|
{
|
|
if (write( handle, (char*)rd, sizeof(RecDes)) == -1)
|
|
fatal_box("Impossibile scrivere il file trc.gen per dati standard: errore %d",errno);
|
|
close(handle);
|
|
}
|
|
else fatal_box("Impossibile creare il file trc.gen per dati standard: errore %d",errno);
|
|
}
|
|
}
|
|
|
|
void TManutenzione_app::do_print(TPrinter & p, TRec_sheet & r)
|
|
|
|
{
|
|
const char* table[] = {"", "Alfanumerico", "Intero", "Intero Lungo",
|
|
"Reale", "Data", "Intero", "Carattere",
|
|
"Booleano", "Intero Zerofilled",
|
|
"Intero Lungo Zerofilled","Memo"};
|
|
TPrintrow row;
|
|
TToken_string s;
|
|
TParagraph_string d("", 25);
|
|
TConfig * descr = NULL;
|
|
TTrec & rec = *r.rec();
|
|
TDir & dir = *r.dir();
|
|
const char * descfname = r.descfname();
|
|
TString16 tab(r.tab());
|
|
const bool istab = tab.not_empty();
|
|
|
|
tab.upper();
|
|
if (fexist(descfname))
|
|
descr = new TConfig(descfname, DESCPAR);
|
|
|
|
const bool hasdescr = descr != NULL;
|
|
|
|
row.reset();
|
|
if (istab)
|
|
row.put(format("Lista tabella %s ", (const char *) tab), 2);
|
|
else
|
|
row.put(format("Lista tracciato %s (%s)", dir.des(), dir.name()), 2);
|
|
row.put("Pag. @#", 69);
|
|
p.setheaderline(2, row);
|
|
row.reset();
|
|
row.put("Nome", 7);
|
|
row.put("Tipo", 18);
|
|
row.put("Lun.", 38);
|
|
row.put("Dec.", 44);
|
|
row.put("Pos.", 48);
|
|
row.put("Descrizione", 53);
|
|
p.setheaderline(4, row);
|
|
|
|
TString riga(78); riga.fill('-');
|
|
row.put(riga, 1);
|
|
p.setheaderline(5, row);
|
|
|
|
for (int i = 0; i < rec.fields(); i ++)
|
|
{
|
|
row.reset();
|
|
s = rec.fielddef(i);
|
|
TString16 name = s.get();
|
|
row.put(format("%3d", i + 1), 2);
|
|
row.put(name, 7);
|
|
row.put(table[s.get_int()], 18);
|
|
row.put(format("%4d", s.get_int()), 38);
|
|
row.put(format("%4d", s.get_int()), 43);
|
|
row.put(format("%4d", rec.rec()->Fd[i].RecOff), 48);
|
|
const char *wd = NULL;
|
|
|
|
d = "";
|
|
if (hasdescr)
|
|
d = descr->get(name);
|
|
if (!istab || d.not_empty())
|
|
{
|
|
if (hasdescr)
|
|
{
|
|
wd = d.get();
|
|
if (wd != NULL)
|
|
row.put(wd, 53);
|
|
}
|
|
p.print(row);
|
|
wd = d.get();
|
|
while(wd != NULL)
|
|
{
|
|
row.reset();
|
|
row.put(wd, 53);
|
|
p.print(row);
|
|
wd = d.get();
|
|
}
|
|
}
|
|
}
|
|
|
|
row.reset();
|
|
p.print(row);
|
|
|
|
row.put("Espressione chiave", 7);
|
|
row.put("Duplicabile", 68);
|
|
p.setheaderline(4, row);
|
|
|
|
if (p.rows_left() < 5)
|
|
p.formfeed();
|
|
else
|
|
{
|
|
p.print(row);
|
|
row.put(riga, 1);
|
|
p.print(row);
|
|
}
|
|
|
|
for (i = 0; i < rec.keys(); i ++)
|
|
{
|
|
row.reset();
|
|
s = rec.keydef(i);
|
|
row.put(format("%3d", i + 1), 2);
|
|
row.put(s.get(), 7);
|
|
row.put(*s.get() == 'X' ? "Si" : "No", 68);
|
|
p.print(row);
|
|
}
|
|
p.formfeed();
|
|
if (hasdescr)
|
|
delete descr;
|
|
}
|
|
|
|
void TManutenzione_app::print()
|
|
|
|
{
|
|
TPrinter& p = printer();
|
|
|
|
p.open();
|
|
p.headerlen(6);
|
|
p.footerlen(4);
|
|
if (_rec == NULL)
|
|
{
|
|
TDir d;
|
|
|
|
d.get(LF_DIR);
|
|
int items = (int)d.eod();
|
|
TProgind *pi;
|
|
pi = new TProgind(items,"Stampa tracciati record archivi", TRUE, TRUE, 63);
|
|
|
|
pi->setstatus(2);
|
|
|
|
for (int i = 2 ; !pi->iscancelled() && i <= items; i++)
|
|
{
|
|
d.get(i);
|
|
if (d.len() > 0)
|
|
{
|
|
TRec_sheet r(i, "");
|
|
pi->addstatus(1);
|
|
do_print(p, r);
|
|
}
|
|
}
|
|
|
|
delete pi;
|
|
TArray list;
|
|
|
|
build_filelist(DESCDIR, list);
|
|
items = list.items();
|
|
|
|
pi = new TProgind(items,"Stampa descrizione tabelle", TRUE, TRUE, 63);
|
|
|
|
for (i = 0; !pi->iscancelled() && i < items; i++)
|
|
{
|
|
TString & tab = (TString &) list[i];
|
|
TRec_sheet r(4, tab);
|
|
|
|
pi->addstatus(1);
|
|
do_print(p, r);
|
|
}
|
|
delete pi;
|
|
}
|
|
else do_print(p, *_rec);
|
|
p.close();
|
|
}
|
|
|
|
bool TManutenzione_app::create() // initvar e arrmask
|
|
|
|
{
|
|
TApplication::create();
|
|
|
|
_firm = get_firm();
|
|
TString sw(argc()>2 ? argv(2) : "");
|
|
|
|
if (argc() > 2 && sw == "-C")
|
|
{
|
|
update();
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (sw == "-D")
|
|
{
|
|
const int c = argc();
|
|
bool des_too = 1; // Anche le descrizioni
|
|
long modules = -1; // Tutti i moduli
|
|
if (c < 4)
|
|
{
|
|
error_box("Usage: BA1 -0 -D <directory> [0|1] [<module number>]");
|
|
return FALSE;
|
|
}
|
|
TFilename dir(argv(3));
|
|
if (!fexist(dir))
|
|
{
|
|
error_box("Non esiste il direttorio %s", (const char*)dir);
|
|
return FALSE;
|
|
}
|
|
if (c == 5)
|
|
des_too = (bool)atoi(argv(4));
|
|
if (c == 6)
|
|
modules = atol(argv(5));
|
|
prefix().set("");
|
|
load_des();
|
|
dump_trc(dir,des_too,modules);
|
|
return FALSE;
|
|
}
|
|
else
|
|
if (!set_firm())
|
|
return FALSE;
|
|
load_des();
|
|
|
|
|
|
const bool superprassi = user() == "PRASSI";
|
|
_mask = new TMask ("ba1100a");
|
|
_browse = new TDir_sheet ("Manutenzione file di sistema", superprassi ? 0xC : 0x8);
|
|
|
|
if (superprassi)
|
|
{
|
|
_browse->add_button(DLG_INSFILE, "~Inserisci", K_F6);
|
|
_browse->add_button(DLG_CONVERT, "~Converti", K_F7);
|
|
_browse->add_button(DLG_ADDFILE, "~Aggiungi", K_F8);
|
|
TButton_field& butt = ((TMask*)_browse)->add_button(DLG_OTHERFILE, 0, "A~ltri", 0, -1, 9, 2, "", 0, 0);
|
|
butt.set_hot_key(K_F5);
|
|
_mask->enable(-1); // Abilita campi privilegiati
|
|
}
|
|
|
|
dispatch_e_menu(BAR_ITEM(1));
|
|
}
|
|
enable_menu_item(M_FILE_PRINT);
|
|
return TRUE ;
|
|
}
|
|
|
|
bool TManutenzione_app::destroy() // releasev e arrmask
|
|
|
|
{
|
|
if (_firm) set_firm(_firm);
|
|
if (_browse != NULL) delete _browse;
|
|
if (_mask != NULL) delete _mask;
|
|
return TApplication::destroy() ;
|
|
}
|
|
|
|
|
|
void TManutenzione_app::insert_riga (long riga_sel, TToken_string& riga)
|
|
{
|
|
const int logicnum = int(riga_sel) + 1;
|
|
const int num_files = (int)_browse->items();
|
|
|
|
_mask->disable(DLG_PACK);
|
|
_mask->disable(DLG_RECORD);
|
|
_mask->disable(DLG_LOAD);
|
|
_mask->disable(DLG_DUMP);
|
|
_mask->show(F_TAB, logicnum >= LF_TABGEN && logicnum <= LF_TAB);
|
|
_mask->hide(FLD_EXTEND);
|
|
_mask->hide(FLD_EOX);
|
|
_mask->set (FLD_NUM, riga.get(0));
|
|
_mask->reset (F_TAB);
|
|
|
|
if (_mask->run() == K_ENTER)
|
|
{
|
|
/* shift di uno in avanti degli elementi del direttorio partendo dall'ultimo */
|
|
for (int i=num_files; i>=logicnum; i--)
|
|
{
|
|
_browse->dir()->get (i, _nolock, _nordir, _sysdirop);
|
|
_browse->dir()->put (i + 1, _nordir, _sysdirop);
|
|
_browse->rec()->get (i);
|
|
_browse->rec()->put (i + 1);
|
|
}
|
|
_browse->dir()->set(_mask->get(FLD_NOME), _mask->get_long(FLD_EOD),
|
|
_mask->get_long(FLD_FLAG), _mask->get (FLD_DESC),
|
|
_mask->get (FLD_FORMULA));
|
|
_browse->dir()->put(logicnum, _nordir, _sysdirop);
|
|
_browse->rec()->zero();
|
|
_browse->rec()->put(logicnum);
|
|
_browse->dir()->get(LF_DIR);
|
|
_browse->dir()->eod()++;
|
|
_browse->set_items(_browse->dir()->eod());
|
|
_browse->dir()->put(LF_DIR);
|
|
}
|
|
}
|
|
|
|
void TManutenzione_app::open_history()
|
|
{
|
|
FILE *fp = fopen(History_file,"r");
|
|
if (fp != NULL)
|
|
{
|
|
char line[16];
|
|
fgets(line,16,fp);
|
|
int l = strlen(line);
|
|
|
|
line[l > 0 ? l -1 : 0 ] = '\0';
|
|
if (l==0) _history_firm = -1;
|
|
else
|
|
_history_firm = atol(line);
|
|
}
|
|
else
|
|
{
|
|
fp = fopen(History_file,"w");
|
|
_history_firm = -1;
|
|
}
|
|
fclose (fp);
|
|
}
|
|
|
|
void TManutenzione_app::put_history(const char* firm)
|
|
{
|
|
FILE * fp = fopen(History_file,"w");
|
|
fprintf(fp,"%s\n",firm);
|
|
fclose (fp);
|
|
}
|
|
|
|
void TManutenzione_app::close_history()
|
|
{
|
|
// Se la conversione non ha rilevato errori rimuove il file di history.
|
|
remove(History_file);
|
|
}
|
|
|
|
void TManutenzione_app::dump_trc(const char * dir, const bool des_too, const long modules)
|
|
{
|
|
TDir d;
|
|
d.get(LF_DIR);
|
|
const int items = (int) d.eod();
|
|
const long flags = d.flags(); // livello archivi
|
|
TFilename fn(dir);
|
|
fn << "/level.dir";
|
|
{
|
|
ofstream of(fn);
|
|
of << flags << '\n';
|
|
}
|
|
|
|
TString s("Scarico dei tracciati standard in ");
|
|
s << dir;
|
|
TProgind p(items ? items : 1, s, FALSE, TRUE, 70);
|
|
p.setstatus(1);
|
|
for (int i=2;i<=items;i++) //Salta il primo (dir.gen)
|
|
{
|
|
p.addstatus(1);
|
|
TTrec& rc = (TTrec&)_recs[i];
|
|
TDir& dr = (TDir&)_dirs[i];
|
|
const long file_mod = (long)abs((int)dr.flags());
|
|
if (modules != -1 && file_mod != modules) continue; // se non fa parte del modulo lo salta
|
|
TFilename descfname;
|
|
descfname.format("%s/d%d.des", DESCDIR, i);
|
|
if (!fexist(descfname)) // crea la descrizione se non esiste
|
|
{
|
|
FILE * fd = fopen(descfname, "w");
|
|
|
|
if (fd != NULL)
|
|
fclose(fd);
|
|
}
|
|
TConfig conf_des(descfname,DESCPAR);
|
|
|
|
if (des_too) rc.set_des(&conf_des);
|
|
fn = dir;
|
|
fn << "/f";fn << i;
|
|
fn.ext("trr");
|
|
ofstream out(fn);
|
|
out << rc;
|
|
fn.ext("dir");
|
|
ofstream out_dir(fn);
|
|
out_dir << dr;
|
|
}
|
|
}
|
|
|
|
const char* TManutenzione_app::dumpfilename(const FileDes& dep) const
|
|
{
|
|
TFilename n; n.tempdir();
|
|
#if XVT_OS == XVT_OS_SCOUNIX
|
|
n << '/';
|
|
#else
|
|
n << '\\';
|
|
#endif
|
|
n << dep.SysName;
|
|
n.strip("$%");
|
|
n.ext("txt");
|
|
n.lower();
|
|
|
|
strcpy(__tmp_string, n);
|
|
return __tmp_string;
|
|
}
|
|
|
|
void TManutenzione_app::edit_riga (const TString& name)
|
|
{
|
|
TExternisamfile* f = new TExternisamfile(name);
|
|
TFilename n(name);
|
|
KEY tasto;
|
|
|
|
const bool superprassi = user() == "PRASSI";
|
|
_mask->set (FLD_NUM, "");
|
|
_mask->set (FLD_NOME, n);
|
|
_mask->set (FLD_EOD, f->items());
|
|
_mask->set (FLD_EOX, f->items());
|
|
_mask->set (F_LEN, f->curr().len());
|
|
_mask->set (FLD_DESC, f->description());
|
|
_mask->set (FLD_FORMULA, "");
|
|
_mask->set (FLD_FLAG, "");
|
|
_mask->reset (FLD_EXTEND);
|
|
_mask->reset (F_TAB);
|
|
_mask->disable(-1);
|
|
_mask->enable(DLG_RECORD, superprassi);
|
|
tasto = _mask->run();
|
|
switch (tasto)
|
|
{
|
|
case K_F4:
|
|
{
|
|
TEdit_file ef;
|
|
ef.browse(f,n);
|
|
break;
|
|
}
|
|
case K_F6:
|
|
_rec = new TRec_sheet(f);
|
|
_rec->edit();
|
|
delete _rec;
|
|
_rec = NULL;
|
|
delete f; // La delete di TExternisamfile va fatta solo qui perche' in K_F4 viene fatta dalla TRelation interna
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void TManutenzione_app::edit_riga (long riga_sel, TToken_string& riga)
|
|
|
|
{
|
|
KEY tasto;
|
|
FileDes dep;
|
|
TDir d;
|
|
const int logicnum = int(riga_sel) + 1;
|
|
|
|
const bool superprassi = user() == "PRASSI";
|
|
|
|
_mask->enable(DLG_PACK, superprassi);
|
|
_mask->enable(DLG_RECORD, superprassi);
|
|
_mask->enable(DLG_LOAD, superprassi);
|
|
_mask->enable(DLG_DUMP);
|
|
|
|
_mask->show(F_TAB, logicnum >= LF_TABGEN && logicnum <= LF_TAB);
|
|
_mask->set (FLD_NUM, riga.get(0));
|
|
_mask->set (FLD_NOME, riga.get());
|
|
_mask->set (FLD_EOD, riga.get());
|
|
_mask->set (FLD_EOX, riga.get());
|
|
_mask->set (F_LEN, riga.get());
|
|
_mask->set (FLD_DESC, riga.get());
|
|
_mask->set (FLD_FORMULA, riga.get());
|
|
_mask->set (FLD_FLAG, riga.get());
|
|
_mask->reset (FLD_EXTEND);
|
|
_mask->reset (F_TAB);
|
|
|
|
const TRecnotype oldeox = _mask->get_long(FLD_EOX);
|
|
const bool com = prefix().is_com() || !*prefix().name();
|
|
const char* name = _mask->get(FLD_NOME);
|
|
const bool enable_extend = (com ? *name != '$' : *name == '$') &&
|
|
(riga_sel > 0) &&
|
|
(_mask->get_int(F_LEN) > 0 || oldeox > 0);
|
|
|
|
_mask->show(FLD_EXTEND, enable_extend);
|
|
_mask->show(FLD_EOX, enable_extend);
|
|
tasto = _mask->run();
|
|
|
|
switch (tasto)
|
|
{
|
|
case K_F4:
|
|
if (logicnum > 1)
|
|
{
|
|
const TFilename filename(_mask->get(FLD_NOME));
|
|
const TString tabella(_mask->get(F_TAB));
|
|
TEdit_file ef;
|
|
ef.browse(logicnum, filename, tabella);
|
|
}
|
|
break;
|
|
case K_F5:
|
|
case K_F6:
|
|
case K_F8:
|
|
if (!superprassi)
|
|
{
|
|
error_box("Funzione non ammessa per l'utente %s", (const char*)user());
|
|
break;
|
|
}
|
|
case K_F7:
|
|
case K_ENTER:
|
|
{
|
|
strcpy (dep.SysName,_mask->get (FLD_NOME));
|
|
dep.EOD = atol(_mask->get (FLD_EOD));
|
|
dep.Flags = atol(_mask->get (FLD_FLAG));
|
|
strcpy (dep.Des,_mask->get (FLD_DESC));
|
|
strcpy (dep.FCalc,_mask->get (FLD_FORMULA));
|
|
const TRecnotype eox = _mask->get_bool(FLD_EXTEND) ? _mask->get_long(FLD_EOX) : oldeox;
|
|
|
|
_browse->dir()->get(logicnum, _lock, _nordir, _sysdirop);
|
|
_browse->dir()->set(dep.SysName, dep.EOD, dep.Flags,
|
|
dep.Des, dep.FCalc);
|
|
_browse->dir()->put(logicnum, _nordir, _sysdirop);
|
|
|
|
{
|
|
TSystemisamfile f(logicnum);
|
|
|
|
if (eox != oldeox)
|
|
{
|
|
d.get(logicnum);
|
|
TFilename f_name(d.name());
|
|
f_name.ext("dbf");
|
|
|
|
if (!fexist(f_name)) f.build(eox);
|
|
else f.extend(eox);
|
|
_browse->dir()->get(logicnum, _nolock, _nordir, _sysdirop);
|
|
}
|
|
if (tasto == K_F5)
|
|
{
|
|
f.packfile();
|
|
f.packindex();
|
|
//Pack supplementare tramite FOXPRO (da togliere con CodeBase 6)
|
|
#if XVT_OS == XVT_OS_WIN
|
|
if (logicnum > 2 && logicnum < 6 && f.status() == NOERR)
|
|
if (fexist("packaga.exe"))
|
|
{
|
|
d.get(logicnum);
|
|
TFilename f_name(d.name());
|
|
f_name.ext("dbf");
|
|
f_name.replace('/','\\'); // A volte rimangono delle slash
|
|
TString cmd("packaga -t");
|
|
cmd << " " << f_name;
|
|
TExternal_app packapp(cmd);
|
|
packapp.run(FALSE,FALSE);
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
if (tasto == K_F6)
|
|
{
|
|
_rec = new TRec_sheet(logicnum, _mask->get(F_TAB));
|
|
_rec->edit();
|
|
delete _rec;
|
|
_rec = NULL;
|
|
}
|
|
else
|
|
if (tasto == K_F7)
|
|
{
|
|
TMask m("ba1100b");
|
|
|
|
TFilename nout(dumpfilename(dep));
|
|
m.set(FLD_OUTFILE, nout);
|
|
|
|
if (m.run() == K_ENTER)
|
|
{
|
|
nout = m.get(FLD_OUTFILE);
|
|
if (nout.not_empty())
|
|
{
|
|
const char fs = *esc(m.get(FLD_FS));
|
|
const char fd = *esc(m.get(FLD_FD));
|
|
const char rs = *esc(m.get(FLD_RS));
|
|
const bool withdel = m.get_bool(FLD_WITHDEL);
|
|
const int keyno = m.get_int(FLD_KEYNO);
|
|
f.dump(nout, keyno, fs, fd, rs, withdel);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
if (tasto == K_F8)
|
|
{
|
|
TMask m("ba1100c");
|
|
TFilename ninp(dumpfilename(dep));
|
|
m.set(FLD_INFILE, ninp);
|
|
if (m.run() == K_ENTER)
|
|
{
|
|
char fs = *esc(m.get(FLD_FS));
|
|
char fd = *esc(m.get(FLD_FD));
|
|
char rs = *esc(m.get(FLD_RS));
|
|
ninp = m.get(FLD_INFILE);
|
|
f.load(ninp, fs, fd, rs);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void TManutenzione_app::delete_riga ()
|
|
|
|
{
|
|
_browse->dir()->get(LF_DIR);
|
|
if (_browse->dir()->eod() == 0) return;
|
|
|
|
int logicnum = (int)_browse->items();
|
|
|
|
_browse->dir()->get(logicnum);
|
|
if (yesnocancel_box("Confermare l'eliminzione dell'archivio %s", _browse->dir()->name()) != K_YES) return;
|
|
_browse->dir()->get(LF_DIR);
|
|
_browse->dir()->eod()--;
|
|
_browse->set_items(_browse->dir()->eod());
|
|
_browse->dir()->put(LF_DIR);
|
|
// Azzera il tracciato record del file eliminato.
|
|
TTrec r;
|
|
r.zero();
|
|
r.put(logicnum);
|
|
|
|
}
|
|
|
|
void TManutenzione_app::update_dir()
|
|
{
|
|
// Particolare significato dei flags oltre i 10000:
|
|
// trattasi di files PRASSI, (ad esempio i cespiti) che da noi non vengono toccati,
|
|
// in modo da evitare colpe inutili. Noi aggiorniamo solo i tracciati su dir e trc,
|
|
// ma il file fisico manco lo tocchiamo!!
|
|
const TString pref(prefix().name());
|
|
const bool is_com = prefix().is_com();
|
|
|
|
if (prefix().get_codditta() <= _history_firm)
|
|
return;
|
|
|
|
const int orig_items = _dirs.last();
|
|
|
|
TDir d ;
|
|
|
|
d.get(LF_DIR);
|
|
const int items = (int)d.eod();
|
|
|
|
const int update_items = (orig_items < items) ? orig_items : items;
|
|
|
|
TString prompt(128);
|
|
prompt = "Aggiornamento direttorio ";
|
|
if (is_com) prompt << "comune";
|
|
else prompt << " della ditta " << atol(pref) <<".";
|
|
#if XVT_OS == XVT_OS_WIN
|
|
prompt << " Memoria libera: " << (long)GetFreeSpace(0)/1024 << " Kbytes.";
|
|
#endif
|
|
|
|
TProgind p(update_items ? update_items : 1, prompt, FALSE, TRUE, 70);
|
|
p.setstatus(1);
|
|
|
|
for (int i = 2; i <= update_items; i++)
|
|
{
|
|
p.addstatus(1);
|
|
// prefix().set("");
|
|
const TDir & ds = (const TDir &) _dirs[i];
|
|
const bool is_firm = ds.is_firm();
|
|
const bool to_create = (is_com ? ds.is_com() : ds.is_firm());
|
|
|
|
|
|
// TString s(ds.name());
|
|
TFilename fd(ds.filename());
|
|
|
|
bool towrite = FALSE;
|
|
|
|
const long flags = ds.flags();
|
|
// word len = ds.len();
|
|
// prefix().set(pref);
|
|
d.get(i, _nolock, _nordir, _sysdirop);
|
|
const bool old_is_firm = d.is_firm();
|
|
d.get(i);
|
|
|
|
|
|
TFilename fs(d.filename());
|
|
if (strrchr(d.name(),'.') != NULL) // No extension please!
|
|
{
|
|
d.get(i, _nolock, _nordir, _sysdirop);
|
|
TFilename ext(d.name());
|
|
ext.ext("");
|
|
d.set_name(ext);
|
|
d.put(i, _nordir, _sysdirop);
|
|
}
|
|
|
|
|
|
if (!fexist(fs))
|
|
{
|
|
if (d.eox() > 0L)
|
|
{
|
|
d.get(i, _nolock, _nordir, _sysdirop);
|
|
d.eod() = 0L;
|
|
d.eox() = 0L;
|
|
d.put(i, _nordir, _sysdirop);
|
|
}
|
|
}
|
|
else
|
|
if (i > 2 && is_firm == old_is_firm)
|
|
{
|
|
FILE * f = fopen(fs, "r");
|
|
if (f != NULL)
|
|
{
|
|
fseek(f, 0L, SEEK_END);
|
|
const long size = ftell(f);
|
|
|
|
fclose(f);
|
|
if (size > 0L && d.len() > 0)
|
|
{
|
|
TBaseisamfile b(i);
|
|
int err = b.is_valid();
|
|
if (err == NOERR)
|
|
{
|
|
TLocalisamfile f(i);
|
|
}
|
|
else
|
|
{
|
|
if (flags < 10000L && !yesno_box("Il file %d non puo' essere aperto: errore %d. Continuo?",i,err))
|
|
stop_run();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (flags < 10000L && to_create )
|
|
{
|
|
remove(d.filename());
|
|
TToken_string idx_names;
|
|
get_idx_names(i, idx_names);
|
|
for (const char * idx_name = idx_names.get(); idx_name != NULL; idx_name = idx_names.get())
|
|
remove(idx_name);
|
|
d.get(i, _nolock, _nordir, _sysdirop);
|
|
d.eod() = 0L;
|
|
d.eox() = 0L;
|
|
d.put(i, _nordir, _sysdirop);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
d.get(i, _nolock, _nordir, _sysdirop);
|
|
|
|
bool cmn_file = FALSE;
|
|
bool valid_file = i == LF_PCON || i == LF_CLIFO || i == LF_CAUSALI || i == LF_RCAUSALI;
|
|
if (!is_com && valid_file && d.is_com())
|
|
cmn_file = TRUE; // Salta in questo caso:
|
|
// sto aggiornando le ditte,
|
|
// il file in questione e' uno di quelli che possono essere comuni
|
|
// il file e' in comune
|
|
// Serve per evitare che durante l'aggiornamento i file
|
|
// PCON, CLIFO, CAUS ed RCAUS vengano spostati da COM alla
|
|
// prima ditta
|
|
|
|
if (to_create && !cmn_file)
|
|
{
|
|
/* non piu' necessario
|
|
if (is_firm)
|
|
{
|
|
TString name(fd);
|
|
fd.cut(0);
|
|
fd << fs.path() << name;
|
|
}
|
|
*/
|
|
|
|
if (flags < 10000L && flags > -1L && fexist(fs) && (fd != fs))
|
|
{
|
|
bool ok = TRUE;
|
|
TFilename path(fd.path());
|
|
|
|
path.rtrim(1);
|
|
if (path.not_empty() && !fexist(path))
|
|
ok = make_dir(path);
|
|
if (ok && fcopy(fs, fd))
|
|
{
|
|
TToken_string ts(10),td(10);
|
|
td.cut(0);
|
|
get_idx_names(i,ts); // Get index names of current file in current dir
|
|
for (int j=1; j<= ts.items() && ok; j++)
|
|
{
|
|
const TFilename fsi(ts.get());
|
|
TFilename fdi(fd); // Nuovo nome. (Con l'estensione)
|
|
fdi.ext("");
|
|
if (j > 1) // Means that more indexes are in TToken_string ts
|
|
{
|
|
TString xx=fdi.name();
|
|
if (xx.len() < 8)
|
|
fdi << ('0' + j);
|
|
else
|
|
fdi[8] = ('0' + j);
|
|
}
|
|
fdi.ext(fsi.ext());
|
|
td.add(fdi);
|
|
if (!fcopy(fsi, fdi))
|
|
ok = FALSE;
|
|
}
|
|
if (ok)
|
|
{
|
|
remove(fs); // Rimuove i files sorgenti. Crea un eventuale .cgp
|
|
fd.ext("cgp");
|
|
FILE *o=NULL;
|
|
if (ts.items() > 1)
|
|
{
|
|
fs.ext("cgp");
|
|
remove(fs);
|
|
o=fopen(fd,"w");
|
|
}
|
|
ts.restart();
|
|
td.restart();
|
|
for (int j=1; j<=ts.items(); j++)
|
|
{
|
|
remove(ts.get());
|
|
if (ts.items() > 1) // Means that fd.cgp must be created
|
|
{
|
|
TFilename ff=td.get();
|
|
ff.ext("");
|
|
ff.rtrim(1);
|
|
fprintf(o,"%s\n",ff.name());
|
|
}
|
|
}
|
|
if (o!=NULL)
|
|
fclose(o);
|
|
}
|
|
else
|
|
{
|
|
remove(fd); // Remove all destinations written
|
|
td.restart();
|
|
for (int j=1; j<=td.items(); j++)
|
|
remove(td.get());
|
|
}
|
|
}
|
|
else
|
|
ok = FALSE;
|
|
if (ok)
|
|
{
|
|
d.set(ds.name(), d.eox(), 0L, ds.des(), d.expr());
|
|
towrite = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!fexist(fs) && !valid_file) // Controlla eventali nomi di files non validi (ed es. %.dbf ecc.)
|
|
{
|
|
d.set(ds.name(), d.eox(), 0L, ds.des(), d.expr());
|
|
towrite = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
towrite = (TString(ds.des()) != d.des());
|
|
if (towrite)
|
|
if (!valid_file)
|
|
d.set(ds.name(), d.eox(), d.eod(), ds.des(), d.expr());
|
|
else
|
|
strcpy((char *) d.des(), ds.des());
|
|
}
|
|
if (towrite)
|
|
d.put(i, _nordir, _sysdirop);
|
|
// d.get(i);
|
|
} // end of for scope
|
|
// prefix().set(pref);
|
|
|
|
if (items >= orig_items) return;
|
|
|
|
for (i = items + 1; i <= orig_items; i++)
|
|
{
|
|
// prefix().set("");
|
|
// d.get(i, _nolock, _nordir, _sysdirop);
|
|
// prefix().set(pref);
|
|
TDir d1((TDir &) _dirs[i]);
|
|
|
|
d1.set_len(0);
|
|
d1.eox() = 0;
|
|
d1.flags() = 0L;
|
|
d1.put(i, _nordir, _sysdirop);
|
|
}
|
|
// prefix().set(pref);
|
|
d.get(LF_DIR, _nolock, _nordir, _sysdirop);
|
|
d.eod() = orig_items;
|
|
if (d.eox() < d.eod())
|
|
d.eox() = d.eod();
|
|
d.put(LF_DIR, _nordir, _sysdirop);
|
|
}
|
|
|
|
void TManutenzione_app::convert_dir()
|
|
{
|
|
const TString pref(prefix().name());
|
|
const bool is_com = prefix().is_com();
|
|
const int orig_items = _dirs.last();
|
|
|
|
TDir d;
|
|
|
|
if (prefix().get_codditta() <= _history_firm)
|
|
return;
|
|
|
|
d.get(LF_DIR);
|
|
const int items = (int)d.eod();
|
|
|
|
const int update_items = (orig_items < items) ? orig_items : items;
|
|
|
|
TString s(256);
|
|
s = "Aggiornamento archivi ";
|
|
if (is_com) s << "comuni.";
|
|
else s << "della ditta " << atol (pref) << ".";
|
|
|
|
#if XVT_OS == XVT_OS_WIN
|
|
s << " Memoria libera: " << (long)GetFreeSpace(0)/1024 << " Kbytes.";
|
|
#endif
|
|
|
|
TProgind p(update_items ? update_items : 1, s, FALSE, TRUE, 70);
|
|
p.setstatus(1);
|
|
|
|
for (int i = 2; i <= update_items; i++)
|
|
{
|
|
p.addstatus(1);
|
|
// prefix().set("");
|
|
const TTrec & rs = (const TTrec &) _recs[i];
|
|
const TDir & ds = (const TDir &) _dirs[i];
|
|
const long flags = ds.flags();
|
|
// prefix().set(pref);
|
|
if (ds.len() > 0)
|
|
{
|
|
if (flags < 10000L && flags > -1L)
|
|
{
|
|
TBaseisamfile b(i);
|
|
const int module = abs((int)ds.flags());
|
|
int err = b.is_valid();
|
|
if (err == -60 || err == -64) err=NOERR; // verif.
|
|
d.get(i, _nolock, _nordir, _sysdirop);
|
|
if (i > 2 && err != NOERR && ((is_com && d.is_com()) || (!is_com && d.is_firm())))
|
|
{
|
|
if (!yesno_box("Il file %d non puo' essere aperto: errore %d. Continuo?",i,err))
|
|
stop_run();
|
|
else continue;
|
|
}
|
|
|
|
//d.get(i, _nolock, _nordir, _sysdirop);
|
|
bool to_create = (is_com ? d.is_com() : d.is_firm());
|
|
const bool actual_create = to_create;
|
|
|
|
// I files LF_PCON, LF_CAUS, LF_RCAUS, LF_CLIFO, LF_CFVEN, LF_INDSPED
|
|
// vanno creati comunque nel direttorio COM, vuoti, (se non esistono gia').
|
|
if (is_com && !to_create)
|
|
if (i == LF_TAB || i == LF_INDSP || i == LF_CLIFO ||
|
|
i == LF_PCON || i == LF_CAUSALI || i == LF_RCAUSALI)
|
|
to_create = TRUE;
|
|
|
|
if (to_create && has_module(module, CHK_DONGLE))
|
|
{
|
|
d.get(i);
|
|
TFilename s(d.filename());
|
|
if (!fexist(s))
|
|
{
|
|
TSystemisamfile f(i);
|
|
set_autoload_new_files(actual_create);
|
|
f.build(0L,rs);
|
|
set_autoload_new_files(TRUE);
|
|
// Anche se il file non esisteva, prosegue, perche' possono esserci conversioni
|
|
// specificate in FCONV.INI
|
|
}
|
|
}
|
|
|
|
|
|
TSystemisamfile f(i);
|
|
|
|
f.update(rs);
|
|
if (f.status() == 8) // cio' significa che e' accaduto quasi l'irreparabile...
|
|
{
|
|
{
|
|
TLocalisamfile u(LF_USER);
|
|
u.zero(); u.put("USERNAME","PRASSI");
|
|
if (u.read() == NOERR)
|
|
{
|
|
u.zero("AUTSTR");
|
|
u.rewrite();
|
|
}
|
|
}
|
|
stop_run();
|
|
}
|
|
}
|
|
else // altrimenti se i flags sono oltre i fatidici 10000...
|
|
{
|
|
TTrec r(rs);
|
|
|
|
d.get(i, _nolock, _nordir, _sysdirop);
|
|
d.set_len(r.len());
|
|
d.put(i, _nordir, _sysdirop);
|
|
r.put(i);
|
|
}
|
|
}
|
|
else // altrimenti se la dimensione del tracciato e' zero...
|
|
{
|
|
TTrec r(rs);
|
|
|
|
r.zero();
|
|
r.put(i);
|
|
}
|
|
}
|
|
// prefix().set(pref);
|
|
d.get(LF_DIR, _nolock, _nordir, _sysdirop);
|
|
d.flags() = _level;
|
|
d.put(LF_DIR, _nordir, _sysdirop);
|
|
put_history(pref);
|
|
}
|
|
|
|
void TManutenzione_app::load_des()
|
|
{
|
|
const TString pref(prefix().name());
|
|
|
|
_dirs.destroy();
|
|
_recs.destroy();
|
|
_level = prefix().filelevel();
|
|
|
|
TDir d;
|
|
TTrec r;
|
|
|
|
d.get(LF_DIR,_nolock, _nordir,_sysdirop);
|
|
int items = (int)d.eod();
|
|
long flags = d.flags();
|
|
const bool standard = pref.empty();
|
|
|
|
if (standard) // carica eventuali nuove descrizioni ed il nuovo livello archivi
|
|
{
|
|
// Cerca in RECDESC i files f[nnn].dir
|
|
ifstream infile;
|
|
TString ws;
|
|
TFilename fn;
|
|
TDir td,new_dir;
|
|
TTrec tr;
|
|
#if XVT_OS == XVT_OS_WIN
|
|
struct _find_t c_file;
|
|
#endif
|
|
int ln = items,last_newln = items;
|
|
bool firstime = TRUE,ok;
|
|
tr.zero();
|
|
fn << DESCDIR << "/level.dir";
|
|
|
|
if (fexist(fn))
|
|
{
|
|
long fl;
|
|
infile.open(fn);
|
|
infile >> fl;
|
|
if (fl > flags) flags = fl;
|
|
infile.close();
|
|
//unlink(fn);
|
|
}
|
|
|
|
// scandisce *.dir in RECDESC tramite dos_findfirst e _dos_findnext
|
|
// eventuali "buchi" oltre al numero attuale di items vengono rimpiazzati
|
|
// con tracciati vuoti.
|
|
|
|
fn.format("%s/f*.dir",DESCDIR);
|
|
#if XVT_OS == XVT_OS_WIN
|
|
do
|
|
{
|
|
if (firstime)
|
|
{
|
|
ok = _dos_findfirst(fn, _A_NORMAL, &c_file ) == 0;
|
|
firstime = FALSE;
|
|
}
|
|
fn.format("%s/%s",DESCDIR,c_file.name);
|
|
if (ok)
|
|
{
|
|
infile.open(fn);
|
|
infile >> td;
|
|
ln = td.num();
|
|
const bool is_new = ln > last_newln; // memorizza l'ultimo record scritto come nuovo
|
|
if (is_new) // aggiunge i files che mancano
|
|
{
|
|
for (int i = last_newln+1; i<ln; i++)
|
|
{
|
|
ws.format("$f%d",i);
|
|
new_dir.set(ws,0L,-1L,"File non presente","");
|
|
new_dir.put(i,_nordir,_sysdirop);
|
|
tr.put(i);
|
|
}
|
|
last_newln = ln;
|
|
}
|
|
td.put(ln,_nordir,_sysdirop);
|
|
if (is_new)
|
|
tr.put(ln);
|
|
infile.close();
|
|
//unlink(fn);
|
|
}
|
|
} while( _dos_findnext( &c_file ) == 0 );
|
|
#endif
|
|
// Aggiorna il numero di files presenti in totale nel direttorio
|
|
if (last_newln > items) // rialloca openf altrimenti la TPrefix::closeall() provoca un grazioso errore in applicazione
|
|
{
|
|
isfdptr *newopenf = new isfdptr[last_newln];
|
|
for (int i = 0; i<last_newln; i++)
|
|
newopenf[i] = (i<items) ? openf[i] : NULL;
|
|
delete openf;
|
|
openf = newopenf;
|
|
}
|
|
d.eod() = (long)last_newln;
|
|
d.eox() = (long)last_newln;
|
|
d.flags() = _level = flags;
|
|
set_std_level(flags);
|
|
d.put(LF_DIR,_nordir,_sysdirop);
|
|
}
|
|
|
|
items = (int) d.eod();
|
|
TString80 s("Caricamento descrizioni archivi ");
|
|
|
|
if (standard) s << "standard";
|
|
else
|
|
if (prefix().is_com()) s << "comuni";
|
|
else s << " della ditta " << atol (pref);
|
|
|
|
TProgind p(items ? items : 1, s, TRUE, TRUE, 70);
|
|
|
|
p.setstatus(1);
|
|
for (int i = 2; i <= items; i++)
|
|
{
|
|
p.addstatus(1);
|
|
d.get(i, _nolock, _nordir, _sysdirop);
|
|
r.get(i);
|
|
if (standard)
|
|
{
|
|
TFilename desc_file;
|
|
|
|
desc_file << DESCDIR << "/f" << i;
|
|
desc_file.ext("trr");
|
|
if (fexist(desc_file))
|
|
{
|
|
{
|
|
ifstream in(desc_file);
|
|
TFilename descfname;
|
|
|
|
descfname.format("%s/d%d.des", DESCDIR, i);
|
|
|
|
if (!fexist(descfname))
|
|
{
|
|
FILE * fd = fopen(descfname, "w");
|
|
|
|
if (fd != NULL)
|
|
fclose(fd);
|
|
}
|
|
|
|
TConfig descr(descfname, DESCPAR);
|
|
|
|
r.set_des(&descr);
|
|
in >> r;
|
|
r.put(i);
|
|
d.set_len(r.len());
|
|
d.put(i, _nordir, _sysdirop);
|
|
r.set_des();
|
|
}
|
|
//remove(desc_file);
|
|
}
|
|
}
|
|
_dirs.add(d, i);
|
|
_recs.add(r, i);
|
|
}
|
|
}
|
|
|
|
void TManutenzione_app::update()
|
|
{
|
|
bool ok = TRUE;
|
|
|
|
TIsamfile utenti(LF_USER, FALSE);
|
|
utenti.open(_excllock);
|
|
|
|
for (int err = utenti.first(); err == NOERR; err = utenti.next())
|
|
{
|
|
const TString16 u = utenti.get("USERNAME");
|
|
if (u == "PRASSI")
|
|
{
|
|
if (utenti.get("AUTSTR") == "CONVERTING")
|
|
{
|
|
ok = error_box("Impossibile proseguire: esiste gia' conversione in corso");
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
utenti.put("AUTSTR", "CONVERTING");
|
|
utenti.rewrite();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (utenti.get_bool("CONNECTED"))
|
|
{
|
|
ok = error_box("La conversione non puo' essere effettuata\n"
|
|
"mentre l'utente %s e' collegato", (const char*)u);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
utenti.close();
|
|
if (!ok)
|
|
return;
|
|
|
|
open_history();
|
|
long firm = get_firm();
|
|
TString pref;
|
|
if (firm == 0) pref = prefix().name();
|
|
|
|
do_events();
|
|
|
|
begin_wait();
|
|
prefix().set("");
|
|
load_des();
|
|
prefix().set_codditta(0L);
|
|
/* if (prefix().filelevel() <= 199502L)
|
|
{
|
|
TExternal_app app("bacnv 4 0");
|
|
app.run();
|
|
} */
|
|
|
|
update_dir();
|
|
convert_dir();
|
|
|
|
TSystemisamfile ditte(LF_NDITTE);
|
|
ditte.open();
|
|
|
|
TString80 s("Conversione archivi ditte.");
|
|
|
|
TProgind p(ditte.items() ? ditte.items() : 1, s, TRUE, TRUE, 70);
|
|
|
|
p.setstatus(1);
|
|
TString mxs;
|
|
|
|
for (ditte.first(); !ditte.eof(); ditte.next())
|
|
{
|
|
const TRecnotype rec = ditte.recno();
|
|
const long codditta = ditte.get_long("CODDITTA");
|
|
mxs = s;
|
|
#if XVT_OS == XVT_OS_WIN
|
|
mxs << " Ditta " << codditta << ". Memoria libera: " << (long)GetFreeSpace(0)/1024 << " Kbytes.";
|
|
#endif
|
|
p.addstatus(1);
|
|
p.set_text(mxs);
|
|
if (codditta > _history_firm && prefix().exist(codditta))
|
|
{
|
|
ditte.close();
|
|
set_firm(codditta);
|
|
update_dir();
|
|
convert_dir();
|
|
ditte.open();
|
|
}
|
|
ditte.readat(rec);
|
|
}
|
|
ditte.close();
|
|
|
|
if (firm > 0) set_firm(firm);
|
|
else prefix().set(pref);
|
|
load_des();
|
|
|
|
ok = FALSE;
|
|
while (!ok)
|
|
{
|
|
utenti.open(_excllock);
|
|
ok = utenti.ok();
|
|
do_events();
|
|
}
|
|
|
|
utenti.put("USERNAME", "PRASSI");
|
|
if (utenti.read() == NOERR)
|
|
{
|
|
utenti.zero("AUTSTR");
|
|
utenti.rewrite();
|
|
}
|
|
utenti.close();
|
|
close_history();
|
|
end_wait();
|
|
}
|
|
|
|
bool TManutenzione_app::menu(MENU_TAG m)
|
|
{
|
|
TToken_string riga;
|
|
long riga_selezionata;
|
|
bool done = FALSE;
|
|
|
|
_browse->rebuild();
|
|
|
|
while (!done)
|
|
{
|
|
disable_menu_item(M_FILE_NEW);
|
|
|
|
KEY key = _browse->run();
|
|
|
|
if (key != K_ENTER && key != K_ESC && user() != "PRASSI")
|
|
{
|
|
error_box("Operazione non permessa all'utente %s", (const char*)user());
|
|
key = 0;
|
|
}
|
|
|
|
switch (key)
|
|
{
|
|
case K_F6:
|
|
riga_selezionata = _browse->selected();
|
|
riga = _browse->row();
|
|
insert_riga (riga_selezionata, riga);
|
|
break;
|
|
|
|
case K_ENTER:
|
|
riga_selezionata = _browse->selected();
|
|
riga = _browse->row();
|
|
edit_riga (riga_selezionata, riga);
|
|
break;
|
|
|
|
case K_DEL: delete_riga(); break;
|
|
|
|
case K_ESC: done = TRUE; close_history(); break;
|
|
|
|
case K_F7:
|
|
update(); break;
|
|
|
|
case K_F8:
|
|
_browse->add();
|
|
riga_selezionata = _browse->items() - 1;
|
|
riga = _browse->row(riga_selezionata);
|
|
edit_riga (riga_selezionata, riga);
|
|
break;
|
|
case K_F5: // Other file
|
|
{
|
|
TMask other("ba1100g");
|
|
other.set_handler(101, browse_file_handler);
|
|
if (other.run() == K_ENTER)
|
|
edit_riga(other.get(101));
|
|
}
|
|
break;
|
|
|
|
default: break;
|
|
}
|
|
|
|
enable_menu_item(M_FILE_NEW);
|
|
}
|
|
|
|
return xvt_test_menu_tag(BAR_ITEM(2));
|
|
}
|
|
|
|
int ba1100(int argc, char** argv)
|
|
{
|
|
TManutenzione_app a;
|
|
a.run(argc, argv, "Gestione files");
|
|
return 0;
|
|
}
|
|
|