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

Patch level :10.0

Browse Source 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :riporto gestione ripartizioni interattive per conversione


git-svn-id: svn://10.65.10.50/trunk@17147 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
luca 2008-09-01 15:36:24 +00:00
parent 5a12bb43ba
commit d12d45d52e
11 changed files with 324 additions and 465 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
ca/ca0800.cpp
View File

@ -80,24 +80,6 @@ bool TRiparti_msk::on_field_event(TOperable_field& o, TField_event e, long jolly
return error_box(TR("Il totale delle percentuali di riparto deve essere 100")); return error_box(TR("Il totale delle percentuali di riparto deve essere 100"));
} }
break; break;
case F_SHEET:
if (e == fe_init)
{
TSheet_field& sf = sfield(F_SHEET);
TMask& sm = sf.sheet_mask();
const bool on = get(F_TIPO)[0] != 'C';
for (short id = 202; id < 214; id++)
{
if (sm.id2pos(id) > 0)
{
sf.enable_column(id, on);
sm.enable(id, on);
}
if (sm.id2pos(id+50) > 0)
sm.enable(id+50, on);
}
}
break;
case F_GENFASI: case F_GENFASI:
if (e == fe_init) if (e == fe_init)
{ {

29
ca/ca0800a.h
View File

@ -1,19 +1,24 @@
#define F_TIPO 101 #define F_TIPO 101
#define F_CODICE_I 102 #define F_CODICE_I 102
#define F_CODICE_B 103 #define F_CODICE_B 103
#define F_DESCRIZ_I 104 //le define commentate per ora non servono ma in futuro forse si (segnaposto)
#define F_DESCRIZ_B 105 //#define F_CODICE_P 104
#define F_TIPORIP 106 //#define F_CODICE_C 105
#define F_LEVEL_1 107 #define F_DESCRIZ_I 106
#define F_LEVEL_2 108 #define F_DESCRIZ_B 107
//#define F_DESCRIZ_P 108
//#define F_DESCRIZ_C 109
#define F_TIPORIP 110
#define F_LEVEL_1 111
#define F_LEVEL_2 112
#define F_GRUPPO 111 #define F_GRUPPO 113
#define F_CONTO 112 #define F_CONTO 114
#define F_SOTTOCONTO 113 #define F_SOTTOCONTO 115
#define F_DESCR 114 #define F_DESCR 116
#define F_ANNOES 115 #define F_ANNOES 117
#define F_INDBIL 116 #define F_INDBIL 118
#define F_CLASSEMOV 117 #define F_CLASSEMOV 119
#define F_CODCDC_1 121 #define F_CODCDC_1 121
#define F_CODCDC_2 122 #define F_CODCDC_2 122

6
ca/ca0800a.uml
View File

@ -18,10 +18,10 @@ BEGIN
FLAGS "ZP" FLAGS "ZP"
ITEM "I|Interattiva" ITEM "I|Interattiva"
MESSAGE SHOW,1@|HIDE,2@ MESSAGE SHOW,1@|HIDE,2@
ITEM "C|Conversione"
MESSAGE SHOW,1@|HIDE,2@
ITEM "B|Batch" ITEM "B|Batch"
MESSAGE SHOW,2@|HIDE,1@ MESSAGE SHOW,2@|HIDE,1@
ITEM "P|Pareggio"
MESSAGE SHOW,1@|HIDE,2@
FIELD TIPO FIELD TIPO
KEY 1 KEY 1
END END
@ -56,8 +56,8 @@ BEGIN
DISPLAY "Codice@8 " CODICE DISPLAY "Codice@8 " CODICE
DISPLAY "Costo@20" CODCOSTO DISPLAY "Costo@20" CODCOSTO
DISPLAY "Commessa@20" CODCMS DISPLAY "Commessa@20" CODCMS
DISPLAY "Fase@10" CODFASE
DISPLAY "Descrizione@50" DESCRIZ DISPLAY "Descrizione@50" DESCRIZ
DISPLAY "Fase@10" CODFASE
OUTPUT F_CODICE_B CODICE OUTPUT F_CODICE_B CODICE
OUTPUT F_DESCRIZ_B DESCRIZ OUTPUT F_DESCRIZ_B DESCRIZ
CHECKTYPE REQUIRED CHECKTYPE REQUIRED

278
ca/ca2200.cpp
View File

@ -24,63 +24,10 @@ class TRib_movanal_msk : public TAnal_report_mask
protected: protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
void save_to_ini();
void load_from_ini();
public: public:
TRib_movanal_msk(); TRib_movanal_msk();
}; };
void TRib_movanal_msk::save_to_ini()
{
TConfig ini(CONFIG_DITTA, "ca");
// Cancella tutte le variabili di pareggio
int j;
for (j = 1; ini.remove("Pareggio", j); j++);
TSheet_field& sf = sfield(F_RIGHE);
const int idx = sf.cid2index(F_CODCAUS);
// Salva tutte le righe dello sheet nel formato
// Pareggio(1) = Causale|Costo|Commessa|Fase
j = 0;
FOR_EACH_SHEET_ROW(sf, i, row)
{
TToken_string par = row->get(idx); // Codice causale
if (!par.blank())
{
TAnal_bill bill;
const int flags = get_row_bill(sf, i, bill);
if (flags != 0)
{
if (flags & 1) par.add(bill.costo(), 1);
if (flags & 2) par.add(bill.commessa(), 2);
if (flags & 4) par.add(bill.fase(), 3);
ini.set("Pareggio", par, NULL, true, ++j);
}
}
}
}
void TRib_movanal_msk::load_from_ini()
{
// Svuota lo sheet
TSheet_field& sf = sfield(F_RIGHE);
sf.destroy();
// Carica tutte le variabili di pareggio nello sheet
TConfig ini(CONFIG_DITTA, "ca");
TToken_string par;
for (int j = 1; ; j++)
{
par = ini.get("Pareggio", NULL, j);
if (par.empty_items())
break;
const TAnal_bill bill("", par.get(1), par.get(2), par.get(3));
set_row_bill(sf, -1, bill);
}
}
bool TRib_movanal_msk::on_field_event(TOperable_field& o, TField_event e, long jolly) bool TRib_movanal_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{ {
@ -98,11 +45,7 @@ bool TRib_movanal_msk::on_field_event(TOperable_field& o, TField_event e, long j
return error_box(TR("La data deve appartenere all'anno selezionato")); return error_box(TR("La data deve appartenere all'anno selezionato"));
} }
break; break;
case DLG_OK:
case DLG_SAVEREC:
if (e == fe_button)
save_to_ini();
break;
default: default:
break; break;
} }
@ -111,8 +54,6 @@ bool TRib_movanal_msk::on_field_event(TOperable_field& o, TField_event e, long j
TRib_movanal_msk::TRib_movanal_msk() : TAnal_report_mask("ca2200a") TRib_movanal_msk::TRib_movanal_msk() : TAnal_report_mask("ca2200a")
{ {
create_sheet(F_RIGHE);
load_from_ini();
} }
//-------------------------------------------------------------------- //--------------------------------------------------------------------
@ -122,131 +63,145 @@ class TRib_movanal_app : public TSkeleton_application
{ {
TCache_ripartizioni _cache_rip; TCache_ripartizioni _cache_rip;
bool _definitivo; bool _definitivo;
TAssoc_array _caus_cms;
virtual const char* extra_modules() const { return "cm"; } //deve funzionare anche per le commesse virtual const char* extra_modules() const { return "cm"; } //deve funzionare anche per le commesse
protected: protected:
virtual void main_loop(); virtual void main_loop();
bool explode_rows(const TRecord_array& input_rows, TRecord_array& output_rows, const int annoes, bool elabora_righe(TAnal_mov& anal_mov, const TRecord_array& input_rows, TRecord_array& output_rows);
const char tipomov); bool ripartizione(const TAnal_ripartizioni_batch& rrip, const TRectype& rec, TRecord_array& output_rows);
bool pareggia_commessa(TAnal_mov& anal_mov); bool pareggio(TAnal_mov& anal_mov, const TAnal_ripartizioni_batch& rrip, const TRectype& rec, TRecord_array& output_rows);
public: public:
bool elabora_movimento(TAnal_mov& anal_mov, const bool esplodi); bool elabora_movimento(TAnal_mov& anal_mov, const bool esplodi);
TRib_movanal_app(){} TRib_movanal_app(){}
}; };
bool TRib_movanal_app::explode_rows(const TRecord_array& input_rows, TRecord_array& output_rows,
const int annoes, const char tipomov) bool TRib_movanal_app::pareggio(TAnal_mov& anal_mov, const TAnal_ripartizioni_batch& rrip, const TRectype& rec,
TRecord_array& output_rows)
{
bool ho_pareggiato = false;
TImporto totdoc(anal_mov.get_char(MOVANA_SEZIONE), anal_mov.get_real(MOVANA_TOTDOC));
const TImporto imp_riga(rec.get_char(RMOVANA_SEZIONE), rec.get_real(RMOVANA_IMPORTO));
totdoc -= imp_riga;
totdoc.normalize();
anal_mov.put(MOVANA_TOTDOC, totdoc.valore());
anal_mov.put(MOVANA_SEZIONE, totdoc.sezione());
//aggiunge la riga originale alle righe di output (e' un pareggio)
const int original_nriga = output_rows.rows() + 1;
TRectype* newrec = new TRectype(rec);
newrec->put(RMOVANA_NUMRIG, original_nriga);
output_rows.add_row(newrec);
//swappa la sezione e la manda al ripartitore in modo da generare righe con la sezione rovesciata rispetto a quella..
//..originale ed ottenere cosi' il pareggio
TRectype swaprec(rec);
swaprec.put(RMOVANA_SEZIONE, imp_riga.sezione() == 'D' ? 'A' : 'D');
ho_pareggiato = ripartizione(rrip, swaprec, output_rows);
//elimina il codcontoori da tutte le righe aggiunte per il pareggio
for (int i = output_rows.rows(); i > original_nriga; i--)
output_rows.row(i, false).zero(RMOVANA_CODCONTORI);
return ho_pareggiato;
}
bool TRib_movanal_app::ripartizione(const TAnal_ripartizioni_batch& rrip, const TRectype& rec, TRecord_array& output_rows)
{
bool ho_ripartito = false;
// Importo totale da distribuire arrotondato ai decimali della valuta di conto
TGeneric_distrib distrib(rec.get_real(RMOVANA_IMPORTO), TCurrency::get_firm_dec());
// Calcolo tutte le percentuali da ripartire
int i;
const int righe_ripartizione = rrip.rows();
for (i = 1; i <= rrip.rows(); i++)
distrib.add(rrip[i].get_real(RRIP_RIPARTO));
for (i = 1; i <= righe_ripartizione; i++)
{
const real imp = distrib.get(); // Legge la quota da distribuire
if (imp != ZERO)
{
TRectype* newrec = new TRectype(rec);
newrec->put(RMOVANA_NUMRIG, output_rows.rows() + 1);
newrec->put(RMOVANA_IMPORTO, imp); //e la mette nella nuova riga
//poi copia i valori dei campi cdc,cms,fsc,in quelli di tipo ori (nello stesso record)
ca_copia_campo(rec, RMOVANA_CODCCOSTO, *newrec, RMOVANA_CODCCORI);
ca_copia_campo(rec, RMOVANA_CODCMS, *newrec, RMOVANA_CODCMSORI);
ca_copia_campo(rec, RMOVANA_CODFASE, *newrec, RMOVANA_CODFASEORI);
ca_copia_campo(rec, RMOVANA_CODCONTO, *newrec, RMOVANA_CODCONTORI);
//e mette nei campi std i valori che trova nelle righe ripartizione
ca_copia_campo(rrip[i], RRIP_CODCOSTO, *newrec, RMOVANA_CODCCOSTO);
ca_copia_campo(rrip[i], RRIP_CODCMS, *newrec, RMOVANA_CODCMS);
ca_copia_campo(rrip[i], RRIP_CODFASE, *newrec, RMOVANA_CODFASE);
ca_copia_campo(rrip[i], RRIP_CODCONTO, *newrec, RMOVANA_CODCONTO);
output_rows.add_row(newrec);
ho_ripartito = true;
} //if(imp!=ZERO)...
} //for(i=1;i<=righe_ripartizione...
return ho_ripartito;
}
bool TRib_movanal_app::elabora_righe(TAnal_mov& anal_mov, const TRecord_array& input_rows, TRecord_array& output_rows)
{ {
bool ho_cambiato_qualchecosa = false; bool ho_cambiato_qualchecosa = false;
const int annoes = anal_mov.get_int(MOVANA_ANNOES);
const char tipomov = anal_mov.get_char(MOVANA_TIPOMOV);
for (int r = 1; r <= input_rows.rows(); r++) for (int r = 1; r <= input_rows.rows(); r++)
{ {
const TRectype& rec = input_rows.row(r); const TRectype& rec = input_rows.row(r);
TAnal_bill zio(rec); TAnal_bill zio(rec);
const int rmovana_indbil = zio.indicatore_bilancio(); const int rmovana_indbil = zio.indicatore_bilancio();
const TAnal_ripartizioni_batch& rrip = _cache_rip.righe(rec.get(RMOVANA_CODCCOSTO), rec.get(RMOVANA_CODCMS),
rec.get(RMOVANA_CODFASE), annoes, rmovana_indbil, tipomov); //ripartizione batch: passa il conto perche' per prima cosa provera' una ripartizione di tipo 'P' con chiave 3; se non..
//..ci riuscira', provera' da solo (metodi della TCache_ripartizioni) le ripartizioni di tipo 'B' con chiave 4.
const TAnal_ripartizioni_batch& rrip = _cache_rip.righe(zio, annoes, rmovana_indbil, tipomov);
const char tiporip = rrip.tiporip();
//ci sono righe di ripartizione //ci sono righe di ripartizione
const int righe_ripartizione = rrip.rows(); const int righe_ripartizione = rrip.rows();
bool ripartisci = righe_ripartizione > 0; bool ripartisci = righe_ripartizione > 0;
//se ci sono righe di ripartizione/pareggio si va a ripartire!
if (ripartisci) if (ripartisci)
{ {
// Importo totale da distribuire arrotondato ai decimali della valuta di conto switch (tiporip)
TGeneric_distrib distrib(rec.get_real(RMOVANA_IMPORTO), TCurrency::get_firm_dec());
// Calcolo tutte le percentuali da ripartire
int i;
for (i = 1; i <= righe_ripartizione; i++)
distrib.add(rrip[i].get_real(RRIP_RIPARTO));
for (i = 1; i <= righe_ripartizione; i++)
{ {
const real imp = distrib.get(); // Legge la quota da distribuire //procedura di ripartizione batch 'B' originale; se tiporip=='P' invece ci vuole il pareggio del movana
case 'B':
if (imp != ZERO) ho_cambiato_qualchecosa = ripartizione(rrip, rec, output_rows);
{ break;
TRectype* newrec = new TRectype(rec); case 'P':
newrec->put(RMOVANA_NUMRIG, output_rows.rows() + 1); ho_cambiato_qualchecosa = pareggio(anal_mov, rrip, rec, output_rows);
newrec->put(RMOVANA_IMPORTO, imp); //e la mette nella nuova riga break;
//poi copia i valori dei campi cdc,cms,fsc,in quelli di tipo ori (nello stesso record) default:
ca_copia_campo(rec, RMOVANA_CODCCOSTO, *newrec, RMOVANA_CODCCORI); break;
ca_copia_campo(rec, RMOVANA_CODCMS, *newrec, RMOVANA_CODCMSORI);
ca_copia_campo(rec, RMOVANA_CODFASE, *newrec, RMOVANA_CODFASEORI);
ca_copia_campo(rec, RMOVANA_CODCONTO, *newrec, RMOVANA_CODCONTORI);
//e mette nei campi std i valori che trova nelle righe ripartizione
ca_copia_campo(rrip[i], RRIP_CODCOSTO, *newrec, RMOVANA_CODCCOSTO);
ca_copia_campo(rrip[i], RRIP_CODCMS, *newrec, RMOVANA_CODCMS);
ca_copia_campo(rrip[i], RRIP_CODFASE, *newrec, RMOVANA_CODFASE);
ca_copia_campo(rrip[i], RRIP_CODCONTO, *newrec, RMOVANA_CODCONTO);
output_rows.add_row(newrec);
ho_cambiato_qualchecosa = true;
}
} }
} }
else //nessuna riga di ripartizione->aggiungo la riga input all'output else //if(ripartisci... nessuna riga di ripartizione->aggiungo la riga input all'output
{ {
TRectype* newrec = new TRectype(rec); TRectype* newrec = new TRectype(rec);
newrec->put(RMOVANA_NUMRIG, output_rows.rows() + 1); newrec->put(RMOVANA_NUMRIG, output_rows.rows() + 1);
output_rows.add_row(newrec); output_rows.add_row(newrec);
} }
} } //for(int r=1; r<=input_rows.rows()...
return ho_cambiato_qualchecosa; return ho_cambiato_qualchecosa;
} }
bool TRib_movanal_app::pareggia_commessa(TAnal_mov& anal_mov)
{
bool ho_cambiato_qualchecosa = false;
const TString& codcaus = anal_mov.get(MOVANA_CODCAUS);
const TAnal_bill* cms = (const TAnal_bill*)_caus_cms.objptr(codcaus);
if (cms != NULL) // La causale del movimento e' tra quelle da pareggiare
{
const TImporto totdoc(anal_mov.get_char(MOVANA_SEZIONE), anal_mov.get_real(MOVANA_TOTDOC));
if (!totdoc.is_zero()) // Movimento da pareggiare
{
TRecord_array& body = anal_mov.body();
// Cerco la commessa/fase/costo tra le righe esistenti
int i;
for (i = body.last_row(); i > 0; i--)
{
const TRectype& row = body[i];
if ((cms->costo().blank() || row.get(RMOVANA_CODCCOSTO) == cms->costo()) &&
(cms->commessa().blank() || row.get(RMOVANA_CODCMS) == cms->commessa()) &&
(cms->fase().blank() || row.get(RMOVANA_CODFASE) == cms->fase()))
break;
}
// Se non trovo nessuna riga compatibile, me la creo
if (i <= 0)
{
TRectype& rmovana = anal_mov.new_row();
rmovana.put(RMOVANA_DESCR, TR("Pareggio commessa"));
rmovana.put(RMOVANA_CODCCOSTO, cms->costo());
rmovana.put(RMOVANA_CODCMS, cms->commessa());
rmovana.put(RMOVANA_CODFASE, cms->fase());
i = rmovana.get_int(RMOVANA_NUMRIG);
}
// Sottraggo all'importo della riga il totale documento,
// il quale verra' quindi azzerato
TRectype& rmovana = body[i];
TImporto importo(rmovana.get_char(RMOVANA_SEZIONE), rmovana.get_real(RMOVANA_IMPORTO));
importo -= totdoc;
importo.normalize();
rmovana.put(RMOVANA_SEZIONE, importo.sezione());
rmovana.put(RMOVANA_IMPORTO, importo.valore());
anal_mov.put(MOVANA_TOTDOC, ZERO);
ho_cambiato_qualchecosa = true;
}
}
return ho_cambiato_qualchecosa;
}
bool TRib_movanal_app::elabora_movimento(TAnal_mov& anal_mov, const bool esplodi) bool TRib_movanal_app::elabora_movimento(TAnal_mov& anal_mov, const bool esplodi)
{ {
@ -266,13 +221,11 @@ bool TRib_movanal_app::elabora_movimento(TAnal_mov& anal_mov, const bool esplodi
output_rows.destroy_rows(); //..e poi lo pulisce output_rows.destroy_rows(); //..e poi lo pulisce
//Esploditore //Esploditore
if (explode_rows(compact_rows, output_rows, anal_mov.get_int(MOVANA_ANNOES), anal_mov.get_char(MOVANA_TIPOMOV))) if (elabora_righe(anal_mov, compact_rows, output_rows))
{ {
input_rows = output_rows; //rimette i record elaborati negli originali input_rows = output_rows; //rimette i record elaborati negli originali
do_rewrite = true; do_rewrite = true;
} }
if (pareggia_commessa(anal_mov))
do_rewrite = true;
if (_definitivo) //se l'elaborazione e' definitiva... if (_definitivo) //se l'elaborazione e' definitiva...
{ {
@ -285,8 +238,12 @@ bool TRib_movanal_app::elabora_movimento(TAnal_mov& anal_mov, const bool esplodi
//Imploditore //Imploditore
do_rewrite = ca_implode_rows(input_rows, compact_rows); do_rewrite = ca_implode_rows(input_rows, compact_rows);
if (do_rewrite) if (do_rewrite)
{
input_rows = compact_rows; // rimette i record compattati negli originali input_rows = compact_rows; // rimette i record compattati negli originali
anal_mov.update_totdoc(); //aggiorna il totale movana (necessarip per ripartizioni a pareggio, di sicurezza per le altre)
}
} }
return do_rewrite; //se ha elaborato delle righe e/o e' una elaborazione definitiva, riscrive la.. return do_rewrite; //se ha elaborato delle righe e/o e' una elaborazione definitiva, riscrive la..
} }
@ -348,23 +305,6 @@ void TRib_movanal_app::main_loop()
//Presa la decisione si parte! Tenetevi forte... //Presa la decisione si parte! Tenetevi forte...
if (run) if (run)
{ {
// Riempie la lista della causali dei movimenti da pareggiare
_caus_cms.destroy();
TSheet_field& sf = mask.sfield(F_RIGHE);
const int pos_codcaus = sf.cid2index(F_CODCAUS);
FOR_EACH_SHEET_ROW(sf, i, row)
{
const TString4 codcaus = row->get(pos_codcaus);
if (codcaus.full())
{
TAnal_bill* bill = new TAnal_bill;
if (mask.get_row_bill(sf, i, *bill) != 0)
_caus_cms.add(codcaus, bill);
else
delete bill;
}
}
if (compattazione) if (compattazione)
cur_movana.scan(compatta_callback, this, TR("Compattamento movimenti...")); cur_movana.scan(compatta_callback, this, TR("Compattamento movimenti..."));
else else

1
ca/ca2200a.h
View File

@ -5,7 +5,6 @@
#define F_DEFINITIVO 203 #define F_DEFINITIVO 203
#define F_ANNO 204 #define F_ANNO 204
#define F_COMPATTA 205 #define F_COMPATTA 205
#define F_RIGHE 300
//Devono valere un numero piu' alto di S_CDC12 (che attualmente e' 112) senno' non nascono in fila nello.. //Devono valere un numero piu' alto di S_CDC12 (che attualmente e' 112) senno' non nascono in fila nello..
//..sheet //..sheet
#define F_CODCAUS 113 #define F_CODCAUS 113

156
ca/ca2200a.uml
View File

@ -83,162 +83,6 @@ BEGIN
PROMPT 2 7 "Blocca movimenti elaborati (DEFINITIVO e vale solo per ripartizione)" PROMPT 2 7 "Blocca movimenti elaborati (DEFINITIVO e vale solo per ripartizione)"
END END
TEXT -1
BEGIN
PROMPT 1 9 "@bCommesse/CdC da pareggiare"
END
SPREADSHEET F_RIGHE -1 -1
BEGIN
PROMPT 1 10 ""
ITEM "Cms 1"
ITEM "Cms 2"
ITEM "Cms 3"
ITEM "Cms 4"
ITEM "Cms 5"
ITEM "Cms 6"
ITEM "Cms 7"
ITEM "Cms 8"
ITEM "Cms 9"
ITEM "Cms 10"
ITEM "Cms 11"
ITEM "Cms 12"
ITEM "Causale"
ITEM "Descrizione@50"
END
ENDPAGE
ENDMASK
PAGE "Riga Commesse/CdC da pareggiare" -1 -1 78 15
STRING F_CODCAUS 3
BEGIN
PROMPT 1 0 "Causale "
USE LF_CAUSALI SELECT MOVIND!=""
INPUT CODCAUS F_CODCAUS
DISPLAY "Codice" CODCAUS
DISPLAY "Descrizione@50" DESCR
OUTPUT F_CODCAUS CODCAUS
OUTPUT F_DESCAUS DESCR
CHECKTYPE NORMAL
ADD RUN cg0 -4
FLAGS "U"
END
STRING F_DESCAUS 50
BEGIN
PROMPT 23 0 ""
USE LF_CAUSALI KEY 2 SELECT MOVIND!=""
INPUT DESCR F_DESCAUS
DISPLAY "Descrizione@50" DESCR
DISPLAY "Codice" CODCAUS
COPY OUTPUT F_CODCAUS
ADD RUN cg0 -4
END
//Non cancellare GROUP 1 dai 12 campi successivi, pena la comparsa di campi inutili e perniciosi nella
//maschera di riga
STRING S_CDC1 20
BEGIN
PROMPT 1 2 "Cms1 "
FLAGS "B"
GROUP 1
END
STRING S_CDC2 20
BEGIN
PROMPT 1 3 "Cms2 "
FLAGS "B"
GROUP 1
END
STRING S_CDC3 20
BEGIN
PROMPT 1 4 "Cms3 "
FLAGS "B"
GROUP 1
END
STRING S_CDC4 20
BEGIN
PROMPT 1 5 "Cms4 "
FLAGS "B"
GROUP 1
END
STRING S_CDC5 20
BEGIN
PROMPT 1 6 "Cms5 "
FLAGS "B"
GROUP 1
END
STRING S_CDC6 20
BEGIN
PROMPT 1 7 "Cms6 "
FLAGS "B"
GROUP 1
END
STRING S_CDC7 20
BEGIN
PROMPT 1 8 "Cms7 "
FLAGS "B"
GROUP 1
END
STRING S_CDC8 20
BEGIN
PROMPT 1 9 "Cms8 "
FLAGS "B"
GROUP 1
END
STRING S_CDC9 20
BEGIN
PROMPT 1 10 "Cms9 "
FLAGS "B"
GROUP 1
END
STRING S_CDC10 20
BEGIN
PROMPT 1 11 "Cms10 "
FLAGS "B"
GROUP 1
END
STRING S_CDC11 20
BEGIN
PROMPT 1 12 "Cms11 "
FLAGS "B"
GROUP 1
END
STRING S_CDC12 20
BEGIN
PROMPT 1 13 "Cms12 "
FLAGS "B"
GROUP 1
END
BUTTON DLG_OK 10 2
BEGIN
PROMPT -13 -1 ""
END
BUTTON DLG_DELREC 10 2
BEGIN
PROMPT -23 -1 ""
END
BUTTON DLG_CANCEL 10 2
BEGIN
PROMPT -33 -1 ""
END
ENDPAGE ENDPAGE
ENDMASK ENDMASK

111
ca/cacnv.cpp
View File

@ -471,72 +471,73 @@ void TConversione_cm2ca::create_new_movana(long numreg_cg, bool definitiva, TAss
//Per prima cosa crea l'array delle righe di ripartizione con questo gr/co/stc/annoes //Per prima cosa crea l'array delle righe di ripartizione con questo gr/co/stc/annoes
const int annoes = mov_head.get_int(MOV_ANNOES); const int annoes = mov_head.get_int(MOV_ANNOES);
if (ca_config().get_bool("UsePdcc")) //solo se in CA si usa il piano dei conti contabile.. const TAnal_ripartizioni_batch& rrip = _cache_rip.righe_interattive(zio, annoes);
{ //..e' possibile costruire la riga movimento
//Compila la riga del movimentodi analitica
TRectype& analriga = analmov.new_row();
analriga.put(RMOVANA_SEZIONE, importo.sezione()); const int righe_ripartizione = rrip.rows();
analriga.put(RMOVANA_IMPORTO, importo.valore()); const bool ripartisci = righe_ripartizione > 0;
analriga.put(RMOVANA_DESCR, importo.descrizione());
analriga.put(RMOVANA_ANNOES, analmov.get(MOVANA_ANNOES)); if (ripartisci) //ci sono righe ripartizione: da 1 riga mov CG a N righe mov CA
analriga.put(RMOVANA_DATACOMP, analmov.get(MOVANA_DATAREG)); {
// Importo totale da distribuire arrotondato ai decimali della valuta di conto
TGeneric_distrib distrib(importo.valore(), TCurrency::get_firm_dec());
analriga.put(RMOVANA_CODCMS, chiave.get(0)); // Calcola tutte le percentuali da ripartire
analriga.put(RMOVANA_CODFASE, chiave.get(1)); int i;
for (i = 1; i <= rrip.rows(); i++)
distrib.add(rrip[i].get_real(RRIP_RIPARTO));
TString16 codconto; //Compila le righe del movimento di analitica in base alle righe ripartizione
codconto.format("%03d%03d%06ld", gruppo, conto, sottoconto); for (i = 1; i <= rrip.rows(); i++)
analriga.put(RMOVANA_CODCONTO, codconto); {
const TRectype& riga_rip = rrip.row(i);
//controlla la coppia fase/(cdc-commessa) e decide se aggiungerla al file delle fasi TRectype& analriga = analmov.new_row();
check_phase(analriga); const real imp = distrib.get(); // Legge la quota da distribuire
analriga.put(RMOVANA_SEZIONE, importo.sezione());
analriga.put(RMOVANA_IMPORTO, imp); //e la mette nella nuova riga
analriga.put(RMOVANA_DESCR, importo.descrizione());
analriga.put(RMOVANA_ANNOES, analmov.get(MOVANA_ANNOES));
analriga.put(RMOVANA_DATACOMP, analmov.get(MOVANA_DATAREG));
//parametri da prendere dalle righe ripartizione!!
analriga.put(RMOVANA_CODCCOSTO, riga_rip.get(RRIP_CODCOSTO));
analriga.put(RMOVANA_CODCMS, riga_rip.get(RRIP_CODCMS));
analriga.put(RMOVANA_CODFASE, riga_rip.get(RRIP_CODFASE));
analriga.put(RMOVANA_CODCONTO, riga_rip.get(RRIP_CODCONTO));
//controlla la coppia fase/(cdc-commessa) e decide se aggiungerla al file delle fasi
check_phase(analriga);
}
} }
else else //nessuna riga ripartizione -> da 1 riga movimento CG ad 1 riga movimento CA
{ {
const TAnal_ripartizioni_batch& rrip = _cache_rip.righe(zio, annoes, ' ', 'I'); if (ca_config().get_bool("UsePdcc")) //solo se in CA si usa il piano dei conti contabile..
{ //..e' possibile costruire la riga movimento
//Compila la riga del movimentodi analitica
TRectype& analriga = analmov.new_row();
const int righe_ripartizione = rrip.rows(); analriga.put(RMOVANA_SEZIONE, importo.sezione());
const bool ripartisci = righe_ripartizione > 0; analriga.put(RMOVANA_IMPORTO, importo.valore());
analriga.put(RMOVANA_DESCR, importo.descrizione());
if (ripartisci) //ci sono righe ripartizione: da 1 riga mov CG a N righe mov CA analriga.put(RMOVANA_ANNOES, analmov.get(MOVANA_ANNOES));
{ analriga.put(RMOVANA_DATACOMP, analmov.get(MOVANA_DATAREG));
// Importo totale da distribuire arrotondato ai decimali della valuta di conto
TGeneric_distrib distrib(importo.valore(), TCurrency::get_firm_dec());
// Calcola tutte le percentuali da ripartire analriga.put(RMOVANA_CODCMS, chiave.get(0));
int i; analriga.put(RMOVANA_CODFASE, chiave.get(1));
for (i = 1; i <= rrip.rows(); i++)
distrib.add(rrip[i].get_real(RRIP_RIPARTO));
//Compila le righe del movimento di analitica in base alle righe ripartizione TString16 codconto;
for (i = 1; i <= rrip.rows(); i++) codconto.format("%03d%03d%06ld", gruppo, conto, sottoconto);
{ analriga.put(RMOVANA_CODCONTO, codconto);
const TRectype& riga_rip = rrip.row(i);
TRectype& analriga = analmov.new_row(); //controlla la coppia fase/(cdc-commessa) e decide se aggiungerla al file delle fasi
const real imp = distrib.get(); // Legge la quota da distribuire check_phase(analriga);
analriga.put(RMOVANA_SEZIONE, importo.sezione()); }
analriga.put(RMOVANA_IMPORTO, imp); //e la mette nella nuova riga else //qui va aggiunta la lista dei conti che non hanno ripartizione quando NON si usa il..
analriga.put(RMOVANA_DESCR, importo.descrizione()); //..piano dei conti contabile in analitica
error_box(TR("Manca la ripartizione di un conto"));
analriga.put(RMOVANA_ANNOES, analmov.get(MOVANA_ANNOES)); }
analriga.put(RMOVANA_DATACOMP, analmov.get(MOVANA_DATAREG));
//parametri da prendere dalle righe ripartizione!!
analriga.put(RMOVANA_CODCCOSTO, riga_rip.get(RRIP_CODCOSTO));
analriga.put(RMOVANA_CODCMS, riga_rip.get(RRIP_CODCMS));
analriga.put(RMOVANA_CODFASE, riga_rip.get(RRIP_CODFASE));
analriga.put(RMOVANA_CODCONTO, riga_rip.get(RRIP_CODCONTO));
//controlla la coppia fase/(cdc-commessa) e decide se aggiungerla al file delle fasi
check_phase(analriga);
}
}
else
error_box(TR("Manca la ripartizione di conversione del conto : %d %d %ld"), zio.gruppo(), zio.conto(), zio.sottoconto());
}
} //end FOR_EACH.. } //end FOR_EACH..
//e alla fine riesce a mettere anche l'importone in testata //e alla fine riesce a mettere anche l'importone in testata

160
ca/calib01.cpp
View File

@ -1521,6 +1521,21 @@ void TAnal_mov::zero(char c)
kill_saldi(); kill_saldi();
} }
void TAnal_mov::update_totdoc()
{
TImporto totdoc;
for (int i = rows(); i > 0; i--)
{
const TRectype& riga = body().row(i);
TImporto imp_riga(riga.get_char(RMOVANA_SEZIONE), riga.get_real(RMOVANA_IMPORTO));
totdoc += imp_riga;
}
totdoc.normalize();
put(MOVANA_TOTDOC, totdoc.valore());
put(MOVANA_SEZIONE, totdoc.sezione());
}
TAnal_mov::TAnal_mov(long numreg) : TMultiple_rectype(LF_MOVANA) TAnal_mov::TAnal_mov(long numreg) : TMultiple_rectype(LF_MOVANA)
{ {
add_file(LF_RMOVANA, RMOVANA_NUMRIG); add_file(LF_RMOVANA, RMOVANA_NUMRIG);
@ -1564,7 +1579,12 @@ int TAnal_ripartizioni_batch::indbil() const
return head().get_int(RIP_INDBIL); return head().get_int(RIP_INDBIL);
} }
int TAnal_ripartizioni_batch::read (const char* codice, char tiporip) char TAnal_ripartizioni_batch::tiporip() const
{
return head().get_char(RIP_TIPO);
}
int TAnal_ripartizioni_batch::read (const char tiporip, const char* codice)
{ {
TLocalisamfile rip(LF_RIP); TLocalisamfile rip(LF_RIP);
_rip.put(RIP_TIPO, tiporip); //solo tipi batch! _rip.put(RIP_TIPO, tiporip); //solo tipi batch!
@ -1573,7 +1593,7 @@ int TAnal_ripartizioni_batch::read (const char* codice, char tiporip)
if (err == NOERR) if (err == NOERR)
{ {
TRectype rrip(LF_RRIP); TRectype rrip(LF_RRIP);
rrip.put(RRIP_TIPO, 'B'); rrip.put(RRIP_TIPO, tiporip);
rrip.put(RRIP_CODICE, codice); rrip.put(RRIP_CODICE, codice);
TRecord_array::read(rrip); TRecord_array::read(rrip);
} }
@ -1583,7 +1603,7 @@ int TAnal_ripartizioni_batch::read (const char* codice, char tiporip)
int TAnal_ripartizioni_batch::read_rip_4(TLocalisamfile& rip, const char* codcosto, const char* commessa, int TAnal_ripartizioni_batch::read_rip_4(TLocalisamfile& rip, const char* codcosto, const char* commessa,
const char* fase, const int annoes, const int indbil, const int classe_mov) const const char* fase, const int annoes, const int indbil, const int classe_mov) const
{ {
rip.put(RIP_TIPO, "B"); //solo tipi batch! rip.put(RIP_TIPO, "B"); //solo tipi batch, unici per chiave cdc/cms/fase
rip.put(RIP_CODCOSTO, codcosto); rip.put(RIP_CODCOSTO, codcosto);
rip.put(RIP_CODCMS, commessa); rip.put(RIP_CODCMS, commessa);
rip.put(RIP_CODFASE, fase); rip.put(RIP_CODFASE, fase);
@ -1628,14 +1648,14 @@ int TAnal_ripartizioni_batch::read (const char* codcosto, const char* commessa,
} }
if (err == NOERR) if (err == NOERR)
err = read(rip.get(RIP_CODICE), 'B'); err = read('B', rip.get(RIP_CODICE)); //per chiave 4 solo tipo B (batch)
return err; return err;
} }
int TAnal_ripartizioni_batch::read_rip_3(TLocalisamfile& rip, const int gr, const int co, const long sot, int TAnal_ripartizioni_batch::read_rip_3(TLocalisamfile& rip, const char tiporip, const int gr, const int co, const long sot,
const int annoes, const int indbil, const int classe_mov, char tiporip) const const int annoes, const int indbil, const int classe_mov) const
{ {
rip.put(RIP_TIPO, tiporip); //solo tipi batch! rip.put(RIP_TIPO, tiporip); //tipo 'P' oppure tipo 'I', che sono quelli che vanno per conto
rip.put(RIP_GRUPPO, gr); rip.put(RIP_GRUPPO, gr);
rip.put(RIP_CONTO, co); rip.put(RIP_CONTO, co);
rip.put(RIP_SOTTOCONTO, sot); rip.put(RIP_SOTTOCONTO, sot);
@ -1645,43 +1665,43 @@ int TAnal_ripartizioni_batch::read_rip_3(TLocalisamfile& rip, const int gr, cons
return rip.read(); return rip.read();
} }
int TAnal_ripartizioni_batch::read (const int gr, const int co, const long sot, int TAnal_ripartizioni_batch::read (const char tiporip, const int gr, const int co, const long sot,
const int annoes, const int indbil, const int classe_mov, char tiporip) const int annoes, const int indbil, const int classe_mov)
{ {
CHECKD(classe_mov > 0, "Classe movimento non valida ", classe_mov); CHECKD(classe_mov > 0, "Classe movimento non valida ", classe_mov);
TLocalisamfile rip(LF_RIP); TLocalisamfile rip(LF_RIP);
rip.setkey(3); rip.setkey(3);
int err = read_rip_3(rip, gr, co, sot, annoes, indbil, classe_mov, tiporip); int err = read_rip_3(rip, tiporip, gr, co, sot, annoes, indbil, classe_mov);
if (err != NOERR) if (err != NOERR)
err = read_rip_3(rip, gr, co, sot, annoes, indbil, 0, tiporip); err = read_rip_3(rip, tiporip, gr, co, sot, annoes, indbil, 0);
//la put va rifatta perche' potrebbe essersi spostato al record successivo!!! //la put va rifatta perche' potrebbe essersi spostato al record successivo!!!
//se fallisce il primo tentativo prova con lo stesso anno e indbil=0 //se fallisce il primo tentativo prova con lo stesso anno e indbil=0
if (err != NOERR && indbil != 0) if (err != NOERR && indbil != 0)
{ {
err = read_rip_3(rip, gr, co, sot, annoes, 0, classe_mov, tiporip); err = read_rip_3(rip, tiporip, gr, co, sot, annoes, 0, classe_mov);
if (err != NOERR) if (err != NOERR)
err = read_rip_3(rip, gr, co, sot, annoes, 0, 0, tiporip); err = read_rip_3(rip, tiporip, gr, co, sot, annoes, 0, 0);
} }
//se fallisce ancora riprova con anno=0 e lo stesso indbil //se fallisce ancora riprova con anno=0 e lo stesso indbil
if (err != NOERR && annoes != 0) if (err != NOERR && annoes != 0)
{ {
err = read_rip_3(rip, gr, co, sot, 0, indbil, classe_mov, tiporip); err = read_rip_3(rip, tiporip, gr, co, sot, 0, indbil, classe_mov);
if (err != NOERR) if (err != NOERR)
err = read_rip_3(rip, gr, co, sot, 0, indbil, 0, tiporip); err = read_rip_3(rip, tiporip, gr, co, sot, 0, indbil, 0);
//estremo tentativo con annoes e indbil = 0 //estremo tentativo con annoes e indbil = 0
if (err != NOERR && indbil != 0) if (err != NOERR && indbil != 0)
{ {
err = read_rip_3(rip, gr, co, sot, 0, 0, classe_mov, tiporip); err = read_rip_3(rip, tiporip, gr, co, sot, 0, 0, classe_mov);
if (err != NOERR) if (err != NOERR)
err = read_rip_3(rip, gr, co, sot, 0, 0, 0, tiporip); err = read_rip_3(rip, tiporip, gr, co, sot, 0, 0, 0);
} }
} }
if (err == NOERR) if (err == NOERR)
err = read(rip.get(RIP_CODICE), tiporip); err = read(tiporip, rip.get(RIP_CODICE)); //per chiave 3 sia tiporip=P che tiporip=B
return err; return err;
} }
@ -1700,30 +1720,47 @@ TObject* TCache_ripartizioni::key2obj(const char* key)
TAnal_ripartizioni_batch* rip = new TAnal_ripartizioni_batch; TAnal_ripartizioni_batch* rip = new TAnal_ripartizioni_batch;
if (nkey == 3) switch (nkey)
{ {
const int gruppo = parametro.get_int(1); case 3:
const int conto = parametro.get_int(2); {
const long sottoconto = parametro.get_long(3); const int gruppo = parametro.get_int(1);
const int anno = parametro.get_int(4); const int conto = parametro.get_int(2);
const int indbil = parametro.get_int(5); const long sottoconto = parametro.get_long(3);
const int classe_mov = parametro.get_int(6); const int anno = parametro.get_int(4);
const char tiporip = parametro.get_char(7); const int indbil = parametro.get_int(5);
const int classe_mov = parametro.get_int(6);
rip->read(gruppo, conto, sottoconto, anno, indbil, classe_mov, tiporip); //solo i movimenti a pareggio hanno chiave 3
rip->read('P', gruppo, conto, sottoconto, anno, indbil, classe_mov);
}
break;
case 5:
{
const int gruppo = parametro.get_int(1);
const int conto = parametro.get_int(2);
const long sottoconto = parametro.get_long(3);
const int anno = parametro.get_int(4);
const int indbil = parametro.get_int(5);
const int classe_mov = parametro.get_int(6);
//solo i movimenti interattivi e di conversione hanno chiave 5
rip->read('I', gruppo, conto, sottoconto, anno, indbil, 1);
}
break;
default: //chiave 4: normali ripartizioni batch
{
const TString80 codcosto = parametro.get(1);
const TString80 commessa = parametro.get(2);
const TString16 fase = parametro.get(3);
const int anno = parametro.get_int(4);
const int indbil = parametro.get_int(5);
const int classe_mov = parametro.get_int(6);
rip->read(codcosto, commessa, fase, anno, indbil, classe_mov);
}
break;
} }
else //chiave 4
{
const TString80 codcosto = parametro.get(1);
const TString80 commessa = parametro.get(2);
const TString16 fase = parametro.get(3);
const int anno = parametro.get_int(4);
const int indbil = parametro.get_int(5);
const int classe_mov = parametro.get_int(6);
rip->read(codcosto, commessa, fase, anno, indbil, classe_mov);
}
if (rip->head().get_int(RIP_TIPORIP) == 1) if (rip->head().get_int(RIP_TIPORIP) == 1)
{ {
bool some_value = false; bool some_value = false;
@ -1787,7 +1824,7 @@ const TAnal_ripartizioni_batch& TCache_ripartizioni::righe(const char* costo, co
return *(const TAnal_ripartizioni_batch*)objptr(parametro); return *(const TAnal_ripartizioni_batch*)objptr(parametro);
} }
const TAnal_ripartizioni_batch& TCache_ripartizioni::righe(const TBill& bill, const int annoes, const char tipomov, char tiporip) const TAnal_ripartizioni_batch& TCache_ripartizioni::righe(const TBill& bill, const int annoes, const char tipomov)
{ {
//classi di movimento: se preventivi 2, se normali 1 //classi di movimento: se preventivi 2, se normali 1
int classe_movimento; int classe_movimento;
@ -1798,7 +1835,44 @@ const TAnal_ripartizioni_batch& TCache_ripartizioni::righe(const TBill& bill, co
TToken_string parametro; TToken_string parametro;
parametro << "3|" << bill.gruppo() << '|' << bill.conto() << '|' << bill.sottoconto() << '|' parametro << "3|" << bill.gruppo() << '|' << bill.conto() << '|' << bill.sottoconto() << '|'
<< annoes << '|' << bill.indicatore_bilancio() << '|' << classe_movimento << '|' << tiporip; //per chiave 3 << annoes << '|' << bill.indicatore_bilancio() << '|' << classe_movimento; //per chiave 3
return *(const TAnal_ripartizioni_batch*)objptr(parametro);
}
const TAnal_ripartizioni_batch& TCache_ripartizioni::righe(const TAnal_bill& bill, const int annoes, const int indbil,
const char tipomov)
{
TConfig& config = ca_config();
const bool use_pdcc = config.get_bool("UsePdcc"); //usa il piano dei conti contabile
if (use_pdcc)
{
const TString& contone = bill.conto();
const int gr = atoi(contone.mid(0,3));
const int co = atoi(contone.mid(3,3));
const long so = atol(contone.mid(6,6));
const TBill zio(gr, co, so);
const TAnal_ripartizioni_batch& rb = righe(zio, annoes, tipomov);
//ha trovato una ripartizione?
if (rb.rows() > 0)
return rb;
}
//se non riesce a trovare una ripartizione per conto (chiave 3, tipo 'P') prova con la chiave 4 (cdc/cms/fase, tipo 'B')
return righe(bill.costo(), bill.commessa(), bill.fase(), annoes, indbil, tipomov);
}
const TAnal_ripartizioni_batch& TCache_ripartizioni::righe_interattive(const TBill& bill, const int annoes, const char tipomov)
{
//classi di movimento: se preventivi 2, se normali 1
int classe_movimento;
if (tipomov == 'P' || tipomov == 'V')
classe_movimento = 2;
else
classe_movimento = 1; //sempre questo per cacnv
TToken_string parametro;
parametro << "5|" << bill.gruppo() << '|' << bill.conto() << '|' << bill.sottoconto() << '|'
<< annoes << '|' << bill.indicatore_bilancio() << '|' << classe_movimento; //per chiave 5
return *(const TAnal_ripartizioni_batch*)objptr(parametro); return *(const TAnal_ripartizioni_batch*)objptr(parametro);
} }
@ -1847,6 +1921,10 @@ bool ca_implode_rows(const TRecord_array& input_rows, TRecord_array& compact_row
//se esiste almeno un campo origine compilato puo' implodere, senno' lascia perdere //se esiste almeno un campo origine compilato puo' implodere, senno' lascia perdere
if (ca_ori_present(rec)) if (ca_ori_present(rec))
{ {
//controlla se e' un pareggio e non una ripartizione
if (rec.get(RMOVANA_CODCONTORI).blank())
continue;
int i = 0; int i = 0;
for (i = compact_rows.rows(); i > 0; i--) //giro sulle righe gia' compattate per scoprire se for (i = compact_rows.rows(); i > 0; i--) //giro sulle righe gia' compattate per scoprire se
{ //il nostro record esiste gia' o e' da aggiungere { //il nostro record esiste gia' o e' da aggiungere

24
ca/calib01.h
View File

@ -157,6 +157,7 @@ public:
public: public:
int read(long numreg, word lockop = _nolock); // Funzione read di comodo int read(long numreg, word lockop = _nolock); // Funzione read di comodo
void update_totdoc();
TAnal_mov(long numreg = 0); TAnal_mov(long numreg = 0);
TAnal_mov(const TRectype& rec); //accetta LF_MOVANA,LF_RMOVANA,LF_MOV TAnal_mov(const TRectype& rec); //accetta LF_MOVANA,LF_RMOVANA,LF_MOV
}; };
@ -164,21 +165,24 @@ public:
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// TAnal_ripartizioni_batch (ahi!) // TAnal_ripartizioni_batch (ahi!)
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
class TAnal_bill;
class TAnal_ripartizioni_batch : public TRecord_array class TAnal_ripartizioni_batch : public TRecord_array
{ {
TRectype _rip; TRectype _rip;
private: private:
int read_rip_3(TLocalisamfile& rip, const int gr, const int co, const long sot, int read_rip_3(TLocalisamfile& rip, const char tiporip, const int gr, const int co, const long sot,
const int annoes, const int indbil, const int classe_mov, char tiporip) const; const int annoes, const int indbil, const int classe_mov) const;
int read_rip_4(TLocalisamfile& rip, const char* codcosto, const char* commessa, const char* fase, int read_rip_4(TLocalisamfile& rip, const char* codcosto, const char* commessa, const char* fase,
const int annoes, const int indbil, const int classe_mov) const; const int annoes, const int indbil, const int classe_mov) const;
public: public:
const TRectype& head() const { return _rip; } const TRectype& head() const { return _rip; }
int indbil() const; int indbil() const;
int read (const char* codice, char tiporip); char tiporip() const;
int read (const char tiporip, const char* codice);
int read (const char* codcosto, const char* commessa, const char* fase, const int annoes, const int indbil, const int classe_mov); int read (const char* codcosto, const char* commessa, const char* fase, const int annoes, const int indbil, const int classe_mov);
int read (const int gr, const int co, const long sot, const int annoes, const int indbil, const int classe_mov, char tiporip); int read (const char tiporip, const int gr, const int co, const long sot, const int annoes, const int indbil, const int classe_mov);
TAnal_ripartizioni_batch(); TAnal_ripartizioni_batch();
}; };
@ -196,11 +200,17 @@ protected:
public: public:
void set_esercizio(const int codes); void set_esercizio(const int codes);
//batch
const TAnal_ripartizioni_batch& righe(const char* costo, const char* commessa, const char* fase, const TAnal_ripartizioni_batch& righe(const char* costo, const char* commessa, const char* fase,
const int annoes, const int indbil, const char tipomov); const int annoes, const int indbil, const char tipomov);
const TAnal_ripartizioni_batch& righe(const TBill& bill, const int annoes, const char tipomov, char tiporip = 'B'); //pareggio
const TAnal_ripartizioni_batch& righe(const TBill& bill, const int annoes, const char tipomov);
TCache_ripartizioni(); //batch
const TAnal_ripartizioni_batch& righe(const TAnal_bill& bill, const int annoes, const int indbil, const char tipomov);
//interattive per conversione e contabilizzazione (usate da cacnv e da contabilizzazione analitica docs)
const TAnal_ripartizioni_batch& righe_interattive(const TBill& bill, const int annoes, const char tipomov = ' ');
TCache_ripartizioni();
}; };
// metodi di implosione movimenti ripartiti!! Serve nel ribaltamento movimenti, stampa rendiconto... // metodi di implosione movimenti ripartiti!! Serve nel ribaltamento movimenti, stampa rendiconto...

2
ca/f149.trr
View File

@ -1,6 +1,6 @@
149 149
13 13
TIPO|1|1|0|Tipo Ripartizione (<I>nterattiva, <B>atch) TIPO|1|1|0|Tipo Ripartizione (<I>nterattiva, <B>atch, <P>areggio)
CODICE|1|8|0|Codice ripartizione CODICE|1|8|0|Codice ripartizione
GRUPPO|2|3|0|Gruppo GRUPPO|2|3|0|Gruppo
CONTO|2|3|0|Conto CONTO|2|3|0|Conto

4
ve/velib04f.cpp
View File

@ -351,7 +351,7 @@ bool TContabilizzazione_analitica::find_conti_iva_indetraibile(const TRiga_docum
else else
{ {
// Cerca la ripartizione del conto // Cerca la ripartizione del conto
const TAnal_ripartizioni_batch& rip = _rip.righe(bill, annoes, tipomov); const TAnal_ripartizioni_batch& rip = _rip.righe_interattive(bill, annoes, tipomov);
for (int i = 1; i <= rip.rows(); i++) for (int i = 1; i <= rip.rows(); i++)
{ {
const TRectype& rigarip = rip.row(i); const TRectype& rigarip = rip.row(i);
@ -438,7 +438,7 @@ bool TContabilizzazione_analitica::find_conti(const TRiga_documento& riga, TStri
if (contanal.blank()) // Non ho trovato il conto in anagrafica ... if (contanal.blank()) // Non ho trovato il conto in anagrafica ...
{ {
// Cerca la ripartizione del conto // Cerca la ripartizione del conto
const TAnal_ripartizioni_batch& rip = _rip.righe(bill, annoes, tipomov, 'I'); const TAnal_ripartizioni_batch& rip = _rip.righe_interattive(bill, annoes, tipomov);
TToken_string conto; TToken_string conto;
for (int i = 1; i <= rip.rows(); i++) for (int i = 1; i <= rip.rows(); i++)
{ {