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

Prima versione funzionante della contabilizzazione effetti.

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@4472 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
angelo 1997-05-31 13:24:42 +00:00
parent 2fac27f1c5
commit 90dcf79c99
1 changed files with 247 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

322
ef/ef0800.cpp
View File

@ -49,8 +49,10 @@
#include <rmoviva.h>
#include <clifo.h>
#include <effetti.h>
#include <pagsca.h>
#include <doc.h>
#define CGROWS_LIMIT 99
#define CGROWS_LIMIT 99 // Limite imposto da invii/ricezioni
#define DIST_INCASSO 'I'
#define DIST_SBF 'B'
@ -59,6 +61,7 @@
enum error_type
{
no_error,
generic_error,
clifo_error,
bank_error
};
@ -73,14 +76,20 @@ class TContabilizzazione_effetti_app : public TApplication
int _cod_es; // Codice/anno esercizio
bool _sc_enabled; // se TRUE il saldaconto di ditta e' abilitato
bool _can_write; // se TRUE e' abilitata la scrittura. Non appena rileva un errore rimane a FALSE for this instance
real _total_mov, // Totale del movimento corrente
_total_mov_val;// Same as above but in valuta
TMask *_msk; // maschera di selezione dati
TLocalisamfile *_attiv, // file delle attivita' (per far funzionare TRegistro)
*_fcaus, // file delle causale (per far funzionare TCausale)
*_frcaus, // file delle righe causali (per far funzionare TCausale)
*_effetti, // file degli effetti (per TDistinta)
*_reffetti, // file delle righe effetti (per TDistinta)
*_cessionari, // file dei cessionari (per TDistinta)
*_part, // file delle partite (per far funzionare TPartita)
*_scad, // file delle scadenze (per far funzionare TPartita)
*_pags, // file dei pagamenti (per far funzionare TPartita)
*_clifo; // file delle causale (per far funzionare TCausale)
*_clifo, // file dei clienti
*_doc; // file dei documenti
TTable *_cpg, // tabella condizioni di pagamento
*_bnp; // tabella banca presentazione effetti
TBill _banca, // conto di contropartita della banca
@ -95,13 +104,13 @@ class TContabilizzazione_effetti_app : public TApplication
int _cur_dist_row;// Numero di riga distinta corrente (per visualizzazione errore)
protected: // TApplication
// Compila la testata del movimento
error_type compile_head_mov();
void compile_head_mov();
// Compila la riga di partita
void compile_riga_partita(TRiga_partite& riga, TEffetto& effetto, TRectype& riga_effetto);
// scrive le scadenze
error_type write_scadenze() { return no_error; }
// Compila la riga di pagamento
void compile_riga_pagamento(TRectype& riga_pagamento, TEffetto& effetto, TRectype& riga_effetto, char acc_sal);
// scrive il movimento e le scadenze
error_type write_all() { return no_error; }
error_type write_all(bool chage_status = TRUE);
// cerca il conto di contropartita per la distinta corrente (setta _banca)
error_type search_bank_counter_bill(int tipopag=0);
// cerca il conto clienti
@ -172,7 +181,7 @@ void TContabilizzazione_effetti_app::build_dist_sheet()
ndist_prec = ndist;
tipo_prec = tipo;
if (rec.get_bool(EFF_EFFCONT)) // Disabilita le distinte che contengono effetti gia' contabilizzati
_dist_sheet->disable_row(pos);
_dist_sheet->disable_row(pos); // ?? Appunto: e se ci sono distinte con alcuni effetti contabilizzati e altri no ?
}
else num_eff++; // numero di effetti che compongono la distinta
}
@ -227,18 +236,21 @@ bool TContabilizzazione_effetti_app::create()
_bnp = new TTable("BNP");
_fcaus = new TLocalisamfile(LF_CAUSALI);
_frcaus = new TLocalisamfile(LF_RCAUSALI);
_effetti = new TLocalisamfile(LF_EFFETTI);
_reffetti = new TLocalisamfile(LF_REFFETTI);
_cessionari = new TLocalisamfile(LF_CESS);
_part = new TLocalisamfile(LF_PARTITE);
_scad = new TLocalisamfile(LF_SCADENZE);
_pags = new TLocalisamfile(LF_PAGSCA);
_attiv = new TLocalisamfile(LF_ATTIV); // Altrimenti TRegistro non va!
_clifo = new TLocalisamfile(LF_CLIFO);
_doc = new TLocalisamfile(LF_DOC);
_distinta = new TDistinta;
_movimento = new TMovimentoPN;
_dist_sheet = new TArray_sheet(-1, -1, -4, -4, "Selezione distinte",
"@1|Tipo|Numero distinta@R|Numero effetti@R|ABI@5|CAB@5");
if (_sc_enabled)
_part_array = new TPartite_array;
build_dist_sheet();
dispatch_e_menu(BAR_ITEM(1));
return TRUE;
}
@ -250,11 +262,15 @@ bool TContabilizzazione_effetti_app::destroy()
if (_bnp) delete _bnp;
if (_fcaus) delete _fcaus;
if (_frcaus) delete _frcaus;
if (_effetti) delete _effetti;
if (_reffetti) delete _reffetti;
if (_cessionari) delete _cessionari;
if (_part) delete _part;
if (_scad) delete _scad;
if (_pags) delete _pags;
if (_attiv) delete _attiv;
if (_clifo)delete _clifo;
if (_doc)delete _doc;
if (_caus) delete _caus;
if (_distinta) delete _distinta;
if (_movimento) delete _movimento;
@ -266,6 +282,7 @@ bool TContabilizzazione_effetti_app::destroy()
bool TContabilizzazione_effetti_app::menu(MENU_TAG mt)
{
build_dist_sheet();
while (_msk->run() == K_ENTER)
{
if (!_dist_sheet->one_checked())
@ -292,6 +309,8 @@ bool TContabilizzazione_effetti_app::menu(MENU_TAG mt)
continue;
}
contabilize();
_msk->reset(F_DISTINTE);
build_dist_sheet();
}
return FALSE;
}
@ -303,14 +322,14 @@ void TContabilizzazione_effetti_app::display_error()
switch (_error)
{
case clifo_error:
msg.format("Non e' possibile reperire il clienti relativamente alla distinta %c %ld. "
"Controllare la riga %d",_distinta->tipodist(), _distinta->ndist(),_cur_dist_row);
msg.format("Non e' possibile reperire il cliente relativamente alla distinta %c %ld. "
"Controllare la riga %d",_distinta->tipodist(), _distinta->ndist(),_cur_dist_row+1);
break;
case bank_error:
msg.format("Non e' possibile reperire i conti di contropartita per la banca di presentazione "
"relativamente alla distinta %c %ld. Controllare la tabella e la causale.",_distinta->tipodist(), _distinta->ndist());
break;
default:
default: // Errori generici o non indicati vengono visualizzati nel punto dell'errore
break;
}
warning_box(msg);
@ -329,9 +348,11 @@ bool TContabilizzazione_effetti_app::add_cg_row(const TRectype& eff, TArray& cus
c_rec->put(RMV_DATAREG,_data_op);
c_rec->put(RMV_NUMREG,numreg);
c_rec->put(RMV_SEZIONE,_caus->sezione_clifo());
c_rec->put(RMV_TIPOC,_cliente.tipo());
c_rec->put(RMV_GRUPPO,_cliente.gruppo());
c_rec->put(RMV_CONTO,_cliente.conto());
c_rec->put(RMV_SOTTOCONTO,_cliente.sottoconto());
c_rec->put(RMV_ROWTYPE,"K");
// setta i valori per la riga banca
TRectype b_r(*c_rec);
@ -345,9 +366,11 @@ bool TContabilizzazione_effetti_app::add_cg_row(const TRectype& eff, TArray& cus
int nriga = 2;
if (_sc_enabled && tipopag>1 && tipopag<8) nriga = tipopag+1;
b_rec.put(RMV_SEZIONE,_caus->sezione(nriga));
b_rec.put(RMV_TIPOC,_banca.tipo());
b_rec.put(RMV_GRUPPO,_banca.gruppo());
b_rec.put(RMV_CONTO,_banca.sottoconto());
b_rec.put(RMV_CONTO,_banca.conto());
b_rec.put(RMV_SOTTOCONTO,_banca.sottoconto());
b_rec.put(RMV_ROWTYPE,"I");
}
real b_imp = b_rec.get_real(RMV_IMPORTO) + imp; // aggiorna l'importo per questa banca
b_rec.put(RMV_IMPORTO,b_imp);
@ -361,39 +384,22 @@ bool TContabilizzazione_effetti_app::add_cg_row(const TRectype& eff, TArray& cus
void TContabilizzazione_effetti_app::join_rows(TArray& customers, TAssoc_array& banks)
{
// aggiunge prima i record delle righe relative alle banche
const int bank_items = banks.items();
TRectype* row;
// aggiunge prima i record delle righe relative ai clienti
int j=0,i=0;
for (row = (TRectype *)banks.first_item(); row != NULL && j<bank_items;j++,row = (TRectype *)banks.succ_item())
_movimento->cg(i++) = *row;
// aggiunge i record delle righe relative ai clienti
const int customer_items = customers.items();
for (j=0; j<customer_items;j++)
{
_movimento->cg(i++) = (TRectype&) customers[j];
}
error_type TContabilizzazione_effetti_app::compile_head_mov()
{
CHECK(_caus,"Causale non allocata");
TLocalisamfile& mov = _movimento->lfile();
mov.last();
const long numreg = mov.get_long(MOV_NUMREG)+1; // Calcola il numero di registrazione
mov.zero();
mov.put(MOV_NUMREG,numreg);
mov.put(MOV_ANNOES,_cod_es);
mov.put(MOV_DATAREG,_data_op);
mov.put(MOV_DATACOMP,_data_op);
mov.put(MOV_DATADOC,_distinta->data_dist());
mov.put(MOV_NUMDOC,_distinta->ndist());
mov.put(MOV_TIPODOC,_caus->tipo_doc());
mov.put(MOV_CODCAUS,_cod_caus);
mov.put(MOV_CODVAL,_distinta->codval());
mov.put(MOV_DATACAM,_distinta->data_cam());
mov.put(MOV_CAMBIO,_distinta->cambio());
// Completare con totale distinta in valuta e in lire
return _error;
_movimento->cg(i-1).put(RMV_NUMRIG,i);
}
// e poi i record delle righe relative alle banche
const int bank_items = banks.items();
TRectype* row;
for (j=0,row = (TRectype *)banks.first_item(); row != NULL && j<bank_items;j++,row = (TRectype *)banks.succ_item())
{
_movimento->cg(i++) = *row;
_movimento->cg(i-1).put(RMV_NUMRIG,i);
}
}
error_type TContabilizzazione_effetti_app::search_clifo_bill(const long codcf)
@ -421,7 +427,7 @@ error_type TContabilizzazione_effetti_app::search_bank_counter_bill(int tipopag)
// La banca di presentazione effetti e' una unica per tutta la distinta
// e non puo' essere vuota
_error = no_error;
if (tipopag != 0) // cerca sulla tabella e poi sulla 2a riga di causale
if (tipopag == 0) // cerca sulla tabella e poi sulla 2a riga di causale
{
TString codtab(_distinta->abip());
codtab << _distinta->cabp();
@ -457,7 +463,7 @@ error_type TContabilizzazione_effetti_app::search_bank_counter_bill(int tipopag)
_caus->bill(2,_banca); // conto della riga 2
if (!_banca.ok())
_error = bank_error;
}
}
// se il saldaconto non e' abilitato, il conto di contropartita sulla causale
// va verificato per ogni riga di distinta, a seconda del tipo di pagamento.
}
@ -498,13 +504,45 @@ char TContabilizzazione_effetti_app::sezione() const
return sezione;
}
void TContabilizzazione_effetti_app::compile_head_mov()
{
CHECK(_caus,"Causale non allocata");
TLocalisamfile& mov = _movimento->lfile();
mov.last();
const long numreg = mov.get_long(MOV_NUMREG)+1; // Calcola il numero di registrazione
const TDate& datadist = _distinta->data_dist();
const TDate& datacam = _distinta->data_cam();
const TString& codval = _distinta->codval();
const real& cambio = _distinta->cambio();
const long ndist = _distinta->ndist();
TString des;
des.format("Contabilizzazione distinta nr. %ld ",ndist, datadist.string());
mov.zero();
mov.put(MOV_DESCR,des);
mov.put(MOV_NUMREG,numreg);
mov.put(MOV_ANNOES,_cod_es);
mov.put(MOV_DATAREG,_data_op);
mov.put(MOV_DATACOMP,_data_op);
mov.put(MOV_DATADOC,datadist);
mov.put(MOV_NUMDOC,ndist);
mov.put(MOV_TIPODOC,_caus->tipo_doc());
mov.put(MOV_CODCAUS,_cod_caus);
mov.put(MOV_CODVAL,codval);
mov.put(MOV_DATACAM,datacam);
mov.put(MOV_CAMBIO,cambio);
// MOV_TOTDOC e MOV_TOTDOCVAL vengono completati prima della scrittura del movimento
// e solo nel caso di saldaconto abilitato
}
void TContabilizzazione_effetti_app::compile_riga_partita(TRiga_partite& riga, TEffetto& effetto, TRectype& riga_effetto)
{
TLocalisamfile& head_mov = _movimento->lfile();
riga.put(PART_TIPOMOV,_caus->tipomov());
riga.put(PART_TIPOPAG,effetto.get_int(EFF_TIPOPAG));
riga.put(PART_NREG,head_mov.get_long(MOV_NUMREG));
riga.put(PART_NUMRIG,_cur_dist_row); // Nelle righe del movimento le righe clienti vengono prima delle banche
riga.put(PART_NUMRIG,_cur_dist_row+1); // Nelle righe del movimento le righe clienti vengono prima delle banche
// percio' vi e' una corrispondenza 1 a 1
riga.put(PART_DATAREG,head_mov.get_date(MOV_DATAREG));
riga.put(PART_DATADOC,head_mov.get_date(MOV_DATADOC));
@ -512,16 +550,104 @@ void TContabilizzazione_effetti_app::compile_riga_partita(TRiga_partite& riga, T
riga.put(PART_NUMDOC,head_mov.get(MOV_NUMDOC)); // Sarebbe il numero della distinta...
// La descrizione della riga (PART_DESCR) la lascio vuota. Verificare con Guy le regole necessarie per la sua compilazione eventuale
riga.put(PART_SEZ,sezione());
riga.put(PART_IMPORTO,riga_effetto.get_real(REFF_IMPORTO));
real imp = riga_effetto.get_real(REFF_IMPORTO);
real imp_val = riga_effetto.get_real(REFF_IMPORTOVAL);
riga.put(PART_IMPORTO,imp);
riga.put(PART_CODVAL,effetto.get(EFF_CODVAL));
riga.put(PART_CAMBIO,effetto.get_real(EFF_CAMBIO));
riga.put(PART_IMPORTOVAL,riga_effetto.get_real(REFF_IMPORTOVAL));
riga.put(PART_IMPORTOVAL,imp_val);
riga.put(PART_DATACAM,effetto.get_date(EFF_DATACAMBIO));
riga.put(PART_TIPOCF,_cliente.tipo());
riga.put(PART_SOTTOCONTO,_cliente.sottoconto());
riga.put(PART_IMPTOTDOC,effetto.get_real(EFF_IMPORTO));
riga.put(PART_IMPTOTVAL,effetto.get_real(EFF_IMPORTOVAL));
// PART_GRUPPOCL e PART_CONTOCL sono gia' compilati dalla TPartita::new_row()
// Aggiorna il totale movimento in lire e totale movimento in valuta (solo con saldaconto abilitato)
if (_sc_enabled)
{
_total_mov += imp;
_total_mov_val += imp_val;
}
}
void TContabilizzazione_effetti_app::compile_riga_pagamento(TRectype& riga_pagamento, TEffetto& effetto, TRectype& riga_effetto, char acc_sal)
{
// ANNO, NUMPART, NRIGA, NRATA, NRIGP dovrebbero essere gia' compilati
riga_pagamento.put(PAGSCA_TIPOC,_cliente.tipo());
riga_pagamento.put(PAGSCA_SOTTOCONTO,_cliente.sottoconto());
riga_pagamento.put(PAGSCA_ACCSAL,acc_sal);
riga_pagamento.put(PAGSCA_IMPORTO,riga_effetto.get_real(REFF_IMPORTO));
riga_pagamento.put(PAGSCA_IMPORTOVAL,riga_effetto.get_real(REFF_IMPORTOVAL));
riga_pagamento.put(PAGSCA_TIPOCC,_banca.tipo());
riga_pagamento.put(PAGSCA_GRUPPOC,_banca.gruppo());
riga_pagamento.put(PAGSCA_CONTOC,_banca.conto());
riga_pagamento.put(PAGSCA_SOTTOCONTC,_banca.sottoconto());
riga_pagamento.put(PAGSCA_CODABI, effetto.get(EFF_CODABI));
riga_pagamento.put(PAGSCA_CODCAB, effetto.get(EFF_CODCAB));
riga_pagamento.put(PAGSCA_CODABIPR, effetto.get(EFF_CODABIP));
riga_pagamento.put(PAGSCA_CODCABPR, effetto.get(EFF_CODCABP));
// Cerca l'eventuale codice agente sul documento
_doc->put(DOC_PROVV,riga_effetto.get(REFF_PROVV));
_doc->put(DOC_ANNO,riga_effetto.get(REFF_ANNODOC));
_doc->put(DOC_CODNUM,riga_effetto.get(REFF_CODNUM));
_doc->put(DOC_NDOC,riga_effetto.get(REFF_NFATT));
if (_doc->read() == NOERR)
riga_pagamento.put(PAGSCA_CODAG,_doc->get(DOC_CODAG));
}
error_type TContabilizzazione_effetti_app::write_all(bool change_status)
{
TRectype& head = _movimento->lfile().curr();
head.put(MOV_TOTDOC,_total_mov); // Se il saldaconto non e' abilitato sono entrambi a 0.0
head.put(MOV_TOTDOCVAL,_total_mov_val);
long orig_numreg, numreg = head.get_long(MOV_NUMREG);
orig_numreg = numreg;
while (_movimento->write() == _isreinsert)
head.put(MOV_NUMREG,++numreg);
if (_movimento->status() != NOERR)
{
error_box("E' stato rilevato l'errore %d scrivendo il movimento %ld.",_movimento->status(),numreg);
_error = generic_error;
}
if (good()) // nessun errore ?
{
if (_sc_enabled) // Debbo scrivere anche le partite ?
{
if (numreg > orig_numreg) // Ha effettuato una rinumerazione ?
{
// Allora scorre le partite in _part_array e aggiorna il campo NREG delle righe di ognuna
for (TPartita * p = _part_array->first(); p != NULL; p = _part_array->next())
// Scorre le righe della partita corrente
for (int n = p->last(); n > 0; n = p->pred(n))
{
TRiga_partite& riga = p->riga(n);
if (riga.get_long(PART_NREG) == orig_numreg) // sostituisce il numero registrazione con quello nuovo
riga.put(PART_NREG, numreg);
}
}
if (!_part_array->write()) // L'errore viene gia' segnalato dalla partita
_error = generic_error;
}
if (good() && change_status) // deve anche cambiare lo stato alla distinta ?
{
TDistinta& distinta = *_distinta;
const int items = distinta.items();
for (int n = 0; n < items; n++)
{
TRectype& eff = distinta[n];
eff.put(EFF_EFFCONT,TRUE);
}
int err = distinta.rewrite();
if (err != NOERR)
{
error_box("E' stato rilevato l'errore %d aggiornando lo stato della distinta %c %ld.",err,distinta.tipodist(),distinta.ndist());
_error = generic_error;
}
}
}
return _error;
}
void TContabilizzazione_effetti_app::contabilize_bill(const char tipo, const long numero)
@ -529,14 +655,16 @@ void TContabilizzazione_effetti_app::contabilize_bill(const char tipo, const lon
TDistinta& distinta = *_distinta;
TLocalisamfile& mov = _movimento->lfile();
// tiene 2 array di record separati: uno per i clienti ed uno per le banche,
// alla fine, prim di scrivere il movimento, li riunisce nel record array di
// _movimento, per metterli in ordine, prima le righe delle banche e poi le righe clienti
// alla fine, prima di scrivere il movimento, li riunisce nel record array di
// _movimento, per metterli in ordine, prima le righe clienti e poi le righe delle banche
// L'array delle banche e' un assoc_array, con indice sul gruppo/conto/sottoconto
// per effettuare il raggruppamento
TArray customers;
TAssoc_array banks;
distinta.read(tipo,numero);
bool reset_bank = FALSE;
_total_mov = 0.0;
_total_mov_val = 0.0;
distinta.read(tipo,numero,_lock); // Sblocca da solo quella precedente
//Cerca il conto della contropartita della banca di presentazione.
//Nel caso in cui sia presente sulla tabella BNP (selezione anche per
@ -566,24 +694,26 @@ void TContabilizzazione_effetti_app::contabilize_bill(const char tipo, const lon
// _cur_dist_row e' un int sebbene su file sia un long: TArray::items() ritorna un int!!
for (_cur_dist_row = 0; _cur_dist_row<items; _cur_dist_row++) // scorre le righe della distinta (effetti)
{
if (nrows == CGROWS_LIMIT) // se sono arrivato a 99 righe, scrivo questo movimento
if (nrows == CGROWS_LIMIT) // se sono arrivato al limite massimo, scrivo questo movimento
{
//Unisce le righe banche e clienti nel record_array delle righe contabili
//di _movimento
if (good() && _can_write)
{
join_rows(customers,banks);
if (write_all() == no_error)
_total_bills++;
write_all(FALSE); // non cambiare lo stato della distinta, cambialo solo alla fine
}
if (good())
{
_movimento->destroy_rows(mov.get_long(MOV_NUMREG)); // azzera le righe..
// compila la testata del nuovo movimento
compile_head_mov();
_part_array->destroy(); // e l'array delle partite
customers.destroy();
banks.destroy();
nrows = 0;
_total_mov = 0.0;
_total_mov_val = 0.0;
// compila la testata del nuovo movimento
compile_head_mov();
}
}
if (!good()) break;
@ -591,13 +721,16 @@ void TContabilizzazione_effetti_app::contabilize_bill(const char tipo, const lon
const long codcf = eff.get_long(EFF_CODCF);
search_clifo_bill(codcf);
if (!good()) break;
// se la banca non e' stata settata significa che il saldaconto e' abilitato.
// Quindi cerca il conto sulla causale a seconda del tipo di pagamento di questo effetto
// se la banca non e' stata settata cerca il conto sulla causale a seconda del tipo di pagamento di questo effetto
if (!_banca.ok())
{
search_bank_counter_bill(eff.get_int(EFF_TIPOPAG));
reset_bank = TRUE; // forza la ricerca del conto della banca ad ogni riga distinta
}
// incrementa il numero di righe contabili generate fino ad ora.
// per i clienti e' sempre vero, mentre per le banche dipende se e' stato fatto un
// raggruppamento
if (!good()) break;
if (add_cg_row(eff,customers,banks)) nrows++;
// Scorre le righe di effetto e setta il TPartite_array
@ -605,29 +738,43 @@ void TContabilizzazione_effetti_app::contabilize_bill(const char tipo, const lon
{
const int rows = eff.rows_r();
TCodice_numerazione cn;
TString16 numpart;
TString16 numpart,numdoc_to_search;
int anno;
long nfatt;
for (int k = 0; k < rows; k++)
for (int k = 1; k <= rows; k++)
{
// reperisce gli estremi della partita eventualmente pre-settati sulla riga
TRectype& reff = eff.row_r(k);
anno = reff.get_int(REFF_ANNO);
numpart = reff.get(REFF_NUMPART);
// Ricava il numero della fattura..
numdoc_to_search = reff.get(REFF_CODNUM);
nfatt = reff.get_long(REFF_NFATT);
if (numdoc_to_search.not_empty() && nfatt > 0L)
{
cn.read(numdoc_to_search);
numdoc_to_search = cn.complete_num(nfatt);
}
else // se gli estremi della fattura non sono compilati si piglia il numero della partita
numdoc_to_search = numpart;
if (anno == 0 || numpart.empty()) // Se non sono gia' settati sulla riga effetto...
{
anno = reff.get_date(REFF_DATAFATT).year(); // ... li va prendere dagli estremi fattura...
numpart = reff.get(REFF_CODNUM);
nfatt = reff.get_long(REFF_NFATT);
if (numpart.not_empty() && nfatt > 0L)
{
cn.read(numpart);
numpart = cn.complete_num(nfatt);
}
//anno = reff.get_date(REFF_DATAFATT).year();
anno = reff.get_int(REFF_ANNODOC);// ... li va prendere dagli estremi fattura...
//numpart = reff.get(REFF_CODNUM);
//nfatt = reff.get_long(REFF_NFATT);
//if (numpart.not_empty() && nfatt > 0L)
if (numdoc_to_search.not_empty())
//{
// cn.read(numpart);
// numpart = cn.complete_num(nfatt);
//}
numpart = numdoc_to_search;
else // ...oppure dalla testata movimento.
{ // Appunto: da verificare: facciamo cosi' o generiamo un errore ?
{ // Appunto: da verificare se facciamo cosi' o generiamo un errore...
anno = distinta.data_dist().year();
numpart.format("%7ld", numero);
numdoc_to_search = numpart; // A mali estremi... estremi rimedi
}
}
TPartita * partita = _part_array->exist(_cliente,anno,numpart);
@ -641,13 +788,41 @@ void TContabilizzazione_effetti_app::contabilize_bill(const char tipo, const lon
compile_riga_partita(riga_part,eff,reff);
// Compila la riga di pagamento:
// reperire il numero della riga partita (nrigp) appena aggiunta
int nrigp = riga_part.get_int(PART_NRIGA);
// scorrere le righe della partita (nriga) per trovare il riferimento alla fattura di cui si sta effettuando il pagamento
// se non la si trova allora... nriga = UNASSIGNED
const int uns = (int) TPartita::UNASSIGNED;
int nriga = uns;
for (int r = partita->last(); r > 0; r = partita->pred(r))
{
TRiga_partite& rpart = partita->riga(r);
if (rpart.is_fattura() && rpart.get(PART_NUMDOC) == numdoc_to_search)
{
nriga = r;
break;
}
}
// reperire il numero di rata (nrata) dalla riga effetto
// TRectype& riga_pagamento = partita->pagamento(nriga,nrata,nrigp)
int nrata = reff.get_int(REFF_NRATA);
char acc_sal = 'A';
if (partita->esiste(nriga,nrata)) // calcola se e' a saldo o in acconto della rata
{
TRiga_scadenze& riga_scadenza = partita->rata(nriga,nrata);
TImporto residuo_scadenza(riga_scadenza.residuo(FALSE));
if (residuo_scadenza.valore() <= reff.get_real(REFF_IMPORTO))
acc_sal = 'S';
}
else
if (nriga != uns)
nriga = uns; // E' praticamente impossibile che si trovi la fattura
// senza le proprie scadenze. Al limite settiamo il numero di riga per non assegnati.
TRectype& riga_pagamento = partita->pagamento(nriga,nrata,nrigp); // Nuova riga di pagamento
// compilare i campi di riga_pagamento
compile_riga_pagamento(riga_pagamento,eff,reff, acc_sal);
// completare se necessario i campi della riga effetto corrente (ANNO-NUMPART-NRIGA)
}
if (reset_bank)
_banca.set(0,0,0);
}
nrows++;
}
@ -656,13 +831,10 @@ void TContabilizzazione_effetti_app::contabilize_bill(const char tipo, const lon
{
join_rows(customers,banks);
if (write_all() == no_error) // Se la scrittura e' andata ok...
{
_movimento->destroy_rows(mov.get_long(MOV_NUMREG)); // azzera le righe..
_total_bills++; // incrementa il numero di effetti contabilizzati
}
_total_bills++; // incrementa il numero di distinte contabilizzate
}
if (_sc_enabled)
_part_array->destroy();
_movimento->destroy_rows(mov.get_long(MOV_NUMREG)); // azzera le righe..
_part_array->destroy(); // e l'array delle partite
}
void TContabilizzazione_effetti_app::contabilize()