From 90dcf79c99fec5fa5278b4274d940adae66e8a80 Mon Sep 17 00:00:00 2001 From: angelo Date: Sat, 31 May 1997 13:24:42 +0000 Subject: [PATCH] Prima versione funzionante della contabilizzazione effetti. git-svn-id: svn://10.65.10.50/trunk@4472 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- ef/ef0800.cpp | 322 ++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 247 insertions(+), 75 deletions(-) diff --git a/ef/ef0800.cpp b/ef/ef0800.cpp index b6f6aec9a..91511f02c 100755 --- a/ef/ef0800.cpp +++ b/ef/ef0800.cpp @@ -49,8 +49,10 @@ #include #include #include +#include +#include -#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 && jcg(i++) = *row; - // aggiunge i record delle righe relative ai clienti const int customer_items = customers.items(); for (j=0; jcg(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 && jcg(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_rowdestroy_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()