root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Patch level : 12.0 1090

Browse Source 
Files correlati     : fp0.exe f90500a.msk

Commento:
aggiunto programma di ripristino archiviazione
tolti i blocchi per rifare le archiviazione

Interno
ho trovato un sacco di errori nascosti sotto forma di memory fault. meglio fare un giro completo
This commit is contained in:
Alessandro Bonazzi 2022-09-12 23:27:30 +02:00
parent 4454eb8bb2
commit a22881ba03
13 changed files with 1549 additions and 1260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/f9/f90.cpp
View File

@ -8,11 +8,12 @@ int main(int argc, char** argv)
switch (r)
{
default:
case 0: rt = f90100(argc, argv); break; // Programma estrazione pacchetti
case 1: rt = f90200(argc, argv); break; // Tabella categorie documentali
case 2: rt = f90300(argc, argv); break; // Gestione documenti cartacei
case 3: rt = f90400(argc, argv); break; // Test classi
default:
case 0: rt = f90100(argc, argv); break; // Programma estrazione pacchetti
case 1: rt = f90200(argc, argv); break; // Tabella categorie documentali
case 2: rt = f90300(argc, argv); break; // Gestione documenti cartacei
case 3: rt = f90400(argc, argv); break; // Test classi
case 4: rt = f90500(argc, argv); break; // Ripristino archiviazioni
}
return rt;
}

1
src/f9/f90.h
View File

@ -5,5 +5,6 @@ int f90100(int argc, char* argv[]);
int f90200(int argc, char* argv[]);
int f90300(int argc, char* argv[]);
int f90400(int argc, char* argv[]);
int f90500(int argc, char* argv[]);
#endif // _F90_H_

290
src/f9/f90100.cpp
View File

