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

1
src/f9/f90.cpp
View File

@ -13,6 +13,7 @@ int main(int argc, char** argv)
case 1: rt = f90200(argc, argv); break; // Tabella categorie documentali case 1: rt = f90200(argc, argv); break; // Tabella categorie documentali
case 2: rt = f90300(argc, argv); break; // Gestione documenti cartacei case 2: rt = f90300(argc, argv); break; // Gestione documenti cartacei
case 3: rt = f90400(argc, argv); break; // Test classi case 3: rt = f90400(argc, argv); break; // Test classi
case 4: rt = f90500(argc, argv); break; // Ripristino archiviazioni
} }
return rt; 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 f90200(int argc, char* argv[]);
int f90300(int argc, char* argv[]); int f90300(int argc, char* argv[]);
int f90400(int argc, char* argv[]); int f90400(int argc, char* argv[]);
int f90500(int argc, char* argv[]);
#endif // _F90_H_ #endif // _F90_H_

208
src/f9/f90100.cpp
View File

@ -27,48 +27,10 @@
#define TAB_BASE_VERSION 100 // Versione base delle tabelle #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 #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 // TEstrai_mask
//////////////////////////////////////////////////////// ////////////////////////////////////////////////////////
int TEstrai_mask::estrai() int TEstrai_mask::estrai()
{ {
const TDate dataini = get_dataini(); const TDate dataini = get_dataini();
@ -123,11 +85,8 @@ int TEstrai_mask::estrai()
// Se definitivo controllo il flag di stampato REGST // Se definitivo controllo il flag di stampato REGST
if ((flagpro || stampato) && numdoc.full() && iva == tipo) if ((flagpro || stampato) && numdoc.full() && iva == tipo)
{ {
// Creo il movimento da inserire // Creo il movimento da inserire e lo inserisco
movimento_t t(mov, tipo, escluso); _estrazione->add_mov(new TMovimento_estr(mov, tipo, escluso));
// Effettivo inserimento del movimento
_estrazione->add_mov(t);
++count; ++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_groupbox(ES_DESCGROUP, 0, "Inserire descrizione estrazione:", 1, 6, 59, 3, "");
add_string (ES_DESCR, 0, "Descrizione", 2, 7, 250, "", 40); add_string (ES_DESCR, 0, "Descrizione", 2, 7, 250, "", 40);
TMask::set_handler(DLG_ELABORA, estrai_handler); set_handler(DLG_ELABORA, estrai_handler);
TMask::set_handler(ES_DATAINI, dataini_handler); set_handler(ES_DATAINI, dataini_handler);
TMask::set_handler(ES_DATAEND, dataend_handler); set_handler(ES_DATAEND, dataend_handler);
TDate dt(TODAY); dt.set_day(1); dt.set_month(1); TDate dt(TODAY); dt.set_day(1); dt.set_month(1);
set(ES_DATAINI, dt); set(ES_DATAINI, dt);
set(ES_DATAEND, today); set(ES_DATAEND, today);
} }
//////////////////////////////////////////////////////// ////////////////////////////////////////////////////////
// TMonitor_mask // TMonitor_mask
//////////////////////////////////////////////////////// ////////////////////////////////////////////////////////
@ -476,14 +434,13 @@ void TMonitor_mask::open_apri_estr_win()
if (last_fill_id != id) 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_estr();
_inclusi_mask->fill_res (); _inclusi_mask.fill_res ();
last_fill_id = id; last_fill_id = id;
} }
_inclusi_mask->run(); _inclusi_mask.run();
} }
void TMonitor_mask::open_win_estr() void TMonitor_mask::open_win_estr()
@ -495,32 +452,27 @@ void TMonitor_mask::open_win_estr()
void TMonitor_mask::open_win_conf() void TMonitor_mask::open_win_conf()
{ {
static TMask* m = nullptr; TMask m("Configurazione Archiviazione Sostitutiva", 1, 70, 20);
if (m == nullptr) m.add_button_tool(DLG_OK, "Conferma", TOOL_OK);
{ m.add_button_tool(DLG_NULL, "", 0);
m = new TMask("Configurazione Archiviazione Sostitutiva", 1, 70, 20); m.add_button_tool(DLG_QUIT, "Esci", TOOL_QUIT);
m->add_button_tool(DLG_OK, "Conferma", TOOL_OK); m.add_groupbox (CF_CODGROUP, 0, "Codice Ambiente Societa' (WEBAPP):", 1, 0, 69, 3, "");
m->add_button_tool(DLG_NULL, "", 0); m.add_string (CF_CODSOC, 0, "Codice ambiente ", 4, 1, 10, "", 10);
m->add_button_tool(DLG_QUIT, "Esci", TOOL_QUIT); 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.set_handler(DLG_OK, save_conf_handler);
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(CF_CODSOC, F9CONF.get_ambiente());
m.set(CF_ADDRDOC, F9CONF.get_addr_doc());
m->set(CF_CODSOC, F9CONF.get_ambiente()); m.set(CF_ADDRDOCLOC, F9CONF.get_addr_doc_loc());
m->set(CF_ADDRDOC, F9CONF.get_addr_doc()); m.set(CF_CARTEXP, F9CONF.get_has_cartexp());
m->set(CF_ADDRDOCLOC, F9CONF.get_addr_doc_loc()); m.run();
m->set(CF_CARTEXP, F9CONF.get_has_cartexp());
}
m->run();
} }
void TMonitor_mask::sel() const void TMonitor_mask::sel() const
@ -534,7 +486,7 @@ void TMonitor_mask::sel() const
sf.force_update(); sf.force_update();
} }
TMonitor_mask::TMonitor_mask(): TAutomask("f90100a"), _inclusi_mask(nullptr) TMonitor_mask::TMonitor_mask() : TAutomask("f90100a")
{ {
// Controllo che esistano delle categorie documentali. // Controllo che esistano delle categorie documentali.
TCategorie_doc catdoc; TCategorie_doc catdoc;
@ -592,7 +544,6 @@ void TControllo_mask::conferma_esclusi() const
if (sf.get_bool_row_cell(row, F_CESCLUDI)) if (sf.get_bool_row_cell(row, F_CESCLUDI))
{ {
const TDate today(TODAY);
TToken_string stato("", ';'); TToken_string stato("", ';');
stato.add("", 0); stato.add("", 0);
@ -643,7 +594,7 @@ void TControllo_mask::fill()
if (!_is_escluso) if (!_is_escluso)
import_error_list(); import_error_list();
else else
_controllo_mov = f9_app()._esclusi; _controllo_mov = f9_app().esclusi();
FOR_EACH_ARRAY_ROW(_controllo_mov, r, row) FOR_EACH_ARRAY_ROW(_controllo_mov, r, row)
{ {
TToken_string& sfrow = sf.row(-1); 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) if (!_is_escluso)
import_error_list(); import_error_list();
else else
_controllo_mov = f9_app()._esclusi; _controllo_mov = f9_app().esclusi();
_datada = EOTIME; _datada = EOTIME;
_dataa = 0L; _dataa = 0L;
FOR_EACH_ARRAY_ROW(_controllo_mov, r, row) FOR_EACH_ARRAY_ROW(_controllo_mov, r, row)
@ -973,10 +924,10 @@ void TApri_estr_msk::conferma_esclusi() const
{ {
const long nreg = sf.get_long_row_cell(row, FI_NUMREG); 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("", ';'); TToken_string stato("", ';');
stato.add("", 0); stato.add("", 0);
@ -1230,37 +1181,35 @@ void TF9_app::open_esclusi()
/* Prima chiedo quale mese e anno visualizzare /* Prima chiedo quale mese e anno visualizzare
*/ */
// FINESTRA // FINESTRA
static TMask* ym_msk = nullptr; TMask ym_msk("Mostra esclusi", 1, 25, 16);;
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;
_flagprov_escl = ym_msk->get(504)[0]; ym_msk.add_button_tool(DLG_OK, "Conferma", TOOL_OK);
_tipodoc_escl = ym_msk->get(505)[0]; 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 /* Caricamento esclusi
* LOADING DI QUEL MESE E ANNO */ * LOADING DI QUEL MESE E ANNO */
f9_app()._esclusi_vect.destroy(); f9_app()._esclusi_vect.destroy();
const int anno = ym_msk->get_int(501); const int anno = ym_msk.get_int(501);
const int mese = ym_msk->get_int(502); const int mese = ym_msk.get_int(502);
const int to_m = ym_msk->get_int(503); const int to_m = ym_msk.get_int(503);
TLocalisamfile movs(LF_MOV); TLocalisamfile movs(LF_MOV);
movs.setkey(2); movs.setkey(2);
const TDate from(1, mese, anno); const TDate from(1, mese, anno);
TDate to(from); TDate to(from);
@ -1299,6 +1248,7 @@ void TF9_app::open_esclusi()
} }
} }
} }
}
if (f9_app()._esclusi_vect.empty()) if (f9_app()._esclusi_vect.empty())
{ {
@ -1315,9 +1265,9 @@ void TF9_app::open_esclusi()
void TF9_app::fill_esclusi() void TF9_app::fill_esclusi()
{ {
TArray & esclusi = f9_app()._esclusi_vect; 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) FOR_EACH_ARRAY_ROW(esclusi, r, row)
sf.row(-1) = *row; sf.row(-1) = *row;
sf.force_update(); 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); descr_mask.add_string(DES_TEXT, 0, "Descrizione", 4, 1, 250, "", 40);
if (descr_mask.run() == K_ENTER) if (descr_mask.run() == K_ENTER)
{ {
TMask& msk = esclusi_mask(); TMask& msk = *f9_app()._esclusi_mask;
TArray & _esclusi = f9_app()._esclusi_vect; TArray & _esclusi = f9_app()._esclusi_vect;
TSheet_field& sf = msk.sfield(S_ESCL); TSheet_field& sf = msk.sfield(S_ESCL);
const TString descr = descr_mask.get(DES_TEXT); 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)) 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); f9_app()._estr_escluso->add_mov(mov);
_stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; _stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
const int stato = f9_app()._estr_escluso->estrai(); const int stato = f9_app()._estr_escluso->estrai();
if (stato == 1) if (stato == 1)
{ {
_esclusi.destroy(row); // Tolto il movimento estratto dal vettore e setto come estratto su elabf9 di mov _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; flag = true;
break; break;
@ -1368,14 +1318,14 @@ bool TF9_app::estrai_escl_handler(TMask_field&, KEY key)
message_box("Selezionare il movimento da estrarre"); message_box("Selezionare il movimento da estrarre");
else else
f9_app().print_log(); f9_app().print_log();
fill_esclusi(); f9_app().fill_esclusi();
} }
return true; return true;
} }
bool TF9_app::mov_handler_escl(TMask_field& f, KEY key) 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()); TToken_string& row = sf.row(sf.selected());
TRectype mov(LF_MOV); TRectype mov(LF_MOV);
mov.put(MOV_NUMREG, row.get(sf.cid2index(FE_NUMREG))); 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 TF9_app::segna_estratti(const bool escluso, const int numreg)
{ {
bool ok = true; bool ok = true;
TArray escl; // <movimento_t> TArray escl; // <TMovimento_estr>
if (escluso) if (escluso)
escl.add(movimento_t(numreg)); // todo: datareg? escl.add(TMovimento_estr(numreg)); // todo: datareg?
TArray& movs_v = escluso ? escl : _movs; TArray& movs_v = escluso ? escl : _movs;
TToken_string elab("X", ';'); // "[flag estratto]; 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]" elab.add(today.date2ansi()); elab.add(" "); // "[flag estratto];[data estrazione];[flag escluso]"
FOR_EACH_ARRAY_ITEM(movs_v, r, obj) 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()); TRectype& mov = (TRectype&) cache().get(LF_MOV, t.numreg());
mov.put(MOV_ELABF9, elab); mov.put(MOV_ELABF9, elab);
@ -1573,27 +1523,21 @@ void TF9_app::main_loop()
{ {
if (!check_table()) if (!check_table())
fatal_box("Controllo tabelle modulo fallito."); fatal_box("Controllo tabelle modulo fallito.");
#ifdef DBG _esclusi_mask = new TMask("f90100c.msk", 0, 1);
//pulisci_mov();
#endif
_msk = new TMonitor_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; _estr_msk = new TEstrai_mask;
_msk = new TMonitor_mask;
while (_msk->run() != K_QUIT) { } 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[]) int f90100(const int argc, char* argv[])
{ {
TF9_app app; TF9_app app;

213
src/f9/f90100.h
View File

@ -43,102 +43,35 @@ public:
~TEstrai_mask() { safe_delete(_estrazione); }; ~TEstrai_mask() { safe_delete(_estrazione); };
}; };
class TApri_estr_msk : public TAutomask
class TF9_app : public TSkeleton_application
{ {
//friend class TEstrai_mask; TString _idestr;
friend class TMonitor_mask; TDate _dataestr;
friend class TEstrai_mask; bool _provv;
friend class TControllo_mask; char _tipodoc;
friend class TApri_estr_msk; TString _statoestr;
friend class TEstrazione; TDate _datadal;
TDate _dataal;
bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
TEstrai_mask * _estr_msk; bool inall_handler() const;
TMonitor_mask * _msk; bool inescludi_handler() const;
TArray _movs; // movimento_t bool inselect_handler() const;
TArray _esclusi; // Vettore con i movimenti esclusi void conferma_esclusi() const;
TArray _esclusi_vect;
TToken_string _mov_escl;
char _tipodoc_escl;
char _flagprov_escl;
TString _log;
TEstrazione* _estr_escluso;
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);
public: public:
/** Mostra la finestrella per l'inserimento delle opzioni per l'estrazione e avviarla. */ void fill_estr() const;
void run_estr_msk() const { _estr_msk->run(); } void fill_res() const;
void notify_estraction() const; void set_from_row_estrazione(TToken_string& row_estrazione);
// Estrazione esclusi - handlers TApri_estr_msk();
~TApri_estr_msk() {}
static bool select_escl_notify(TSheet_field& s, int row, KEY key);
static bool controllo_escl_handler(TMask_field& field, KEY key);
static bool year_handler(TMask_field& field, KEY key);
static bool estrai_escl_handler(TMask_field&, KEY key);
void open_esclusi();
static void fill_esclusi();
movimento_t TF9_app::escl2mov(TSheet_field & sf, int row) { return movimento_t(sf, row); }
static bool mov_handler_escl(TMask_field&, KEY key);
/** Aggiorna tabella F9WA. */
void edit_wa(TString& old_codsoc) const;
// logs
void print_log();
void add_msg_log(const char* msg);
void add_sqlerror_msg_log(const char* query);
static bool is_autofattura(const TLocalisamfile& mov);
/** Segna su mov che il movimento e' stato estratto. */
bool segna_estratti(bool escluso = false, int numreg = 0);
// Controllo e aggiornamento tabelle F9
private:
bool create_tables() const; // Creazione tabelle F9.
bool check_tabelle_f9() const; // Controllo esistenza delle tabelle e in caso le crea.
bool aggiorna_tab_f9(int version) const; // Aggiorna modifiche alle tabelle F9 come descritto in cima al file f90100.cpp.
bool check_tab_version() const; // Controllo della versione e in caso aggiorna le tabelle.
bool check_table() const; // Controllo e aggiornamento versione sql. Chiamata in main_loop.
public:
void main_loop() override;
TF9_app();
~TF9_app() { safe_delete(_estr_msk); safe_delete(_msk); }
}; };
inline TF9_app& f9_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 class TMonitor_mask : public TAutomask
{ {
friend class TF9_app; // friend class TF9_app;
vector<TToken_string> _fppro; TString_array _fppro;
TApri_estr_msk * _inclusi_mask; TApri_estr_msk _inclusi_mask;
// Configurazione mask // Configurazione mask
static bool save_conf_handler(TMask_field& f, KEY key); static bool save_conf_handler(TMask_field& f, KEY key);
@ -152,17 +85,17 @@ class TMonitor_mask : public TAutomask
static void delete_estr_fld(const TString& idestr); static void delete_estr_fld(const TString& idestr);
void delete_pack(bool all = false) const; 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; bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
static void open_win_estr(); static void open_win_estr();
static void open_win_conf(); static void open_win_conf();
void sel() const; void sel() const;
public: public:
// Riempie sheet per visualizzare le estrazioni
void fill() const;
TMonitor_mask(); TMonitor_mask();
~TMonitor_mask() { safe_delete(_inclusi_mask); } ~TMonitor_mask() {}
}; };
class TControllo_mask : public TAutomask class TControllo_mask : public TAutomask
@ -199,32 +132,90 @@ public:
TControllo_mask(const char* codsoc, const char* id_estr, bool esclusi = false); TControllo_mask(const char* codsoc, const char* id_estr, bool esclusi = false);
}; };
class TApri_estr_msk : public TAutomask class TF9_app : public TSkeleton_application
{ {
TString _idestr; // friend class TMonitor_mask;
TDate _dataestr; friend class TEstrai_mask;
bool _provv; // friend class TControllo_mask;
char _tipodoc; // friend class TApri_estr_msk;
TString _statoestr; friend class TEstrazione;
TDate _datadal;
TDate _dataal;
bool on_field_event(TOperable_field& o, TField_event e, long jolly) override; 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;
char _tipodoc_escl;
char _flagprov_escl;
TString _log;
TEstrazione* _estr_escluso;
char get_tipodoc_escl() const { return _tipodoc_escl; }
// Dato il codice stato estrazione (es. "01") viene restituito il suo significato a parole (es. "in diagnostica").
TMask & esclusi_mask() { return *_esclusi_mask; }
bool inall_handler() const;
bool inescludi_handler() const;
bool inselect_handler() const;
void conferma_esclusi() const;
public: public:
void fill_estr() const; TArray & esclusi() { return _esclusi; }
void fill_res() const; TipoIVA get_tipoiva_escl() const { return get_tipodoc_escl() == 'A' ? iva_acquisti : iva_vendite; }
void set_from_row_estrazione(TToken_string& row_estrazione); 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() { _estr_msk->run(); }
void notify_estraction() const;
TApri_estr_msk(); // Estrazione esclusi - handlers
static bool select_escl_notify(TSheet_field& s, int row, KEY key);
static bool controllo_escl_handler(TMask_field& field, KEY key);
static bool year_handler(TMask_field& field, KEY key);
static bool estrai_escl_handler(TMask_field&, KEY key);
void open_esclusi();
void fill_esclusi();
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);
/** Aggiorna tabella F9WA. */
void edit_wa(TString& old_codsoc) const;
// logs
void print_log();
void add_msg_log(const char* msg);
void add_sqlerror_msg_log(const char* query);
static bool is_autofattura(const TLocalisamfile& mov);
/** Segna su mov che il movimento e' stato estratto. */
bool segna_estratti(bool escluso = false, int numreg = 0);
// Controllo e aggiornamento tabelle F9
private:
bool create_tables() const; // Creazione tabelle F9.
bool check_tabelle_f9() const; // Controllo esistenza delle tabelle e in caso le crea.
bool aggiorna_tab_f9(int version) const; // Aggiorna modifiche alle tabelle F9 come descritto in cima al file f90100.cpp.
bool check_tab_version() const; // Controllo della versione e in caso aggiorna le tabelle.
bool check_table() const; // Controllo e aggiornamento versione sql. Chiamata in main_loop.
public:
void main_loop() override;
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;
}
inline bool open_mov(const TRectype& mov) inline bool open_mov(const TRectype& mov)
{ {

47
src/f9/f90200.cpp
View File

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

279
src/f9/f90300.cpp
View File

@ -1,9 +1,4 @@
#include "f90.h" #include "f90.h"
#include <Windows.h>
#include <set>
#include <map>
#include "annessif9.h" // File 183 #include "annessif9.h" // File 183
#include "applicat.h" #include "applicat.h"
#include "automask.h" #include "automask.h"
@ -27,7 +22,7 @@ class TImport_msk : public TAutomask
{ {
friend class TGestione_doc_cartacei_f9_msk; 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; 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: case F_IMPNUMREG:
if(e == fe_modify) 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) if (c != nullptr)
{ {
set(F_CATANNPADRE, c->catdoc); set(F_CATANNPADRE, c->catdoc());
set(F_CATDOCANN, ""); set(F_CATDOCANN, "");
} }
else 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_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" 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."; "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(); TImport_msk& msk = (TImport_msk&)field.mask();
if (key == K_TAB && field.dirty() && field.full()) if (key == K_TAB && field.dirty() && field.full())
{ {
if (msk.get(F_CATANNPADRE).full()) if (msk.get(F_CATANNPADRE).full())
{ {
TCategorie_doc cd;
const TString_array names_ann = cd.get_array_ann(msk.get(F_CATANNPADRE)); const TString_array names_ann = cd.get_array_ann(msk.get(F_CATANNPADRE));
if (names_ann.items() > 0) if (names_ann.items() > 0)
{ {
bool ok = false; bool ok = false;
@ -114,21 +113,23 @@ bool TImport_msk::catdocann_handler(TMask_field& field, KEY key)
if (key == K_F9) if (key == K_F9)
{ {
const TString & catdoc_padre = msk.get(F_CATANNPADRE); const TString & catdoc_padre = msk.get(F_CATANNPADRE);
if (catdoc_padre.full()) 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 && annessi->items() > 0)
{ {
if (annessi->run() == K_ENTER) if (annessi->run() == K_ENTER)
{ {
const char* s = annessi->row(annessi->selected()).get(0); 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") if (ann->opcee() != "RC")
msk.set(F_CATDOCANN, annesso.catdoc); msk.set(F_CATDOCANN, ann->catdoc());
else else
warning_box("Impossibile importare un annesso cartaceo per un prospetto integrativo per Reverse Charge."); 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; TCategorie_doc cd;
TImport_msk& msk = (TImport_msk&)field.mask(); TImport_msk& msk = (TImport_msk&)field.mask();
if (key == K_TAB && field.dirty() && field.full()) 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()) >= 0;
const bool ok = name_cats.find(field.get()) != name_cats.end();
if (!ok) if (!ok)
{ {
msk.error_box("La categoria inserita e' inesistente"); 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() 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) if (catdocs->run() == K_ENTER)
return catdocs->row().get(0); return catdocs->row().get(0);
return ""; return "";
@ -207,7 +210,7 @@ TImport_msk::TImport_msk(): TAutomask("f90300b")
class TGestione_doc_cartacei_f9_msk : public TAutomask class TGestione_doc_cartacei_f9_msk : public TAutomask
{ {
struct doc_cart_t /* struct doc_cart_t
{ {
TString filename; TString filename;
TString loaddate; TString loaddate;
@ -222,13 +225,12 @@ class TGestione_doc_cartacei_f9_msk : public TAutomask
TString catdocann; TString catdocann;
TString loaddate; TString loaddate;
TString user; TString user;
}; }; */
const TString& _addr_cart; // Indirizzo cartella doc. cartacei F9 const TString& _addr_cart; // Indirizzo cartella doc. cartacei F9
std::unique_ptr<TMask> _config_msk; // TMask * _config_msk;
std::unique_ptr<std::set<TString>> _extensions; // todo: controllare che con TString funzioni l'ordinamento, quindi la find TString_array _extensions;
std::unique_ptr<TImport_msk> _import_msk; // TAssoc_array _list_file; // doc_cart_t
std::map<TString, doc_cart_t> _list_file; // TAssoc_array _list_ann; // ann_cart_t
std::map<TString, ann_cart_t> _list_ann;
bool on_field_event(TOperable_field& o, TField_event e, long jolly) override; 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(); void fill_docs();
static TToken_string& get_valid_extensions(); static TToken_string& get_valid_extensions();
void load_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_config_win();
void open_import_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); bool verify_extension(const TFilename& file);
public: public:
@ -414,6 +417,7 @@ void TGestione_doc_cartacei_f9_msk::edit_file()
{ {
TToken_string& row = sfield(S_IMPORTED).row(sfield(S_IMPORTED).selected()); TToken_string& row = sfield(S_IMPORTED).row(sfield(S_IMPORTED).selected());
TImport_msk win; TImport_msk win;
win.set_caption("Modifica documento cartaceo"); win.set_caption("Modifica documento cartaceo");
TLocalisamfile f9docs(LF_F9DOCS); TLocalisamfile f9docs(LF_F9DOCS);
const char* numreg = row.get(2); 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() void TGestione_doc_cartacei_f9_msk::fill_annessi()
{ {
std::set<TString> file_err; TString_array file_err;
TSheet_field& sf = sfield(S_ANNESSI); TSheet_field& sf = sfield(S_ANNESSI);
sf.hide();
sf.destroy();
TLocalisamfile ann(LF_F9ANNESSI); TLocalisamfile ann(LF_F9ANNESSI);
sf.reset();
if(ann.first() == NOERR) 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 do
{ {
TToken_string& row = sf.row(-1); const TString& namefile = ann.get(F9A_FILENAME);
const TString& numreg = ann.get(F9A_NUMREG); 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); if (not_exist)
mov.read(); file_err.add(namefile, numreg);
row.add(ann.get(F9A_FILENAME), 1); // ITEM "Nome File@25" const int row = sf.set_row_cell(F_AFILENAME, ann.get(F9A_FILENAME)); // 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"
_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); } while (ann.next() == NOERR);
} }
sf.force_update(); sf.force_update();
sf.show();
if (!file_err.empty()) if (!file_err.empty())
{ {
int count = 0; 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'; 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.size() << " file non " << (m ? "e'" : "sono") << " stat" << p <<
" trovat" << p << ".\nSi prega di rimuoverl" << p << " dall'elenco\n\nFile non trovat" << 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) if (count++ == 10)
{ {
msg << "\n" << "..."; msg << "\n" << "...";
break; break;
} }
msg << "\n" << *it << " [Num. Reg.: " << _list_ann.find(*it)->second.numreg << "]"; msg << "\n" << (TString &) *str << " [Num. Reg.: " << nr << "]";
} }
warning_box(msg); warning_box(msg);
} }
@ -508,66 +514,57 @@ void TGestione_doc_cartacei_f9_msk::fill_docs()
TLocalisamfile files(LF_F9DOCS); TLocalisamfile files(LF_F9DOCS);
TLocalisamfile mov(LF_MOV); TLocalisamfile mov(LF_MOV);
TSheet_field& sf = sfield(S_IMPORTED); TSheet_field& sf = sfield(S_IMPORTED);
sf.hide(); TString_array file_err;
sf.destroy();
_list_file.clear(); sf.reset();
std::set<TString> file_err; for (int err = files.first(); err == NOERR; err = files.next())
if (files.first() == NOERR)
{
do
{ {
const TString& namefile = files.get(F9C_FILENAME); 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); const bool not_exist = !check_file_exist(namefile);
if (not_exist) if (not_exist)
file_err.insert(namefile); file_err.add(namefile, numreg);
const TString& numreg = files.get(F9C_NUMREG);
TString datamov, caus, numdoc, nprot, descrmov; const int row = sf.set_row_cell(F_FILENAME, namefile);
mov.zero();
mov.put(MOV_NUMREG, numreg); sf.set_row_cell(F_NUMREG, numreg, row);
if (mov.read() == NOERR) sf.set_row_cell(F_DATAMOV, mov.get_date(MOV_DATAREG), row);
{ sf.set_row_cell(F_CAUS, mov.get(MOV_CODCAUS), row);
datamov = mov.get(MOV_DATAREG);
caus = mov.get(MOV_CODCAUS); TString nprot, numdoc = mov.get(MOV_NUMDOCEXT);
numdoc = mov.get(MOV_NUMDOCEXT);
if (numdoc.empty()) numdoc = mov.get(MOV_NUMDOC); 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); 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
_list_file.insert({ namefile, { namefile, files.get(F9C_LOADDATE), numreg, files.get(F9C_USER) } });
} while (files.next() == NOERR);
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.force_update();
sf.show();
if (!file_err.empty()) if (!file_err.empty())
{ {
int count = 0; 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'; 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 << ":"; " 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) if (count++ == 10)
{ {
msg << "\n" << "..."; msg << "\n" << "...";
break; break;
} }
msg << "\n" << *it << " [Num. Reg.: " << _list_file.find(*it)->second.numreg << "]"; msg << "\n" << (TString &) *str << " [Num. Reg.: " << r << "]";
} }
#ifndef DBG #ifndef DBG
const bool del = warning_box(msg); 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() 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(); TToken_string& ext = get_valid_extensions();
for (int i = 0; i < ext.items(); ++i) for (int i = 0; i < ext.items(); ++i)
{ {
TString e = ext.get(i); TString e = ext.get(i);
@ -606,62 +603,48 @@ void TGestione_doc_cartacei_f9_msk::load_extensions()
{ {
if (e.starts_with(".")) if (e.starts_with("."))
e.ltrim(1); 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() void TGestione_doc_cartacei_f9_msk::open_config_win()
{ {
// Creazione maschera TMask config_msk("Configurazione", 1, 78, 14);
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);
_config_msk->add_groupbox(DLG_NULL, 0, "@BCartella documenti cartacei", 1, 0, 76, 4); config_msk.add_button_tool(DLG_OK, "Conferma", TOOL_OK);
_config_msk->add_static (DLG_NULL, 0, "@BInserire nome cartella, all'interno della area dati della ditta", 2, 1); config_msk.add_button_tool(DLG_NULL, "", 0);
_config_msk->add_string (102, 0, "", 2, 2, 64, "", 30); config_msk.add_button_tool(DLG_QUIT, "Esci", TOOL_QUIT);
_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_groupbox(DLG_NULL, 0, "@BCartella documenti cartacei", 1, 0, 76, 4);
_config_msk->add_string (101, 0, "Estensioni:", 2, 6, 255, "", 60); 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());
_config_msk->set(101, F9CONF.get_estensioni());
TString s = F9CONF.get_addr_cart(); TString s = F9CONF.get_addr_cart();
s.rtrim(1); s.rtrim(1);
s.ltrim(s.rfind('\\') + 1); s.ltrim(s.rfind('\\') + 1);
_config_msk->set(102, s); config_msk.set(102, s);
}
// Esecuzione maschera // Esecuzione maschera
while (true) if (config_msk.run() == K_ENTER)
{ {
if (_config_msk->run() != K_ENTER) TString dir = config_msk.get(102);
{
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);
if (dir.empty()) if (dir.empty())
{ {
if(yesno_box("Nome cartella vuoto.\nCreare cartella con nome 'Cartacei_F9'?")) if(yesno_box("Nome cartella vuoto.\nCreare cartella con nome 'Cartacei_F9'?"))
_config_msk->set(102, dir = "Cartacei_F9"); config_msk.set(102, dir = "Cartacei_F9");
else continue; else return;
} }
F9CONF.set_estensioni(config_msk.get(101));
TFilename path(prefix().get_studio()); TFilename path(prefix().get_studio());
path.add(dir).slash_terminate(); path.add(dir).slash_terminate();
@ -672,33 +655,33 @@ void TGestione_doc_cartacei_f9_msk::open_config_win()
if (!make_dir(path)) if (!make_dir(path))
{ {
warning_box("Impossibile creare il percorso specificato."); warning_box("Impossibile creare il percorso specificato.");
continue; return;
} }
} }
else continue; else return;
} }
F9CONF.set_addr_cart(path); F9CONF.set_addr_cart(path);
break;
} }
} }
void TGestione_doc_cartacei_f9_msk::open_import_win() void TGestione_doc_cartacei_f9_msk::open_import_win()
{ {
if(_import_msk == nullptr) TImport_msk import_msk;
_import_msk = make_unique<TImport_msk>();
while(_import_msk->run() == K_ENTER) while(import_msk.run() == K_ENTER)
{ {
const TString& file = _import_msk->get(F_IMPADDRESS); const TString& file = import_msk.get(F_IMPADDRESS);
const TString& numreg = _import_msk->get(F_IMPNUMREG); const long numreg = import_msk.get_long(F_IMPNUMREG);
const bool is_annesso = _import_msk->get_bool(F_ISANNESSO); const bool is_annesso = import_msk.get_bool(F_ISANNESSO);
const TString& catannpadre = _import_msk->get(F_CATANNPADRE); const TString& catannpadre = import_msk.get(F_CATANNPADRE);
const TString& catdocann = _import_msk->get(F_CATDOCANN); const TString& catdocann = import_msk.get(F_CATDOCANN);
if (!file.empty()) if (!file.empty())
{ {
TFilename f(file); TFilename f(file);
if (verify_extension(f)) if (verify_extension(f))
{ {
if(!numreg.empty()) if (numreg != 0)
{ {
if (!is_annesso || catannpadre.full() && catdocann.full()) if (!is_annesso || catannpadre.full() && catdocann.full())
{ {
@ -723,13 +706,13 @@ void TGestione_doc_cartacei_f9_msk::open_import_win()
fill(); 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); TLocalisamfile f9cart(LF_F9DOCS);
for(auto it = files.begin(); it != files.end(); ++it) FOR_EACH_ARRAY_ROW(files, row, str)
{ {
f9cart.zero(); f9cart.zero();
f9cart.put(F9C_FILENAME, *it); f9cart.put(F9C_FILENAME, (const TString &) *str);
f9cart.read(); f9cart.read();
f9cart.remove(); 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) bool TGestione_doc_cartacei_f9_msk::verify_extension(const TFilename& file)
{ {
load_extensions(); 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()) TGestione_doc_cartacei_f9_msk::TGestione_doc_cartacei_f9_msk(): TAutomask("f90300a"), _addr_cart(F9CONF.get_addr_cart())

76
src/f9/f90400.cpp
View File

@ -81,42 +81,49 @@ void TF9_test_app::main_loop()
preload.add_annesso("FATTACQ", "LEASING", "Annesso leasing", "DC"); preload.add_annesso("FATTACQ", "LEASING", "Annesso leasing", "DC");
CHECK(preload.get_array_rows().items() > 0, "Errore aggiunta o caricamento categorie documentali."); 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"); TClasse_doc get_classe_doc_right{ "ACQREV", "Fattura acq. con rev. charge", "FTA", "TD01", "052", "FA" };
CHECK(get_classe_doc->catdoc == get_classe_doc_right.catdoc &&
get_classe_doc->descr == get_classe_doc_right.descr && const TClasse_doc* get_classe_doc = preload.get_classe_doc("ACQREV");
get_classe_doc->class_sost == get_classe_doc_right.class_sost &&
get_classe_doc->caus_sost == get_classe_doc_right.caus_sost && CHECK(get_classe_doc->catdoc() == get_classe_doc_right.catdoc() &&
get_classe_doc->causcont == get_classe_doc_right.causcont && get_classe_doc->descr() == get_classe_doc_right.descr() &&
get_classe_doc->tipocaus == get_classe_doc_right.tipocaus, "get_classe_doc failed" 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() && TString_array * catdocs = preload.get_name_catdocs();
get_name_catdocs.find("FATTVEN") != get_name_catdocs.end() &&
get_name_catdocs.find("NOTCREDACQ") != get_name_catdocs.end() && CHECK(catdocs->find("FATTACQ") >= 0 && catdocs->find("FATTVEN") >= 0 && catdocs->find("NOTCREDACQ") >= 0 &&
get_name_catdocs.find("NOTDEBVEN") != get_name_catdocs.end() && catdocs->find("NOTDEBVEN") >= 0 && catdocs->find("FATTCORR") >= 0 && catdocs->find("ACQREV") >= 0, "Get catdocs failed");
get_name_catdocs.find("FATTCORR") != get_name_catdocs.end() &&
get_name_catdocs.find("ACQREV") != get_name_catdocs.end(), "Get catdocs failed" const TClasse_doc* mov2cat = preload.mov2cat(95752);
);
const TCategorie_doc::classe_doc* mov2cat = preload.mov2cat(95752);
CHECK(mov2cat, "mov2cat failed: classe doc is null"); CHECK(mov2cat, "mov2cat failed: classe doc is null");
mov2cat = preload.mov2cat(96955); // Rev. charge causale 052 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"; const TString cat_selected = "FATTACQ";
TCategorie_doc catdoc; 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())); 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(); 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())); 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 rec(TRecord_categorie::catdocs);
TRecord_categorie rec2(TRecord_categorie::annessi); TRecord_categorie rec2(TRecord_categorie::annessi);
rec.put("NAME", "FATTACQ"); rec.put("NAME", "FATTACQ");
rec.read(); rec.read();
TString name = rec.get("NAME"); TString name = rec.get("NAME");
@ -145,31 +152,21 @@ void TF9_test_app::main_loop()
if (false) if (false)
{ {
TF9_doccart doccart; TF9_doccart doccart;
TString old_numreg; old_numreg << 95752; long old_numreg = 95752;
TFilename doc; TFilename doc;
TString_array list_annessi; TString_array list_annessi;
vector<annesso_t> vect_annessi; TArray vect_annessi; // TAnnesso_mov
//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); bool movdoc = doccart.mov2doc(old_numreg, doc);
TString msg("Error retriving filename from reg n. "); msg << old_numreg; TString msg("Error retriving filename from reg n. "); msg << old_numreg;
CHECK(movdoc && TString(doc.name()) == "ve1300_F01_0000000011_0002237.pdf", (const char*)msg); 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); 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); //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); 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); //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) if(false)
@ -199,10 +196,10 @@ void TF9_test_app::main_loop()
TString codfisc; TString codfisc;
//TEstrazione::fill_id(clifo, statopaiv, idfisc, paiv, codfisc); //TEstrazione::fill_id(clifo, statopaiv, idfisc, paiv, codfisc);
TCategorie_doc::annesso annesso; TAnnesso *annesso = nullptr;
TCategorie_doc categorie_doc; 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); TEstrazione::make_prosp_int_revc(153480, annesso);
TString s = get_numdoc_exp_fp(105396); TString s = get_numdoc_exp_fp(105396);
@ -210,9 +207,6 @@ void TF9_test_app::main_loop()
message_box("TESTS COMPLETELY SUCCESSFUL"); message_box("TESTS COMPLETELY SUCCESSFUL");
} }
int f90400(const int argc, char* argv[]) int f90400(const int argc, char* argv[])
{ {
TF9_test_app test_app; 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

225
src/f9/f9lib.h
View File

@ -1,9 +1,9 @@
#ifndef __F901001_H #ifndef __F901001_H
#define __F901001_H #define __F901001_H
#include <map> // #include <map>
#include <set> // #include <set>
#include <vector> // #include <vector>
#include "strings.h" #include "strings.h"
#include "date.h" #include "date.h"
@ -23,14 +23,35 @@
const char* check_str(const TString& str); const char* check_str(const TString& str);
const TString & get_numdoc_exp_fp(int numreg); const TString & get_numdoc_exp_fp(int numreg);
struct annesso_t class TAnnesso_mov : public TObject
{ {
TString numreg; // TString ez-pz long _numreg;
TString filename; TString _filename;
TString catdocpad; TString _catdocpad;
TString catdocann; TString _catdocann;
TDate loaddate; TDate _loaddate;
TString user; 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 struct statistics
@ -130,38 +151,79 @@ public:
extern TF9_config F9CONF; 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 class TCategorie_doc
{ {
public: TAssoc_array _rows; // TClasse_doc *
struct classe_doc TAssoc_array _sheets_annessi; // TArray_sheet *
{ TArray_sheet * _sheet_catdocs;
TString catdoc; // Codice cat. documentale. TString_array * _name_catdocs;
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; int _mode_sheet;
TCategorie_doc::classe_doc * find_causcont(const TString& caus) const ; // OK TClasse_doc * find_causcont(const TString& caus); // OK
TCategorie_doc::classe_doc * find_tipodoc(const TString& tipodoc) const ; // OK TClasse_doc * find_tipodoc(const TString& tipodoc); // OK
TCategorie_doc::classe_doc * find_tipodocsdi(const TString& tipodocsdi, const char * tipocaus) const ; // 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 load_all();
void save_ann(); void save_ann();
@ -172,9 +234,9 @@ private:
static const char* traduci_class_sost(const TString& class_sost); static const char* traduci_class_sost(const TString& class_sost);
protected: 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: public:
void add_annesso(const TString& catdoc_padre, const TString& catdoc_ann, const TString& descr, 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, void add_categoria(const TString& catdoc, const TString& descr, const TString& class_sost,
const TString& caus_sost, const TString& causcont, const TString& tipocaus); 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); 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_ann(const TString& catdoc);
TString_array get_array_rows(bool traduci = false); TString_array get_array_rows(bool traduci = false);
classe_doc* get_classe_doc(const TString& catdoc); TClasse_doc* get_classe_doc(const TString& catdoc) { return (TClasse_doc *)_rows.objptr(catdoc); }
std::set<TString>& get_name_catdocs() { get_sheet_catdocs(); return *_name_catdocs; } TString_array * get_name_catdocs() { get_sheet_catdocs(); return _name_catdocs; }
std::shared_ptr<TArray_sheet> get_sheet_catdocs(); TArray_sheet * get_sheet_catdocs();
std::shared_ptr<TArray_sheet> get_sheet_ann(const TString& catdoc); TArray_sheet * get_sheet_ann(const TString& catdoc);
classe_doc * mov2cat(const long numreg); TClasse_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; } 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(); void reload();
static void remove_all(); static void remove_all();
static void remove_all_ann(); static void remove_all_ann();
@ -243,7 +305,7 @@ enum err_mov
mov_annesso_nexist // Un annesso obbligatorio e' mancante. 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. TString _descr_err; // Messaggio di errore visibile dal controllo estrazione.
bool _estratto; bool _estratto;
err_mov _descr_estr; // Messaggio di informazioni visibile dal 'Apri Estr.' err_mov _descr_estr; // Messaggio di informazioni visibile dal 'Apri Estr.'
TCategorie_doc::classe_doc* _catdoc;
bool _cartaceo; bool _cartaceo;
TFilename _nomefilecart; TFilename _nomefilecart;
vector<annesso_t> _annessi; TArray _annessi; // TAnnesso_mov
TMovimento_estr & copy(const TMovimento_estr & m);
public: 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); static const char* err_mov2name(const err_mov descr_estr);
const char* get_descr_estr() const { return err_mov2name(_descr_estr); } const char* get_descr_estr() const { return err_mov2name(_descr_estr); }
bool err() const { return _err; } bool err() const { return _err; }
@ -288,8 +353,8 @@ public:
const TString & descr_err() const { return _descr_err; } const TString & descr_err() const { return _descr_err; }
bool estratto() const { return _estratto; } bool estratto() const { return _estratto; }
err_mov descr_estr() const { return _descr_estr; } err_mov descr_estr() const { return _descr_estr; }
TCategorie_doc::classe_doc* catdoc() const { return _catdoc; } TClasse_doc* catdoc(TCategorie_doc& catdoc) const { return catdoc.mov2cat(numreg()); }
vector<annesso_t> annessi() const { return _annessi; } TArray & annessi() { return _annessi; }
bool cartaceo() const { return _cartaceo; } // todo bool cartaceo() const { return _cartaceo; } // todo
const TFilename & nomefilecart() const { return _nomefilecart; } 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_descr_estr(err_mov descr_estr) { _descr_estr = descr_estr; }
void set_numdoc(const char * numdoc) { _numdoc = numdoc; } void set_numdoc(const char * numdoc) { _numdoc = numdoc; }
void set_estratto(bool estratto) { _estratto = estratto; } 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; } void set_nomefilecart(const char * nomefilecart) { _nomefilecart = nomefilecart; }
movimento_t(TSheet_field& sf, int row); TMovimento_estr(TSheet_field& sf, int row);
movimento_t(const long numreg); TMovimento_estr(const long numreg);
movimento_t(TISAM_recordset & mov, TipoIVA tipo, bool escl); TMovimento_estr (const TMovimento_estr & m) { copy(m); }
~movimento_t() { safe_delete(_catdoc); }
TMovimento_estr(TISAM_recordset & mov, TipoIVA tipo, bool escl);
~TMovimento_estr() {}
}; };
class TEstrazione : public TObject class TEstrazione : public TObject
{ {
drd _head; drd _head;
vector<movimento_t> _movs; TArray _movs; // TMovimento_estr
ofstream * _error_sql; ofstream * _error_sql;
bool _escluso; bool _escluso;
const TString _descr; const TString _descr;
@ -325,11 +391,11 @@ class TEstrazione : public TObject
*/ */
bool update_drd_stato_estr() const; bool update_drd_stato_estr() const;
static const char* caus_sos(const TLocalisamfile& mov, TipoIVA iva); 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. // 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_annessi_oblig(const TString& catdoc, int numreg, TToken_string& ann_nexist);
static bool check_cartaceo_acq(const movimento_t& movimento); static bool check_cartaceo_acq(const TMovimento_estr& movimento);
static bool check_documento_vendita(const TLocalisamfile& mov, _Out_ bool& exist_doc); static bool check_documento_vendita(const TLocalisamfile& mov, bool& exist_doc);
/** CHECK RIFERIMENTO FPPRO /** CHECK RIFERIMENTO FPPRO
* Per le fatture di acquisto controllo se ho il riferimento nell'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 * 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); static state_fppro check_fppro(int numreg);
bool check_periodo_def() const; 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); 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; } TipoIVA get_tipoiva() const { return _head.tipo_doc == 'A' ? iva_acquisti : iva_vendite; }
static bool is_doc_xml(const TRectype& mov); static bool is_doc_xml(const TRectype& mov);
static bool find_movcoll(int numreg, _Out_ TString& numreg_rev_vend); static bool find_movcoll(int numreg, TString& numreg_rev_vend);
static bool load_annessi(movimento_t& movimento); 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. // 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); static bool stampa_documento(const TMovimento_estr& movimento, TFilename& file);
bool grab_pdf_from_spotlite(const movimento_t& movimento, TFilename& file) const; bool grab_pdf_from_spotlite(const TMovimento_estr& movimento, TFilename& file) const;
public: public:
static bool make_prosp_int_revc(int numreg, TCategorie_doc::annesso& annesso); static bool make_prosp_int_revc(int numreg, TAnnesso * TAnnesso);
private: private:
@ -374,7 +440,7 @@ private:
public: public:
void add_mov(const movimento_t& movimento); void add_mov(TMovimento_estr * movimento) { _movs.add(movimento); }
/** DIAGNOSTICA GESTIONALE. /** DIAGNOSTICA GESTIONALE.
* Controllo lo stato delle fatture: * Controllo lo stato delle fatture:
* Per le fatt. acquisto non collegate a fppro cerca di agganciarle. * Per le fatt. acquisto non collegate a fppro cerca di agganciarle.
@ -406,7 +472,7 @@ public:
// Getters // Getters
TString get_id_estr() const { return _head.id_estr; } TString get_id_estr() const { return _head.id_estr; }
TString4 get_stato_estr() const { return _head.stato_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 // Setters
void set_provvisorio(bool flag_prov) { _head.flag_prov = flag_prov; } void set_provvisorio(bool flag_prov) { _head.flag_prov = flag_prov; }
@ -447,43 +513,44 @@ public:
class TIva_insert_prepared_stat class TIva_insert_prepared_stat
{ {
vector<pair<TString, TString>> _fields; TAssoc_array _fields; // TString
bool _ok{ true }; bool _ok{ true };
TString _query; 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(); void write();
public: public:
void add(const char* field, const TString& str, int len = -1); 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 char* str, int len = -1);
void add(const char* field, const TDate& date); void add(const char* field, const TDate& date);
void add(const char* field, char c); void add(const char* field, char c);
void add(const char* field, long l); void add(const char* field, long l);
void add(const char* field, const int n) { add(field, (long)n); } 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); bool get(TString& query);
void reset(); void reset();
}; };
class TF9_doccart class TF9_doccart
{ {
TLocalisamfile _tdocs;
TLocalisamfile _tannessi; TLocalisamfile _tannessi;
public: 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); const TString& catannpadre = "", const TString& catdocann = "", bool suppress_errors = true);
bool doc_already_exists(const TFilename& file, TString& numreg, bool& annesso); bool doc_already_exists(const TFilename& file, long & numreg, bool& TAnnesso);
bool mov2doc(const TString& numreg, TFilename& doc); bool mov2doc(long numreg, TFilename& doc);
bool mov2listann(const TString& numreg, TString_array & list_annessi); bool mov2listann(const TString& numreg, TString_array & list_annessi);
bool mov2listann_vect(const TString& numreg, vector<annesso_t>& list_annessi); bool mov2listann_vect(const long numreg, TArray & list_annessi);
static TString get_full_path_file_cartaceo(const TString& filename) static TString get_full_path_file_cartaceo(const TString& filename)
{ {
return TString() << TFilename(F9CONF.get_addr_cart()).slash_terminate() << filename; return TString() << TFilename(F9CONF.get_addr_cart()).slash_terminate() << filename;
} }
TF9_doccart() : _tdocs(LF_F9DOCS), _tannessi(LF_F9ANNESSI) { } TF9_doccart() : _tannessi(LF_F9ANNESSI) { }
}; };

730
src/f9/f9lib01.cpp
View File

File diff suppressed because it is too large Load Diff

98
src/f9/f9lib02.cpp
View File

@ -74,18 +74,19 @@ TF9_config::TF9_config()
// TF9_doccart // 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) const TString& catannpadre, const TString& catdocann, bool suppress_errors)
{ {
TString numreg_old; long numreg_old;
bool annesso; bool annesso_found;
TF9_doccart f9cart; TF9_doccart f9cart;
TLocalisamfile f9docs(LF_F9DOCS); TLocalisamfile f9docs(LF_F9DOCS);
TLocalisamfile f9annessi(LF_F9ANNESSI); 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) 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; 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 // 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 // Prendo la lista degli annessi per questa registrazione e li controllo in cerca della categoria
TF9_doccart doccart; TF9_doccart doccart;
vector<annesso_t> list_annessi; TArray list_annessi;
doccart.mov2listann_vect(numreg, list_annessi); doccart.mov2listann_vect(numreg, list_annessi);
bool exist = false; 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; exist = true;
} }
if (exist) if (exist)
@ -162,40 +166,39 @@ bool TF9_doccart::add_cart(const TFilename& file, const TString& numreg, const b
return true; 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; annesso = false;
_tdocs.zero();
_tdocs.setkey(2); const TRectype & tdocs = cache().get(LF_F9DOCS, file.name(), 2);
_tdocs.put(F9C_FILENAME, file.name()); bool ok = tdocs.full();
bool ok = _tdocs.read() == NOERR;
if (ok) if (ok)
numreg = _tdocs.get(F9C_NUMREG); numreg = tdocs.get_long(F9C_NUMREG);
else else
{ {
numreg = 0L;
_tannessi.zero(); _tannessi.zero();
_tannessi.setkey(2); _tannessi.setkey(2);
_tannessi.put(F9A_FILENAME, file.name()); _tannessi.put(F9A_FILENAME, file.name());
ok = _tannessi.read() == NOERR; ok = _tannessi.read() == NOERR;
if (ok) if (ok)
{ {
numreg = _tannessi.get(F9A_NUMREG); numreg = _tannessi.get_long(F9A_NUMREG);
annesso = true; annesso = true;
} }
} }
return ok; return ok;
} }
bool TF9_doccart::mov2doc(const TString& numreg, _Out_ TFilename& doc) bool TF9_doccart::mov2doc(long numreg, TFilename& doc)
{ {
_tdocs.zero(); const TRectype & tdocs = cache().get(LF_F9DOCS, numreg);
_tdocs.setkey(1); // Ricerca per NUMREG const bool ok = tdocs.full();
_tdocs.put(F9C_NUMREG, numreg);
const bool ok = _tdocs.read() == NOERR;
doc.cut(0); doc.cut(0);
if (ok) 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; return ok;
} }
@ -228,54 +231,46 @@ bool TF9_doccart::mov2listann(const TString& numreg, _Out_ TString_array& list_a
return ok; 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.zero();
_tannessi.setkey(1); _tannessi.setkey(1);
_tannessi.put(F9A_NUMREG, numreg); _tannessi.put(F9A_NUMREG, numreg);
TString numreg_fetched;
bool ok = false; bool ok = false;
// Si posiziona nl primo record giusto. Poi per sapere quando terminare guardo se la chiave e' ancora quella giusta. // 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())
{
long numreg_fetched = _tannessi.get_long(F9A_NUMREG);
if (numreg_fetched == numreg)
{ {
ok = true; ok = true;
TString filename = _tannessi.get(F9A_FILENAME); TString filename = _tannessi.get(F9A_FILENAME);
annesso_t t; TAnnesso_mov t(numreg_fetched, _tannessi.get(F9A_FILENAME), _tannessi.get(F9A_CATDOCPAD),
t.numreg = numreg_fetched; _tannessi.get(F9A_CATDOCANN), _tannessi.get_date(F9A_LOADDATE), _tannessi.get(F9A_USER));
t.filename = _tannessi.get(F9A_FILENAME);
t.catdocpad = _tannessi.get(F9A_CATDOCPAD); list_annessi.add(t);
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
} }
else
break;
}
return ok; return ok;
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// TIva_insert_prepared_stat // 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() void TIva_insert_prepared_stat::write()
{ {
TString vals_appo; TString vals_appo;
_query.cut(0) << "INSERT INTO " F9_IVA " (\n"; _query.cut(0) << "INSERT INTO " F9_IVA " (\n";
int count = 0; int count = 0;
bool first = true; bool first = true;
for(auto it = _fields.begin(); it != _fields.end(); ++it) FOR_EACH_ASSOC_OBJECT(_fields, hash, key, obj)
{ {
if (!first) if (!first)
{ {
@ -287,8 +282,8 @@ void TIva_insert_prepared_stat::write()
_query << "\n"; _query << "\n";
vals_appo << "\n"; vals_appo << "\n";
} }
_query << it->first; _query << key;
vals_appo << it->second; vals_appo << *(TString *) obj;
first = false; first = false;
count = ++count % 3; count = ++count % 3;
} }
@ -333,11 +328,6 @@ void TIva_insert_prepared_stat::add(const char* field, long l)
add_value(field, v); 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) bool TIva_insert_prepared_stat::get(TString& query)
{ {
if (_query.empty()) if (_query.empty())
@ -348,7 +338,7 @@ bool TIva_insert_prepared_stat::get(TString& query)
void TIva_insert_prepared_stat::reset() void TIva_insert_prepared_stat::reset()
{ {
_fields.clear(); _fields.destroy();
_ok = true; _ok = true;
_query.cut(0); _query.cut(0);
} }