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

Aggiunta gestione IVA per cassa

Browse Source 
git-svn-id: svn://10.65.10.50/branches/R_10_00@22755 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 2012-10-26 09:12:52 +00:00
parent b4692685a8
commit 200b962343
27 changed files with 1058 additions and 875 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
cg/cg0200.cpp
View File

@ -384,8 +384,7 @@ bool TClifo_application::crea_percipienti(TMask_field& f, KEY key)
{ {
if (tipo == 'F') if (tipo == 'F')
{ {
TLocalisamfile anafis(LF_ANAGFIS); TLocalisamfile anafis(LF_ANAGFIS);
anafis.put(ANF_CODANAGR, percip); anafis.put(ANF_CODANAGR, percip);
anafis.put(ANF_DATANASC, m.get(F_DATANASC)); anafis.put(ANF_DATANASC, m.get(F_DATANASC));
anafis.put(ANF_SESSO, atoi(m.get(F_COFI).mid(9, 2)) > 31 ? 'F' : 'M'); anafis.put(ANF_SESSO, atoi(m.get(F_COFI).mid(9, 2)) > 31 ? 'F' : 'M');
@ -397,9 +396,7 @@ bool TClifo_application::crea_percipienti(TMask_field& f, KEY key)
else else
{ {
TLocalisamfile anagiu(LF_ANAGGIU); TLocalisamfile anagiu(LF_ANAGGIU);
anagiu.put(ANG_CODANAGR, percip); anagiu.put(ANG_CODANAGR, percip);
err = anagiu.write(); err = anagiu.write();
if (err != NOERR) if (err != NOERR)
return cantwrite_box(anagiu.description()); return cantwrite_box(anagiu.description());

1
cg/cg2.cpp
View File

@ -14,6 +14,5 @@ int main(int argc,char** argv)
default: default:
cg2100(argc, argv); break; cg2100(argc, argv); break;
} }
exit(0);
return 0; return 0;
} }

6
cg/cg2100.cpp
View File

@ -1557,7 +1557,7 @@ void TPrimanota_application::genera_automatico(int tipo, const char* causimm)
case 2: // Regolarizzazione IVA case 2: // Regolarizzazione IVA
{ {
// Reperisce l'eventuale cliente associato al fornitore e lo propone // Reperisce l'eventuale cliente associato al fornitore e lo propone
TString16 forn; forn.format("F|%ld", _automatico->_clifo.codclifo()); TString8 forn; forn.format("F|%ld", _automatico->_clifo.codclifo());
const TString& clnt = cache().get(LF_CLIFO, forn, CLI_CODCFASS); const TString& clnt = cache().get(LF_CLIFO, forn, CLI_CODCFASS);
m.set(F_CLIENTE, clnt); m.set(F_CLIENTE, clnt);
m.set(F_TOTALE, _automatico->_totale); // Imposta il totale documento e ... m.set(F_TOTALE, _automatico->_totale); // Imposta il totale documento e ...
@ -1719,6 +1719,7 @@ bool TPrimanota_application::link_m770()
} }
} }
else // Movimento puramente contabile else // Movimento puramente contabile
{
switch (m770) switch (m770)
{ {
case 1: case 1:
@ -1739,6 +1740,7 @@ bool TPrimanota_application::link_m770()
break; break;
default: default:
break; break;
}
} }
if (tipo_coll) if (tipo_coll)
@ -1760,7 +1762,7 @@ bool TPrimanota_application::link_m770()
s.add(imposte.string()); s.add(imposte.string());
s.add(ritenute.string()); s.add(ritenute.string());
const char* name = (tipo_coll == 4) ? "770 -1" : "770 -0"; const char* const name = (tipo_coll == 4) ? "770 -1" : "770 -0";
TMessage m(name, "LINK770", s); TMessage m(name, "LINK770", s);
m.send(); m.send();

1
cg/cg2100.h
View File

@ -77,6 +77,7 @@
#define F_ADJUST_IVA 148 #define F_ADJUST_IVA 148
#define F_DATAINC 149 #define F_DATAINC 149
#define F_LIQDIFF 150 #define F_LIQDIFF 150
#define F_IVAXCASSA 167
#define F_GRUPPO 180 #define F_GRUPPO 180
#define F_CONTO 181 #define F_CONTO 181

30
cg/cg2100c.uml
View File

@ -592,22 +592,28 @@ BEGIN
FIELD DATA74TER FIELD DATA74TER
END END
BOOLEAN F_IVAXCASSA
BEGIN
PROMPT 1 17 "IVA per cassa"
FIELD IVAXCASSA
MODULE IC
END
BOOLEAN F_LIQDIFF BOOLEAN F_LIQDIFF
BEGIN BEGIN
PROMPT 38 15 "Liq.differita" PROMPT 25 17 "Liquidazione differita"
WARNING "Data di incasso per liquidazione differita" WARNING "Data di incasso per liquidazione differita"
FIELD LIQDIFF FIELD LIQDIFF
MESSAGE FALSE HIDE,F_DATAINC|RESET,F_DATAINC MESSAGE FALSE CLEAR,F_DATAINC
MESSAGE TRUE SHOW,F_DATAINC MESSAGE TRUE ENABLE,F_DATAINC
FLAGS "H" FLAGS "H"
END END
DATE F_DATAINC DATE F_DATAINC
BEGIN BEGIN
PROMPT 54 15 "Data incasso " PROMPT 52 17 "Data incasso "
WARNING "Data di incasso per liquidazione differita" WARNING "Data di incasso per liquidazione differita"
FIELD DATAINC FIELD DATAINC
FLAGS "H"
END END
NUMBER F_ANNORIF 4 NUMBER F_ANNORIF 4
@ -626,7 +632,7 @@ END
STRING F_VALUTAINTRA 3 STRING F_VALUTAINTRA 3
BEGIN BEGIN
PROMPT 1 17 "Cambio intracom. " PROMPT 1 18 "Cambio intracom. "
FIELD CODVALI FIELD CODVALI
FLAGS "UZ" FLAGS "UZ"
GROUP 4 GROUP 4
@ -644,7 +650,7 @@ END
NUMBER F_CAMBIOINTRA 15 6 NUMBER F_CAMBIOINTRA 15 6
BEGIN BEGIN
PROMPT 25 17 "" PROMPT 25 18 ""
FIELD CAMBIOI FIELD CAMBIOI
FLAGS "U" FLAGS "U"
GROUP 4 GROUP 4
@ -653,20 +659,20 @@ END
DATE F_DATAINTRA DATE F_DATAINTRA
BEGIN BEGIN
PROMPT 43 17 "Data competenza intra " PROMPT 43 18 "Data competenza intra "
FIELD DATACOMPI FIELD DATACOMPI
END END
CURRENCY F_CORRISPETTIVO 18 CURRENCY F_CORRISPETTIVO 18
BEGIN BEGIN
PROMPT 1 18 "Corrispettivo " PROMPT 1 19 "Corrispettivo "
FIELD CORRLIRE FIELD CORRLIRE
GROUP 4 GROUP 4
END END
CURRENCY F_CORRVALUTA 18 CURRENCY F_CORRVALUTA 18
BEGIN BEGIN
PROMPT 39 18 "Corrispet. valuta " PROMPT 39 19 "Corrispet. valuta "
FIELD CORRVALUTA FIELD CORRVALUTA
GROUP 4 GROUP 4
VALIDATE REQIF_FUNC 1 F_VALUTAINTRA VALIDATE REQIF_FUNC 1 F_VALUTAINTRA
@ -675,7 +681,7 @@ END
STRING NP_CONTSEP 6 STRING NP_CONTSEP 6
BEGIN BEGIN
PROMPT 1 19 "Cont. separata " PROMPT 1 20 "Cont. separata "
USE &NPENT USE &NPENT
INPUT CODTAB NP_CONTSEP INPUT CODTAB NP_CONTSEP
DISPLAY "Codice@6" CODTAB DISPLAY "Codice@6" CODTAB
@ -688,7 +694,7 @@ END
STRING NP_DESCONTSEP 50 STRING NP_DESCONTSEP 50
BEGIN BEGIN
PROMPT 25 19 "" PROMPT 25 20 ""
USE &NPENT KEY 2 USE &NPENT KEY 2
INPUT S0 NP_DESCONTSEP INPUT S0 NP_DESCONTSEP
DISPLAY "Descrizione@50" S0 DISPLAY "Descrizione@50" S0

2
cg/cg2101.cpp
View File

