diff --git a/cg/cg7200.cpp b/cg/cg7200.cpp index b60db9abc..0432dd235 100755 --- a/cg/cg7200.cpp +++ b/cg/cg7200.cpp @@ -139,6 +139,120 @@ void TInvioP_mask::config_setter(TSheet_field& sf, const char* paragrafo) } } +////////////////////////////////////////////// +// STRUCT (saldo di 1 conto) +////////////////////////////////////////////// +struct TInvioP_saldo : public TObject +{ + TString16 _zio; + TImporto _importo; + + TInvioP_saldo(const TRectype& r); + TInvioP_saldo(const TString& zio, const TImporto& importo); +}; + +TInvioP_saldo::TInvioP_saldo(const TRectype& r) +{ + const TBill zio(r); + _zio = zio.string(0x8); + + const char sezione = r.get_char(RMV_SEZIONE); + const real imp = r.get_real(RMV_IMPORTO); + _importo.set(sezione, imp); + _importo.normalize(); +} + +TInvioP_saldo::TInvioP_saldo(const TString& zio, const TImporto& importo) + : _zio(zio), _importo(importo) +{} + + +////////////////////////////////////////////// +// SALDI MOVIMENTO CONTABILE +////////////////////////////////////////////// +class TInvioP_saldi_cg : public TArray +{ +public: + //prende l'oggetto i-esimo (in questo caso un TInvioP_saldo) e ritorna il conto di tale oggetto + const TString& conto(int i) { return ((TInvioP_saldo*)objptr(i))->_zio; } + //stessa roba ma per l'importo + TImporto& importo(int i) { return ((TInvioP_saldo*)objptr(i))->_importo; } + bool sottrai_importo(const TString& conto, const TImporto& importo); + void somma(const TRectype& rmov); + void sottrai(const TRectype& rmovana); +}; + +void TInvioP_saldi_cg::somma(const TRectype& rmov) +{ + TInvioP_saldo* s = new TInvioP_saldo(rmov); + add(s); +} + +bool TInvioP_saldi_cg::sottrai_importo(const TString& zio, const TImporto& imp) +{ + int k; + //caso fortunato + //scandisce gli elementi dell'array;se ne trova uno (k-esimo) con conto ed importo coincidenti.. + //..con quelli passati al metodo, azzera l'importo di tale elemento dell'array + for (k = 0; k < items(); k++) + { + if (conto(k) == zio && importo(k) == imp) + { + importo(k).set('D', ZERO); + return true; + } + } + + //caso sfortunato + //in questo caso gli importi dell'elemento k-esimo dell'array e passato al metodo NON coincidono + TImporto residuo = imp; + int ultima_riga_buona = -1; + + for (k = 0; k < items() && !residuo.is_zero(); k++) + { + if (conto(k) == zio) + { + TImporto& val = importo(k); + residuo.normalize(val.sezione()); + if (residuo >= val) + { + residuo -= val; + val.set('D', ZERO); + } + else + { + val -= residuo; + residuo.set('D', ZERO); + } + ultima_riga_buona = k; + } + } + //alla fine del ciclo sull'array resta un residuo non nullo.. + if (!residuo.is_zero()) + { + residuo.normalize(); + residuo.swap_section(); + if (ultima_riga_buona >= 0) + importo(ultima_riga_buona) += residuo; +// else +// add(new TInvioP_saldo(zio, residuo)); + } + return true; +} + +void TInvioP_saldi_cg::sottrai(const TRectype& rmovana) +{ + //adesso tocca alle righe contabili senza commessa + 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)); + + const TBill zio(gruppo, conto, sottoconto); + + const TImporto importo(rmovana.get_char(RMOVANA_SEZIONE), rmovana.get_real(RMOVANA_IMPORTO)); + sottrai_importo(zio.string(0x8), importo); +} + ////////////////////////////////////////////// // APPLICAZIONE ////////////////////////////////////////////// @@ -362,25 +476,68 @@ bool TInvioP::i_proforma_righe(TCursor& cur, TInvioP_file* trasfilerighe) //necessita del numreg del corrente movimento analitico per poterlo istanziare e prenderne le righe const long numreg = cur.curr().get_long(MOVANA_NUMREG); TAnal_mov analmov(numreg); //..istanzia il movimento analitico cercato.. - + //..prende il numregcg che usera' per risalire ai movimenti analitico ed iva + const TString8 numregcg = analmov.get(MOVANA_NUMREGCG); + TRecord_text recrighe; //istanzia il tipo record corretto da scrivere sul trasfilerighe recrighe.set_type("R"); + TInvioP_saldi_cg conti_importi; + + //Creo un movimento PN (con numreg = a quello del movana)che servira' un po' dovunque + TMovimentoPN pn; + pn.curr().put(MOV_NUMREG, numregcg); + if (pn.read() == NOERR) + { + for (int j = 0; j < pn.cg_items(); j++) + conti_importi.somma(pn.cg(j)); + } + int i; for (i = 1; i <= analmov.body().rows(); i++) { - //..e scandisce le righe alla ricerca di quelle con conto = gruppo/conto/sottoconto del movimento contabile + //..e scandisce le righe const TRectype& riga = analmov.body().row(i); - //inganno il cursore passandogli la riga analitica in esame + //inganna il cursore passandogli la riga analitica in esame (bastardo!) cur.curr(LF_RMOVANA) = riga; - - trasfilerighe->autoload(recrighe, cur); + //carica le righe analitiche + trasfilerighe->autoload(recrighe, cur); + //tglie le righe contabili corrispondenti che sono appena state aggiunte con la autoload (sarebbero.. + //..duplicate se non lo facesse!!!) + conti_importi.sottrai(riga); + //scrive sul file di trasferimento (alla faccia della semplicita'!) trasfilerighe->write(recrighe); } + //prende le righe contabili che non sono state eliminate dalle analitiche nelle sottrai(riga).. + //..in modo da passare anche quelle (in caso contrario sarebbero andati perduti gli importi di.. + //..tali righe che non avevano commessa!) + TString workstring; //stringa di lavoro che serve nel ciclo sotto + for (i = 0; i < conti_importi.items(); i++) + { + if (!conti_importi.importo(i).is_zero()) + { + //aggiunge i valori ai campi uno ad uno perchè non ha un cursore per fare l'autoload + recrighe.destroy(); + recrighe.add(numregcg, 0); //numreg + workstring = "N"; + recrighe.add(workstring, 1); //rigaiva + TImporto& imp = conti_importi.importo(i); + workstring = imp.sezione(); + recrighe.add(workstring, 2); //sezione + const TString& zio = conti_importi.conto(i); + recrighe.add(zio.left(3), 3); //gruppo + recrighe.add(zio.mid(3,3), 4); //conto + recrighe.add(zio.mid(6,6), 5); //sottoconto + recrighe.add(pn.curr().get(MOV_TIPO), 6); //tipocf + recrighe.add(pn.curr().get(MOV_CODCF), 7); //codcf + recrighe.add(pn.curr().get(RMV_DESCR), 8); //descrizione + recrighe.add(imp.valore().string(), 9); //importo + } + } //---- righe iva ---- //adesso tocca alle righe iva...e sara' un casino indicibile! - const TString8 numregcg = analmov.get(MOVANA_NUMREGCG); + //record_array con le righe iva aventi il numreg = numregcg analitico TRecord_array righeiva(numregcg, LF_RMOVIVA); //assoc array contenente tutti i diversi conti che incontrera' nello scanning delle righe iva