campo-sirio/cg/cg5900.cpp

// Programma per la gestione e la stampa della dichiarazione periodica IVA
#include <applicat.h>
#include <automask.h>
#include <execp.h>
#include <progind.h>
#include <recarray.h>
#include <relation.h>
#include <reprint.h>

#include "cg5900a.h"
#include "cglib03.h"

#include <attiv.h>
#include <causali.h>
#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>

///////////////////////////////////////////////////////////
// TProrata_set
///////////////////////////////////////////////////////////

static int _year = 0;
static long _attiv = 0;
static TAssoc_array _causali;

static bool prorata_filter(const TRelation* rel)
{
  const TRectype& mov = rel->curr(LF_MOV);

  if (mov.get_char(MOV_TIPO) != 'F') // Solo movimenti fornitori
    return false;

  if (mov.get_char(MOV_PROVVIS) > ' ') // Solo movimenti definitivi
    return false;

  if (_year > 0)
  {
    const int anno = mov.get_int(MOV_ANNOIVA);
    if (anno != _year)
      return false;
  }

  const TBill zio(rel->curr());
  const int cric = zio.tipo_cr();
  if (cric >= 2 && cric <= 4)      // Beni strumentali
    return false;

  const TString& codcaus = mov.get(MOV_CODCAUS);
  TCausale* caus = (TCausale*)_causali.objptr(codcaus);
  if (caus == NULL)
  {
    caus = new TCausale(codcaus, _year);
    _causali.add(codcaus, caus);
  }
  if (caus->iva() != iva_acquisti)
    return false;

  if (caus->intra())
    return false;

  if (caus->tipodoc() == "AF")
    return false;

  if (_year > 0 && _attiv > 0)
  {
    const TRegistro& reg = caus->reg();
    const long attiv = atol(reg.attivita());
    if (attiv != _attiv)
      return false;
  }
  
  return true;
}

class TProrata_set : public TISAM_recordset
{
protected:
  virtual void set_custom_filter(TCursor& c) const;
  virtual const TVariant& get_field(int logic, const char* fldname) const;
  real perc_det() const;

public:
  TProrata_set(const char* sql) : TISAM_recordset(sql) { }
};

void TProrata_set::set_custom_filter(TCursor& c) const
{
  c.set_filterfunction(prorata_filter);
}

real TProrata_set::perc_det() const
{
  real i = CENTO;
  const TRectype& rmi = cursor()->curr();
  if (rmi.get(RMI_TIPODET).full())
  {
    const TRectype& mov = cursor()->curr(LF_MOV);
    real percind; get_tipodet_from_rmi(rmi, mov, percind);
    i = CENTO-percind;
  }
  return i;
}

const TVariant& TProrata_set::get_field(int logic, const char* fldname) const
{
  const TVariant& var = TISAM_recordset::get_field(logic, fldname);
  if (logic == 0 || logic == LF_RMOVIVA)
  {
    if (xvt_str_same(fldname, RMI_IMPOSTA))
    {
      const real pd = perc_det();
      if (pd < CENTO)
      {
        real i = var.as_real() * pd / CENTO;
        return get_tmp_var() = i.round(2);
      }
    } else
    if (xvt_str_same(fldname, "PERCDET"))
    {
      return get_tmp_var() = perc_det();
    }
  }
  return var;
}

///////////////////////////////////////////////////////////
// TProrata_rep
///////////////////////////////////////////////////////////

class TProrata_rep : public TReport
{
protected:
  virtual bool use_mask() { return false; } 
  virtual bool set_recordset(const TString& sql);

public:
  TProrata_rep();
};

bool TProrata_rep::set_recordset(const TString& sql)
{
  TString query = sql;

  if (_year > 0 && query.find("FROM ") < 0)
  {
    const TDate dal( 1,  1, _year);
    const TDate  al(31, 12, _year);
    TISAM_recordset mov("USE MOV KEY 2\nFROM DATAREG=#DAL\nTO DATAREG=#AL");
    mov.set_var("#DAL", dal);
    mov.set_var("#AL",   al);

    long danumreg = 0;
    long anumreg  = 0;
    const TRectype& curr = mov.cursor()->curr();
    for (bool good = mov.move_first(); good; good = mov.move_next())
    {
      const long numreg = curr.get_long(MOV_NUMREG);
      if (danumreg == 0 || numreg < danumreg)
        danumreg = numreg;
      if (numreg > anumreg)
        anumreg = numreg;
    }
    query << "\nFROM NUMREG=" << danumreg << "\nTO NUMREG=" << anumreg;
  }

  TProrata_set* prs = new TProrata_set(query);
  return TReport::set_recordset(prs);  
}

TProrata_rep::TProrata_rep() 
{ 
  const char* name = "cg5900a.rep";
  if (!load(name))
    cantread_box(name);
}

///////////////////////////////////////////////////////////
// TProrata_msk
///////////////////////////////////////////////////////////

class TProrata_msk : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  real get_perc_prorata();  
  bool genera_mov(TFilename& ininame);

public:
  TProrata_msk() : TAutomask("cg5900a") {}
};

real TProrata_msk::get_perc_prorata()
{
  const long f = get_long(F_CODDITTA);
  const int  y = get_date(F_DATAFIN).year();
  const long a = get_long(F_CODATT);
  TString16 codtab;
  codtab.format("%05ld%4d%05ld1", f, y, a);
  const real pr = cache().get("%PLA", codtab, "R8");
  set(F_PRORATA, pr);
  _year  = y;

  TToken_string key; key.format("%05ld", prefix().get_codditta());
  TRecord_array att(key, LF_ATTIV);
  if (att.rows() >  1)
    _attiv = a;
  else
    _attiv = 0;
  return pr;
}

