Prima versione funzionante della contabilizzazione effetti.

git-svn-id: svn://10.65.10.50/trunk@4472 c028cbd2-c16b-5b4b-a496-9718f37d4682

ef/ef0800.cpp

@@ -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
+  // Compila la riga di pagamento
-  error_type write_scadenze() { return no_error; }
+  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. "
+      msg.format("Non e' possibile reperire il cliente relativamente alla distinta %c %ld. "
-                 "Controllare la riga %d",_distinta->tipodist(), _distinta->ndist(),_cur_dist_row);
+                 "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
+  // aggiunge prima i record delle righe relative ai clienti
-  const int bank_items = banks.items();
-  TRectype* row;
   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];
-}
+    _movimento->cg(i-1).put(RMV_NUMRIG,i);
-
+  }
-error_type TContabilizzazione_effetti_app::compile_head_mov()
+  // e poi i record delle righe relative alle banche
-{
+  const int bank_items = banks.items();
-  CHECK(_caus,"Causale non allocata");
+  TRectype* row;
-  
+  for (j=0,row = (TRectype *)banks.first_item(); row != NULL && j<bank_items;j++,row = (TRectype *)banks.succ_item())
-  TLocalisamfile& mov = _movimento->lfile();
+  {
-  mov.last();
+    _movimento->cg(i++) = *row;
-  const long numreg = mov.get_long(MOV_NUMREG)+1; // Calcola il numero di registrazione
+    _movimento->cg(i-1).put(RMV_NUMRIG,i);
-  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;
 }
 
 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 
+  // alla fine, prima 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
+  // _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;
-  
+  bool reset_bank = FALSE;
-  distinta.read(tipo,numero);
+  _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)
+        write_all(FALSE); // non cambiare lo stato della distinta, cambialo solo alla fine
-          _total_bills++;
       }
       if (good())
       {
         _movimento->destroy_rows(mov.get_long(MOV_NUMREG)); // azzera le righe..
-        // compila la testata del nuovo movimento
+        _part_array->destroy(); // e l'array delle partite
-        compile_head_mov();
         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.
+    // se la banca non e' stata settata cerca il conto sulla causale a seconda del tipo di pagamento di questo effetto
-    // Quindi 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...
+          //anno = reff.get_date(REFF_DATAFATT).year(); 
-          numpart = reff.get(REFF_CODNUM);
+          anno = reff.get_int(REFF_ANNODOC);// ... li va prendere dagli estremi fattura...
-          nfatt = reff.get_long(REFF_NFATT);
+          //numpart = reff.get(REFF_CODNUM);
-          if (numpart.not_empty() && nfatt > 0L)
+          //nfatt = reff.get_long(REFF_NFATT);
-          {
+          //if (numpart.not_empty() && nfatt > 0L)
-            cn.read(numpart);
+          if (numdoc_to_search.not_empty())
-            numpart = cn.complete_num(nfatt);
+          //{
-          }
+          //  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...
-    {
+      _total_bills++; // incrementa il numero di distinte contabilizzate
-      _movimento->destroy_rows(mov.get_long(MOV_NUMREG)); // azzera le righe..
-      _total_bills++; // incrementa il numero di effetti contabilizzati
-    }
   }
-   if (_sc_enabled) 
+  _movimento->destroy_rows(mov.get_long(MOV_NUMREG)); // azzera le righe..
-     _part_array->destroy();
+  _part_array->destroy(); // e l'array delle partite
 }
 
 void TContabilizzazione_effetti_app::contabilize()