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

Corretto calcolo provvigioni negative generate da note di credito

Browse Source 
git-svn-id: svn://10.65.10.50/branches/R_10_00@22735 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 2012-09-26 10:41:35 +00:00
parent 34cd783a46
commit 1f2e7c2c82
9 changed files with 180 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pr/f124.dir
View File

@ -1,3 +1,3 @@
124 124
0 0
$provv|0|0|246|0|Archivio provvigioni||| $provv|0|0|254|0|Archivio provvigioni|||

3
pr/f124.trr
View File

@ -1,5 +1,5 @@
124 124
25 26
CODAGE|1|5|0|Codice agente CODAGE|1|5|0|Codice agente
ANNO|2|4|0|Anno del documento ANNO|2|4|0|Anno del documento
CODNUM|1|4|0|Codice numerazione del documento CODNUM|1|4|0|Codice numerazione del documento
@ -25,6 +25,7 @@ PROVVPAG|4|18|2|Provvigione pagata
PAGMAT|4|18|2|Pagamento maturato PAGMAT|4|18|2|Pagamento maturato
PROVVMAT|4|18|2|Provvigione maturata PROVVMAT|4|18|2|Provvigione maturata
TIPOPAGPR|2|1|0|Tipo pagamento della provvigione (?) TIPOPAGPR|2|1|0|Tipo pagamento della provvigione (?)
DATASTAMPA|5|8|0|Data pagamento ultima provvigione
2 2
CODAGE+ANNO+CODNUM+NDOC+NRIGA| CODAGE+ANNO+CODNUM+NDOC+NRIGA|
CODAGE+DATADOC|X CODAGE+DATADOC|X

26
pr/pr0.cpp
View File

@ -4,27 +4,17 @@
int main(int argc,char** argv) int main(int argc,char** argv)
{ {
const int n = argc > 1 ? argv[1][1]-'0' : 0; const int n = argc > 1 ? argv[1][1]-'0' : 0;
switch (n) switch (n)
{ {
case 1: case 1: pr0200(argc,argv); break; // stampa tabelle
pr0200(argc,argv); break; // stampa tabelle case 2: pr0300(argc,argv); break; // parametri studio
case 2: case 3: pr0400(argc,argv); break; // parametri ditta
pr0300(argc,argv); break; // parametri studio case 4: pr0500(argc,argv); break; // gestione agenti
case 3: case 5: pr0600(argc,argv); break; // gestione archivi percentuali di provvigione
pr0400(argc,argv); break; // parametri ditta case 6: pr0700(argc,argv); break; // gestione provvigioni agenti
case 4: case 7: pr0800(argc,argv); break; // aggiornamento maturato
pr0500(argc,argv); break; // gestione agenti default:pr0100(argc,argv); break; // gestione tabelle
case 5:
pr0600(argc,argv); break; // gestione archivi percentuali di provvigione
case 6:
pr0700(argc,argv); break; // gestione provvigioni agenti
case 7:
pr0800(argc,argv); break; // aggiornamento maturato
default:
pr0100(argc,argv); break; // gestione tabelle
} }
exit(0);
return 0; return 0;
} }

242
pr/pr0800.cpp
View File

