8e5e264e6f
Files correlati : tf cg Commento : - Aggiunto break in cg1300 - Reso non bloccante controllo iniziale "Aggiornamento tipo conto cliente/fornitore"
837 lines
25 KiB
C++
837 lines
25 KiB
C++
/* Gestione maschera */
|
||
|
||
#include "tf0100b.h"
|
||
#include <utility.h>
|
||
#include "urldefid.h"
|
||
|
||
/////////////////////////////////////////////////////////////////////////////////////
|
||
// TTrFa_mask
|
||
/////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
TTrFa_mask::~TTrFa_mask()
|
||
{
|
||
TSheet_field& sheet = sfield(F_RIGHE);
|
||
if(!sheet.empty())
|
||
sheet.destroy();
|
||
}
|
||
|
||
void TTrFa_mask::next_page(int p)
|
||
{
|
||
TAutomask::next_page(p);
|
||
if (_filter_changed)
|
||
{
|
||
TSheet_field & sf = sfield(F_RIGHE);
|
||
if (curr_win() == sf.parent())
|
||
{
|
||
load_sheet();
|
||
sf.force_update();
|
||
_filter_changed = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
bool TTrFa_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
|
||
{
|
||
switch (o.dlg())
|
||
{
|
||
case F_DATAFIN:
|
||
if (e == fe_init)
|
||
o.set(TDate(TODAY));
|
||
break;
|
||
case DLG_ALL:
|
||
if (e == fe_button)
|
||
{
|
||
TSheet_field& docs = sfield(F_RIGHE);
|
||
TString_array& sht = docs.rows_array();
|
||
const int items = sht.items();
|
||
|
||
if (items > 0)
|
||
{
|
||
const TString4 select = *(sht.row(0).get(0)) == 'X' ? "" : "X";
|
||
for (int i = 0; i < items; i++)
|
||
sht.row(i).add(select, 0);
|
||
docs.force_update();
|
||
}
|
||
}
|
||
break;
|
||
case DLG_PDF:
|
||
if(e == fe_button)
|
||
{
|
||
TMask cs_mask("Cambiamento stato movimenti", 1, 30, 5);
|
||
cs_mask.add_button_tool(DLG_OK, "~Conferma", TOOL_OK);
|
||
cs_mask.add_button_tool(DLG_CANCEL, "Annulla", TOOL_CANCEL);
|
||
cs_mask.add_list(101, 0, "Da stato", 0, 0, 15, "", "X|I|N|F|E", "Da Inviare|Inviato|Disabilitato|Forzato|Errato");
|
||
cs_mask.add_list(102, 0, "A stato", 0, 2, 15, "", "X|I|N|F|E", "Da Inviare|Inviato|Disabilitato|Forzato|Errato");
|
||
if (cs_mask.run() == K_ENTER)
|
||
{
|
||
update_stato(cs_mask.get(101), cs_mask.get(102));
|
||
}
|
||
}
|
||
break;
|
||
case F_RIGHE:
|
||
if (e == se_notify_add)
|
||
{
|
||
TSheet_field& s = dynamic_cast<TSheet_field&>(o);
|
||
TToken_string& row = s.row(jolly);
|
||
row.add(nuovo_progr(), s.cid2index(A_NUMERO));
|
||
row.add(get(F_TIPOCF), s.cid2index(A_TIPOCF));
|
||
} else
|
||
if (e == se_query_del)
|
||
{
|
||
TSheet_field& s = dynamic_cast<TSheet_field&>(o);
|
||
TToken_string& row = s.row(jolly);
|
||
const TRecnotype progr = row.get_long(0);
|
||
return progr >= MOV_CUSTOM;
|
||
} else
|
||
if(e == se_enter)
|
||
{
|
||
//primaNota(o,e);
|
||
}
|
||
break;
|
||
case A_DATAREG:
|
||
{
|
||
// Mi interessa solo fe_edit
|
||
if(e != fe_modify) break;
|
||
// Controllo che la data sia < della data documento e l'esercizio sia quello richiesto
|
||
TDate datareg = static_cast<const char*>(o.get()), datadoc = o.mask().get_date(A_DATADOC);
|
||
if(datareg >= get_date(F_DATAINI) && datareg <= get_date(F_DATAFIN))
|
||
{
|
||
// Controllo la data del documento
|
||
if(datadoc.ok())
|
||
{
|
||
if(datadoc > datareg)
|
||
{
|
||
error_box("La data del documento <20> antecedente a quella di registrazione");
|
||
o.set("");
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
error_box("La data di registrazione non appartiene al periodo corrente");
|
||
o.set("");
|
||
}
|
||
}
|
||
break;
|
||
case A_DATADOC:
|
||
{
|
||
// Mi interessa solo fe_edit
|
||
if(e != fe_modify) break;
|
||
TDate datareg = o.mask().get_date(A_DATAREG), datadoc = static_cast<const char*>(o.get());
|
||
// Controllo la data di registrazione
|
||
if(datareg.ok())
|
||
{
|
||
if(datadoc > datareg)
|
||
{
|
||
error_box("La data del documento <20> antecedente a quella di registrazione");
|
||
o.set("");
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case A_ALIQUOTA:
|
||
if(e == fe_modify)
|
||
{
|
||
// Calcolo la natura
|
||
o.mask().set(A_NATURA, natura(o.get()));
|
||
// Se esiste un imponibile calcolo l'imposta
|
||
real imponibile = o.mask().get_real(A_IMPONIBILE), imposta = ZERO;
|
||
if(imponibile > 0)
|
||
{
|
||
imposta = imponibile * real(cache().get("%IVA", o.get(), "R0")) / 100;
|
||
if(imposta != o.mask().get_real(A_IMPOSTA) && yesno_box("Aggiornare l'imposta?"))
|
||
o.mask().set(A_IMPOSTA, imposta.round(2).string());
|
||
}
|
||
}
|
||
break;
|
||
case A_IMPONIBILE:
|
||
if(e == fe_modify)
|
||
{
|
||
// Se esiste l'iva calcolo l'imposta
|
||
real imponibile = static_cast<const char*>(o.get()), imposta = ZERO;
|
||
TString codiva = o.mask().get(A_ALIQUOTA);
|
||
if(codiva.full())
|
||
{
|
||
imposta = imponibile * real(cache().get("%IVA", codiva, "R0")) / 100;
|
||
if(imposta != o.mask().get_real(A_IMPOSTA) && yesno_box("Aggiornare l'imposta?"))
|
||
o.mask().set(A_IMPOSTA, imposta.round(2).string());
|
||
}
|
||
}
|
||
break;
|
||
case A_IMPOSTA:
|
||
if(e == fe_modify)
|
||
{
|
||
// Controllo dell'esistenza sia di codiva che dell'imponibile e verifico che l'importo immesso sia corretto
|
||
real imponibile = o.mask().get_real(A_IMPONIBILE), imposta = ZERO;
|
||
TString codiva = o.mask().get(A_ALIQUOTA);
|
||
if(codiva.full() && imponibile > ZERO)
|
||
{
|
||
imposta = imponibile * real(cache().get("%IVA", codiva, "R0")) / 100; imposta = imposta.round(2);
|
||
// Controllo che l'aliquota calcolata sia == a quella che ho qua
|
||
real imposta_inserita = static_cast<const char*>(o.get());
|
||
if(imposta_inserita != imposta)
|
||
{
|
||
TString msg;
|
||
msg << "Attenzione!! Il valore immesso " << imposta_inserita.string() << "<EFBFBD> non <20> corretto!\n";
|
||
msg << "Valore corretto: " << imposta.string() << "<EFBFBD>\nVuoi proseguire?";
|
||
if(!yesno_box(msg))
|
||
{
|
||
o.set(imposta.string());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case A_TIPOCF:
|
||
case A_CODCF:
|
||
case A_OCFPI:
|
||
{
|
||
if(e != fe_modify) break;
|
||
// Leggo dal clifo
|
||
TString tipocf, codcf, ocfpi;
|
||
tipocf = o.mask().get(A_TIPOCF);
|
||
codcf = o.mask().get(A_CODCF);
|
||
ocfpi = o.mask().get(A_OCFPI);
|
||
TRectype app = getCli(tipocf, codcf, ocfpi);
|
||
o.mask().set(A_RAGSOC, app.get("RAGSOC"));
|
||
o.mask().set(A_RFSO, app.get("CODRFSO"));
|
||
o.mask().set(A_RAGSOCRFSO, get_rfso(app.get("CODRFSO")));
|
||
o.mask().set(A_PAIV, app.get("PAIV"));
|
||
o.mask().set(A_COFI, app.get("COFI"));
|
||
|
||
// Abilito se il cliente <20> occasionale
|
||
o.mask().enable(A_OCFPI, app.get_bool("OCCAS"));
|
||
|
||
// Controllo autofattura
|
||
TString key; key << prefix().firm().get("TIPOA") << "|" << prefix().firm().get("CODANAGR");
|
||
TString piva = cache().get(LF_ANAG, key, "PAIV");
|
||
if(piva == app.get("PAIV"))
|
||
{
|
||
// Autofattura!
|
||
o.mask().set(A_AUTOFATT, "X");
|
||
}
|
||
}
|
||
break;
|
||
case DLG_SAVEREC:
|
||
if(e == fe_button)
|
||
save_all();
|
||
break;
|
||
case DLG_ARCHIVE:
|
||
if(e == fe_button)
|
||
check_all();
|
||
break;
|
||
case DLG_EDIT:
|
||
if(e == fe_button)
|
||
{
|
||
TSheet_field& sheet = sfield(F_RIGHE);
|
||
if(sheet.items() > 0)
|
||
{
|
||
sheet.esporta();
|
||
}
|
||
else
|
||
{
|
||
warning_box("Impossibile esportare una griglia vuota");
|
||
}
|
||
}
|
||
break;
|
||
case DLG_RECALC:
|
||
if(e == fe_button)
|
||
next_page(1);
|
||
break;
|
||
case DLG_USER:
|
||
if (e == fe_button || e == fe_init)
|
||
{
|
||
const long numreg = o.mask().get_long(A_NUMERO);
|
||
const bool enab = (numreg > 0) && (numreg < MOV_CUSTOM);
|
||
if (e == fe_button && enab)
|
||
{
|
||
o.disable(); // Tecnica anti doppio click!
|
||
TRectype mov(LF_MOV);
|
||
mov.put("NUMREG", numreg);
|
||
mov.edit();
|
||
o.enable();
|
||
}
|
||
else
|
||
o.enable(enab);
|
||
}
|
||
break;
|
||
case DLG_DELREC:
|
||
if (e == fe_button && o.active())
|
||
{
|
||
const long progr = o.mask().get_long(A_NUMERO);
|
||
TString codalq = o.mask().get(A_ALIQUOTA);
|
||
TString key; key << progr << "|" << codalq;
|
||
if(cache().get(LF_TRASFATT, key).full())
|
||
{
|
||
TLocalisamfile trasfat(LF_TRASFATT);
|
||
trasfat.put("NUMREG", progr);
|
||
trasfat.put("CODIVA", codalq);
|
||
const int err = trasfat.remove();
|
||
if (err != NOERR)
|
||
return error_box(FR("Errore di cancellazione: %d"), err);
|
||
}
|
||
else
|
||
return error_box(TR("Riga non cancellabile"));
|
||
|
||
// Elimino la riga
|
||
TSheet_field& sheet = sfield(F_RIGHE);
|
||
// Vado a cercare la riga
|
||
FOR_EACH_SHEET_ROW(sheet, r, strarr)
|
||
{
|
||
long this_prog;
|
||
TString this_alq;
|
||
strarr->get(_numero, this_prog);
|
||
strarr->get(_aliquota, this_alq);
|
||
if(this_prog == progr && this_alq == codalq) break;
|
||
}
|
||
sheet.destroy(r); // Aggiorna in automatico
|
||
|
||
// Se ha cancellato un movimento custom che deriva dalla prima nota propongo di andarlo a ripescare
|
||
if(progr < MOV_CUSTOM && yesno_box("Hai cancellato una riga custom di un movimento in prima nota, vuoi ricaricare la tabella?\n(Tutti i record verranno salvati per non perdere le modifiche!)"))
|
||
{
|
||
save_all();
|
||
load_sheet();
|
||
return true;
|
||
}
|
||
}
|
||
break;
|
||
case DLG_EMAIL:
|
||
if(e == fe_button)
|
||
open_java();
|
||
break;
|
||
|
||
case B_PAF_NOT_SENT:
|
||
case B_PAF_SENT:
|
||
{
|
||
const bool ena_no_wa = !(get_bool(B_PAF_NOT_SENT) || get_bool(B_PAF_SENT));
|
||
enable(B_PAF_SOG_FAT, ena_no_wa);
|
||
enable(B_PAF_ESTERI, ena_no_wa);
|
||
break;
|
||
}
|
||
case B_PAA_NOT_SENT:
|
||
case B_PAA_SENT:
|
||
{
|
||
const bool ena_no_wa = !(get_bool(B_PAA_NOT_SENT) || get_bool(B_PAA_SENT));
|
||
enable(B_PAA_SOG_FAT, ena_no_wa);
|
||
enable(B_PAA_ESTERI, ena_no_wa);
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
|
||
const short id = o.dlg();
|
||
if (e == fe_modify && jolly == 1)
|
||
{
|
||
if (id >= START_SHEET && id < END_SHEET && id != A_FORZATA)
|
||
{
|
||
// Se ho modificato l'impostazione dell'invio non va segnata la modifica MA devo togliere o mettere il flag a tutti quelli con movimento uguale
|
||
if(id != A_INVIO)
|
||
o.mask().set(A_FORZATA, true);
|
||
else
|
||
{
|
||
TString invio = o.mask().get(A_INVIO);
|
||
if(invio != FLAG_FORZATO && invio != FLAG_ERRORE)
|
||
change_invio(o.mask().get(A_TIPOCF), o.mask().get(A_CODCF), o.mask().get(A_NUMDOC), invio);
|
||
}
|
||
}
|
||
}
|
||
if (e == fe_modify && jolly == 0)
|
||
{
|
||
if (id >= START_MASK && id <= END_MASK)
|
||
{
|
||
set_filter_changed();
|
||
}
|
||
if(id >= START_BOOLEAN && id <= END_BOOLEAN)
|
||
save_config();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void TTrFa_mask::open_java()
|
||
{
|
||
TFilename tmp = SPESOMETROBASE "\\ModuliSirio.jar";
|
||
tmp.make_absolute_path();
|
||
|
||
DIRECTORY old_dir; xvt_fsys_get_dir(&old_dir);
|
||
DIRECTORY new_dir; xvt_fsys_convert_str_to_dir(tmp.path(), &new_dir);
|
||
xvt_fsys_set_dir(&new_dir);
|
||
|
||
const bool good = goto_url(tmp);
|
||
if (good)
|
||
{
|
||
xvt_sys_sleep(3000);
|
||
}
|
||
else
|
||
{
|
||
error_box(FR("Impossibile eseguire Java -jar %s"), static_cast<const char*>(tmp));
|
||
}
|
||
xvt_fsys_set_dir(&old_dir);
|
||
}
|
||
|
||
void TTrFa_mask::load_config()
|
||
{
|
||
// Rilevo i tipi scelti
|
||
TToken_string tipidoc(ini_get_string(CONFIG_DITTA, "tf", "TIPIDOC"));
|
||
// Potrei fare un for su TToken_string ma non darebbe la possibilit<69> di flaggare tutto in caso di prima installazione
|
||
for(int pos = 0; pos < tipidoc.items(); pos++)
|
||
{
|
||
const int field = get_tipo_doc(tipidoc.get(pos));
|
||
if(field != -1)
|
||
set(field, "X");
|
||
}
|
||
|
||
for(int id = END_BOOLEAN_FATT + 1; id <= END_BOOLEAN; id++)
|
||
{
|
||
set(id, ini_get_bool(CONFIG_DITTA, "tf", get_tipo_doc(id)) ? "X" : "");
|
||
}
|
||
}
|
||
void TTrFa_mask::save_config() const
|
||
{
|
||
TToken_string tipidoc;
|
||
int id = START_BOOLEAN_FATT;
|
||
for(; id <= END_BOOLEAN_FATT; id++)
|
||
{
|
||
if(get_bool(id))
|
||
{
|
||
tipidoc.add(get_tipo_doc(id));
|
||
}
|
||
}
|
||
ini_set_string(CONFIG_DITTA, "tf", "TIPIDOC", tipidoc);
|
||
|
||
for (; id <= END_BOOLEAN; id++)
|
||
{
|
||
ini_set_bool(CONFIG_DITTA, "tf", get_tipo_doc(id), get_bool(id));
|
||
}
|
||
}
|
||
|
||
/* salvo tutti i record modificati */
|
||
bool TTrFa_mask::save_all() const
|
||
{
|
||
TSheet_field& sheet = sfield(F_RIGHE);
|
||
//TString_array& strarr = sheet.rows_array();
|
||
TString mod = "";
|
||
TLocalisamfile mov(LF_MOV);
|
||
FOR_EACH_SHEET_ROW(sheet, r, strarr)
|
||
{
|
||
strarr->get(_forzata, mod);
|
||
if(mod == "X")
|
||
{
|
||
bool ok, retry = false;
|
||
do
|
||
{
|
||
ok = save_rec(*strarr);
|
||
if(!ok)
|
||
{
|
||
TString msg = "Errore durante il salvataggio del movimento ";
|
||
msg << "alla riga " << r << "\nRitentare?";
|
||
retry = yesno_box(msg);
|
||
}
|
||
} while(retry && !ok);
|
||
if(!ok)
|
||
return false;
|
||
}
|
||
// Salvo il valore di invio se <20> stato modificato
|
||
else
|
||
{
|
||
TRectype rmov = cache().get(LF_MOV, strarr->get(_numero));
|
||
rmov.put("TFINVIO", strarr->get(_invio));
|
||
mov.rewrite(rmov);
|
||
}
|
||
}
|
||
message_box("Salvataggio effettuato!");
|
||
return true;
|
||
}
|
||
|
||
bool TTrFa_mask::check_all()
|
||
{
|
||
// Controllo di avere uno sheet pieno
|
||
if(!check_not_empty()) return true;
|
||
|
||
if(yesno_box("Controllare tutti i C.F. P.IVA?"))
|
||
{
|
||
TExternal_app servizio("cg1 -2 L");
|
||
servizio.run();
|
||
}
|
||
|
||
// Sistemo i flag
|
||
the_final_check_down();
|
||
|
||
static TPrinter stampa;
|
||
stampa.reset();
|
||
stampa.open();
|
||
TPrintrow riga;
|
||
riga.put(TR("------------------ Controllo Errori TF -------------------"), 30);
|
||
stampa.setheaderline(1, riga);
|
||
riga.reset();
|
||
riga.put("N.Registrazione", 0);
|
||
riga.put("N.Documento", 20);
|
||
riga.put("Tipo errore", 40);
|
||
stampa.setheaderline(3, riga);
|
||
riga.reset();
|
||
riga.put(TR("Tutti i record qui elencati sono stati segnati con il codice \"Errore\" e non verranno inviati"), 0);
|
||
stampa.setheaderline(2, riga);
|
||
riga.reset();
|
||
stampa.setheaderline(4, riga);
|
||
stampa.print(riga);
|
||
TSheet_field& sheet = sfield(F_RIGHE);
|
||
FOR_EACH_SHEET_ROW(sheet, r, strarr)
|
||
{
|
||
check_rec(&stampa, strarr);
|
||
}
|
||
riga.reset();
|
||
riga.put(TR("------------------ Fine controllo! ------------------"), 30);
|
||
stampa.print(riga);
|
||
stampa.close();
|
||
return true;
|
||
}
|
||
|
||
inline void print_error(TPrinter* stampa, const TString& movimento, const TString& documento, const TString& msgerr)
|
||
{
|
||
TPrintrow riga;
|
||
riga.put(movimento, 0);
|
||
riga.put(documento, 20);
|
||
riga.put(msgerr, 40);
|
||
stampa->print(riga);
|
||
}
|
||
|
||
bool TTrFa_mask::check_rec(TPrinter* stampa, TToken_string* rec)
|
||
{
|
||
bool ok = true;
|
||
const TString num_mov = rec->get(_numero);
|
||
const TString num_doc = rec->get(_numdoc);
|
||
TString msgerr;
|
||
TString coderr;
|
||
// Controllo date ***********************************************************************************
|
||
const TDate reg = rec->get(_datareg), doc = rec->get(_datadoc);
|
||
if(reg < doc)
|
||
{
|
||
ok = false;
|
||
msgerr.cut(0) << "Data registrazione precedente alla data del documento";
|
||
print_error(stampa, num_mov, num_doc, msgerr);
|
||
coderr << "1;";
|
||
}
|
||
|
||
// Controllo aliquota, imponibile e imposta *********************************************************
|
||
TCodiceIVA codiva(rec->get(_aliquota));
|
||
TString nat = rec->get(_natura);
|
||
const TString real_nat(natura(rec->get(_aliquota)));
|
||
nat.ltrim(); // Se vuoto arriva con uno spazio
|
||
const real imponibile = static_cast<const char*>(rec->get(_imponibile)), imposta = static_cast<const char*>(rec->get(_importoIVA));
|
||
if(nat != real_nat)
|
||
{
|
||
msgerr.cut(0) << "Natura del movimento errata, valore dichiarato: " << nat << " valore corretto: " << real_nat;
|
||
print_error(stampa, num_mov, num_doc, msgerr);
|
||
coderr << "2;";
|
||
}
|
||
|
||
real real_imp = imponibile * codiva.percentuale() / CENTO;
|
||
real_imp.round(2);
|
||
if(imposta > real_imp + TOLLARANZA || imposta < real_imp - TOLLARANZA)
|
||
{
|
||
msgerr.cut(0) << "Imposta errata, valore dichiarato: " << imposta.string() << " valore \"potenzialmente\" corretto: " << real_imp.string();
|
||
print_error(stampa, num_mov, num_doc, msgerr);
|
||
coderr << "3;";
|
||
}
|
||
|
||
if(strcmp(rec->get(_codnum), "ERR0") == 0)
|
||
{
|
||
ok = false;
|
||
msgerr.cut(0) << "Non riesco a determinare il tipo di documento corretto per l'agenzia delle entrate!";
|
||
print_error(stampa, num_mov, num_doc, msgerr);
|
||
coderr << "4;";
|
||
}
|
||
|
||
// Flaggo il record con i messaggi di errore
|
||
rec->add(coderr, _coderr); // Sempre potrebbero esserci errori non bloccanti
|
||
|
||
return ok;
|
||
}
|
||
|
||
bool TTrFa_mask::check_not_empty()
|
||
{
|
||
TSheet_field& sheet = sfield(F_RIGHE);
|
||
TString msg;
|
||
|
||
if(sheet.empty())
|
||
msg = "La tabella dei movimenti <20> vuota, vuoi caricarla con i filtri selezionati?";
|
||
else if(_filter_changed)
|
||
msg = "I filtri sono stati cambiati, vuoi ricaricare la tabella con i nuovi filtri selezionati?";
|
||
|
||
if(msg.full() && yesno_box(msg))
|
||
{
|
||
_filter_changed = false;
|
||
load_sheet();
|
||
}
|
||
return sheet.full();
|
||
}
|
||
|
||
void TTrFa_mask::the_final_check_down() // IT'S THE FINAL CHECKDOOOOOOOWN! WE'RE CHECKING TOGEEEETHEEEEER!!!!
|
||
{
|
||
TSheet_field& sheet = sfield(F_RIGHE);
|
||
TAssoc_array cli_docs;
|
||
FOR_EACH_SHEET_ROW(sheet, r, strarr)
|
||
{
|
||
// Chiave: TIPOCF + CODCF + NUMDOC + CODIVA
|
||
TString key; key << strarr->get_char(_tipocf) << "|" << strarr->get_int(_codcf) << "|" << strarr->get(_numdoc) << "|" << strarr->get(_aliquota);
|
||
TToken_string new_numero; new_numero.add(r, 0); new_numero.add(strarr->get_char(_invio), 1);
|
||
if(cli_docs.is_key(key))
|
||
{
|
||
TToken_string oldnumero = *dynamic_cast<TToken_string*>(cli_docs.objptr(key));
|
||
TString oldflag; oldnumero.get(1, oldflag);
|
||
if(oldflag == FLAG_FORZATO)
|
||
flag_row(r, FLAG_NINVIO);
|
||
else
|
||
{
|
||
int oldr; oldnumero.get(0, oldr);
|
||
flag_row(oldr, FLAG_NINVIO);
|
||
}
|
||
|
||
cli_docs.add(key, new_numero);
|
||
}
|
||
else
|
||
{
|
||
cli_docs.add(key, new_numero);
|
||
}
|
||
}
|
||
// Forzo l'aggiornamento dello sheet
|
||
sfield(F_RIGHE).force_update();
|
||
}
|
||
|
||
void TTrFa_mask::flag_row(const int nrow, const TString& flag)
|
||
{
|
||
sfield(F_RIGHE).row(nrow).add(flag, _invio);
|
||
}
|
||
|
||
TRecnotype TTrFa_mask::nuovo_progr()
|
||
{
|
||
static TRectype app(LF_TRASFATT);
|
||
static TLocalisamfile ltrasfatt(LF_TRASFATT);
|
||
app.last(ltrasfatt);
|
||
// Lo inizializzo solo la prima volta poi incremento
|
||
static TRecnotype numreg = app.get_long("NUMREG") > MOV_CUSTOM ? app.get_long("NUMREG") : MOV_CUSTOM;
|
||
numreg++;
|
||
return numreg;
|
||
}
|
||
|
||
// Dato un cliente e il suo numero documento imposto il nuovo flag di invio su tutti i campi
|
||
void TTrFa_mask::change_invio(const TString& tipocf, const TString& codcf, const TString& numdoc, const TString& invio) const
|
||
{
|
||
TSheet_field& sheet = sfield(F_RIGHE);
|
||
TString rtipo, rcod, rnum, rinvio;
|
||
FOR_EACH_SHEET_ROW(sheet, r, strarr)
|
||
{
|
||
// Ricevo i parametri della riga
|
||
rtipo.cut(0); rtipo << strarr->get_char(_tipocf);
|
||
rcod.cut(0); rcod << strarr->get_int(_codcf);
|
||
rnum.cut(0); rnum << strarr->get(_numdoc);
|
||
rinvio.cut(0); rinvio << strarr->get(_invio);
|
||
if(rinvio != FLAG_FORZATO && invio != FLAG_ERRORE && tipocf == rtipo && codcf == rcod && rnum == numdoc)
|
||
{
|
||
strarr->add(invio, _invio);
|
||
// Aggiorno la riga
|
||
sheet.force_update(r);
|
||
}
|
||
}
|
||
}
|
||
|
||
void TTrFa_mask::update_stato(const TString& da_stato, const TString& a_stato)
|
||
{
|
||
TSheet_field& sf = sfield(F_RIGHE);
|
||
sf.hide();
|
||
FOR_EACH_SHEET_ROW(sf, r, row)
|
||
{
|
||
if (*row->get(sf.cid2index(A_INVIO)) == *da_stato)
|
||
row->add(a_stato, sf.cid2index(A_INVIO));
|
||
}
|
||
sf.force_update();
|
||
sf.show();
|
||
}
|
||
|
||
void TTrFa_mask::load_sheet()
|
||
{
|
||
const char tipo = get(F_TIPOCF)[0];
|
||
const long codice = get_long(F_CODCF);
|
||
TDate dal = get_date(F_DATAINI), al = get_date(F_DATAFIN);
|
||
|
||
// Importanti! Evito errori dopo premendo il bottone invia
|
||
if(!dal.ok())
|
||
{
|
||
dal = TDate(01, 01, 2017); // Data inizio validit<69> questo spesometro
|
||
set(F_DATAINI, dal);
|
||
}
|
||
if(!al.ok())
|
||
{
|
||
al = TDate(TODAY);
|
||
set(F_DATAFIN, al);
|
||
}
|
||
//TString key; key << "TIPOA=" << prefix().firm().get("TIPOA")<< ",CODANAGR=" << prefix().firm().get("CODANAGR");
|
||
TString key; key << prefix().firm().get("TIPOA") << "|" << prefix().firm().get("CODANAGR");
|
||
static const TString piva_ditta = cache().get(LF_ANAG, key, "PAIV");
|
||
static const TString cofi_ditta = cache().get(LF_ANAG, key, "COFI");
|
||
|
||
TTrFa_cursors c;
|
||
|
||
TSheet_field& sheet = sfield(F_RIGHE);
|
||
|
||
sheet.hide(); // Nascondo lo sheet per guadagnare un 20% di velocit<69> di caricamento, le ottimizzazioni da PRO!
|
||
if(!sheet.empty())
|
||
sheet.destroy();
|
||
TAssoc_array recimposte;
|
||
const int items = c.update_filters(tipo, codice, dal, al, get_int(F_FATTSEL));
|
||
TString tipocf, codcf, ocfpi, nat;
|
||
for(bool ok = true; items > 0 && ok;)
|
||
{
|
||
tipocf.cut(0), codcf.cut(0), ocfpi.cut(0), nat.cut(0);
|
||
const int err = c.next(recimposte, ok, tipocf, codcf, ocfpi);
|
||
|
||
// Carico i clienti
|
||
TRectype cli = getCli(tipocf, codcf, ocfpi);
|
||
|
||
FOR_EACH_ASSOC_OBJECT(recimposte, h, iva, rec)
|
||
{
|
||
TRectype movimento = *dynamic_cast<TRectype*>(rec);
|
||
// Controllo che sia un tipo documento da leggere
|
||
const int tipo_doc = get_tipo_doc(movimento.get("TIPODOC"));
|
||
if(tipo_doc != -1 && !get_bool(tipo_doc)) continue;
|
||
// A volte mi pesca movimenti con invio sbagliato
|
||
if(!check_invio(movimento.get("TFINVIO"))) continue;
|
||
|
||
// Creo una nuova riga nello sheet
|
||
TToken_string& row = sheet.row(-1);
|
||
|
||
/* Siccome mi cambiano l'ordine ogni volta e non ho voglia di cambiare tutto ovunque
|
||
* basta settare i valori negli enum e lo sheet
|
||
*/
|
||
TRectype is_cust = getTrasFatt(movimento.get("NUMREG"), iva);
|
||
#ifdef DBG
|
||
if(is_cust.full() && (err < foundcust || err > foundidcust))
|
||
bool tolla = true;
|
||
#endif
|
||
const char * to_send = movimento.get("TFINVIO").blank() ? FLAG_INVIO : movimento.get("TFINVIO");
|
||
row.add(movimento.get("TFINVIO") == FLAG_INVIATO ? "X" : "", _spedita); // Spedita
|
||
row.add(to_send); // Da spedire
|
||
row.add(is_cust.full() ? "X" : "", _forzata); // Modificato
|
||
row.add(movimento.get_long("NUMREG"), _numero); // Numero registrazione
|
||
row.add(movimento.get_date("DATAREG"), _datareg); // Data Registrazione
|
||
row.add(movimento.get("TIPO"), _tipocf); // Tipo Cli/For
|
||
row.add(movimento.get("CODCF"), _codcf); // Codice Cli/For
|
||
row.add(movimento.get("OCCAS"), _occas); // Codice Occasionale
|
||
row.add(cli.get("RAGSOC"), _ragsoc); // Ragione sociale
|
||
row.add(cli.get("CODRFSO"), _rfso); // Codice RF/SO
|
||
row.add(get_rfso(cli.get("CODRFSO")), _ragsocrfso); // Ragione Sociale RF/SO
|
||
row.add(movimento.get("NUMDOC"), _numdoc); // Numero documento
|
||
row.add(movimento.get_date("DATADOC"), _datadoc); // Data documento
|
||
nat.cut(0) << movimento.get("NATURA");
|
||
row.add(nat.full() ? nat : natura(iva), _natura); // NATURA!
|
||
row.add(iva, _aliquota); // Codice aliquota!
|
||
row.add(find_detraib(movimento.get("TIPODET")), _detraibile); // Detraibilit<69>
|
||
row.add(movimento.get_real("IMPONIBILE"), _imponibile); // Imponibile
|
||
row.add(movimento.get_real("IMPOSTA"), _importoIVA); // Imposta
|
||
row.add(rev_charge(movimento.get("NUMREG"), movimento.get_date("DATAREG").year()), _reverse); // Rev.Charge
|
||
|
||
|
||
row.add(movimento.get("TIPODOC"), _codnum);
|
||
// Calcolo il tipo documento alla fine per sicurezza
|
||
if (is_cust.full())
|
||
{
|
||
row.add(movimento.get("TIPODOCAE").blank() ? decod_tipo(&row) : movimento.get("TIPODOCAE"), _codnumAE); // Tipo documento
|
||
}
|
||
else
|
||
row.add(decod_tipo(&row), _codnumAE); // Tipo documento
|
||
|
||
/*
|
||
* Possono esistere movimenti custom dove il cliente ha una partita IVA propria
|
||
* ma <20> stato flaggato l'autofattura, quindi in trasfat <20> presente il codice cliente con PIVA e CODFIS della ditta.
|
||
* Controllo sia il movimento che il cliente
|
||
*/
|
||
if(movimento.get("AUTOFATT") == "X" || piva_ditta == cli.get("PAIV")) // Se <20> un autofattura
|
||
{
|
||
row.add("X", _autofatt); // AutoFatt
|
||
row.add(piva_ditta, _paiv); // P.IVA
|
||
row.add(cofi_ditta, _codfis); // Codice Fiscale
|
||
}
|
||
else
|
||
{
|
||
row.add("", _autofatt); // AutoFatt
|
||
row.add(cli.get("PAIV"), _paiv); // P.IVA
|
||
row.add(cli.get("COFI"), _codfis); // Codice Fiscale
|
||
}
|
||
sheet.enable_cell(sheet.items()-1, _occas, movimento.get("OCCAS").full());
|
||
}
|
||
recimposte.destroy();
|
||
}
|
||
sheet.force_update();
|
||
sheet.show();
|
||
}
|
||
|
||
|
||
bool TTrFa_mask::check_invio(const TString& invio) const
|
||
{
|
||
bool ok;
|
||
switch(get_int(F_FATTSEL))
|
||
{
|
||
case to_send:
|
||
ok = invio.empty() || invio == FLAG_INVIO || invio == FLAG_FORZATO || invio == FLAG_ERRORE;
|
||
break;
|
||
case sent:
|
||
ok = invio == FLAG_INVIATO;
|
||
break;
|
||
case untouched:
|
||
ok = invio.empty() || invio == FLAG_INVIO;
|
||
case forced:
|
||
ok = invio == FLAG_FORZATO;
|
||
break;
|
||
case disabled:
|
||
ok = invio == FLAG_NINVIO;
|
||
break;
|
||
case err:
|
||
ok = invio == FLAG_ERRORE;
|
||
break;
|
||
case all:
|
||
default:
|
||
ok = true;
|
||
break;
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
|
||
TTrFa_mask::TTrFa_mask(const TString& msk)
|
||
: TAutomask(msk), _filter_changed(true)
|
||
{
|
||
load_config();
|
||
#ifndef DBG
|
||
|
||
// Controllo che abbia aggiornato le causali dopo l'ultima patch cg0500
|
||
bool ok = ini_get_int(CONFIG_GENERAL, "cg", "Patch") >= 500;
|
||
if (!ok)
|
||
{
|
||
if (is_debug_station())
|
||
{
|
||
TString msg; msg << "HEY " << user() << ", installa ste patch!";
|
||
warning_box(msg);
|
||
}
|
||
else
|
||
fatal_box("Per eseguire questo programma <20> necessario aver installata la patch 500 del modulo cg");
|
||
}
|
||
if (ini_get_int(CONFIG_DITTA, "cg", "atccf", 0) <= 0) // Aggiornamento Tipo Conto Cliente Fornitore
|
||
{
|
||
// cg1 -2 U
|
||
if (yesno_box("Attenzione, per proseguire con questo programma bisogna aggiornare il tipo conto per i C/F, desideri farlo adesso?"))
|
||
{
|
||
TExternal_app atccf("cg1 -2 U -force"); // solo cos<6F> viene eseguito su tutte le ditte, togliere i campi servono per l'interattivo non andavano tolti
|
||
atccf.run();
|
||
// Ricontrollo che sia andato tutto bene
|
||
if (ini_get_int(CONFIG_DITTA, "cg", "atccf", 0) <= 0)
|
||
fatal_box("L'aggiornamento non <20> andato a buon fine, non puoi procedere con il Trasferimento Fatture");
|
||
}
|
||
else if(yesno_box("Senza effettuare l'aggiornamento non possiamo garantirti il corretto funzionamento del Trasferimento Fatture.\nSi e' sicuri di proseguire?") == 0)
|
||
{
|
||
fatal_box("Programma terminato");
|
||
}
|
||
}
|
||
|
||
#endif // !DBG
|
||
}
|