@ -27,48 +27,10 @@
#define TAB_BASE_VERSION 100 // Versione base delle tabelle
#define SQL_VERSION 104 // Utilizzo questo per controllare la versione attuale delle tabelle e nel caso aggiornarle
////////////////////////////////////////////////////////
// Utilities
////////////////////////////////////////////////////////
TMask& descr_msk()
{
static TMask * m = nullptr;
if (m == nullptr)
{
m = new TMask("Estrazione", 1, 60, 5);
m->add_button_tool(DLG_OK, "Conferma", TOOL_OK);
m->add_groupbox(DES_GROUP, 0, "Inserire descrizione estrazione:", 1, 0, 59, 3, "");
m->add_string(DES_TEXT, 0, "Descrizione", 4, 1, 250, "", 40);
}
return *m;
}
TMask& esclusi_mask()
{
static TMask * _esclusi_mask = nullptr;
if (_esclusi_mask == nullptr)
{
_esclusi_mask = new TMask("f90100c.msk");
TMask& m = *_esclusi_mask;
((TSheet_field&)m.field(S_ESCL)).set_notify(TF9_app::select_escl_notify); // Handler dello sheet per selezione singola
m.set_handler(DLG_FINDREC, TF9_app::controllo_escl_handler); // Bottone per aprire maschera di controllo movimenti
m.set_handler(B_ESTRAI, TF9_app::estrai_escl_handler); // Bottone estrai
TMask& sheet_m = ((TSheet_field&)m.field(S_ESCL)).sheet_mask(); // Maschera dei campi dello sheet
sheet_m.set_handler(DLG_USER, TF9_app::mov_handler_escl); // Bottone collega movimento
m.field(DLG_FINDREC).disable();
}
return *_esclusi_mask;
}
////////////////////////////////////////////////////////
// TEstrai_mask
////////////////////////////////////////////////////////
int TEstrai_mask::estrai()
{
const TDate dataini = get_dataini();
@ -123,11 +85,8 @@ int TEstrai_mask::estrai()
// Se definitivo controllo il flag di stampato REGST
if ((flagpro || stampato) && numdoc.full() && iva == tipo)
{
// Creo il movimento da inserire
movimento_t t(mov, tipo, escluso);
// Effettivo inserimento del movimento
_estrazione->add_mov(t);
// Creo il movimento da inserire e lo inserisco
_estrazione->add_mov(new TMovimento_estr(mov, tipo, escluso));
++count;
}
}
@ -248,18 +207,17 @@ TEstrai_mask::TEstrai_mask() : TMask("Estrazione", 1, 60, 16), _estrazione(nullp
add_groupbox(ES_DESCGROUP, 0, "Inserire descrizione estrazione:", 1, 6, 59, 3, "");
add_string (ES_DESCR, 0, "Descrizione", 2, 7, 250, "", 40);
TMask::set_handler(DLG_ELABORA, estrai_handler);
TMask::set_handler(ES_DATAINI, dataini_handler);
TMask::set_handler(ES_DATAEND, dataend_handler);
set_handler(DLG_ELABORA, estrai_handler);
set_handler(ES_DATAINI, dataini_handler);
set_handler(ES_DATAEND, dataend_handler);
TDate dt(TODAY); dt.set_day(1); dt.set_month(1);
set(ES_DATAINI, dt);
set(ES_DATAEND, today);
}
////////////////////////////////////////////////////////
// TMonitor_mask
////////////////////////////////////////////////////////
@ -476,14 +434,13 @@ void TMonitor_mask::open_apri_estr_win()
if (last_fill_id != id)
{
_inclusi_mask = new TApri_estr_msk;
_inclusi_mask->set_from_row_estrazione(*row_estrazione);
_inclusi_mask.set_from_row_estrazione(*row_estrazione);
_inclusi_mask->fill_estr();
_inclusi_mask->fill_res ();
_inclusi_mask.fill_estr();
_inclusi_mask.fill_res ();
last_fill_id = id;
}
_inclusi_mask->run();
_inclusi_mask.run();
}
void TMonitor_mask::open_win_estr()
@ -495,32 +452,27 @@ void TMonitor_mask::open_win_estr()
void TMonitor_mask::open_win_conf()
{
static TMask* m = nullptr;
TMask m("Configurazione Archiviazione Sostitutiva", 1, 70, 20);
if (m == nullptr)
{
m = new TMask("Configurazione Archiviazione Sostitutiva", 1, 70, 20);
m.add_button_tool(DLG_OK, "Conferma", TOOL_OK);
m.add_button_tool(DLG_NULL, "", 0);
m.add_button_tool(DLG_QUIT, "Esci", TOOL_QUIT);
m->add_button_tool(DLG_OK, "Conferma", TOOL_OK);
m->add_button_tool(DLG_NULL, "", 0);
m->add_button_tool(DLG_QUIT, "Esci", TOOL_QUIT);
m.add_groupbox (CF_CODGROUP, 0, "Codice Ambiente Societa' (WEBAPP):", 1, 0, 69, 3, "");
m.add_string (CF_CODSOC, 0, "Codice ambiente ", 4, 1, 10, "", 10);
m.add_groupbox (CF_ADDRGROUP, 0, "Indicare percorso documenti cartacei:", 1, 3, 69, 4, "");
m.add_string (CF_ADDRDOC, 0, "Server ", 2, 4, 256, "", 40);
m.add_string (CF_ADDRDOCLOC, 0, "Locale ", 2, 5, 256, "", 40);
m.add_groupbox (CF_ESTRGROUP, 0, "Opzioni estrazione", 1, 7, 69, 4, "");
m.add_boolean (CF_CARTEXP, 0, "Estrai anche documenti cartacei", 2, 8);
m->add_groupbox (CF_CODGROUP, 0, "Codice Ambiente Societa' (WEBAPP):", 1, 0, 69, 3, "");
m->add_string (CF_CODSOC, 0, "Codice ambiente", 4, 1, 10, "", 10);
m->add_groupbox (CF_ADDRGROUP, 0, "Indicare percorso documenti cartacei:", 1, 3, 69, 4, "");
m->add_string (CF_ADDRDOC, 0, "Server", 2, 4, 256, "", 40);
m->add_string (CF_ADDRDOCLOC, 0, "Locale", 2, 5, 256, "", 40);
m->add_groupbox (CF_ESTRGROUP, 0, "Opzioni estrazione", 1, 7, 69, 4, "");
m->add_boolean (CF_CARTEXP, 0, "Estrai anche documenti cartacei", 2, 8);
m.set_handler(DLG_OK, save_conf_handler);
m->set_handler(DLG_OK, save_conf_handler);
m->set(CF_CODSOC, F9CONF.get_ambiente());
m->set(CF_ADDRDOC, F9CONF.get_addr_doc());
m->set(CF_ADDRDOCLOC, F9CONF.get_addr_doc_loc());
m->set(CF_CARTEXP, F9CONF.get_has_cartexp());
}
m->run();
m.set(CF_CODSOC, F9CONF.get_ambiente());
m.set(CF_ADDRDOC, F9CONF.get_addr_doc());
m.set(CF_ADDRDOCLOC, F9CONF.get_addr_doc_loc());
m.set(CF_CARTEXP, F9CONF.get_has_cartexp());
m.run();
}
void TMonitor_mask::sel() const
@ -534,7 +486,7 @@ void TMonitor_mask::sel() const
sf.force_update();
}
TMonitor_mask::TMonitor_mask(): TAutomask("f90100a"), _inclusi_mask(nullptr)
TMonitor_mask::TMonitor_mask() : TAutomask("f90100a")
{
// Controllo che esistano delle categorie documentali.
TCategorie_doc catdoc;
@ -592,7 +544,6 @@ void TControllo_mask::conferma_esclusi() const
if (sf.get_bool_row_cell(row, F_CESCLUDI))
{
const TDate today(TODAY);
TToken_string stato("", ';');
stato.add("", 0);
@ -643,7 +594,7 @@ void TControllo_mask::fill()
if (!_is_escluso)
import_error_list();
else
_controllo_mov = f9_app()._esclusi;
_controllo_mov = f9_app().esclusi();
FOR_EACH_ARRAY_ROW(_controllo_mov, r, row)
{
TToken_string& sfrow = sf.row(-1);
@ -879,7 +830,7 @@ TControllo_mask::TControllo_mask(const char* codsoc, const char* id_estr, const
if (!_is_escluso)
import_error_list();
else
_controllo_mov = f9_app()._esclusi;
_controllo_mov = f9_app().esclusi();
_datada = EOTIME;
_dataa = 0L;
FOR_EACH_ARRAY_ROW(_controllo_mov, r, row)
@ -972,11 +923,11 @@ void TApri_estr_msk::conferma_esclusi() const
FOR_EACH_SHEET_ROW_LOOP(sf, row)
{
const long nreg = sf.get_long_row_cell(row, FI_NUMREG);
TRectype & movs = (TRectype&)cache().get(LF_MOV, nreg);
TRectype & movs = (TRectype&)cache().get(LF_MOV, nreg);
const TString & da_escludere = sf.get_str_row_cell(row, FI_IESCLUDI);
if (sf.get_str_row_cell(row, FI_IESCLUDI) == "S")
if (da_escludere == "S")
{
const TDate today(TODAY);
TToken_string stato("", ';');
stato.add("", 0);
@ -1230,74 +1181,73 @@ void TF9_app::open_esclusi()
/* Prima chiedo quale mese e anno visualizzare
*/
// FINESTRA
static TMask* ym_msk = nullptr;
if (ym_msk == nullptr)
{
ym_msk = new TMask("Mostra esclusi", 1, 25, 16);
ym_msk->add_button_tool(DLG_OK, "Conferma", TOOL_OK);
ym_msk->add_button_tool(DLG_NULL, "", 0);
ym_msk->add_button_tool(DLG_QUIT, "Esci", TOOL_QUIT);
ym_msk->add_groupbox(507, 0, "Movimenti da visualizzare:", 0, 0, 25, 6);
ym_msk->add_number(501, 0, "Anno", 1, 1, 4);
ym_msk->add_list(502, 0, "Mese", 1, 2, 8, "", "01|02|03|04|05|06|07|08|09|10|11|12", "Gennaio|Febbraio|Marzo|Aprile|Maggio|Giugno|Luglio|Agosto|Settembre|Ottobre|Novembre|Dicembre");
ym_msk->add_list(503, 0, "Fino al", 1, 3, 9, "", " |01|02|03|04|05|06|07|08|09|10|11|12", " |Gennaio|Febbraio|Marzo|Aprile|Maggio|Giugno|Luglio|Agosto|Settembre|Ottobre|Novembre|Dicembre");
ym_msk->add_groupbox(506, 0, "Selezionare il tipo di estrazione", 0, 6, 25);
ym_msk->add_list(504, 0, "Flag Provvisorio", 1, 7, 1, "", "P|D", "Provvisorio|Definitivo");
ym_msk->add_list(505, 0, "Tipo doc.", 1, 4, 1, "", "A|V", "Acquisti|Vendite");
ym_msk->set(501, today.year());
ym_msk->set_handler(501, year_handler);
}
ym_msk->run();
if (ym_msk->last_key() == K_QUIT)
return;
TMask ym_msk("Mostra esclusi", 1, 25, 16);;
_flagprov_escl = ym_msk->get(504)[0];
_tipodoc_escl = ym_msk->get(505)[0];
ym_msk.add_button_tool(DLG_OK, "Conferma", TOOL_OK);
ym_msk.add_button_tool(DLG_NULL, "", 0);
ym_msk.add_button_tool(DLG_QUIT, "Esci", TOOL_QUIT);
ym_msk.add_groupbox(507, 0, "Movimenti da visualizzare:", 0, 0, 25, 6);
ym_msk.add_number(501, 0, "Anno", 1, 1, 4);
ym_msk.add_list(502, 0, "Mese", 1, 2, 8, "", "01|02|03|04|05|06|07|08|09|10|11|12", "Gennaio|Febbraio|Marzo|Aprile|Maggio|Giugno|Luglio|Agosto|Settembre|Ottobre|Novembre|Dicembre");
ym_msk.add_list(503, 0, "Fino al", 1, 3, 9, "", " |01|02|03|04|05|06|07|08|09|10|11|12", " |Gennaio|Febbraio|Marzo|Aprile|Maggio|Giugno|Luglio|Agosto|Settembre|Ottobre|Novembre|Dicembre");
ym_msk.add_groupbox(506, 0, "Selezionare il tipo di estrazione", 0, 6, 25);
ym_msk.add_list(504, 0, "Flag Provvisorio", 1, 7, 1, "", "P|D", "Provvisorio|Definitivo");
ym_msk.add_list(505, 0, "Tipo doc.", 1, 4, 1, "", "A|V", "Acquisti|Vendite");
ym_msk.set(501, today.year());
ym_msk.set_handler(501, year_handler);
if (ym_msk.run() == K_ENTER)
{
_flagprov_escl = ym_msk.get(504)[0];
_tipodoc_escl = ym_msk.get(505)[0];
/* Caricamento esclusi
* LOADING DI QUEL MESE E ANNO */
f9_app()._esclusi_vect.destroy();
const int anno = ym_msk->get_int(501);
const int mese = ym_msk->get_int(502);
const int to_m = ym_msk->get_int(503);
TLocalisamfile movs(LF_MOV);
movs.setkey(2);
const TDate from(1, mese, anno);
TDate to(from);
if (to_m != 0)
to.set_month(to_m);
to.set_end_month();
/* Caricamento esclusi
* LOADING DI QUEL MESE E ANNO */
f9_app()._esclusi_vect.destroy();
const int anno = ym_msk.get_int(501);
const int mese = ym_msk.get_int(502);
const int to_m = ym_msk.get_int(503);
movs.put(MOV_DATAREG, from);
movs.read();
if (movs.get_date(MOV_DATAREG) >= from && movs.get_date(MOV_DATAREG) <= to)
{
for (bool ok = true; ok && movs.get_date(MOV_DATAREG) <= to; ok = movs.next() == NOERR)
{
TToken_string stato(movs.get(MOV_ELABF9), ';');
if (stato.items() == 3 && stato.get(2)[0] == 'X')
{
TToken_string m("", '|');
m.add("", 0);
m.add(movs.get_int(MOV_NUMREG));
m.add(movs.get_date(MOV_DATAREG));
m.add(movs.get_date(MOV_DATADOC));
m.add(movs.get(MOV_CODCAUS));
m.add(movs.get(MOV_MESELIQ));
TString numdoc; numdoc << movs.get(MOV_NUMDOCEXT);
m.add(numdoc.full() ? numdoc : movs.get(MOV_NUMDOC));
const real imptot = movs.get_real(MOV_TOTDOC) + movs.get_real(MOV_RITFIS) + movs.get_real(MOV_RITSOC);
m.add(imptot);
m.add(movs.get_int(MOV_CODCF));
TLocalisamfile clifo(LF_CLIFO);
clifo.put(CLI_TIPOCF, movs.get(MOV_TIPO));
clifo.put(CLI_CODCF, movs.get(MOV_CODCF));
m.add(clifo.read() == NOERR ? clifo.get(CLI_RAGSOC) : "");
m.add(TString(movs.get(MOV_REG)) << "/" << movs.get(MOV_PROTIVA));
m.add(movs.get(MOV_DESCR));
f9_app()._esclusi_vect.add(m);
}
}
TLocalisamfile movs(LF_MOV);
movs.setkey(2);
const TDate from(1, mese, anno);
TDate to(from);
if (to_m != 0)
to.set_month(to_m);
to.set_end_month();
movs.put(MOV_DATAREG, from);
movs.read();
if (movs.get_date(MOV_DATAREG) >= from && movs.get_date(MOV_DATAREG) <= to)
{
for (bool ok = true; ok && movs.get_date(MOV_DATAREG) <= to; ok = movs.next() == NOERR)
{
TToken_string stato(movs.get(MOV_ELABF9), ';');
if (stato.items() == 3 && stato.get(2)[0] == 'X')
{
TToken_string m("", '|');
m.add("", 0);
m.add(movs.get_int(MOV_NUMREG));
m.add(movs.get_date(MOV_DATAREG));
m.add(movs.get_date(MOV_DATADOC));
m.add(movs.get(MOV_CODCAUS));
m.add(movs.get(MOV_MESELIQ));
TString numdoc; numdoc << movs.get(MOV_NUMDOCEXT);
m.add(numdoc.full() ? numdoc : movs.get(MOV_NUMDOC));
const real imptot = movs.get_real(MOV_TOTDOC) + movs.get_real(MOV_RITFIS) + movs.get_real(MOV_RITSOC);
m.add(imptot);
m.add(movs.get_int(MOV_CODCF));
TLocalisamfile clifo(LF_CLIFO);
clifo.put(CLI_TIPOCF, movs.get(MOV_TIPO));
clifo.put(CLI_CODCF, movs.get(MOV_CODCF));
m.add(clifo.read() == NOERR ? clifo.get(CLI_RAGSOC) : "");
m.add(TString(movs.get(MOV_REG)) << "/" << movs.get(MOV_PROTIVA));
m.add(movs.get(MOV_DESCR));
f9_app()._esclusi_vect.add(m);
}
}
}
}
if (f9_app()._esclusi_vect.empty())
@ -1315,9 +1265,9 @@ void TF9_app::open_esclusi()
void TF9_app::fill_esclusi()
{
TArray & esclusi = f9_app()._esclusi_vect;
TSheet_field& sf = esclusi_mask().sfield(S_ESCL);
TSheet_field& sf = _esclusi_mask->sfield(S_ESCL);
sf.destroy();
sf.reset();
FOR_EACH_ARRAY_ROW(esclusi, r, row)
sf.row(-1) = *row;
sf.force_update();
@ -1334,7 +1284,7 @@ bool TF9_app::estrai_escl_handler(TMask_field&, KEY key)
descr_mask.add_string(DES_TEXT, 0, "Descrizione", 4, 1, 250, "", 40);
if (descr_mask.run() == K_ENTER)
{
TMask& msk = esclusi_mask();
TMask& msk = *f9_app()._esclusi_mask;
TArray & _esclusi = f9_app()._esclusi_vect;
TSheet_field& sf = msk.sfield(S_ESCL);
const TString descr = descr_mask.get(DES_TEXT);
@ -1351,14 +1301,14 @@ bool TF9_app::estrai_escl_handler(TMask_field&, KEY key)
{
if (sf.get_bool_row_cell(row, FE_SEL))
{
const movimento_t mov = f9_app().escl2mov(sf, row);
TMovimento_estr * mov = f9_app().escl2mov(sf, row);
f9_app()._estr_escluso->add_mov(mov);
_stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
const int stato = f9_app()._estr_escluso->estrai();
if (stato == 1)
{
_esclusi.destroy(row); // Tolto il movimento estratto dal vettore e setto come estratto su elabf9 di mov
f9_app().segna_estratti(true, mov.numreg());
f9_app().segna_estratti(true, mov->numreg());
}
flag = true;
break;
@ -1368,14 +1318,14 @@ bool TF9_app::estrai_escl_handler(TMask_field&, KEY key)
message_box("Selezionare il movimento da estrarre");
else
f9_app().print_log();
fill_esclusi();
f9_app().fill_esclusi();
}
return true;
}
bool TF9_app::mov_handler_escl(TMask_field& f, KEY key)
{
TSheet_field& sf = esclusi_mask().sfield(S_ESCL);
TSheet_field& sf = f9_app().esclusi_mask().sfield(S_ESCL);
TToken_string& row = sf.row(sf.selected());
TRectype mov(LF_MOV);
mov.put(MOV_NUMREG, row.get(sf.cid2index(FE_NUMREG)));
@ -1411,10 +1361,10 @@ bool TF9_app::is_autofattura(const TLocalisamfile& mov)
bool TF9_app::segna_estratti(const bool escluso, const int numreg)
{
bool ok = true;
TArray escl; // <movimento_t>
TArray escl; // <TMovimento_estr>
if (escluso)
escl.add(movimento_t(numreg)); // todo: datareg?
escl.add(TMovimento_estr(numreg)); // todo: datareg?
TArray& movs_v = escluso ? escl : _movs;
TToken_string elab("X", ';'); // "[flag estratto];
@ -1422,7 +1372,7 @@ bool TF9_app::segna_estratti(const bool escluso, const int numreg)
elab.add(today.date2ansi()); elab.add(" "); // "[flag estratto];[data estrazione];[flag escluso]"
FOR_EACH_ARRAY_ITEM(movs_v, r, obj)
{
const movimento_t & t = (movimento_t &) *obj;
const TMovimento_estr & t = (TMovimento_estr &) *obj;
TRectype& mov = (TRectype&) cache().get(LF_MOV, t.numreg());
mov.put(MOV_ELABF9, elab);
@ -1573,27 +1523,21 @@ void TF9_app::main_loop()
{
if (!check_table())
fatal_box("Controllo tabelle modulo fallito.");
#ifdef DBG
//pulisci_mov();
#endif
_esclusi_mask = new TMask("f90100c.msk", 0, 1);
_msk = new TMonitor_mask;
_estr_msk = new TEstrai_mask;
_esclusi_mask->sfield(S_ESCL).set_notify(select_escl_notify); // Handler dello sheet per selezione singola
_esclusi_mask->set_handler(DLG_FINDREC, controllo_escl_handler); // Bottone per aprire maschera di controllo movimenti
_esclusi_mask->set_handler(B_ESTRAI, estrai_escl_handler); // Bottone estrai
TMask& sheet_m = _esclusi_mask->sfield(S_ESCL).sheet_mask(); // Maschera dei campi dello sheet
sheet_m.set_handler(DLG_USER, mov_handler_escl); // Bottone collega movimento
_esclusi_mask->field(DLG_FINDREC).disable();
_estr_msk = new TEstrai_mask;
_msk = new TMonitor_mask;
while (_msk->run() != K_QUIT) { }
/*delete _msk;
delete _estr_msk;*/
}
TF9_app::TF9_app()
: _estr_msk(nullptr), _msk(nullptr), _mov_escl("", '|'),
_tipodoc_escl('A'), _flagprov_escl('P'), _estr_escluso(nullptr)
{ }
int f90100(const int argc, char* argv[])
{
TF9_app app;

225
src/f9/f90100.h
View File

@ -43,22 +43,107 @@ public:
~TEstrai_mask() { safe_delete(_estrazione); };
};
class TApri_estr_msk : public TAutomask
{
TString _idestr;
TDate _dataestr;
bool _provv;
char _tipodoc;
TString _statoestr;
TDate _datadal;
TDate _dataal;
bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
bool inall_handler() const;
bool inescludi_handler() const;
bool inselect_handler() const;
void conferma_esclusi() const;
public:
void fill_estr() const;
void fill_res() const;
void set_from_row_estrazione(TToken_string& row_estrazione);
TApri_estr_msk();
~TApri_estr_msk() {}
};
class TMonitor_mask : public TAutomask
{
// friend class TF9_app;
TString_array _fppro;
TApri_estr_msk _inclusi_mask;
// Configurazione mask
static bool save_conf_handler(TMask_field& f, KEY key);
// Metodi per la maschera 'Apri Estr.'
void open_apri_estr_win();
// Controllo estr. mask
void controllo_errori() const;
static void delete_estr_fld(const TString& idestr);
void delete_pack(bool all = false) const;
bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
static void open_win_estr();
static void open_win_conf();
void sel() const;
public:
// Riempie sheet per visualizzare le estrazioni
void fill() const;
TMonitor_mask();
~TMonitor_mask() {}
};
class TControllo_mask : public TAutomask
{
TArray _controllo_mov; // Usare import_error_list().
char _ordin;
char _verso;
int _selected_mov;
bool _sel_esclusi;
bool _is_escluso;
TString _cod_soc;
TString _id_estr;
char _tipo_doc_err{};
TDate _datada;
TDate _dataa;
void associa();
void conferma_esclusi() const;
TArray& import_error_list();
void fill();
void fill_fppro_sheet() const;
TMask& get_win_order();
void open_win_order();
TToken_string* selected_mov();
TToken_string* selected_fat() const;
/** Gestisce la selezione multipla negli sheet di controllo movimenti */
void selfatt(TOperable_field& o, long jolly) const;
bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
public:
TControllo_mask(const char* codsoc, const char* id_estr, bool esclusi = false);
};
class TF9_app : public TSkeleton_application
{
//friend class TEstrai_mask;
friend class TMonitor_mask;
{
// friend class TMonitor_mask;
friend class TEstrai_mask;
friend class TControllo_mask;
friend class TApri_estr_msk;
// friend class TControllo_mask;
// friend class TApri_estr_msk;
friend class TEstrazione;
TEstrai_mask * _estr_msk;
TMonitor_mask * _msk;
TArray _movs; // movimento_t
TMask * _esclusi_mask;
TEstrai_mask * _estr_msk;
TMonitor_mask * _msk;
TArray _movs; // TMovimento_estr
TArray _esclusi; // Vettore con i movimenti esclusi
TArray _esclusi_vect;
TToken_string _mov_escl;
@ -69,15 +154,16 @@ class TF9_app : public TSkeleton_application
char get_tipodoc_escl() const { return _tipodoc_escl; }
TipoIVA get_tipoiva_escl() const { return get_tipodoc_escl() == 'A' ? iva_acquisti : iva_vendite; }
// Dato il codice stato estrazione (es. "01") viene restituito il suo significato a parole (es. "in diagnostica").
static const char* traduci_stato(const TString& cod);
static bool is_stato_errore(const TString& stato_etr);
TMask & esclusi_mask() { return *_esclusi_mask; }
public:
TArray & esclusi() { return _esclusi; }
TipoIVA get_tipoiva_escl() const { return get_tipodoc_escl() == 'A' ? iva_acquisti : iva_vendite; }
static const char* traduci_stato(const TString& cod);
static bool is_stato_errore(const TString& stato_etr);
/** Mostra la finestrella per l'inserimento delle opzioni per l'estrazione e avviarla. */
void run_estr_msk() const { _estr_msk->run(); }
void run_estr_msk() { _estr_msk->run(); }
void notify_estraction() const;
// Estrazione esclusi - handlers
@ -88,9 +174,9 @@ public:
static bool estrai_escl_handler(TMask_field&, KEY key);
void open_esclusi();
static void fill_esclusi();
void fill_esclusi();
movimento_t TF9_app::escl2mov(TSheet_field & sf, int row) { return movimento_t(sf, row); }
TMovimento_estr * TF9_app::escl2mov(TSheet_field & sf, int row) { return new TMovimento_estr(sf, row); }
static bool mov_handler_escl(TMask_field&, KEY key);
@ -119,113 +205,18 @@ private:
public:
void main_loop() override;
TF9_app();
~TF9_app() { safe_delete(_estr_msk); safe_delete(_msk); }
TF9_app::TF9_app() : _mov_escl("", '|'), _tipodoc_escl('A'), _flagprov_escl('P'), _estr_escluso(nullptr) {}
~TF9_app() { safe_delete(_esclusi_mask); safe_delete(_estr_msk); }
};
inline TF9_app& f9_app()
{
static TF9_app* app = nullptr;
if (app == nullptr)
app = (TF9_app*)&main_app();
return *app;
static TF9_app* app = nullptr;
if (app == nullptr)
app = (TF9_app*)&main_app();
return *app;
}
class TApri_estr_msk;
class TMonitor_mask : public TAutomask
{
friend class TF9_app;
vector<TToken_string> _fppro;
TApri_estr_msk * _inclusi_mask;
// Configurazione mask
static bool save_conf_handler(TMask_field& f, KEY key);
// Metodi per la maschera 'Apri Estr.'
void open_apri_estr_win();
// Controllo estr. mask
void controllo_errori() const;
static void delete_estr_fld(const TString& idestr);
void delete_pack(bool all = false) const;
// Riempie sheet per visualizzare le estrazioni
void fill() const;
bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
static void open_win_estr();
static void open_win_conf();
void sel() const;
public:
TMonitor_mask();
~TMonitor_mask() { safe_delete(_inclusi_mask); }
};
class TControllo_mask : public TAutomask
{
TArray _controllo_mov; // Usare import_error_list().
char _ordin;
char _verso;
int _selected_mov;
bool _sel_esclusi;
bool _is_escluso;
TString _cod_soc;
TString _id_estr;
char _tipo_doc_err{};
TDate _datada;
TDate _dataa;
void associa();
void conferma_esclusi() const;
TArray& import_error_list();
void fill();
void fill_fppro_sheet() const;
TMask& get_win_order();
void open_win_order();
TToken_string* selected_mov();
TToken_string* selected_fat() const;
/** Gestisce la selezione multipla negli sheet di controllo movimenti */
void selfatt(TOperable_field& o, long jolly) const;
bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
public:
TControllo_mask(const char* codsoc, const char* id_estr, bool esclusi = false);
};
class TApri_estr_msk : public TAutomask
{
TString _idestr;
TDate _dataestr;
bool _provv;
char _tipodoc;
TString _statoestr;
TDate _datadal;
TDate _dataal;
bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
bool inall_handler() const;
bool inescludi_handler() const;
bool inselect_handler() const;
void conferma_esclusi() const;
public:
void fill_estr() const;
void fill_res() const;
void set_from_row_estrazione(TToken_string& row_estrazione);
TApri_estr_msk();
};
inline bool open_mov(const TRectype& mov)
{
TFilename ininame; ininame.temp("lnk", "ini");

53
src/f9/f90200.cpp
View File

@ -36,7 +36,7 @@ public:
class TF9_categorie_doc_msk : public TAutomask
{
std::shared_ptr<TArray_sheet> _annessi_sheet;
TArray_sheet * _annessi_sheet;
TCategorie_doc _categorie_doc;
bool _mod_precaricate;
@ -143,21 +143,21 @@ void TF9_categorie_doc_msk::check_spell() const
void TF9_categorie_doc_msk::check_duplicate_tipodoc() const
{
TSheet_field& sf = sfield(S_CLASSDOC);
map<TString, int> lookup_table;
vector<TString> dup;
FOR_EACH_SHEET_ROW(sf, nr, row)
TString_array lookup_table;
TString_array dup;
FOR_EACH_SHEET_ROW_LOOP(sf, nr)
{
if(TString(row->get(5)).empty()) // Se non ha specificato una causale
const TString & caus = sf.get_str_row_cell(nr, F_CAUSCONT);
if (caus.blank()) // Se non ha specificato una causale
{
const char* tipodoc = row->get(6);
auto it = lookup_table.find({ tipodoc });
if (it == lookup_table.end()) // Se non lo trovo vuol dire che e' il primo.
lookup_table.insert({ tipodoc, 0 });
const TString & tipodoc = sf.get_str_row_cell(nr, F_TIPOCAUSCONT);
if (lookup_table.find(tipodoc) < 0) // Se non lo trovo vuol dire che e' il primo.
lookup_table.add(tipodoc);
else
{
++it->second;
dup.emplace_back(it->first);
}
dup.add(tipodoc);
}
}
if (!dup.empty() && !_mod_precaricate)
@ -186,15 +186,19 @@ void TF9_categorie_doc_msk::edit_annesso(const TString& catdoc_padre)
{
TString title; title << "Modifica annesso per " << catdoc_padre;
TNew_annesso_msk new_ann(title);
new_ann.edit_mode();
TToken_string& r = _annessi_sheet->row(_annessi_sheet->selected());
new_ann.fill_field(r.get(0), r.get(1), r.get(2), r.get_bool(3));
if (new_ann.run() == K_ENTER)
{
const TString& catann = new_ann.get(101);
const TString& descr = new_ann.get(102);
const TString& tipo = new_ann.get(103);
const bool obblig = new_ann.get_bool(104);
const bool obblig = new_ann.get_bool(104);
_categorie_doc.edit_annesso(catdoc_padre, catann, descr, tipo, obblig);
fill_annessi(catdoc_padre);
}
@ -211,9 +215,9 @@ void TF9_categorie_doc_msk::fill_annessi(const TString& catdoc)
void TF9_categorie_doc_msk::load_table() const
{
TSheet_field& sf = sfield(S_CLASSDOC);
sf.hide();
sf.destroy();
int idx = 0;
int idx = 0;
sf.reset();
while (true)
{
TToken_string appo(ini_get_string(CONFIG_DITTA, "F9", "CATDOC", "", idx++));
@ -222,9 +226,7 @@ void TF9_categorie_doc_msk::load_table() const
TToken_string& row = sf.row(-1);
row = appo;
}
sf.show();
sf.force_update();
check_duplicate_tipodoc();
}
@ -232,22 +234,27 @@ void TF9_categorie_doc_msk::new_annesso(const TString& catdoc_padre)
{
_categorie_doc.reload();
TString title;
title << "Nuovo annesso per " << catdoc_padre;
TNew_annesso_msk new_ann(title);
while (new_ann.run() == K_ENTER)
{
TString catann = new_ann.get(101);
if (catann.empty())
{
warning_box("Inserire il nome tipo annesso");
continue;
}
TCategorie_doc::annesso ann;
if (!_categorie_doc.annesso_exist(catdoc_padre,catann))
if (!_categorie_doc.annesso_exist(catdoc_padre,catann))
{
const TString& descr = new_ann.get(102);
const TString& tipo = new_ann.get(103);
const bool obblig = new_ann.get_bool(104);
correct_spell_catdoc(catann);
_categorie_doc.add_annesso(catdoc_padre, catann, descr, tipo, obblig);
fill_annessi(catdoc_padre);
@ -270,10 +277,12 @@ void TF9_categorie_doc_msk::salva_tabella() const
}
idx = 0;
TSheet_field& sf = sfield(S_CLASSDOC);
FOR_EACH_SHEET_ROW(sf, nr, row)
{
if(row->get(1) && TString(row->get(1)).full())
if(row->get(1) && *row->get(1))
ini_set_string(CONFIG_DITTA, "F9", "CATDOC", *row, idx++);
}
ini_set_string(CONFIG_DITTA, "F9", "CATDOC", "STOP", idx); // Riga terminatrice

303
src/f9/f90300.cpp
View File

@ -1,9 +1,4 @@
#include "f90.h"
#include <Windows.h>
#include <set>
#include <map>
#include "annessif9.h" // File 183
#include "applicat.h"
#include "automask.h"
@ -27,7 +22,7 @@ class TImport_msk : public TAutomask
{
friend class TGestione_doc_cartacei_f9_msk;
map<TString, unique_ptr<TArray_sheet>> _annessi;
// map<TString, unique_ptr<TArray_sheet>> _annessi;
bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
@ -58,10 +53,12 @@ bool TImport_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
case F_IMPNUMREG:
if(e == fe_modify)
{
const TCategorie_doc::classe_doc* c = TCategorie_doc().mov2cat(o.get_int());
TCategorie_doc cd;
TClasse_doc* c = cd.mov2cat(o.get_int());
if (c != nullptr)
{
set(F_CATANNPADRE, c->catdoc);
set(F_CATANNPADRE, c->catdoc());
set(F_CATDOCANN, "");
}
else
@ -81,13 +78,15 @@ bool TImport_msk::catdocann_handler(TMask_field& field, KEY key)
static const char* msg_notexist = "Non esistono tipologie di annessi per questa categoria documentale.";
static const char* msg_inspadre = "Questa registrazione non e' riconosciuta in nessuna categoria documentale.\nImpossible inserire un annesso.\n"
"Si prega di inserire prima una cat. documentale che comprenda questo tipo di registrazione\naggiungendo anche eventuali tipologie di annessi.";
TCategorie_doc cd;
TImport_msk& msk = (TImport_msk&)field.mask();
if (key == K_TAB && field.dirty() && field.full())
{
if (msk.get(F_CATANNPADRE).full())
{
TCategorie_doc cd;
const TString_array names_ann = cd.get_array_ann(msk.get(F_CATANNPADRE));
if (names_ann.items() > 0)
{
bool ok = false;
@ -113,22 +112,24 @@ bool TImport_msk::catdocann_handler(TMask_field& field, KEY key)
}
if (key == K_F9)
{
const TString & catdoc_padre = msk.get(F_CATANNPADRE);
if (catdoc_padre.full())
const TString & catdoc_padre = msk.get(F_CATANNPADRE);
if (catdoc_padre.full())
{
TArray_sheet* annessi = cd.get_sheet_ann(msk.get(F_CATANNPADRE)).get();
TCategorie_doc cd;
TArray_sheet * annessi = cd.get_sheet_ann(msk.get(F_CATANNPADRE));
if (annessi && annessi->items() > 0)
{
if (annessi->run() == K_ENTER)
{
const char* s = annessi->row(annessi->selected()).get(0);
TCategorie_doc::annesso annesso;
TAnnesso * ann = cd.get_ann(catdoc_padre, s);
if (cd.get_ann(catdoc_padre,s, annesso))
if (ann != nullptr)
{
if (annesso.opcee != "RC")
msk.set(F_CATDOCANN, annesso.catdoc);
if (ann->opcee() != "RC")
msk.set(F_CATDOCANN, ann->catdoc());
else
warning_box("Impossibile importare un annesso cartaceo per un prospetto integrativo per Reverse Charge.");
}
@ -149,11 +150,13 @@ bool TImport_msk::catannpadre_handler(TMask_field& field, KEY key)
{
TCategorie_doc cd;
TImport_msk& msk = (TImport_msk&)field.mask();
if (key == K_TAB && field.dirty() && field.full())
{
std::set<TString>& name_cats = cd.get_name_catdocs();
TString_array * name_cats = cd.get_name_catdocs();
const bool ok = name_cats.find(field.get()) != name_cats.end();
const bool ok = name_cats->find(field.get()) >= 0;
if (!ok)
{
msk.error_box("La categoria inserita e' inesistente");
@ -176,7 +179,7 @@ bool TImport_msk::ok_handler(TMask_field& field, KEY key)
const char* TImport_msk::select_catdoc()
{
auto catdocs = TCategorie_doc().get_sheet_catdocs();
TArray_sheet * catdocs = TCategorie_doc().get_sheet_catdocs();
if (catdocs->run() == K_ENTER)
return catdocs->row().get(0);
return "";
@ -207,7 +210,7 @@ TImport_msk::TImport_msk(): TAutomask("f90300b")
class TGestione_doc_cartacei_f9_msk : public TAutomask
{
struct doc_cart_t
/* struct doc_cart_t
{
TString filename;
TString loaddate;
@ -222,13 +225,12 @@ class TGestione_doc_cartacei_f9_msk : public TAutomask
TString catdocann;
TString loaddate;
TString user;
};
const TString& _addr_cart; // Indirizzo cartella doc. cartacei F9
std::unique_ptr<TMask> _config_msk;
std::unique_ptr<std::set<TString>> _extensions; // todo: controllare che con TString funzioni l'ordinamento, quindi la find
std::unique_ptr<TImport_msk> _import_msk;
std::map<TString, doc_cart_t> _list_file;
std::map<TString, ann_cart_t> _list_ann;
}; */
const TString& _addr_cart; // Indirizzo cartella doc. cartacei F9
// TMask * _config_msk;
TString_array _extensions;
// TAssoc_array _list_file; // doc_cart_t
// TAssoc_array _list_ann; // ann_cart_t
bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
@ -243,10 +245,11 @@ class TGestione_doc_cartacei_f9_msk : public TAutomask
void fill_docs();
static TToken_string& get_valid_extensions();
void load_extensions();
static bool load_file(const TFilename& file, const TString& numreg, bool is_annesso, const TString& catannpadre, const TString& catdocann);
bool load_file(const TFilename& file, long numreg, const bool is_annesso, const TString& catannpadre, const TString& catdocann)
{ return TF9_doccart::add_cart(file, numreg, is_annesso, catannpadre, catdocann, false); }
void open_config_win();
void open_import_win();
static void remove_file_from_f9cart(const std::set<TString>& files);
static void remove_file_from_f9cart(const TString_array & files);
bool verify_extension(const TFilename& file);
public:
@ -414,6 +417,7 @@ void TGestione_doc_cartacei_f9_msk::edit_file()
{
TToken_string& row = sfield(S_IMPORTED).row(sfield(S_IMPORTED).selected());
TImport_msk win;
win.set_caption("Modifica documento cartaceo");
TLocalisamfile f9docs(LF_F9DOCS);
const char* numreg = row.get(2);
@ -443,61 +447,63 @@ void TGestione_doc_cartacei_f9_msk::fill()
void TGestione_doc_cartacei_f9_msk::fill_annessi()
{
std::set<TString> file_err;
TString_array file_err;
TSheet_field& sf = sfield(S_ANNESSI);
sf.hide();
sf.destroy();
TLocalisamfile ann(LF_F9ANNESSI);
TLocalisamfile ann(LF_F9ANNESSI);
sf.reset();
if(ann.first() == NOERR)
{
const TString& namefile = ann.get(F9A_FILENAME);
const bool not_exist = !check_file_exist(namefile);
if (not_exist)
file_err.insert(namefile);
TLocalisamfile mov(LF_MOV);
do
{
TToken_string& row = sf.row(-1);
const TString& numreg = ann.get(F9A_NUMREG);
{
const TString& namefile = ann.get(F9A_FILENAME);
const long numreg = ann.get_long(F9A_NUMREG);
const TRectype & mov = cache().get(LF_MOV, numreg);
const bool not_exist = !check_file_exist(namefile);
mov.put(MOV_NUMREG, numreg);
mov.read();
if (not_exist)
file_err.add(namefile, numreg);
row.add(ann.get(F9A_FILENAME), 1); // ITEM "Nome File@25"
row.add(ann.get(F9A_CATDOCPAD)); // ITEM "Categoria di\nappartenenza@7"
row.add(ann.get(F9A_CATDOCANN)); // ITEM "Classe doc.\nannesso@7"
row.add(numreg); // ITEM "Movimento\nContabile N.@7"
row.add(mov.get(MOV_DATAREG)); // ITEM "Data\nMovimento@10"
row.add(mov.get(MOV_CODCAUS)); // ITEM "Causale@7"
row.add(mov.get(MOV_NUMDOC)); // ITEM "Num. Doc.@7"
row.add(TString(mov.get(MOV_REG)) << "/" << mov.get(MOV_PROTIVA)); // ITEM "Reg./Prot. IVA@10"
row.add(mov.get(MOV_DESCR)); // ITEM "Descrizione@20"
row.add(ann.get(F9A_LOADDATE)); // ITEM "Data\nCaricamento@10"
row.add(not_exist ? "IL FILE NON E' PRESENTE IN ARCHIVIO." : ""); // ITEM "Info (Errori)@25"
const int row = sf.set_row_cell(F_AFILENAME, ann.get(F9A_FILENAME)); // ITEM "Nome File@25"
_list_ann.insert({ namefile, { numreg, namefile, ann.get(F9A_CATDOCPAD), ann.get(F9A_CATDOCANN), ann.get(F9C_LOADDATE), ann.get(F9C_USER) } });
sf.set_row_cell(F_ACATPADRE, ann.get(F9A_CATDOCPAD), row); // ITEM "Categoria di\nappartenenza@7"
sf.set_row_cell(F_ACATANN, ann.get(F9A_CATDOCANN), row); // ITEM "Classe doc.\nannesso@7"
sf.set_row_cell(F_ANUMREG, numreg, row); // ITEM "Movimento\nContabile N.@7"
sf.set_row_cell(F_ADATAMOV, mov.get(MOV_DATAREG), row); // ITEM "Data\nMovimento@10"
sf.set_row_cell(F_ACAUS, mov.get(MOV_CODCAUS), row); // ITEM "Causale@7"
sf.set_row_cell(F_ANUMDOC, mov.get(MOV_NUMDOC), row); // ITEM "Num. Doc.@7"
TString nprot;
nprot << mov.get(MOV_REG) << "/" << mov.get(MOV_PROTIVA);
sf.set_row_cell(F_ANPROTOCOL, nprot, row); // ITEM "Reg./Prot. IVA@10"
sf.set_row_cell(F_ADESCRMOV, mov.get(MOV_DESCR), row); // ITEM "Descrizione@20"
sf.set_row_cell(F_ADATACARIC, ann.get(F9A_LOADDATE), row); // ITEM "Data\nCaricamento@10"
sf.set_row_cell(F_AINFO, not_exist ? "IL FILE NON E' PRESENTE IN ARCHIVIO." : "", row); // ITEM "Info (Errori)@25"
// _list_ann.add( namefile, { numreg, namefile, ann.get(F9A_CATDOCPAD), ann.get(F9A_CATDOCANN), ann.get(F9C_LOADDATE), ann.get(F9C_USER) });
} while (ann.next() == NOERR);
}
sf.force_update();
sf.show();
if (!file_err.empty())
{
int count = 0;
const bool m = (int)file_err.size() == 1;
const bool m = (int)file_err.items() == 1;
const char p = m ? 'o' : 'i';
TString msg; msg << (int)file_err.size() << " file non " << (m ? "e'" : "sono") << " stat" << p <<
" trovat" << p << ".\nSi prega di rimuoverl" << p << " dall'elenco\n\nFile non trovat" << p << ":";
for (auto it = file_err.begin(); it != file_err.end(); ++it)
FOR_EACH_ARRAY_ROW(file_err, nr, str)
{
if (count++ == 10)
{
msg << "\n" << "...";
break;
}
msg << "\n" << *it << " [Num. Reg.: " << _list_ann.find(*it)->second.numreg << "]";
msg << "\n" << (TString &) *str << " [Num. Reg.: " << nr << "]";
}
warning_box(msg);
}
@ -508,66 +514,57 @@ void TGestione_doc_cartacei_f9_msk::fill_docs()
TLocalisamfile files(LF_F9DOCS);
TLocalisamfile mov(LF_MOV);
TSheet_field& sf = sfield(S_IMPORTED);
sf.hide();
sf.destroy();
_list_file.clear();
std::set<TString> file_err;
if (files.first() == NOERR)
{
do
{
const TString& namefile = files.get(F9C_FILENAME);
const bool not_exist = !check_file_exist(namefile);
if (not_exist)
file_err.insert(namefile);
const TString& numreg = files.get(F9C_NUMREG);
TString datamov, caus, numdoc, nprot, descrmov;
mov.zero();
mov.put(MOV_NUMREG, numreg);
if (mov.read() == NOERR)
{
datamov = mov.get(MOV_DATAREG);
caus = mov.get(MOV_CODCAUS);
numdoc = mov.get(MOV_NUMDOCEXT);
if (numdoc.empty()) numdoc = mov.get(MOV_NUMDOC);
nprot << mov.get(MOV_REG) << "/" << mov.get(MOV_PROTIVA);
descrmov = mov.get(MOV_DESCR);
}
TToken_string& r = sf.row(-1);
r.add(" ", 0); // F_SEL
r.add(namefile); // F_FILENAME
r.add(numreg); // F_NUMREG
r.add(datamov); // F_DATAMOV
r.add(caus); // F_CAUS
r.add(numdoc); // F_NUMDOC
r.add(nprot); // F_NPROTOCOL
r.add(descrmov); // F_DESCRMOV
r.add(files.get(F9C_LOADDATE)); // F_DATACARIC
r.add(not_exist ? "IL FILE NON E' PRESENTE IN ARCHIVIO." : ""); // F_INFO
TString_array file_err;
_list_file.insert({ namefile, { namefile, files.get(F9C_LOADDATE), numreg, files.get(F9C_USER) } });
} while (files.next() == NOERR);
sf.reset();
for (int err = files.first(); err == NOERR; err = files.next())
{
const TString& namefile = files.get(F9C_FILENAME);
const long numreg = files.get_long(F9C_NUMREG);
const TRectype & mov = cache().get(LF_MOV, numreg);
const bool not_exist = !check_file_exist(namefile);
if (not_exist)
file_err.add(namefile, numreg);
const int row = sf.set_row_cell(F_FILENAME, namefile);
sf.set_row_cell(F_NUMREG, numreg, row);
sf.set_row_cell(F_DATAMOV, mov.get_date(MOV_DATAREG), row);
sf.set_row_cell(F_CAUS, mov.get(MOV_CODCAUS), row);
TString nprot, numdoc = mov.get(MOV_NUMDOCEXT);
if (numdoc.empty())
numdoc = mov.get(MOV_NUMDOC);
sf.set_row_cell(F_NUMDOC, numdoc, row);
nprot << mov.get(MOV_REG) << "/" << mov.get(MOV_PROTIVA);
sf.set_row_cell(F_NPROTOCOL, nprot, row);
sf.set_row_cell(F_DESCRMOV, mov.get(MOV_DESCR), row);
sf.set_row_cell(F_DATACARIC, files.get(F9C_LOADDATE), row);
sf.set_row_cell(F_INFO, not_exist ? "IL FILE NON E' PRESENTE IN ARCHIVIO." : "", row);
}
sf.force_update();
sf.show();
if (!file_err.empty())
{
int count = 0;
const bool m = (int)file_err.size() == 1;
const bool m = (int)file_err.items() == 1;
const char p = m ? 'o' : 'i';
TString msg; msg << (int)file_err.size() << " file non " << (m ? "e'" : "sono") << " stat" << p <<
TString msg; msg << (int)file_err.items() << " file non " << (m ? "e'" : "sono") << " stat" << p <<
" trovat" << p << ".\nSi prega di rimuoverl" << p << " dall'elenco\n\nFile non trovat" << p << ":";
for (auto it = file_err.begin(); it != file_err.end(); ++it)
FOR_EACH_ARRAY_ROW(file_err, r, str)
{
if (count++ == 10)
{
msg << "\n" << "...";
break;
}
msg << "\n" << *it << " [Num. Reg.: " << _list_file.find(*it)->second.numreg << "]";
msg << "\n" << (TString &) *str << " [Num. Reg.: " << r << "]";
}
#ifndef DBG
const bool del = warning_box(msg);
@ -595,10 +592,10 @@ TToken_string& TGestione_doc_cartacei_f9_msk::get_valid_extensions()
void TGestione_doc_cartacei_f9_msk::load_extensions()
{
if (_extensions == nullptr)
if (_extensions.empty())
{
_extensions = std::make_unique<std::set<TString>>();
TToken_string& ext = get_valid_extensions();
for (int i = 0; i < ext.items(); ++i)
{
TString e = ext.get(i);
@ -606,62 +603,48 @@ void TGestione_doc_cartacei_f9_msk::load_extensions()
{
if (e.starts_with("."))
e.ltrim(1);
_extensions->insert(e);
_extensions.add(e);
}
}
}
}
bool TGestione_doc_cartacei_f9_msk::load_file(const TFilename& file, const TString& numreg, const bool is_annesso,
const TString& catannpadre, const TString& catdocann)
{
return TF9_doccart::add_cart(file, numreg, is_annesso, catannpadre, catdocann, false);
}
void TGestione_doc_cartacei_f9_msk::open_config_win()
{
// Creazione maschera
if(_config_msk == nullptr)
{
_config_msk = std::make_unique<TMask>("Configurazione", 1, 78, 14);
_config_msk->add_button_tool(DLG_OK, "Conferma", TOOL_OK);
_config_msk->add_button_tool(DLG_NULL, "", 0);
_config_msk->add_button_tool(DLG_QUIT, "Esci", TOOL_QUIT);
TMask config_msk("Configurazione", 1, 78, 14);
_config_msk->add_groupbox(DLG_NULL, 0, "@BCartella documenti cartacei", 1, 0, 76, 4);
_config_msk->add_static (DLG_NULL, 0, "@BInserire nome cartella, all'interno della area dati della ditta", 2, 1);
_config_msk->add_string (102, 0, "", 2, 2, 64, "", 30);
_config_msk->add_groupbox(DLG_NULL, 0, "", 1, 4, 76, 4, "");
_config_msk->add_static (DLG_NULL, 0, "@BInserire estensioni file riconosciute, separate da virgola.", 2, 5);
_config_msk->add_string (101, 0, "Estensioni:", 2, 6, 255, "", 60);
config_msk.add_button_tool(DLG_OK, "Conferma", TOOL_OK);
config_msk.add_button_tool(DLG_NULL, "", 0);
config_msk.add_button_tool(DLG_QUIT, "Esci", TOOL_QUIT);
config_msk.add_groupbox(DLG_NULL, 0, "@BCartella documenti cartacei", 1, 0, 76, 4);
config_msk.add_static (DLG_NULL, 0, "@BInserire nome cartella, all'interno della area dati della ditta", 2, 1);
config_msk.add_string (102, 0, "", 2, 2, 64, "", 30);
config_msk.add_groupbox(DLG_NULL, 0, "", 1, 4, 76, 4, "");
config_msk.add_static (DLG_NULL, 0, "@BInserire estensioni file riconosciute, separate da virgola.", 2, 5);
TMask_field & ext = config_msk.add_string (101, 0, "Estensioni:", 2, 6, 255, "", 60);
ext.check_type(CHECK_REQUIRED);
config_msk.set(101, F9CONF.get_estensioni());
TString s = F9CONF.get_addr_cart();
_config_msk->set(101, F9CONF.get_estensioni());
TString s = F9CONF.get_addr_cart();
s.rtrim(1);
s.ltrim(s.rfind('\\') + 1);
_config_msk->set(102, s);
}
config_msk.set(102, s);
// Esecuzione maschera
while (true)
if (config_msk.run() == K_ENTER)
{
if (_config_msk->run() != K_ENTER)
{
if (_config_msk->get(102).empty())
{
warning_box("Si prega di inserire il nome della cartella per i documenti cartacei.");
continue;
}
break;
}
F9CONF.set_estensioni(_config_msk->get(101));
TString dir = _config_msk->get(102);
TString dir = config_msk.get(102);
if (dir.empty())
{
if(yesno_box("Nome cartella vuoto.\nCreare cartella con nome 'Cartacei_F9'?"))
_config_msk->set(102, dir = "Cartacei_F9");
else continue;
config_msk.set(102, dir = "Cartacei_F9");
else return;
}
F9CONF.set_estensioni(config_msk.get(101));
TFilename path(prefix().get_studio());
path.add(dir).slash_terminate();
@ -672,33 +655,33 @@ void TGestione_doc_cartacei_f9_msk::open_config_win()
if (!make_dir(path))
{
warning_box("Impossibile creare il percorso specificato.");
continue;
return;
}
}
else continue;
else return;
}
F9CONF.set_addr_cart(path);
break;
}
}
void TGestione_doc_cartacei_f9_msk::open_import_win()
{
if(_import_msk == nullptr)
_import_msk = make_unique<TImport_msk>();
while(_import_msk->run() == K_ENTER)
TImport_msk import_msk;
while(import_msk.run() == K_ENTER)
{
const TString& file = _import_msk->get(F_IMPADDRESS);
const TString& numreg = _import_msk->get(F_IMPNUMREG);
const bool is_annesso = _import_msk->get_bool(F_ISANNESSO);
const TString& catannpadre = _import_msk->get(F_CATANNPADRE);
const TString& catdocann = _import_msk->get(F_CATDOCANN);
const TString& file = import_msk.get(F_IMPADDRESS);
const long numreg = import_msk.get_long(F_IMPNUMREG);
const bool is_annesso = import_msk.get_bool(F_ISANNESSO);
const TString& catannpadre = import_msk.get(F_CATANNPADRE);
const TString& catdocann = import_msk.get(F_CATDOCANN);
if (!file.empty())
{
TFilename f(file);
if (verify_extension(f))
{
if(!numreg.empty())
if (numreg != 0)
{
if (!is_annesso || catannpadre.full() && catdocann.full())
{
@ -723,13 +706,13 @@ void TGestione_doc_cartacei_f9_msk::open_import_win()
fill();
}
void TGestione_doc_cartacei_f9_msk::remove_file_from_f9cart(const std::set<TString>& files)
void TGestione_doc_cartacei_f9_msk::remove_file_from_f9cart(const TString_array & files)
{
TLocalisamfile f9cart(LF_F9DOCS);
for(auto it = files.begin(); it != files.end(); ++it)
FOR_EACH_ARRAY_ROW(files, row, str)
{
f9cart.zero();
f9cart.put(F9C_FILENAME, *it);
f9cart.put(F9C_FILENAME, (const TString &) *str);
f9cart.read();
f9cart.remove();
}
@ -738,7 +721,7 @@ void TGestione_doc_cartacei_f9_msk::remove_file_from_f9cart(const std::set<TStri
bool TGestione_doc_cartacei_f9_msk::verify_extension(const TFilename& file)
{
load_extensions();
return _extensions->find(file.ext()) != _extensions->end();
return _extensions.find(file.ext()) >= 0;
}
TGestione_doc_cartacei_f9_msk::TGestione_doc_cartacei_f9_msk(): TAutomask("f90300a"), _addr_cart(F9CONF.get_addr_cart())

80
src/f9/f90400.cpp
View File

@ -81,42 +81,49 @@ void TF9_test_app::main_loop()
preload.add_annesso("FATTACQ", "LEASING", "Annesso leasing", "DC");
CHECK(preload.get_array_rows().items() > 0, "Errore aggiunta o caricamento categorie documentali.");
TCategorie_doc::annesso annesso;
if (preload.get_ann("FATTACQ","GENACQ", annesso))
TAnnesso * annesso = nullptr;
if (preload.get_ann("FATTACQ","GENACQ") != nullptr)
{ }
TCategorie_doc::classe_doc get_classe_doc_right{ "ACQREV", "Fattura acq. con rev. charge", "FTA", "TD01", "052", "FA" };
const TCategorie_doc::classe_doc* get_classe_doc = preload.get_classe_doc("ACQREV");
CHECK(get_classe_doc->catdoc == get_classe_doc_right.catdoc &&
get_classe_doc->descr == get_classe_doc_right.descr &&
get_classe_doc->class_sost == get_classe_doc_right.class_sost &&
get_classe_doc->caus_sost == get_classe_doc_right.caus_sost &&
get_classe_doc->causcont == get_classe_doc_right.causcont &&
get_classe_doc->tipocaus == get_classe_doc_right.tipocaus, "get_classe_doc failed"
TClasse_doc get_classe_doc_right{ "ACQREV", "Fattura acq. con rev. charge", "FTA", "TD01", "052", "FA" };
const TClasse_doc* get_classe_doc = preload.get_classe_doc("ACQREV");
CHECK(get_classe_doc->catdoc() == get_classe_doc_right.catdoc() &&
get_classe_doc->descr() == get_classe_doc_right.descr() &&
get_classe_doc->class_sost()== get_classe_doc_right.class_sost() &&
get_classe_doc->caus_sost() == get_classe_doc_right.caus_sost() &&
get_classe_doc->causcont() == get_classe_doc_right.causcont() &&
get_classe_doc->tipocaus() == get_classe_doc_right.tipocaus(), "get_classe_doc failed"
);
std::set<TString> get_name_catdocs = preload.get_name_catdocs();
CHECK(get_name_catdocs.find("FATTACQ") != get_name_catdocs.end() &&
get_name_catdocs.find("FATTVEN") != get_name_catdocs.end() &&
get_name_catdocs.find("NOTCREDACQ") != get_name_catdocs.end() &&
get_name_catdocs.find("NOTDEBVEN") != get_name_catdocs.end() &&
get_name_catdocs.find("FATTCORR") != get_name_catdocs.end() &&
get_name_catdocs.find("ACQREV") != get_name_catdocs.end(), "Get catdocs failed"
);
const TCategorie_doc::classe_doc* mov2cat = preload.mov2cat(95752);
TString_array * catdocs = preload.get_name_catdocs();
CHECK(catdocs->find("FATTACQ") >= 0 && catdocs->find("FATTVEN") >= 0 && catdocs->find("NOTCREDACQ") >= 0 &&
catdocs->find("NOTDEBVEN") >= 0 && catdocs->find("FATTCORR") >= 0 && catdocs->find("ACQREV") >= 0, "Get catdocs failed");
const TClasse_doc* mov2cat = preload.mov2cat(95752);
CHECK(mov2cat, "mov2cat failed: classe doc is null");
mov2cat = preload.mov2cat(96955); // Rev. charge causale 052
CHECK(mov2cat->causcont == "052", "Error retriving cat.doc. from numreg for causale.");
CHECK(mov2cat->causcont() == "052", "Error retriving cat.doc. from numreg for causale.");
const TString cat_selected = "FATTACQ";
TCategorie_doc catdoc;
std::shared_ptr<TArray_sheet> annessi = catdoc.get_sheet_ann(cat_selected);
TArray_sheet * annessi = catdoc.get_sheet_ann(cat_selected);
CHECK(annessi->items() == 2, format(FR("TCategorie_doc::get_sheet_ann() failed: retrived %d elements instead of 2"), (int)annessi->items()));
std::shared_ptr<TArray_sheet> sheet_catdocs = catdoc.get_sheet_catdocs();
CHECK(sheet_catdocs->items() == 6, format(FR("TCategorie_doc::get_sheet_catdocs() failed: retrived %d elements instead of 6"), (int)sheet_catdocs->items()));
TArray_sheet * sheet_catdocs = catdoc.get_sheet_catdocs();
CHECK(sheet_catdocs->items() == 6, format(FR("TCategorie_doc::get_sheet_catdocs() failed: retrived %d elements instead of 6"), (int)sheet_catdocs->items()));
TRecord_categorie rec(TRecord_categorie::catdocs);
TRecord_categorie rec2(TRecord_categorie::annessi);
rec.put("NAME", "FATTACQ");
rec.read();
TString name = rec.get("NAME");
@ -145,31 +152,21 @@ void TF9_test_app::main_loop()
if (false)
{
TF9_doccart doccart;
TString old_numreg; old_numreg << 95752;
long old_numreg = 95752;
TFilename doc;
TString_array list_annessi;
vector<annesso_t> vect_annessi;
//TFilename f_doc; f_doc << "asd";
//bool annesso;
//bool doc_ae = doccart.doc_already_exists(f_doc, old_numreg, annesso);
bool movdoc = doccart.mov2doc(old_numreg, doc);
TArray vect_annessi; // TAnnesso_mov
bool movdoc = doccart.mov2doc(old_numreg, doc);
TString msg("Error retriving filename from reg n. "); msg << old_numreg;
CHECK(movdoc && TString(doc.name()) == "ve1300_F01_0000000011_0002237.pdf", (const char*)msg);
old_numreg.cut(0) << 95222; // Doppio annesso
old_numreg = 95222; // Doppio annesso
bool movann = doccart.mov2listann(old_numreg, list_annessi);
//CHECK(movann && list_annessi.items() == 2, "Error retriving list annessi from numreg %s", (const char*)old_numreg);
bool movannvect = doccart.mov2listann_vect(old_numreg, vect_annessi);
//CHECK(movannvect && vect_annessi.size() == 2, "Error retriving vector annessi from numreg %s", (const char*)old_numreg);
/*TCategorie_doc::annesso annesso;
annesso.catdoc = "INTEGREV";
annesso.catdocpadre = "FATTREV";
annesso.descr = "Integrazione Rev. Charge";
annesso.opcee = "RC";
annesso.obblig = true;
TEstrazione::make_prosp_int_revc(96951, annesso);*/
}
if(false)
@ -199,10 +196,10 @@ void TF9_test_app::main_loop()
TString codfisc;
//TEstrazione::fill_id(clifo, statopaiv, idfisc, paiv, codfisc);
TCategorie_doc::annesso annesso;
TAnnesso *annesso = nullptr;
TCategorie_doc categorie_doc;
if(categorie_doc.get_ann("FATTACQ","INTREVC", annesso))
if(categorie_doc.get_ann("FATTACQ","INTREVC") != nullptr)
TEstrazione::make_prosp_int_revc(153480, annesso);
TString s = get_numdoc_exp_fp(105396);
@ -210,9 +207,6 @@ void TF9_test_app::main_loop()
message_box("TESTS COMPLETELY SUCCESSFUL");
}
int f90400(const int argc, char* argv[])
{
TF9_test_app test_app;

113
src/f9/f90500.cpp Normal file
View File

@ -0,0 +1,113 @@
#include <applicat.h>
#include <mask.h>
#include <progind.h>
#include <relation.h>
#include <tabutil.h>
#include <mov.h>
#include "f90.h"
#include "f90500.h"
#include "../cg/cglib.h"
class TRipristina_estrazione : public TSkeleton_application
{
protected: // TApplication
virtual void main_loop();
public:
bool restore(const TString & tipomov, int year, int from_month, int to_month);
TRipristina_estrazione() {}
~TRipristina_estrazione() {}
};
// Azzera flag di stampato della liquidazione mensile dal mese dato in poi
bool TRipristina_estrazione::restore(const TString & tipomov,
int year, int from_month, int to_month)
{
TRelation rel(LF_MOV);
const TipoIVA tipo = (tipomov == "V") ? iva_vendite : iva_acquisti;
const TDate from_date(1, from_month, year);
TDate to_date(1, to_month, year);
TRectype from(LF_MOV);
TRectype to(from);
TString filter;
to_date.set_end_month();
from.put(MOV_DATAREG, from_date);
to.put(MOV_DATAREG, to_date);
// filter movimenti archiviati + tipomov
filter << "(" << MOV_ELABF9 << "!=\"\")";
TCursor c(&rel, filter, 2, &from, &to);
TRectype & mov = c.curr();
long last_num = 0L;
const long items = c.items();
TString msg; msg.format(FR("Ripristino estrazione %s"), tipomov == "V" ? "vendite" : "acquisti");
TProgind p(items ? items : 1, msg , true, true);
for (c = 0L; p.addstatus(1) && c.pos() < items; ++c)
{
const TString & codreg = mov.get(MOV_REG);
if (codreg.full())
{
const TRegistro & reg = cached_registro(codreg, mov.get_int(MOV_ANNOIVA));
if (reg.tipo() == tipo)
{
mov.zero(MOV_ELABF9);
const int err = mov.rewrite(rel.lfile());
if (err != NOERR)
return error_box(FR("Errore nell'aggiornamento del movimento %ld.\n Errore n. %d"),
mov.get_long(MOV_NUMREG), err);
}
}
}
return true;
}
void TRipristina_estrazione::main_loop()
{
TMask msk("f90500a") ;
while (msk.run() == K_ENTER)
{
const long old_firm = prefix().get_codditta();
const long firm = msk.get_long(F_FIRM);
const TString4 tipomov = msk.get(F_TIPOMOV) ;
const int year = msk.get_int(F_YEAR);
const int from_month = msk.get_int(F_DAMESE);
const int to_month = msk.get_int(F_AMESE);
if (prefix().exist(firm))
{
if (firm != old_firm)
prefix().set_codditta(firm);
TString256 mess(TR("Attenzione ripristino dell'estrazione "));
mess << TR("della ditta ") << firm;
mess << " da " << itom(from_month) << " a " << itom(to_month) << ' ' << year;
if (yesno_box(mess))
if (yesno_box(TR("\nSi desidera veramente continuare?")))
restore(tipomov, year, from_month, to_month);
if (firm != old_firm)
prefix().set_codditta(old_firm);
}
else
error_box(TR("Ditta assente"));
msk.reset();
}
}
int f90500(int argc, char* argv[])
{
TRipristina_estrazione a ;
a.run(argc, argv, TR("Ripristino estrazioni"));
return 0;
}

8
src/f9/f90500.h Normal file
View File

@ -0,0 +1,8 @@
#define F_FIRM 101
#define F_DFIRM 102
#define F_TIPOMOV 103
#define F_YEAR 104
#define F_DAMESE 105
#define F_AMESE 106

64
src/f9/f90500a.uml Normal file
View File

@ -0,0 +1,64 @@
#include "f90500.h"
PAGE "Ripristino estarzioni" -1 -1 80 11
NUMBER F_FIRM 5
BEGIN
PROMPT 2 1 "Ditta "
FLAGS "RF"
USE LF_NDITTE
INPUT CODDITTA F_FIRM
DISPLAY "Codice" CODDITTA
DISPLAY "Ragione sociale @50" RAGSOC
OUTPUT F_FIRM CODDITTA
OUTPUT F_DFIRM RAGSOC
WARNING "Ditta assente"
CHECKTYPE REQUIRED
END
STRING F_DFIRM 50
BEGIN
PROMPT 26 1 ""
USE LF_NDITTE KEY 2
CHECKTYPE NORMAL
INPUT RAGSOC F_DFIRM
DISPLAY "Ragione sociale @60" RAGSOC
DISPLAY "Codice" CODDITTA
COPY OUTPUT F_FIRM
WARNING "Ditta assente"
END
LIST F_TIPOMOV 15
BEGIN
PROMPT 2 3 "Tipo movimento "
ITEM "A|Acquisti"
ITEM "V|Vendite"
END
NUMBER F_YEAR 4
BEGIN
PROMPT 2 5 "Anno "
FLAGS "AR"
CHECKTYPE REQUIRED
WARNING "L'anno deve essere specificato"
END
LIST F_DAMESE 10
BEGIN
PROMPT 2 7 "Da Mese "
FLAGS "M"
END
LIST F_AMESE 10
BEGIN
PROMPT 40 7 "A Mese "
FLAGS "M"
END
ENDPAGE
TOOLBAR "topbar" 0 0 0 2
#include <stdbar.h>
ENDPAGE
ENDMASK

229
src/f9/f9lib.h
View File

@ -1,9 +1,9 @@
#ifndef __F901001_H
#define __F901001_H
#include <map>
#include <set>
#include <vector>
// #include <map>
// #include <set>
// #include <vector>
#include "strings.h"
#include "date.h"
@ -23,14 +23,35 @@
const char* check_str(const TString& str);
const TString & get_numdoc_exp_fp(int numreg);
struct annesso_t
class TAnnesso_mov : public TObject
{
TString numreg; // TString ez-pz
TString filename;
TString catdocpad;
TString catdocann;
TDate loaddate;
TString user;
long _numreg;
TString _filename;
TString _catdocpad;
TString _catdocann;
TDate _loaddate;
TString _user;
protected:
TAnnesso_mov & copy(const TAnnesso_mov & a);
public :
virtual TObject* TAnnesso_mov::dup() const { return new TAnnesso_mov(*this); }
TAnnesso_mov & operator = (const TAnnesso_mov & a) { return copy(a);}
const TString & numreg() const { return _numreg; }
const TString & filename() const { return _filename; }
const TString & catdocpad() const { return _catdocpad; }
const TString & catdocann() const { return _catdocann; }
const TDate & loaddate() const { return _loaddate; }
const TString & user() const { return _user; }
void ann2row(TToken_string & row);
TAnnesso_mov(long numreg, const char * filename, const char * catdocpad, const char * catdocann, const TDate & loaddate, const char * user)
: _numreg(numreg), _filename(filename), _catdocpad(catdocpad), _catdocann(catdocann), _loaddate(loaddate), _user(user) {}
TAnnesso_mov(TToken_string & row, int start = 0);
TAnnesso_mov(const TAnnesso_mov & a) { copy(a); }
~TAnnesso_mov() {}
};
struct statistics
@ -130,38 +151,79 @@ public:
extern TF9_config F9CONF;
class TClasse_doc : public TObject
{
TString _catdoc; // Codice cat. documentale.
TString _descr; // Descrizione documento.
TString _class_sost; // { FTA | FTV } - classe documentale sostitutiva.
TString _caus_sost; // causale per sostitutiva (TD01...).
TString _causcont; // Codice causale.
TString _tipocaus; // Usato come tipo documento (FA, FV, CR, ...).
protected:
TClasse_doc & copy(const TClasse_doc & c);
public:
virtual TObject* TClasse_doc::dup() const { return new TClasse_doc(*this); }
TClasse_doc & operator = (const TClasse_doc & c) { return copy(c); }
const TString & catdoc() const { return _catdoc; }
const TString & descr() const { return _descr; }
const TString & class_sost() const { return _class_sost; }
const TString & caus_sost() const { return _caus_sost; }
const TString & causcont() const { return _causcont; }
const TString & tipocaus() const { return _tipocaus; }
void ann2row(TToken_string & row);
TClasse_doc(const char * catdoc, const char * descr, const char * class_sost, const char * caus_sost,
const char * causcont, const char * tipocaus)
: _catdoc(catdoc), _descr(descr), _class_sost(class_sost), _caus_sost(caus_sost), _causcont(causcont),
_tipocaus(tipocaus) {}
TClasse_doc(TToken_string & row, int start = 0);
TClasse_doc(const TClasse_doc & c) { copy(c); }
~TClasse_doc() {}
};
class TAnnesso : public TObject
{
TString _catdocpadre;
TString _catdoc; // Codice cat. documentale.
TString _descr; // Descrizione documento.
TString _opcee; // { RV | DC } - Usato come classificazione annesso (Reverse, ann. cartaceo).
bool _obblig; // Definisce se deve essere per forza presente l'annesso.
TAnnesso & copy(const TAnnesso & a);
public:
virtual TObject* TAnnesso::dup() const { return new TAnnesso(*this); }
TAnnesso & operator = (const TAnnesso & a) { return copy(a); }
const TString & catdocpadre() const { return _catdocpadre; }
const TString & catdoc() const { return _catdoc; }
const TString & descr() const { return _descr; }
const TString & opcee() const { return _opcee; }
bool obblig() const { return _obblig; }
void ann2row(TToken_string & row);
TAnnesso(const char * catdocpadre, const char * catdoc, const char * descr, const char * opcee, bool obblig = false)
: _catdocpadre(catdocpadre), _catdoc(catdoc), _descr(descr), _opcee(opcee), _obblig(obblig) {}
TAnnesso(TToken_string & row, int start = 0);
TAnnesso(const TAnnesso & a) { copy(a); }
~TAnnesso() {}
};
class TCategorie_doc
{
public:
struct classe_doc
{
TString catdoc; // Codice cat. documentale.
TString descr; // Descrizione documento.
TString class_sost; // { FTA | FTV } - classe documentale sostitutiva.
TString caus_sost; // causale per sostitutiva (TD01...).
TString causcont; // Codice causale.
TString tipocaus; // Usato come tipo documento (FA, FV, CR, ...).
};
struct annesso
{
TString catdocpadre;
TString catdoc; // Codice cat. documentale.
TString descr; // Descrizione documento.
TString opcee; // { RV | DC } - Usato come classificazione annesso (Reverse, ann. cartaceo).
bool obblig{ false }; // Definisce se deve essere per forza presente l'annesso.
};
private:
std::vector<classe_doc *> _rows;
std::vector<std::pair<TString, std::shared_ptr<TArray_sheet>>> _sheets_annessi;
std::shared_ptr<TArray_sheet> _sheet_catdocs;
std::shared_ptr<std::set<TString>> _name_catdocs;
int _mode_sheet;
TAssoc_array _rows; // TClasse_doc *
TAssoc_array _sheets_annessi; // TArray_sheet *
TArray_sheet * _sheet_catdocs;
TString_array * _name_catdocs;
int _mode_sheet;
TCategorie_doc::classe_doc * find_causcont(const TString& caus) const ; // OK
TCategorie_doc::classe_doc * find_tipodoc(const TString& tipodoc) const ; // OK
TCategorie_doc::classe_doc * find_tipodocsdi(const TString& tipodocsdi, const char * tipocaus) const ; // OK
TClasse_doc * find_causcont(const TString& caus); // OK
TClasse_doc * find_tipodoc(const TString& tipodoc); // OK
TClasse_doc * find_tipodocsdi(const TString& tipodocsdi, const char * tipocaus); // OK
std::vector<pair<TString, std::shared_ptr<TArray_sheet>>>::iterator find_sheet_annessi(const TString& catdoc); // OK
TArray_sheet * find_sheet_annessi(const TString& catdoc) { return (TArray_sheet *) _sheets_annessi.objptr(catdoc); }
void load_all();
void save_ann();
@ -172,9 +234,9 @@ private:
static const char* traduci_class_sost(const TString& class_sost);
protected:
std::map<TString, annesso> _rows_annessi;
TAssoc_array _rows_annessi; // TAnnesso
std::map<TString, annesso>::iterator find_annesso(const TString& catdoc_padre, const char* catdoc_ann);
TCategorie_doc::TAnnesso * find_annesso(const TString& catdoc_padre, const char* catdoc_ann);
public:
void add_annesso(const TString& catdoc_padre, const TString& catdoc_ann, const TString& descr,
@ -184,18 +246,18 @@ public:
void add_categoria(const TString& catdoc, const TString& descr, const TString& class_sost,
const TString& caus_sost, const TString& causcont, const TString& tipocaus);
bool annesso_exist(const TString& catdoc_padre, const char* catdoc_ann) { return find_annesso(catdoc_padre, catdoc_ann) != _rows_annessi.end();}
bool annesso_exist(const TString& catdoc_padre, const char* catdoc_ann) { return find_annesso(catdoc_padre, catdoc_ann) != nullptr; }
void del_annesso(const TString& catdoc, const char* catdoc_ann);
bool get_ann(const TString & catdoc, const TString& catann, _Out_ annesso& _Annesso_out);
TAnnesso * get_ann(const TString & catdoc, const TString& catann);
TString_array get_array_ann(const TString& catdoc);
TString_array get_array_rows(bool traduci = false);
classe_doc* get_classe_doc(const TString& catdoc);
std::set<TString>& get_name_catdocs() { get_sheet_catdocs(); return *_name_catdocs; }
std::shared_ptr<TArray_sheet> get_sheet_catdocs();
std::shared_ptr<TArray_sheet> get_sheet_ann(const TString& catdoc);
classe_doc * mov2cat(const long numreg);
const TString & tipo2caus_cont(const TString & tipodoc, const char * tipocaus) { TCategorie_doc::classe_doc * c = find_tipodocsdi(tipodoc, tipocaus); if (c != nullptr) return c->causcont; else return EMPTY_STRING; }
TClasse_doc* get_classe_doc(const TString& catdoc) { return (TClasse_doc *)_rows.objptr(catdoc); }
TString_array * get_name_catdocs() { get_sheet_catdocs(); return _name_catdocs; }
TArray_sheet * get_sheet_catdocs();
TArray_sheet * get_sheet_ann(const TString& catdoc);
TClasse_doc * mov2cat(const long numreg);
const TString & tipo2caus_cont(const TString & tipodoc, const char * tipocaus) { TClasse_doc * c = find_tipodocsdi(tipodoc, tipocaus); if (c != nullptr) return c->causcont(); else return EMPTY_STRING; }
void reload();
static void remove_all();
static void remove_all_ann();
@ -243,7 +305,7 @@ enum err_mov
mov_annesso_nexist // Un annesso obbligatorio e' mancante.
};
class movimento_t : public TObject // aggiungere metodi per TArray
class TMovimento_estr : public TObject // aggiungere metodi per TArray
{
@ -263,12 +325,15 @@ class movimento_t : public TObject // aggiungere metodi per TArray
TString _descr_err; // Messaggio di errore visibile dal controllo estrazione.
bool _estratto;
err_mov _descr_estr; // Messaggio di informazioni visibile dal 'Apri Estr.'
TCategorie_doc::classe_doc* _catdoc;
bool _cartaceo;
TFilename _nomefilecart;
vector<annesso_t> _annessi;
TArray _annessi; // TAnnesso_mov
TMovimento_estr & copy(const TMovimento_estr & m);
public:
virtual TObject* TMovimento_estr::dup() const { return new TMovimento_estr(*this); }
TMovimento_estr & operator =(const TMovimento_estr& m) { return copy(m);}
static const char* err_mov2name(const err_mov descr_estr);
const char* get_descr_estr() const { return err_mov2name(_descr_estr); }
bool err() const { return _err; }
@ -288,8 +353,8 @@ public:
const TString & descr_err() const { return _descr_err; }
bool estratto() const { return _estratto; }
err_mov descr_estr() const { return _descr_estr; }
TCategorie_doc::classe_doc* catdoc() const { return _catdoc; }
vector<annesso_t> annessi() const { return _annessi; }
TClasse_doc* catdoc(TCategorie_doc& catdoc) const { return catdoc.mov2cat(numreg()); }
TArray & annessi() { return _annessi; }
bool cartaceo() const { return _cartaceo; } // todo
const TFilename & nomefilecart() const { return _nomefilecart; }
@ -301,19 +366,20 @@ public:
void set_descr_estr(err_mov descr_estr) { _descr_estr = descr_estr; }
void set_numdoc(const char * numdoc) { _numdoc = numdoc; }
void set_estratto(bool estratto) { _estratto = estratto; }
void set_catdoc(TCategorie_doc::classe_doc* catdoc) { _catdoc = catdoc; }
void set_nomefilecart(const char * nomefilecart) { _nomefilecart = nomefilecart; }
movimento_t(TSheet_field& sf, int row);
movimento_t(const long numreg);
movimento_t(TISAM_recordset & mov, TipoIVA tipo, bool escl);
~movimento_t() { safe_delete(_catdoc); }
TMovimento_estr(TSheet_field& sf, int row);
TMovimento_estr(const long numreg);
TMovimento_estr (const TMovimento_estr & m) { copy(m); }
TMovimento_estr(TISAM_recordset & mov, TipoIVA tipo, bool escl);
~TMovimento_estr() {}
};
class TEstrazione : public TObject
{
drd _head;
vector<movimento_t> _movs;
TArray _movs; // TMovimento_estr
ofstream * _error_sql;
bool _escluso;
const TString _descr;
@ -325,11 +391,11 @@ class TEstrazione : public TObject
*/
bool update_drd_stato_estr() const;
static const char* caus_sos(const TLocalisamfile& mov, TipoIVA iva);
static void check_annessi(movimento_t& mov_i, int numreg); // Controllo se ci sono tutti gli annessi obbligatori.
static void check_annessi(TMovimento_estr& mov_i, int numreg); // Controllo se ci sono tutti gli annessi obbligatori.
// Controllo se esistono tutti gli annessi cartacei obbligatori e se ci sono annessi reverse charge li genero.
static bool check_annessi_oblig(const TString& catdoc, int numreg, _Out_ TToken_string& ann_nexist);
static bool check_cartaceo_acq(const movimento_t& movimento);
static bool check_documento_vendita(const TLocalisamfile& mov, _Out_ bool& exist_doc);
static bool check_annessi_oblig(const TString& catdoc, int numreg, TToken_string& ann_nexist);
static bool check_cartaceo_acq(const TMovimento_estr& movimento);
static bool check_documento_vendita(const TLocalisamfile& mov, bool& exist_doc);
/** CHECK RIFERIMENTO FPPRO
* Per le fatture di acquisto controllo se ho il riferimento nell'FPPRO.
* Altrimenti cerco di capire se riesco a trovare il corrispondente del movimento
@ -342,18 +408,18 @@ class TEstrazione : public TObject
*/
static state_fppro check_fppro(int numreg);
bool check_periodo_def() const;
void copy_file_to_webapp_fld(const movimento_t& movimento) const;
void copy_file_to_webapp_fld(TMovimento_estr& movimento) const;
static void fill_id(const TRectype& clifo, TString& statopaiv, TString& idfisc, TString& paiv, TString& codfis);
TipoIVA get_tipoiva() const { return _head.tipo_doc == 'A' ? iva_acquisti : iva_vendite; }
static bool is_doc_xml(const TRectype& mov);
static bool find_movcoll(int numreg, _Out_ TString& numreg_rev_vend);
static bool load_annessi(movimento_t& movimento);
static bool find_movcoll(int numreg, TString& numreg_rev_vend);
static bool load_annessi(TMovimento_estr& movimento);
// Se il movimento e' di vendita e ha i riferimenti al documento generatore provo a stamparlo con ve, e lo inserisco tra i cartacei F9.
static bool stampa_documento(const movimento_t& movimento, TFilename& file);
bool grab_pdf_from_spotlite(const movimento_t& movimento, TFilename& file) const;
static bool stampa_documento(const TMovimento_estr& movimento, TFilename& file);
bool grab_pdf_from_spotlite(const TMovimento_estr& movimento, TFilename& file) const;
public:
static bool make_prosp_int_revc(int numreg, TCategorie_doc::annesso& annesso);
static bool make_prosp_int_revc(int numreg, TAnnesso * TAnnesso);
private:
@ -374,7 +440,7 @@ private:
public:
void add_mov(const movimento_t& movimento);
void add_mov(TMovimento_estr * movimento) { _movs.add(movimento); }
/** DIAGNOSTICA GESTIONALE.
* Controllo lo stato delle fatture:
* Per le fatt. acquisto non collegate a fppro cerca di agganciarle.
@ -406,7 +472,7 @@ public:
// Getters
TString get_id_estr() const { return _head.id_estr; }
TString4 get_stato_estr() const { return _head.stato_estr; }
const vector<movimento_t>& get_movs() const { return _movs; }
const TArray & get_movs() const { return _movs; }
// Setters
void set_provvisorio(bool flag_prov) { _head.flag_prov = flag_prov; }
@ -447,43 +513,44 @@ public:
class TIva_insert_prepared_stat
{
vector<pair<TString, TString>> _fields;
TAssoc_array _fields; // TString
bool _ok{ true };
TString _query;
void add_value(const char* field, const TString& value);
void add_value(const char* field, const TString& value) { _fields.add(field, value); }
void write();
public:
void add(const char* field, const TString& str, int len = -1);
void add(const char* field, const char* str, int len = -1);
void add(const char* field, const TDate& date);
void add(const char* field, char c);
void add(const char* field, long l);
void add(const char* field, const int n) { add(field, (long)n); }
void add_getdate(const char* field);
void add_getdate(const char* field) { _fields.add(field, "GETDATE()"); }
bool get(TString& query);
void reset();
};
class TF9_doccart
{
TLocalisamfile _tdocs;
TLocalisamfile _tannessi;
public:
static bool add_cart(const TFilename& file, const TString& numreg, bool is_annesso = false,
static bool add_cart(const TFilename& file, long numreg, bool is_annesso = false,
const TString& catannpadre = "", const TString& catdocann = "", bool suppress_errors = true);
bool doc_already_exists(const TFilename& file, TString& numreg, bool& annesso);
bool mov2doc(const TString& numreg, TFilename& doc);
bool mov2listann(const TString& numreg, TString_array& list_annessi);
bool mov2listann_vect(const TString& numreg, vector<annesso_t>& list_annessi);
bool doc_already_exists(const TFilename& file, long & numreg, bool& TAnnesso);
bool mov2doc(long numreg, TFilename& doc);
bool mov2listann(const TString& numreg, TString_array & list_annessi);
bool mov2listann_vect(const long numreg, TArray & list_annessi);
static TString get_full_path_file_cartaceo(const TString& filename)
{
return TString() << TFilename(F9CONF.get_addr_cart()).slash_terminate() << filename;
}
TF9_doccart() : _tdocs(LF_F9DOCS), _tannessi(LF_F9ANNESSI) { }
TF9_doccart() : _tannessi(LF_F9ANNESSI) { }
};

1330
src/f9/f9lib01.cpp
View File

File diff suppressed because it is too large Load Diff

102
src/f9/f9lib02.cpp
View File

@ -74,18 +74,19 @@ TF9_config::TF9_config()
// TF9_doccart
///////////////////////////////////////////////////////////////////////////////
bool TF9_doccart::add_cart(const TFilename& file, const TString& numreg, const bool is_annesso,
bool TF9_doccart::add_cart(const TFilename& file, long numreg, const bool is_annesso,
const TString& catannpadre, const TString& catdocann, bool suppress_errors)
{
TString numreg_old;
bool annesso;
long numreg_old;
bool annesso_found;
TF9_doccart f9cart;
TLocalisamfile f9docs(LF_F9DOCS);
TLocalisamfile f9annessi(LF_F9ANNESSI);
if (f9cart.doc_already_exists(file, numreg_old, annesso))
if (f9cart.doc_already_exists(file, numreg_old, annesso_found))
{
if(!suppress_errors)
warning_box("Attenzione: esiste gia' un %s con questo nome associato al num. di registrazione %s", annesso ? "annesso" : "documento", (const char*)numreg_old);
warning_box("Attenzione: esiste gia' un %s con questo nome associato al num. di registrazione %d", annesso_found ? "annesso" : "documento", numreg_old);
return false;
}
@ -111,12 +112,15 @@ bool TF9_doccart::add_cart(const TFilename& file, const TString& numreg, const b
// Controllo che non sto gia' utilizzando questa categoria di annesso per questa registrazione
// Prendo la lista degli annessi per questa registrazione e li controllo in cerca della categoria
TF9_doccart doccart;
vector<annesso_t> list_annessi;
TArray list_annessi;
doccart.mov2listann_vect(numreg, list_annessi);
bool exist = false;
for (auto it = list_annessi.begin(); it != list_annessi.end(); ++it)
FOR_EACH_ARRAY_ITEM(list_annessi, row, obj)
{
if (it->catdocann == catdocann)
TAnnesso_mov * ann_mov = (TAnnesso_mov *) obj;
if (ann_mov->catdocann() == catdocann)
exist = true;
}
if (exist)
@ -162,40 +166,39 @@ bool TF9_doccart::add_cart(const TFilename& file, const TString& numreg, const b
return true;
}
bool TF9_doccart::doc_already_exists(const TFilename& file, TString& numreg, bool& annesso)
bool TF9_doccart::doc_already_exists(const TFilename& file, long& numreg, bool& annesso)
{
numreg = "";
annesso = false;
_tdocs.zero();
_tdocs.setkey(2);
_tdocs.put(F9C_FILENAME, file.name());
bool ok = _tdocs.read() == NOERR;
const TRectype & tdocs = cache().get(LF_F9DOCS, file.name(), 2);
bool ok = tdocs.full();
if (ok)
numreg = _tdocs.get(F9C_NUMREG);
numreg = tdocs.get_long(F9C_NUMREG);
else
{
numreg = 0L;
_tannessi.zero();
_tannessi.setkey(2);
_tannessi.put(F9A_FILENAME, file.name());
ok = _tannessi.read() == NOERR;
if (ok)
{
numreg = _tannessi.get(F9A_NUMREG);
numreg = _tannessi.get_long(F9A_NUMREG);
annesso = true;
}
}
return ok;
}
bool TF9_doccart::mov2doc(const TString& numreg, _Out_ TFilename& doc)
bool TF9_doccart::mov2doc(long numreg, TFilename& doc)
{
_tdocs.zero();
_tdocs.setkey(1); // Ricerca per NUMREG
_tdocs.put(F9C_NUMREG, numreg);
const bool ok = _tdocs.read() == NOERR;
const TRectype & tdocs = cache().get(LF_F9DOCS, numreg);
const bool ok = tdocs.full();
doc.cut(0);
if (ok)
doc << TFilename(F9CONF.get_addr_cart()).slash_terminate() << _tdocs.get(F9C_FILENAME);
doc << TFilename(F9CONF.get_addr_cart()).slash_terminate() << tdocs.get(F9C_FILENAME);
return ok;
}
@ -228,54 +231,46 @@ bool TF9_doccart::mov2listann(const TString& numreg, _Out_ TString_array& list_a
return ok;
}
bool TF9_doccart::mov2listann_vect(const TString& numreg, _Out_ vector<annesso_t>& list_annessi)
bool TF9_doccart::mov2listann_vect(const long numreg, TArray & list_annessi)
{
list_annessi.clear();
list_annessi.destroy();
_tannessi.zero();
_tannessi.setkey(1);
_tannessi.put(F9A_NUMREG, numreg);
TString numreg_fetched;
bool ok = false;
// Si posiziona nl primo record giusto. Poi per sapere quando terminare guardo se la chiave e' ancora quella giusta.
for (bool r = _tannessi.read(_isgteq) == NOERR; (numreg_fetched = _tannessi.get(F9A_NUMREG)) == numreg && r; r = _tannessi.next() == NOERR)
for (int err = _tannessi.read(_isgteq) == NOERR; err == NOERR; err = _tannessi.next())
{
ok = true;
TString filename = _tannessi.get(F9A_FILENAME);
annesso_t t;
t.numreg = numreg_fetched;
t.filename = _tannessi.get(F9A_FILENAME);
t.catdocpad = _tannessi.get(F9A_CATDOCPAD);
t.catdocann = _tannessi.get(F9A_CATDOCANN);
t.loaddate = _tannessi.get(F9A_LOADDATE);
t.user = _tannessi.get(F9A_USER);
list_annessi.emplace_back(t);
#ifdef DBG
CHECK(numreg_fetched == numreg_fetched, "*Maledetooo*");
#endif
long numreg_fetched = _tannessi.get_long(F9A_NUMREG);
if (numreg_fetched == numreg)
{
ok = true;
TString filename = _tannessi.get(F9A_FILENAME);
TAnnesso_mov t(numreg_fetched, _tannessi.get(F9A_FILENAME), _tannessi.get(F9A_CATDOCPAD),
_tannessi.get(F9A_CATDOCANN), _tannessi.get_date(F9A_LOADDATE), _tannessi.get(F9A_USER));
list_annessi.add(t);
}
else
break;
}
return ok;
}
///////////////////////////////////////////////////////////////////////////////
// TIva_insert_prepared_stat
///////////////////////////////////////////////////////////////////////////////
void TIva_insert_prepared_stat::add_value(const char* field, const TString& value)
{
_fields.insert(_fields.end(), { field, value });
}
void TIva_insert_prepared_stat::write()
{
TString vals_appo;
_query.cut(0) << "INSERT INTO " F9_IVA " (\n";
int count = 0;
bool first = true;
for(auto it = _fields.begin(); it != _fields.end(); ++it)
FOR_EACH_ASSOC_OBJECT(_fields, hash, key, obj)
{
if (!first)
{
@ -287,8 +282,8 @@ void TIva_insert_prepared_stat::write()
_query << "\n";
vals_appo << "\n";
}
_query << it->first;
vals_appo << it->second;
_query << key;
vals_appo << *(TString *) obj;
first = false;
count = ++count % 3;
}
@ -333,11 +328,6 @@ void TIva_insert_prepared_stat::add(const char* field, long l)
add_value(field, v);
}
void TIva_insert_prepared_stat::add_getdate(const char* field)
{
_fields.insert(_fields.end(), { field, "GETDATE()" });
}
bool TIva_insert_prepared_stat::get(TString& query)
{
if (_query.empty())
@ -348,7 +338,7 @@ bool TIva_insert_prepared_stat::get(TString& query)
void TIva_insert_prepared_stat::reset()
{
_fields.clear();
_fields.destroy();
_ok = true;
_query.cut(0);
}