@ -1,13 +1,12 @@
// Programma di gestione provvigioni // Programma di gestione provvigioni
#include <applicat.h> #include <applicat.h>
#include <automask.h> #include <automask.h>
#include <msksheet.h>
#include <recset.h> #include <recset.h>
#include "../cg/cgsaldac.h" #include "../cg/cgsaldac.h"
#include "../ve/velib.h"
#include "prlib.h" #include "prlib.h"
#include <modaut.h> #include <modaut.h>
#include <mov.h> #include <mov.h>
#include <doc.h> #include <doc.h>
#include "provv.h" #include "provv.h"
@ -22,9 +21,7 @@ protected:
public: public:
void load_params(); void load_params();
void save_params(); void save_params();
TAggiornamento_maturato_mask() : TAutomask("pr0800a") {} TAggiornamento_maturato_mask() : TAutomask("pr0800a") {}
virtual ~TAggiornamento_maturato_mask() {}
}; };
bool TAggiornamento_maturato_mask::on_field_event(TOperable_field& o, TField_event e, long jolly) bool TAggiornamento_maturato_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
@ -37,9 +34,16 @@ bool TAggiornamento_maturato_mask::on_field_event(TOperable_field& o, TField_eve
const long a_cod = atol(o.get()); const long a_cod = atol(o.get());
const long da_cod = get_long(F_DA_CODAGE); const long da_cod = get_long(F_DA_CODAGE);
if (a_cod > 0L && da_cod > a_cod) if (a_cod > 0L && da_cod > a_cod)
return error_box("Codice agente finale minore del codice agente iniziale"); return error_box(TR("Codice agente finale minore del codice agente iniziale"));
} }
break; break;
case F_CHECK_INSOLUTI:
if (e == fe_init)
{
const TRectype prov(LF_PROVV);
o.enable(prov.exist(PROV_DATASTAMPA));
}
break;
default: default:
break; break;
} }
@ -48,17 +52,14 @@ bool TAggiornamento_maturato_mask::on_field_event(TOperable_field& o, TField_eve
class TAggiornamento_maturato_app : public TSkeleton_application class TAggiornamento_maturato_app : public TSkeleton_application
{ {
protected: protected:
virtual bool create(); virtual bool create();
virtual bool destroy();
void aggiorna_maturato(TAggiornamento_maturato_mask &m);
virtual void main_loop(); virtual void main_loop();
public:
void aggiorna_maturato(const TAggiornamento_maturato_mask &m);
}; };
static inline TAggiornamento_maturato_app& app() { return (TAggiornamento_maturato_app&) main_app(); }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// Da fare : // Da fare :
// - Quando si elimina l'ultima riga dello spreadsheet si posiziona sulla prima senza // - Quando si elimina l'ultima riga dello spreadsheet si posiziona sulla prima senza
@ -77,135 +78,170 @@ bool TAggiornamento_maturato_app::create()
const bool saldaconto = has_module(SCAUT, CHK_DONGLE); const bool saldaconto = has_module(SCAUT, CHK_DONGLE);
if (!saldaconto) if (!saldaconto)
return error_box("Questo programma necessita del saldaconto"); return error_box(TR("Questo programma necessita del saldaconto"));
open_files(LF_PROVV, LF_TABCOM, LF_DOC, LF_PARTITE, LF_SCADENZE, LF_PAGSCA, LF_TAB, 0); open_files(LF_PROVV, LF_TABCOM, LF_DOC, LF_PARTITE, LF_SCADENZE, LF_PAGSCA, LF_TAB, 0);
return TSkeleton_application::create(); return TSkeleton_application::create();
} }
bool TAggiornamento_maturato_app::destroy() static bool prov_saldata(const TRectype& prov)
{ {
return TSkeleton_application::destroy(); bool is_saldata = prov.get_bool(PROV_SALDATA);
if (!is_saldata)
{
const real importo_rata = prov.get(PROV_IMPRATA);
const real importo_pagato = prov.get(PROV_PAGATO);
if ((importo_rata > ZERO) && (importo_rata <= importo_pagato)) // come fosse saldata, per cui ...
is_saldata = true;
}
return is_saldata;
} }
bool filter_func(const TRelation* rel) static bool scan_func(const TRelation& rel, void* pJolly)
{ {
const real importo_rata = rel->curr().get(PROV_IMPRATA); const TAggiornamento_maturato_mask& m = *(const TAggiornamento_maturato_mask*)pJolly;
const real importo_pagato = rel->curr().get(PROV_PAGATO); TRectype& rec = rel.curr();
const bool is_saldata = prov_saldata(rec);
if ((importo_rata > ZERO) && (importo_rata <= importo_pagato)) bool check_insoluti = false;
return false; TDate data_stampa;
else if (is_saldata && m.get_bool(F_CHECK_INSOLUTI))
return true; {
} data_stampa = rec.get_date(PROV_DATASTAMPA);
bool scan_func(const TRelation& rel, void* pJolly) check_insoluti = data_stampa.ok();
{ }
TAggiornamento_maturato_mask * m = (TAggiornamento_maturato_mask *) pJolly;
const TDate data_scad(m->get(F_DATA_SCAD)); if (!check_insoluti && is_saldata)
TDate data_rischio(data_scad); data_rischio -= m->get_long(F_GIORNI_RISCHIO); return true;
bool sbf = false;
TRectype & rec = rel.curr(); const int anno = rec.get_int(PROV_ANNO);
const int anno = rec.get_int(PROV_ANNO); const TString& codnum(rec.get(PROV_CODNUM)) ;
const TString16 codnum(rec.get(PROV_CODNUM)) ;
const long ndoc = rec.get_long(PROV_NDOC); const long ndoc = rec.get_long(PROV_NDOC);
TString key;
TString80 key; key.format("D|%d|%s|%ld", anno, (const char *) codnum, ndoc);
key.format("D|%d|%s|%ld", anno, (const char *) codnum, ndoc);
const long nreg = atol(cache().get(LF_DOC, key, DOC_NUMREG)); const long nreg = atol(cache().get(LF_DOC, key, DOC_NUMREG));
if (nreg > 0) if (nreg <= 0)
return true; // nessuna partita???
const TDate data_scad = m.get(F_DATA_SCAD);
TDate data_rischio(data_scad); data_rischio -= m.get_long(F_GIORNI_RISCHIO);
TPartite_array partite;
partite.add_numreg(nreg); // Always 1 record
bool changed_record = false;
for (const TPartita* part = partite.first(); part && !changed_record; part = partite.next()) // Always 1 game
{ {
TPartite_array p; bool insoluti_in_ritardo = false;
p.add_numreg(nreg); for (int nriga = part->last(); nriga > 0 && !changed_record; nriga = part->pred(nriga))
if (p.items() > 0)
{ {
const TPartita & part = *(p.first()); const TRiga_partite& r = part->riga(nriga);
const int nriga = part.prima_fattura(nreg); if (check_insoluti && r.tipo() >= tm_insoluto)
if (nriga >= 0) {
const TDate data_insoluto = r.get(PART_DATAREG);
if (data_insoluto > data_stampa)
insoluti_in_ritardo = true;
continue;
}
if (r.get_long(PART_NREG) != nreg || r.tipo() > tm_nota_credito)
continue;
if (rec.get_bool(PROV_SALDATA))
{
if (check_insoluti && !insoluti_in_ritardo)
continue; // Ignora righe saldate in assenza di insoluti
}
int nrata = rec.get_int(PROV_NRATA);
if (nrata > 0 && !r.exist(nrata))
nrata = 0;
const real importo_rata(rec.get_real(PROV_IMPRATA));
const real importo_pagato(rec.get_real(PROV_PAGATO));
const real provvigione_rata(rec.get_real(PROV_IMPPROVV));
const real provvigione_pagata(rec.get_real(PROV_PROVVPAG));
if (nrata > 0)
{ {
bool changed_record = false; bool sbf = false;
TRiga_partite & r = part.riga(nriga);
const int nrata = rec.get_int(PROV_NRATA);
const real importo_rata(rec.get_real(PROV_IMPRATA));
const real importo_pagato(rec.get_real(PROV_PAGATO));
const real provvigione_rata(rec.get_real(PROV_IMPPROVV));
const real provvigione_pagata(rec.get_real(PROV_PROVVPAG));
if (nrata > 0)
{
TRiga_scadenze & s = r.rata(nrata);
TImporto pagato(s.importo_pagato(false));
pagato -= s.esposto(false, data_scad, data_rischio, sbf); const TRiga_scadenze& s = r.rata(nrata);
pagato.normalize('A'); TImporto pagato(s.importo_pagato(false));
if (pagato.valore() >= importo_rata) pagato -= s.esposto(false, data_scad, data_rischio, sbf);
{ pagato.normalize('A');
const real importo_maturato = importo_rata - importo_pagato; if (pagato.valore() >= importo_rata)
const real provvigione_maturata = provvigione_rata - provvigione_pagata; {
const real importo_maturato = importo_rata - importo_pagato;
const real provvigione_maturata = provvigione_rata - provvigione_pagata;
rec.put(PROV_PAGMAT, importo_maturato); rec.put(PROV_PAGMAT, importo_maturato);
rec.put(PROV_PROVVMAT, provvigione_maturata); rec.put(PROV_PROVVMAT, provvigione_maturata);
changed_record = true; changed_record = true;
} }
else
{
const real importo_maturato = pagato.valore() - importo_pagato;
if (importo_maturato > ZERO)
{
real provvigione_maturata = provvigione_rata * (importo_maturato / importo_rata);
rec.put(PROV_PAGMAT, importo_maturato);
rec.put(PROV_PROVVMAT, provvigione_maturata);
changed_record = true;
}
}
}
else else
{ {
const TDate data_mat = rec.get_date(PROV_DATASCAD); real importo_maturato = pagato.valore() - importo_pagato;
if (importo_maturato < ZERO)
if (data_mat <= data_scad) {
if (-importo_maturato > importo_pagato)
importo_maturato = -importo_pagato;
}
if (importo_maturato >= ZERO)
{ {
real provvigione_maturata = provvigione_rata * importo_maturato / importo_rata;
provvigione_maturata.round(2);
rec.put(PROV_PAGMAT, importo_maturato);
rec.put(PROV_PROVVMAT, provvigione_maturata);
changed_record = true; changed_record = true;
rec.put(PROV_PAGMAT, importo_rata);
rec.put(PROV_PROVVMAT, provvigione_rata);
} }
} }
}
if (changed_record) else
{
const TDate data_mat = rec.get_date(PROV_DATASCAD);
if (data_mat <= data_scad)
{ {
TLocalisamfile provv(LF_PROVV); changed_record = true;
provv.curr() = rec; rec.put(PROV_PAGMAT, importo_rata);
int err = provv.read(_isequal, _lock); rec.put(PROV_PROVVMAT, provvigione_rata);
if (err == NOERR)
err = rec.rewrite(provv);
if (err != NOERR)
return yesno_box("Errore %d nell' aggioramento agente %ld, Continuare ugualmente", err, rec.get_long(PROV_CODAGE));
} }
} }
if (changed_record)
{
TLocalisamfile provv(LF_PROVV);
provv.curr() = rec;
int err = provv.read(_isequal, _lock);
if (err == NOERR)
err = rec.rewrite(provv);
if (err != NOERR)
return yesno_box(FR("Errore %d in aggioramento agente %ld, Continuare ugualmente"), err, rec.get_long(PROV_CODAGE));
}
} }
} }
return true;
return true;
} }
void TAggiornamento_maturato_app::aggiorna_maturato(TAggiornamento_maturato_mask &m) void TAggiornamento_maturato_app::aggiorna_maturato(const TAggiornamento_maturato_mask &m)
{ {
TCursor c(new TRelation(LF_PROVV), "(ANNO!=\"\")&&(CODNUM!=\"\")&&(NDOC!=\"\")&&(SALDATA!=\"X\")"); const bool check_insoluti = m.get_bool(F_CHECK_INSOLUTI);
TRectype from(LF_PROVV);
TRectype to(LF_PROVV);
const TString16 da_cod(m.get(F_DA_CODAGE));
const TString16 a_cod(m.get(F_A_CODAGE));
if (da_cod > 0) TString filter = "(ANNO!=\"\")&&(CODNUM!=\"\")&&(NDOC!=\"\")";
from.put(PROV_CODAGE, da_cod); if (!check_insoluti)
if (a_cod > 0) filter << "&&(SALDATA!=\"X\")";
to.put(PROV_CODAGE, a_cod);
TRectype from(LF_PROVV), to(LF_PROVV);
from.put(PROV_CODAGE, m.get(F_DA_CODAGE));
to.put(PROV_CODAGE, m.get(F_A_CODAGE));
TRelation rel(LF_PROVV);
TCursor c(&rel, filter, 1, &from, &to);
c.setregion(from, to); c.setregion(from, to);
c.set_filterfunction(filter_func); c.scan(scan_func, (void*)&m, TR("Aggiornamento provvigioni maturate"));
c.scan(scan_func, &m, TR("Aggiornamento provvigioni maturate"));
} }
void TAggiornamento_maturato_app::main_loop() void TAggiornamento_maturato_app::main_loop()

