1997 lines
55 KiB
C++
Executable File
1997 lines
55 KiB
C++
Executable File
#include <progind.h>
|
|
#include <tabutil.h>
|
|
#include <urldefid.h>
|
|
#include <utility.h>
|
|
|
|
#include "cg2100.h"
|
|
#include "cg2102.h"
|
|
#include "cg21sld.h"
|
|
|
|
#include <mov.h>
|
|
#include <clifo.h>
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Funzioni di decodifica/calcolo
|
|
///////////////////////////////////////////////////////////
|
|
|
|
char TPrimanota_application::row_type(const TToken_string& s)
|
|
{
|
|
const int l = s.len()-1;
|
|
return l > 0 ? s[l] : ' ';
|
|
}
|
|
|
|
// Determina il tipo IVA da causale+anno
|
|
// Certified 100%
|
|
TipoIVA TPrimanota_application::cau2IVA(const char* causale, int annoiva)
|
|
{
|
|
TipoIVA i = nessuna_iva;
|
|
|
|
if (*causale > ' ')
|
|
{
|
|
TCausale& c = app().causale();
|
|
if (c.read(causale, annoiva))
|
|
i = c.iva();
|
|
else
|
|
{
|
|
error_box("Causale errata: '%s'", causale);
|
|
i = iva_errata;
|
|
}
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
// Calcolo della percentuale di un dato codice IVA
|
|
// Certified 99%
|
|
const real& TPrimanota_application::cod2IVA(const TMask& m)
|
|
{
|
|
static TString16 _codiva;
|
|
static real _percent;
|
|
|
|
if (app().iva() == iva_acquisti && m.get_int(103) == 3)
|
|
return ZERO;
|
|
|
|
const TString& codiva = m.get(102);
|
|
if (_codiva != codiva)
|
|
{
|
|
_codiva = codiva;
|
|
TCodiceIVA c(_codiva);
|
|
_percent = c.percentuale();
|
|
}
|
|
|
|
return _percent;
|
|
}
|
|
|
|
|
|
// Scorpora dall'imponibile la percentuale d'imposta(0.0%-100.0%) e ritorna l'imposta stessa
|
|
// Certified 99% Non sono sicurissimo degli imponibili negativi
|
|
real TPrimanota_application::scorpora(real& imponibile, const real& percent)
|
|
{
|
|
real imposta = abs(imponibile) * percent / (percent + 100.0); imposta.ceil();
|
|
if (imponibile.sign() < 0) imposta = -imposta;
|
|
imponibile -= imposta;
|
|
return imposta;
|
|
}
|
|
|
|
|
|
// Calcola il totale del documento tenenod conto del segno della prima riga e di quella delle
|
|
// ritenute sociali sulla causale
|
|
real TPrimanota_application::totale_documento()
|
|
{
|
|
const TMask& m = curr_mask();
|
|
|
|
const bool swapt = test_swap(FALSE); // Totale invertito ?
|
|
const bool swaps = test_swap(TRUE); // Ritenute sociali invertite ?
|
|
|
|
real tot(m.get(F_TOTALE)); // Legge totale
|
|
const real ritfis(m.get(F_RITFIS));
|
|
tot += ritfis; // Somma ritenute fiscali
|
|
|
|
real ritsoc(m.get(F_RITSOC));
|
|
if (swapt ^ swaps)
|
|
ritsoc = -ritsoc;
|
|
tot += ritsoc; // Somma ritenute sociali con segno
|
|
|
|
return tot;
|
|
}
|
|
|
|
|
|
// Determina se un codice sospeso o no
|
|
// Certified 99%
|
|
bool TPrimanota_application::suspended_handler(TMask_field& f, KEY k)
|
|
{
|
|
if (f.to_check(k))
|
|
{
|
|
CHECKD(f.is_edit(), "Can't check suspension of a non edit-field ", f.dlg());
|
|
const TEdit_field& c = (const TEdit_field&)f;
|
|
const TBrowse* b = c.browse();
|
|
CHECKD(b, "Can't check suspension of a edit-field without a USE ", f.dlg());
|
|
const TLocalisamfile& i = b->cursor()->file();
|
|
// Tabella File
|
|
const char* sf = i.tab() ? "B2" : "SOSPESO";
|
|
const bool suspended = i.get_bool(sf);
|
|
if (suspended)
|
|
{
|
|
sf = f.get();
|
|
return f.error_box("Il codice '%s' e' sospeso e non puo' essere utilizzato", sf);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Determina se un codice detrazione e' di tipo detraibile o no
|
|
// Certified 70%
|
|
bool TPrimanota_application::detraibile(TToken_string& row)
|
|
{
|
|
if (app().iva() == iva_vendite) // Vendite sempre detraibili
|
|
return TRUE;
|
|
|
|
const int tipo_det = row.get_int(2); // Leggi tipo detraibilita
|
|
if (tipo_det != 0)
|
|
return FALSE;
|
|
|
|
const real& prorata = app().causale().reg().prorata();
|
|
return prorata < 100.0; // Se prorata = 100% e' indetraibile
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Funzioni di ricerca
|
|
///////////////////////////////////////////////////////////
|
|
|
|
int TPrimanota_application::type2pos(char tipo)
|
|
{
|
|
TString_array& cg = app().cgs().rows_array();
|
|
for (int i = 0; i < cg.items(); i++)
|
|
{
|
|
const TToken_string& s = cg.row(i);
|
|
const char t = row_type(s);
|
|
if (t == tipo)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
// Trova nelle righe contabili un conto nelle righe di tipo prescelto
|
|
int TPrimanota_application::bill2pos(const TBill& conto, char tipo)
|
|
{
|
|
TString_array& cg = app().cgs().rows_array();
|
|
for (int i = 0; i < cg.items(); i++)
|
|
{
|
|
TToken_string& s = cg.row(i);
|
|
const char t = row_type(s);
|
|
if (t == tipo)
|
|
{
|
|
const TBill c(s, 3, 0x0);
|
|
if (c == conto)
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
// Trova nelle righe contabili un conto di contropartita per il conto dato
|
|
int TPrimanota_application::bill2contr(const TBill& conto, char sezione) const
|
|
{
|
|
TString_array& rows = cgs().rows_array();
|
|
for (int i = 0; i < rows.items(); i++)
|
|
{
|
|
TToken_string& r = rows.row(i);
|
|
const real dare(r.get(0));
|
|
const char sez = dare.is_zero() ? 'A' : 'D';
|
|
if (sez == sezione) // Devo cercare sezione contraria
|
|
continue;
|
|
const TBill c(r, 3, 0x0);
|
|
if (conto == c)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
// Controlla se un conto e' usato nelle righe IVA
|
|
int TPrimanota_application::bill_used(const TBill& conto) const
|
|
{
|
|
int users = 0;
|
|
|
|
const TArray& rows = ivas().rows_array();
|
|
for (int i = 0; i < rows.items(); i++)
|
|
{
|
|
TToken_string& row = (TToken_string&)rows[i];
|
|
if (!row.empty_items())
|
|
{
|
|
const TBill c(row, 6, 0x0);
|
|
if (conto == c) users++;
|
|
}
|
|
}
|
|
|
|
return users;
|
|
}
|
|
|
|
/*
|
|
// Controlla se e' stato usata l'IVA detraibile o indetraibile nelle righe IVA
|
|
// Certified 90%
|
|
int TPrimanota_application::det_used(char det) const
|
|
{
|
|
int users = 0;
|
|
|
|
const bool detraib = det == 'D';
|
|
TString_array& arr = ivas().rows_array();
|
|
for (int i = 0; i < arr.items(); i++)
|
|
{
|
|
TToken_string& row = arr.row(i);
|
|
if (!row.empty_items())
|
|
{
|
|
const bool d = detraibile(row);
|
|
if (detraib == d) users++;
|
|
}
|
|
}
|
|
|
|
return users;
|
|
}
|
|
*/
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Gestione sheet CG
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TSheet_field& TPrimanota_application::cgs() const
|
|
{
|
|
TSheet_field& s = (TSheet_field&)curr_mask().field(F_SHEETCG);
|
|
return s;
|
|
}
|
|
|
|
|
|
// Certified 100%
|
|
// Scrive l'importo imp nella opportuna colonna della riga n
|
|
void TPrimanota_application::set_cgs_imp(int n, const TImporto& imp)
|
|
{
|
|
TSheet_field& s = cgs();
|
|
imp.add_to(s.row(n), 0);
|
|
s.force_update(n);
|
|
|
|
TMask& m = s.sheet_mask();
|
|
if (m.is_running() && s.selected() == n)
|
|
{
|
|
m.set(101, imp.sezione() == 'D' ? imp.valore().string() : "");
|
|
m.set(102, imp.sezione() == 'A' ? imp.valore().string() : "");
|
|
}
|
|
}
|
|
|
|
// Legge l'importo della riga n e lo ritorna col segno dovuto
|
|
// Certified 100%
|
|
TImporto TPrimanota_application::get_cgs_imp(int n)
|
|
{
|
|
TSheet_field& s = cgs();
|
|
|
|
TImporto importo;
|
|
|
|
const TMask& m = s.sheet_mask();
|
|
if (m.is_running() && s.selected() == n)
|
|
{
|
|
const TString& imp = m.get(101);
|
|
if (imp.not_empty())
|
|
importo.set('D', real(imp));
|
|
else
|
|
importo.set('A', real(m.get(102)));
|
|
}
|
|
else
|
|
importo = s.row(n);
|
|
|
|
return importo;
|
|
}
|
|
|
|
// Certified 90%
|
|
bool TPrimanota_application::add_cgs_imp(int n, const TImporto& imp)
|
|
{
|
|
TImporto tot;
|
|
tot = cgs().row(n);
|
|
tot += imp;
|
|
set_cgs_imp(n, tot);
|
|
return tot.is_zero();;
|
|
}
|
|
|
|
// Certified 90%
|
|
bool TPrimanota_application::sub_cgs_imp(int n, const TImporto& imp)
|
|
{
|
|
TImporto tot;
|
|
tot = cgs().row(n);
|
|
tot -= imp;
|
|
set_cgs_imp(n, tot);
|
|
return tot.is_zero();
|
|
}
|
|
|
|
|
|
TImporto TPrimanota_application::real2imp(const real& r, char row_type)
|
|
{
|
|
bool dare;
|
|
if (row_type == 'S')
|
|
{
|
|
dare = causale().sezione_ritsoc() == 'D';
|
|
}
|
|
else
|
|
{
|
|
dare = causale().sezione_clifo() == 'D';
|
|
if (row_type != 'T' && row_type != 'F') dare = !dare;
|
|
}
|
|
|
|
TImporto importo(dare ? 'D' : 'A', r);
|
|
return importo;
|
|
}
|
|
|
|
// Disabilita le celle della riga contabile n in base al suo tipo
|
|
void TPrimanota_application::disable_cgs_cells(int n, char tipo)
|
|
{
|
|
int first = 0, last = 0;
|
|
switch(tipo)
|
|
{
|
|
case 'A': // Abbuoni attivi
|
|
case 'C': // Differenza cambio
|
|
case 'D': // IVA Detraibile
|
|
case 'F': // Ritenute Fiscali
|
|
case 'N': // IVA Non detraibile
|
|
case 'P': // Abbuoni passsivi
|
|
case 'R': // Ritenute professionali
|
|
case 'S': // Ritenute Sociali
|
|
case 'T': // Totale documento
|
|
last = 3;
|
|
break;
|
|
case 'K': // Riga cliente/fornitore per saldaconto
|
|
first = 2;
|
|
case 'I':
|
|
last = 7; // Imponibile
|
|
break;
|
|
default:
|
|
last = 0; // Solo contabile
|
|
break;
|
|
}
|
|
|
|
if (last > 0)
|
|
{
|
|
TSheet_field& cg = cgs();
|
|
for (int i = first; i < last; i++)
|
|
cg.disable_cell(n, i);
|
|
if (tipo == 'T' && !causale().corrispettivi())
|
|
{
|
|
cg.disable_cell(n, 5);
|
|
cg.disable_cell(n, 6);
|
|
}
|
|
}
|
|
}
|
|
|
|
void TPrimanota_application::reset_sheet_row(TSheet_field& s, int n)
|
|
{
|
|
s.row(s.items()); // Append a new line
|
|
s.destroy(n); // Remove line n
|
|
}
|
|
|
|
int TPrimanota_application::set_cgs_row(int n, const TImporto& imp,
|
|
TBill& conto, const char* desc,
|
|
char tipo)
|
|
{
|
|
TSheet_field& cg = cgs();
|
|
if (n < 0) n = cg.first_empty();
|
|
TToken_string& row = cg.row(n);
|
|
row = "";
|
|
imp.add_to(row, 0);
|
|
row.add(conto.string(0x3));
|
|
row.add(""); // Codice decrizione
|
|
row.add(desc); // Descrizione aggiuntiva
|
|
|
|
if (tipo == 'T') // Calcolo contropartita
|
|
{
|
|
TToken_string& irow = ivas().row(0);
|
|
for (int i = 5; i < 10; i++)
|
|
row.add(irow.get(i == 5 ? 5 : -1));
|
|
}
|
|
else
|
|
{
|
|
const int pos = type2pos('T');
|
|
if (pos >= 0)
|
|
{
|
|
TBill contro(cg.row(pos), 2, 0x3);
|
|
row.add(contro.string(0x3));
|
|
}
|
|
else row.add(" | | | | ");
|
|
}
|
|
|
|
row << "| |" << tipo;
|
|
|
|
disable_cgs_cells(n, tipo);
|
|
cg.force_update(n);
|
|
|
|
return n;
|
|
}
|
|
|
|
|
|
HIDDEN int compare_rows(const TObject** o1, const TObject** o2)
|
|
{
|
|
// Totale, Rit.Fisc., Rit.Soc., da riga IVA, riga contabile, IVA detr., IVA non detr.
|
|
const char* const sort_order = "TFSI DNAPRC";
|
|
|
|
const TToken_string* r1 = (const TToken_string*)*o1;
|
|
const TToken_string* r2 = (const TToken_string*)*o2;
|
|
const char c1 = app().row_type(*r1);
|
|
const char c2 = app().row_type(*r2);
|
|
return int(strchr(sort_order, c1) - strchr(sort_order, c2));
|
|
}
|
|
|
|
HIDDEN bool can_remove(TToken_string& s)
|
|
{
|
|
const char* dare = s.get(0);
|
|
bool yes = dare == NULL ;
|
|
if (!yes)
|
|
{
|
|
if (*dare == '\0' || *dare == ' ' || strcmp(dare,"0") == 0)
|
|
{
|
|
const char* avere = s.get();
|
|
yes = (avere == NULL || *avere == '\0' || *avere == ' ' || strcmp(avere,"0") == 0);
|
|
}
|
|
}
|
|
return yes;
|
|
}
|
|
|
|
|
|
void TPrimanota_application::cgs_pack()
|
|
{
|
|
TString_array& rows = cgs().rows_array();
|
|
const bool pagamento = is_saldaconto() && iva() == nessuna_iva;
|
|
|
|
for (int i = rows.items()-1; i >= 0; i--)
|
|
{
|
|
TToken_string& r = rows.row(i);
|
|
if (can_remove(r))
|
|
{
|
|
if (pagamento && row_type(r) == 'K')
|
|
cg_notify(cgs(), i, K_DEL);
|
|
rows.destroy(i, TRUE);
|
|
}
|
|
}
|
|
if (!pagamento) // Il pagamento e' gia' ordinato
|
|
rows.sort(compare_rows); // Pack and sort array
|
|
}
|
|
|
|
|
|
bool TPrimanota_application::ci_sono_importi() const
|
|
{
|
|
TString_array& rows = cgs().rows_array();
|
|
for (int i = 0; i < rows.items(); i++)
|
|
{
|
|
TToken_string& r = rows.row(i);
|
|
const real dare(r.get(0));
|
|
if (dare != ZERO) return TRUE;
|
|
const real avere(r.get());
|
|
if (avere != ZERO) return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
real TPrimanota_application::calcola_saldo() const
|
|
{
|
|
TString_array& rows = cgs().rows_array();
|
|
const int max = rows.items();
|
|
|
|
real tdare, tavere;
|
|
for (int i = 0; i < max; i++)
|
|
{
|
|
TToken_string& r = rows.row(i);
|
|
tdare += real(r.get(0));
|
|
tavere += real(r.get());
|
|
}
|
|
|
|
real sbilancio = abs(tdare)-abs(tavere);
|
|
switch (sbilancio.sign())
|
|
{
|
|
case +1: // Il dare supera l'avere in valore assoluto
|
|
curr_mask().set(F_DARE, (tdare-tavere).string());
|
|
curr_mask().reset(F_AVERE);
|
|
break;
|
|
case -1: // L'avere supera il dare in valore assoluto
|
|
curr_mask().reset(F_DARE);
|
|
curr_mask().set(F_AVERE, (tavere-tdare).string());
|
|
break;
|
|
default: // Sbilancio nullo
|
|
curr_mask().reset(F_DARE);
|
|
curr_mask().reset(F_AVERE);
|
|
break;
|
|
}
|
|
|
|
return sbilancio;
|
|
}
|
|
|
|
|
|
// Handler dello sheet di contabilita'
|
|
// Certified 90%
|
|
bool TPrimanota_application::cg_handler(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_ENTER)
|
|
{
|
|
const real saldo = app().calcola_saldo();
|
|
|
|
if (saldo != ZERO)
|
|
{
|
|
const char* ss = saldo.string(".");
|
|
return f.error_box("Il movimento e' sbilanciato di %s lire.", ss);
|
|
}
|
|
|
|
TSheet_field& cg = app().cgs();
|
|
bool empty = TRUE;
|
|
for (int i = 0; i < cg.items(); i++)
|
|
{
|
|
TToken_string& r = cg.row(i);
|
|
TImporto importo; importo = r;
|
|
|
|
if (!importo.is_zero())
|
|
{
|
|
const TBill c(r, 3, 0x0);
|
|
if (!c.ok())
|
|
return f.error_box("Il conto della riga %d non e' completo", i+1);
|
|
const TBill co(r, 10, 0x0);
|
|
if (!co.empty() && !co.ok())
|
|
return f.error_box("La contropartita della riga %d non e' completa", i+1);
|
|
empty = FALSE;
|
|
|
|
const char tipo = row_type(r);
|
|
if (tipo == 'K' && app().iva() == nessuna_iva && app().is_saldaconto())
|
|
{
|
|
const long numreg = f.mask().get_long(F_NUMREG);
|
|
const int currig = i+1;
|
|
const TImporto speso = app().partite().importo_speso(numreg, currig, TRUE);
|
|
if (importo != speso)
|
|
{
|
|
bool ok = yesno_box("L'importo della riga %d dovrebbe essere %c %s\n"
|
|
"Si desidera correggerlo?", currig, speso.sezione(), speso.valore().string("."));
|
|
if (ok) app().set_cgs_imp(i, speso);
|
|
else return FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (empty)
|
|
return error_box("Il movimento non ha nessuna riga contabile con un importo");
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void TPrimanota_application::generazione_righe_cg(int r)
|
|
{
|
|
begin_wait();
|
|
|
|
TSheet_field& cg = cgs();
|
|
TToken_string& row = cg.row(r);
|
|
|
|
if (can_remove(row)) // Ignora righe senza importo
|
|
return;
|
|
|
|
TImporto importo; importo = row;
|
|
const bool causale_ok = causale().codice()[0] > ' ';
|
|
|
|
if (r == 0 && cg.row(1).empty_items())
|
|
{
|
|
TBill contro(row, 9, 0x3); // Contropartita della prima riga
|
|
if (causale_ok && !contro.ok())
|
|
{
|
|
causale().bill(2, contro); // Prendi contropartita dalla causale
|
|
if (contro.ok())
|
|
{
|
|
contro.add_to(row, 9, 0x3);
|
|
cg.force_update(r);
|
|
}
|
|
}
|
|
if (contro.ok())
|
|
{
|
|
importo.swap_section();
|
|
set_cgs_row(1, importo, contro, "", ' ');
|
|
TBill conto(row, 2, 0x3);
|
|
conto.add_to(cg.row(1), 9, 0x3);
|
|
cg.force_update(1);
|
|
}
|
|
}
|
|
|
|
if (causale_ok)
|
|
{
|
|
int first_not_empty = 0;
|
|
for (int i = 0; i < r; i++)
|
|
{
|
|
TToken_string& row = cg.row(i);
|
|
if (!can_remove(row))
|
|
{
|
|
first_not_empty = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
TBill conto(row, 2, 0x3);
|
|
if (first_not_empty == r) // Sono la prima riga con importo ?
|
|
{
|
|
int last = -1;
|
|
for (i = r+1; i < cg.items(); i++) // Aggiorna tutte le altre contropartite
|
|
{
|
|
TToken_string& rowi = cg.row(i);
|
|
int gruppo = rowi.get_int(3);
|
|
if (gruppo != 0) // Considera righe con conto ...
|
|
{
|
|
gruppo = rowi.get_int(10);
|
|
if (gruppo == 0) // ... e senza contropartita
|
|
{
|
|
char sez = ' '; // Calcola sezione D/A della riga i
|
|
if (cg.cell_disabled(i,0)) sez = 'A'; else
|
|
if (cg.cell_disabled(i,1)) sez = 'D';
|
|
|
|
if (sez != ' ' && importo.sezione() != sez) // Considera solo le sezioni opposte
|
|
{
|
|
conto.add_to(rowi, 9, 0x3);
|
|
cg.force_update(i);
|
|
if (last < 0) last = i;
|
|
else last = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (last > r)
|
|
{
|
|
importo.swap_section();
|
|
set_cgs_imp(last, importo);
|
|
|
|
const int gruppo = row.get_int(10);
|
|
if (gruppo == 0) // Se non ho contropartita ...
|
|
{
|
|
TBill contro(cg.row(last), 2, 0x3); // ... copiala dalla riga corrispondente
|
|
contro.add_to(row, 9, 0x3);
|
|
cg.force_update(r);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TToken_string& first = cg.row(first_not_empty);
|
|
int gruppo = first.get_int(10);
|
|
if (gruppo == 0) // Se la prima riga non ha contropartita ...
|
|
{
|
|
conto.add_to(first, 9, 0x3); // ... copiaci la mia partita
|
|
cg.force_update(first_not_empty);
|
|
}
|
|
gruppo = row.get_int(10);
|
|
if (gruppo == 0) // Se non ho contropartita ...
|
|
{
|
|
TBill contro(first, 2, 0x3); // ... copiala dalla prima riga
|
|
contro.add_to(row, 9, 0x3);
|
|
cg.force_update(r);
|
|
}
|
|
}
|
|
}
|
|
|
|
end_wait();
|
|
}
|
|
|
|
|
|
bool TPrimanota_application::cg_notify(TSheet_field& cg, int r, KEY k)
|
|
{
|
|
int i; // Contatore nello switch
|
|
const char tipo = row_type(cg.row(r)); // Tipo della riga in esame
|
|
|
|
switch(k)
|
|
{
|
|
case K_TAB:
|
|
cg.sheet_mask().enable(DLG_DELREC, tipo <= ' ' || tipo == 'K' || tipo == 'G');
|
|
cg.sheet_mask().enable(100, tipo == 'K');
|
|
break;
|
|
case K_ENTER:
|
|
if (app().iva() == nessuna_iva)
|
|
app().generazione_righe_cg(r);
|
|
app().calcola_saldo();
|
|
break;
|
|
case K_DEL:
|
|
if (tipo == 'K')
|
|
app().notify_cgline_deletion(r+1);
|
|
break;
|
|
case K_INS:
|
|
if (app().iva() == nessuna_iva && app().is_saldaconto())
|
|
{
|
|
const char tipo = app().curr_mask().get(S_TIPORIGA)[0];
|
|
switch (tipo)
|
|
{
|
|
case 'K':
|
|
cg.row(r).add("K", 15);
|
|
for (i = 0; i < r; i++)
|
|
{
|
|
const TToken_string& row = cg.row(i);
|
|
if (row_type(row) != 'K')
|
|
{
|
|
cg.swap_rows(r, i);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 'G':
|
|
cg.row(r).add("G", 15);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TPrimanota_application::descr_handler(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_TAB && f.focusdirty())
|
|
{
|
|
if (app().iva() != nessuna_iva)
|
|
{
|
|
const int first = type2pos('T');
|
|
if (first >= 0)
|
|
{
|
|
TSheet_field& cg = app().cgs();
|
|
cg.row(first).add(f.get(), 8);
|
|
cg.force_update(first);
|
|
}
|
|
}
|
|
}
|
|
if (k == K_ENTER && f.get().empty())
|
|
{
|
|
if (f.mask().get(F_CODCAUS).empty())
|
|
return f.error_box("La descrizione del documento e' necessaria in mancanza della causale");
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Handler per le colonne 'Dare' e 'Avere' dello sheet contabile.
|
|
// Scrivendo qualcosa in dare (101) cancella l'importo in avere (102) e viceversa
|
|
bool TPrimanota_application::dareavere_handler(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_TAB && f.focusdirty() && f.get().not_empty())
|
|
{
|
|
const int id = 203-f.dlg(); // Calcola id del campo da resettare
|
|
f.mask().reset(id);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// cazzorate
|
|
|
|
TSheet_field& TPrimanota_application::pags() const
|
|
{
|
|
TSheet_field& s = (TSheet_field&)_msk[2]->field(FS_RATESHEET);
|
|
return s;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Gestione sheet IVA
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TSheet_field& TPrimanota_application::ivas() const
|
|
{
|
|
TSheet_field& s = (TSheet_field&)_msk[2]->field(F_SHEETIVA);
|
|
return s;
|
|
}
|
|
|
|
|
|
TBill& TPrimanota_application::ivas_bill(TBill& c)
|
|
{
|
|
const int spric = c.tipo_cr();
|
|
if (spric == 2 || spric == 3)
|
|
{
|
|
const TFixed_string td(causale().tipo_doc());
|
|
if (td == "FV" || td == "NC") c.tipo_cr(4);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
bool TPrimanota_application::imponibile_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_TAB && f.dirty())
|
|
{
|
|
TMask& m = f.mask();
|
|
TString16 iva(m.get(102));
|
|
if (iva.empty())
|
|
{
|
|
iva = app().curr_mask().get(F_CODIVA);
|
|
m.set(102, iva);
|
|
}
|
|
if (iva.not_empty() && !app().causale().corrispettivi())
|
|
{
|
|
const real& percent = cod2IVA(m);
|
|
const real imponibile(f.get());
|
|
real imposta = abs(imponibile) * percent / 100.0; imposta.ceil();
|
|
if (imponibile.sign() < 0) imposta = -imposta;
|
|
m.set(104, imposta.string());
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool TPrimanota_application::codiva_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (!suspended_handler(f, key))
|
|
return FALSE;
|
|
|
|
if (key == K_TAB && f.dirty())
|
|
{
|
|
TMask& m = f.mask();
|
|
|
|
if (m.get_int(107) == 0)
|
|
{
|
|
TCodiceIVA iva(f.get());
|
|
TBill b; app().IVA2bill(iva, b);
|
|
|
|
char cr[2] = { b.tipo_cr() + '0', '\0' };
|
|
m.set(105, *cr > '0' ? cr : "");
|
|
|
|
const char tipo[2] = { b.tipo(), '\0' };
|
|
m.set(106, tipo);
|
|
m.set(107, b.gruppo());
|
|
m.set(108, b.conto());
|
|
const short id = b.tipo() == 'C' ? 209 : (b.tipo() == 'F' ? 309 : 109);
|
|
m.set(id, b.sottoconto());
|
|
m.set(id+1, b.descrizione());
|
|
}
|
|
|
|
TMask_field& im = m.field(101);
|
|
im.set_dirty();
|
|
im.on_hit();
|
|
} else
|
|
if (key == K_ENTER)
|
|
{
|
|
if (f.get().empty() && f.mask().get(101).not_empty())
|
|
return f.error_box("Codice IVA obbligatorio");
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TPrimanota_application::detrazione_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_TAB && f.dirty() && app().iva() == iva_acquisti)
|
|
{
|
|
TMask_field& ci = f.mask().field(101);
|
|
ci.set_dirty();
|
|
ci.on_hit();
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TPrimanota_application::imposta_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_ENTER || key == K_TAB)
|
|
{
|
|
const real imponibile(f.mask().get(101));
|
|
const real& percent = app().causale().corrispettivi() ? ZERO : cod2IVA(f.mask());
|
|
real imposta = abs(imponibile) * percent / 100.0;
|
|
imposta.ceil();
|
|
if (imponibile.sign() < 0) imposta = -imposta;
|
|
|
|
const real val(f.get());
|
|
if (val != imposta)
|
|
{
|
|
f.warning_box("L'imposta dovrebbe essere %s", (const char*)imposta.string("."));
|
|
}
|
|
} else
|
|
if (key == K_F8)
|
|
{
|
|
real imposta(f.get());
|
|
if (imposta.is_zero())
|
|
{
|
|
real imponibile(f.mask().get(101));
|
|
const real& percent = cod2IVA(f.mask());
|
|
imposta = scorpora(imponibile, percent);
|
|
f.mask().set(101, imponibile.string());
|
|
f.set(imposta.string());
|
|
}
|
|
else
|
|
f.warning_box("Cancellare l'imposta (tasto F2) prima di effettuare lo scorporo");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Calcola il totale degli imponibili e delle imposte e aggiorna
|
|
// i corrispondenti campi della maschera
|
|
// Certified 99%
|
|
real TPrimanota_application::calcola_imp() const
|
|
{
|
|
TArray& rows = ivas().rows_array();
|
|
const int max = rows.items();
|
|
|
|
real imponibili, imposte;
|
|
for (int r = 0; r < max; r++)
|
|
{
|
|
TToken_string& row = (TToken_string&)rows[r];
|
|
imponibili += real(row.get(0));
|
|
imposte += real(row.get(3));
|
|
}
|
|
|
|
curr_mask().set(F_IMPONIBILI, imponibili.string(), TRUE);
|
|
curr_mask().set(F_IMPOSTE, imposte.string(), TRUE);
|
|
|
|
return imponibili+imposte;
|
|
}
|
|
|
|
void TPrimanota_application::ivas_pack()
|
|
{
|
|
TString_array& rows = ivas().rows_array();
|
|
|
|
const int max = rows.items();
|
|
for (int i = 0; i < max; i++)
|
|
{
|
|
TToken_string& r = rows.row(i);
|
|
const real imponibile(r.get(0));
|
|
if (imponibile != ZERO) continue;
|
|
const real imposta(r.get(3));
|
|
if (imposta != ZERO) continue;
|
|
rows.destroy(i, FALSE);
|
|
}
|
|
|
|
rows.pack(); // Pack array
|
|
}
|
|
|
|
// Certified 50%
|
|
bool TPrimanota_application::iva_notify(TSheet_field& iva, int r, KEY k)
|
|
{
|
|
static int oldpos,oldposiva;
|
|
static real oldimp, oldiva;
|
|
|
|
TToken_string& row = iva.row(r);
|
|
const TCausale& cau = app().causale();
|
|
|
|
if (k == K_SPACE)
|
|
{
|
|
oldimp = real(row.get(0)); // Imponibile
|
|
oldiva = real(row.get(3)); // Imposta
|
|
|
|
if (oldiva.is_zero() && cau.corrispettivi())
|
|
{ // In caso di corrispettivi ...
|
|
const TCodiceIVA i(row.get(1));
|
|
const real percent = i.percentuale();
|
|
oldiva = scorpora(oldimp, percent); // ... scorpora imposta dall'imponibile
|
|
}
|
|
|
|
const char tipod = detraibile(row) ? 'D' : 'N';
|
|
oldposiva = type2pos(tipod);
|
|
|
|
if (oldposiva < 0 && !oldiva.is_zero())
|
|
{
|
|
const int ri = tipod == 'D' ? 3 : 4; // Calcola riga causale per l'IVA
|
|
TBill c; cau.bill(ri, c);
|
|
if (c.ok())
|
|
{
|
|
const TString80 d(cau.desc_agg(ri));
|
|
oldposiva = app().set_cgs_row(-1, app().real2imp(ZERO, 'I'), c, d, tipod);
|
|
}
|
|
else
|
|
if (ri == 4) // Se non esiste il conto IVA indetraibile ...
|
|
{ // ... somma imponibile e imposta
|
|
oldimp += oldiva;
|
|
oldiva = 0.0;
|
|
}
|
|
}
|
|
|
|
TBill oldconto(row, 6, 0x0); // g/c/s 6 7 8
|
|
if (oldconto.ok())
|
|
{
|
|
oldpos = bill2pos(oldconto, 'I');
|
|
if (oldpos < 0)
|
|
{
|
|
const TString80 d(cau.desc_agg(2));
|
|
oldpos = app().set_cgs_row(-1, app().real2imp(ZERO, 'I'), oldconto, d, 'I');
|
|
}
|
|
}
|
|
else
|
|
oldpos = -1; // Se il conto e' incompleto ignoralo
|
|
}
|
|
if (k == K_DEL) // Cancellazione di una riga
|
|
{
|
|
row.add("0", 0); // Azzera imponibile
|
|
row.add("0", 3); // Azzera imposta
|
|
k = K_ENTER; // Elegante o Sporco trucco (dipende dai gusti!)
|
|
}
|
|
if (k == K_ENTER)
|
|
{
|
|
int delimp = -1, deliva = -1; // Eventuali righe contabili da cancellare
|
|
if (oldpos >= 0) // Se il conto esisteva anche prima ...
|
|
{ // sottrai il vecchio imponibile
|
|
TImporto i(app().get_cgs_imp(oldpos));
|
|
i.valore() -= oldimp;
|
|
app().set_cgs_imp(oldpos, i);
|
|
if (i.is_zero()) delimp = oldpos;
|
|
}
|
|
if (oldposiva >= 0) // Se conto IVA esisteva anche prima ...
|
|
{ // sottrai la vecchia imposta
|
|
TImporto i(app().get_cgs_imp(oldposiva));
|
|
i.valore() -= oldiva;
|
|
app().set_cgs_imp(oldposiva, i);
|
|
if (i.is_zero()) deliva = oldposiva;
|
|
}
|
|
|
|
real imponibile(row.get(0)); // Nuovo imponibile
|
|
real imposta(row.get(3)); // Nuova imposta
|
|
|
|
if (imposta.is_zero() && app().causale().corrispettivi())
|
|
{ // In caso di corrispettivi ...
|
|
const TCodiceIVA i(row.get(1));
|
|
const real percent = i.percentuale();
|
|
imposta = scorpora(imponibile, percent); // ... scorpora imposta dall'imponibile
|
|
}
|
|
|
|
TBill conto(row, 5, 0x3);
|
|
int newpos = bill2pos(conto, 'I'); // Riga in cui andra' l'imponibile
|
|
|
|
const bool detrarre = detraibile(row); // Determina se IVA detraibile
|
|
const int ri = detrarre ? 3 : 4; // Calcola riga causale col conto opportuno
|
|
TBill contoiva; app().causale().bill(ri, contoiva);
|
|
if (ri == 4 && !contoiva.ok()) // Se non c'e' il conto IVA indetraibile ...
|
|
{ // ... somma imponibile e imposta
|
|
imponibile += imposta;
|
|
imposta = 0.0;
|
|
}
|
|
|
|
// Aggiorna conto sulla riga contabile
|
|
if (newpos < 0)
|
|
{
|
|
if (delimp >= 0)
|
|
{
|
|
app().reset_cgs_row(delimp); // Cancella vecchia riga
|
|
if (deliva > delimp) deliva--;
|
|
}
|
|
|
|
const TImporto val(app().real2imp(imponibile, 'I'));
|
|
if (conto.ok() && !val.is_zero()) // Se c'e' imponibile ...
|
|
{ // crea una nuova riga contabile
|
|
const TString80 d(cau.desc_agg(2));
|
|
app().set_cgs_row(-1, val, conto, d, 'I');
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TImporto val(app().real2imp(imponibile, 'I'));
|
|
const bool empty = app().add_cgs_imp(newpos, val);
|
|
if (empty) // Se la riga si e' azzerata ...
|
|
{ // ... cancellala
|
|
app().reset_cgs_row(newpos);
|
|
newpos = -1;
|
|
}
|
|
}
|
|
oldimp = imponibile;
|
|
oldpos = newpos;
|
|
|
|
// Aggiorna conto IVA sulla riga contabile
|
|
|
|
const char tipod = detrarre ? 'D' : 'N';
|
|
int newposiva = type2pos(tipod);
|
|
|
|
if (deliva >= 0 && newposiva != deliva) // E' cambiato il tipo d'imposta
|
|
app().reset_cgs_row(deliva); // Azzera il vecchio tipo se necessario
|
|
|
|
if (newposiva < 0)
|
|
{
|
|
if (!imposta.is_zero()) // Se c'e' imposta ...
|
|
{ // ... crea nuova riga per l'IVA
|
|
const TImporto val(app().real2imp(imposta, 'I'));
|
|
const TString80 d(cau.desc_agg(ri));
|
|
newposiva = app().set_cgs_row(-1, val, contoiva, d, tipod);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const TImporto val(app().real2imp(imposta, 'I'));
|
|
const bool empty = app().add_cgs_imp(newposiva, val);
|
|
if (empty) // Se l'imposta si e' azzerata ...
|
|
{
|
|
app().reset_cgs_row(newposiva); // ... cancellala
|
|
newposiva = -1;
|
|
}
|
|
|
|
}
|
|
|
|
oldiva = imposta;
|
|
oldposiva = newposiva;
|
|
|
|
if (r == 0) // Se cambio la prima riga ...
|
|
app().add_cgs_tot(app().curr_mask()); // ... ricalcola conti
|
|
|
|
app().calcola_imp(); // Ricalcola totale IVA
|
|
app().calcola_saldo(); // Ricalcola sbilanci
|
|
|
|
TMask& m = app().curr_mask();
|
|
if (app().is_saldaconto() && m.page_enabled(2))
|
|
app().set_scadenze(m);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Handler dello sheet
|
|
// Certified 90%
|
|
bool TPrimanota_application::iva_handler(TMask_field& f, KEY k)
|
|
{
|
|
if ((k == K_TAB && !f.mask().is_running()) || k == K_ENTER)
|
|
{
|
|
const real imp = app().calcola_imp();
|
|
const real tot = app().totale_documento();
|
|
if (k == K_ENTER)
|
|
{
|
|
if (imp != tot)
|
|
{
|
|
TString16 t(tot.string("."));
|
|
TString16 i(imp.string("."));
|
|
return error_box("La somma del totale documento e delle ritenute (%s) e' diverso dalla "
|
|
"somma degli imponibili e delle imposte (%s)", (const char*)t, (const char*)i);
|
|
}
|
|
|
|
TSheet_field& iva = app().ivas();
|
|
for (int i = 0; i < iva.items(); i++)
|
|
{
|
|
TToken_string& row = iva.row(i);
|
|
const real im(row.get(0));
|
|
if (!im.is_zero())
|
|
{
|
|
TBill c(row, 5, 0x1);
|
|
if (!c.ok() || !c.find())
|
|
return error_box("Il conto della riga iva %d e' errato o incompleto", i+1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TPrimanota_application::cg_conto_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_ENTER)
|
|
{
|
|
TMask& m = f.mask();
|
|
if (m.get(115)[0] == 'T') // Se riga totale documento
|
|
{
|
|
const char cf = m.get(f.dlg()-2)[0];
|
|
char tipo = app().clifo();
|
|
if (app().causale().corrispettivi()) tipo = ' ';
|
|
if (cf != tipo)
|
|
{
|
|
const char* d = tipo == ' ' ? "normale" : (tipo == 'C' ? "clienti" : "fornitori");
|
|
return f.error_box("E' richiesto un conto %s.", d);
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// Gestore del sottoconto dello sheet IVA
|
|
bool TPrimanota_application::iva_sottoconto_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (!suspended_handler(f, key))
|
|
return FALSE;
|
|
|
|
if (key == K_TAB && f.dirty())
|
|
{
|
|
const TLocalisamfile& piano = ((TEdit_field&)f).browse()->cursor()->file();
|
|
int spric = piano.get_int("TIPOSPRIC");
|
|
if ((spric == 2 || spric == 3) && !app().causale().corrispettivi())
|
|
{
|
|
const TFixed_string td(app().causale().tipo_doc());
|
|
if (td == "FV" || td == "NC") spric = 4;
|
|
}
|
|
f.mask().set(105, spric > 0 ? format("%d", spric) : "", TRUE);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool TPrimanota_application::sheet_clifo_handler(TMask_field& f, KEY k)
|
|
{
|
|
if (!suspended_handler(f, k))
|
|
return FALSE;
|
|
|
|
if (k == K_TAB || k == K_ENTER)
|
|
{
|
|
TMask& m = f.mask();
|
|
const short cid = 100 + (f.dlg() % 100) -1;
|
|
const int conto = m.get_int(cid);
|
|
if (conto == 0)
|
|
{
|
|
const long codice = atol(f.get());
|
|
if (codice > 0L)
|
|
{
|
|
TBill c(0, 0, codice, f.dlg() > 300 ? 'F' : 'C');
|
|
c.descrizione(); // Carica gruppo e conto
|
|
m.set(cid-1, c.gruppo());
|
|
m.set(cid, c.conto());
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Handlers dei campi della testata
|
|
///////////////////////////////////////////////////////////
|
|
|
|
// Handler of the F_NUMREG field on the query mask
|
|
// Certified 99%
|
|
bool TPrimanota_application::num_handler(TMask_field& f, KEY key)
|
|
{
|
|
TMask& m = f.mask();
|
|
const long num = atol(f.get());
|
|
if (key == K_TAB && m.is_running() && num > 0)
|
|
{
|
|
const long max = app()._lastreg+1;
|
|
|
|
app()._skip_giornale_check = FALSE;
|
|
app()._skip_bollato_check = FALSE;
|
|
|
|
if (num < max)
|
|
{
|
|
if (app().find(1))
|
|
{
|
|
const TLocalisamfile& mov = app()._rel->lfile();
|
|
bool ok = TRUE;
|
|
|
|
if (mov.get_bool("STAMPATO"))
|
|
{
|
|
ok = yesno_box("Il movimento e' gia' stato stampato sul libro giornale:\n"
|
|
"si desidera continuare ugualmente");
|
|
app()._skip_giornale_check = ok;
|
|
}
|
|
|
|
if (ok && mov.get_bool("REGST"))
|
|
{
|
|
ok = yesno_box("Il movimento e' gia' stato stampato sul bollato:\n"
|
|
"si desidera continuare ugualmente");
|
|
app()._skip_bollato_check = ok;
|
|
}
|
|
|
|
if (ok && mov.get_bool("INVIATO"))
|
|
{
|
|
ok = yesno_box("Il movimento e' stato inviato ad un'altra contabilita':\n"
|
|
"si desidera continuare ugualmente");
|
|
}
|
|
|
|
if (ok) // Riempie a mano i campi necessari nel caso non sia stato usata la ricerca F9
|
|
{
|
|
m.set(F_DATAREG, mov.get("DATAREG"), TRUE);
|
|
m.set(F_DATACOMP, mov.get("DATACOMP"), TRUE);
|
|
m.set(F_CODCAUS, mov.get("CODCAUS"));
|
|
m.stop_run(K_AUTO_ENTER);
|
|
}
|
|
}
|
|
}
|
|
else if (num > max)
|
|
{
|
|
f.set(format("%ld", max));
|
|
return f.error_box("Non e' possibile inserire movimenti superiori al %ld", max);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Handler of the F_CODCAUS field on the query mask
|
|
// Certified 99%
|
|
bool TPrimanota_application::caus_query_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (!f.mask().is_running()) return TRUE;
|
|
|
|
if (f.to_check(key))
|
|
{
|
|
const int ann = f.mask().get_int(F_ANNOIVA);
|
|
const char* cau = f.get();
|
|
|
|
const TipoIVA i = cau2IVA(cau, ann); // Cerca causale e suo tipo
|
|
if (i != iva_errata)
|
|
{
|
|
const bool ok = suspended_handler(f, key); // Controlla sospensione
|
|
if (ok && key == K_TAB)
|
|
f.mask().stop_run(K_INS); // Entra in modo inserimento
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Handler of the F_CODCAUS field on the modify mask
|
|
// Certified 99%
|
|
bool TPrimanota_application::caus_modify_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (f.to_check(key))
|
|
{
|
|
bool ok = suspended_handler(f, key);
|
|
if (!ok) return FALSE;
|
|
|
|
const int ann = f.mask().get_int(F_ANNOIVA);
|
|
const TString16 cau(f.get());
|
|
const TCausale c(cau, ann);
|
|
if (!c.ok()) return FALSE;
|
|
|
|
ok = app().causale().similar(c);
|
|
if (!ok) return FALSE;
|
|
if (key == K_TAB)
|
|
{
|
|
app().read_caus(cau, ann);
|
|
app().cgs().force_update();
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Handler of the F_DATAREG field
|
|
// Certified 70%
|
|
bool TPrimanota_application::datareg_handler(TMask_field& f, KEY key)
|
|
{
|
|
bool ok = TRUE;
|
|
TMask& m = f.mask();
|
|
|
|
if ((key == K_TAB && m.is_running()) || key == K_ENTER)
|
|
{
|
|
const TDate dr(f.get()); // Data dell'operazione
|
|
if (dr > TDate(TODAY))
|
|
return f.error_box("La data dell'operazione e' superiore quella di sistema");
|
|
|
|
const int ae = date2esc(dr); // Anno esercizio
|
|
if (ae == 0)
|
|
return f.error_box("La data dell'operazione non appartiene a nessun esercizio");
|
|
|
|
if (m.query_mode() || app().giornale().year() != ae)
|
|
ok = app().giornale().read(ae);
|
|
else
|
|
ok = TRUE;
|
|
|
|
if (!ok)
|
|
return f.error_box("Non esiste il libro giornale dell'esercizio %d", ae);
|
|
|
|
if (key == K_ENTER || f.focusdirty())
|
|
{
|
|
const long numreg = m.get_long(F_NUMREG);
|
|
const bool error = numreg == 0 || numreg > app()._lastreg;
|
|
|
|
if (key != K_ENTER && !app()._skip_giornale_check)
|
|
{
|
|
const TLibro_giornale& gio = app().giornale();
|
|
if (dr < gio.last_print())
|
|
{
|
|
f.error_box("La data dell'operazione e' antecedente al %s,\n"
|
|
"ultima stampa del libro giornale dell'esercizio %d",
|
|
gio.last_print().string(), ae);
|
|
if (error) return FALSE;
|
|
}
|
|
if (key == K_TAB && dr < gio.last_reg())
|
|
f.warning_box("La data dell'operazione e' antecedente al %s,\n"
|
|
"ultima registrazione sul libro giornale dell'esercizio %d",
|
|
gio.last_reg().string(), ae);
|
|
}
|
|
|
|
if (m.query_mode())
|
|
app().causale().read(m.get(F_CODCAUS), dr.year());
|
|
|
|
TRegistro& reg = app().causale().reg();
|
|
const TString16 codreg(reg.name());
|
|
if (codreg.not_empty())
|
|
{
|
|
if (reg.year() != dr.year())
|
|
{
|
|
const bool ok = reg.read(codreg, dr.year());
|
|
if (!ok) return FALSE;
|
|
app().read_caus(NULL, 0);
|
|
if (app().iva() != nessuna_iva)
|
|
m.field(F_CODREG).on_hit();
|
|
}
|
|
|
|
if (!app()._skip_bollato_check)
|
|
{
|
|
if (dr < reg.last_print())
|
|
{
|
|
f.error_box("La data dell'operazione e' antecedente al %s,\n"
|
|
"ultima stampa del registro '%s' dell'anno %d",
|
|
reg.last_print().string(), (const char*)codreg, dr.year());
|
|
if (error) return FALSE;
|
|
}
|
|
if (key == K_TAB && dr < reg.last_reg())
|
|
f.warning_box("La data dell'operazione e' antecedente al %s,\n"
|
|
"ultima registrazione sul registro '%s' dell'anno %d",
|
|
reg.last_reg().string(), (const char*)codreg, dr.year());
|
|
}
|
|
|
|
if (reg.iva() != nessuna_iva && app()._rel->controlla_liquidazione(dr) == TRUE)
|
|
{
|
|
const char* m = itom(dr.month());
|
|
f.warning_box("La liquidazione IVA relativa al mese di %s e' gia' stata calcolata", m);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
// Handler of the F_DATACOMP field on the modify mask
|
|
// Certified 90%
|
|
bool TPrimanota_application::datacomp_handler(TMask_field& f, KEY key)
|
|
{
|
|
TMask& m = f.mask();
|
|
|
|
if (key == K_TAB || key == K_ENTER)
|
|
{
|
|
const TDate dr(m.get(F_DATAREG)); // Data operazione
|
|
|
|
TString16 datacomp = f.get();
|
|
if (datacomp.empty())
|
|
{
|
|
datacomp = dr.string();
|
|
f.set(datacomp);
|
|
}
|
|
const TDate dc(datacomp); // Data di competenza
|
|
const int ae = date2esc(dc); // Esercizio corrispondente
|
|
|
|
const char* data = "del 74/ter";
|
|
if (f.dlg() == F_DATACOMP)
|
|
{
|
|
m.set(F_ANNOES, ae);
|
|
data = "di competenza";
|
|
}
|
|
|
|
if (ae)
|
|
{
|
|
int pr; // Esercizio precedente
|
|
const int ar = date2esc(dr, &pr); // Esercizio in corso
|
|
if (ae != ar && ae != pr)
|
|
{
|
|
TString80 e;
|
|
e << "La data " << data << " deve appartenere all'esercizio " << ar;
|
|
if (pr > 0) e << " o al " << pr;
|
|
return f.error_box(e);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m.is_running())
|
|
return f.error_box("La data %s non appartiene a nessun esercizio", data);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Handler of the F_DATA74TER field on the modify mask
|
|
// Certified 90%
|
|
bool TPrimanota_application::data74ter_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (!f.to_check(key)) return TRUE;
|
|
bool ok = datacomp_handler(f, key);
|
|
if (ok)
|
|
{
|
|
const TDate d74(f.get());
|
|
const TLibro_giornale& g = app().giornale();
|
|
if (d74 < g.last_print())
|
|
{
|
|
ok = f.error_box("La data per il 74/ter e' antecedente alla data di stampa "
|
|
"del libro giornale dell'esercizio %d", g.year());
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool TPrimanota_application::doc_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_TAB)
|
|
{
|
|
TMask& m = f.mask();
|
|
const TString16 val(f.get());
|
|
|
|
if (!val.empty() && m.field(F_ANNORIF).active())
|
|
{ // Se c'e' gestione saldaconto
|
|
if (f.dlg() == F_DATADOC)
|
|
{
|
|
const TDate dd(val);
|
|
m.set(F_ANNORIF, dd.year()); // copia data documento
|
|
}
|
|
else if (!app().npart_is_prot())
|
|
{
|
|
if (m.get(F_NUMRIF).empty())
|
|
{
|
|
m.set(F_NUMRIF, val); // copia numero documento
|
|
app().set_numrif(val);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool TPrimanota_application::numrif_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_TAB)
|
|
{
|
|
TMask& m = f.mask();
|
|
const TString& val = f.get();
|
|
|
|
if (f.focusdirty())
|
|
{
|
|
// se cambiato chiedo conferma:
|
|
// se svuotato, azzero il cazzoconto
|
|
if (val.empty())
|
|
{
|
|
if (yesno_box("Si desidera l'azzeramento delle scadenze?"))
|
|
{
|
|
// sbraga giu' il saldaconto: andra' tutto kancellato
|
|
// se c'era
|
|
app().remove_scadenze(f.mask(), app().get_numrif());
|
|
f.mask().disable_page(2);
|
|
}
|
|
else f.set(app().get_numrif());
|
|
}
|
|
else
|
|
{
|
|
if (yesno_box("Si desidera la ridefinizione delle scadenze?"))
|
|
{
|
|
// lo ridefinisco da capo
|
|
// con il nuovo porcodio, riabilitando se
|
|
// non c'era
|
|
app().remove_scadenze(f.mask(), app().get_numrif());
|
|
|
|
app().reset_pagamento();
|
|
app().set_scadenze(m);
|
|
f.mask().enable_page(2);
|
|
|
|
}
|
|
else f.set(app().get_numrif());
|
|
}
|
|
}
|
|
app().set_numrif(f.get());
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool TPrimanota_application::occas_code_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_TAB)
|
|
{
|
|
const char* code = f.get();
|
|
if (*code)
|
|
{
|
|
TRelation occas(LF_OCCAS);
|
|
occas.lfile().put("CFPI", code);
|
|
if (occas.read(_isequal) == NOERR)
|
|
{
|
|
f.mask().autoload(&occas);
|
|
f.mask().send_key(K_TAB, O_COMUNE); // Forza decodifica comuni
|
|
f.mask().send_key(K_TAB, O_COMUNENAS);
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TPrimanota_application::occas_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_SPACE && f.mask().is_running())
|
|
{
|
|
TMask& om = app().occas_mask();
|
|
om.run();
|
|
f.set_focus();
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// Crea o aggiorna la riga contabile col totale documento
|
|
// Certified 99%
|
|
void TPrimanota_application::add_cgs_tot(TMask& m)
|
|
{
|
|
// Lettura del conto dalla maschera
|
|
char tipo = app().clifo();
|
|
long codice = m.get_long(tipo == 'C' ? F_CLIENTE : F_FORNITORE);
|
|
TBill bill(0, 0, codice, tipo);
|
|
|
|
if (!causale().corrispettivi())
|
|
bill.find();
|
|
|
|
if (bill.conto() == 0)
|
|
{
|
|
// Se l'utente non ha ancora specificato un conto lo prendo dalla prima riga della causale
|
|
causale().bill(1, bill);
|
|
if (causale().corrispettivi())
|
|
{
|
|
tipo = ' ';
|
|
codice = bill.sottoconto();
|
|
}
|
|
}
|
|
|
|
TBill nuovo(bill.gruppo(), bill.conto(), codice, tipo);
|
|
|
|
real tot(m.get(F_TOTALE));
|
|
|
|
const int pos = type2pos('T');
|
|
if (pos >= 0)
|
|
{
|
|
TSheet_field& ss = cgs();
|
|
TToken_string& row = ss.row(pos);
|
|
const TBill vecchio(row, 2, 0x1);
|
|
if (!vecchio.empty() && nuovo != vecchio) // Se cambio cliente/fornitore
|
|
{
|
|
for (int i = 0; i < ss.items(); i++) if (i != pos)
|
|
{
|
|
TToken_string& r = ss.row(i);
|
|
const TBill tacchia(r, 9, 0x1);
|
|
if (tacchia == vecchio)
|
|
{
|
|
nuovo.add_to(r, 9, 0x3); // Aggiorna contropartite
|
|
ss.force_update(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Creazione/Aggiornamento riga totale
|
|
set_cgs_row(pos, real2imp(tot, 'T'), nuovo, m.get(F_DESCR), 'T');
|
|
calcola_saldo();
|
|
}
|
|
|
|
// Handler of the F_CLIENTE & F_FORNITORE field on the modify mask
|
|
// Certified 99%
|
|
bool TPrimanota_application::clifo_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_TAB && f.active())
|
|
{
|
|
TMask& m = f.mask();
|
|
|
|
const char cf = app().clifo();
|
|
TLocalisamfile& clifo = ((TEdit_field&)f).browse()->cursor()->file();
|
|
|
|
if (clifo.get_char(CLI_TIPOCF) != cf || clifo.get(CLI_CODCF) != f.get())
|
|
{
|
|
clifo.setkey(1);
|
|
clifo.put(CLI_TIPOCF, cf);
|
|
clifo.put(CLI_CODCF, f.get());
|
|
clifo.read();
|
|
CHECK(clifo.good(), "Impossibile ritrovare il clifo");
|
|
}
|
|
if (!suspended_handler(f, key))
|
|
return FALSE;
|
|
|
|
if (!m.is_running() || f.dirty())
|
|
{
|
|
app()._conto_ricavo.set(clifo.get_int(CLI_GRUPPORIC),
|
|
clifo.get_int(CLI_CONTORIC),
|
|
clifo.get_long(CLI_SOTTOCRIC));
|
|
|
|
const int alleg = clifo.get_int(CLI_ALLEG);
|
|
TEdit_field& upi = m.efield(F_RIEPILOGO);
|
|
upi.check_type(alleg == 3 ? CHECK_REQUIRED : CHECK_NORMAL);
|
|
|
|
const TString& s = clifo.get(CLI_CODPAG);
|
|
if (s.not_empty()) m.set(F_CODPAG, s, TRUE);
|
|
}
|
|
|
|
const bool occas = clifo.get_bool(CLI_OCCAS);
|
|
m.show(F_OCCASEDIT, occas); // Bottone Dati anagrafici
|
|
m.show(F_STATOPAIV, !occas); // Stato partita IVA
|
|
m.show(cf == 'C' ? F_PIVACLIENTE : F_PIVAFORNITORE, !occas); // Partita IVA
|
|
m.show(cf == 'C' ? F_COFICLIENTE : F_COFIFORNITORE, !occas); // Codice Fiscale
|
|
|
|
if (f.focusdirty())
|
|
{
|
|
app().add_cgs_tot(m);
|
|
|
|
if (m.field(S_VALUTA).active())
|
|
{
|
|
const TString16 valuta(clifo.get("CODVAL"));
|
|
if (valuta.not_empty() && valuta != m.get(S_VALUTA))
|
|
{
|
|
TTable val("%val");
|
|
val.put("CODTAB", valuta);
|
|
if (val.read() == NOERR)
|
|
{
|
|
m.set(S_VALUTA, valuta);
|
|
m.set(S_CAMBIO, val.get("R10"), TRUE);
|
|
}
|
|
}
|
|
}
|
|
if (occas && app().occas_mask().get(O_CODICE).empty())
|
|
m.send_key(K_SPACE, F_OCCASEDIT); // Lancia maschera occasionali
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool TPrimanota_application::IVA2bill(const TCodiceIVA& iva, TBill& bill)
|
|
{
|
|
const TCausale& cau = causale();
|
|
const TString& tipo = iva.tipo();
|
|
|
|
if (tipo.not_empty())
|
|
{
|
|
if (tipo == "ES") cau.bill(5, bill); else
|
|
if (tipo == "NI") cau.bill(6, bill); else
|
|
if (tipo == "NS") cau.bill(7, bill);
|
|
}
|
|
if (!bill.ok() && !cau.corrispettivi())
|
|
bill = _conto_ricavo;
|
|
|
|
if (!bill.ok())
|
|
cau.bill(2, bill);
|
|
|
|
ivas_bill(bill);
|
|
|
|
return bill.ok();
|
|
}
|
|
|
|
|
|
// Handler of the F_CODIVA
|
|
// Certified 99%
|
|
bool TPrimanota_application::main_codiva_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_TAB && f.get().not_empty())
|
|
{
|
|
if (!suspended_handler(f, key))
|
|
return FALSE;
|
|
|
|
const real imp(app().ivas().row(1).get(0)); // Se il totale non e' stato spezzato
|
|
if (imp.is_zero())
|
|
{
|
|
TToken_string& row = app().ivas().row(0);
|
|
|
|
TMask& m = f.mask();
|
|
iva_notify(app().ivas(), 0, K_SPACE);
|
|
|
|
const TCodiceIVA iva(f.get());
|
|
const bool corr = app().causale().corrispettivi();
|
|
const bool acq3 = (app().iva() == iva_acquisti) && (row.get_int(2) == 3);
|
|
|
|
real tot = app().totale_documento(); // Calcola totale documento
|
|
real imposta; // Calcola imposta
|
|
if (!corr && !acq3)
|
|
imposta = app().scorpora(tot, iva.percentuale());
|
|
|
|
row.add(tot.string(), 0); // imponibile
|
|
row.add(imposta.string(), 3); // imposta
|
|
|
|
if (iva.codice() != row.get(1))
|
|
{
|
|
row.add(iva.codice(), 1); // Aggiorna codice IVA
|
|
TBill bill; // Aggiorna conto della prima riga IVA
|
|
app().IVA2bill(iva, bill);
|
|
bill.add_to(row, 4, 0x7);
|
|
}
|
|
app().ivas().force_update(0);
|
|
|
|
iva_notify(app().ivas(), 0, K_ENTER);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// Handler of the F_TOTALE
|
|
// Certified 99%
|
|
bool TPrimanota_application::totale_handler(TMask_field& f, KEY key)
|
|
{
|
|
bool ok = TRUE;
|
|
TMask& m = f.mask();
|
|
|
|
if (key == K_TAB && f.focusdirty())
|
|
{
|
|
app().add_cgs_tot(m);
|
|
m.field(F_CODIVA).on_hit();
|
|
}
|
|
|
|
if (key == K_ENTER && f.get().empty())
|
|
ok = f.yesno_box("Totale documento nullo: continuare ugualmente?");
|
|
return ok;
|
|
}
|
|
|
|
bool TPrimanota_application::totdoc_handler(TMask_field& f, KEY key)
|
|
{
|
|
bool ok = TRUE;
|
|
if (key == K_ENTER && f.get().empty())
|
|
ok = f.yesno_box("Totale documento nullo: continuare ugualmente?");
|
|
return ok;
|
|
}
|
|
|
|
|
|
void TPrimanota_application::add_cgs_rit(bool fiscali)
|
|
{
|
|
const real imp(curr_mask().get(fiscali ? F_RITFIS : F_RITSOC));
|
|
|
|
const char tipo = fiscali ? 'F' : 'S';
|
|
const int pos = type2pos(tipo);
|
|
if (pos < 0)
|
|
{
|
|
const int riga = fiscali ? 8 : 9;
|
|
TBill conto; causale().bill(riga, conto);
|
|
const TString80 desc(causale().desc_agg(riga));
|
|
set_cgs_row(-1, real2imp(imp, tipo), conto, desc, tipo);
|
|
}
|
|
else
|
|
{
|
|
if (imp.is_zero())
|
|
reset_cgs_row(pos);
|
|
else
|
|
set_cgs_imp(pos, real2imp(imp, tipo));
|
|
}
|
|
}
|
|
|
|
// Handler of the F_PROTIVA
|
|
bool TPrimanota_application::protiva_handler(TMask_field& f, KEY key)
|
|
{
|
|
bool ok = TRUE;
|
|
const TString16 piva(f.get());
|
|
if (key == K_ENTER && f.dirty() && f.mask().mode() == MODE_INS)
|
|
{
|
|
const long protiva = atol(f.get());
|
|
const long protocol = app().causale().reg().protocol() + 1;
|
|
if (protiva != protocol)
|
|
ok = f.yesno_box("Accettare il protocollo IVA fuori sequenza: %ld invece di %ld",
|
|
protiva, protocol);
|
|
|
|
}
|
|
else if (key == K_TAB && app().is_saldaconto() && f.mask().get(F_NUMRIF).empty())
|
|
{
|
|
if (app().npart_is_prot())
|
|
{
|
|
f.mask().set(F_NUMRIF, piva);
|
|
app().set_numrif(piva);
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
|
|
// Handler of the F_RITFIS
|
|
// Certified 99%
|
|
bool TPrimanota_application::ritfis_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_TAB && f.focusdirty())
|
|
app().add_cgs_rit(TRUE);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Handler of F_RITSOC
|
|
// Certified 99%
|
|
bool TPrimanota_application::ritsoc_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_TAB && f.focusdirty())
|
|
app().add_cgs_rit(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
// Handler of F_CORRLIRE
|
|
// Certified 99%
|
|
bool TPrimanota_application::corrlire_handler(TMask_field& f, KEY key)
|
|
{
|
|
TMask& m = f.mask();
|
|
|
|
if (key == K_ENTER && f.get().empty())
|
|
{
|
|
if (m.get(F_CORRVALUTA).not_empty())
|
|
{
|
|
TMask_field& cv = m.field(F_CORRVALUTA);
|
|
cv.set_focusdirty();
|
|
cv.on_hit();
|
|
}
|
|
else
|
|
key = K_F8;
|
|
}
|
|
|
|
if (key == K_F8)
|
|
{
|
|
f.set(m.get(F_IMPONIBILI));
|
|
f.set_dirty();
|
|
m.reset(F_CORRVALUTA);
|
|
key = K_TAB;
|
|
}
|
|
if (key == K_TAB && f.focusdirty())
|
|
{
|
|
if (m.get(F_CORRVALUTA).empty())
|
|
{
|
|
const real cambio = m.get(F_CAMBIOINTRA);
|
|
if (cambio != ZERO && m.get(F_CORRVALUTA).empty())
|
|
{
|
|
real c(f.get());
|
|
c /= cambio;
|
|
m.set(F_CORRVALUTA, c.string());
|
|
}
|
|
}
|
|
}
|
|
|
|
if (key == K_ENTER)
|
|
{
|
|
const TString16 im(m.get(F_IMPONIBILI));
|
|
const char* cl = f.get();
|
|
if (im != cl)
|
|
warning_box("Il corrispettivo in lire e' diverso dal totale degli imponibili");
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Handler of F_CORRVALUTA
|
|
// Certified 99%
|
|
bool TPrimanota_application::corrvaluta_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_TAB && f.focusdirty())
|
|
{
|
|
TMask& m = f.mask();
|
|
if (m.get(F_CORRLIRE).empty())
|
|
{
|
|
const real cambio = m.get(F_CAMBIOINTRA);
|
|
if (cambio != ZERO)
|
|
{
|
|
real c = f.get();
|
|
c *= cambio;
|
|
m.set(F_CORRLIRE, c.string());
|
|
}
|
|
}
|
|
} else
|
|
if (key == K_ENTER && f.get().empty())
|
|
{
|
|
TMask_field& cl = f.mask().field(F_CORRLIRE);
|
|
cl.set_dirty();
|
|
cl.on_hit();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool TPrimanota_application::solaiva_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (key == K_SPACE)
|
|
{
|
|
TMask& m = f.mask();
|
|
const bool anchecg = !m.get_bool(F_SOLAIVA);
|
|
|
|
m.show(F_SHEETCG, anchecg);
|
|
m.show(F_DARE, anchecg);
|
|
m.show(F_AVERE, anchecg);
|
|
|
|
if (m.is_running() && anchecg)
|
|
{
|
|
TSheet_field& iva = app().ivas();
|
|
const int righe = iva.items();
|
|
TProgind pi(righe, "Generazione righe contabilita'", FALSE, TRUE, 16);
|
|
|
|
app().cgs().reset();
|
|
app().add_cgs_tot(m);
|
|
if (m.get(F_RITFIS).not_empty()) app().add_cgs_rit(TRUE);
|
|
if (m.get(F_RITSOC).not_empty()) app().add_cgs_rit(FALSE);
|
|
|
|
TToken_string oldrow(128);
|
|
for (int i = 0; i < righe; i++)
|
|
{
|
|
TToken_string& r = iva.row(i);
|
|
if (!r.empty_items())
|
|
{
|
|
oldrow = r;
|
|
r = "";
|
|
iva_notify(iva, i, K_SPACE);
|
|
r = oldrow;
|
|
iva_notify(iva, i, K_ENTER);
|
|
}
|
|
pi.setstatus(i+1);
|
|
}
|
|
app().fill_sheet(m);
|
|
app().cgs().force_update();
|
|
m.set_focus();
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|