// ------------------------------------------------------------ // Calcolo liquidazioni // Part 2: calcolo // fv 21-1-94 // ------------------------------------------------------------ #include #include #include #include #include #include #include #include #include "cg4300.h" #ifdef DBG #if XVT_OS == XVT_OS_WIN #define STRICT #include #endif #endif // -------------------- QUI comincia l'avventura -------------------------- // 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); int save_month = _month; /* ------------------------------------------------------------- * leggi parametri ditta necessari; stabilisci se annuale, * se si' metti _month a 13 * istanzia _freqviva, _isbenzinaro, _isannual, _isriepilogo * -------------------------------------------------------------- */ _reg_arr.destroy(); // Azzera la cache dei registri per ogni ditta. _nditte->zero(); _nditte->curr().put("CODDITTA",nomeditta.get_long(1)); _nditte->read(); _freqviva = nomeditta.get(3); bool mens = _freqviva == "M"; // determina attivita' prevalente e istanzia cazzuole // per vedere che Kazzo di liquidazione calcolare TString attprev = _nditte->curr().get("CODATTPREV"); TLocalisamfile& atts = _nditte->lfile(LF_ATTIV); atts.zero(); atts.put("CODDITTA",nomeditta.get_long(1)); atts.put("CODATT", attprev); if (atts.read() != NOERR) atts.zero(); // istanzia benzinaro _isbenzinaro = atts.get_bool("ART74_4"); // riaggiusta relazione _nditte->read(); // decidi per stocazzo di annuale // ***************** Previous kasin *************************** // per QUALSIASI annuale il mese diventa 13 // _isannual = (_month == 12 && !mens && !_isbenzinaro) || // (_month == 13 && (mens || _isbenzinaro)); // _isriepilogo = _month == 13 && !mens; // if (_isannual) _month = 13; // che ti piaccia o no // ************************************************************ // strasemplificato: per l'annuale si sceglie annuale, altrimenti // e' la 12ma anche per le trimestrali. _isannual = _isriepilogo = _month == 13; TApplication::set_firm(nomeditta.get_long(1)); _prind->addstatus(1); /* * trimestrali impropriamente selezionate per mesi intermedi * provocano il ricalcolo dei progressivi mensili ma non la stampa */ _canprint = is_month_ok_strict(_month) || _month == 13; /* -------------------------------------------------------------- * Ricalcola i mesi necessari, tutti se annuale * -------------------------------------------------------------- */ int need_refresh = FALSE; if (_recalc != ever) { for (int m = 1; m < _month; m++) if (is_month_ok_strict(m) && (!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++) // fino a 13 compreso if (is_month_plain(m) || _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 (look_lim(m)) { _lim->put("B0",""); _lim->rewrite(); break; } _month = save_month; } } 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(liq_month(month), TRUE); //modifica del 19/01/1996 //if (_isfinal && _lim->get_bool("B1")) // && _month != 13) // return TRUE; //fine { TConfig cnf(CONFIG_DITTA, "cg"); //MI3262... //_isdiffacc = cnf.get_bool("GeLiDi"); //usato per stampa acconto in coda ai registri _isdiffacc = is_differita(); _isdifferita = _isdiffacc;// && _month != 13; _isintr = !cnf.get_bool("InTrTr") && _freqviva != "M"; if (_isbenzinaro) _gest4 = cnf.get_bool("GesT74"); // controlla che il periodo corrente non sia l'inizio dell'attivita' // nel caso, differita va a FALSE _monthinatt = 1; } TDate inatt(_nditte->lfile().get("DINIZIOATT")); { if (is_in_liq_period(inatt)) _isdifferita = FALSE; if (inatt.year() == atoi(_year)) _monthinatt = inatt.month(); TConfig cnf1(CONFIG_STUDIO, "cg"); _isricacq = cnf1.get_bool("RicAcq"); } // ricalcolo normale // lim c'e' solo per i trimestri bool ok = _lim->get_bool("B0"); if (ok && !recalc) return TRUE; bool calc = (_recalc == ever || (_recalc == one && is_month_ok(month,_month))); if (!calc && _recalc != never) calc = !ok; bool gheravergot = FALSE; bool quater = FALSE; TToken_string atts; TToken_string cattivs; // azzera rimborsi zero_firm(month); // casini per stampa minchie in coda ai registri //22/12/1995 bool riepliq = _isregis ? _riepilogo : FALSE; bool stliq = TRUE; //fine _nditte->save_status(); if (_nditte->is_first_match(LF_ATTIV)) { TString 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; buf.format( _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); // se ricalcola l'annuale si tiene tutte le vendite e corrispettivi di // tutti i lerci mesi if (!(_month == 13 && month > 1)) { _vend_arr.destroy(); _corr_arr.destroy(); } cattivs = ""; for (int tipoatt = 1; tipoatt <= (_mixed ? 2 : 1); tipoatt++) { TString cattiv(codatt); bool waspla; cattiv << tipoatt; if (tipoatt == 1 && (waspla = 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"); _isvent = FALSE; if (tipoatt == 1 && waspla && month == 13) { // azzera pla dove serve _pla->put("R0",""); _pla->put("R1",""); _pla->put("R2",""); _pla->put("R3",""); _pla->put("R4",""); _pla->put("R13",""); _pla->put("R9",""); _pla->put("R10",""); _pla->put("R11",""); _pla->put("R12",""); _pla->put("R14",""); _pla->put("S1","0"); _pla->put("S2","0"); _pla->put("S3","0"); _pla->rewrite(); } for (_reg->first(); _reg->good(); _reg->next()) { //22/12/1995 //if (codatt == _reg->get("S8") || quater) if (codatt == _reg->get("S8")) { //if (!riepliq) riepliq = _reg->get_bool("B6"); //if (!stliq) stliq = _reg->get_bool("B7"); if (_reg->get_int("I0") == 2) if (!_isvent) _isvent = _reg->get_bool("B3"); //fine } } if (!_isregis) stliq = riepliq = TRUE; if (_comp_acconto) stliq = riepliq = FALSE; if (calc || !recalc) if (!update_att(month, cattiv) && stliq) describe_error("Attivita' non ricalcolate: possibili errori", codatt); //13/12/1995 if (month == 13) recalc_annual(cattiv); //fine // 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 && riepliq) describe_att(month, cattiv, gheravergot, '0' + (_mixed ? tipoatt : 0)); atts.add(cattiv); cattivs.add(cattiv); } // for tipoatt // se attivita' mista stampa riepilogo if (_mixed && month == _month && riepliq) describe_att(month,cattivs, TRUE, 'M'); // se sta calcolando l'annuale, scrive tutti i dati calcolati per il trasferimento // sui files adibiti a mantenere le informazioni per IVA 11: tab1100a e tab1100b if (_is_interactive && month == 13) iva11_set_arr_pim(codatt); // scorre tutti i maledetti PIM di questa ditta/attivita' per completare _iva11_arr // Ehm. Ehmm... Nota da fare in futuro non appena si ha un poco di tempo. // Attualmente iva11_set_arr() scorre tutti i PIM. Tale funzione viene chiamata per ogni // attivita' della ditta corrente. // Si potrebbe ottimizzare il tutto scorrendo PIM una sola volta per tutte le ditte e tutte le // attivita' (ovviamente solo per il mese 13). } while (_nditte->next_match(LF_ATTIV)); // se quater stampa riepilogo if (quater && month == _month && riepliq) describe_att(month,atts, TRUE, 'Q'); // occorre poterla chiamare altre volte con mesi diversi _nditte->restore_status(); // aggiorna le liquidazioni //13/12/1995. //Concordato con Ferdinando che, visto che qualche //calcoluccio viene fatto anche in write_liq, essa //verra' sempre richiamata. //if (calc || !recalc) //fine // Se siamo in annuale e se non e' stato indicato di ricalcolare (stampa liquidazione chiamata // dalla stampa registri) non riscrivere i risultati delle liquidazioni, if ((is_month_ok_strict(month) && _month != 13 && _recalc != never) || month == 13) write_liq(month, atts); // rimborso infraannuale _DescrItem* rimb_d = NULL; if (month == _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, stliq); if (stliq) { describe_firm(month); //describe_liq(_month, atts, _isregis ? NULL : rimb_d); describe_liq(_month, atts, rimb_d); } if (_month == 13 && look_lim(_month)) // scrive i risultati solo in annuale { real r0 = _lim->get_real("R0"); iva11_write(rimb_d == NULL || r0.sign() >= 0); // scrive su tab1100 at last. } } //in caso di stampa registri e in caso sia //stato calcolato l'acconto (metodo analitico) //deve essere stampato il prospetto di liquidazione //dell'acconto in coda al resto if (_isregis && stliq) if ((month == 12 && _freqviva == "M") || (month == 12 && _isbenzinaro && _gest4) || (month == 13 && _freqviva == "T" && !_isbenzinaro) || (month == 13 && _isbenzinaro && !_gest4)) describe_liqacc(); } 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 { look_plm(month, codatt, TRUE); bool ok = _plm->get_bool("B0"); if (ok && !recalc) return TRUE; bool calc = _recalc == ever || (_recalc == one && is_month_ok(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); //13/12/1995 // if (month == 13) // recalc_annual(codatt); //fine } return ok || calc; } void TLiquidazione_app::zero_firm(int month) { // nothing more, left for sicurezz } 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 && (_year == *_pim_anno)) { _pim->put("R0",""); _pim->put("R1",""); _pim->put("R2",""); _pim->put("R3",""); _pim->put("R4",""); _pim->put("R5",""); _pim->put("R6",""); _pim->put("R7",""); _pim->put("R8",""); _pim->put("R9",""); _pim->put("R10",""); _pim->put("R11",""); _pim->put("R12",""); _pim->put("R13",""); _pim->put("R14",""); _pim->put("S0",""); _pim->put("S1",""); _pim->put("S2",""); _pim->rewrite(); } } if (look_plm(month, codatt)) { // zero PLM, POM, PAM, PUM TString codtab(_plm->get("CODTAB")); _plm->zero(); _pom->zero(); _pam->zero(); _pum->zero(); _plm->put("CODTAB", codtab); _pom->put("CODTAB", codtab); _pam->put("CODTAB", codtab); _pum->put("CODTAB", codtab); _plm->rewrite(); _pam->rewrite(); _pom->rewrite(); _pum->rewrite(); } if (_isplafond && month != 13) 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_det = 0.0; real ammort_det_iva = 0.0; real ammort_indet = 0.0; real ammort_indet_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 esni_rimb = 0.0; // ci sommo tutti esenti e ni validi per rimborso 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_1i = 0.0; real agr_2i = 0.0; real agr_1 = 0.0; real agr_2 = 0.0; real agr_3 = 0.0; real agr_4 = 0.0; real agr_5 = 0.0; real agr_6 = 0.0; real agr_7 = 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; real assp_imp = 0.0; real assp_iva = 0.0; real vssp_imp = 0.0; real vssp_iva = 0.0; real bdog_imp = 0.0; real bdog_iva = 0.0; real agr_imp = 0.0; real agr_iva = 0.0; if (!_isviaggio) { TRectype from(_cur->curr()); from.zero(); TRectype to(from); TDate f(1, month == 13 ? 1 : month, atoi(_year)); TDate t(1, month == 13 ? 12 : month, atoi(_year)); t.set_end_month(); from.put(MOV_DATAREG, f); to.put(MOV_DATAREG, t); _cur->setregion(from, to); } *_cur = 0; long items = _cur->items(); TString trueatt(codatt); int tipatt = atoi(trueatt.sub(5)); //trueatt = trueatt.left(5); trueatt.cut(5); #ifdef DBG TString msgdbg; long freespace; #endif for (; _cur->pos() < items; ++(*_cur)) { if ((_cur->pos() & 0x7F) == 0) { #ifdef DBG msgdbg.format("Ricalcolo attivita': P=%ld/%ld",_cur->pos(),items); freespace = GetFreeSpace(0); msgdbg << " Memoria libera(1): " << freespace/1024 << " Kbytes."; xvt_statbar_set(msgdbg); #endif do_events(); } TDate date(_mov->get("DATAREG")); TString16 reg = _mov->get("REG"); bool isreg = look_reg(_mov->get("REG")); TString16 tipodoc = _mov->get("TIPODOC"); bool corrisp = _reg->get_bool("B0"); tiporeg tipomov = (tiporeg)_reg->get_long("I0"); if (_isviaggio && tipomov == vendita && !(_mov->get("DATA74TER").empty())) date = _mov->get_date("DATA74TER"); /* * check register present, rmoviva present and date OK */ const bool dok = !is_date_ok(date, month); const bool sreg = !isreg; const bool rs8 = _reg->get("S8") != trueatt; const bool cmt = !_cur->is_first_match(LF_RMOVIVA); const bool sosp_imp = _reg->get_bool("B1"); const TRectype& rcs = _cur->curr(LF_CAUSALI); const bool fattrit = rcs.get_bool("RITFATT"); if (dok || sreg || rs8 || cmt) continue; /* * Tipo documento da eliminare (Scudler 1994) * Trattasi per lo piu' di non incassati * Da oggi vengono sommati nei real di S2 in pim * assieme alle FS per stampa registri */ bool noninc = (tipodoc == "SN" || tipodoc == "CN" || tipodoc == "RN" || tipodoc == "IN" || tipodoc == "PG"); /* * check date: se si calcola l'acconto, solo da 1/12 a 20/12 */ int accmonth = _isdifferita ? 11 : 12; /* * Patrizia: se e' differita i mov. vanno da 1/11 a 30/11 * potrei allora andarmi a leggere i risultati della liq di 11 * ma il cliente potrebbe voler calcolare l'acconto prima * di aver calcolato la liquidazione (perche' cosi' complicato?) */ //if (_comp_acconto && date.month() == accmonth && date.day() > 20) if (_comp_acconto && date.month() == accmonth) if (!_isdifferita && date.day() > 20) continue; do { look_iva(_rmoviva->get("CODIVA")); // totali parziali registrati nei pim per motivi ignoti real bolld_imp = 0.0; // imponibile bolle doganali real bolld_iva = 0.0; // imposta bolle doganali real asimp_imp = 0.0; // imponibile acquisti sosp. imposta real asimp_iva = 0.0; // imposta acquisti sosp. imposta real vsimp_imp = 0.0; // imponibile vendite sosp. imposta real vsimp_iva = 0.0; // imposta vendite sosp. imposta real rit_imp = 0.0; // imponibile fatture in ritardo real rit_iva = 0.0; // imposta fatture in ritardo real nin_imp = 0.0; // imponibile non incassati real nin_iva = 0.0; // imposta non incassati TString codiva = _iva->get("CODTAB"); TString tipoiva = _iva->get("S1"); TString riga11_v = _iva->get("S0"); TString tipoes_v = _iva->get("S2"); TString tipoes_a = _iva->get("S9"); int tipoagr = atoi(_iva->get("S4")); int tipoag = atoi(_iva->get("S5")); int tipopla = atoi(_iva->get("S3")); int tipodet = atoi(_rmoviva->get("TIPODET")); int isrimbinfr = _iva->get_bool("B3"); // vale per calcolo rimborso se ES o NI int ivarimb = !_iva->get_bool("B4"); // non escluso calcolo rimb. per al. media 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"); // autofatture art. 17 per non residenti, con trattamento // speciale in liquidazione annuale bool autodafe = tipodoc == "AF"; //Adesso il tipocr==4 non c'entra piu' un tubo // vendite art. 40 c. 5/6/8 acq.intra., con trattamento // speciale in liquidazione annuale (A13 in stampa) bool art40 = (tipodoc != "AF" && tipoiva != "NS" && !rcs.get_bool("AUTOFATT") && rcs.get_bool("VALINTRA") && !intra); // indica acquisti per rivendita; viene messo in B4 di PIM per // indicare che e' soggetto al ricalcolo IVA (se voluto) in modo // da evitare di dover controllare mese e anno sul PIM bool was_riv = FALSE; /* * 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) */ /* * In liq. annuale si totalizzano * solo le stranezze che seguono */ if (month == 13) { // Filling dell'array per IVA11 if (_is_interactive && _month == 13) iva11_set_arr(trueatt); // si contano soltanto le vendite. bool okc = tipomov == vendita; // purche' ... bool cond1 = (rcs.get_bool("AUTOFATT") && tipoiva == "NS" && tipodoc == "AF"); // oppure ... bool cond2 = (rcs.get_bool("AUTOFATT") && tipoiva == "NS" && tipodoc != "AF" && rcs.get_bool("INTRACOM") && rcs.get_bool("VALINTRA")); /* * Fatture in ritardo vengono considerate solo in dichiarazione * annuale, ma vanno comunque sommate per i porci registri */ if (!(okc && (cond1 || cond2)) && !fattrit) continue; } if (noninc) // non incassati: non devono entrare in nessun altro calcolo { nin_imp = imponibile; nin_iva = imposta; } else if (sosp_imp) // sospensione di imposta { if (tipomov == vendita) { vsimp_imp = imponibile; vsimp_iva = imposta; } else { asimp_imp = imponibile; asimp_iva = imposta; } assp_imp += asimp_imp; assp_iva += asimp_iva; vssp_imp += vsimp_imp; vssp_iva += vsimp_iva; } else if (fattrit && month != 13) { rit_imp = imponibile; rit_iva = imposta; } else if (!fattrit || (fattrit && _isagricolo && _month == 13)) // normale { // ***************************************** // 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 */ { acq_riv += imponibile; acq_riv_iva += imposta; was_riv = TRUE; } else if (tipomov == acquisto && tipocr == 2 && tipodet == 0) // Acquisto beni ammortizzabili detraibili { ammort_det += imponibile; ammort_det_iva += imposta; } else if (tipomov == acquisto && tipocr == 2 && tipodet != 0) // Acquisto beni ammortizzabili indetraibili { ammort_indet += imponibile; ammort_indet_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) */ { /* NO! * Invece non le deve comprendere nell'annuale * (Vladimiro 1995, piu' tardi) */ if (!(_month == 13 && autodafe)) { 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 infraanale // Scudler 1995 e molti dopo di lei // La breve estate vissuta dal metodo del 51% rende // oramai superflua la tabella rimborsi, eliminata // senza entusiasmo ed interrogandomi sul senso della vita if (ivarimb) { bool ok = _isagricolo ? tipoagr == 2 : FALSE; if (tipomov == acquisto && !ok) ok = (tipocr == 0 || tipocr == 1 || tipocr == 5 || tipocr == 9); if (tipomov == vendita && !ok) ok = tipoiva != "NS" && tipocr != 4; ivarimb = ok; } // operazioni esenti if (tipoiva == "ES") { if (tipomov == vendita) { if (tipoes_v == "B1") esenti_b1 += imponibile; else if (tipoes_v == "B2") esenti_b2 += imponibile; else if (tipoes_v == "B3") esenti_b3 += imponibile; // se e' il caso sommare esenti per rimborso if (isrimbinfr) esni_rimb += imponibile; } else if (tipoes_a == "12") esenti_b14 += imponibile; } // non imponibili per rimborso if (tipoiva == "NI" && tipomov == vendita && isrimbinfr) esni_rimb += imponibile; // bolle doganali if (tipodoc == "BD") { bolld_imp = imponibile; bolld_iva = imposta; bdog_imp += bolld_imp; bdog_iva += bolld_iva; } // plafond if (_isplafond && tipomov == acquisto && month != 13 && 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 + imposta; else corr_CEE += imponibile + imposta; break; case 2: if (tipomov == acquisto) acq_noCEE += imponibile + imposta; else corr_noCEE += imponibile + imposta; break; case 3: if (tipomov == vendita) corr_misCEE += imponibile + imposta; break; case 4: if (tipomov == acquisto) acq_misCEE += imponibile + imposta; break; case 5: if (tipomov == acquisto) acq_misnoCEE += imponibile + imposta; break; } if (_isagricolo) { /* * rifatto sensu Scudler 1995 con invidiabile sicurezza * senza porsi domande e mettendo NUMERI uguali * al TIPO RECORD del frigorifero */ if (tipomov == vendita) { agr_imp = imponibile; agr_iva = imposta; const real p = _iva->get_real("R0") / CENTO; if (corrisp) lordo2netto(agr_imp,agr_iva,p); if (tipoagr == 1) // Ora si utilizza solo il segnalino 1 { agr_1 += agr_iva; agr_1i += agr_imp; } else if (tipoagr == 2) { agr_2 += agr_iva; agr_2i += agr_imp; } } else if (tipodet == 0) { if (tipoagr == 2) { if (tipocr != 2 && tipocr != 3 && tipocr != 8) agr_3 += imposta; else agr_4 += imposta; } else if (tipoagr == 3) { if (tipocr != 2 && tipocr != 3 && tipocr != 8) agr_7 += imposta; } else // ne' 2 ne' 3 { if (tipocr != 2 && tipocr != 3 && tipocr != 8) agr_5 += imposta; else agr_6 += imposta; } } } // __end of _agricolo 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 // ***************************************** } // non sosp_imp ne' altre casistiche che escludono la liq. /* * Calcolo e aggiornamento * cerca o crea progressivo IVA */ look_pim(month, codatt, reg, tipocr_s, codiva, tipodet, TRUE); /* * se ign == TRUE non bisogna neppure PROGRESSIVARLI */ bool ign = sosp_imp || (fattrit && month != 13) || noninc; /* * se liq == FALSE gli importi non contano ai fini * del calcolo liquidazione */ bool liq = !(tipodet == 1 || tipodet == 3 || tipodet == 9 || ign); real imp = _pim->get_real("R0"); // imponibile real ivp = _pim->get_real("R1"); // IVA su imp. real lor = _pim->get_real("R2"); // lordo real lorcor = _pim->get_real("R3"); // lordo corrispettivi (da non ventilare) /* * 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. * * 5.7.1996. Mi permetto di aggiungere una cosa: le bastardissime fatture con scontrino * possono anche essere sul registro vendite. Indi le schiaffo dentro * a R5 e R6 anche nel caso vi sia un documento FS registrato sul registro * delle vendite. Nel caso in futuro si accorgessero finalmente della puttanata * galattiche che mi hanno fatto fare basta eliminare il controllo su FS * nel caso si tratti di non corrispettivi (vedi sotto). * Da togliere anche nella :describe_pim() in cg4304.cpp. * */ real ifs = _pim->get_real("R5"); // imponibile fatture con scontrino real vfs = _pim->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 */ real adf = _pim->get_real("R7"); real adi = _pim->get_real("R8"); /* le fottute fatture in sospensione di imposta */ real fsi = _pim->get_real("R11"); real fsv = _pim->get_real("R12"); /* le putride bolle doganali */ real bdi = _pim->get_real("R9"); real bdv = _pim->get_real("R10"); /* i luridi falsi corrispettivi */ real fci = _pim->get_real("R13"); real fcv = _pim->get_real("R14"); /* i conturbanti art. 40 c. 5/6/8 a.i. */ TToken_string kr(_pim->get("S0"),'!'); real a13i(kr.get(0)); real a13v(kr.get(1)); /* le porche fatture in ritardo */ TToken_string fr(_pim->get("S1"),'!'); real rti(fr.get(0)); real rtv(fr.get(1)); /* * la stramadonna dei corrispettivi gia' scorporati * Gli si aggiungono i non incassati, sperando in bene */ TToken_string cs(_pim->get("S2"),'!'); real csi(cs.get(0)); real csv(cs.get(1)); /* incrociamm'e dituozz' */ csi += nin_imp; csv += nin_iva; rti += rit_imp; rtv += rit_iva; if (tipomov == vendita) { fsi += vsimp_imp; fsv += vsimp_iva; } else { fsi += asimp_imp; fsv += asimp_iva; bdi += bolld_imp; bdv += bolld_iva; } 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 bool true_corrisp = FALSE; 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, a meno di * indicazioni contrarie. */ if (tipodoc == "CR" || tipodoc == "RF" || tipodoc == "SC") { true_corrisp = TRUE; _pim->put("I0",LORDO); // questi sono corrispettivi davvero; comportamento normale if (tipoiva == "VE") // da ventilare { lor += imponibile; add_vendite(month, reg, tipodet, imponibile); } else // non da ventilare, con imposta gia' conteggiata { real perc = _iva->get_real("R0")/CENTO; lor += imponibile + imposta; lorcor += imponibile+imposta; real tot = imponibile+imposta; if (liq) add_corrisp(month, reg, tot, perc, tipodet, codiva, codatt); } } else if (tipodoc == "FS") { // queste sono fatture che seguono scontrino, il lordo va detratto // perche' si e' gia' registrato lo scontrino medesimo true_corrisp = TRUE; // non e' vero ma non devono essere sommate ai falsi // corrispettivi if (tipoiva == "VE") { real rr = imponibile + imposta; imp += rr; if (liq) vendite += rr; add_vendite(month, reg, tipodet, rr); } if (liq) { csi += imponibile; csv += 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; csi += imponibile; csv += imposta; } imp += imponibile; ivp += imposta; //fci += imponibile; //fcv += imposta; _pim->put("I0",NETTO); } } // if corrisp else // non corrisp { // imponibile e imposta separata imp += imponibile; ivp += imposta; if (tipodoc == "FS") // Questo e' per l'errore MI3404 { // Dicono che una volta funzionasse, ci credo poco... ifs += imponibile; // Anyway, comincio a condividere appieno i commenti sparsi qua e vfs += imposta; // la da Ferdinando... } _pim->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 AF in caso di liq. annuale */ adf += imponibile; adi += imposta; } if (art40) // ammontare acq. intr. art40 c. 5/6/8 { // Analogamente alle autofatture, si devono riportare a parte in annuale // Vengono piazzati in una TToken_string con separatore = a '!'. // La TToken_string viene registrata in S0. // La describe_pim() sommera' tutte le storie, scorporandoli // dalle vendite e assegnandoli al codice A13 in caso di liq annuale. a13i += imponibile; a13v += imposta; } if (corrisp && !true_corrisp) { fci += imponibile; fcv += imposta; } if (!ign) { _pim->put("R0",imp); _pim->put("R1",ivp); _pim->put("R2",lor); _pim->put("R3",lorcor); // Corrispettivi, non inclusi quelli da ventilare _pim->put("R5",ifs); _pim->put("R6",vfs); _pim->put("R7",adf); _pim->put("R8",adi); _pim->put("R9",bdi); _pim->put("R10",bdv); _pim->put("R13",fci); _pim->put("R14",fcv); } // questi servono per i ricalcoli altrui (classify_pim) o // per trucchetti di ricalcolo successivi _pim->put("R11",fsi); _pim->put("R12",fsv); _pim->put("I1", (long)tipomov); _pim->put("B3", ivarimb ? "X" : ""); _pim->put("B4", (_isricacq && was_riv) ? "X" : ""); _pim->put("S5", tipoiva); // art 40 c. 5/6/8 per A13. kr.add(a13i.string(), 0); kr.add(a13v.string(), 1); _pim->put("S0",kr); // fatture in ritardo fr.add(rti.string(), 0); fr.add(rtv.string(), 1); _pim->put("S1",fr); // corrispettivi gia' scorporati; anche questi servono per // non cannare la stampa dei registri; contengono anche // tutti i non incassati (vedi definizione di bool nonimp) cs.add(csi.string(), 0); cs.add(csv.string(), 1); _pim->put("S2",cs); _pim->rewrite(); } while (_cur->next_match(LF_RMOVIVA)); } // fine calcolo progressivi IVA /* * calcolati tutti i movimenti e aggiornati i pim * se necessario risistema le imposte acquisti beni * per rivendita */ if (_isricacq) // flag settato parametri studio { for (_pim->first(); !_pim->eof(); _pim->next()) { // this is much furber than doing all of the checks if (_pim->get_bool("B4")) { // ricalcola l'imposta a partire dal codice IVA look_iva(*_pim_codiva); real old_iva = _pim->get_real("R1"); real perc = _iva->get_real("R0"); real new_iva = (_pim->get_real("R0") * perc)/CENTO; new_iva.ceil(ROUND_LIRA); // TBC check ceil if (new_iva != old_iva) { // ricalcola: acquisti_iva, acq_riv_iva acquisti_iva -= old_iva; acquisti_iva += new_iva; acq_riv_iva -= old_iva; acq_riv_iva += new_iva; _pim->put("R1", new_iva); // resetta in modo da non vederlo il mese dopo _pim->put("B4", ""); _pim->rewrite(); } } } } /* * calcola il lercio prorata * solo se liq. periodica */ real prorata; if (!_prorata.is_zero() && month != 13) { prorata = acquisti_iva * (_prorata / CENTO); //13/12/1995 //prorata.round(ROUND_MILLELIRE); //fine acquisti_iva -= prorata; } 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) { real deb_mens = 0.0; _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); // ---- NOTA BENE ------------------------ // l'iva vendite nei plm non comprende // l'iva agenzie di viaggio, calcolata // in liquidazione (mensile o trimestrale) // --------------------------------------- // Mod 7/7/95: calcolo effettuato anche qui, in modo da // avere l'IVA dovuta per riportarla nei progressivi // Dato che il resto funziona non tocco nulla, ovvero // duplico il calcolo di write_liq, nella remota ipotesi // che ci siano due o piu' attivita' e siano tutte // agenzie di viaggio real perc_r = (acq_misCEE * CENTO)/(acq_misCEE + acq_misnoCEE); perc_r.round(2); real ivm = (corr_misCEE * perc_r)/CENTO; ivm.round(ROUND_LIRA); real tc = (corr_CEE + ivm); real ta = (acq_CEE + acq_misCEE); real bi = tc - ta - credito_costo_prec(month); if (bi.sign() > 0) { deb_mens = (bi /((CENTO + aliquota_agvia())/CENTO)) * (aliquota_agvia()/CENTO); deb_mens.ceil(ROUND_LIRA); // ceil voluto MI3074 } _pom->put("R13", deb_mens); } else if (_isagricolo) { _plm->put("R5", agr_1); _plm->put("R6", agr_2); _plm->put("R7", agr_3); _plm->put("R8", agr_4); _plm->put("R9", agr_5); _plm->put("R10", agr_6); _plm->put("R11", agr_7); _pum->put("R10", agr_1i); _pum->put("R11", agr_2i); // Il porco agricoltore spende poco e paga meno vendite_iva = agr_2; acquisti_iva = agr_3; // nuovo calcolo IVA detraibile if (!agr_7.is_zero()) { real pdetr = (agr_2i / (agr_1i + agr_2i)); pdetr.round(2); acquisti_iva += agr_7 * pdetr; acquisti_iva.round(ROUND_LIRA); } } _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) _pom->put("R9", acq_ies); _pom->put("R10", acq_ies_iva); _pum->put("R8", acq_pint); _pum->put("R9", acq_pint_iva); _pam->put("R10", spgen); _pam->put("R11", spgen_iva); _pom->put("R0", totintra); _pom->put("R1", nond19_imp); _pom->put("R2", nond19_iva); _pom->put("R3", ammort_det); _pom->put("R4", ammort_det_iva); _pom->put("R5", acq_riv); _pom->put("R6", acq_riv_iva); _pom->put("R7", leasing); _pom->put("R8", leasing_iva); _pom->put("R11", ammort_indet); _pom->put("R12", ammort_indet_iva); _pum->put("R0", cess_amm); _pum->put("R1", cess_amm_iva); _pum->put("R2", ammort_6); _pum->put("R3", ammort_6_iva); _pum->put("R4", esenti_b1); _pum->put("R5", esenti_b2); _pum->put("R6", esenti_b3); _pum->put("R7", esenti_b14); _pum->put("R12", esni_rimb); _pam->put("R0", acquisti); _pam->put("R1", vendite); _pam->put("R6", assp_imp); _pam->put("R7", assp_iva); _pam->put("R8", vssp_imp); _pam->put("R9", vssp_iva); _pam->put("R4", bdog_imp); _pam->put("R5", bdog_iva); _plm->rewrite(); _pam->rewrite(); _pum->rewrite(); _pom->rewrite(); } void TLiquidazione_app::iva11_set_arr(const TString& codatt) // viene chiamata quando vengono scorsi i movimenti del mese, settando gran parte degli elementi di _iva11_arr. { // My God! Che 2 palle riestrarre tutte le informazioni const TString16 tipodoc = _mov->get("TIPODOC"); const bool intra = _rmoviva->get_bool("INTRA"); const int tipocr = _rmoviva->get_int("TIPOCR"); const int tipodet = _rmoviva->get_int("TIPODET"); real imponibile = _rmoviva->get_real("IMPONIBILE"); real imposta = _rmoviva->get_real("IMPOSTA"); const TString16 codiva = _iva->get("CODTAB"); const TString tipoiva = _iva->get("S1"); const real ali = _iva->get_real("R0"); const TString16 tipoes_v = _iva->get("S2"); const TString16 tipoes_a = _iva->get("S9"); const int tipoagr = atoi(_iva->get("S4")); const TRectype& rcs = _cur->curr(LF_CAUSALI); const bool autofattura = rcs.get_bool("AUTOFATT"); const bool valintra = rcs.get_bool("VALINTRA"); const bool sosp_imp = _reg->get_bool("B1"); const bool corrisp = _reg->get_bool("B0"); tiporeg tipomov = (tiporeg)_reg->get_long("I0"); const bool is_vendita = tipomov == vendita; const bool is_acquisto = tipomov == acquisto; _BolgArray b_arr; const bool is_key = _iva11_arr.is_key(codatt); _BolgArray& array = is_key ? (_BolgArray&)_iva11_arr.find(codatt) : b_arr; // TAB11_RQA34 ovvero "RQA34" non viene trasferito! // Sebbene per motivi di pieta' viene comunque lasciato nel tracciato record (esigenze PRASSI) if (codiva.empty()) return; if (is_acquisto) { if (_isagricolo && tipodet == 0) { if (tipoagr == 2) { if (tipocr == 2 || tipocr == 3 || tipocr == 8) { array.sub(imponibile,TAB11_G30I,LF_TAB1100B); array.sub(imposta,TAB11_G30V,LF_TAB1100B); } else { array.add(imponibile,TAB11_G30I,LF_TAB1100B); array.add(imposta,TAB11_G30V,LF_TAB1100B); } } else if (tipoagr == 3 && tipocr !=2 && tipocr != 3 && tipocr != 8) { array.add(imponibile,TAB11_G31I,LF_TAB1100B); array.add(imposta,TAB11_G31V,LF_TAB1100B); } } if (!sosp_imp && tipodet == 0 && (tipocr == 2 || tipocr == 8)) { array.add(imposta,TAB11_R6,LF_TAB1100B); } if (!sosp_imp) { if (tipodoc == "BD" && tipodet == 9) { array.add(imponibile,TAB11_F76); if (_sind11) array.add(imposta,TAB11_F76); } if (tipodoc != "BD") { // Compila prima i campi FC1nn ed FC2nn, poi i campi SBFnn ed SBInn if (tipodet != 9) { if (ali == 2.00) { array.add(imponibile,TAB11_FC101); array.add(imposta,TAB11_FC201); } else if (ali == 4.00) { array.add(imponibile,TAB11_FC102); array.add(imposta,TAB11_FC202); } else if (ali == 8.50) { array.add(imponibile,TAB11_FC103); array.add(imposta,TAB11_FC203); } else if (ali == 9.00) { array.add(imponibile,TAB11_FC104); array.add(imposta,TAB11_FC204); } else if (ali == 10.00) { array.add(imponibile,TAB11_FC105); array.add(imposta,TAB11_FC205); } else if (ali == 13.00) { array.add(imponibile,TAB11_FC106); array.add(imposta,TAB11_FC206); } else if (ali == 16.00) { array.add(imponibile,TAB11_FC107); array.add(imposta,TAB11_FC207); } else if (ali == 19.00) { array.add(imponibile,TAB11_FC108); array.add(imposta,TAB11_FC208); } if (tipoes_a == "13") array.add(imponibile,TAB11_FC109); else if (tipoes_a == "10") array.add(imponibile,TAB11_FC110); else if (tipoes_a == "11") array.add(imponibile,TAB11_FC111); else if (tipoes_a == "12") array.add(imponibile,TAB11_FC112); else if (tipoes_a == "14") array.add(imponibile,TAB11_FC113); } else { array.add(imponibile,TAB11_FC114); if (_sind11) array.add(imposta,TAB11_FC114); } if (intra) // Compila i campi SBFnn { if (tipodet != 9) { if (ali == 4.00) { array.add(imponibile,TAB11_SBF01); array.add(imposta,TAB11_SBI01); } else if (ali == 9.00) { array.add(imponibile,TAB11_SBF02); array.add(imposta,TAB11_SBI02); } else if (ali == 10.00) { array.add(imponibile,TAB11_SBF03); array.add(imposta,TAB11_SBI03); } else if (ali == 13.00) { array.add(imponibile,TAB11_SBF04); array.add(imposta,TAB11_SBI04); } else if (ali == 16.00) { array.add(imponibile,TAB11_SBF05); array.add(imposta,TAB11_SBI05); } else if (ali == 19.00) { array.add(imponibile,TAB11_SBF06); array.add(imposta,TAB11_SBI06); } if (tipoes_a == "13") array.add(imponibile,TAB11_SBF07); else if (tipoes_a == "10") array.add(imponibile,TAB11_SBF08); else if (tipoes_a == "11") array.add(imponibile,TAB11_SBF09); else if (tipoes_a == "12") array.add(imponibile,TAB11_SBF10); } else { array.add(imponibile,TAB11_SBF11); if (_sind11) array.add(imposta,TAB11_SBF11); } } } } } if (is_vendita) { if (corrisp && tipoiva != "VE" && (tipodoc == "CR" || tipodoc == "RF" || tipodoc == "SC") ) // x13 return; /* { return; real p = ali/CENTO; lordo2netto(imponibile,imposta,p);// In tal caso scorpora l'iva dall'imponibile... } */ // fine x13 if (tipodoc == "CN" || tipodoc == "SN" || tipodoc == "RN") // salta i non incassati return; if (!valintra) { // x13 /* if (tipodoc != "AF" && ((_isagricolo && tipoagr==2) || !_isagricolo)) { if (ali == 4.00) { array.add(imponibile,TAB11_EC101); array.add(imposta,TAB11_EC201); } else if (ali == 9.00) { array.add(imponibile,TAB11_EC102); array.add(imposta,TAB11_EC202); } else if (ali == 10.00) { array.add(imponibile,TAB11_EC103); array.add(imposta,TAB11_EC203); } else if (ali == 13.00) { array.add(imponibile,TAB11_EC104); array.add(imposta,TAB11_EC204); } else if (ali == 16.00) { array.add(imponibile,TAB11_EC105); array.add(imposta,TAB11_EC205); } else if (ali == 19.00) { array.add(imponibile,TAB11_EC106); array.add(imposta,TAB11_EC206); } } */ // fine x13 if (tipoes_v == "24") array.add(imponibile,TAB11_EC107); if (tipoes_v == "21") array.add(imponibile,TAB11_EC108); else if (tipoes_v == "B1") array.add(imponibile,TAB11_EC109); else if (tipoes_v == "B2") array.add(imponibile,TAB11_EC110); else if (tipoes_v == "B3") array.add(imponibile,TAB11_EC111); else if (tipoes_v == "25") array.add(imponibile,TAB11_EC112); else if (tipoes_v == "22") array.add(imponibile,TAB11_EC114); else if (tipoes_v == "20") array.add(imponibile,TAB11_EC115); if (tipocr == 4 && tipodoc != "AF") array.add(imponibile,TAB11_EC113); } if (!autofattura && tipoiva != "NS") if (tipodoc == "AF") { array.add(imponibile,TAB11_A35); array.add(imposta,TAB11_L2); } else if (valintra && !intra) { array.add(imponibile,TAB11_A35BIS); array.add(imposta,TAB11_L2BIS); } if (!autofattura && !sosp_imp && intra && tipoes_v == "22") array.add(imponibile,TAB11_E52); if (_isagricolo && (tipodoc != "CR" && tipodoc != "SC" && tipodoc != "RF" && tipodoc != "FS")) { const bool t1 = tipoagr == 1; const bool t1_3 = tipoagr == 1 || tipoagr == 3; if (ali == 2.00) { if (t1) { array.add(imponibile,TAB11_AGME01,LF_TAB1100B); array.add(imposta,TAB11_AGVE01,LF_TAB1100B); } if (intra && t1_3) { array.add(imponibile,TAB11_ABME01); array.add(imposta,TAB11_ABVE01); } } else if (ali == 4.00) { if (t1) { array.add(imponibile,TAB11_AGME02,LF_TAB1100B); array.add(imposta,TAB11_AGVE02,LF_TAB1100B); } if (intra && t1_3) { array.add(imponibile,TAB11_ABME02); array.add(imposta,TAB11_ABVE02); } } else if (ali == 8.50) { if (t1) { array.add(imponibile,TAB11_AGME03,LF_TAB1100B); array.add(imposta,TAB11_AGVE03,LF_TAB1100B); } if (intra && t1_3) { array.add(imponibile,TAB11_ABME03); array.add(imposta,TAB11_ABVE03); } } else if (ali == 9.00) { if (t1) { array.add(imponibile,TAB11_AGME04,LF_TAB1100B); array.add(imposta,TAB11_AGVE04,LF_TAB1100B); } if (intra && t1_3) { array.add(imponibile,TAB11_ABME04); array.add(imposta,TAB11_ABVE04); } } } } if (is_acquisto || is_vendita) if (autofattura) array.add(imponibile,TAB11_A35TER); _iva11_arr.add(codatt,array,is_key); } void TLiquidazione_app::iva11_set_arr_pim(const TString& codatt) // scorre (guarda un poco) tutti i PIM della ditta per COMPLETARE _iva11_arr { // Ribadisco: questa funzione COMPLETA solamente l'array scorrendo i PIM e memorizzando 51 // campi. Gli altri 74 sono compilati scorrendo i movimenti! (fatto prima della chiamata a questa funzione) TString16 codiva, reg, tiva; TString16 tpla, tvia; TString16 v11, a11; TToken_string tt("",'!'); tiporeg treg; int tipocr,tipodet,tagr; real aliq, imp, iva, vtot, atot, ivav, ivaa, adf, adi, a13i, a13v; TString16 cur_att; _BolgArray b_arr; const bool is_key = _iva11_arr.is_key(codatt); _BolgArray& array = is_key ? (_BolgArray&)_iva11_arr.find(codatt) : b_arr; // Scorporo corretto dei corrispettivi in R3 TAssoc_array corr_ann; _CorrItem cx,*cc; bool is_present; for (_pim->first(); !_pim->eof(); _pim->next()) { if (_year != *_pim_anno) continue; cur_att = *_pim_codatt; cur_att.rtrim(1); if (codatt != cur_att) continue; // considera solo quelli dell'anno, obviously. // Must consider current activity too... codiva = *_pim_codiva; reg = *_pim_codreg; look_iva(codiva); look_reg(reg); // posiziona la tabella registri e quella IVA tiva = _iva->get("S1"); // tipo IVA tpla = _iva->get("S3"); // tipo gestione plafond tagr = _iva->get_int("S4"); // tipo gestione regime agricolo tvia = _iva->get("S5"); // tipo gestione ag. viaggio v11 = _iva->get("S2"); // n.ro riga vendite per mod. IVA11 a11 = _iva->get("S9"); // n.ro riga acquisti per mod. IVA11 aliq = _iva->get_real("R0"); // aliquota treg = (tiporeg)_reg->get_long("I0"); const bool is_vendita = treg == vendita; const bool is_acquisto = treg == acquisto; tipocr = atoi(*_pim_tipocr); tipodet = atoi(*_pim_tipodet); imp = _pim->get_real("R0"); iva = _pim->get_real("R1"); if (is_acquisto) { switch (tipocr) { case 2: array.add(imp,TAB11_IMA01); break; case 8: array.add(imp,TAB11_IMA02); break; case 1: case 5: array.add(imp,TAB11_IMA03); break; default: break; } if (tipodet == 1) array.add(iva,TAB11_B14); // FBC???: tipo detr != 9 if (tipodet != 9) { if (aliq == 4.00) { array.add(_pim->get_real("R9"),TAB11_FBC101); array.add(_pim->get_real("R10"),TAB11_FBC201); } else if (aliq == 9.00) { array.add(_pim->get_real("R9"),TAB11_FBC102); array.add(_pim->get_real("R10"),TAB11_FBC202); } else if (aliq == 10.00) { array.add(_pim->get_real("R9"),TAB11_FBC103); array.add(_pim->get_real("R10"),TAB11_FBC203); } else if (aliq == 13.00) { array.add(_pim->get_real("R9"),TAB11_FBC104); array.add(_pim->get_real("R10"),TAB11_FBC204); } else if (aliq == 16.00) { array.add(_pim->get_real("R9"),TAB11_FBC105); array.add(_pim->get_real("R10"),TAB11_FBC205); } else if (aliq == 19.00) { array.add(_pim->get_real("R9"),TAB11_FBC106); array.add(_pim->get_real("R10"),TAB11_FBC206); } if (a11 == "10") array.add(_pim->get_real("R9"),TAB11_FBC107); if (a11 == "11" || a11 == "12") array.add(_pim->get_real("R9"),TAB11_FBC108); if (a11 == "14") array.add(_pim->get_real("R9"),TAB11_FBC109); } } // is_acquisto if (is_vendita) { if (v11 == "G7A") array.add(imp,TAB11_EC116); else if (v11 == "G7B") array.add(imp,TAB11_EC117); else if (v11 == "R9") // Divenuto obsoleto prima ancora di utilizzarlo... array.add(imp,TAB11_R9,LF_TAB1100B); if ((_isagricolo && tagr==2) || !_isagricolo) { // Accumula i corrispettivi da scorporare per codice iva is_present = corr_ann.is_key(codiva); cx._totale = 0; _CorrItem& ca = is_present ? (_CorrItem&) corr_ann[codiva] : cx; ca._totale += _pim->get_real("R3"); if (!is_present) // se non c'e' lo aggiunge { ca._aliquota = _iva->get_real("R0"); // Se e' nuovo setta l'aliquota corr_ann.add(codiva,ca); } tt = _pim->get("S0"); a13i = tt.get(0); a13v = tt.get(1); adf = imp - _pim->get_real("R7") - a13i; adi = iva - _pim->get_real("R8") - a13v; if (aliq == 4.00) { array.add(adf,TAB11_EC101); array.add(adi,TAB11_EC201); } else if (aliq == 9.00) { array.add(adf,TAB11_EC102); array.add(adi,TAB11_EC202); } else if (aliq == 10.00) { array.add(adf,TAB11_EC103); array.add(adi,TAB11_EC203); } else if (aliq == 13.00) { array.add(adf,TAB11_EC104); array.add(adi,TAB11_EC204); } else if (aliq == 16.00) { array.add(adf,TAB11_EC105); array.add(adi,TAB11_EC205); } else if (aliq == 19.00) { array.add(adf,TAB11_EC106); array.add(adi,TAB11_EC206); } } if (_isagricolo && (tagr == 1 || tagr == 3)) { if (aliq == 2.00) { array.add(imp,TAB11_AGME01,LF_TAB1100B); array.add(iva,TAB11_AGVE01,LF_TAB1100B); } else if (aliq == 4.00) { array.add(imp,TAB11_AGME02,LF_TAB1100B); array.add(iva,TAB11_AGVE02,LF_TAB1100B); } else if (aliq == 8.50) { array.add(imp,TAB11_AGME03,LF_TAB1100B); array.add(iva,TAB11_AGVE03,LF_TAB1100B); } else if (aliq == 9.00) { array.add(imp,TAB11_AGME04,LF_TAB1100B); array.add(iva,TAB11_AGVE04,LF_TAB1100B); } } } // is_vendita // Boia chi linka! // Sommatoria per il calcolo aliquote medie vendite/acquisti... if (_pim->get_bool("B3")) // E' un record valido per fare questa cosa? { if ((tiporeg)_pim->get_long("I1") == vendita) { //vendite vtot += imp; ivav+=iva; } else //acquisti if (tipodet != 9) // Evita di sommare quelli con tipo detraibilita' 9 (MI2209) { atot += imp; ivaa+=iva; } } } // Scorre i corrispettivi lordi accumulati, li scorpora ed aggiorna i righi relativi for (cc = (_CorrItem *)corr_ann.first_item(); cc != NULL; cc = (_CorrItem *)corr_ann.succ_item()) { lordo2netto(cc->_totale,imp,iva,cc->_aliquota/CENTO); vtot += imp; ivav += iva; if (cc->_aliquota == 4.00) { array.add(imp,TAB11_EC101); array.add(iva,TAB11_EC201); } else if (cc->_aliquota == 9.00) { array.add(imp,TAB11_EC102); array.add(iva,TAB11_EC202); } else if (cc->_aliquota == 10.00) { array.add(imp,TAB11_EC103); array.add(iva,TAB11_EC203); } else if (cc->_aliquota == 13.00) { array.add(imp,TAB11_EC104); array.add(iva,TAB11_EC204); } else if (cc->_aliquota == 16.00) { array.add(imp,TAB11_EC105); array.add(iva,TAB11_EC205); } else if (cc->_aliquota == 19.00) { array.add(imp,TAB11_EC106); array.add(iva,TAB11_EC206); } } // Hisss... Rettifica l'importo di EC115: EC115 = EC116 + EC117 + EC115 // Va beh... real r16, r17; if (array.is_key(TAB11_EC116)) r16 = ((_BolgItem&)array[TAB11_EC116]).value(); if (array.is_key(TAB11_EC117)) r17 = ((_BolgItem&)array[TAB11_EC117]).value(); r17+=r16; array.add(r17,TAB11_EC115); // Calcola le maledette aliquote medie... real alv,ala; if (vtot != 0.0) { alv = ivav/vtot; alv *= CENTO; alv.round(2); } if (atot != 0.0) { ala = ivaa/atot; ala *= CENTO; ala.round(2); } array.add(ala,TAB11_R1,LF_TAB1100B); array.add(alv,TAB11_R2,LF_TAB1100B); // Uargh, Uargh. Mo' mi pappo i PLM per compilare T1, T1C, T2, T2C, T3, T5 e T6 // Ah, Ah, Ah! // ATTENZIONE: solo per i regimi 74ter (ag. viaggio) for (_plm->first();!_plm->eof();_plm->next()) { if (_year != *_plm_anno || *_plm_mese == "13") continue; cur_att = *_plm_codatt; cur_att.rtrim(1); if (codatt != cur_att) continue; if (_isviaggio) { array.add(_plm->get_real("R5"),TAB11_T1,LF_TAB1100B); array.add(_plm->get_real("R7"),TAB11_T1C,LF_TAB1100B); array.add(_plm->get_real("R6"),TAB11_T2,LF_TAB1100B); array.add(_plm->get_real("R8"),TAB11_T2C,LF_TAB1100B); array.add(_plm->get_real("R9"),TAB11_T3,LF_TAB1100B); array.add(_plm->get_real("R10"),TAB11_T5,LF_TAB1100B); array.add(_plm->get_real("R11"),TAB11_T6,LF_TAB1100B); } array.add(_plm->get_real("R0"),TAB11_IVVENR); } _iva11_arr.add(codatt,array,is_key); } void TLiquidazione_app::iva11_write(bool reset_r1r2) // Trasferisce i dati IVA11 annuali dall'assoc_array al file tab1100 { const int items = _iva11_arr.items(); if (items == 0) return; TString ditta,attiv,fld_name; _BolgArray * bolg_arr; _BolgItem * bolg; int i=0,err; // Ciclo sulle attivita' for (bolg_arr = (_BolgArray *) _iva11_arr.first_item(); bolg_arr != NULL && i < items; i++,bolg_arr = (_BolgArray*)_iva11_arr.succ_item()) { // Setta i campi chiave per entrambi i files della relazione ditta.format("%05ld",_nditte->curr().get_long(NDT_CODDITTA)); attiv = _iva11_arr.get_hashobj()->key(); TLocalisamfile& tab1100a = _tab11->lfile(); TLocalisamfile& tab1100b = _tab11->lfile(LF_TAB1100B); tab1100a.zero(); tab1100a.put(TAB11_TADITT,ditta); tab1100a.put(TAB11_TACATT,attiv); tab1100b.zero(); tab1100b.put(TAB11_TADITT,ditta); tab1100b.put(TAB11_TACATT,attiv); const int bolg_items = bolg_arr->items(); int j=0; // Ciclo sugli elementi per compilare i campi della relazione for (bolg = (_BolgItem *)bolg_arr->first_item(); bolg != NULL && jsucc_item()) { fld_name = bolg_arr->get_hashobj()->key(); if (reset_r1r2 && (fld_name == TAB11_R1 || fld_name == TAB11_R2)) continue; // salta R1/R2 se devono rimanere a zero _tab11->lfile(bolg->file()).put(fld_name,bolg->value()); } if (_tab11->write() != NOERR) if ((err=_tab11->rewrite()) != NOERR) error_box("Errore %d tentando di scrivere sul file tab1100.",err); } _iva11_arr.destroy(); // resetta l'array. } void TLiquidazione_app::write_liq(int month, const char* codatts) // Calcolo liq. mensili e liq. annuali. Scrive le lim { TToken_string atts(codatts); const char* tmpatt; if (_ver->read(atoi(_year),_month)!=NOERR) warning_box("Errore %d in lettura tabella versamenti ed interessi.",_ver->status()); // evita casino se differita ma si sta ricalcolando il primo // mese con ricalcolo di piu' mesi bool wasdifferita = (_isdifferita && month <= _monthinatt && _month > _monthinatt); if (wasdifferita) _isdifferita = FALSE; // liq. differita: considera mese precedente (solo per i risultati) int deltam = month; if (_isdifferita && !is_first_month(month) && month != 13) month -= (_freqviva == "T" ? 3 : 1); deltam -= month; real risultato = 0.0; real detrazioni = 0.0; real versamenti = 0.0; real vers_int = 0.0; real rimborsi = 0.0; real rettifiche = 0.0; real res_debt = 0.0; real res_cred = 0.0; real cred_prec = 0.0; real debt_precd = 0.0; real acc_dec = 0.0; real iva_vend = 0.0; real iva_acq = 0.0; real conguaglio = 0.0; // totali per regimi agricoli real acq_noCEE = 0.0; real imp_agr1 = 0.0; real imp_agr2 = 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; // totali per annuali real vol_aff_1 = 0.0; real vol_aff_2 = 0.0; real vol_aff_t = 0.0; real vol_aff_l = 0.0; real tot_cong = 0.0; bool differita = FALSE; int attc = 0; // counter attivita' while ((tmpatt = atts.get()) != NULL) { TString att(tmpatt); if (_isdifferita && is_first_month(month+deltam)) { // usa i totali del mese di dicembre dell'anno // precedente differita = TRUE; TString yr(_year); _year = format("%d", atoi(_year)-1); if (!look_lim(12)) //controlla solamente, il vero posizionamento lo fa dopo { _year = yr; differita = FALSE; } } for (int m = 1; m <= 13; m++) { // ciclo su tutti i mesi del caso (1 o 3; // tutti se annuale) if (!is_month_ok(m, month)) continue; look_plm(differita ? 12 : m, att); bool is_lim = look_lim(_isdifferita ? m+deltam : m); // gia' conteggiato: prorata // da conteggiare: IVA vendite ag. viaggio // a debito: IVA vendite, debito precedente // a credito: IVA acquisti, ulteriori detrazioni 1 e 2 if (!_isagricolo) { iva_vend += _plm->get_real("R0"); iva_acq += _plm->get_real("R1"); risultato += (_plm->get_real("R0") - _plm->get_real("R1")); res_debt += _plm->get_real("R0"); res_cred += _plm->get_real("R1"); } else { // Tiene aggiornata l'iva vendite iva_vend += _plm->get_real("R6") + _plm->get_real("R5"); // Tiene aggiornata l'iva acquisti, che andra' rettificata all'uscita // secondo la formula: // iva_acq = iva_acq + iva detraibile calcolata // l'iva detraibile calcolata e' a sua volta fatta cosi' // sum(plm->R11) * { sum(pum->R11) / [sum(pum->R11) + sum(pum->R10)]} // dove plm->R11 = acquisti misti fuori CEE // pum->R10 = tot. imponibile reg agr. 1 // pum->R11 = tot. imponibile reg agr. 2 iva_acq += _plm->get_real("R7") + _plm->get_real("R5"); acq_noCEE += _plm->get_real("R11"); imp_agr1 += _pum->get_real("R10"); imp_agr2 += _pum->get_real("R11"); } detrazioni+= (_plm->get_real("R3") + _plm->get_real("R4")); // detrazioni solo non in regime agricolo if (!_isagricolo) { risultato -= (_plm->get_real("R3") + _plm->get_real("R4")); res_cred += (_plm->get_real("R3") + _plm->get_real("R4")); } /* se annuale, somma versamenti mesi 1-12 * solo una volta (non per tutte le attivita') */ if (attc == 0 && month == 13) { // l'acconto a dicembre si conteggia a parte solo // nei casi previsti e non in annuale (vedi sotto) real vs(versamenti_IVA(m , m == 12 ? "1" : "1|7")); real vi(versamenti_IVA(m,"5")); versamenti += vs; vers_int += vi; res_cred += vs + vi; } /* * rimborso se chiesto e previsto * in annuale non si chiede e non va sommato se no lo cumula */ if (attc == 0 && is_lim && m < 13) { risultato += _lim->get_real("R1"); rimborsi += _lim->get_real("R1"); res_debt += _lim->get_real("R1"); } /* * rettifiche gia' col loro bravo segno */ if (attc == 0 && is_lim) { // se sono per benzinaro le conta solo in annuale, // se no vanno solo in periodica // almeno cosi' dicevano fino ad agosto // poi, sara' il caldo, mi hanno detto che e' sbagliato TString descrett(_lim->get("S0")); bool isforbenzinaro = descrett[0] == '$' || (descrett[0] == '>' && descrett[1] == '>'); if (/*(isforbenzinaro && _isannual) || ...alla cincia quest'idea non piaceva piu' (!isforbenzinaro && !_isannual) adesso la storia e' cosi': in ANNUALE solo se benzinaro, altrimenti niente; diversamente tutto*/ !(month == 13 && !isforbenzinaro) && m < 13) { risultato += _lim->get_real("R5"); rettifiche += _lim->get_real("R5"); if (_lim->get_real("R5").sign() < 0) res_cred += abs(_lim->get_real("R5")); else res_debt += abs(_lim->get_real("R5")); } } /* totalizza importi 74 ter */ 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 // counter attivita' per evitare troppi versamenti attc++; if (differita) _year = format("%d", atoi(_year)+1); if (!(_isdifferita && is_first_month(month+deltam))) { if (_isviaggio) { // calcolo credito costo, debito mensile, perc. ripart. perc_r = (a_mCEE * CENTO)/(a_mCEE + a_meCEE); perc_r.round(2); real ivm = (c_mCEE * perc_r)/CENTO; ivm.round(ROUND_LIRA); real tc = (c_iCEE + ivm); 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.ceil(ROUND_LIRA); // ceil voluto MI3074 risultato += deb_mens; res_debt += deb_mens; iva_vend += deb_mens; } } } } // end ciclo su attivita' if (_isagricolo) { real perc; // percentuale di deducibilita' real iva_ded; // iva deducibile perc = imp_agr2 /(imp_agr1 + imp_agr2); perc.round(2); iva_ded = acq_noCEE * perc; iva_ded.round(ROUND_LIRA); iva_acq += iva_ded; res_debt += iva_vend; res_cred += iva_acq; risultato += (iva_vend - iva_acq); } // __ end of _isagricolo if (month < 13) // va bene anche se differita sommando deltam (che e' 0 normalmente) { // toglie credito precedente cred_prec = credito_prec(month+deltam); risultato -= cred_prec; res_cred += cred_prec; // vedi se c'era un debito precedente per debiti < 50.000 debt_precd = debt_prec(month+deltam); risultato += debt_precd; res_debt += debt_precd; } else { // per l'annuale considera solo il credito a inizio anno cred_prec = credito_prec(_freqviva == "M" ? 1 : 3); risultato -= cred_prec; res_cred += cred_prec; } if (month == 13) { // totalizza volumi affari e calcola nuovo prorata // per tutte le attivita' atts.restart(); while ((tmpatt = atts.get()) != NULL) { TString att(tmpatt); int tipoatt = att[att.len() -1] - '0'; if (tipoatt == 1) // su PLA l'attivita' e' sempre 1 { if (!look_pla(att)) continue; real vf1 = _pla->get_real("R14"); real vf2(_pla->get("S1")); real iaq = _pla->get_real("R11"); // IVA acquisti real ppg = _pla->get_real("R12"); // pro-rata pagato vol_aff_1 += vf1; vol_aff_2 += vf2; vol_aff_t = vf1 + vf2; vol_aff_l += _pla->get_real("R0"); // volume affari lordo real es_b1 = _pla->get_real("R1"); real es_b2 = _pla->get_real("R2"); real es_b3 = _pla->get_real("R3"); real csamm = _pla->get_real("R4"); // calcola nuovo prorata per ogni attivita' (miste: 1+2) real ris = vol_aff_t; // gia' esclusi: NS, B3, cess. amm real prorata(0.0); if (!ris.is_zero()) prorata = (es_b1/ris) * CENTO; real conguaglio = 0.0; prorata.round(ROUND_LIRA); if (prorata != _prorata) { // calcolo conguaglio -- se positivo e' a debito real topay; if (prorata > 0.0) { topay = (iaq + ppg) * (prorata / CENTO); //topay.round(ROUND_MILLELIRE); round_mille_lire(topay); } conguaglio = topay - ppg; //conguaglio.round(ROUND_MILLELIRE); round_mille_lire(conguaglio); } if (prorata < 0.0) prorata = 0.0; _pla->put("R9", conguaglio); _pla->put("R10",prorata); tot_cong += conguaglio; _pla->rewrite(); // scrivi nuovo prorata in tabella anno successivo TString yr = _year; _year = format("%d", atoi(_year) + 1); look_pla(att, TRUE); _pla->put("R8", prorata); _pla->rewrite(); look_lia(); _lia->put("R5", cred_cost); _lia->rewrite(); _year = yr; } } look_lia(); _lia->put("R1", vol_aff_l); _lia->put("R2", vol_aff_1); _lia->put("R3", vol_aff_2); _lia->rewrite(); } // comprende anche il conguaglio prorata risultato += tot_cong; if (tot_cong.sign() > 0) res_debt += tot_cong; if (tot_cong.sign() < 0) res_cred += abs(tot_cong); look_lim(month+deltam,TRUE); // azzeriamo tutto (tranne r1, r5, s1, s0, s7) TString codtab = _lim->get("CODTAB"); real r5 = _lim->get("R5"); real r1 = _lim->get("R1"); TString s7 = _lim->get("S7"); TString s0 = _lim->get("S0"); TString s1 = _lim->get("S1"); bool wasb0 = _lim->get_bool("B0"); bool wasb1 = _lim->get_bool("B1"); _lim->zero(); _lim->put("CODTAB", codtab); _lim->put("R1", r1); _lim->put("R5", r5); _lim->put("S0", s0); _lim->put("S1", s1); _lim->put("S7", s7); _lim->put("B0", wasb0 ? "X" : ""); _lim->put("B1", wasb1 ? "X" : ""); /* * versamenti effettuati: si conteggiano in R0, * sono > 0 solo se andavano calcolati (vedi sopra) */ risultato -= versamenti + vers_int; /* * acconto dicembre se previsto */ //if ((month == 12 && _isbenzinaro) || // (month >= 12 && _freqviva == "M")) if (((month+deltam) >= 12 && _freqviva == "M") || //solo freq. M puo' (month == 12 && _isbenzinaro && _gest4) || //essere differita (month == 13 && _freqviva == "T")) { acc_dec = versamenti_IVA(12,"7"); risultato -= acc_dec; res_cred += acc_dec; } // in annuale si arrotondera' a 1000 in stampa // se no il conguaglio prorata fa casino risultato.round(ROUND_LIRA); _lim->put("R0",risultato); _lim->put("R2",cred_cost); _lim->put("R3",deb_mens); _lim->put("R4",perc_r); if (!_isagricolo) _lim->put("R6",detrazioni); else // per evitare sbagli nei ricalcoli esterni _lim->put("R6",""); if (month == 13 || differita) { // scrivi totali rettifiche e rimborsi // nella finale oppure se copiati da // anno precedente _lim->put("R1",rimborsi); _lim->put("R5",rettifiche); } /* * Interessi dovuti solo da trimestrali in periodica, * Era anche non benzinari, smentito da Cinzia (MI0853); * Ora gestito esplicitamente nei parametri ditta, forzato * FALSE per ditte mensili e liq. annuale * Ulteriormente smentito e rettificato */ //if (_isintr && month < 13) bool true_trim = (month == 3 || month == 6 || month == 9); if (_isintr && ( true_trim || (month == 12 && _isbenzinaro && _gest4) || (month == 13 && !(_isbenzinaro && _gest4)) )) { real interesse = interesse_trimestrale(_month); real ivi = risultato * (interesse / CENTO); ivi.ceil(ROUND_LIRA); _lim->put("R14", ivi); } //questo serve anche per la visualizzazione e per l'estrazione deleghe //if (_isintr && month < 13) if (_isintr && ( true_trim || (month == 12 && _isbenzinaro && _gest4) || (month == 13 && !(_isbenzinaro && _gest4)) )) _lim->put("R10",interesse_trimestrale(_month)); // totale conguaglio su tutte le attivita' _lim->put("R7", tot_cong); _lim->put("R8", versamenti); _lim->put("R9", vers_int); _lam->put("R0", iva_vend); _lam->put("R1", iva_acq); _lam->put("R2", cred_prec); _lam->put("R3", debt_precd); _lim->put("R11", acc_dec); _lim->put("R12", res_cred); _lim->put("R13", res_debt); //modifica del 19/01/1996 //if (!_recalc_only) if (!_recalc_only && _recalc != never) { _lim->put("B0","X"); _lim->put("B1","X"); } //fine //modifica del 19/01/1996 //if (_isfinal) _lim->put("B1", "X"); if (_recalc_only) _lim->put("B1", "X"); //fine if (wasdifferita) _isdifferita = TRUE; // AWFUL! se siamo in annuale, occorre arrotondare alle 1000 lire // TUTTI gli ADDENDI e non il risultato. Cio' e' disonesto e mostruoso; // siccome sa di ricorso al TAR nonche' di errore della Prassi // schiaffo tutto il codice nell'IF che segue, e se lo si vuole togliere // non si fara' che scancellare tutto il blocco if (month == 13) { // molto codice duplicato, ma ne val la pena (vedi sopra) //iva_vend.round(ROUND_MILLELIRE); //iva_acq.round(ROUND_MILLELIRE); //detrazioni.round(ROUND_MILLELIRE); //versamenti.round(ROUND_MILLELIRE); //vers_int.round(ROUND_MILLELIRE); //rimborsi.round(ROUND_MILLELIRE); //rettifiche.round(ROUND_MILLELIRE); //deb_mens.round(ROUND_MILLELIRE); //cred_prec.round(ROUND_MILLELIRE); //tot_cong.round(ROUND_MILLELIRE); //acc_dec.round(ROUND_MILLELIRE); //debt_precd.round(ROUND_MILLELIRE); round_mille_lire(iva_vend); round_mille_lire(iva_acq); round_mille_lire(detrazioni); round_mille_lire(versamenti); round_mille_lire(vers_int); round_mille_lire(rimborsi); round_mille_lire(rettifiche); round_mille_lire(deb_mens); round_mille_lire(cred_prec); round_mille_lire(tot_cong); round_mille_lire(acc_dec); round_mille_lire(debt_precd); res_cred = iva_acq + versamenti + vers_int + cred_prec + acc_dec; res_debt = iva_vend + rimborsi + debt_precd; // Tolto la somma di deb_mens, perche' gia' presente in iva_vend if (tot_cong.sign() > 0) res_debt += tot_cong; else res_cred -= tot_cong; if (rettifiche.sign() > 0) res_debt += rettifiche; else res_cred -= rettifiche; if (!_isagricolo) res_cred += detrazioni; // res_debt.round(); // res_cred.round(); // TString r1(res_debt.string()); // TString r2(res_cred.string()); // real rd(r1); // real rc(r2); risultato = res_debt - res_cred; // TString r3(risultato.string()); // tut ricalcule', riscrivem _lim->put("R0", risultato); _lim->put("R2", cred_cost); _lim->put("R3", deb_mens); _lim->put("R1", rimborsi); _lim->put("R5", rettifiche); _lim->put("R7", tot_cong); _lim->put("R8", versamenti); _lim->put("R9", vers_int); _lam->put("R0", iva_vend); _lam->put("R1", iva_acq); _lam->put("R2", cred_prec); _lam->put("R3", debt_precd); _lim->put("R11", acc_dec); _lim->put("R12", res_cred); _lim->put("R13", res_debt); // ciapa } _lim->rewrite(); _lam->rewrite(); } void TLiquidazione_app::recalc_annual(const char* att) { // viene chiamata 2 volte per le att. miste; PLA e' stata // azzerata dove serve da update_firm se siamo all'annuale 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 iva_acq = 0.0; real ven_lrd = 0.0; real volaff1 = 0.0; real volaff2 = 0.0; real imp_ifs = 0.0; real imp_af = 0.0; real imp_a13 = 0.0; TString16 codiva,reg,tiva; TToken_string a13("",'!'); int tipoatt = att[strlen(att) -1] - '0'; TString aaa(att); look_pla(aaa); volaff1 = _pla->get_real("R14"); volaff2 = (const char*)_pla->get("S1"); 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"); pro_pag = _pla->get_real("R12"); iva_acq = _pla->get_real("R11"); // Per avere un risultato corretto, si deve totalizzare PIM->R3 per codice iva // e quindi effettuare lo scorporo dell'imponibile e aggiungere al relativo volume d'affari TAssoc_array corr_ann; _CorrItem cx,*cc; bool is_key; for (_pim->first(); !_pim->eof(); _pim->next()) { if (_year != *_pim_anno) continue; int tipocr = atoi(*_pim_tipocr); codiva = *_pim_codiva; reg = *_pim_codreg; look_iva(codiva); look_reg(reg); tiva = _iva->get("S1"); int biva = (int)_iva->get_long("I3"); tiporeg treg = (tiporeg)_reg->get_long("I0"); const bool corrisp = _reg->get_bool("B0"); const bool simp = _reg->get_bool("B1"); imp_ifs = _pim->get_real("R0"); imp_af = _pim->get_real("R7"); a13 = _pim->get("S0"); imp_a13 = a13.get(0); imp_ifs -= imp_af + imp_a13; // Toglie le autofatture e le op. A13 if (corrisp) { imp_ifs += _pim->get_real("R5"); // Se corrisp. aggiunge le FS is_key = corr_ann.is_key(codiva); cx._totale = 0; _CorrItem& ca = is_key ? (_CorrItem&) corr_ann[codiva] : cx; ca._totale += _pim->get_real("R3"); if (!is_key) // se non c'e' lo aggiunge { ca._aliquota = _iva->get_real("R0")/CENTO; // Se e' nuovo setta l'aliquota corr_ann.add(codiva,ca); } } if ( // ESCLUSI: strcmp(att,*_pim_codatt) != 0 || treg != vendita || // non vendite tipocr == 4 || // cessioni beni ammortizzabili tiva == "NS" || // non soggetti biva == 3 || // bi tre simp) // sospensione di imposta continue; if (tipoatt == 1) volaff1 += imp_ifs; else volaff2 += imp_ifs; } // Ora si scorporano i corrispettivi raggruppati per codice IVA e si totalizzano gli imponibili // calcolati, da aggiungere poi a volaff1 o volaff2 real imp,iva; for (cc = (_CorrItem *)corr_ann.first_item(); cc != NULL; cc = (_CorrItem *)corr_ann.succ_item()) { lordo2netto(cc->_totale,imp,iva,cc->_aliquota); if (tipoatt == 1) volaff1 += imp; else volaff2 += imp; } // calcola esenti, cessioni, lordo vendite, prorata pagato // e IVA acquisti dai plm/ptm/pum/pam/pom for (int i = 1; i <= 13; i++) { if (!look_plm(i,aaa)) continue; vendite += _pam->get_real("R1"); iva_acq += _plm->get_real("R1"); es_b1 += _pum->get_real("R4"); es_b2 += _pum->get_real("R5"); es_b3 += _pum->get_real("R6"); cess_amm += _pum->get_real("R0"); pro_pag += _plm->get_real("R2"); } _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("R11", iva_acq); _pla->put("R12", pro_pag); _pla->put("R14", volaff1); _pla->put("S1", volaff2.string()); _pla->rewrite(); }