1
pr/pr0800a.h
View File

@ -6,3 +6,4 @@
#define F_A_RAGSOC 204 #define F_A_RAGSOC 204
#define F_DATA_SCAD 205 #define F_DATA_SCAD 205
#define F_GIORNI_RISCHIO 206 #define F_GIORNI_RISCHIO 206
#define F_CHECK_INSOLUTI 207

16
pr/pr0800a.uml
View File

@ -5,9 +5,10 @@ TOOLBAR "" 0 0 0 2
ENDPAGE ENDPAGE
PAGE "Aggiornamento Maturato" 0 2 0 0 PAGE "Aggiornamento Maturato" 0 2 0 0
GROUPBOX DLG_NULL 80 6 GROUPBOX DLG_NULL 80 6
BEGIN BEGIN
PROMPT 1 1 "Agente" PROMPT 1 1 "Selezione agenti"
FLAGS "R" FLAGS "R"
END END
@ -61,6 +62,12 @@ BEGIN
ADD RUN PR0 -4 ADD RUN PR0 -4
END END
GROUPBOX DLG_NULL 80 5
BEGIN
PROMPT 1 7 "Parametri"
FLAGS "R"
END
DATE F_DATA_SCAD DATE F_DATA_SCAD
BEGIN BEGIN
PROMPT 2 8 "Data scadenza " PROMPT 2 8 "Data scadenza "
@ -69,7 +76,12 @@ END
NUMBER F_GIORNI_RISCHIO 2 NUMBER F_GIORNI_RISCHIO 2
BEGIN BEGIN
PROMPT 2 10 "Giorni rischio " PROMPT 2 9 "Giorni rischio "
END
BOOLEAN F_CHECK_INSOLUTI
BEGIN
PROMPT 2 10 "Controllo insoluti registrati dopo il pagamento delle provvigioni"
END END
TEXT DLG_NULL TEXT DLG_NULL

