// ------------------------------------------------------------ // Calcolo liquidazioni // Part 2: calcolo // fv 21-1-94 // ------------------------------------------------------------ #include #include #include #include "cg4300.h" // -------------------- QUI comincia l'avventura -------------------------- // ----------------------------------------------------- ****************** // che nel gennaio 1995 non solo non e' finita, ma si fa ****************** // ogni giorno piu' odiosa e nevrastenica ****************** // ----------------------------------------------------- ****************** // Datemi un punto di appoggio ****************** // e mi ci appoggero' ****************** // ----------------------------------------------------- ****************** bool TLiquidazione_app::recalc_all() { _prind = new TProgind(_selected.ones()*2, _printonly ? " Stampa liquidazione... \n" " Preparazione archivi \n" " " : " Calcolo liquidazione... \n" " Preparazione archivi \n" " ", TRUE,TRUE,45); for (int l = 0; l < _ditte->items(); l++) { if (_prind->iscancelled()) break; if (_selected[(long)l]) { TToken_string& nomeditta = _ditte->row(l); _nditte->zero(); _nditte->curr().put("CODDITTA",nomeditta.get_long(1)); _nditte->read(); TApplication::set_firm(nomeditta.get_long(1)); _prind->addstatus(1); _freqviva = nomeditta.get(3); /* * trimestrali impropriamente selezionate per mesi intermedi * provocano il ricalcolo dei progressivi mensili ma non la stampa */ _canprint = is_month_ok_strict(_month); int need_refresh = FALSE; if (_recalc != ever) { for (int m = 1; m < _month; m++) if (!look_lim(m) || !_lim->get_bool("B0")) { need_refresh = TRUE; break; } if (need_refresh && yesno_box("Alcuni mesi precedenti non " "risultano ricalcolati. E' consigliabile il ricalcolo. " "Si desidera eseguirlo?")) _recalc = ever; } for (int m = 1; m <= _month; m++) if (is_month_ok(m, _month) || _recalc == ever) { if (_prind->iscancelled()) break; update_firm(m); } // se ci sono altri mesi dopo l'ultimo calcolato, invalida il // flag 'calcolato' del primo, per causare il ricalcolo dei // successivi (evitando problemi per credito precedente) for (m = _month+1; m <= 13; m++) if (is_month_ok_strict(m) && look_lim(m)) { _lim->put("B0",""); break; } } } bool canc = _prind->iscancelled(); if (!canc) _prind->addstatus(1); TApplication::set_firm(__firm); delete _prind; _prind = NULL; return !canc; } bool TLiquidazione_app::update_firm(int month, bool recalc) { // Se recalc e' TRUE considera la necessita' di ricalcolare e le // opzioni utente. Se FALSE se ne impipa dell'utente e ricalcola // se necessario (serve nelle chiamate ricorsive) // Ritorna FALSE soltanto se il ricalcolo era necessario e non e' // stato effettuato per scelta dello stronzo commercialista. look_lim(month, TRUE); // gia' ricalcolata definitivamente? bool ok = _lim->get_bool("B1"); if (ok && !_comp_acconto) return TRUE; // azzera ulteriori detrazioni _lim->put("R6",""); _lim->rewrite(); TConfig cnf(CONFIG_DITTA, "cg"); _isricacq = cnf.get_bool("RicAcq"); // ricalcolo normale ok = _lim->get_bool("B0"); if (ok && !recalc) return TRUE; bool calc = (_recalc == ever || (_recalc == one && month == _month)); if (!calc && _recalc != never) calc = !ok; bool gheravergot = FALSE; bool quater = FALSE; TToken_string atts; TToken_string cattivs; _nditte->save_status(); if (_nditte->is_first_match(LF_ATTIV)) { char buf[256]; do { TString16 codatt = _nditte->curr(LF_ATTIV).get("CODATT"); TString80 desatt = _nditte->curr(LF_ATTIV).get("DESCR"); quater = _nditte->curr().get_bool("FLIVA11Q"); // attivita' mista: ce ne sono in realta' due // viene calcolato nel ciclo su tipoatt (che viene ripetuto solo // se diventa TRUE); _mixed = FALSE; sprintf (buf, _printonly ? "Stampa liquidazione (%d)...\n%s: %s\n" : "Calcolo liquidazione (%d)...\n%s: %s\n", month, (const char*)_nditte_r->get("RAGSOC"), (const char*)desatt); if (_prind) _prind->set_text(buf); _vend_arr.destroy(); _corr_arr.destroy(); cattivs = ""; for (int tipoatt = 1; tipoatt <= (_mixed ? 2 : 1); tipoatt++) { TString cattiv(codatt); cattiv << tipoatt; if (tipoatt == 1 && look_pla(cattiv, FALSE)) { _p8 = _pla->get_real("R5"); _p8b = _pla->get_real("R6"); _p9 = _pla->get_real("R7"); _prorata = _pla->get_real("R8"); _isplafond = !(_p8.is_zero() && _p8b.is_zero() && _p9.is_zero()); _isservizio = _pla->get("S7") == "S"; _mixed = _pla->get("S7") == "M" || _pla->get("S7") == "E"; } else _isservizio = _nditte->curr(LF_ATTIV).get("TIPOATT") == "S"; _isviaggio = _nditte->curr(LF_ATTIV).get_bool("REG74TER"); _isagricolo = _nditte->curr(LF_ATTIV).get_bool("REGAGR"); _isbenzinaro = _nditte->curr(LF_ATTIV).get_bool("ART74/4"); bool mens = _freqviva == "M"; _isannual = (_month == 12 && !mens && !_isbenzinaro) || (_month == 13 && (mens || _isbenzinaro)); _isriepilogo = _month == 13; _isvent = FALSE; for (_reg->first(); !_isvent && _reg->good(); _reg->next()) { if (codatt == _reg->get("S8") && _reg->get_int("I0") == 2) _isvent = _reg->get_bool("B3"); } if ((month != 13 || _isannual) && (calc || !recalc)) if (!update_att(month, cattiv)) describe_error("Attivita' non ricalcolate: possibili errori", codatt); // vediamo se c'e' qualcosa da raccontare gheravergot = _isannual || _isriepilogo; if (!gheravergot) { look_plm(month,cattiv); gheravergot = !_plm->get_real("R0").is_zero() || !_plm->get_real("R1").is_zero(); } if (month == _month) describe_att(month,cattiv,gheravergot); atts.add(cattiv); cattivs.add(cattiv); } // for tipoatt // se attivita' mista stampa riepilogo if (_mixed && month == _month) describe_att(month,cattivs, TRUE); } while (_nditte->next_match(LF_ATTIV)); // se quater stampa riepilogo if (quater && month == _month) describe_att(month,atts, TRUE); // occorre poterla chiamare altre volte con mesi diversi _nditte->restore_status(); // aggiorna le liquidazioni mensili if ((_month != 13 || _isannual) && (calc || !recalc)) write_liq(month, atts); // rimborso infraannuale _DescrItem* rimb_d = NULL; if (month == _month && is_trim(month)) { // unica nel suo genere, recalc_rimborso ritorna // un bel descritem (NULL se non si rimborsa un cas) // da passare a describe_liq rimb_d = recalc_rimborso(month,atts); } if (month == _month) { describe_firm(month); describe_liq(_month, atts, rimb_d); } } return ok || calc; } bool TLiquidazione_app::update_att(int month, const char* codatt, bool recalc) // viene passato un codice attivita' con codatt+tipoatt // vedi update_firm per il burdel dei calc e recalc // occhecasino. Se _comp_acconto e' TRUE, i movimenti considerati // saranno solo quelli di dicembre per data <= 20/12; // il ricalcolo e' FORZATO da _recalc messo a one { if (month == 13) recalc_annual(codatt); else { look_plm(month, codatt, TRUE); bool ok = _plm->get_bool("B0"); if (ok && !recalc) return TRUE; bool calc = _recalc == ever || (_recalc == one && month == _month); if (!calc && _recalc != never) calc = !ok; if (calc || !recalc) { zero_att(month,codatt); recalc_att(month,codatt); recalc_ventilation(month, codatt); recalc_corrispettivi(month, codatt); // per trimestrali if (_isannual) recalc_annual(codatt); } return ok || calc; } return TRUE; } void TLiquidazione_app::zero_att(int month, const char* codatt) { for (_pim->first(); !_pim->eof(); _pim->next()) { int m = atoi(*_pim_mese); TString att = (const char*)*_pim_codatt; if (m == month && att == codatt) { _pim->put("R0",""); _pim->put("R1",""); _pim->put("R2",""); _pim->rewrite(); } } if (_isplafond) zero_plafond(month,codatt); } void TLiquidazione_app::recalc_att(int month, const char* codatt) // il codatt passato e' codice att + tipo att ( IN {1|2} ) // occhecasino. Se _comp_acconto e' TRUE, i movimenti considerati // saranno solo quelli di dicembre per data <= 20/12; { real totintra = 0.0; real nond19_imp = 0.0; real nond19_iva = 0.0; real ammort = 0.0; real ammort_iva = 0.0; real ammort_6 = 0.0; real ammort_6_iva = 0.0; real acq_riv = 0.0; real acq_riv_iva = 0.0; real leasing = 0.0; real leasing_iva = 0.0; real cess_amm = 0.0; real cess_amm_iva = 0.0; real acquisti = 0.0; real acquisti_iva = 0.0; real vendite = 0.0; real vendite_iva = 0.0; real esenti_b1 = 0.0; real esenti_b2 = 0.0; real esenti_b3 = 0.0; real esenti_b14 = 0.0; real corr_CEE = 0.0; real corr_noCEE = 0.0; real acq_CEE = 0.0; real acq_noCEE = 0.0; real corr_misCEE = 0.0; real acq_misCEE = 0.0; real acq_misnoCEE = 0.0; real agr_ven = 0.0; real agr_acq = 0.0; real agr_conf = 0.0; real agr_acc = 0.0; real for_rimb = 0.0; real acq_ies = 0.0; real acq_ies_iva = 0.0; real ult_detr = 0.0; real acq_pint = 0.0; real acq_pint_iva = 0.0; real spgen = 0.0; real spgen_iva = 0.0; *_cur = 0; long items = _cur->items(); TString trueatt(codatt); int tipatt = atoi(trueatt.sub(5)); trueatt = trueatt.left(5); for (; _cur->pos() < items; ++(*_cur)) { TDate date(_mov_r->get("DATAREG")); TString16 reg = _mov_r->get("REG"); bool isreg = look_reg(_mov_r->get("REG")); TString16 tipodoc = _mov_r->get("TIPODOC"); /* * check register present, rmoviva present and date OK */ const bool dok = !is_date_ok(date, month); const bool sreg = !isreg; const bool rs8 = _reg_r->get("S8") != trueatt; const bool cmt = !_cur->is_first_match(LF_RMOVIVA); if (dok || sreg || rs8 || cmt) continue; /* * Fatture in sospensione di imposta non vengono considerate */ if (_reg->get_bool("B1")) continue; /* * Tipo documento da eliminare (Scudler 1994) */ if (tipodoc == "SN" || tipodoc == "CN" || tipodoc == "RN" || tipodoc == "IN" || tipodoc == "PG") continue; /* * Fatture in ritardo vengono considerate solo in dichiarazione * annuale */ if (!_isannual && _cur->curr(LF_CAUSALI).get_bool("RITFATT")) continue; /* * check date se si calcola l'acconto */ if (_month == 12 && _comp_acconto) if (date.month() != 12 && date.day() > 20) continue; bool corrisp = _reg_r->get_bool("B0"); tiporeg tipomov = (tiporeg)_reg_r->get_long("I0"); do { look_iva(_rmoviva->get("CODIVA")); TString codiva = _iva->get("CODTAB"); TString tipoiva = _iva->get("S1"); int tipoes_v = (int)_iva->get_long("I3"); int tipoes_a = (int)_iva->get_long("I4"); int tipoagr = atoi(_iva->get("S4")); int tipoag = atoi(_iva->get("S5")); int tipopla = atoi(_iva->get("S3")); int tipodet = atoi(_rmoviva->get("TIPODET")); bool ivarimb = _iva->get_bool("B3"); TString tipocr_s = _rmoviva->get("TIPOCR"); int tipocr = atoi(tipocr_s); real imponibile = _rmoviva->get_real("IMPONIBILE"); real imposta = _rmoviva->get_real("IMPOSTA"); bool intra = _rmoviva->get_bool("INTRA"); int tipoatt = _rmoviva->get_int("TIPOATT"); int rigaimp = _rmoviva->get_int("RIGAIMP"); // autofatture art. 17 per non residenti, con trattamento // speciale in liquidazione annuale bool autodafe = (tipodoc == "AF" && tipocr == 4); /* * puo' capitare per motivi brutalmente prassici * SENSU Sergio 1995, Guido */ if (tipoatt == 0) tipoatt = 1; if(tipoatt != tipatt) continue; /* * Riga imponibile > 9 = ritenute; non si * considerano (Scudler 1994) */ if(rigaimp > 9) continue; // ***************************************** // casi particolari // ***************************************** // imposta acquisti intracomunitari if (tipomov == acquisto && intra) totintra += imposta; // Altre cose di cui tener conto if (tipomov == acquisto && (tipocr == 1 || tipocr == 5)) /* * Acquisto beni per rivendita: sono comunque sommati, ma * vengono considerati in ventilazione solo se l'apposito * parametro ditta e' settato, piu' altre condizioni (vedi * recalc_ventilation() for spulcing) */ { acq_riv += imponibile; acq_riv_iva += imposta; } else if (tipomov == acquisto && tipocr == 2) // Acquisto beni ammortizzabili { ammort += imponibile; ammort_iva += imposta; } else if (tipomov == acquisto && tipocr == 3) // Acquisto beni ammortizzabili detr. 6% { ammort_6 += imponibile; ammort_6_iva += imposta; ult_detr += imponibile * real(DETRAZIONE_6PERCENTO); } else if (tipomov == vendita && tipocr == 4) /* * Vendite strum. art 17 (cess. amm.) * Comprende anche autofatture, anche nell'annuale * (Sergio 1995) */ { cess_amm += imponibile; cess_amm_iva += imposta; } else if (tipomov == acquisto && tipocr == 8) // Acquisto beni strum. acquisiti in leasing { leasing += imponibile; leasing_iva += imposta; } else if (tipomov == acquisto && tipocr == 9) // Spese generali { spgen += imponibile; spgen_iva += imposta; } // operazioni per calcolo rimborso infracazzuale if (tipomov == acquisto && (tipoiva == "ES" || tipoiva == "NI") && ivarimb) { /* * solo determinati tipi costo (Scudler 1995) */ if (tipocr == 0 || tipocr == 1 || tipocr == 5) { /* * se agricolo, vale solo se tipoagr == 2 * cfr. disegnini Scudler 1995 */ if (!_isagricolo || (_isagricolo && tipoagr == 2)) for_rimb += imponibile; } } // operazioni esenti if (tipoiva == "ES") { if (tipomov == vendita) { switch(tipoes_v) { case 1: esenti_b1 += imponibile; break; case 2: esenti_b2 += imponibile; break; case 3: esenti_b3 += imponibile; break; } } else if (tipoes_a == 14) esenti_b14 += imponibile; } // plafond if (_isplafond && tipomov == acquisto && !_isannual && tipoiva == "NI" && tipopla != 0) { add_plafond(month, codatt, tipopla, imponibile, tipodoc == "BD"); } // agenzie viaggio (CHECK imponibili etc.) if (_isviaggio) switch (tipoag) { case 1: if (tipomov == acquisto) acq_CEE += imponibile; else corr_CEE += imponibile; break; case 2: if (tipomov == acquisto) acq_noCEE += imponibile; else corr_noCEE += imponibile; break; case 3: corr_misCEE += imponibile; break; case 4: acq_misCEE += imponibile; break; case 5: acq_misnoCEE += imponibile; break; } if (_isagricolo) switch(tipoagr) { case 1: if (tipomov == acquisto) agr_acq += imposta; else agr_ven += imposta; break; case 2: if (tipomov == vendita) agr_conf += imposta; break; case 3: if (tipomov == vendita) agr_acc += imposta; break; } if (tipodet == 1) // acquisti indeducibili su ricavi esenti art. 10 { acq_ies += imponibile; acq_ies_iva += imposta; } if (tipodet == 3) // passaggi interni (solo per ventilaz) { acq_pint += imponibile; acq_pint_iva += imposta; } // acquisti non detraibili art. 19 // possono valere per la ventilazione if (tipodet == 9) { nond19_imp += imponibile; nond19_iva += imposta; } // ***************************************** // Fine casi particolari // Non che i casi normali siano tanto meglio // ***************************************** /* * Calcolo e aggiornamento * cerca o crea progressivo IVA */ look_pim(month, codatt, reg, tipocr_s, codiva, tipodet, TRUE); /* * se liq == FALSE gli importi non contano ai fini * del calcolo liquidazione */ bool liq = !(tipodet == 1 || tipodet == 3 || tipodet == 9); real imp = _pim_r->get_real("R0"); // imponibile real ivp = _pim_r->get_real("R1"); // IVA su imp. real lor = _pim_r->get_real("R2"); // lordo /* * le maledette fatture con scontrino sono sul registro dei * corrispettivi, ma vanno riportate nelle vendite in stampa; * dunque, le sommiamo in R5 e R6 di PIM anche se continuiamo * a sommarle anche in R0 e R1. La stampa (describe_pim) * dovra' scorporarle */ real ifs = _pim_r->get_real("R5"); // imponibile fatture con scontrino real vfs = _pim_r->get_real("R6"); // IVA fatt. con scontrino /* * le maledette autofatture non residenti art. 17 * vedi al calcolo if (autodafe) si tengono da parte * La stampa le scorpora solo IN SEDE di dichiarazione annuale * NELL'OTTICA di una PIU' CORRETTA e CONSONA ...................... */ real adf = _pim_r->get_real("R7"); real adi = _pim_r->get_real("R8"); if (liq && tipomov == vendita && !corrisp) // i corrispettivi sono gestiti a parte { // totale vendite vendite += imponibile; vendite_iva += imposta; } else if (liq && tipomov == acquisto) { // totale acquisti acquisti += imponibile; acquisti_iva += imposta; } // corrispettivi if (corrisp) { /* * ennesimo casino: non tutti i corrispettivi sono * corrispettivi; in effetti, alcuni corrispettivi * non sono corrispettivi. Ci si potrebbe domandare * se gli altri corrispettivi sono corrispettivi o * no; ebbene, gli altri corrispettivi risultano * fortunatamente essere corrispettivi. */ if (tipodoc == "CR" || tipodoc == "RF" || tipodoc == "SC") { // questi sono corrispettivi davvero; comportamento normale if (tipoiva == "VE") // da ventilare { lor += imponibile; _pim_r->put("I0",LORDO); add_vendite(month, reg, tipodet, imponibile); } else // non da ventilare, con imposta gia' conteggiata { real perc = _iva->get_real("R0") / CENTO; lor += imponibile + imposta; _pim_r->put("I0",LORDO); if (liq) add_corrisp(month, reg, imponibile, perc, tipodet, codiva); } } else if (tipodoc == "FS") { // queste sono fatture che seguono scontrino, il lordo va detratto // perche' si e' gia' registrato lo scontrino medesimo if (tipoiva == "VE") { real rr = imponibile + imposta; imp += rr; if (liq) vendite += rr; add_vendite(month, reg, tipodet, rr); } else { if (liq) { vendite += imponibile; vendite_iva += imposta; } imp += imponibile; ivp += imposta; } lor -= imponibile + imposta; ifs += imponibile; vfs += imposta; } else // vendite normali a tutti gli effetti { if (liq) { vendite += imponibile; vendite_iva += imposta; } imp += imponibile; ivp += imposta; ifs += imponibile; vfs += imposta; _pim_r->put("I0",NETTO); } } // if corrisp else // non corrisp { // imponibile e imposta separata imp += imponibile; ivp += imposta; _pim_r->put("I0",NETTO); } if (autodafe) // autofatture non residenti art, 17 { /* * Si devono riportare a parte in annuale * e non comparire nel riepilogo del codice IVA * corrispondente, solo se la liq. e' annuale * Li metto in R7/R8 di pim e li sommo anche nelle * vendite; la describe_pim() dovra' sommarli su tutti i * pim, scorporarli dalle rispettive vendite * e assegnarli al codice IVA A35 in caso di liq. annuale */ adf += imponibile; adi += imposta; } _pim_r->put("R0",imp); _pim_r->put("R1",ivp); _pim_r->put("R2",lor); _pim_r->put("R5",ifs); _pim_r->put("R6",vfs); _pim_r->put("R7",adf); _pim_r->put("R8",adi); _pim->rewrite(); } while (_cur->next_match(LF_RMOVIVA)); } // calcolati tutti i movimenti e aggiornati i pim // salviamo i totali antes que seja tarde /* * calcola il lercio prorata */ real prorata; if (!_prorata.is_zero()) { prorata = acquisti_iva * (_prorata / CENTO); prorata.round(ROUND_LIRA); } look_plm(month, codatt, TRUE); /* * ACHTUNG: l'iva sulle vendite e' calcolata sommando anche i * corrispettivi che sono corrispettivi, a differenza dei corrispettivi * che non sono corrispettivi, ma tanto quelli (come si sa) non sono * corrispettivi. Dunque, non si tiene conto delle imposte calcolate * con la ventilazione (che vanno sottratte) ne' di quelle * calcolate per le agenzie di viaggio (che sembra non vadano * comunque sottratte nel calcolo del volume di affari) */ _plm->put("R2", prorata); if (_isviaggio) { _plm->put("R5", corr_CEE); _plm->put("R6", corr_noCEE); _plm->put("R7", acq_CEE); _plm->put("R8", acq_noCEE); _plm->put("R9", corr_misCEE); _plm->put("R10",acq_misCEE); _plm->put("R11",acq_misnoCEE); } else if (_isagricolo) { _plm->put("R5", agr_ven); _plm->put("R6", agr_conf); _plm->put("R7", agr_acc); _plm->put("R8", agr_acq); // Il porco agricoltore spende poco e paga meno acquisti_iva -= (agr_acq + leasing_iva + ammort_iva + ammort_6_iva); vendite_iva -= (agr_ven + agr_conf + agr_acc); } // COSA MI TOCCA FARE (per campare, of course) // due numeri nello stesso campo ma e' sempre meglio // del TIPO RECORD TToken_string s(40); _plm->put("R0", vendite_iva); _plm->put("R1", acquisti_iva); _plm->put("R3", ult_detr); // probabilmente R4 serviva per il decalage e non si usera' _plm->put("R12", _prorata); // per comodita' in stampa _plm->put("B0", "X"); // calcolato (invalidato dalla primanota) _plm->put("S1", for_rimb.string()); // si riempiano le stringhe di coppie di real s.add(acq_ies.string()); s.add(acq_ies_iva.string()); _plm->put("S2", (const char*)s); s = ""; s.add(acq_pint.string()); s.add(acq_pint_iva.string()); _plm->put("S3", (const char*)s); s = ""; s.add(spgen.string()); s.add(spgen_iva.string()); _plm->put("S4", (const char*)s); _plm->rewrite(); // salva gli altri totali para no ponernos locos despues look_ptm(month, codatt, TRUE); _ptm->put("R0", totintra); _ptm->put("R1", nond19_imp); _ptm->put("R2", nond19_iva); _ptm->put("R3", ammort); _ptm->put("R4", ammort_iva); _ptm->put("R5", ammort_6); _ptm->put("R6", acq_riv); _ptm->put("R7", acq_riv_iva); _ptm->put("R8", leasing); _ptm->put("R9", leasing_iva); _ptm->put("R10", cess_amm); _ptm->put("R11", cess_amm_iva); _ptm->put("R12", ammort_6_iva); _ptm->put("R13", esenti_b1); _ptm->put("R14", esenti_b2); _ptm->put("S0", esenti_b3.string()); _ptm->put("S1", esenti_b14.string()); _ptm->put("S2", acquisti.string()); _ptm->put("S3", vendite.string()); _ptm->rewrite(); } void TLiquidazione_app::write_liq(int month, const char* codatts) // Calcolo liq. mensili e progr. liq. annuali { TToken_string atts(codatts); const char* tmpatt; real risultato = 0.0; real vol_aff = 0.0; real debito_prec = 0.0; real detrazioni = 0.0; // totali per agenzie viaggio real c_iCEE(0.0); real c_eCEE(0.0); real a_iCEE(0.0); real a_eCEE(0.0); real c_mCEE(0.0); real a_mCEE(0.0); real a_meCEE(0.0); real cred_cost(0.0); real deb_mens(0.0); real perc_r(0.0); while ((tmpatt = atts.get()) != NULL) { TString att(tmpatt); for (int m = 1; m <= 12; m++) { // ciclo su tutti i mesi del caso (1 o 3) // non porta via tempo anche cosi' if (!_isannual && !is_month_ok(m, month)) continue; look_plm(month, att); look_ptm(month,att); // a debito: IVA vendite, debito precedente, Prorata // a credito: IVA acquisti, ulteriori detrazioni 1 e 2 risultato += (_plm->get_real("R0") - _plm->get_real("R1") + _plm->get_real("R2") - _plm->get_real("R3") - _plm->get_real("R4")); detrazioni+= (_plm->get_real("R3") + _plm->get_real("R4")); if (_isviaggio) { // somma totali per calcolo successivo c_iCEE += _plm->get_real("R5"); c_eCEE += _plm->get_real("R6"); a_iCEE += _plm->get_real("R7"); a_eCEE += _plm->get_real("R8"); c_mCEE += _plm->get_real("R9"); a_mCEE += _plm->get_real("R10"); a_meCEE += _plm->get_real("R11"); } } // fine ciclo sul mese // toglie credito precedente considerando rimborsi // e acconto versato e rettifiche, come da manuale risultato -= credito_prec(month); // vedi se c'era un debito precedente per debiti < 50.000 risultato += debt_prec(month); if (_isviaggio) { // calcolo credito costo, debito mensile, perc. ripart. perc_r = (a_mCEE * CENTO)/(a_mCEE + a_meCEE); real c = (c_mCEE * perc_r)/CENTO; c.round(ROUND_LIRA); real tc = (c_iCEE + c); real ta = (a_iCEE + a_mCEE); real bi = tc - ta - credito_costo_prec(month); if (bi.sign() < 0) // credito di costo { cred_cost = abs(bi); cred_cost.round(ROUND_LIRA); } else { deb_mens = (bi /((CENTO + aliquota_agvia())/CENTO)) * (aliquota_agvia()/CENTO); deb_mens.round(ROUND_LIRA); } } } look_lim(month,TRUE); _lim->put("R0",risultato); _lim->put("R2",cred_cost); _lim->put("R3",perc_r); _lim->put("R4",deb_mens); _lim->put("R6",detrazioni); if (_freqviva == "T" && risultato.sign() > 0) { real interesse = interesse_trimestrale(_month); real ivi = risultato * interesse / CENTO; ivi.ceil(ROUND_LIRA); _lim->put("R7",ivi); } _lim->put("B0","X"); _lim->rewrite(); } void TLiquidazione_app::recalc_annual(const char* att) { // calcolo volume d'affari e altro real es_b1 = 0.0; real es_b2 = 0.0; real es_b3 = 0.0; real cess_amm = 0.0; real vendite = 0.0; real pro_pag = 0.0; real acq_iva = 0.0; // per conguaglio prorata real acq = 0.0; real ivlac = 0.0; real ivven = 0.0; real ven_lrd = 0.0; int tipoatt = att[strlen(att) -1] - '0'; TString aaa(att); if (tipoatt == 2) { // istanzia ai valori precedenti, calcolati per l'attivita' 1 // llok_pla forza a 1 il tipo attivita' if (look_pla(aaa)) { vendite = _pla->get_real("R0"); es_b1 = _pla->get_real("R1"); es_b2 = _pla->get_real("R2"); es_b3 = _pla->get_real("R3"); cess_amm = _pla->get_real("R4"); ivven = _pla->get_real("R11"); ivlac = _pla->get_real("R12"); ven_lrd = _pla->get_real("R13"); acq = _pla->get_real("R14"); } } for (int i = 1; i <= 12; i++) { // ricalcola se necessario if (i != 12 && !update_att(i,aaa,FALSE)) describe_error("Attivita' non ricalcolata: " "possibili errori",att); look_ptm(i,aaa); look_plm(i,aaa); real vend(_ptm->get("S3")); ven_lrd += vend; // lordo vendite // non entra l'IVA per calcolo volume affari vendite += (vend - _plm->get_real("R0")); real eb3(_ptm->get("S0")); es_b1 += _ptm->get_real("R13"); es_b2 += _ptm->get_real("R14"); es_b3 += eb3; acq_iva += _plm->get_real("R1"); cess_amm += _ptm->get_real("R10"); pro_pag += _plm->get_real("R2"); real aax(_ptm->get("S2")); acq += aax - // rilevanti per aliquota media _ptm->get_real("R3") - // toglie ammortizz. etc _ptm->get_real("R5") - // non detraibili non ci sono _ptm->get_real("R8"); ivlac += _plm->get_real("R1") - // idem per IVE _ptm->get_real("R4") - _ptm->get_real("R9") - _ptm->get_real("R12"); ivven += _plm->get_real("R0"); } // calcolo prorata real prorata = (es_b1/(vendite - cess_amm - es_b3)) * CENTO; real conguaglio = 0.0; prorata.round(ROUND_LIRA); if (prorata != _prorata) { // calcolo conguaglio -- se positivo e' a debito real topay = acq_iva * (prorata / CENTO); conguaglio = topay - pro_pag; } look_pla(aaa); _pla->put("R0", vendite); _pla->put("R1", es_b1); _pla->put("R2", es_b2); _pla->put("R3", es_b3); _pla->put("R4", cess_amm); _pla->put("R9", prorata); _pla->put("R10", conguaglio); _pla->put("R11", ivven); _pla->put("R12", ivlac); _pla->put("R13", ven_lrd); _pla->put("R14", acq); _pla->rewrite(); } _DescrItem* TLiquidazione_app::recalc_rimborso(int month, const char* codatts) { bool rimborsami = FALSE; _DescrItem* d = NULL; TToken_string atts(codatts); const char* tmpatt; TString att; real iva_v, iva_a, imp_a, es_ni, vol_aff; while ((tmpatt = atts.get()) != NULL) { att = tmpatt; look_plm(month,att); look_ptm(month,att); real tvol(_ptm->get("S3")); vol_aff += tvol; real esni(_plm->get("S1")); es_ni += esni; iva_a += _plm->get_real("R1"); iva_v += _plm->get_real("R0"); real aax(_ptm->get("S2")); imp_a += aax - // rilevanti per aliquota media _ptm->get_real("R3") - // toglie ammortizz. etc _ptm->get_real("R5") - // non detraibili non ci sono _ptm->get_real("R8"); if (_freqviva == "M") // sommiamo i due mesi precedenti { for (int m = month - 2; m < month; m++) { bool ok = look_plm(m,att); if (!ok) if (!update_att(m, att)) describe_error("Attivita' non ricalcolate: possibili errori", att); look_ptm(m,att); real tvol(_ptm->get("S3")); vol_aff += tvol; real esni(_plm->get("S1")); es_ni += esni; iva_a += _plm->get_real("R1"); iva_v += _plm->get_real("R0"); real aax(_ptm->get("S2")); imp_a += aax - // rilevanti per aliquota media _ptm->get_real("R3") - // toglie ammortizz. etc _ptm->get_real("R5") - // non detraibili non ci sono _ptm->get_real("R8"); } } } // condizione 1 if (!vol_aff.is_zero() && (es_ni/vol_aff) > MIN_PARTE_ESENTE) { rimborsami = TRUE; d = new _DescrItem(RIMBORSO); d->_f0 = TRUE; d->_r0 = es_ni; d->_r1 = vol_aff; } real alv = vol_aff.is_zero() ? real(0.0) : (iva_v / vol_aff); real ala = imp_a.is_zero() ? real(0.0) : (iva_a / imp_a); alv.round(2); ala.round(2); // condizione 2 if (ala > alv) { rimborsami = TRUE; if (d == NULL) d = new _DescrItem(RIMBORSO); d->_f1 = TRUE; d->_r2 = vol_aff; d->_r3 = imp_a; d->_r4 = iva_v; d->_r5 = iva_a; d->_r6 = alv * CENTO; d->_r7 = ala * CENTO; } return d; }