diff --git a/ca/ca3700.cpp b/ca/ca3700.cpp index c76364b36..7ce0c7570 100755 --- a/ca/ca3700.cpp +++ b/ca/ca3700.cpp @@ -320,6 +320,8 @@ TPrint_rendiconto_ca_mask::TPrint_rendiconto_ca_mask() class TPrint_rendiconto_ca_recordset : public TISAM_recordset { TExternisamfile* _tmp; + bool _riclassificato; + TString _prefix, _da_conto_riclas, _a_conto_riclas; protected: int _anno; @@ -346,7 +348,7 @@ protected: public: virtual void set_filter(const TPrint_rendiconto_ca_mask& msk, int cms_row); - TPrint_rendiconto_ca_recordset(const TString& sql) : TISAM_recordset(sql) { _tmp = NULL;} + TPrint_rendiconto_ca_recordset(const TString& sql) : TISAM_recordset(sql), _riclassificato(false) { _tmp = NULL;} ~TPrint_rendiconto_ca_recordset() {} }; @@ -411,10 +413,20 @@ void TPrint_rendiconto_ca_recordset::set_custom_filter(TCursor& cur) const //filtro sul file esterno (_tmp, cioè 1000) sui conti selezionati sulla maschera TRectype darec(cur.curr()), arec(cur.curr()); //curr perchè è il file externisamfile - darec.put("CONTO", _daconto); - darec.put("DATA", _dadata); - arec.put("CONTO", _aconto); + if (!_riclassificato) + { + darec.put("CONTO", _daconto); + arec.put("CONTO", _aconto); + } + else + { + darec.put("CONTO", _da_conto_riclas); + arec.put("CONTO", _a_conto_riclas); + } + + darec.put("DATA", _dadata); arec.put("DATA", _adata); + cur.setregion(darec, arec); myself = this; @@ -516,45 +528,68 @@ void TPrint_rendiconto_ca_recordset::salva_rmovana(const TRectype& rmovana, cons //compila i campi da stampare // il conto puo' essere analitico o contabile... - //se si usa il piano dei conti contabile ed è compilato l'archivio di collegamento PANAPDC - //si deve usare come conto il campo codconto del panapdc!!!... - TConfig_anal ini; - const bool use_pdc = ini.get_bool("UsePdcc"); - TLocalisamfile panapdc(LF_PANAPDC); - panapdc.setkey(2); - if (use_pdc && panapdc.first() == NOERR) + //se è compilato l'archivio di collegamento PANAPDC + //si deve usare come conto il campo codconto del panapdc!!!... + if (_riclassificato) { - TRectype& rec_panapdc = panapdc.curr(); + TString conto_riclassificato; //stringa che conterrà il conto riclassificato (se sara' trovato) + //prende il gruppo dalla riga rmovana in esame const int gruppo = atoi(rmovana.get(RMOVANA_CODCONTO).left(3)); - const int conto = atoi(rmovana.get(RMOVANA_CODCONTO).mid(3,3)); const long sottoconto = atol(rmovana.get(RMOVANA_CODCONTO).mid(6,6)); - rec_panapdc.put(PANAPDC_GRUPPO, gruppo); - rec_panapdc.put(PANAPDC_CONTO, conto); - rec_panapdc.put(PANAPDC_SOTTOCONTO, sottoconto); - int err = panapdc.read(rec_panapdc, _isgteq); - //poichè non puo' avere la chiave 2 completa, visto che sta cercando l'ultimo elemento.. - //deve fare il confronto campo a campo dei gr/co/sottoc del record corrente con quelli - //estratti qualche riga sopra da rmovana - const int curr_gruppo = rec_panapdc.get_int(PANAPDC_GRUPPO); - if (gruppo - curr_gruppo == 0) + //relazione e cursore su panapdc alla ricerca del conto riclassificato corrispondente + //alla triade gr/co/sottoc di rmovana + TRelation rel_panapdc(LF_PANAPDC); + //servono solamente i record con il gruppo = al gruppo di rmovana + TRectype da_panapdc(LF_PANAPDC); + da_panapdc.put(PANAPDC_GRUPPO, gruppo); + + TString filtro; + if (_prefix.not_empty()) + filtro << "(CODCONTO[1," << _prefix.len() << "]=='" << _prefix << "')"; + + TCursor cur_panapdc(&rel_panapdc, filtro, 2, &da_panapdc, &da_panapdc); + const long panapdc_items = cur_panapdc.items(); + cur_panapdc.freeze(); + if (panapdc_items > 0) //se non ci sono record con il gruppo=rmovana.gruppo ed il prefisso voluto->salta l'rmovana { - const int curr_conto = rec_panapdc.get_int(PANAPDC_CONTO); - if (conto - curr_conto == 0) - { - const long curr_sottoconto = rec_panapdc.get_long(PANAPDC_SOTTOCONTO); - if (sottoconto - curr_sottoconto == 0) + TRectype& rec_panapdc = cur_panapdc.curr(); + for (cur_panapdc = 0; cur_panapdc.pos() < panapdc_items; ++cur_panapdc) + { + int current_conto = rec_panapdc.get_int(PANAPDC_CONTO); + long current_sottoconto = rec_panapdc.get_long(PANAPDC_SOTTOCONTO); + + if (current_conto == 0 && current_sottoconto == 0) { - const TString80 codconto = rec_panapdc.get(PANAPDC_CODCONTO); - _tmp->curr().put("CONTO", codconto); + conto_riclassificato = rec_panapdc.get(PANAPDC_CODCONTO); + _tmp->curr().put("CONTO", conto_riclassificato); + break; //esce dal casino e passa ai campi successivi + } + else if (conto == current_conto && current_sottoconto == 0) + { + conto_riclassificato = rec_panapdc.get(PANAPDC_CODCONTO); + _tmp->curr().put("CONTO", conto_riclassificato); + break; //esce dal casino e passa ai campi successivi } - } - } + else if (conto == current_conto && sottoconto == current_sottoconto) + { + conto_riclassificato = rec_panapdc.get(PANAPDC_CODCONTO); + _tmp->curr().put("CONTO", conto_riclassificato); + break; //esce dal casino e passa ai campi successivi + } + } //for sugli elementi del cursore + } //if panapdc_items > 0 + + //ATTENZIONE! Se era stata operata una selezione sui conti riclassificati nella maschera + //ed il conto riclassificato attuale non ricade nell'intervallo selezionato il programma + //non deve aggiungere il record al file!! + if (conto_riclassificato < _da_conto_riclas || conto_riclassificato > _a_conto_riclas) + return; } - else //...sennò si usa il normale piano dei conti analitico + else //...sennò si usa il normale piano dei conti analitico (cioè tutti tranne che il CRPA) _tmp->curr().put("CONTO", rmovana.get(RMOVANA_CODCONTO)); //conto //i movimenti possono essere normali o generati da documento... @@ -674,11 +709,15 @@ void TPrint_rendiconto_ca_recordset::crea_righe_rmovana() rel_rmovana.add(LF_MOVANA, "NUMREG==NUMREG"); //aggiunge le testate x avere tipi mov e descr //..crea un cursore su rmovana per vedere se i conti selezionati hanno veri movimenti che soddisfano - //i parametri del filtro sulla maschera + //i parametri del filtro sulla maschera. ACHTUNG! Questo filtro ha senso solo se non esiste la + //riclassificazione!!! TRectype da_rmovana(LF_RMOVANA); - da_rmovana.put(RMOVANA_CODCONTO, _daconto); TRectype a_rmovana(LF_RMOVANA); - a_rmovana.put(RMOVANA_CODCONTO, _aconto); + if (!_riclassificato) + { + da_rmovana.put(RMOVANA_CODCONTO, _daconto); + a_rmovana.put(RMOVANA_CODCONTO, _aconto); + } TString filtro; @@ -721,8 +760,12 @@ void TPrint_rendiconto_ca_recordset::crea_righe_rmovana() { const TRectype& rmovana = cur_rmovana.curr(); const TRectype& movana = rel_rmovana.curr(LF_MOVANA); + TProgind pi(rmovana_items, "Scansione righe movimenti..."); for (cur_rmovana = 0; cur_rmovana.pos() < rmovana_items; ++cur_rmovana) + { + pi.addstatus(1); salva_rmovana(rmovana, movana, NULL); + } } } @@ -785,19 +828,24 @@ void TPrint_rendiconto_ca_recordset::crea_righe_rdoc(const TPrint_rendiconto_ca_ const long doc_items = cur_doc.items(); cur_doc.freeze(); - //scanning del file dei documenti alla ricerca di quelli che hanno la data ed il CODNUM - //validi nei filtri impostati dall'utente - for (cur_doc = 0; cur_doc.pos() < doc_items; ++cur_doc) + if (doc_items > 0) { - TDocumento doc(cur_doc.curr()); - TAnal_mov mov; - cont_anal.elabora(doc, 0, NULL, false, mov); - for (int j = 1; j <= mov.rows(); j++) - { - salva_rmovana(mov.body()[j], mov, &doc); - } - } + TProgind pi(doc_items, "Scansione documenti..."); + //scanning del file dei documenti alla ricerca di quelli che hanno la data ed il CODNUM + //validi nei filtri impostati dall'utente + for (cur_doc = 0; cur_doc.pos() < doc_items; ++cur_doc) + { + pi.addstatus(1); + TDocumento doc(cur_doc.curr()); + TAnal_mov mov; + cont_anal.elabora(doc, 0, NULL, false, mov); + for (int j = 1; j <= mov.rows(); j++) + { + salva_rmovana(mov.body()[j], mov, &doc); + } //for int j... + } //for cur_doc.. + } //if doc_items } } @@ -863,19 +911,51 @@ void TPrint_rendiconto_ca_recordset::set_filter(const TPrint_rendiconto_ca_mask& const short dlg_da = tc == 'C' ? F_PDC1_INI : F_PAN1_INI; const short dlg_al = tc == 'C' ? F_PDC1_FIN : F_PAN1_FIN; - for (int i = 0; msk.id2pos(dlg_da+i) > 0; i++) + //si utilizza la riclassificazione dei conti? + if (msk.get(F_PIANO) == "A") + _riclassificato = true; + else + _riclassificato = false; + + //conti non riclassificati + if (!_riclassificato) { - _daconto << msk.get(dlg_da+i); - _aconto << msk.get(dlg_al+i); + for (int i = 0; msk.id2pos(dlg_da+i) > 0; i++) + { + _daconto << msk.get(dlg_da+i); + _aconto << msk.get(dlg_al+i); + } + } + else //conti riclassificati + { + for (int i = 0; msk.id2pos(dlg_da+i) < 43; i++) //***43 andrebbe sostituito con una condizione + seria + { + _da_conto_riclas << msk.get(dlg_da+i); + _a_conto_riclas << msk.get(dlg_al+i); + } } - _dadata = msk.get_date(F_DATAINI); - _adata = msk.get_date(F_DATAFIN); + _dadata = msk.get_date(F_DATAINI); + _adata = msk.get_date(F_DATAFIN); + if (_riclassificato) + { + //esiste un prefisso a più livelli? + if (msk.get(F_PRE1).not_empty()) + { + _prefix << msk.get(F_PRE1); + if (msk.get(F_PRE2).not_empty()) + { + _prefix << msk.get(F_PRE1); + if (msk.get(F_PRE3).not_empty()) + _prefix << msk.get(F_PRE3); + } + } + } //metodo per riempire il file crea_righe_rmovana(); - //crea_righe_rdoc(msk); + crea_righe_rdoc(msk); } @@ -908,7 +988,7 @@ void TPrint_rendiconto_ca_rep::set_filter(const TPrint_rendiconto_ca_mask& msk, { TPrint_rendiconto_ca_recordset* recset = NULL; - const char* query ="USE 1000\nJOIN MOVANA INTO NUMREG==NUMRD\nJOIN RMOVANA INTO NUMREG==NUMRD NUMRIG==NRIGA"; //\nJOIN DOC INTO PROVV=='D' ANNO==ANNO CODNUM==CODNUM"; + const char* query ="USE 1000\nJOIN MOVANA INTO NUMREG==NUMRD\nJOIN RMOVANA INTO NUMREG==NUMRD NUMRIG==NRIGA"; recset = new TPrint_rendiconto_ca_recordset(query);