16
pr/pr1.cpp
View File

@ -7,18 +7,12 @@ int main(int argc,char** argv)
const int n = argc > 1 ? argv[1][1]-'0' : 0; const int n = argc > 1 ? argv[1][1]-'0' : 0;
switch (n) switch (n)
{ {
case 1: case 1: pr1200(argc,argv); break; // stampa archivio percentuali di provvigione
pr1200(argc,argv); break; // stampa archivio percentuali di provvigione case 2: pr1300(argc,argv); break; // stampa schede di provvigione
case 2: case 3: pr1400(argc,argv); break; // stampa statistiche
pr1300(argc,argv); break; // stampa schede di provvigione case 4: pr1500(argc,argv); break; // stampa versamenti
case 3: default: pr1100(argc,argv); break; // stampa agenti
pr1400(argc,argv); break; // stampa statistiche
case 4:
pr1500(argc,argv); break; // stampa versamenti
default:
pr1100(argc,argv); break; // stampa agenti
} }
exit(0);
return 0; return 0;
} }

13
pr/pr1300.cpp
View File

@ -125,11 +125,10 @@ bool TStampa_schedeprovv::destroy()
void TStampa_schedeprovv::riporta_pagamenti(TCursor &cur) void TStampa_schedeprovv::riporta_pagamenti(TCursor &cur)
{ {
if (cur.items()==0) return;
const TRelation * r = cur.relation(); const TRelation * r = cur.relation();
TLocalisamfile& prov = r->lfile(); TLocalisamfile& prov = r->lfile();
TProgind barra(cur.items(),TR("Registro le provvigioni pagate")); TProgind barra(cur.items(),TR("Registro le provvigioni pagate"));
for (int c=0; c<cur.items(); c++) for (int c=0; c < cur.items(); c++)
{ {
cur=c; cur=c;
barra.setstatus(c); barra.setstatus(c);
@ -137,8 +136,8 @@ void TStampa_schedeprovv::riporta_pagamenti(TCursor &cur)
real provv_pag, pag_pag; real provv_pag, pag_pag;
provv_pag = prov.get_real(PROV_PROVVMAT); provv_pag = prov.get_real(PROV_PROVVMAT);
pag_pag = prov.get_real(PROV_PAGMAT); pag_pag = prov.get_real(PROV_PAGMAT);
if (!provv_pag.is_zero() && if (!provv_pag.is_zero()
!prov.get_bool(PROV_SALDATA)) // this should never happen! && !prov.get_bool(PROV_SALDATA)) // this should never happen!
{ {
prov.reread(_lock); prov.reread(_lock);
provv_pag += prov.get_real(PROV_PROVVPAG); provv_pag += prov.get_real(PROV_PROVVPAG);
@ -149,6 +148,12 @@ void TStampa_schedeprovv::riporta_pagamenti(TCursor &cur)
prov.put(PROV_PAGMAT,0); prov.put(PROV_PAGMAT,0);
if (provv_pag>=prov.get_real(PROV_IMPPROVV)) if (provv_pag>=prov.get_real(PROV_IMPPROVV))
prov.put(PROV_SALDATA,"X"); prov.put(PROV_SALDATA,"X");
if (prov.curr().exist(PROV_DATASTAMPA))
{
const TDate oggi = _m->get(F_ADATA);
if (oggi.ok())
prov.put(PROV_DATASTAMPA, oggi);
}
prov.rewrite(); prov.rewrite();
} }
} }

1
pr/provv.h
View File

@ -27,6 +27,7 @@
#define PROV_PAGMAT "PAGMAT" #define PROV_PAGMAT "PAGMAT"
#define PROV_PROVVMAT "PROVVMAT" #define PROV_PROVVMAT "PROVVMAT"
#define PROV_TIPOPAGPR "TIPOPAGPR" #define PROV_TIPOPAGPR "TIPOPAGPR"
#define PROV_DATASTAMPA "DATASTAMPA"
#endif #endif