bool TProrata_msk::genera_mov(TFilename& ininame)
{
  ininame.temp("cg5900", "ini");
  TConfig trans(ininame, "Transaction");
  trans.set("Action", "INSERT");

  const TString& codcaus = get(F_CAUSALE);
  const TCausale caus(codcaus, _year);

  trans.set_paragraph("23");
  trans.set(MOV_CODCAUS, codcaus);
  trans.set(MOV_DATAREG, TDate(TODAY));
  TString descr; descr << "PRO-RATA " << _year;
  trans.set(MOV_DESCR, descr);

  TProrata_rep rep;
  rep.mask2report(*this);
  TRecordset& recset = *rep.recordset();
  TProgress_monitor pi(recset.items(), TR("Calcolo pro-rata"), false);  

  TAssoc_array mconti;
  TString80 key;

  const real prorata = get_perc_prorata();

  for (bool good = recset.move_first(); good; good = recset.move_next())
  {
    if (!pi.add_status())
      break;

    const real impdet = recset.get(RMI_IMPOSTA).as_real(); // Imposta detraibile
    if (!impdet.is_zero())
    {
      const int gruppo      = recset.get(RMI_GRUPPO).as_int();
      const int conto       = recset.get(RMI_CONTO).as_int();
      const long sottoconto = recset.get(RMI_SOTTOCONTO).as_int();
      const TString& codiva = recset.get(RMI_CODIVA).as_string();
      key.format("%03d|%03d|%06ld|%s", gruppo, conto, sottoconto, (const char*)codiva);
      real* pr = (real*)mconti.objptr(key);
      if (pr == NULL)
      {
        pr = new real;
        mconti.add(key, pr);
      }

      real imp = impdet * prorata / CENTO;
      imp.round(2);
      *pr += imp;
    }
  }

  TString_array aconti;
  FOR_EACH_ASSOC_OBJECT(mconti, o, k, i)
  {
    TToken_string* row = new TToken_string(k);
    *row << '|' << *i;
    aconti.add(row);
  }
  aconti.sort();
  int riga = 0;
  real tot;
  const char* seziva = caus.sezione(1) == 'A' ? "A" : "D";
  const char* sezimp = caus.sezione(1) == 'A' ? "D" : "A";

  TString8 para; 

  FOR_EACH_ARRAY_ROW(aconti, r, row)
  {
    const int gruppo      = row->get_int(0);
    const int conto       = row->get_int();
    const long sottoconto = row->get_long();
    const TString4 codiva = row->get();
    const real imp        = row->get();
    if (!imp.is_zero())
    {
      para.format("%d,%d", LF_RMOV, ++riga);
      trans.set_paragraph(para);
      trans.set(RMV_SEZIONE, sezimp);
      trans.set(RMV_IMPORTO, imp.string());
      trans.set(RMV_GRUPPO, gruppo);
      trans.set(RMV_CONTO,  conto);
      trans.set(RMV_SOTTOCONTO, sottoconto);
      descr.cut(0) << TR("Codice IVA") << ' ' << codiva;
      trans.set(RMV_DESCR, descr);
      tot += imp;
    }
  }

  TBill civa; caus.bill(1, civa);
  para.format("%d,%d", LF_RMOV, ++riga);
  trans.set_paragraph(para);
  trans.set(RMV_SEZIONE, seziva);
  trans.set(RMV_IMPORTO, tot.string());
  trans.set(RMV_GRUPPO, civa.gruppo());
  trans.set(RMV_CONTO,  civa.conto());
  trans.set(RMV_SOTTOCONTO, civa.sottoconto());

  return true;
}

bool TProrata_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case DLG_PREVIEW:
  case DLG_PRINT:
    if (e == fe_button)
    {
      TProrata_rep rep;
      if (rep.ok())
      {
        rep.mask2report(*this);
        if (o.dlg() == DLG_PRINT)
          rep.print();
        else
          rep.preview();
      }
      return false;
    }
    break;
  case F_CODATT:
    if (e == fe_init)
    {
      TBrowse& b = *((TEdit_field&)o).browse();
      TCursor& c = *b.cursor();
      const TRecnotype i = c.items();
      if (i > 0)
      {
        c = 0L;
        o.set(c.curr().get(ATT_CODATT));
        b.do_output();
        o.enable(i > 1);
      }
      else
        o.disable();
    } 
    if (!o.empty() && (e == fe_init || e == fe_modify))
      get_perc_prorata();
    break;
  case F_DATAINI:
    if (e == fe_init)
    {
      TDate d(TODAY); d.set_day(1); --d;
      d.set_day(1);
      o.set(d);
      d.set_end_month();
      set(F_DATAFIN, d, 0x3);
    }
    break;
  case F_DATAFIN:
    if (!o.empty() && (e == fe_init || e == fe_modify))
      get_perc_prorata();
    break;
  case DLG_ELABORA:
    if (e == fe_button)
    {
      TFilename ininame;
      if (genera_mov(ininame))
      {
        TString app; app << "cg2 -0 /i" << ininame;
        TExternal_app a(app);
        a.run();
      }
    }
    break;
  default:
    break;
  }
  return true;
}

///////////////////////////////////////////////////////////
// TProrata_app
///////////////////////////////////////////////////////////

class TProrata_app : public TSkeleton_application
{
public:
  virtual void main_loop();
};

void TProrata_app::main_loop()
{
  TProrata_msk m;
  m.run();
}

int cg5900(int argc, char* argv[])
{
  TProrata_app a;
  a.run(argc, argv, TR("Stampa pro-rata"));
  return 0;
}