@ -217,7 +217,7 @@ int TMovimentoPN::registra(bool re, bool force)
const int annoiva = m.get_int(MOV_ANNOIVA); const int annoiva = m.get_int(MOV_ANNOIVA);
const TString4 reg(m.get(MOV_REG)); const TString4 reg(m.get(MOV_REG));
TRegistro registro(reg, annoiva); TRegistro registro(reg, annoiva);
const bool att_mista = reg.empty() ? FALSE : registro.attivita_mista(); const bool att_mista = reg.empty() ? false : registro.attivita_mista();
for (int i = 0 ; i < iva_items(); i++) for (int i = 0 ; i < iva_items(); i++)
{ {

39
cg/cg2102.cpp
View File

@ -1,5 +1,6 @@
#include <automask.h> #include <automask.h>
#include <colors.h> #include <colors.h>
#include <dongle.h>
#include <execp.h> #include <execp.h>
#include <msksheet.h> #include <msksheet.h>
#include <progind.h> #include <progind.h>
@ -2241,7 +2242,7 @@ bool TPrimanota_application::datareg_handler(TMask_field& f, KEY key)
const TDate oggi(TODAY); const TDate oggi(TODAY);
TDate dr(f.get()); // Data dell'operazione TDate dr(f.get()); // Data dell'operazione
if (dr > oggi) if (dr > oggi)
return f.error_box(TR("La data dell'operazione e' superiore quella di sistema")); return f.error_box(TR("La data dell'operazione è superiore quella di sistema"));
TMask& m = f.mask(); TMask& m = f.mask();
if (dr == oggi && m.query_mode() && !m.field(F_NUMREG).empty()) if (dr == oggi && m.query_mode() && !m.field(F_NUMREG).empty())
@ -2270,6 +2271,8 @@ bool TPrimanota_application::datareg_handler(TMask_field& f, KEY key)
if (key == K_ENTER || f.focusdirty()) if (key == K_ENTER || f.focusdirty())
{ {
m.enable(F_IVAXCASSA, a.gestione_IVAxCassa(dr));
const long numreg = m.get_long(F_NUMREG); const long numreg = m.get_long(F_NUMREG);
const bool error = numreg == 0 || numreg > a._lastreg; const bool error = numreg == 0 || numreg > a._lastreg;
@ -2301,8 +2304,8 @@ bool TPrimanota_application::datareg_handler(TMask_field& f, KEY key)
a.read_caus(m.get(F_CODCAUS), ar); a.read_caus(m.get(F_CODCAUS), ar);
TRegistro& reg = a.causale().reg(); TRegistro& reg = a.causale().reg();
const TString codreg(reg.name()); const TString4 codreg = reg.name();
if (codreg.not_empty()) if (codreg.full())
{ {
if (reg.year() != ar) if (reg.year() != ar)
{ {
@ -2715,7 +2718,7 @@ bool TPrimanota_application::clifo_handler(TMask_field& f, KEY key)
const bool del = f.yesno_box(TR("Si desidera cancellare i pagamenti effettuati?")); const bool del = f.yesno_box(TR("Si desidera cancellare i pagamenti effettuati?"));
if (!del) // Ripristina codice copiandolo dalla prima partita if (!del) // Ripristina codice copiandolo dalla prima partita
{ {
TString cod; cod << game->conto().codclifo(); TString8 cod; cod << game->conto().codclifo();
f.set(cod); f.set(cod);
return true; return true;
} }
@ -2805,7 +2808,6 @@ bool TPrimanota_application::clifo_handler(TMask_field& f, KEY key)
m.set(FS_NSCAB, clifov.get(CFV_CODCABPR)); m.set(FS_NSCAB, clifov.get(CFV_CODCABPR));
m.send_key(K_TAB, FS_NSCAB); m.send_key(K_TAB, FS_NSCAB);
} }
const TString& agente = clifov.get(CLI_CODAG); const TString& agente = clifov.get(CLI_CODAG);
if (agente.full()) if (agente.full())
{ {
@ -2826,7 +2828,7 @@ bool TPrimanota_application::clifo_handler(TMask_field& f, KEY key)
if (occas && a.is_fattura() && a.partite().first() != NULL) if (occas && a.is_fattura() && a.partite().first() != NULL)
{ {
f.warning_box(TR("Attenzione, il saldaconto verra' eliminato!")); f.warning_box(TR("Attenzione, il saldaconto verrà eliminato!"));
f.set_dirty(); // warning_box cleans the field! f.set_dirty(); // warning_box cleans the field!
} }
a.activate_numrif(m, true); a.activate_numrif(m, true);
@ -2836,6 +2838,12 @@ bool TPrimanota_application::clifo_handler(TMask_field& f, KEY key)
a.add_cgs_tot(m); a.add_cgs_tot(m);
if (occas && a.occas_mask().get(O_CODICE).blank()) if (occas && a.occas_mask().get(O_CODICE).blank())
m.send_key(K_SPACE, F_OCCASEDIT); // Lancia maschera occasionali m.send_key(K_SPACE, F_OCCASEDIT); // Lancia maschera occasionali
if (m.field(F_IVAXCASSA).active())
{
const int alleg = clifo.get_int(CLI_ALLEG);
m.set(F_IVAXCASSA, alleg != 6);
}
} }
} }
@ -3275,6 +3283,25 @@ bool TPrimanota_application::corrvaluta_handler(TMask_field& f, KEY key)
return true; return true;
} }
bool TPrimanota_application::gestione_IVAxCassa(const TDate& data) const
{
bool yes = has_module(ICAUT);
if (yes)
{
TString16 codtab;
codtab.format("%05ld%04d", get_firm(), data.year());
const TRectype& lia = cache().get("%LIA", codtab);
yes = lia.get_bool("B5");
if (yes)
{
TDate dal = lia.get("D0"); if (!dal.ok()) dal = TDate(1,1,data.year());
TDate al = lia.get("D1"); if (!al.ok()) dal = TDate(31,12,data.year());
yes = data >= dal && data <= al;
}
}
return yes;
}
bool TPrimanota_application::activate_numrif(TMask& m, bool init_pag) bool TPrimanota_application::activate_numrif(TMask& m, bool init_pag)
{ {
// Il numero riferimento esiste // Il numero riferimento esiste

3
cg/cg2102.h
View File

@ -206,7 +206,8 @@ protected:
char clifo() const { return iva() == iva_vendite ? 'C' : 'F'; } char clifo() const { return iva() == iva_vendite ? 'C' : 'F'; }
bool gestione_valuta() const { return _ges_val; } bool gestione_valuta() const { return _ges_val; }
bool gestione_saldaconto() const { return _ges_sal; } bool gestione_saldaconto() const { return _ges_sal; }
bool npart_is_prot() { return _npart_is_prot; } bool npart_is_prot() const { return _npart_is_prot; }
bool gestione_IVAxCassa(const TDate& data) const;
bool is_saldaconto() const { return _is_saldaconto; } bool is_saldaconto() const { return _is_saldaconto; }
bool is_fattura() const { return is_saldaconto() && causale().tipomov() == 1; } bool is_fattura() const { return is_saldaconto() && causale().tipomov() == 1; }

60
cg/cg4100.cpp
View File

@ -10,6 +10,8 @@
#include <isam.h> #include <isam.h>
#include <mask.h> #include <mask.h>
#include <progind.h> #include <progind.h>
#include <recset.h>
#include <relation.h>
#include <sort.h> #include <sort.h>
#include <utility.h> #include <utility.h>
@ -71,8 +73,7 @@ bool CG4100_App::sort_sal()
if (!set_parms()) if (!set_parms())
return FALSE; return FALSE;
TSystemisamfile saldi(LF_SALDI); saldi.open(_excllock); TSystemisamfile saldi(LF_SALDI); saldi.open(_excllock);
TLocalisamfile rmov(LF_RMOV);
TLocalisamfile mov(LF_MOV); TLocalisamfile mov(LF_MOV);
TSaldo_agg sal; TSaldo_agg sal;
@ -82,12 +83,8 @@ bool CG4100_App::sort_sal()
int gruppo, conto; int gruppo, conto;
const int year = _year; const int year = _year;
long oldnumreg = 0L, sottoconto; long oldnumreg = 0L, sottoconto;
TProgind prnd(rmov.items(),
TR("Riordino archivio saldi in corso\nLettura archivio movimenti..."),
FALSE,TRUE);
mov.setkey(1); mov.setkey(1);
rmov.first();
sal.reset(); sal.reset();
sal.set_anno_es(year); sal.set_anno_es(year);
sal.clear_saldi(year); sal.clear_saldi(year);
@ -95,9 +92,20 @@ bool CG4100_App::sort_sal()
tiposal tsal = normale; tiposal tsal = normale;
bool provvis = FALSE; bool provvis = FALSE;
TDate datareg; TDate datareg;
TString query; query << "USE RMOV SELECT ANNOES=" << _year;
TISAM_recordset righe(query);
TProgind prnd(righe.items(),
TR("Riordino archivio saldi in corso\nLettura archivio movimenti..."),
FALSE, TRUE);
const TRectype& rmov = righe.cursor()->curr();
while (!rmov.eof()) for (bool ok = righe.move_first(); ok; ok = righe.move_next())
{ {
if (!prnd.addstatus(1))
break;
if (_year == rmov.get_int(RMV_ANNOES)) if (_year == rmov.get_int(RMV_ANNOES))
{ {
numreg = rmov.get_long(RMV_NUMREG); numreg = rmov.get_long(RMV_NUMREG);
@ -109,10 +117,10 @@ bool CG4100_App::sort_sal()
if (numreg != oldnumreg) if (numreg != oldnumreg)
{ {
if (oldnumreg !=0) if (sal.items() > 0)
{ {
if (sal.items() > 0) sal.registra();
sal.registra(); sal.reset();
} }
oldnumreg = numreg; oldnumreg = numreg;
mov.zero(); mov.zero();
@ -123,25 +131,20 @@ bool CG4100_App::sort_sal()
// Tipo saldo normale per default // Tipo saldo normale per default
tsal = normale; tsal = normale;
const TString& codcaus = mov.get(MOV_CODCAUS); const TString& codcaus = mov.get(MOV_CODCAUS);
if (codcaus.not_empty()) // cerca causale per determinare il tipo del saldo const TRectype& causale = cache().get(LF_CAUSALI, codcaus);
if (!causale.empty())
{ {
const TRectype& causale = cache().get(LF_CAUSALI, codcaus); const char ac = causale.get_char(CAU_MOVAP);
if (!causale.empty()) if (ac == 'A')
{ tsal = apertura; else
const char ac = causale.get_char(CAU_MOVAP); if (ac == 'C')
if (ac == 'A') tsal = chiusura;
tsal = apertura; }
else
if (ac == 'C')
tsal = chiusura;
}
}
scaricato = mov.get_bool(MOV_SCARCON); scaricato = mov.get_bool(MOV_SCARCON);
provvis = mov.get(MOV_PROVVIS).not_empty(); provvis = mov.get(MOV_PROVVIS).not_empty();
datareg = mov.get_date(MOV_DATAREG); datareg = mov.get_date(MOV_DATAREG);
sal.reset();
sal.set_anno_es(_year); sal.set_anno_es(_year);
sal.set_tipo_saldo(tsal); sal.set_tipo_saldo(tsal);
sal.set_movprovv(provvis); sal.set_movprovv(provvis);
@ -149,21 +152,16 @@ bool CG4100_App::sort_sal()
sal.set_num_ulmov(oldnumreg); sal.set_num_ulmov(oldnumreg);
} }
const char sezione = rmov.get(RMV_SEZIONE)[0]; const char sezione = rmov.get(RMV_SEZIONE)[0];
real importo(rmov.get(RMV_IMPORTO)); const real importo = rmov.get(RMV_IMPORTO);
sal.aggiorna(gruppo, conto, sottoconto, importo, sezione, TRUE, scaricato); sal.aggiorna(gruppo, conto, sottoconto, importo, sezione, TRUE, scaricato);
} }
rmov.next();
prnd.addstatus(1);
do_events();
} }
if (sal.items() > 0) sal.registra();
sal.registra();
remove("__sal__.sav"); remove("__sal__.sav");
saldi.close(); return true;
return TRUE;
} }
int cg4100(int argc, char* argv[]) int cg4100(int argc, char* argv[])

43
cg/cg4300.cpp
View File

@ -80,7 +80,7 @@ inline TLiquidazione_app& app()
{ return (TLiquidazione_app&)main_app(); } { return (TLiquidazione_app&)main_app(); }
TLiquidazione_app::TLiquidazione_app(int m) : TLiquidazione_app::TLiquidazione_app(int m) :
_ditte(NULL), _selected(10000), _ditte(NULL), _selected(16),
_year(4), _nomiditte(100), _menu(m), _firm_bookmark(-1) _year(4), _nomiditte(100), _menu(m), _firm_bookmark(-1)
{ {
_isprint = _is_interactive = _canprint = true; _isprint = _is_interactive = _canprint = true;
@ -517,7 +517,8 @@ bool TLiquidazione_app::set_print(int)
{ {
if (_selected.ones() > 0l) if (_selected.ones() > 0l)
return recalc_all() && _isprint; return recalc_all() && _isprint;
else warning_box(TR("Nessuna ditta selezionata!")); else
warning_box(TR("Nessuna ditta selezionata!"));
} }
break; break;
case 2: // estrazione deleghe case 2: // estrazione deleghe
@ -558,7 +559,8 @@ bool TLiquidazione_app::set_print(int)
long TLiquidazione_app::select_firm_range(long from, long to, wht freq) long TLiquidazione_app::select_firm_range(long from, long to, wht freq)
{ {
if (to == 0l) to = 99999L; if (to < from)
to = 99999L;
for (int i = 0; i < _ditte->items(); i++) for (int i = 0; i < _ditte->items(); i++)
{ {
@ -591,9 +593,8 @@ long TLiquidazione_app::select_firm_range(long from, long to, wht freq)
bool TLiquidazione_app::ch_year_handler(TMask_field& f, KEY key) bool TLiquidazione_app::ch_year_handler(TMask_field& f, KEY key)
{ {
if (key == K_TAB && f.focusdirty()) if (key == K_TAB && f.focusdirty())
{ {
TWait_cursor hourglass;
TWait_cursor hourglass;
app().reset_choices(f.mask()); app().reset_choices(f.mask());
app().set_year(f.get()); app().set_year(f.get());
app().build_nomiditte(); app().build_nomiditte();
@ -711,13 +712,14 @@ bool TLiquidazione_app::what_freq_handler(TMask_field& f, KEY key)
{ {
if (month > 3) if (month > 3)
while (!is_trim(month)) month--; while (!is_trim(month)) month--;
else month = 3; else
month = 3;
f.mask().set(CG43_LST_TRIM,month); f.mask().set(CG43_LST_TRIM,month);
} }
app().set_month(month); app().set_month(month);
app().reset_choices(f.mask());
app().build_ditte_sheet((wht)atoi(f.get())); app().build_ditte_sheet((wht)atoi(f.get()));
app().reset_choices(f.mask());
} }
return TRUE; return TRUE;
} }
@ -794,29 +796,32 @@ bool TLiquidazione_app::chk_final_handler(TMask_field& f, KEY key)
void TLiquidazione_app::reset_choices(TMask& m) void TLiquidazione_app::reset_choices(TMask& m)
{ {
_selected.reset(); _selected.reset();
_ditte->check(-1, FALSE);
if (m.source_file() == "cg4300a.msk") if (m.source_file() == "cg4300a.msk")
{ {
m.reset(CG43_FLD_SELECTED); const long ditta = get_firm();
m.reset(CG43_FLD_DFR); m.set(CG43_FLD_DFR, ditta, 0x2);
m.reset(CG43_FLD_DTO); m.set(CG43_FLD_DTO, ditta, 0x2);
const wht freq = (wht)m.get_int(CG43_RDB_VERS);
select_firm_range(ditta, ditta, freq);
set_choice_limits(m);
} }
_ditte->check(-1, FALSE);
} }
void TLiquidazione_app::set_choice_limits(TMask& m) void TLiquidazione_app::set_choice_limits(TMask& m)
{ {
long first = -1l, last = -1l; long first = 0, last = 0;
for (int i = 0; i < _ditte->items(); i++) for (int i = 0; i < _ditte->items(); i++)
{ {
if (_selected[i]) if (_selected[i])
{ {
const long dit = _ditte->row(i).get_long(1); const long dit = _ditte->row(i).get_long(1);
if (first == -1l) first = dit; if (first <= 0) first = dit;
if (last < dit) last = dit; if (last < dit) last = dit;
} }
} }
if (first != -1) m.set(CG43_FLD_DFR, first); m.set(CG43_FLD_DFR, first, 0x2);
if (last != -1) m.set(CG43_FLD_DTO, last); m.set(CG43_FLD_DTO, last, 0x2);
m.set(CG43_FLD_SELECTED, _selected.ones()); m.set(CG43_FLD_SELECTED, _selected.ones());
} }
@ -867,10 +872,8 @@ bool TLiquidazione_app::set_liquidazione()
m.set_handler(CG43_BUT_SEL, select_button); m.set_handler(CG43_BUT_SEL, select_button);
m.set_handler(CG43_BUT_ANN, reset_button); m.set_handler(CG43_BUT_ANN, reset_button);
m.set_handler(CG43_CHK_FINAL, chk_final_handler); m.set_handler(CG43_CHK_FINAL, chk_final_handler);
m.set(CG43_FLD_SELECTED, _selected.ones());
m.set(CG43_FLD_ANNO, _year); m.set(CG43_FLD_ANNO, _year);
set_choice_limits(m);
// stampa abilitata per default // stampa abilitata per default
m.set(CG43_CHK_STAMPA,"X"); m.set(CG43_CHK_STAMPA,"X");

29
cg/cg4300.h
View File

@ -177,10 +177,8 @@ public:
TDate _d0; TDate _d0;
real _diff_ven_ap, _diff_ven_ap_iva, _diff_acq_ap, _diff_acq_ap_iva; real _diff_ven_ap, _diff_ven_ap_iva, _diff_acq_ap, _diff_acq_ap_iva;
_DescrItem(word f) : _f0(0), _f1(0), _f2(0) _DescrItem(word f) : _flags(f), _f0(0), _f1(0), _f2(0) { }
{ _flags = f; } virtual ~_DescrItem() { }
virtual ~_DescrItem()
{ }
}; };
class _ErrItem : public TObject class _ErrItem : public TObject
@ -189,8 +187,7 @@ class _ErrItem : public TObject
public: public:
TString _err; TString _err;
TString _att; TString8 _att, _firm;
TString _firm;
_ErrItem(const char* err, const char* att, const char* firm) _ErrItem(const char* err, const char* att, const char* firm)
{ _err = err; _att = att; _firm = firm; } { _err = err; _att = att; _firm = firm; }
virtual ~_ErrItem() {} virtual ~_ErrItem() {}
@ -245,7 +242,7 @@ class TLiquidazione_app : public TPrint_application
wht _what; wht _what;
TBit_array _selected; TBit_array _selected;
int _menu; // 1 = Liquidazione, 2 = Deleghe, 3 = Acconti int _menu; // 1 = Liquidazione, 2 = Deleghe, 3 = Acconti
TString16 _year; // anno di calcolo TString4 _year; // anno di calcolo
int _month; // mese da calcolare int _month; // mese da calcolare
TDate _date; // data di stampa TDate _date; // data di stampa
bool _isprint; // vuoi stampare o no? bool _isprint; // vuoi stampare o no?
@ -281,7 +278,7 @@ class TLiquidazione_app : public TPrint_application
bool _riepilogo; // stampa riepilogo sul registro bool _riepilogo; // stampa riepilogo sul registro
bool _sind11; // somma imposte non detraibili in trasferimento IVA11 (da configurazione dati studio) bool _sind11; // somma imposte non detraibili in trasferimento IVA11 (da configurazione dati studio)
tbc _basecalc; // tipo base di calcolo acconto tbc _basecalc; // tipo base di calcolo acconto
TString16 _freqviva; // frequenza versamenti (M|T) TString4 _freqviva; // frequenza versamenti (M|T)
long _n_ditte; // numero ditte long _n_ditte; // numero ditte
bool _comp_acconto; // stiamo calcolando l'acconto bool _comp_acconto; // stiamo calcolando l'acconto
TArray _nomiditte; // array descr. ditte per sheet TArray _nomiditte; // array descr. ditte per sheet
@ -450,7 +447,11 @@ protected:
static bool chk_final_handler(TMask_field& f, KEY key); static bool chk_final_handler(TMask_field& f, KEY key);
static TLiquidazione_app& app() { return (TLiquidazione_app&)main_app(); } static TLiquidazione_app& app() { return (TLiquidazione_app&)main_app(); }
bool print_diff_log(int& rw);
bool residuo_da_liquidare(long numreg, int numrig, const TDate& last_pag,
real& importo_res, real& imponibile_res, real& imposta_res) const;
bool print_inc_diff_log(int& rw, int tipoatt);
bool print_dainc_diff_log(int& rw, int tipoatt);
public: public:
@ -509,17 +510,15 @@ public:
// Ritorna il valore dell'iva da riportare (solitamente 50500) // Ritorna il valore dell'iva da riportare (solitamente 50500)
real iva_da_riportare(int month); real iva_da_riportare(int month);
// Funzione personale di arrotondamento alle 1000 LIRE o all'euro. // Funzione personale di arrotondamento all'euro.
// Risolve il seguente problema: da 0 a 500 lire arrotonda alle mille inferiori
// da 501 a 999 arrotonda alle mille superiori.
void round_imposta(real& d) const; void round_imposta(real& d) const;
// Funzione personale di arrotondamento alla lira o centesimo di euro. // Funzione personale di arrotondamento alla lira o centesimo di euro.
void round_alla_lira(real& d, bool superiore = FALSE); void round_al_centesimo(real& d) const;
// supporto stampa // supporto stampa
void describe_firm(int month); void describe_firm(int month);
void describe_att(int month, const char* codatt, bool isresult, char flags); void describe_att(int month, const char* codatt, bool isresult, char flags);
void describe_name(int month, TToken_string& atts, char flags); void describe_name(int month, const TToken_string& atts, char flags);
void describe_plafond(int month, const char* codatt); void describe_plafond(int month, const char* codatt);
void describe_ventilation(int month, const char* codatt); void describe_ventilation(int month, const char* codatt);
void describe_agricolo(int month, const char* codatt); void describe_agricolo(int month, const char* codatt);
@ -584,7 +583,7 @@ public:
void set_att(_DescrItem& d); void set_att(_DescrItem& d);
void set_pim(_DescrItem& d); void set_pim(_DescrItem& d);
void set_pumpam(_DescrItem& d); void set_pumpam(_DescrItem& d);
void set_plm_diff(_DescrItem& d); void set_plm_diff(const _DescrItem& d);
void set_plm(_DescrItem& d); void set_plm(_DescrItem& d);
bool set_annual(_DescrItem& d); bool set_annual(_DescrItem& d);
void set_grand(_DescrItem& d); void set_grand(_DescrItem& d);

704
cg/cg4301.cpp
View File

@ -7,6 +7,7 @@
#include <config.h> #include <config.h>
#include <modaut.h> #include <modaut.h>
#include <recarray.h> #include <recarray.h>
#include <recset.h>
#include <progind.h> #include <progind.h>
#include <sheet.h> #include <sheet.h>
@ -157,7 +158,7 @@ bool TLiquidazione_app::update_firm(int month, bool recalc)
// Ritorna FALSE soltanto se il ricalcolo era necessario e non e' // Ritorna FALSE soltanto se il ricalcolo era necessario e non e'
// stato effettuato per scelta dello stronzo commercialista. // stato effettuato per scelta dello stronzo commercialista.
TConfig c(CONFIG_DITTA); TConfig c(CONFIG_DITTA, "cg");
_isdiff = c.get_bool("GesLiqDiff"); _isdiff = c.get_bool("GesLiqDiff");
if (_isdiff) if (_isdiff)
@ -170,7 +171,6 @@ bool TLiquidazione_app::update_firm(int month, bool recalc)
if (month == 13 && recalc) if (month == 13 && recalc)
{ {
TTable pem("PEM"); TTable pem("PEM");
for (int reg = 0; reg < 23; reg++) for (int reg = 0; reg < 23; reg++)
{ {
look_pem(pem, reg); look_pem(pem, reg);
@ -194,25 +194,23 @@ bool TLiquidazione_app::update_firm(int month, bool recalc)
_monthinatt = 1; _monthinatt = 1;
const TDate inatt = _nditte->curr().get("DINIZIOATT"); const TDate inatt = _nditte->curr().get("DINIZIOATT");
if (is_in_liq_period(inatt)) if (is_in_liq_period(inatt))
_isdifferita = FALSE; _isdifferita = false;
if (inatt.year() == atoi(_year)) if (inatt.year() == atoi(_year))
_monthinatt = inatt.month(); _monthinatt = inatt.month();
{ _isricacq = (month == 13) && ini_get_bool(CONFIG_STUDIO, "cg", "RicAcq");
TConfig cnf1(CONFIG_STUDIO, "cg");
_isricacq = cnf1.get_bool("RicAcq") && month == 13;
}
// ricalcolo normale // ricalcolo normale
// lim c'e' solo per i trimestri // lim c'e' solo per i trimestri
bool ok = _lim->get_bool("B0"); bool ok = _lim->get_bool("B0");
if (ok && !recalc) return TRUE; if (ok && !recalc)
return true;
if (_recalc_regis) if (_recalc_regis)
ok = FALSE; // Se sta ricalcolando i PRM/PRP se ne sbatte delle LIM ok = false; // Se sta ricalcolando i PRM/PRP se ne sbatte delle LIM
bool calc = (_recalc == ever || (_recalc == one && is_month_ok(month,_month))); bool calc = (_recalc == ever || (_recalc == one && is_month_ok(month,_month)));
if (!calc && _recalc != never) calc = !ok; if (!calc && _recalc != never) calc = !ok;
bool gheravergot = FALSE; bool gheravergot = false;
bool quater = FALSE; bool quater = false;
TToken_string atts; TToken_string atts;
TToken_string cattivs; TToken_string cattivs;
@ -232,9 +230,8 @@ bool TLiquidazione_app::update_firm(int month, bool recalc)
quater = _nditte->curr().get_bool("FLIVA11Q"); quater = _nditte->curr().get_bool("FLIVA11Q");
// attivita' mista: ce ne sono in realta' due // attivita' mista: ce ne sono in realta' due
// viene calcolato nel ciclo su tipoatt (che viene ripetuto solo // viene calcolato nel ciclo su tipoatt (che viene ripetuto solo se diventa TRUE);
// se diventa TRUE); _mixed = false;
_mixed = FALSE;
buf.format( _printonly ? FR("Stampa liquidazione (%d)...\n%s: %s\n") : buf.format( _printonly ? FR("Stampa liquidazione (%d)...\n%s: %s\n") :
FR("Calcolo liquidazione (%d)...\n%s: %s\n"), FR("Calcolo liquidazione (%d)...\n%s: %s\n"),
@ -258,18 +255,19 @@ bool TLiquidazione_app::update_firm(int month, bool recalc)
for (int tipoatt = 1; tipoatt <= (_mixed ? 2 : 1); tipoatt++) for (int tipoatt = 1; tipoatt <= (_mixed ? 2 : 1); tipoatt++)
{ {
TString8 cattiv(codatt); bool waspla; bool waspla = false;
TString8 cattiv(codatt);
cattiv << tipoatt; cattiv << tipoatt;
if (tipoatt == 1 && (waspla = look_pla(cattiv, FALSE))) if (tipoatt == 1 && (waspla = look_pla(cattiv, false)))
{ {
_p8 = _pla->get_real("R5"); _p8 = _pla->get_real("R5");
_p8b = _pla->get_real("R6"); _p8b = _pla->get_real("R6");
_p9 = _pla->get_real("R7"); _p9 = _pla->get_real("R7");
_isplafond = !(_p8.is_zero() && _p8b.is_zero() && _isplafond = !(_p8.is_zero() && _p8b.is_zero() && _p9.is_zero());
_p9.is_zero()); const char s7 = _pla->get_char("S7");
_isservizio = _pla->get("S7") == "S"; _isservizio = (s7 == 'S');
_mixed = _pla->get("S7") == "M" || _pla->get("S7") == "E"; _mixed = (s7 == 'M') || (s7 == 'E');
const TString4 yr(_year); const TString4 yr(_year);
TAssoc_array& pa = _prorata.perc_array(); TAssoc_array& pa = _prorata.perc_array();
@ -281,12 +279,12 @@ bool TLiquidazione_app::update_firm(int month, bool recalc)
for (int i = atoi(_year); i>=anno; i--) for (int i = atoi(_year); i>=anno; i--)
{ {
_year = format("%d", i); _year.format("%d", i);
if (look_pla(cattiv, FALSE)) // Reperisce percentuale prorata anno indicato (se esiste la tabella) if (look_pla(cattiv, FALSE)) // Reperisce percentuale prorata anno indicato (se esiste la tabella)
pa.add(_year, _pla->get_real("R8")); pa.add(_year, _pla->get_real("R8"));
} }
_year = yr; // Risetta l'anno corretto e riposiziona la tabella... _year = yr; // Risetta l'anno corretto e riposiziona la tabella...
look_pla(cattiv, FALSE); look_pla(cattiv, false);
} }
else else
_isservizio = _nditte->curr(LF_ATTIV).get("TIPOATT") == "S"; _isservizio = _nditte->curr(LF_ATTIV).get("TIPOATT") == "S";
@ -294,7 +292,7 @@ bool TLiquidazione_app::update_firm(int month, bool recalc)
_isviaggio = _nditte->curr(LF_ATTIV).get_bool("REG74TER"); _isviaggio = _nditte->curr(LF_ATTIV).get_bool("REG74TER");
_isagricolo = _nditte->curr(LF_ATTIV).get_bool("REGAGR"); _isagricolo = _nditte->curr(LF_ATTIV).get_bool("REGAGR");
_isagr98 = _isagricolo && atoi(_year) >= 1998; _isagr98 = _isagricolo && atoi(_year) >= 1998;
_isvent = FALSE; _isvent = false;
if (!_recalc_regis && tipoatt == 1 && waspla && month == 13) if (!_recalc_regis && tipoatt == 1 && waspla && month == 13)
{ {
@ -349,13 +347,11 @@ bool TLiquidazione_app::update_firm(int month, bool recalc)
if (!gheravergot) if (!gheravergot)
{ {
look_plm(month,cattiv); look_plm(month,cattiv);
gheravergot = !_plm->get_real("R0").is_zero() || gheravergot = !_plm->get_real("R0").is_zero() || !_plm->get_real("R1").is_zero();
!_plm->get_real("R1").is_zero();
} }
if (month == _month && riepliq) if (month == _month && riepliq)
describe_att(month, cattiv, gheravergot, describe_att(month, cattiv, gheravergot, '0' + (_mixed ? tipoatt : 0));
'0' + (_mixed ? tipoatt : 0));
atts.add(cattiv); atts.add(cattiv);
cattivs.add(cattiv); cattivs.add(cattiv);
@ -364,7 +360,7 @@ bool TLiquidazione_app::update_firm(int month, bool recalc)
if (_recalc_regis) if (_recalc_regis)
continue; continue;
// se attivita' mista stampa riepilogo // se attività mista stampa riepilogo
if (_mixed && month == _month && riepliq) if (_mixed && month == _month && riepliq)
describe_att(month,cattivs, TRUE, 'M'); describe_att(month,cattivs, TRUE, 'M');
@ -379,7 +375,7 @@ bool TLiquidazione_app::update_firm(int month, bool recalc)
{ {
_nditte->restore_status(); _nditte->restore_status();
// Se trattasi di ricalcolo per registri, setta il flag relativo, onde evitare ricalcoli // Se trattasi di ricalcolo per registri, setta il flag relativo, onde evitare ricalcoli
// nel caso di registro riepilogativo: se i PRM esistono gia' (perche' creati // nel caso di registro riepilogativo: se i PRM esistono già (perchè creati
// da stampa bollato precedente o altro riepilogo) non vanno ricalcolati. // da stampa bollato precedente o altro riepilogo) non vanno ricalcolati.
look_lim(month, TRUE); // Crea se non esiste look_lim(month, TRUE); // Crea se non esiste
_lim->put("B1","X"); _lim->put("B1","X");
@ -447,21 +443,22 @@ bool TLiquidazione_app::update_firm(int month, bool recalc)
return ok || calc; return ok || calc;
} }
bool TLiquidazione_app::update_att(int month, const char* codatt, bool TLiquidazione_app::update_att(int month, const char* codatt, bool recalc)
bool recalc)
// viene passato un codice attivita' con codatt+tipoatt // viene passato un codice attivita' con codatt+tipoatt
// vedi update_firm per il burdel dei calc e recalc // vedi update_firm per il burdel dei calc e recalc
// occhecasino. Se _comp_acconto e' TRUE, i movimenti considerati // occhecasino. Se _comp_acconto e' TRUE, i movimenti considerati
// saranno solo quelli di dicembre per data <= 20/12; // saranno solo quelli di dicembre per data <= 20/12;
// il ricalcolo e' FORZATO da _recalc messo a one // il ricalcolo e' FORZATO da _recalc messo a one
{ {
look_plm(month, codatt, TRUE); look_plm(month, codatt, true);
bool ok = _plm->get_bool("B0"); bool ok = _plm->get_bool("B0");
if (_recalc_regis) if (_recalc_regis)
ok = FALSE; // Se sta ricalcolando i PRM/PRP se ne sbatte dei PLM ok = FALSE; // Se sta ricalcolando i PRM/PRP se ne sbatte dei PLM
if (ok && !recalc) return TRUE; if (ok && !recalc)
return true;
bool calc = _recalc == ever || (_recalc == one && is_month_ok(month,_month)); bool calc = _recalc == ever || (_recalc == one && is_month_ok(month,_month));
if (!calc && _recalc != never) calc = !ok; if (!calc && _recalc != never)
calc = !ok;
if (calc || !recalc) if (calc || !recalc)
{ {
@ -566,6 +563,92 @@ void TLiquidazione_app::zero_att(int month, const char* codatt)
zero_plafond(month,codatt); zero_plafond(month,codatt);
} }
// Fattura più vecchia di un anno a ente NON pubblico
static bool sarebbe_da_pagare(const TRectype& mov, const TDate& fine)
{
const TDate datareg = mov.get(MOV_DATAREG);
const long giorni = fine - datareg;
if (giorni <= 365)
return false; // E' passato meno di un anno
const TDate datainc = mov.get(MOV_DATAINC);
if (datainc.ok() && datainc <= fine)
return false; // Già pagata senza saldaconto
TString8 key; key.format("%c|%ld", mov.get_char(MOV_TIPO), mov.get_long(MOV_CODCF));
const TRectype& clifo = cache().get(LF_CLIFO, key);
return clifo.get_int(CLI_ALLEG) != 7; // Non è un ente pubblico
}
bool TLiquidazione_app::residuo_da_liquidare(long numreg, int numrig, const TDate& last_pag,
real& importo_res, real& imponib_res, real& imposta_res) const
{
CHECKD(numreg > 0 && numrig > 0, "Numero registrazione non valido ", numreg);
bool found = false;
if (!found)
{
TString query;
query << "USE " << LF_IVADIFF
<< "\nFROM NUMREG=" << numreg << " NUMRIG=" << numrig
<< "\nTO NUMREG=" << numreg << " NUMRIG=" << numrig;
TISAM_recordset id(query);
found = id.items() >= 2; // riga fattura ed almeno un pagamento o nota di credito
if (found)
{
TImporto importo, imponib, imposta;
for (bool ok = id.move_first(); ok; ok = id.move_next())
{
const char sez = id.get("SEZIONE").as_string()[0];
const int tipomov = id.get(PART_TIPOMOV).as_int();
if ((tipomov == 1 || tipomov == 2) || !last_pag.ok())
{
importo += TImporto(sez, id.get(PAGSCA_IMPORTO).as_real());
imponib += TImporto(sez, id.get(RMI_IMPONIBILE).as_real());
imposta += TImporto(sez, id.get(RMI_IMPOSTA).as_real());
}
else
{
const TDate data_pag = id.get("DATAREGP").as_date();
if (data_pag >= last_pag)
continue;
const TImporto vers(sez, id.get("VERSATA").as_real());
if (!vers.is_zero())
{
importo += TImporto(sez, id.get(PAGSCA_IMPORTO).as_real());
imponib += TImporto(sez, id.get(RMI_IMPONIBILE).as_real());
imposta += vers;
}
}
}
if (importo.valore() > ZERO)
{
importo_res = importo.valore();
imponib_res = imponib.valore();
imposta_res = imposta.valore();
}
}
}
if (!found)
{
TLocalisamfile rmi(LF_RMOVIVA);
rmi.put(RMI_NUMREG, numreg);
rmi.put(RMI_NUMRIG, numrig);
found = rmi.read() == NOERR;
if (found)
{
imposta_res = rmi.get_real(RMI_IMPOSTA);
imponib_res = rmi.get_real(RMI_IMPONIBILE);
importo_res = imponib_res + imposta_res;
}
}
return found;
}
void TLiquidazione_app::recalc_att(int month, const char* codatt) void TLiquidazione_app::recalc_att(int month, const char* codatt)
// il codatt passato e' codice att + tipo att ( IN {1|2} ) // il codatt passato e' codice att + tipo att ( IN {1|2} )
// occhecasino. Se _comp_acconto e' TRUE, i movimenti considerati // occhecasino. Se _comp_acconto e' TRUE, i movimenti considerati
@ -777,34 +860,33 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
filter << format("||((ANSI(DATA74TER)>=%ld)&&(ANSI(DATA74TER)<=%ld))", f74.date2ansi(), t.date2ansi()); filter << format("||((ANSI(DATA74TER)>=%ld)&&(ANSI(DATA74TER)<=%ld))", f74.date2ansi(), t.date2ansi());
if (_isdiff) if (_isdiff)
filter << "|| NUM(LIQDIFF==\"X\")"; filter << "|| NUM(LIQDIFF==\"X\")";
// format( ||((ANSI(DATAINC)>=%ld)&&(ANSI(DATAINC)<=%ld))", fromdate.date2ansi(), t.date2ansi());
} }
_cur->setfilter(filter); _cur->setfilter(filter);
const long items = _cur->items(); const long items = _cur->items();
_cur->freeze(); _cur->freeze();
*_cur = 0; *_cur = 0;
TString16 trueatt(codatt); TString16 trueatt(codatt);
const int tipatt = atoi(trueatt.sub(5)); const int tipatt = trueatt[5] - '0';
trueatt.cut(5); trueatt.cut(5);
TString pimsg; pimsg << TR("Ricalcolo attività ") << trueatt << " (" << month << ')'; TString pimsg; pimsg << TR("Ricalcolo attività ") << trueatt << " (mese " << month << ')';
TProgind pi(items, pimsg, false, true); TProgind pi(items, pimsg, false, true);
for (; _cur->pos() < items; ++(*_cur)) for (; _cur->pos() < items; ++(*_cur))
{ {
if (!pi.setstatus(_cur->pos())) if (!pi.setstatus(_cur->pos()))
break; break;
TDate date(_mov->get(MOV_DATAREG)); TDate date = _mov->get(MOV_DATAREG);
const int liqmonth = _mov->get_int(MOV_MESELIQ); const int liqmonth = _mov->get_int(MOV_MESELIQ);
const TString4 reg = _mov->get("REG"); const TString4 reg = _mov->get("REG");
const bool isreg = look_reg(_mov->get("REG")); const bool isreg = look_reg(reg);
const TString4 tipodoc = _mov->get(MOV_TIPODOC); const TString4 tipodoc = _mov->get(MOV_TIPODOC);
const bool corrisp = _reg->get_bool("B0"); const bool corrisp = _reg->get_bool("B0");
const tiporeg tipomov = (tiporeg)_reg->get_int("I0"); const tiporeg tipomov = (tiporeg)_reg->get_int("I0");
// Controlla se la data del documento si riferisce all'anno precedente (PRORATA 1998) // Controlla se la data del documento si riferisce all'anno precedente (PRORATA 1998)
TDate datedoc(_mov->get(MOV_DATADOC)); const TDate datedoc(_mov->get(MOV_DATADOC));
if (_isviaggio) if (_isviaggio)
{ {
@ -814,90 +896,85 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
continue; continue;
} }
const TRectype& rcs = _cur->curr(LF_CAUSALI); const TRectype& rcs = _cur->curr(LF_CAUSALI);
const bool fattrit = rcs.get_bool("RITFATT"); const bool fattrit = rcs.get_bool("RITFATT");
const bool cau_intra = rcs.get_bool("INTRACOM"); const bool cau_intra = rcs.get_bool("INTRACOM");
const bool cau_valintra = rcs.get_bool("VALINTRA"); const bool cau_valintra = rcs.get_bool("VALINTRA");
// Inizio gestione IVA differita // Inizio gestione IVA differita
const bool movdiff = _isdiff && _mov->get_bool(MOV_LIQDIFF); const bool iva_cass = has_module(ICAUT) && _mov->get_bool(MOV_IVAXCASSA);
const bool iva_diff = _isdiff && _mov->get_bool(MOV_LIQDIFF);
// Se c'è data incasso, normalmente vuol dire che: NO saldaconto e pagamento completo const bool movdiff = iva_diff || iva_cass;
TDate datainc = _mov->get_date(MOV_DATAINC);
if (movdiff && !datainc.ok())
{
const long codcf = _mov->get_long(MOV_CODCF);
TString8 key(_mov->get(MOV_TIPO)); key << "|" << codcf;
const TRectype & clifo = cache().get(LF_CLIFO, key);
// se non e' un ente pubblico forzo data incasso un anno dopo il documento
if (clifo.get_int(CLI_ALLEG) < 7)
{
datainc = _mov->get_date(MOV_DATADOC);
if (datainc.ok())
datainc.addyear();
}
}
// datainc_ok significa che la data incasso è compresa nel periodo di liquidazione in corso di calcolo
bool datainc_ok = is_date_ok(datainc, month, liqmonth, year_int);
const bool diffpayed = movdiff && datainc_ok;
const bool difftopay = movdiff && !diffpayed;
// Se ho fatto un pagamento differito porto la data di registrazione alla data incasso
if (diffpayed)
date = datainc;
real totfat, pagatt, ncatt;
bool dok = is_date_ok(date, month, liqmonth, year_int); bool dok = is_date_ok(date, month, liqmonth, year_int);
TPartite_array arrpart; // Partite interessate TPartite_array arrpart; // Partite interessate
TPointer_array pagscatt; // Righe di pagsca interessate TPointer_array pagscatt; // Righe di pagsca interessate
const long numreg = _mov->get_long(MOV_NUMREG); if (movdiff)
// In presenza di saldaconto determino meglio la data incasso in base alle righe di pagamento
if (has_sc && movdiff && (!datainc.ok() || datainc > inizio))
{ {
//arrpart.add_numreg(numreg); // Sezione preferita per fatture decisa in base a vendita->'A' o acquisto->'D'
//if (arrpart.utilizzata(numreg, 1)) const char sezfat = tipomov == vendita ? 'D' : 'A';
if (arrpart.add_numreg(numreg)) // Ovviamente più efficiente di quanto sopra const char sezpag = tipomov == vendita ? 'A' : 'D';
const long numreg = _mov->get_long(MOV_NUMREG);
TDate datainc;
real tot_incassato, tot_da_incassare;
int flag_pg_nc = 0; // Ci sono pagamenti (0x1) e/o note di credito(0x2) ?
bool game_found = false;
if (has_sc)
{
arrpart.add_numreg(numreg);
const TPartita* p = arrpart.first();
const int row = p ? p->mov2rig(numreg, 0) : 0;
game_found = row > 0;
if (game_found)
{
const TRiga_partite& rp = p->riga(row);
TImporto pg, nc;
flag_pg_nc = rp.calcola_pagato_periodo(inizio+1L, fine, pg, nc, &pagscatt);
if (!p->chiusa() && sarebbe_da_pagare(_mov->curr(), fine))
{
rp.calcola_pagato_periodo(TDate(1,1,date.year()), fine, pg, nc, NULL);
TImporto saldo = rp.importo(false);
saldo += pg; saldo += nc;
saldo.normalize(sezfat);
if (saldo.valore() > ZERO)
tot_da_incassare = saldo.valore();
}
}
}
if (!game_found) // No saldaconto o partita assente
{
datainc = _mov->get(MOV_DATAINC);
if (datainc.ok() && datainc <= fine)
tot_incassato = _mov->get_real(MOV_TOTDOC);
else
{
// Fattura più vecchia di un anno a ente NON pubblico
if (sarebbe_da_pagare(_mov->curr(), fine))
tot_da_incassare = _mov->get_real(MOV_TOTDOC);
}
}
// Simulo incasso se necessario
if (!tot_da_incassare.is_zero()) // già controllato se sarebbe_da_pagare(_mov->curr(), fine)
{ {
// Sezione preferita per fatture decisa in base a vendita->'A' o acquisto->'D' tot_incassato = tot_da_incassare;
const char sezfat = tipomov == vendita ? 'D' : 'A'; datainc = fine;
const char sezpag = tipomov == vendita ? 'A' : 'D'; _mov->put(MOV_DATAINC, datainc);
for (TPartita * p = arrpart.first(); p != NULL; p = arrpart.next())
{
const int row = p->mov2rig(numreg, 0);
if (row > 0)
{
const TRiga_partite& rp = p->riga(row);
TImporto pg, nc;
TDate lastpg, lastnc;
const int flag = rp.calcola_pagato_periodo(inizio+1L, fine, pg, nc, &pagscatt);
if (flag)
{
TImporto importo = rp.importo(false, 0x1);
importo.normalize(sezfat);
totfat = importo.valore();
CHECK(totfat >= ZERO, "Fattura negativa inattesa qui");
if (flag & 1)
{
pg.normalize(sezpag);
pagatt += pg.valore();
}
if (flag & 2)
{
nc.normalize(sezpag);
ncatt += nc.valore();
}
}
}
}
if ((diffpayed && dok) || (pagatt > totfat))
pagatt = totfat;
if (pagatt > ZERO)
dok = true;
} }
if (tot_incassato > ZERO && is_date_ok(datainc, month, liqmonth, year_int))
{
flag_pg_nc = 0x1;
TRectype* pagsca = new TRectype(LF_PAGSCA);
pagsca->put(PAGSCA_TIPOC, _mov->get(MOV_TIPO));
pagsca->put(PAGSCA_SOTTOCONTO, _mov->get(MOV_CODCF));
pagsca->put(PAGSCA_ANNO, year_int);
pagsca->put(PAGSCA_NRIGA, 1);
pagsca->put(PAGSCA_NRATA, 1);
pagsca->put(PAGSCA_NRIGP, 9999);
pagsca->put(PAGSCA_IMPORTO, tot_incassato);
pagscatt.add(pagsca);
}
if (flag_pg_nc)
dok = true;
} }
/* /*
* check register present, rmoviva present and date OK * check register present, rmoviva present and date OK
@ -908,9 +985,9 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
* la lettura dei movimenti. * la lettura dei movimenti.
*/ */
const bool sreg = !isreg; const bool sreg = !isreg;
const bool rs8 = _reg->get("S8") != trueatt; const bool rs8 = _reg->get("S8") != trueatt;
const bool cmt = !_cur->is_first_match(LF_RMOVIVA); const bool cmt = !_cur->is_first_match(LF_RMOVIVA);
if (!dok || sreg || rs8 || cmt) if (!dok || sreg || rs8 || cmt)
continue; continue;
@ -923,13 +1000,12 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
* Da oggi vengono sommati nei real di S2 in pim * Da oggi vengono sommati nei real di S2 in pim
* assieme alle FS per stampa registri * assieme alle FS per stampa registri
*/ */
bool noninc = (tipodoc == "SN" || tipodoc == "CN" || tipodoc == "RN" || const bool noninc = (tipodoc == "SN" || tipodoc == "CN" || tipodoc == "RN" || tipodoc == "IN" || tipodoc == "PG");
tipodoc == "IN" || tipodoc == "PG");
/* /*
* check date: se si calcola l'acconto, solo da 1/12 a 20/12 * check date: se si calcola l'acconto, solo da 1/12 a 20/12
*/ */
int accmonth = _isdifferita ? 11 : 12; const int accmonth = _isdifferita ? 11 : 12;
/* /*
* Patrizia: se e' differita i mov. vanno da 1/11 a 30/11 * Patrizia: se e' differita i mov. vanno da 1/11 a 30/11
@ -942,15 +1018,11 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
if (!_isdifferita && date.day() > 20) if (!_isdifferita && date.day() > 20)
continue; continue;
// Ciclo sulle righe iva del movimento
do do
{ {
int tipoatt = _rmoviva->get_int(RMI_TIPOATT); const int rmi_tipoatt = max(_rmoviva->get_int(RMI_TIPOATT), 1); // Poteva capitare tipoatt == 0
/* if (rmi_tipoatt != tipatt)
* puo' capitare per motivi brutalmente prassici
* SENSU Sergio 1995, Guido
*/
if (tipoatt == 0) tipoatt = 1;
if (tipoatt != tipatt)
continue; continue;
// totali parziali registrati nei pim per motivi ignoti // totali parziali registrati nei pim per motivi ignoti
@ -1007,183 +1079,155 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
real impon_det; // Imponibile detraibile real impon_det; // Imponibile detraibile
real impos_det; // Imposta detraibile real impos_det; // Imposta detraibile
if (pagatt > ZERO || ncatt > ZERO) if (movdiff)
{ {
// Il totale dei pagamenti chiude la fattura? const char sezfat = tipomov == vendita ? 'D' : 'A';
if (pagatt >= totfat) // Calcolo del cavolo: dovrebbe guardare il saldo fattura, no? const TDate datareg = _mov->get(MOV_DATAREG);
{
TDate from(_mov->get(MOV_DATAREG));
real impprec, ivaprec, ncprec;
if (month < 13)
{
TDate to(inizio);
from.set_day(1); TLocalisamfile id(LF_IVADIFF);
--from; id.put(RMI_NUMREG, _rmoviva->get(RMI_NUMREG));
while (from < to) id.put(RMI_NUMRIG, _rmoviva->get(RMI_NUMRIG));
{ id.put(PART_TIPOMOV, 1);
TDate endp(from); id.put("NUMPRO", 0);
id.put("TIPOATT", rmi_tipoatt);
id.put("ANNOLIQ", datareg.year());
int mesereg = datareg.month();
if (_freqviva == "T")
{
const int resto = mesereg % 3;
if (resto > 0)
mesereg += 3-resto;
}
id.put("MESELIQ", mesereg);
id.put("TIPOIVA", tipomov == 2 ? 2 : 1);
id.put("TIPODIFF", iva_cass ? 2 : 1);
id.put(MOV_DATAREG, _mov->get(MOV_DATADOC));
id.put(RMI_CODIVA, _rmoviva->get(RMI_CODIVA));
id.put("SEZIONE", sezfat);
id.put("IMPORTO", imponibile_orig+imposta_orig);
id.put(RMI_IMPONIBILE, imponibile_orig);
id.put(RMI_IMPOSTA, imposta_orig);
id.write_rewrite();
}
if (_freqviva == "M") if (!pagscatt.empty())
endp.addmonth(); {
else const char sezpag = tipomov == vendita ? 'A' : 'D';
endp.set_month((endp.month() / 3 + 1) * 3); const real totfat = _mov->get(MOV_TOTDOC);
endp.set_end_month();
if (arrpart.utilizzata(numreg, 1))
{
const int items = arrpart.items();
const char sez = (tipomov == vendita ? 'A' : 'D');
TImporto pagtmp;
// Inizio aggiunte di Bonazzi del 16/02/2012
TImporto nctmp;
// Fine aggiunte di Bonazzi del 16/02/2012
for (TPartita* p = arrpart.first(); p != NULL; p = arrpart.next()) TLocalisamfile id(LF_IVADIFF);
{ FOR_EACH_ARRAY_ITEM(pagscatt, r, obj)
const int row = p->mov2rig(numreg, 1); {
if (row > 0) const TRectype& pagsca = *(TRectype*)obj;
{ const int nrigp = pagsca.get_int(PAGSCA_NRIGP);
const TRiga_partite& rp = p->riga(row);
rp.calcola_pagato_periodo(from+1L, endp, pagtmp, nctmp);
}
}
pagtmp.normalize(sez);
if (!pagtmp.is_zero()) id.zero();
{ id.put(RMI_NUMREG, _rmoviva->get(RMI_NUMREG));
const real perc = pagtmp.valore() / totfat; id.put(RMI_NUMRIG, _rmoviva->get(RMI_NUMRIG));
id.put(MOV_DATAREG, _mov->get(MOV_DATADOC));
id.put("NUMPRO", nrigp);
id.put("TIPOATT", rmi_tipoatt);
id.put("TIPOIVA", tipomov == 2 ? 2 : 1);
id.put("TIPODIFF", iva_cass ? 2 : 1);
id.put(RMI_CODIVA, _rmoviva->get(RMI_CODIVA));
real val = imponibile_orig * perc; TImporto pagtmp;
val.round(TCurrency::get_firm_dec()); bool ultimo = false;
impprec += val; if (nrigp > 0 && nrigp < 9999)
val = imposta_orig * perc;
val.round(TCurrency::get_firm_dec());
ivaprec += val;
}
// Inizio aggiunte di Bonazzi del 16/02/2012
if (!nctmp.is_zero())
ncprec += nctmp.valore();
// Fine aggiunte di Bonazzi del 16/02/2012
from = endp;
}
}
}
else
{
if (from.year() != fromdate.year())
{
if (arrpart.utilizzata(numreg, 1))
{
TDate to(31,12, from.year());
const int items = arrpart.items();
const char sez = (tipomov == vendita ? 'A' : 'D');
TImporto pagtmp, nctmp;
for (TPartita * p = arrpart.first(); p != NULL; p = arrpart.next())
{
const int row = p->mov2rig(numreg, 1);
if (row >= 0)
{
const TRiga_partite& rp = p->riga(row);
rp.calcola_pagato_periodo(botime, to, pagtmp, nctmp);
}
}
if (!pagtmp.is_zero())
{
const real perc = pagtmp.valore() / totfat;
real val = imponibile_orig * perc;
val.round(decimals);
impprec = val;
val = imposta_orig * perc;
val.round(decimals);
ivaprec = val;
}
if (!nctmp.is_zero())
ncprec = nctmp.valore();
}
}
}
incdiff_imp = imponibile_orig - impprec;
incdiff_iva = imposta_orig - ivaprec;
ncatt -= ncprec;
const real ncperc = ncatt / totfat;
real val = imponibile_orig * ncperc;
val.round(decimals);
diff_imp = -val;
incdiff_imp -= val;
val = imposta_orig * ncperc;
val.round(decimals);
diff_iva = -val;
incdiff_iva -= val;
}
else
{ // La fattura è ancora aperta
// Calcolo rapporto tra pagamento e totale fattura
const real perc = pagatt / totfat;
incdiff_imp = imponibile_orig * perc;
incdiff_imp.round(decimals);
incdiff_iva = imposta_orig * perc;
incdiff_iva.round(decimals);
if (month == 13)
{
diff_imp = imponibile_orig - incdiff_imp;
diff_iva = imposta_orig - incdiff_iva;
}
/* Guy 08-08-2012: Mi pare una cosa inutile
// Calcolo rapporto tra nota credito e totale fattura
const real ncperc = ncatt / totfat;
real val = imponibile_orig * ncperc;
val.round(TCurrency::get_firm_dec());
diff_imp = -val;
incdiff_imp -= val;
val = imposta_orig * ncperc;
val.round(TCurrency::get_firm_dec());
diff_iva = -val;
incdiff_iva -= val;
*/
if (pagatt > ZERO && !pagscatt.empty())
{ {
TFilename tmp; tmp.tempdir(); const TPartita& p = arrpart.partita(pagsca);
tmp.add("liqdiff.txt"); const TRiga_partite& rp = p.riga(nrigp);
ofstream log(tmp, ios_base::app); id.put(PART_TIPOMOV, rp.tipo());
id.put("NUMREGP", rp.get(PART_NREG));
const TRectype& rec = (TRectype&)pagscatt[pagscatt.last()]; id.put("NUMRIGP", rp.get(PART_NUMRIG));
const TPartita& par = arrpart.partita(rec); id.put("DATAREGP", rp.get(PART_DATAPAG));
const TRiga_partite& sum = par.riga(rec.get_int(PAGSCA_NRIGP)); pagtmp = p.importo_pagsca(pagsca);
if (p.chiusa() && rp.tipo() >= 3)
log << codiva << '\t' << pagatt.string() << '\t' {
<< incdiff_imp.string() << '\t' << incdiff_iva.string() << '\t' ultimo = true;
<< sum.get(PART_NREG) << '\t' << sum.get_date(PART_DATAPAG) << '\t' for (int r = p.last(); r > nrigp; r = p.pred(r))
<< numreg << '\t' << date.string() << endl; {
if (p.riga(r).tipo() >= tm_pagamento)
{
ultimo = false;
break;
}
}
}
} }
} else
{
// Falso record generato da datainc
id.put(PART_TIPOMOV, 3);
id.put("NUMREGP", _mov->get(MOV_NUMREG));
id.put("NUMRIGP", nrigp);
id.put("DATAREGP", _mov->get(MOV_DATAINC));
pagtmp.set(sezpag, pagsca.get_real(PAGSCA_IMPORTO));
ultimo = true;
}
id.put("ANNOLIQ", year_int);
int meseliq = id.get_date("DATAREGP").month();
if (_freqviva == "T")
{
const int resto = meseliq % 3;
if (resto > 0)
meseliq += 3-resto;
}
id.put("MESELIQ", meseliq);
id.put("SEZIONE", pagtmp.sezione());
if (ultimo)
{
real importo, imponibile, imposta;
residuo_da_liquidare(id.get_long(RMI_NUMREG), id.get_int(RMI_NUMRIG), id.get_date("DATAREGP"),
importo, imponibile, imposta);
id.put(PAGSCA_IMPORTO, importo);
id.put(RMI_IMPONIBILE, imponibile);
id.put(RMI_IMPOSTA, imposta);
incdiff_imp += imponibile;
incdiff_iva += imposta;
}
else
{
id.put(PAGSCA_IMPORTO, pagtmp.valore());
pagtmp.normalize(sezpag);
const real perc = pagtmp.valore() / totfat;
real val = imponibile_orig * perc;
round_imposta(val);
id.put(RMI_IMPONIBILE, val);
incdiff_imp += val;
val = imposta_orig * perc;
round_imposta(val);
id.put(RMI_IMPOSTA, val);
incdiff_iva += val;
}
if (_isfinal && id.get_int(PART_TIPOMOV) > 2)
id.put("VERSATA", id.get(RMI_IMPOSTA));
else
id.zero("VERSATA");
id.write_rewrite();
}
diff_imp = imponibile_orig - incdiff_imp;
diff_iva = imposta_orig - incdiff_iva;
} }
else else
{ {
if (difftopay) if (movdiff)
{ {
diff_imp = imponibile_orig; diff_imp = imponibile_orig;
diff_iva = imposta_orig; diff_iva = imposta_orig;
} }
else else
{ analizza_IVA(imponibile_orig, imposta_orig, percind, corrisp, false, codiva,
if (diffpayed) impon_det, impos_det, impon_ind, impos_ind);
{
incdiff_imp = imponibile_orig;
incdiff_iva = imposta_orig;
}
else
analizza_IVA(imponibile_orig, imposta_orig, percind, corrisp, false, codiva,
impon_det, impos_det, impon_ind, impos_ind);
}
} }
// qui
for (int is_detraibile = 0; is_detraibile < 2; is_detraibile++) for (int is_detraibile = 0; is_detraibile < 2; is_detraibile++)
{ {
const int tipodet = is_detraibile ? 0 : tipoind; const int tipodet = is_detraibile ? 0 : tipoind;
@ -1224,8 +1268,8 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
if (tipoiva.empty() && codcf != 0) if (tipoiva.empty() && codcf != 0)
{ {
TString8 key(_mov->get(MOV_TIPO)); key << "|" << codcf; TString8 key; key.format("%c|%ld", _mov->get_char(MOV_TIPO), codcf);
const TRectype & clifo = cache().get(LF_CLIFO, key); const TRectype& clifo = cache().get(LF_CLIFO, key);
int codreg = 0; // codice regione x privati 22 == partite iva 0 == senza codice int codreg = 0; // codice regione x privati 22 == partite iva 0 == senza codice
const int tipoalleg = clifo.get_int(CLI_ALLEG); const int tipoalleg = clifo.get_int(CLI_ALLEG);
@ -1344,19 +1388,19 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
switch (sosp_imp) switch (sosp_imp)
{ {
case normale: case normale:
assp_imp += asimp_imp; assp_imp += asimp_imp;
assp_iva += asimp_iva; assp_iva += asimp_iva;
vssp_imp += vsimp_imp; vssp_imp += vsimp_imp;
vssp_iva += vsimp_iva; vssp_iva += vsimp_iva;
break; break;
case liquidazione: case liquidazione:
assl_imp += asimp_imp; assl_imp += asimp_imp;
assl_iva += asimp_iva; assl_iva += asimp_iva;
vssl_imp += vsimp_imp; vssl_imp += vsimp_imp;
vssl_iva += vsimp_iva; vssl_iva += vsimp_iva;
default: default:
break; break;
} }
} }
else if (fattrit) // Possono essere solo acquisti else if (fattrit) // Possono essere solo acquisti
@ -1765,8 +1809,7 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
if (year_int > 1997 && (yr < (year_int-1) && yr > (year_int-4))) // Prende un intervallo di 2 anni al massimo if (year_int > 1997 && (yr < (year_int-1) && yr > (year_int-4))) // Prende un intervallo di 2 anni al massimo
{ // Quelli relativi all'anno in corso e precedente vanno assieme. { // Quelli relativi all'anno in corso e precedente vanno assieme.
// Se abilitato, somma l'iva acquisti relativi ai documenti memorizzati con anni precedenti // Se abilitato, somma l'iva acquisti relativi ai documenti memorizzati con anni precedenti
TString16 yy; TString4 yy; yy << datedoc.year();
yy << datedoc.year();
const bool is_key = acq_iva_anni_prec.is_key(yy); const bool is_key = acq_iva_anni_prec.is_key(yy);
if (!is_key) if (!is_key)
acq_iva_anni_prec.add(yy, new real, is_key); acq_iva_anni_prec.add(yy, new real, is_key);
@ -1952,18 +1995,18 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
switch (i) switch (i)
{ {
case 1: // Progressivi Iva mensili da periodo Successivo case 1: // Progressivi Iva mensili da periodo Successivo
look_pis(month, codatt, reg, tipocr_s, codiva, tipodet, TRUE); look_pis(month, codatt, reg, tipocr_s, codiva, tipodet, TRUE);
break; break;
case 2: // Progressivi Registri iva Mensili case 2: // Progressivi Registri iva Mensili
look_prm(month, codatt, reg, tipocr_s, codiva, tipodet, TRUE); look_prm(month, codatt, reg, tipocr_s, codiva, tipodet, TRUE);
break; break;
case 3: // Progressivi Registri iva Mensili da periodo Precedente case 3: // Progressivi Registri iva Mensili da periodo Precedente
look_prp(month, codatt, reg, tipocr_s, codiva, tipodet, TRUE); look_prp(month, codatt, reg, tipocr_s, codiva, tipodet, TRUE);
break; break;
default: // Progressivi Iva Mensili normali default: // Progressivi Iva Mensili normali
look_pim(month, codatt, reg, tipocr_s, codiva, tipodet, TRUE); look_pim(month, codatt, reg, tipocr_s, codiva, tipodet, TRUE);
break; break;
} }
TTable *tab = arr[i]; TTable *tab = arr[i];
@ -2022,11 +2065,11 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
if (is_detraibile == 0 && if (is_detraibile == 0 &&
(!diff_imp.is_zero() ||!diff_iva.is_zero() || (!diff_imp.is_zero() ||!diff_iva.is_zero() ||
!incdiff_imp.is_zero() || !incdiff_imp.is_zero())) !incdiff_imp.is_zero() || !incdiff_iva.is_zero()))
{ {
if (tipomov == vendita) if (tipomov == vendita)
{ {
// fatture a liquidazione differita // fatture vendita a liquidazione differita
tab->curr().add("R26", diff_imp); tab->curr().add("R26", diff_imp);
tab->curr().add("R27", diff_iva); tab->curr().add("R27", diff_iva);
tab->curr().add("R28", incdiff_imp); tab->curr().add("R28", incdiff_imp);
@ -2043,7 +2086,7 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
} }
else else
{ {
// fatture a liquidazione differita // fatture acquisto a liquidazione differita
tab->curr().add("R30", diff_imp); tab->curr().add("R30", diff_imp);
tab->curr().add("R31", diff_iva); tab->curr().add("R31", diff_iva);
tab->curr().add("R32", incdiff_imp); tab->curr().add("R32", incdiff_imp);
@ -2088,7 +2131,7 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
real perc = _iva->get_real("R0"); real perc = _iva->get_real("R0");
real new_iva = _pim->get_real("R0") * perc / CENTO; real new_iva = _pim->get_real("R0") * perc / CENTO;
round_alla_lira(new_iva, TRUE); round_al_centesimo(new_iva);
if (new_iva != old_iva) if (new_iva != old_iva)
{ {
@ -2119,7 +2162,7 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
real perc = _iva->get_real("R0"); real perc = _iva->get_real("R0");
real iva = _pia->get_real("R0") * perc / CENTO; real iva = _pia->get_real("R0") * perc / CENTO;
round_alla_lira(iva, TRUE); round_al_centesimo(iva);
agr_detIA += iva; agr_detIA += iva;
_pia->put("R1",iva); _pia->put("R1",iva);
// resetta in modo da non vederlo il mese dopo // resetta in modo da non vederlo il mese dopo
@ -2234,7 +2277,7 @@ void TLiquidazione_app::recalc_att(int month, const char* codatt)
real pdetr = (agr_2i / (agr_1i + agr_2i)); real pdetr = (agr_2i / (agr_1i + agr_2i));
pdetr.round(2); pdetr.round(2);
acquisti_iva += agr_7 * pdetr; acquisti_iva += agr_7 * pdetr;
round_alla_lira(acquisti_iva, true); round_al_centesimo(acquisti_iva);
} }
if (_isagr98) if (_isagr98)
@ -3333,7 +3376,7 @@ void TLiquidazione_app::write_liq(int month, const char* codatts)
{ {
// calcolo credito costo, debito mensile, perc. ripart. // calcolo credito costo, debito mensile, perc. ripart.
perc_r = a_mCEE.is_zero() ? ZERO : (a_mCEE * CENTO)/(a_mCEE + a_meCEE); perc_r.round(2); perc_r = a_mCEE.is_zero() ? ZERO : (a_mCEE * CENTO)/(a_mCEE + a_meCEE); perc_r.round(2);
real ivm = (c_mCEE * perc_r)/CENTO; round_alla_lira(ivm, TRUE); real ivm = (c_mCEE * perc_r)/CENTO; round_al_centesimo(ivm);
real tc = (c_iCEE + ivm); real tc = (c_iCEE + ivm);
real ta = (a_iCEE + a_mCEE); real ta = (a_iCEE + a_mCEE);
real bi = tc - ta - credito_costo_prec(month); real bi = tc - ta - credito_costo_prec(month);
@ -3342,17 +3385,14 @@ void TLiquidazione_app::write_liq(int month, const char* codatts)
// credito di costo // credito di costo
{ {
cred_cost = abs(bi); cred_cost = abs(bi);
if (atoi(_year) < 2000) round_imposta(cred_cost);
round_alla_lira(cred_cost);
else
round_imposta(cred_cost);
} }
else else
{ {
const real ali_via = aliquota_agvia(); const real ali_via = aliquota_agvia();
// deb_mens = (bi /((CENTO + ali_via)/CENTO)) * (ali_via/CENTO); // deb_mens = (bi /((CENTO + ali_via)/CENTO)) * (ali_via/CENTO);
deb_mens = bi * ali_via / (ali_via+CENTO); deb_mens = bi * ali_via / (ali_via+CENTO);
round_alla_lira(deb_mens, TRUE); // ceil voluto MI3074 round_al_centesimo(deb_mens); // ceil voluto MI3074
risultato += deb_mens; risultato += deb_mens;
res_debt += deb_mens; res_debt += deb_mens;
iva_vend += deb_mens; iva_vend += deb_mens;
@ -3367,7 +3407,7 @@ void TLiquidazione_app::write_liq(int month, const char* codatts)
perc = imp_agr2.is_zero() ? ZERO : imp_agr2 / (imp_agr1 + imp_agr2); perc = imp_agr2.is_zero() ? ZERO : imp_agr2 / (imp_agr1 + imp_agr2);
perc.round(2); perc.round(2);
iva_ded = acq_noCEE * perc; iva_ded = acq_noCEE * perc;
round_alla_lira(iva_ded); round_al_centesimo(iva_ded);
iva_acq += iva_ded; iva_acq += iva_ded;
res_debt += iva_vend; res_debt += iva_vend;
res_cred += iva_acq; res_cred += iva_acq;
@ -3626,7 +3666,7 @@ void TLiquidazione_app::write_liq(int month, const char* codatts)
// in annuale si arrotondera' a 1000 in stampa // in annuale si arrotondera' a 1000 in stampa
// se no il conguaglio prorata fa casino // se no il conguaglio prorata fa casino
round_alla_lira(risultato); round_al_centesimo(risultato);
_lim->put("R0",risultato); _lim->put("R0",risultato);
_lim->put("R2",cred_cost); _lim->put("R2",cred_cost);
@ -3673,7 +3713,7 @@ void TLiquidazione_app::write_liq(int month, const char* codatts)
const real interesse = interesse_trimestrale(_month); const real interesse = interesse_trimestrale(_month);
const real r = risultato - imposta_non_versata; // CM 26-09-2000 const real r = risultato - imposta_non_versata; // CM 26-09-2000
real ivi = r.sign() > 0 ? (r * interesse / CENTO) : ZERO; real ivi = r.sign() > 0 ? (r * interesse / CENTO) : ZERO;
round_alla_lira(ivi, TRUE); round_al_centesimo(ivi);
_lim->put("R14", ivi); _lim->put("R14", ivi);
} }

30
cg/cg4302.cpp
View File

@ -936,24 +936,8 @@ void TLiquidazione_app::round_imposta(real& d) const
ir.round(d); ir.round(d);
} }
void TLiquidazione_app::round_alla_lira(real& d, bool sup) void TLiquidazione_app::round_al_centesimo(real& d) const
{ { d.round(2); }
const int dec = TCurrency::get_firm_dec();
if (dec == 0) // lire
{
if (sup)
{
if (d >= ZERO)
d.ceil(0);
else
d.floor(0);
}
else
d.round(0);
}
else
d.round(dec);
}
// Ritorna il parametro della liquidazione differita per la ditta corrente, cosi come // Ritorna il parametro della liquidazione differita per la ditta corrente, cosi come
@ -962,12 +946,12 @@ void TLiquidazione_app::round_alla_lira(real& d, bool sup)
// Analogamente per l'anno // Analogamente per l'anno
bool TLiquidazione_app::is_differita(long firm, int year) bool TLiquidazione_app::is_differita(long firm, int year)
{ {
long d = (firm <= 0) ? _nditte->curr().get_long("CODDITTA") : firm; bool diff = false;
int y = (year <= 0) ? atoi(_year) : year; const long d = (firm <= 0) ? _nditte->curr().get_long("CODDITTA") : firm;
const int y = (year <= 0) ? atoi(_year) : year;
if (look_lia(d, y > 0, y)) // 26/03/2012 aggiunto ,y) if (look_lia(d, y > 0, y)) // 26/03/2012 aggiunto ,y)
return _lia->get_bool("B1"); diff = _lia->get_bool("B1");
else return diff;
return false;
} }
real TLiquidazione_app::aliquota_agvia() real TLiquidazione_app::aliquota_agvia()

6
cg/cg4303.cpp
View File

@ -326,7 +326,7 @@ void TLiquidazione_app::recalc_ventilation(int month, const char* codatt)
{ {
_VentItem* vv = (_VentItem*)&_vent_arr[j]; _VentItem* vv = (_VentItem*)&_vent_arr[j];
imponibile = vv->_totale * moltiplicatore; // Importo lordo vendite imponibile = vv->_totale * moltiplicatore; // Importo lordo vendite
round_alla_lira(imponibile); round_al_centesimo(imponibile);
lordo2netto(imponibile, imposta, vv->_aliquota); // Scorpora l'iva lordo2netto(imponibile, imposta, vv->_aliquota); // Scorpora l'iva
// aggiusto l'IVA vendite nei plm // aggiusto l'IVA vendite nei plm
look_plm(month, codatt); look_plm(month, codatt);
@ -420,7 +420,7 @@ void TLiquidazione_app::recalc_viaggio(int month, const char* codatt)
if (month == 13) if (month == 13)
round_imposta(ivm); round_imposta(ivm);
else else
round_alla_lira(ivm, TRUE); round_al_centesimo(ivm);
const real tc = c_CEE + ivm; const real tc = c_CEE + ivm;
const real ta = a_CEE + a_mCEE; const real ta = a_CEE + a_mCEE;
@ -435,7 +435,7 @@ void TLiquidazione_app::recalc_viaggio(int month, const char* codatt)
if (month == 13) if (month == 13)
round_imposta(deb_mens); round_imposta(deb_mens);
else else
round_alla_lira(deb_mens, TRUE); round_al_centesimo(deb_mens);
} }
if (look_plm(month,codatt)) if (look_plm(month,codatt))
{ {

320
cg/cg4304.cpp
View File

@ -6,10 +6,15 @@
#include <currency.h> #include <currency.h>
#include <recarray.h> #include <recarray.h>
#include <recset.h>
#include <utility.h> #include <utility.h>
#include "cg4300.h" #include "cg4300.h"
#include <attiv.h> #include <attiv.h>
#include <nditte.h>
#include <rmoviva.h>
// flags per annuale // flags per annuale
#define IS_PRORATA 0x0001 #define IS_PRORATA 0x0001
@ -124,55 +129,62 @@ bool TLiquidazione_app::preprocess_page(int file, int cnt)
// Print description // Print description
// ---------------------------------------------------------------- // ----------------------------------------------------------------
void TLiquidazione_app::describe_att(int month, const char* codatt, void TLiquidazione_app::describe_att(int month, const char* codatt, bool /*isresult*/, char flags)
bool isresult, char flags)
{ {
TToken_string atts(codatt);
if (_isprint && _canprint) if (_isprint && _canprint)
{ {
TToken_string atts(codatt);
const bool single_att = atts.items() == 1;
describe_name(month, atts, flags); describe_name(month, atts, flags);
if (atts.items() == 1 && _isplafond)
describe_plafond(month, codatt); if (single_att)
if (atts.items() == 1 && _isvent) {
describe_ventilation(month, codatt); if (_isplafond)
if (atts.items() == 1 && _isagricolo) describe_plafond(month, codatt);
describe_agricolo(month, codatt); if (_isvent)
if (atts.items() == 1 && _isviaggio) describe_ventilation(month, codatt);
describe_viaggio(month, codatt); if (_isagricolo)
describe_pims(month,codatt,FALSE); describe_agricolo(month, codatt);
// if (atoi(_year) > 1997) // Descrive anche i PIS se esistono if (_isviaggio)
describe_pims(month,codatt,TRUE); describe_viaggio(month, codatt);
if (atts.items() == 1) }
describe_pims(month, codatt, false); // PIM
describe_pims(month, codatt, true); // PIS
if (single_att)
describe_consistence(codatt); describe_consistence(codatt);
} }
} }
void TLiquidazione_app::describe_name(int month, TToken_string& codatts, char flags) void TLiquidazione_app::describe_name(int month, const TToken_string& codatts, char flags)
{ {
const bool single_att = codatts.items() == 1;
_DescrItem* d = new _DescrItem(CHG_PARMS); _DescrItem* d = new _DescrItem(CHG_PARMS);
d->_s0 = _nditte->curr().get("CODDITTA"); d->_s0 = _nditte->curr().get(NDT_CODDITTA);
d->_s1 = _nditte->curr().get("RAGSOC"); d->_s1 = _nditte->curr().get(NDT_RAGSOC);
if (atoi(_year) > 2007) if (atoi(_year) > 2007)
{ {
const TString16 codateco = _nditte->curr(LF_ATTIV).get(ATT_CODATECO); const TString16 codateco = _nditte->curr(LF_ATTIV).get(ATT_CODATECO);
d->_s2 = codateco; d->_s2 = codateco;
} }
else else
d->_s2 = _nditte->curr(LF_ATTIV).get("CODATT"); d->_s2 = _nditte->curr(LF_ATTIV).get(ATT_CODATT);
d->_s3 = codatts.items() == 1 ? (const char*)_nditte->curr(LF_ATTIV).get("DESCR") : ""; d->_s3 = single_att ? (const char*)_nditte->curr(LF_ATTIV).get(ATT_DESCR) : "";
d->_s4 = _freqviva; d->_s4 = _freqviva;
d->_f1 = month; d->_f1 = month;
d->_f2 = _isbenzinaro; d->_f2 = _isbenzinaro;
d->_f3 = (word)flags; d->_f3 = (word)flags;
if (_mixed && codatts.items() == 1) d->_f0 = 0;
if (_mixed && single_att)
d->_f0 = atoi(codatts.mid(5)); d->_f0 = atoi(codatts.mid(5));
else d->_f0 = 0;
_descr_arr.add(d); _descr_arr.add(d);
} }
@ -420,10 +432,10 @@ void TLiquidazione_app::describe_agricolo(int month, const char* codatt)
// _r9 mantiene la percentuale (gia' arrotondata!) // _r9 mantiene la percentuale (gia' arrotondata!)
// _r10 mantiene l'iva detraibile calcolata! // _r10 mantiene l'iva detraibile calcolata!
d->_r9 = d->_r8 / (d->_r7 + d->_r8); d->_r9 = d->_r8 / (d->_r7 + d->_r8);
d->_r9.round(2); round_al_centesimo(d->_r9);
d->_r10 = d->_r6 * d->_r9; d->_r10 = d->_r6 * d->_r9;
d->_r9 *= CENTO; d->_r9 *= CENTO;
round_alla_lira(d->_r10, TRUE); round_al_centesimo(d->_r10);
_descr_arr.add(d); _descr_arr.add(d);
} }
@ -471,7 +483,7 @@ void TLiquidazione_app::describe_viaggio(int month, const char* codatt)
if (month == 13) if (month == 13)
round_imposta(d->_r9); round_imposta(d->_r9);
else else
round_alla_lira(d->_r9); round_al_centesimo(d->_r9);
// Calcola l'iva a debito, visto che servira' anche nel calcolo liquidazione (solo annuale) // Calcola l'iva a debito, visto che servira' anche nel calcolo liquidazione (solo annuale)
const real aliva = aliquota_agvia(); const real aliva = aliquota_agvia();
@ -484,17 +496,17 @@ void TLiquidazione_app::describe_viaggio(int month, const char* codatt)
if (month == 13) if (month == 13)
round_imposta(d->_r11); round_imposta(d->_r11);
else else
round_alla_lira(d->_r11, TRUE); round_al_centesimo(d->_r11);
} }
_descr_arr.add(d); _descr_arr.add(d);
} }
void TLiquidazione_app::describe_pims(int month, const char* codatt, const bool describe_pis) void TLiquidazione_app::describe_pims(int month, const char* codatt, const bool describe_pis)
// le si passa una tokenstring (o un codatt) e lei, da brava, calcola // le si passa una tokenstring (o un codatt) e lei, da brava, calcola
// cumulando per tutte le attivita' nominatele // cumulando per tutte le attività nominatele
// ogni riga riguarda un codiva ma tutti i registri // ogni riga riguarda un codiva ma tutti i registri
// se il mese e' 13 si guarda tutto l'anno // se il mese e' 13 si guarda tutto l'anno
// se si tratta di una sola attivita' in att. mista evidenziata o servizievole, // se si tratta di una sola attività in att. mista evidenziata o servizievole,
// stampa solo vendite e corrispettivi // stampa solo vendite e corrispettivi
// L'ultimo parametro serve per calcolare i PIS (progressivi del periodo successivo) // L'ultimo parametro serve per calcolare i PIS (progressivi del periodo successivo)
{ {
@ -536,12 +548,6 @@ void TLiquidazione_app::describe_pims(int month, const char* codatt, const bool
_CorrItem cx; _CorrItem cx;
bool is_key; bool is_key;
// Never mind the bollox
TString80 codtab;
TString8 activity;
TString4 codreg, codiva, anno;
int mese;
FOR_EACH_TOKEN(atts, tmpatt) FOR_EACH_TOKEN(atts, tmpatt)
{ {
const TString8 att(tmpatt); const TString8 att(tmpatt);
@ -550,12 +556,13 @@ void TLiquidazione_app::describe_pims(int month, const char* codatt, const bool
{ {
_DescrItem* d = NULL; _DescrItem* d = NULL;
// compute // compute
codtab = tab->get("CODTAB"); const TString80 codtab = tab->get("CODTAB");
anno = codtab.mid(0,4); const TString4 anno = codtab.mid(0,4);
activity= codtab.mid(4,6); const TString8 activity= codtab.mid(4,6);
codreg = codtab.mid(10,3); const TString4 codreg = codtab.mid(10,3);
mese = atoi(codtab.mid(13,2)); const int mese = atoi(codtab.mid(13,2));
codiva = codtab.mid(16,4); TString4 codiva = codtab.mid(16,4);
const int tipodet = atoi(codtab.mid(20,1));
bool ok = look_reg(codreg); bool ok = look_reg(codreg);
ok |= look_iva(codiva); ok |= look_iva(codiva);
@ -564,12 +571,12 @@ void TLiquidazione_app::describe_pims(int month, const char* codatt, const bool
tiporeg tipomov = (tiporeg)_reg->get_long("I0"); tiporeg tipomov = (tiporeg)_reg->get_long("I0");
bool corrisp = _reg->get_bool("B0"); bool corrisp = _reg->get_bool("B0");
TString tipoiva = _iva->get("S1"); TString tipoiva = _iva->get("S1");
int tipodet = atoi(codtab.mid(20,1)); const TString4 other = tab->get("S4");
TString other = tab->get("S4");
TToken_string s1(tab->get("S1"),'!'); // Imponibile/iva fatture in ritardo TToken_string s1(tab->get("S1"),'!'); // Imponibile/iva fatture in ritardo
real rit_imp(s1.get(0)); real rit_imp(s1.get(0));
real rit_iva(s1.get(1)); real rit_iva(s1.get(1));
/* Perchè _pim invece di tab ? 17-10-2012
diffimp = _pim->get_real("R26"); diffimp = _pim->get_real("R26");
diffiva = _pim->get_real("R27"); diffiva = _pim->get_real("R27");
diffincimp = _pim->get_real("R28"); diffincimp = _pim->get_real("R28");
@ -578,7 +585,17 @@ void TLiquidazione_app::describe_pims(int month, const char* codatt, const bool
diffimp_acq = _pim->get_real("R30"); diffimp_acq = _pim->get_real("R30");
diffiva_acq = _pim->get_real("R31"); diffiva_acq = _pim->get_real("R31");
diffincimp_acq = _pim->get_real("R32"); diffincimp_acq = _pim->get_real("R32");
diffinciva_acq = _pim->get_real("R33"); diffinciva_acq = _pim->get_real("R33"); */
diffimp = tab->get_real("R26");
diffiva = tab->get_real("R27");
diffincimp = tab->get_real("R28");
diffinciva = tab->get_real("R29");
diffimp_acq = tab->get_real("R30");
diffiva_acq = tab->get_real("R31");
diffincimp_acq = tab->get_real("R32");
diffinciva_acq = tab->get_real("R33");
const bool is_rit= tipodet != 0 && month == 13 && rit_imp != 0.0; //Se fattura in ritardo con tipo detr. != 0 e si sta calcolando l'annuale const bool is_rit= tipodet != 0 && month == 13 && rit_imp != 0.0; //Se fattura in ritardo con tipo detr. != 0 e si sta calcolando l'annuale
const tipo_sospensione sosp_imp = _reg->get_bool("B1") ? (tipo_sospensione) _reg->get_int("I9") : nessuna; const tipo_sospensione sosp_imp = _reg->get_bool("B1") ? (tipo_sospensione) _reg->get_int("I9") : nessuna;
@ -586,7 +603,7 @@ void TLiquidazione_app::describe_pims(int month, const char* codatt, const bool
// ACHTUNG! Corrispettivi da ventileer possono ventilare // ACHTUNG! Corrispettivi da ventileer possono ventilare
// ad un altro codiva; in tal caso si scrive quello // ad un altro codiva; in tal caso si scrive quello
if (corrisp && !other.empty()) if (corrisp && other.full())
{ {
look_iva(other); look_iva(other);
codiva = other; codiva = other;
@ -627,13 +644,10 @@ void TLiquidazione_app::describe_pims(int month, const char* codatt, const bool
{ {
// vedi se c'e' gia' un item corrispondente // vedi se c'e' gia' un item corrispondente
int i; int i;
for(i = last+1; i < _descr_arr.items(); i++) for(i = last+1; i < _descr_arr.items(); i++)
{ {
_DescrItem * wd = (_DescrItem*)&_descr_arr[i]; _DescrItem* wd = (_DescrItem*)&_descr_arr[i];
if (wd->_flags == PIM_PIS && if (wd->_flags == PIM_PIS && wd->_s0 == ref && wd->_s1 == codiva)
wd->_s0 == ref &&
wd->_s1 == codiva)
{ {
d = wd; d = wd;
break; break;
@ -647,12 +661,12 @@ void TLiquidazione_app::describe_pims(int month, const char* codatt, const bool
} }
if (d == NULL) if (d == NULL)
{ {
bool isfirst = (hea == NULL); const bool isfirst = (hea == NULL);
if (isfirst) if (isfirst)
{ {
hea = new _DescrItem(describe_pis ? PIS_HEAD : PIM_HEAD); hea = new _DescrItem(describe_pis ? PIS_HEAD : PIM_HEAD);
hea->_f0 = skip_acq; // cosi' non compare nemmeno la colonnina! contento? hea->_f0 = skip_acq; // così non compare nemmeno la colonnina! contento?
hea->_f1 = true; hea->_f1 = true;
_descr_arr.insert(hea, i++); _descr_arr.insert(hea, i++);
tot = new _DescrItem(TOT_ROW); tot = new _DescrItem(TOT_ROW);
@ -794,7 +808,7 @@ void TLiquidazione_app::describe_pims(int month, const char* codatt, const bool
} }
} }
// if (tipomov == vendita) // if (tipomov == vendita)
// { {
if (!diffimp.is_zero() || !diffiva.is_zero() || if (!diffimp.is_zero() || !diffiva.is_zero() ||
!diffimp_acq.is_zero() || !diffiva_acq.is_zero()) !diffimp_acq.is_zero() || !diffiva_acq.is_zero())
{ {
@ -854,7 +868,7 @@ void TLiquidazione_app::describe_pims(int month, const char* codatt, const bool
d = NULL; d = NULL;
for (j = totpos + 1; j < _descr_arr.items(); j++) for (j = totpos + 1; j < _descr_arr.items(); j++)
{ {
_DescrItem * wd = (_DescrItem*)&_descr_arr[j]; _DescrItem* wd = (_DescrItem*)&_descr_arr[j];
const bool found = wd->_flags == id && wd->_s0 == ref; const bool found = wd->_flags == id && wd->_s0 == ref;
if (found && wd->_s1 == codiva) if (found && wd->_s1 == codiva)
@ -876,6 +890,7 @@ void TLiquidazione_app::describe_pims(int month, const char* codatt, const bool
_descr_arr.insert(headi, j++); _descr_arr.insert(headi, j++);
headi->_f0 = false; headi->_f0 = false;
headi->_f1 = true; headi->_f1 = true;
headi->_f2 = atoi(activity.right(1)); // Tipo attività = 1 (servizi) o 2 (mista)
totdi = new _DescrItem(TOT_ROW_DI); totdi = new _DescrItem(TOT_ROW_DI);
_descr_arr.insert(totdi, j); _descr_arr.insert(totdi, j);
} }
@ -894,7 +909,7 @@ void TLiquidazione_app::describe_pims(int month, const char* codatt, const bool
t32 += diffincimp_acq; t32 += diffincimp_acq;
t33 += diffinciva_acq; t33 += diffinciva_acq;
} }
// } }
} }
} // End of _pim cycle } // End of _pim cycle
@ -1435,6 +1450,7 @@ void TLiquidazione_app::set_firm(_DescrItem& d)
if (j) set_row(i+3,""); if (j) set_row(i+3,"");
} }
static int _tipo_attivita_corrente = 0;
void TLiquidazione_app::set_att(_DescrItem& d) void TLiquidazione_app::set_att(_DescrItem& d)
{ {
@ -1444,7 +1460,7 @@ void TLiquidazione_app::set_att(_DescrItem& d)
// Bookmark // Bookmark
TString book_name(d._s3); TString book_name(d._s3);
char flags = (char)d._f3; const char flags = (char)d._f3;
if (flags == '1') book_name << TR(" (servizi)"); if (flags == '1') book_name << TR(" (servizi)");
else if (flags == '2') book_name << TR(" (altre)"); else if (flags == '2') book_name << TR(" (altre)");
@ -1473,22 +1489,17 @@ void TLiquidazione_app::set_att(_DescrItem& d)
(const char*)_year); (const char*)_year);
} }
TString tipatt; const char* tipatt = "";
if (d._f0 > 0) if (d._f0 > 0)
tipatt.format(d._f0 == 1 ? TR("SERVIZI") : TR("ALTRE ATTIVITA'")); tipatt = d._f0 == 1 ? TR("SERVIZI") : TR("ALTRE ATTIVITA'");
if (d._s3.empty()) if (d._s3.empty())
{ {
att_title = flags == 'M' ? TR("Riepilogo attività mista") : att_title = flags == 'M' ? TR("Riepilogo attività mista") : TR("Riepilogo quater");
TR("Riepilogo quater");
// att_title << d._s2; // att_title << d._s2;
} }
else else
att_title = format(FR("Attività %s %s %s"), att_title = format(FR("Attività %s %s %s"), (const char*)(d._s2), (const char*)(d._s3), tipatt);
(const char*)(d._s2),
(const char*)(d._s3),
(const char*)tipatt);
reset_header(); reset_header();
int soh = 1; int soh = 1;
@ -1697,47 +1708,121 @@ void TLiquidazione_app::set_liqacc_2000(_DescrItem& d)
set_auto_ff(); set_auto_ff();
} }
bool TLiquidazione_app::print_diff_log(int& rw) bool TLiquidazione_app::print_dainc_diff_log(int& rw, int tipoatt)
{ {
if (_isregis || _isfinal) if (_isregis)
return false; return false;
TFilename tmp; tmp.tempdir(); TString limit; limit << "ANNOLIQ=" << _year;
tmp.add("liqdiff.txt"); if (_month < 13) limit << " MESELIQ=" << _month;
ifstream f(tmp); TString query;
TToken_string str(256, '\t'); query << "USE IVADIFF KEY 2 SELECT (TIPOMOV==1)";
if (tipoatt == 1 || tipoatt == 2)
query << " &&(TIPOATT==" << tipoatt << ")";
query << "\nBY TIPOIVA DATAREG";
query << "\nJOIN MOV INTO NUMREG==NUMREG";
query << "\nJOIN CLIFO TO MOV INTO TIPOCF==TIPO CODCF==CODCF";
query << "\nFROM " << limit << "\nTO " << limit;
bool header = false; int header = 0;
while (f.good()) TISAM_recordset id(query);
const int rfat = id.items();
if (rfat > 0)
{ {
f.getline(str.get_buffer(), str.size()); str.trim(); const TRectype& rec = id.cursor()->curr();
if (str.full()) bool header_printed = false;
for (bool ok = id.move_first(); ok; ok = id.move_next())
{ {
if (!header) real importo, imponibile, imposta;
const TDate nulldate;
residuo_da_liquidare(rec.get_long(RMI_NUMREG), rec.get_int(RMI_NUMRIG), nulldate,
importo, imponibile, imposta);
if (!importo.is_zero())
{ {
header = true; const int ti = rec.get_int("TIPOIVA");
set_row(rw++, "IVA@17gImporto@30gImponibile@49gImposta@64gPagamento@96gFattura"); if (ti != header)
} {
if (ti < 2)
set_row(rw++, TR("Fatture a liquidazione differita o per cassa da incassare"));
else
set_row(rw++, TR("Fatture a liquidazione differita o per cassa da pagare"));
set_row(rw++, "IVA@17gImporto@30gImponibile@49gImposta@58gTipologia@71gFattura@92gRagione sociale");
header = ti;
}
const TString4 codiva = str.get(0); const TString4 codiva = rec.get("CODIVA");
const real importo = str.get(); const TString16 numfat = id.get("MOV.NUMDOC").as_string();
const real imponibile = str.get(); const TString16 datafat = rec.get("DATAREG");
const real imposta = str.get(); const char* tipolog = id.get("TIPODIFF").as_int() == 2 ? TR("Per Cassa") : TR("Differita");
const TString16 numpag = str.get();
const TString16 datapag = str.get(); TParagraph_string clifo(id.get("CLIFO.RAGSOC").as_string(), 40);
const TString16 numfat = str.get(); set_row(rw++, "%s@9g%r@25g%r@41g%r@58g%s@71g%s@81g%s@92g%s",
const TString16 datafat = str.get(); (const char*)codiva, &importo, &imponibile, &imposta,
set_row(rw++, "%s@9g%r@25g%r@41g%r@64g%s@80g%s@96g%s@112g%s", tipolog, (const char*)numfat, (const char*)datafat,
(const char*)codiva, &importo, &imponibile, &imposta, clifo.get());
(const char*)numpag, (const char*)datapag, (const char*)numfat, (const char*)datafat); }
str.cut(0);
} }
} }
return header; return rfat > 0;
} }
bool TLiquidazione_app::print_inc_diff_log(int& rw, int tipoatt)
{
if (_isregis)
return false;
TString limit; limit << "ANNOLIQ=" << _year;
if (_month < 13) limit << " MESELIQ=" << _month;
TString query;
query << "USE IVADIFF KEY 2 SELECT (TIPOMOV>2)";
if (tipoatt == 1 || tipoatt == 2)
query << "&&(TIPOATT==" << tipoatt << ")";
query << "\nBY TIPOIVA DATAREGP";
query << "\nJOIN MOV INTO NUMREG==NUMREG";
query << "\nJOIN CLIFO TO MOV INTO TIPOCF==TIPO CODCF==CODCF";
query << "\nFROM " << limit << "\nTO " << limit;
TISAM_recordset id(query);
const int rpag = id.items();
if (rpag > 0)
{
const TRectype& rec = id.cursor()->curr();
int header = 0;
for (bool ok = id.move_first(); ok; ok = id.move_next())
{
const int ti = rec.get_int("TIPOIVA");
if (ti != header)
{
if (ti < 2)
set_row(rw++, TR("Fatture a liquidazione differita o per cassa incassate"));
else
set_row(rw++, TR("Fatture a liquidazione differita o per cassa pagate"));
set_row(rw++, "IVA@17gImporto@30gImponibile@49gImposta@58gPagamento@71gFattura@92gRagione sociale");
header = ti;
}
const TString4 codiva = rec.get(RMI_CODIVA);
const real importo = rec.get("IMPORTO");
const real imponibile = rec.get(RMI_IMPONIBILE);
const real imposta = rec.get(RMI_IMPOSTA);
const TString16 datapag = rec.get("DATAREGP");
const TString16 numfat = id.get("MOV.NUMDOC").as_string();
const TString16 datafat = rec.get("DATAREG");
TParagraph_string clifo(id.get("CLIFO.RAGSOC").as_string(), 40);
set_row(rw++, "%s@9g%r@25g%r@41g%r@58g%s@71g%s@81g%s@92g%s",
(const char*)codiva, &importo, &imponibile, &imposta,
(const char*)datapag, (const char*)numfat, (const char*)datafat,
clifo.get());
}
}
return rpag > 0;
}
void TLiquidazione_app::set_pim_head(_DescrItem& d) void TLiquidazione_app::set_pim_head(_DescrItem& d)
{ {
int r = 1; int r = 1;
@ -1749,15 +1834,14 @@ void TLiquidazione_app::set_pim_head(_DescrItem& d)
set_row(r++,""); set_row(r++,"");
if (d._flags == PIM_HEAD_D) if (d._flags == PIM_HEAD_D)
{ {
set_row(r++, TR("Fatture a liquidazione differita da incassare"));
set_bookmark(TR("Riepilogo progressivi a liquidazione differita"), _att_bookmark); set_bookmark(TR("Riepilogo progressivi a liquidazione differita"), _att_bookmark);
print_dainc_diff_log(r, d._f2);
} }
else else
if (d._flags == PIM_HEAD_DI) if (d._flags == PIM_HEAD_DI)
{ {
set_row(r++, TR("Fatture a liquidazione differita incassate"));
set_bookmark(TR("Riepilogo progressivi a liquidazione differita incassati"), _att_bookmark); set_bookmark(TR("Riepilogo progressivi a liquidazione differita incassati"), _att_bookmark);
print_diff_log(r); print_inc_diff_log(r, d._f2);
} }
else // PIS_HEAD else // PIS_HEAD
{ {
@ -1778,7 +1862,6 @@ void TLiquidazione_app::set_pim_head(_DescrItem& d)
{ {
set_row(r++, TR("Fatture a liquidazione differita incassate")); set_row(r++, TR("Fatture a liquidazione differita incassate"));
set_bookmark(TR("Riepilogo progressivi successivi a liquidazione differita incassati"), _att_bookmark); set_bookmark(TR("Riepilogo progressivi successivi a liquidazione differita incassati"), _att_bookmark);
print_diff_log(r);
} }
} }
set_row(r++,""); set_row(r++,"");
@ -1864,7 +1947,7 @@ void TLiquidazione_app::set_pim(_DescrItem& d)
} }
} }
void TLiquidazione_app::set_plm_diff(_DescrItem& d) void TLiquidazione_app::set_plm_diff(const _DescrItem& d)
{ {
int rw = 1; int rw = 1;
@ -1886,21 +1969,12 @@ void TLiquidazione_app::set_plm_diff(_DescrItem& d)
void TLiquidazione_app::set_plm(_DescrItem& d) void TLiquidazione_app::set_plm(_DescrItem& d)
{ {
int rw = 1; int rw = 1;
if (!(d._r0.is_zero() && if (!(d._r0.is_zero() && d._r1.is_zero() && d._r2.is_zero() &&
d._r1.is_zero() && d._r3.is_zero() && d._r4.is_zero() && d._r5.is_zero()))
d._r2.is_zero() &&
d._r3.is_zero() &&
d._r4.is_zero() &&
d._r5.is_zero()))
{ {
set_row(rw++,""); set_row(rw++,""); set_row(rw++,""); set_row(rw++,"");
set_row(rw++,FR("Totale@25g%r@41g%r@58g%r@74g%r@91g%r@107g%r"), set_row(rw++,FR("Totale@25g%r@41g%r@58g%r@74g%r@91g%r@107g%r"),
&(d._r0), &(d._r0), &(d._r1), &(d._r2), &(d._r3), &(d._r4), &(d._r5));
&(d._r1),
&(d._r2),
&(d._r3),
&(d._r4),
&(d._r5));
set_row(rw++,""); set_row(rw++,"");
} }
if (!(d._r7.is_zero() && d._r8.is_zero())) if (!(d._r7.is_zero() && d._r8.is_zero()))
@ -1911,8 +1985,7 @@ void TLiquidazione_app::set_plm(_DescrItem& d)
if (! (d._r9.is_zero() && d._r10.is_zero())) if (! (d._r9.is_zero() && d._r10.is_zero()))
{ {
set_row(rw++, FR("Totale acquisti indeducibili su ricavi esenti@91g%r@107g%r"), set_row(rw++, FR("Totale acquisti indeducibili su ricavi esenti@91g%r@107g%r"),
&(d._r9), &(d._r9), &(d._r10));
&(d._r10));
} }
real acq_pint(d._s0); real acq_pint(d._s0);
@ -1938,32 +2011,18 @@ void TLiquidazione_app::set_plm(_DescrItem& d)
// per ora lascio r2 e r3 anche se sono sempre 0 // per ora lascio r2 e r3 anche se sono sempre 0
set_row(rw++, ""); set_row(rw++, "");
set_row(rw++,FR("Totale Generale IVA@25g%r@41g%r@58g%r@74g%r@91g%r@107g%r"), set_row(rw++,FR("Totale Generale IVA@25g%r@41g%r@58g%r@74g%r@91g%r@107g%r"),
&(d._r0), &(d._r0), &(d._r1), &(d._r2), &(d._r3), &tot1, &tot2);
&(d._r1),
&(d._r2),
&(d._r3),
&tot1,
&tot2);
} }
// Stampa il totale progressivo da registri, comprensivo dei movimenti valevoli per il calcolo vol. affari. // Stampa il totale progressivo da registri, comprensivo dei movimenti valevoli per il calcolo vol. affari.
real pr_imp(d._s2); real pr_imp(d._s2);
real pr_iva(d._s3); real pr_iva(d._s3);
if (!(d._r11.is_zero() && if (!(d._r11.is_zero() && d._r12.is_zero() && d._r13.is_zero() &&
d._r12.is_zero() && d._r14.is_zero() && pr_imp.is_zero() && pr_iva.is_zero()))
d._r13.is_zero() &&
d._r14.is_zero() &&
pr_imp.is_zero() &&
pr_iva.is_zero()))
{ {
set_row(rw++,""); set_row(rw++,""); set_row(rw++,""); set_row(rw++,"");
set_row(rw++,FR("Totale Prog. da registri@25g%r@41g%r@58g%r@74g%r@91g%r@107g%r"), set_row(rw++,FR("Totale Prog. da registri@25g%r@41g%r@58g%r@74g%r@91g%r@107g%r"),
&(d._r11), &(d._r11), &(d._r12), &(d._r13), &(d._r14), &(pr_imp), &(pr_iva));
&(d._r12),
&(d._r13),
&(d._r14),
&(pr_imp),
&(pr_iva));
set_row(rw++,""); set_row(rw++,"");
} }
} }
@ -3201,3 +3260,4 @@ void TLiquidazione_app::set_deltab(_DescrItem& d, bool iscred)
} }
set_auto_ff(TRUE); set_auto_ff(TRUE);
} }

467
cg/cg4400.cpp
View File

File diff suppressed because it is too large Load Diff

3
cg/cg5300a.h
View File

@ -13,6 +13,9 @@
#define F_UTCR_IVA 213 #define F_UTCR_IVA 213
#define F_INTRTR 214 #define F_INTRTR 214
#define F_GEST74 215 #define F_GEST74 215
#define F_GESIC 216
#define F_ICDAL 217
#define F_ICAL 218
#define F_ROUNDLIQ 221 #define F_ROUNDLIQ 221
#define F_ROUNDDIC 222 #define F_ROUNDDIC 222

65
cg/cg5300a.uml
View File

@ -8,9 +8,9 @@ ENDPAGE
PAGE "Liquidazione" 0 0 0 2 PAGE "Liquidazione" 0 0 0 2
GROUPBOX DLG_NULL 78 4 GROUPBOX DLG_NULL 78 10
BEGIN BEGIN
PROMPT 1 0 "@bDitta" PROMPT 1 0 "@bParametri Ditta"
FLAGS "R" FLAGS "R"
END END
@ -64,19 +64,14 @@ BEGIN
FLAGS "HD" FLAGS "HD"
END END
GROUPBOX DLG_NULL 78 10
BEGIN
PROMPT 1 4 "@bParametri ditta"
END
TEXT DLG_NULL TEXT DLG_NULL
BEGIN BEGIN
PROMPT 4 5 "Frequenza versamenti" PROMPT 4 3 "Frequenza versamenti"
END END
RADIOBUTTON F_FREQ_VERS 1 38 RADIOBUTTON F_FREQ_VERS 1 38
BEGIN BEGIN
PROMPT 29 4 "" PROMPT 29 2 ""
HELP "Indicare la frequenza dei versamenti delle liquidazioni IVA" HELP "Indicare la frequenza dei versamenti delle liquidazioni IVA"
ITEM "M|Mensile" MESSAGE ENABLE,F_GELIDI|CLEAR,F_INTRTR|CLEAR,F_GEST74 ITEM "M|Mensile" MESSAGE ENABLE,F_GELIDI|CLEAR,F_INTRTR|CLEAR,F_GEST74
ITEM "T|Trimestrale" MESSAGE CLEAR,F_GELIDI|ENABLE,F_INTRTR|ENABLE,F_GEST74 ITEM "T|Trimestrale" MESSAGE CLEAR,F_GELIDI|ENABLE,F_INTRTR|ENABLE,F_GEST74
@ -86,40 +81,70 @@ END
BOOLEAN F_GELIDI BOOLEAN F_GELIDI
BEGIN BEGIN
PROMPT 4 6 "Liquidazione differita " PROMPT 4 4 "Liquidazione differita "
FIELD B1 FIELD B1
END END
BOOLEAN F_AGRMIN BOOLEAN F_AGRMIN
BEGIN BEGIN
PROMPT 47 6 "Agricoltore minimo " PROMPT 47 4 "Agricoltore minimo "
FIELD B2 FIELD B2
END END
BOOLEAN F_INTRTR BOOLEAN F_INTRTR
BEGIN BEGIN
PROMPT 4 7 "Non calcolare interessi per frequenza versamenti trimestrale" PROMPT 4 5 "Non calcolare interessi per frequenza versamenti trimestrale"
FIELD B3 FIELD B3
END END
BOOLEAN F_GEST74 BOOLEAN F_GEST74
BEGIN BEGIN
PROMPT 4 8 "Gestione versamenti 4.tr per soggetti art. 74/4" PROMPT 4 6 "Gestione versamenti 4.tr per soggetti art. 74/4"
FIELD B4 FIELD B4
END END
BOOLEAN F_GESIC
BEGIN
PROMPT 4 7 "Gestione IVA per cassa"
FIELD B5
MESSAGE FALSE DISABLE,F_ICDAL|DISABLE,F_ICAL
MESSAGE TRUE ENABLE,F_ICDAL|ENABLE,F_ICAL
MODULE IC
END
DATA F_ICDAL
BEGIN
PROMPT 40 7 "Dal "
CHECKTYPE REQUIRED
FIELD D0
MODULE IC
END
DATA F_ICAL
BEGIN
PROMPT 60 7 "Al "
CHECKTYPE REQUIRED
FIELD D1
MODULE IC
END
GROUPBOX DLG_NULL 78 6
BEGIN
PROMPT 1 10 "@bCredito"
FLAGS "R"
END
CURRENCY F_CRED_COST 18 CURRENCY F_CRED_COST 18
BEGIN BEGIN
PROMPT 4 9 "Credito di costo " PROMPT 4 11 "Credito di costo "
HELP "Eventuale credito di costo dell'anno precedente" HELP "Eventuale credito di costo dell'anno precedente"
FIELD R5 FIELD R5
DRIVENBY F_CODVAL DRIVENBY F_CODVAL
END END
LISTBOX F_UTCR_IVA 2 34 LISTBOX F_UTCR_IVA 2 34
BEGIN BEGIN
PROMPT 4 10 "Utilizzo credito IVA " PROMPT 4 12 "Utilizzo credito IVA "
ITEM " |Visibile e utilizzato solo in IVA" ITEM " |Visibile e utilizzato solo in IVA"
ITEM "NV|Non visibile ma compensabile" ITEM "NV|Non visibile ma compensabile"
FIELD S9 FIELD S9
@ -127,7 +152,7 @@ END
CURRENCY F_CRED_PREC 18 CURRENCY F_CRED_PREC 18
BEGIN BEGIN
PROMPT 4 11 "Credito compensabile inizio anno " PROMPT 4 13 "Credito compensabile inizio anno "
HELP "Eventuale credito di imposta dell'anno precedente" HELP "Eventuale credito di imposta dell'anno precedente"
FIELD R0 FIELD R0
DRIVENBY F_CODVAL DRIVENBY F_CODVAL
@ -135,7 +160,7 @@ END
CURRENCY F_CRED_RES 18 CURRENCY F_CRED_RES 18
BEGIN BEGIN
PROMPT 4 12 "Credito in compensaz.utilizzato " PROMPT 4 14 "Credito in compensaz.utilizzato "
FIELD R15 FIELD R15
DRIVENBY F_CODVAL DRIVENBY F_CODVAL
NUM_EXPR #THIS<=#F_CRED_PREC NUM_EXPR #THIS<=#F_CRED_PREC
@ -144,14 +169,14 @@ END
LISTBOX F_MESE_RES_AL 2 14 LISTBOX F_MESE_RES_AL 2 14
BEGIN BEGIN
PROMPT 57 12 "A " PROMPT 57 14 "A "
ITEM "0|" ITEM "0|"
FIELD I0 FIELD I0
END END
SPREADSHEET F_SHEET_PLA 78 SPREADSHEET F_SHEET_PLA 78
BEGIN BEGIN
PROMPT 1 14 "Parametri attivita'" PROMPT 1 16 "Parametri attivita'"
ITEM "Attiv.@5F" ITEM "Attiv.@5F"
ITEM "Tipo@3" ITEM "Tipo@3"
ITEM "Prorata" ITEM "Prorata"

11
cg/cglib02.cpp
View File

@ -882,14 +882,14 @@ void TSaldo_agg::reset()
void TSaldo_agg::clear_saldi(int year) void TSaldo_agg::clear_saldi(int year)
{ {
TLocalisamfile saldi(LF_SALDI); TFast_isamfile saldi(LF_SALDI);
set_anno_es(year); set_anno_es(year);
saldi.zero(); saldi.zero();
if (anno_es() != 0) if (anno_es() != 0)
saldi.put(SLD_ANNOES, anno_es()); saldi.put(SLD_ANNOES, anno_es());
TRectype last(saldi.curr()); const TRectype last = saldi.curr();
for (saldi.read(_isgteq, _lock); for (saldi.read(_isgteq, _lock);
!saldi.eof() && saldi.curr() <= last; !saldi.eof() && saldi.curr() <= last;
@ -926,7 +926,7 @@ void TSaldo_agg::registra()
TDate data_ulmov; TDate data_ulmov;
long num_ulmov; long num_ulmov;
TLocalisamfile saldi(LF_SALDI); TLocalisamfile saldi(LF_SALDI);
int conti = _tab_conti.items(); const int conti = _tab_conti.items();
_tab_conti.restart(); _tab_conti.restart();
for (int i = 0; i < conti; i++) for (int i = 0; i < conti; i++)
@ -1055,7 +1055,8 @@ void TSaldo_agg::registra()
si = saldo.saldofin_esprec(annoes, tcon.gruppo(), tcon.conto(), tcon.sottoconto()); si = saldo.saldofin_esprec(annoes, tcon.gruppo(), tcon.conto(), tcon.sottoconto());
if (si < ZERO) if (si < ZERO)
{ {
flag_salini = 'A'; si = -si; flag_salini = 'A';
si = -si;
} }
else else
flag_salini = 'D'; flag_salini = 'D';
@ -1072,7 +1073,7 @@ void TSaldo_agg::registra()
const TImporto avere('A', saldi.get_real(SLD_PAVERE)); const TImporto avere('A', saldi.get_real(SLD_PAVERE));
sf += dare; sf += dare;
sf += avere; sf += avere;
sf.normalize(+1); // Rendi sempre positivo sf.normalize(+1); // Rendi sempre positivo
tcon.saldo_finale() = sf; tcon.saldo_finale() = sf;
} }
} }

2
cg/cglib02.h
View File

@ -78,7 +78,7 @@ class TSaldo : public TObject
int _annoes; int _annoes;
int _indbil; int _indbil;
TDate _inizioEs, _fineEs; TDate _inizioEs, _fineEs;
TString16 _codcaus; TString4 _codcaus;
TDate _datareg; TDate _datareg;
TDate _datacomp; TDate _datacomp;
TString _provv; TString _provv;

5
cg/cgmenu.men
View File

@ -93,7 +93,7 @@ Item_03 = "Visualizzazione mastrini", "cg3 -5", "F"
Item_04 = "Visualizzazione saldi", "cg5 -2", "F" Item_04 = "Visualizzazione saldi", "cg5 -2", "F"
Item_05 = "Ricalcolo saldi", "cg4 -0", "F" Item_05 = "Ricalcolo saldi", "cg4 -0", "F"
Item_06 = "IVA", [CGMENU_010] Item_06 = "IVA", [CGMENU_010]
Item_07 = "Stampe di contabilita`", [CGMENU_023] Item_07 = "Stampe di contabilità", [CGMENU_023]
Item_08 = "Saldaconto", <scmenu.men> Item_08 = "Saldaconto", <scmenu.men>
Item_09 = "Tracciabilita' CUP-CIG", <ctmenu.men> Item_09 = "Tracciabilita' CUP-CIG", <ctmenu.men>
@ -111,7 +111,8 @@ Item_06 = "Liste fatture", [CGMENU_026]
Item_07 = "Gestione acconti IVA", [CGMENU_027] Item_07 = "Gestione acconti IVA", [CGMENU_027]
Item_08 = "Gestione versamenti IVA", [CGMENU_022] Item_08 = "Gestione versamenti IVA", [CGMENU_022]
Item_09 = "Operazioni annuali", [CGMENU_029] Item_09 = "Operazioni annuali", [CGMENU_029]
Item_10 = "Gestione autotrasportatori", "cg4 -9", "F" Item_10 = "IVA per cassa / differita", <icmenu.men>
Item_11 = "Gestione autotrasportatori", "cg4 -9", "F"
[CGMENU_011] [CGMENU_011]
Caption = "Tabelle ministeriali" Caption = "Tabelle ministeriali"

66
cg/cgsaldac.cpp
View File

@ -297,9 +297,15 @@ bool TRiga_scadenze::chiusa(bool update) const
return chiusa; return chiusa;
} }
static TImporto extract_importo(const TRectype& pag, const TRiga_partite& sum, bool val, int mode) TImporto TPartita::importo_pagsca(const TRectype& pag, bool val, int mode) const
{ {
CHECK(pag.num() == LF_PAGSCA, "Solo PAGSCA prego");
TImporto totale; TImporto totale;
const int nrigp = pag.get_int(PAGSCA_NRIGP);
if (!esiste(nrigp))
return totale;
const TRiga_partite& sum = riga(nrigp);
// Inizio aggiunte di Bonazzi del 16/02/2012 // Inizio aggiunte di Bonazzi del 16/02/2012
if (mode & 0x10) // solo le note di credito if (mode & 0x10) // solo le note di credito
@ -1093,6 +1099,9 @@ TImporto TRiga_partite::calcola_pagato_al(bool valuta,const TDate& al, const TDa
} }
*/ */
TImporto TRiga_partite::importo_pagsca(const TRectype& pag, bool val, int mode) const
{ return partita().importo_pagsca(pag, val, mode); }
int TRiga_partite::calcola_pagato_periodo(const TDate& dal, const TDate& al, TImporto& pg, TImporto& nc, TPointer_array* pagsca) const int TRiga_partite::calcola_pagato_periodo(const TDate& dal, const TDate& al, TImporto& pg, TImporto& nc, TPointer_array* pagsca) const
{ {
int flag = 0; int flag = 0;
@ -1138,12 +1147,27 @@ int TRiga_partite::calcola_pagato_periodo(const TDate& dal, const TDate& al, TIm
} }
} }
for (int i = 0; i < pags.items(); i++)
{
for (int j = i+1; j < pags.items(); j++)
{
const TRectype& pi = *(TRectype*)pags.objptr(i);
const TRectype& pj = *(TRectype*)pags.objptr(j);
const TRiga_partite& si = partita().riga(pi.get_int(PAGSCA_NRIGP));
const TRiga_partite& sj = partita().riga(pj.get_int(PAGSCA_NRIGP));
const TDate di = si.get(PART_DATAPAG);
const TDate dj = sj.get(PART_DATAPAG);
if (di > dj)
pags.swap(i, j);
}
}
FOR_EACH_ARRAY_ITEM(pags, p, obj) FOR_EACH_ARRAY_ITEM(pags, p, obj)
{ {
const TRectype& pag = *(TRectype*)obj; const TRectype& pag = *(TRectype*)obj;
const TRiga_partite& sum = partita().riga(pag.get_int(PAGSCA_NRIGP)); const TRiga_partite& sum = partita().riga(pag.get_int(PAGSCA_NRIGP));
const tipo_movimento tm = sum.tipo(); const tipo_movimento tm = sum.tipo();
const TImporto imp = extract_importo(pag, sum, false, 0xF); const TImporto imp = importo_pagsca(pag);
if (tm == tm_nota_credito) if (tm == tm_nota_credito)
{ {
nc += imp; nc += imp;
@ -1153,9 +1177,9 @@ int TRiga_partite::calcola_pagato_periodo(const TDate& dal, const TDate& al, TIm
{ {
pg += imp; pg += imp;
flag |= 1; flag |= 1;
if (pagsca != NULL && tm == tm_pagamento || tm == tm_pagamento_insoluto)
pagsca->add(obj);
} }
if (pagsca != NULL)
pagsca->add(obj);
} }
return flag; return flag;
@ -1772,15 +1796,11 @@ int TPartita::prima_riga(long nreg, tipo_movimento tipo) const
// Trova la prima riga della partita contenente una fattura // Trova la prima riga della partita contenente una fattura
int TPartita::prima_fattura(long nreg) const int TPartita::prima_fattura(long nreg) const
{ { return prima_riga(nreg, tm_fattura); }
return prima_riga(nreg, tm_fattura);
}
// Trova la prima riga della partita contenente una pagamento // Trova la prima riga della partita contenente una pagamento
int TPartita::primo_pagamento(long nreg) const int TPartita::primo_pagamento(long nreg) const
{ { return prima_riga(nreg, tm_pagamento); }
return prima_riga(nreg, tm_pagamento);
}
void TPartita::calcola_saldo(TImporto& saldo, TImporto& doc, TImporto& pag, TImporto& imp) const void TPartita::calcola_saldo(TImporto& saldo, TImporto& doc, TImporto& pag, TImporto& imp) const
{ {
@ -1794,16 +1814,10 @@ void TPartita::calcola_saldo(TImporto& saldo, TImporto& doc, TImporto& pag, TImp
const tipo_movimento tipo = row.tipo(); const tipo_movimento tipo = row.tipo();
switch (tipo) switch (tipo)
{ {
case tm_fattura: case tm_fattura : // fatture
case tm_nota_credito: case tm_nota_credito: doc += i; break; // note di credito
doc += i; // documenti case tm_pagamento : pag += i; break; // pagamenti
break; default : imp += i; break;// altri importi
case tm_pagamento:
pag += i; // pagamenti
break;
default:
imp += i; // altri importi
break;
} }
if (tipo >= tm_pagamento) if (tipo >= tm_pagamento)
@ -1904,9 +1918,11 @@ real TPartita::calcola_scaduto_al(bool valuta,const TDate& al) const
const TBill & c = conto(); const TBill & c = conto();
char sezione = ' '; char sezione = ' ';
if (c.tipo() == 'C') sezione = 'D'; if (c.tipo() == 'C')
sezione = 'D';
else else
if (c.tipo() == 'F') sezione = 'A'; if (c.tipo() == 'F')
sezione = 'A';
else else
{ {
const TRiga_partite& row = riga(ultima); const TRiga_partite& row = riga(ultima);
@ -1924,9 +1940,8 @@ real TPartita::calcola_scaduto_al(bool valuta,const TDate& al) const
{ {
for (int s = row.rate(); s > 0 ;s--) for (int s = row.rate(); s > 0 ;s--)
{ {
const TRiga_scadenze & rata = row.rata(s); const TRiga_scadenze& rata = row.rata(s);
const TDate data(rata.get(SCAD_DATASCAD)); const TDate data = rata.get(SCAD_DATASCAD);
if (data <= al) if (data <= al)
{ {
scaduto += rata.importo(valuta); scaduto += rata.importo(valuta);
@ -2099,7 +2114,6 @@ void TPartita::rimuovi_riga(int r)
chiusa(true); chiusa(true);
} }
static void somma(const TRectype& vec, TRectype& nuo, const char* field) static void somma(const TRectype& vec, TRectype& nuo, const char* field)
{ {
real totale(vec.get(field)); real totale(vec.get(field));

3
cg/cgsaldac.h
View File

@ -194,7 +194,7 @@ public:
TImporto importo(bool valuta, int mode = 0xF) const; TImporto importo(bool valuta, int mode = 0xF) const;
TImporto esposto(bool valuta, const TDate & data_scad, const TDate & data_rischio, bool & sbf) const; TImporto esposto(bool valuta, const TDate & data_scad, const TDate & data_rischio, bool & sbf) const;
//TImporto calcola_pagato_al(bool valuta, const TDate& al, const TDate & data_scaduto, const TDate& data_rischio, int mode = 0xF) const; TImporto importo_pagsca(const TRectype& pag, bool val = false, int mode = 0xF) const; // low level
int calcola_pagato_periodo(const TDate& dal, const TDate& al, TImporto& pag, TImporto& nc, TPointer_array* pagsca = NULL) const; int calcola_pagato_periodo(const TDate& dal, const TDate& al, TImporto& pag, TImporto& nc, TPointer_array* pagsca = NULL) const;
const TString& codice_valuta() const; const TString& codice_valuta() const;
@ -305,6 +305,7 @@ public:
TImporto calcola_saldo_al(bool valuta, const TDate& al, const TDate& data_scaduto, const TDate& data_rischio) const; TImporto calcola_saldo_al(bool valuta, const TDate& al, const TDate& data_scaduto, const TDate& data_rischio) const;
real calcola_scaduto_al(bool valuta, const TDate& al = botime) const; real calcola_scaduto_al(bool valuta, const TDate& al = botime) const;
TImporto importo_pagato_unassigned(bool val, int mode = 0xF) const; TImporto importo_pagato_unassigned(bool val, int mode = 0xF) const;
TImporto importo_pagsca(const TRectype& pag, bool val = false, int mode = 0xF) const; // low level
bool modifica_pagamento(const TRectype& new_pag, const TValuta& valuta, bool modifica_pagamento(const TRectype& new_pag, const TValuta& valuta,
char& old_ap, TImporto& old_abb, TImporto& old_diffcam, char& old_ap, TImporto& old_abb, TImporto& old_diffcam,

3
cg/f171.dir Normal file
View File

@ -0,0 +1,3 @@
171
0
$ivadiff|0|0|127|0|IVA ad esigibilità differita o per cassa|||

24
cg/f171.trr Normal file
View File

@ -0,0 +1,24 @@
171
19
NUMREG|3|7|0|Numero operazione Fattura
NUMRIG|2|3|0|Numero riga IVA
NUMPRO|2|3|0|Numero progressivo PAG o NC
TIPOMOV|2|1|0|Tipo movimento (1=Fattura;2=Nota credito;3=Pagamento)
DATAREG|5|8|0|Data fattura
NUMREGP|3|7|0|Numero operazione PAG o NC
NUMRIGP|2|3|0|Numero riga PAG o NC
DATAREGP|5|8|0|Data pagamento
ANNOLIQ|2|4|0|Anno liquidazione
MESELIQ|2|2|0|Mese liquidazione
TIPOATT|2|1|0|Tipo attività (1=Normale; 2=Mista)
TIPOIVA|2|1|0|Tipo IVA (1=Vendite; 2=Acquisti)
TIPODIFF|2|1|0|IVA differita (1) o per Cassa (2)
CODIVA|1|4|0|Codice IVA
SEZIONE|1|1|0|Sezione <D>are <A>vere
IMPORTO|4|18|3|Importo
IMPONIBILE|4|18|3|Imponibile
IMPOSTA|4|18|3|Imposta
VERSATA|4|18|3|Imposta Versata
2
NUMREG+NUMRIG+NUMPRO|
ANNOLIQ+MESELIQ+DATAREGP|X

2
cg/f23.dir
View File

@ -1,3 +1,3 @@
23 23
0 0
$mov|0|0|420|0|Movimenti di prima nota||| $mov|0|0|421|0|Movimenti di prima nota|||

3
cg/f23.trr
View File

@ -1,5 +1,5 @@
23 23
53 54
ANNOES|9|4|0|Codice esercizio ANNOES|9|4|0|Codice esercizio
NUMREG|3|7|0|Numero di operazione NUMREG|3|7|0|Numero di operazione
DATAREG|5|8|0|Data operazione DATAREG|5|8|0|Data operazione
@ -47,6 +47,7 @@ DCODNUM|1|4|0|Documento originale CODNUM
DNDOC|3|7|0|Documento originale NDOC DNDOC|3|7|0|Documento originale NDOC
DATAINC|5|8|0|Data di incasso per liquidazione differita DATAINC|5|8|0|Data di incasso per liquidazione differita
LIQDIFF|8|1|0|Flag di movimento a liquidazione differita LIQDIFF|8|1|0|Flag di movimento a liquidazione differita
IVAXCASSA|8|1|0|Flag di movimento IVA per cassa
MODPAG|2|1|0|Modalità di pagamento 1=Non frazionato; 2=Frazionato; 3=Periodico MODPAG|2|1|0|Modalità di pagamento 1=Non frazionato; 2=Frazionato; 3=Periodico
CONTRATTO|1|18|0|Contratto con importo > 3000 Euro CONTRATTO|1|18|0|Contratto con importo > 3000 Euro
DATARETT|5|8|0|Data documento rettificato DATARETT|5|8|0|Data documento rettificato