From 8ec9b32ff88064d510a9fd144e70f98aeaf91384 Mon Sep 17 00:00:00 2001 From: angelo Date: Mon, 13 Oct 1997 15:21:11 +0000 Subject: [PATCH] Cambiata gestione provvigioni per agente: la chiave e' ora CODAGE+ANNO+CODNUM+NDOC+NRIGA. effettuate le modifiche del caso a prlib01 e pr0700 git-svn-id: svn://10.65.10.50/trunk@5356 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- pr/f124.trr | 2 +- pr/pr0700.cpp | 144 +++++++++++++++++++++++++++++++++++++++---------- pr/pr0700b.h | 1 + pr/pr0700b.uml | 49 +++++++++-------- pr/prlib.h | 43 +++++++++------ pr/prlib01.cpp | 143 ++++++++++++++++++++++++++++-------------------- 6 files changed, 259 insertions(+), 123 deletions(-) diff --git a/pr/f124.trr b/pr/f124.trr index 5a6c2f553..594548007 100755 --- a/pr/f124.trr +++ b/pr/f124.trr @@ -26,4 +26,4 @@ PAGMAT|4|18|2|Pagamento maturato PROVVMAT|4|18|2|Provvigione maturata TIPOPAGPR|2|1|0|Tipo pagamento della provvigione (?) 1 -CODAGE+NRIGA| +CODAGE+ANNO+CODNUM+NDOC+NRIGA| diff --git a/pr/pr0700.cpp b/pr/pr0700.cpp index 2e994ff68..96221b6c5 100755 --- a/pr/pr0700.cpp +++ b/pr/pr0700.cpp @@ -2,7 +2,8 @@ #include #include #include -#include + +#include "../ve/velib.h" #include "prlib.h" #include "provv.h" #include "pr0700a.h" @@ -12,7 +13,13 @@ class TGestione_provv_app:public TApplication { TMask *_msk; - TLocalisamfile *_provv; + TDocumento *_documento; + TLocalisamfile *_provv, + *_rdoc, + *_doc, + *_tab, + *_occas, + *_cfven; TProvvigioni_agente *_prag; bool _dirty; @@ -27,9 +34,11 @@ protected: static bool rate_sheet_notify(TSheet_field& rs, int r, KEY key); static bool nrata_handler(TMask_field& f, KEY key); static bool ndoc_handler(TMask_field& f, KEY key); + static bool calcola_rate_handler(TMask_field& f, KEY k); static bool datascad_handler(TMask_field& f, KEY key); static bool imprata_handler(TMask_field& f, KEY key); static bool improvv_handler(TMask_field& f, KEY key); + static bool enable_handler(TMask_field& f, KEY k); static void fill_rate_doc(TRate_doc& rd, TSheet_field& sf); public: TGestione_provv_app() {}; @@ -41,34 +50,79 @@ static TString16 __current_key; //////////////////////////////////////////////////////////////////////////////////////// // Da fare : -// - abilitazione colonne provvpag e pagato con pulsante -// - Calcolo provvigioni in caso di selezione documento -// +// - Errore: quando si elimina una rata il pgm vuota lo spreadsheet e non aggiorna il video +// con i dati del documento corrente +// - Ultimo ma non meno importante (da ritenersi visualmente valido) lo riempimento fisso +// degli sheet (documenti e rate) in modo da evitare il fastidiosissimo sfarfallio in +// inserimento righe con elementi vuoti //////////////////////////////////////////////////////////////////////////////////////// -bool TGestione_provv_app::nrata_handler(TMask_field& f, KEY key) +bool TGestione_provv_app::calcola_rate_handler(TMask_field& f, KEY key) { - if (key == K_ENTER) - { // Scorre tutte le righe dello spreadsheet esaminando il numero di rata - // nel caso trovi un'altra riga con lo stesso numero, visualizza un errore - const int nrata = atoi(f.get()); - TSheet_field& s = *f.mask().get_sheet(); - const int selected = s.selected(); - const int items = s.items(); // Numero di righe dello spreadsheet - for (int i = 0; i < items; i++) - if (i != selected) + // - Impostazione importi e provvigioni (documento) in caso di selezione documento + // - Calcolo righe di provvigioni in caso di selezione documento (integrato in TDocumento) + // - Rata 0 : importo rata = 0; importo provvigione = provvigione all'atto della fattura (percentuale sugli agenti) + // la provvigione rimanente va suddivisa in rate a seconda del codice pagamento + if (f.focusdirty() && key == K_TAB) + { + TMask& m = f.mask(); + TLocalisamfile& doc = *app()._doc; + doc.put(DOC_PROVV,"D"); + doc.put(DOC_ANNO,m.get_int(F_ANNO)); + doc.put(DOC_CODNUM,m.get(F_CODNUM)); + doc.put(DOC_NDOC,m.get(F_NDOC)); + if (doc.read() == NOERR) // Se esiste il documento allora prende i valori relativi al totale documento, totale provvigione e base di calcolo provvigione + { + TDocumento* documento = app()._documento; + int err = documento->read(doc.curr()); + if (err == NOERR) { - int other_rata = s.row(i).get_int(0); - if (nrata == other_rata) - return f.error_box("Non e' possibile inserire due rate con lo stesso numero"); + m.set(F_DATADOC, documento->data()); + m.set(F_CLIENTE, documento->codcf()); + m.set(F_CODVAL,documento->valuta()); + m.set(F_CAMBIO,documento->cambio()); + m.set(F_DATACAMBIO,documento->get_date(DOC_DATACAMBIO)); + m.set(F_IMPDOC,documento->totale_doc()); + m.set(F_IMPPRDOC,documento->provvigione()); + m.set(F_IMPNETDOC, ZERO /* documento->totale_basec() ???*/); + // Adesso calcoliamo la provvigione all'atto della fatturazione da inserire + // nella rata 0. Il residuo va ripartito nelle rate del documento + TProvvigioni_agente& pra = documento->calc_provvigioni(); + + // Adesso genera le righe da mettere nello spreadsheet. Quando si uscira' dalla riga + // attuale verra' chiamata la doc_sheet_notify() con K_ENTER, che memorizza il tutto + // gestendo automaticamente la eventuale modifica di un documento gia' presente o meno. + + TSheet_field & rs = (TSheet_field&)app()._msk->field(F_RATE_SHEET);// Resetta lo spreadsheet + rs.reset(); + TRate_doc& rd = pra.rate(documento->anno(), m.get(F_CODNUM), documento->numero()); // Estrae le rate appena calcolate + const int numrate = rd.items(); /* Numero rate per questo documento */ + for (int i = 0; i < numrate; i++) + { + TToken_string& ttt = rs.row(i); + TRata& rt = rd[i]; + ttt.add(rt.rata()); // Numero di rata + ttt.add(rt.datascad()); // Data scadenza della rata + ttt.add(rt.imprata().string()); // Importo della rata (occhio alla valuta) + ttt.add(rt.impprovv().string()); // Importo della provvigione per questa rata + ttt.add(""); // Tutti gli altri valori sono a 0 + ttt.add(""); ttt.add(""); ttt.add(""); + ttt.add(""); ttt.add(""); + } + rs.force_update(); + f.set_focusdirty(FALSE); + f.set_dirty(FALSE); } + else + return f.error_box("Errore %d tentando di leggere il documento specificato",err); + } // Altrimenti l'utente e' libero di inserire importi e rate } return TRUE; } bool TGestione_provv_app::ndoc_handler(TMask_field& f, KEY key) { - if (key == K_ENTER) + if (key == K_ENTER) // Quando sta cambiando riga... { // Scorre tutte le righe dello spreadsheet esaminando ANNO+CODNUM+NDOC // nel caso trovi un'altra riga con la stessa chiave, visualizza un errore TSheet_field& s = *f.mask().get_sheet(); @@ -93,10 +147,25 @@ bool TGestione_provv_app::ndoc_handler(TMask_field& f, KEY key) return f.error_box("Non e' possibile inserire due documenti con lo stessa chiave"); } } - if (key == K_TAB) - { - // - Impostazione importi e provvigioni in caso di selezione documento - // - Calcolo righe di provvigioni in caso di selezione documento + return calcola_rate_handler(f, key); +} + +bool TGestione_provv_app::nrata_handler(TMask_field& f, KEY key) +{ + if (key == K_ENTER) + { // Scorre tutte le righe dello spreadsheet esaminando il numero di rata + // nel caso trovi un'altra riga con lo stesso numero, visualizza un errore + const int nrata = atoi(f.get()); + TSheet_field& s = *f.mask().get_sheet(); + const int selected = s.selected(); + const int items = s.items(); // Numero di righe dello spreadsheet + for (int i = 0; i < items; i++) + if (i != selected) + { + int other_rata = s.row(i).get_int(0); + if (nrata == other_rata) + return f.error_box("Non e' possibile inserire due rate con lo stesso numero"); + } } return TRUE; } @@ -114,6 +183,14 @@ bool TGestione_provv_app::datascad_handler(TMask_field& f, KEY key) return TRUE; } +// Abilita le colonne PAGATO e PROVVPAG per evntuale editing degli importi +bool TGestione_provv_app::enable_handler(TMask_field& f, KEY key) +{ + if (key == K_SPACE) + f.mask().enable(-5); + return TRUE; +} + bool TGestione_provv_app::imprata_handler(TMask_field& f, KEY key) { if (key == K_ENTER && __current_key.not_empty()) @@ -239,8 +316,6 @@ bool TGestione_provv_app::doc_sheet_notify(TSheet_field& ds, int r, KEY key) ttt.add(rt.provvpag().string()); ttt.add(rt.saldata() ? "X" : " "); ttt.add(rt.tipopagpr()); - int i = 1; - i++; } rs.force_update(); } @@ -290,10 +365,16 @@ bool TGestione_provv_app::create() { _msk = new TMask("pr0700b") ; _provv = new TLocalisamfile(LF_PROVV); + _doc = new TLocalisamfile(LF_DOC); + _rdoc = new TLocalisamfile(LF_RIGHEDOC); + _cfven = new TLocalisamfile(LF_CFVEN); + _occas = new TLocalisamfile(LF_OCCAS); + _tab = new TLocalisamfile(LF_TAB); _prag = new TProvvigioni_agente; + _documento = new TDocumento; TSheet_field & sf = (TSheet_field&)_msk->field(F_DOC_SHEET); sf.set_notify(doc_sheet_notify); - sf.sheet_mask().set_handler(F_ANNO,ndoc_handler); + sf.sheet_mask().set_handler(F_NDOC,ndoc_handler); TSheet_field & rs = (TSheet_field&)_msk->field(F_RATE_SHEET); rs.set_notify(rate_sheet_notify); TMask& sm = rs.sheet_mask(); @@ -301,6 +382,7 @@ bool TGestione_provv_app::create() sm.set_handler(F_DATASCAD,datascad_handler); sm.set_handler(F_IMPRATA,imprata_handler); sm.set_handler(F_IMPPROVV,improvv_handler); + sm.set_handler(DLG_ENABLE,enable_handler); dispatch_e_menu(MENU_ITEM(1)); return TRUE; @@ -309,8 +391,14 @@ bool TGestione_provv_app::create() bool TGestione_provv_app::destroy() { delete _msk; - delete _provv; + delete _documento; delete _prag; + delete _provv; + delete _doc; + delete _rdoc; + delete _tab; + delete _cfven; + delete _occas; return TRUE; } @@ -368,7 +456,7 @@ void TGestione_provv_app::load_provvigioni(TMask* m) KEY k; bool repeat; - const char* msg = _prag->rows() == 0 ? "Registrare i dati inseriti" : "Registrare le modifiche" ; + const char* msg = _prag->items() == 0 ? "Registrare i dati inseriti" : "Registrare le modifiche" ; fill_sheet_doc(); // Inizializza lo sheet dei documenti _dirty = FALSE; diff --git a/pr/pr0700b.h b/pr/pr0700b.h index e5f4a1baf..a75078e45 100755 --- a/pr/pr0700b.h +++ b/pr/pr0700b.h @@ -35,4 +35,5 @@ #define F_PROVVPAG 108 #define F_SALDATA 109 #define F_TIPOPAGPR 110 +#define DLG_ENABLE 401 diff --git a/pr/pr0700b.uml b/pr/pr0700b.uml index 10e4d38f9..daef82533 100755 --- a/pr/pr0700b.uml +++ b/pr/pr0700b.uml @@ -115,17 +115,17 @@ BEGIN INPUT ANNO F_ANNO INPUT CODNUM F_CODNUM INPUT NDOC F_NDOC - DISPLAY "Anno" ANNO - DISPLAY "Codice numerazione" CODNUM - DISPLAY "Numero documento" NDOC + DISPLAY "Anno@10" ANNO + DISPLAY "Cod. num.@15" CODNUM + DISPLAY "Num. doc.@15" NDOC OUTPUT F_ANNO ANNO OUTPUT F_CODNUM CODNUM OUTPUT F_NDOC NDOC - OUTPUT F_DATADOC DATADOC - OUTPUT F_CLIENTE CODCF - OUTPUT F_CODVAL CODVAL - OUTPUT F_CAMBIO CAMBIO - OUTPUT F_DATACAMBIO DATACAMBIO +// OUTPUT F_DATADOC DATADOC +// OUTPUT F_CLIENTE CODCF +// OUTPUT F_CODVAL CODVAL +// OUTPUT F_CAMBIO CAMBIO +// OUTPUT F_DATACAMBIO DATACAMBIO OUTPUT F_TIPOPAG -401->S4 ADD RUN VE0 -1 END @@ -138,13 +138,13 @@ END NUMBER F_IMPDOC 18 2 BEGIN PROMPT 2 4 "Importo doc. " - PICTURE "##.###.###.###.###" + PICTURE "." END NUMBER F_IMPPRDOC 18 2 BEGIN PROMPT 2 5 "Importo provv. doc. " - PICTURE "##.###.###.###.###" + PICTURE "." NUM_EXPR {(#THIS_FIELD <= #F_IMPDOC)} WARNING "L'importo della provvigione deve essere minore dell'importo documento" END @@ -152,7 +152,7 @@ END NUMBER F_IMPNETDOC 18 2 BEGIN PROMPT 2 6 "Base di calcolo " - PICTURE "##.###.###.###.###" + PICTURE "." NUM_EXPR {(#THIS_FIELD <= #F_IMPDOC)} WARNING "L'importo della base di calcolo deve essere minore dell'importo documento" END @@ -249,19 +249,19 @@ END NUMBER F_IMPRATA 18 2 BEGIN PROMPT 2 3 "Importo rata " - PICTURE "##.###.###.###.###" + PICTURE "." END NUMBER F_IMPPROVV 18 2 BEGIN PROMPT 2 4 "Importo provvigione " - PICTURE "##.###.###.###.###" + PICTURE "." END NUMBER F_PAGMAT 18 2 BEGIN PROMPT 2 7 "Importo pagamento maturato " - PICTURE "##.###.###.###.###" + PICTURE "." NUM_EXPR {(#THIS_FIELD <= #F_IMPRATA)} WARNING "L'importo pagamento maturato deve essere minore dell'importo della rata" END @@ -269,7 +269,7 @@ END NUMBER F_PROVVMAT 18 2 BEGIN PROMPT 2 8 "Importo provvigione maturata " - PICTURE "##.###.###.###.###" + PICTURE "." NUM_EXPR {(#THIS_FIELD <= #F_IMPPROVV)} WARNING "L'importo provvigione maturata deve essere minore dell'importo della provvigione" END @@ -277,15 +277,17 @@ END NUMBER F_PAGATO 18 2 BEGIN PROMPT 2 5 "Importo rata pagata " - PICTURE "##.###.###.###.###" + PICTURE "." FLAGS "D" + GROUP 5 END NUMBER F_PROVVPAG 18 2 BEGIN PROMPT 2 6 "Importo provvigione pagata " - PICTURE "##.###.###.###.###" + PICTURE "." FLAGS "D" + GROUP 5 END BOOLEAN F_SALDATA @@ -309,17 +311,22 @@ END BUTTON DLG_OK 9 2 BEGIN - PROMPT -13 -1 "" + PROMPT -14 -1 "" END BUTTON DLG_CANCEL 9 2 BEGIN - PROMPT -23 -1 "" + PROMPT -24 -1 "" END BUTTON DLG_DELREC 9 2 -BEGIN - PROMPT -33 -1 "" +BEGIN + PROMPT -34 -1 "" +END + +BUTTON DLG_ENABLE 9 2 +BEGIN + PROMPT -44 -1 "~Abilita" END ENDPAGE diff --git a/pr/prlib.h b/pr/prlib.h index c06600206..88aa575cc 100755 --- a/pr/prlib.h +++ b/pr/prlib.h @@ -9,6 +9,8 @@ #include #endif +#include "agenti.h" + class TRata : public TSortable { TDate _datascad; @@ -26,11 +28,15 @@ public: const real impprovv() const { return _impprovv;} const real pagato() const { return _pagato;} const real provvpag() const { return _provvpag;} - const real provvmat() const { return _pagmat;} - const real pagmat() const { return _provvmat;} + const real provvmat() const { return _provvmat;} + const real pagmat() const { return _pagmat;} const bool saldata() const { return _saldata;} const char generata() const { return _generata;} const int tipopagpr()const { return _tipopagpr;} + void set_rata(int n) { _nrata = n; } + void set_datascad(TDate& d) { _datascad = d; } + void set_imprata(real& r) { _imprata = r; } + void set_impprovv(real& r) { _impprovv = r; } void set_saldata(bool b = TRUE) { _saldata = b; } void set_generata(char g = ' ') { _generata = g; } void set(TRectype& rec); @@ -66,8 +72,8 @@ public: const real cambio() const { return _cambio;} const real impnet() const { return _impnetdoc;} const int items() { return _rows.items();} - TRata& row(int i) { return (TRata&) _rows[i]; } - TRata& operator[](int i) { return row(i); } + TRata& row(int i, bool create = FALSE); + TRata& operator[](int i){ return row(i,FALSE); } void add_rata(TRata* r) {_rows.add(r);} void remove_rata(int i = -1) {_rows.destroy(i,TRUE);} // Ordina le rate @@ -80,26 +86,30 @@ public: ~TRate_doc() {} }; -class TProvvigioni_agente : public TObject +class TProvvigioni_agente : public TRectype { TString16 _agente; // Codice agente - TRecord_array *_rows; // Righe provvigionali (LF_PROVV) usato per leggere/scrivere + //TRecord_array *_rows; // Righe provvigionali (LF_PROVV) usato per leggere/scrivere + TRelation* _provv_rel; + TCursor* _provv_cur; TAssoc_array _rate; // Array associativo per ANNO+CODNUM+NDOC // contiene le informazioni del documento con le relative rate. protected: - void rate2rows(); + int rate2rows(int action); public: - const TString16& agente () const { return _agente;} + const TString16& agente () const { return _agente;} + real perc_fatt() const { return get_real(AGE_PERCFATT);} + real perc_fissa() const { return get_real(AGE_PERCPROVV);} // Per operare direttamente sulle righe - const TRectype& operator [](int index) const - { return _rows->operator[](index);} - TRectype& operator[] (int index) { return _rows->operator[](index);} - const int rows() const { return _rows->rows();} + //const TRectype& operator [](int index) const + // { return _rows->operator[](index);} + //TRectype& operator[] (int index) { return _rows->operator[](index);} + const int items() const { return _rate.items();} // lettura, scrittura ecc... - int read(const char* agente); - int write(bool rows = FALSE); // Se rows == TRUE scrive le righe cosi' come sono, senza chiamare la rate2rows - int rewrite(bool rows = FALSE); - int remove(bool rows = FALSE); + int read(const char* agente, const int anno = 0, const char* codnum = NULL, const long = 0L); + int write() { return rate2rows(0); } + int rewrite() { return rate2rows(1); } + int remove() { return rate2rows(2); } // Restituisce un elenco di documenti che hanno rate per le provvigioni di questo agente int documenti(TString_array& kl) { return _rate.get_keys(kl); } // Per accedere tramite singole rate... @@ -108,6 +118,7 @@ public: // Rimuove le rate del documento indicato void remove_rate(int anno, const char* codnum, long ndoc); void remove_rate(const char* key); + void destroy() { _rate.destroy(); } TProvvigioni_agente(const char* agente); TProvvigioni_agente() ; ~TProvvigioni_agente(); diff --git a/pr/prlib01.cpp b/pr/prlib01.cpp index ad72836de..13fc4691f 100755 --- a/pr/prlib01.cpp +++ b/pr/prlib01.cpp @@ -5,47 +5,68 @@ // TProvvigioni_agente -TProvvigioni_agente::TProvvigioni_agente() +TProvvigioni_agente::TProvvigioni_agente() : TRectype(LF_AGENTI) { - _rows = new TRecord_array(LF_PROVV,PROV_NRIGA); +// _rows = new TRecord_array(LF_PROVV,PROV_NRIGA); + _provv_rel = new TRelation(LF_PROVV); + _provv_cur = new TCursor(_provv_rel); } -TProvvigioni_agente::TProvvigioni_agente(const char* agente) +TProvvigioni_agente::TProvvigioni_agente(const char* agente) : TRectype(LF_AGENTI) { - _rows = new TRecord_array(LF_PROVV,PROV_NRIGA); + //_rows = new TRecord_array(LF_PROVV,PROV_NRIGA); + _provv_rel = new TRelation(LF_PROVV); + _provv_cur = new TCursor(_provv_rel); read(agente); } TProvvigioni_agente::~TProvvigioni_agente() { - delete _rows; +// delete _rows; + delete _provv_rel; + delete _provv_cur; } -int TProvvigioni_agente::read(const char* agente) +int TProvvigioni_agente::read(const char* agente, const int anno, const char* codnum, const long ndoc) { int err = NOERR; - TRectype rec(LF_PROVV); - - rec.put(PROV_CODAGE,agente); - _agente = agente; - _rate.destroy(); - _rows->destroy_rows(); - err = _rows->read(rec); // Legge tutte le righe provvigionali di codesto agente + destroy(); // Cancella eventuali residui + TLocalisamfile age(LF_AGENTI); + TRectype::put(AGE_CODAGE,agente); + err = TRectype::read(age); // Carica i dati dell'agente if (err != NOERR) return err; - const int rows = _rows->rows(); - int anno; - long ndoc; - TString key,codnum; - for (int i = 1; i <= rows; i++) // Compila l'assoc_array per documenti/rate + _agente = agente; + + TRectype rec_from(LF_PROVV); + + rec_from.put(PROV_CODAGE,agente); + if (anno != 0) + rec_from.put(PROV_ANNO, anno); + if (codnum != NULL) + rec_from.put(PROV_CODNUM, codnum); + if (ndoc != 0L) + rec_from.put(PROV_NDOC, ndoc); + + TRectype rec_to(rec_from); + + _provv_cur->setregion(rec_from, rec_to); // Cursore da leggere contenente le provvigioni + + const long items = _provv_cur->items(); + TRectype& r = _provv_cur->file().curr(); + TString key, codnum1; + int anno1; + long ndoc1; + for (long i = 0; i < items; i++) // Compila l'assoc_array per documenti/rate { - TRectype& r = _rows->row(i,FALSE); - anno = r.get_int(DOC_ANNO); - codnum = r.get(DOC_CODNUM); - ndoc = r.get_long(DOC_NDOC); - key.format("%4d%4s%7ld",anno,(const char*)codnum,ndoc); // Compone la chiave + *_provv_cur = i; // posiziona il cursore + + anno1 = r.get_int(PROV_ANNO); + codnum1 = r.get(PROV_CODNUM); + ndoc1 = r.get_long(PROV_NDOC); + key.format("%4d%4s%7ld",anno1,(const char*)codnum1,ndoc1); // Compone la chiave const bool exist = _rate.is_key(key); // Guarda se esiste gia' questo documento TRate_doc com_rata(r); @@ -63,32 +84,39 @@ int TProvvigioni_agente::read(const char* agente) return err; } -void TProvvigioni_agente::rate2rows() +int TProvvigioni_agente::rate2rows(int action) { - _rows->destroy_rows(); - // Setta la chiave del TRecord_array - TRectype* chiave = new TRectype(LF_PROVV); - chiave->put(PROV_CODAGE, _agente); - _rows->set_key(chiave); // Scorre gli elementi di _rate (TDoc_rate) uno ad uno // per settare le righe provvigionali TString_array kl; const int items = documenti(kl); // Prende l'elenco dei documenti kl.sort(); // ordina per documento - int nrow = 1; - for (int i = 0; i < items; i++) + int err = NOERR; + for (int i = 0; i < items && err == NOERR; i++) { TRate_doc& rd = (TRate_doc&)_rate[kl.row(i)]; + const int anno = rd.anno(); + const long ndoc = rd.ndoc(); + TString codnum(rd.codnum()); + TRecord_array* rows = new TRecord_array(LF_PROVV,PROV_NRIGA); + // Chiave del TRecord_array + TRectype* k = new TRectype(LF_PROVV); + k->put(PROV_CODAGE, _agente); + k->put(PROV_ANNO,anno); + k->put(PROV_CODNUM,codnum); + k->put(PROV_NDOC,ndoc); + rows->set_key(k); const int ritems = rd.items(); // Ciclo per rate di questo documento + int nrow = 1; for (int j = 0; j < ritems; j++) { TRata& rt = rd[j]; TRectype* record = new TRectype(LF_PROVV); record->put(PROV_CODAGE,_agente); + record->put(PROV_ANNO,anno); + record->put(PROV_CODNUM,codnum); + record->put(PROV_NDOC,ndoc); record->put(PROV_NRIGA,nrow++); - record->put(PROV_ANNO,rd.anno()); - record->put(PROV_CODNUM,rd.codnum()); - record->put(PROV_NDOC,rd.ndoc()); record->put(PROV_NRATA,rt.rata()); record->put(PROV_GENERATA,rt.generata()); record->put(PROV_SALDATA,rt.saldata()); @@ -109,30 +137,25 @@ void TProvvigioni_agente::rate2rows() record->put(PROV_PROVVPAG,rt.provvpag()); record->put(PROV_PAGMAT,rt.pagmat()); record->put(PROV_PROVVMAT,rt.provvmat()); - _rows->add_row(record); + rows->add_row(record); } + switch (action) + { + case 0: // write + err = rows->write(); + break; + case 1: // rewrite + err = rows->rewrite(); + break; + case 2: // remove + err = rows->remove(); + break; + default: // remove + break; + } + delete rows; } -} - -int TProvvigioni_agente::write(bool rows) -{ - if (!rows) - rate2rows(); - return _rows->write(); -} - -int TProvvigioni_agente::rewrite(bool rows) -{ - if (!rows) - rate2rows(); - return _rows->rewrite(); -} - -int TProvvigioni_agente::remove(bool rows) -{ - if (!rows) - rate2rows(); - return _rows->remove(); + return err; } TRate_doc& TProvvigioni_agente::rate(int anno, const char* codnum, long ndoc, bool create) @@ -184,12 +207,18 @@ void TProvvigioni_agente::remove_rate(const char* key) ///////////////////////////////////////////////////////////////////////////////// // TRate_doc ///////////////////////////////////////////////////////////////////////////////// - TRate_doc::TRate_doc(TRectype& rec) { set(rec); // bleah! } +TRata& TRate_doc::row(int i, bool create) +{ + if (create && _rows.objptr(i) == NULL) // Parametro di creazione + _rows.add(new TRata(),i); + return (TRata&) _rows[i]; +} + bool TRate_doc::ok_provvigione() { real totprov;