campo-sirio/cg/cg4301.cpp

// ------------------------------------------------------------
// Calcolo liquidazioni
// Part 2: calcolo 
// fv 21-1-94
// ------------------------------------------------------------

#include <progind.h>              
#include <sheet.h>
#include <config.h>
#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_STUDIO, "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;
}