609 lines
15 KiB
C++
Executable File
609 lines
15 KiB
C++
Executable File
#include <config.h>
|
|
#include <dongle.h>
|
|
#include <prefix.h>
|
|
#include <progind.h>
|
|
|
|
#include "bainstlib.h"
|
|
#include "bainsta.h"
|
|
|
|
// ********************************
|
|
// classe TSystemtempfile
|
|
// ********************************
|
|
|
|
|
|
// classe provvisoria per i system file temporanei, ovvero file temporanei con
|
|
// caricamento/scaricamento
|
|
// @doc EXTERNAL
|
|
|
|
// @mfunc Importa un file ascii
|
|
//
|
|
// @rdesc Ritorna NOERR se l'operazione di lettura e' riuscita, altrimenti il codice di
|
|
// di errore generato (vedi <t TIsamerr>).
|
|
int TSystemtempfile::load(
|
|
const char* from, // @parm Nome del file da importare
|
|
char fs, // @parm Carattere separatore di campo (default <pipe>)
|
|
char fd, // @parm Carattere delimitatore di campi (default '\\0')
|
|
char rs, // @parm Carattere separatore di record (default '\\n')
|
|
bool vis, // @parm Indica se visualizzare lo stato dell'operazione (default TRUE)
|
|
bool extended) // @parm Indica se interpretare alcune stringhe come macro (default FALSE)
|
|
|
|
// @comm Se <p extended> e' TRUE e trova alcune stringhe col formato %stringa% (es. %frm%)
|
|
// ne sostituisce i valori (es. ditta corrente).
|
|
|
|
// @xref <mf TSystemisamfile::dump>
|
|
|
|
{
|
|
FILE* fl = NULL;
|
|
int err = fopen_s(&fl, from, "r");;
|
|
if (fl == NULL)
|
|
{
|
|
cantread_box(from);
|
|
return err;
|
|
}
|
|
TRecnotype r = 0, e = 0, nitems = 0, nread = 0;
|
|
TString16 firm, year, attprev("00000");
|
|
|
|
if (extended)
|
|
{
|
|
TDate d(TODAY);
|
|
TLocalisamfile ditte(LF_NDITTE);
|
|
|
|
firm.format("%05ld", prefix().get_codditta());
|
|
year.format("%04d", d.year());
|
|
ditte.zero();
|
|
ditte.put("CODDITTA", firm);
|
|
if (ditte.read() == NOERR)
|
|
attprev = ditte.get("CODATTPREV");
|
|
}
|
|
if (fl == NULL)
|
|
{
|
|
clearerr(fl);
|
|
setstatus(err);
|
|
return err;
|
|
}
|
|
char w[256];
|
|
while ((fgets(w, sizeof(w), fl) != NULL))
|
|
{
|
|
if (strncmp(w, "[Data]", 6) == 0)
|
|
{
|
|
nitems = ftell(fl);
|
|
break;
|
|
}
|
|
}
|
|
fseek(fl, 0L, SEEK_END);
|
|
nitems = ftell(fl) - nitems;
|
|
fclose(fl);
|
|
TScanner f(from);
|
|
|
|
TToken_string s(1024, fs);
|
|
bool fixedlen = (fs == '\0');
|
|
int nflds = curr().items();
|
|
TArray fld(nflds);
|
|
int len[MaxFields];
|
|
TString sfd(3);
|
|
TString s1(64);
|
|
|
|
if (f.paragraph("Header"))
|
|
{
|
|
f.equal();
|
|
const unsigned int level = atoi(f.line());
|
|
const unsigned int stdlev = prefix().get_stdlevel();
|
|
if (level > stdlev)
|
|
error_box("L'archivio %s e' stato generato con gli archivi di livello %ld%/%ld.\n Il livello attuale e' %ld/%ld.\n Convertire gli archivi e ripetere l' operazione.",
|
|
from, level/100, level%100, stdlev/100, stdlev%100);
|
|
|
|
nflds = 0;
|
|
while (true)
|
|
{
|
|
const TString& riga = f.line();
|
|
//quando termina la testata deve uscire dal ciclo!
|
|
if (riga.blank() || riga[0] == ']')
|
|
break;
|
|
//legge il tracciato record
|
|
if (riga.starts_with("Fields"))
|
|
{
|
|
TToken_string s2 = riga.after("=");
|
|
for (const char * fd = s2.get(); fd != NULL; fd = s2.get())
|
|
{
|
|
TToken_string wfd(fd, ',');
|
|
fld.add(new TString(wfd.get()));
|
|
len[nflds] = wfd.get_int();
|
|
nflds++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int j = 0; j < nflds; j++)
|
|
{
|
|
fld.add(TString(curr().fieldname(j)), j);
|
|
const TString & wfld = (const TString & ) fld[j];
|
|
len[j] = (curr().type(wfld) == _datefld) ? 10 : curr().length(wfld);
|
|
}
|
|
}
|
|
if (!f.paragraph("Data"))
|
|
{
|
|
error_box("Formato dei dati non valido");
|
|
//close();
|
|
err = 1;
|
|
setstatus(err);
|
|
return err;
|
|
}
|
|
|
|
if (fd) sfd << fd;
|
|
int last = NOERR;
|
|
|
|
s1.format("Imp. archivio %s\n%6ld records %6ld errori - %3d", filename(), r, e, last);
|
|
TProgind p(nitems, s1, TRUE, TRUE, 70);
|
|
s = f.line();
|
|
while (s.not_empty() && !p.iscancelled())
|
|
{
|
|
if (extended)
|
|
{
|
|
int p, i;
|
|
|
|
while ((p = s.find("%yr%")) >= 0)
|
|
for (i = 0; i < 4; i++) s[p + i] = year[i];
|
|
while ((p = s.find("%frm%")) >= 0)
|
|
for (i = 0; i < 5; i++) s[p + i] = firm[i];
|
|
while ((p = s.find("%att%")) >= 0)
|
|
for (i = 0; i < 5; i++) s[p + i] = attprev[i];
|
|
}
|
|
if ((r + e) % 50 == 0)
|
|
{
|
|
s1.format("Imp. archivio %s\n%6ld records %6ld errori - %3d", filename(), r, e, last);
|
|
p.set_text(s1);
|
|
}
|
|
p.setstatus(nread + 1);
|
|
nread += s.len() + 1;
|
|
zero();
|
|
if (fixedlen)
|
|
{
|
|
int pos = 0;
|
|
for (int j = 0; j < nflds; j++)
|
|
{
|
|
s1 = s.mid(pos,len[j]);
|
|
s1.rtrim();
|
|
put((const TString&) fld[j], s1);
|
|
pos += len[j];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
s.restart();
|
|
for (int j = 0; j < nflds; j++)
|
|
{
|
|
char* s2 = (char*) s.get();
|
|
if (fd)
|
|
{
|
|
s2++;
|
|
s2[strlen(s2) - 1] = '\0';
|
|
}
|
|
put((const TString&) fld[j], s2);
|
|
}
|
|
}
|
|
if (write() == NOERR) r++;
|
|
else
|
|
{
|
|
#ifdef DBG
|
|
yesnofatal_box("Numero linea relativa all'errore: %ld",r+e+1);
|
|
#endif
|
|
e++;
|
|
last = status();
|
|
}
|
|
s = f.line();
|
|
}
|
|
s1.format("Imp. archivio %s\n%6ld records %6ld errori - %3d", filename(), r, e, last);
|
|
p.set_text(s1);
|
|
//close();
|
|
setstatus(err);
|
|
return err;
|
|
}
|
|
|
|
// @mfunc Esporta VERSO un file ascii.
|
|
//
|
|
// @rdesc Ritorna NOERR se l'operazione di esportazione e' riuscita, altrimenti il codice di
|
|
// di errore generato (vedi <t TIsamerr>).
|
|
int TSystemtempfile::dump(
|
|
const char* to, // @parm Nome del file verso quale esportare
|
|
int nkey, // @parm Numero della chiave di ordinamento con cui scaricare i dati (defualt 1)
|
|
char fs, // @parm Carattere seperatore di campo (defualt <pipe>)
|
|
char fd, // @parm Carattere delimitatore di campo (default '\\0')
|
|
char rs, // @parm Carattere separatore di record (default '\\n')
|
|
bool vis, // @parm Indica se visualizzare lo stato dell'operazione (defualt TRUE)
|
|
bool withdeleted) // @parm Indica se scaricare anche i record cancellati (dafault FALSE)
|
|
|
|
// @xref <mf TSystemisamfile::load>
|
|
|
|
{
|
|
FILE* f = NULL;
|
|
int err = fopen_s(&f, to, "w");
|
|
if (f == NULL)
|
|
{
|
|
setstatus(2);
|
|
return err;
|
|
}
|
|
if (withdeleted)
|
|
nkey = 0;
|
|
err = ferror(f);
|
|
|
|
//open(FALSE, nkey ? TRUE : FALSE);
|
|
TString s(512);
|
|
bool fixedlen = (fs == '\0');
|
|
int nflds = curr().items();
|
|
TArray fld(nflds);
|
|
TBit_array rjust(nflds);
|
|
int len[MaxFields];
|
|
int j;
|
|
|
|
for (j = 0; j < nflds; j++)
|
|
{
|
|
fld.add(TString(curr().fieldname(j)), j);
|
|
const TString & wfld = (const TString&) fld[j];
|
|
const TFieldtypes t = curr().type(wfld);
|
|
rjust.set(j, t == _intfld || t == _longfld || t == _realfld ||
|
|
t == _wordfld || t == _intzerofld || t == _longzerofld);
|
|
len[j] = (t == _datefld) ? 10 : curr().length(wfld);
|
|
}
|
|
TRecnotype i = 0;
|
|
const TRecnotype nitems = items();
|
|
s.format("Esportazione archivio %s", filename());
|
|
TProgind p(nitems, s, TRUE, TRUE, 70);
|
|
TString s1;
|
|
|
|
fprintf(f, "[Header]\nVersion=%ld", (long) prefix().filelevel());
|
|
for (int k = 0; k < nflds; k++)
|
|
{
|
|
if ((k % 10) == 0) fprintf(f, "\nFields=");
|
|
else fprintf(f, "|");
|
|
fprintf(f, "%s,%d", (const char *) (const TString&) fld[k], len[k]);
|
|
}
|
|
fprintf(f, "\n\n[Data]\n");
|
|
if (nkey)
|
|
{
|
|
setkey(nkey);
|
|
for ( first(); status() == NOERR && !p.iscancelled(); next(), i++)
|
|
{
|
|
p.setstatus(i + 1);
|
|
s = "";
|
|
for (j = 0; j < nflds; j++)
|
|
{
|
|
if (fixedlen)
|
|
{
|
|
s1 = get((const TString&)fld[j]);
|
|
if (rjust[j]) s1.right_just(len[j]);
|
|
else s1.left_just(len[j]);
|
|
}
|
|
else
|
|
{
|
|
s1 = "";
|
|
if (j && fs) s1 << fs;
|
|
if (fd) s1 << fd;
|
|
s1 << get((const TString&)fld[j]);
|
|
if (fd) s1 << fd;
|
|
}
|
|
s << s1;
|
|
}
|
|
fprintf(f, "%s%c", (const char*) s, rs);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
for (i = 0; i < nitems && !p.iscancelled(); i++)
|
|
{
|
|
zero();
|
|
p.setstatus(i + 1);
|
|
readat(i + 1);
|
|
s="";
|
|
if (withdeleted || curr().valid())
|
|
{
|
|
for (j = 0; j < nflds; j++)
|
|
{
|
|
if (fixedlen)
|
|
{
|
|
s1 = get((const TString&)fld[j]);
|
|
if (rjust[j]) s1.right_just(len[j]);
|
|
else s1.left_just(len[j]);
|
|
}
|
|
else
|
|
{
|
|
s1 = "";
|
|
if (j && fs) s1 << fs;
|
|
if (fd) s1 << fd;
|
|
s1 << get((const TString&)fld[j]);
|
|
if (fd) s1 << fd;
|
|
}
|
|
s << s1;
|
|
}
|
|
fprintf(f, "%s%c", (const char*) s, rs);
|
|
}
|
|
}
|
|
}
|
|
p.setstatus(nitems);
|
|
//close();
|
|
fclose(f);
|
|
setstatus(err);
|
|
return err;
|
|
}
|
|
|
|
// ********************************
|
|
// classe TStd_filename
|
|
// ********************************
|
|
|
|
bool TStd_filename::check(bool verbose, const char * n)
|
|
{
|
|
if (n && *n)
|
|
set(n);
|
|
insert("std\\");
|
|
if (!exist())
|
|
{
|
|
*this = name();
|
|
if (!exist())
|
|
{
|
|
insert("std\\");
|
|
insert(prefix().get_studio());
|
|
}
|
|
}
|
|
if (!exist())
|
|
{
|
|
if (verbose)
|
|
cantread_box(name());
|
|
cut(0);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ********************************
|
|
// classe TInstallmodule_app
|
|
// ********************************
|
|
|
|
const char* TInstallmodule_app::module_name() const
|
|
{
|
|
return dongle().module_code2desc(module_number());
|
|
}
|
|
|
|
const char* TInstallmodule_app::module_code() const
|
|
{
|
|
return dongle().module_code2name(module_number());
|
|
}
|
|
|
|
|
|
bool TInstallmodule_app::create()
|
|
{
|
|
if (modal())
|
|
{
|
|
TString16 maskname;
|
|
maskname.format("bainst%02d",module_number());
|
|
_m = new TMask(maskname);
|
|
}
|
|
else
|
|
_m = NULL;
|
|
|
|
TConfig campo_ini(CONFIG_INSTALL, "Main");
|
|
const int type = campo_ini.get_int("Type");
|
|
if (type == 1 || type == 2)
|
|
_test_database = true;
|
|
else
|
|
_test_database = campo_ini.get_bool("TestDatabase");
|
|
|
|
return TSkeleton_application::create();
|
|
}
|
|
|
|
bool TInstallmodule_app::destroy()
|
|
{
|
|
if (_m) delete _m;
|
|
return TSkeleton_application::destroy();
|
|
}
|
|
|
|
bool TInstallmodule_app::something_to_load() const
|
|
{
|
|
bool yes = false;
|
|
//dati comuni
|
|
TFilename file_to_load = module_code();
|
|
file_to_load << "tabcom.txt";
|
|
yes = ci_sono_novita(file_to_load, LF_TABCOM);
|
|
//dati ditta
|
|
if (!yes)
|
|
{
|
|
file_to_load = module_code();
|
|
file_to_load << "tab.txt";
|
|
yes = ci_sono_novita(file_to_load, LF_TAB);
|
|
}
|
|
//dati di modulo
|
|
if (!yes)
|
|
{
|
|
file_to_load = module_code();
|
|
file_to_load << "tabmod.txt";
|
|
yes = ci_sono_novita(file_to_load, LF_TABMOD);
|
|
}
|
|
return yes;
|
|
}
|
|
|
|
bool TInstallmodule_app::preload_mask()
|
|
{
|
|
if (test_database())
|
|
{
|
|
if (something_to_load())
|
|
_m->set(F_DEFAULTSDATA,"X");
|
|
}
|
|
else
|
|
{
|
|
_m->set(F_DEFAULTSDATA," ");
|
|
_m->disable(F_DEFAULTSDATA);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool TInstallmodule_app::ci_sono_novita(const TFilename& txt, const int filedest) const
|
|
{
|
|
TStd_filename filesource;
|
|
bool ok = (filedest == LF_TAB || filedest == LF_TABCOM || filedest == LF_TABMOD) && filesource.check(false, txt);
|
|
if (ok)
|
|
{
|
|
TScanner scan(filesource);
|
|
ok = scan.paragraph("Data");
|
|
if (ok)
|
|
{
|
|
TIsamfile ifile(filedest);
|
|
ok = ifile.open_ex() != NOERR; //se il file non e' buono va aggiornato...
|
|
if (!ok)
|
|
{
|
|
ok = ifile.read(_isfirst) != NOERR; //se il file e' vuoto ci sono sicuramente novita'!!!
|
|
TToken_string tok;
|
|
while (!ok)
|
|
{
|
|
tok = scan.line();
|
|
if (tok.blank())
|
|
break;
|
|
if (filedest == LF_TABMOD)
|
|
{
|
|
ifile.put("MOD", tok.get(0));
|
|
ifile.put("CUST", tok.get(1));
|
|
ifile.put("COD", tok.get(2));
|
|
ifile.put("CODTAB", tok.get(3));
|
|
}
|
|
else
|
|
{
|
|
ifile.put("COD", tok.get(0));
|
|
ifile.put("CODTAB", tok.get(1));
|
|
}
|
|
ok = ifile.read() != NOERR;
|
|
}
|
|
ifile.close();
|
|
}
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool TInstallmodule_app::something_checked() const
|
|
{
|
|
return _m->get_bool(F_DEFAULTSDATA);
|
|
}
|
|
|
|
void TInstallmodule_app::main_loop()
|
|
{
|
|
bool ok = true;
|
|
|
|
if (modal())
|
|
{
|
|
if (test_database()) //solo se puoi modificare i dati ti e' permesso di entrare, oh utonto!
|
|
{
|
|
preload_mask();
|
|
if (something_checked() && _m->run() != K_QUIT) //modifica per far apparire il caricamento dei dati standard solo se non ci sono
|
|
{
|
|
if (something_checked()) //rifare il test in caso di flaggaggio manuale
|
|
{
|
|
install_com();
|
|
install_firm();
|
|
install_mod();
|
|
}
|
|
}
|
|
else
|
|
ok = false;
|
|
}
|
|
}
|
|
if (ok)
|
|
post_installer();
|
|
}
|
|
|
|
bool TInstallmodule_app::install_firm()
|
|
{
|
|
// ciclo su ogni ditta
|
|
TStd_filename txtfile(module_code());
|
|
txtfile << "tab.txt";
|
|
if (txtfile.check())
|
|
{
|
|
TString_array firms;
|
|
TPrefix::firms(firms);
|
|
|
|
FOR_EACH_ARRAY_ROW(firms, r, riga)
|
|
{
|
|
set_firm(atol(*riga));
|
|
TSystemisamfile tab(LF_TAB);
|
|
tab.load(txtfile);
|
|
}
|
|
// carica le tabelle nei file di default
|
|
TSystemtempfile tabstd(LF_TAB);
|
|
TFilename stdtabname(prefix().get_studio());
|
|
stdtabname << "STD\\lf0005.txt";
|
|
tabstd.load(txtfile);
|
|
tabstd.load(stdtabname);
|
|
tabstd.set_autodel();
|
|
TFilename tempfile;
|
|
tempfile.temp();
|
|
|
|
// riconverte le macro delle date
|
|
tabstd.dump(tempfile);
|
|
TScanner scan(tempfile);
|
|
FILE *dest = NULL;
|
|
fopen_s(&dest, stdtabname, "w");
|
|
while (dest)
|
|
{
|
|
TString &line=scan.line();
|
|
if (line.empty()) break;
|
|
|
|
int pos=(line.find("-0000"));
|
|
while (pos >= 0 )
|
|
{
|
|
line.overwrite("%yr%",pos+1);
|
|
pos=(line.find("-0000"));
|
|
}
|
|
line << '\n' ;
|
|
fputs((const char * )line,dest);
|
|
}
|
|
fclose(dest);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool TInstallmodule_app::install_com()
|
|
{
|
|
bool ok = true;
|
|
TStd_filename txtfile(module_code());
|
|
txtfile << "tabcom.txt";
|
|
if (txtfile.check())
|
|
{
|
|
TSystemisamfile tabcom(LF_TABCOM);
|
|
tabcom.load(txtfile);
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool TInstallmodule_app::install_mod()
|
|
{
|
|
// ciclo su ogni ditta
|
|
TStd_filename txtfile(module_code());
|
|
txtfile << "tabmod.txt";
|
|
if (txtfile.check())
|
|
{
|
|
TString_array firms;
|
|
TPrefix::firms(firms);
|
|
|
|
FOR_EACH_ARRAY_ROW(firms, r, riga)
|
|
{
|
|
set_firm(atol(*riga));
|
|
TSystemisamfile tabmod(LF_TABMOD);
|
|
tabmod.load(txtfile);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void TInstallmodule_app::run(int argc, char* argv[])
|
|
{
|
|
TString title("Installazione ");
|
|
title << module_name();
|
|
TSkeleton_application::run(argc, argv,(const char* )title);
|
|
}
|
|
|
|
void TInstallmodule_app::set_tab_app(const char * appname)
|
|
{
|
|
TConfig ditta(CONFIG_DITTA);
|
|
ditta.set_paragraph(module_code());
|
|
ditta.set("TabApp",appname);
|
|
}
|