campo-sirio/ca/calib02.cpp

#include <xvt.h>

#include "calib01.h"
#include "calib02.h"

#include "movana.h"
#include "rmovana.h"
#include "saldana.h"

///////////////////////////////////////////////////////////
// TAnal_report
///////////////////////////////////////////////////////////

bool TAnal_report::get_usr_val(const TString& name, TVariant& var) const
{
  // CODCONTO:1, CODCMS:3, FASCMS:2, ecc...
  const int namelen = name.len();
  if (namelen >= 6 && name[namelen-2] == ':') 
  {
    int logicnum = 0;
    if (name.starts_with("CODCONTO:"))
      logicnum = LF_PCONANA; else
    if (name.starts_with("CODCMS:"))
      logicnum = LF_COMMESSE; else
    if (name.starts_with("CODCOSTO:"))
      logicnum = LF_CDC; else
    if (name.starts_with("FASCMS:"))
      logicnum = LF_FASI;
    if (logicnum > 0)
    {
      const TMultilevel_code_info& mci = ca_multilevel_code_info(logicnum);
      const int level = name[namelen-1]-'1';
      if (level < mci.levels())
      {
        TString16 fldname = name; fldname.cut(namelen-2);
        TFieldref field = mci.fieldref(level);
        field.set_name(fldname);
        field.set_from(0);
        fldname.cut(0) << field;  // Trasformo il TFieldref in stringa!
        get_record_field(fldname, var);
      }
      else
        var.set_null();
      return true;
    }
  }
  return TReport::get_usr_val(name, var);
}

size_t TAnal_report::get_usr_words(TString_array& words) const
{
  TReport::get_usr_words(words);
  
  const char* const name[] = 
  { 
    "CA_FORMAT_COSTO", 
    "CA_FORMAT_COMMESSA", 
    "CA_FORMAT_FASE", 
    "CA_FORMAT_CONTO", 
    "CA_FORMAT_CMSCDC", 
    NULL
  };

  ((TAnal_report*)this)->_first_msg = words.items(); // Calcola il primo numero disponibile
  size_t i; 
  for (i = 0; name[i] != NULL; i++)
    words.add(name[i]);
  
  return words.items();
}

void TAnal_report::msg_format(int logicnum, TVariant_stack& stack)
{
  const TString& str_in = curr_field()->get().as_string();
  if (str_in.not_empty())
  {
    TString80 separator = " ";
    if (stack.items() > 0)
      separator = stack.pop().as_string();
    if (separator.not_empty())
    {
      const TMultilevel_code_info& mci = ca_multilevel_code_info(logicnum);
      TString str_out;
      for (int i = 0; i < mci.levels(); i++)
      {
        const TFieldref& fld = mci.fieldref(i);
        const TString& str = str_in.sub(fld.from(), fld.to());
        if (str.not_empty())
        {
          if (i > 0) str_out << separator;
          str_out << str;
        }
        else
          break;
      }
      curr_field()->set(str_out);
    }
  }
}

void TAnal_report::msg_format_costo   (TVariant_stack& stack)
{ msg_format(LF_CDC, stack); }

void TAnal_report::msg_format_commessa(TVariant_stack& stack)
{ msg_format(LF_COMMESSE, stack); }

void TAnal_report::msg_format_fase    (TVariant_stack& stack)
{ msg_format(LF_FASI, stack); }

void TAnal_report::msg_format_conto   (TVariant_stack& stack)
{ msg_format(LF_PCONANA, stack); }

void TAnal_report::msg_format_commessa_costo(TVariant_stack& stack)
{
  const TMultilevel_code_info& main_info = ca_multilevel_code_info(LF_FASI);
	msg_format(main_info.parent(), stack);
}

bool TAnal_report::execute_usr_word(unsigned int opcode, TVariant_stack& stack)
{
  if (opcode < _first_msg)
    return TReport::execute_usr_word(opcode, stack);
  opcode -= _first_msg;
  switch (opcode)
  {
  case 0 : msg_format_costo(stack);          break;
  case 1 : msg_format_commessa(stack);       break;
  case 2 : msg_format_fase(stack);           break;
  case 3 : msg_format_conto(stack);          break;
  case 4 : msg_format_commessa_costo(stack); break;
  default: break;
  }
  return true;
}

///////////////////////////////////////////////////////////
// TAnal_balance
///////////////////////////////////////////////////////////

TImporto TAnal_balance::saldo_fine_anno(const char* conto, const char* costo, 
                                        const char* commessa, const char* fase, 
                                        int anno, char tipo) const
{
  TImporto saldo;

  if (anno > 0)
  {
    TString query, select;

    if (costo && *costo)
      select << "(CODCOSTO=='" << costo << "')";
    if (commessa && *commessa)
    {
      if (select.not_empty()) select << "&&";
      select << "(CODCMS=='" << commessa << "')";
    }
    if (fase && *fase)
    {
      if (select.not_empty()) select << "&&";
      select << "(FASCMS=='" << fase << "')";
    }
  
    query << "USE SALDANA";
    if (select.not_empty())
      query << "SELECT " << select;
    query << "\nFROM CONTO=#CONTO"
          << "\nTO   CONTO=#CONTO ANNO=#ANNO";

    TString4 strtipo; strtipo << tipo;
    TISAM_recordset saldini(query);
    saldini.set_var("#CONTO", TVariant(conto));
    saldini.set_var("#ANNO", TVariant(long(anno)));

    TString8 sezname = SALDANA_SEZIONE;
    TString8 salname = SALDANA_SALDO;
    if (tipo == 'P' || tipo == 'V')
    {
      sezname << tipo;
      salname << tipo;
    }

    for (int i = 0; i < saldini.items(); i++)
    {
      const char sez = saldini.get(sezname).as_string()[0];
      const real imp = saldini.get(salname).as_real();
      saldo += TImporto(sez, imp);
    }
    saldo.normalize();
  }

  return saldo;
}

bool TAnal_balance::saldo_movimenti(const char* conto, const char* costo, 
                                    const char* commessa, const char* fase, 
                                    const TDate& dal, const TDate& al, char tipo,
                                    TImporto& ini, TImporto& dare, TImporto& avere) const
{
  TString4 strtipo; 
  if (tipo > ' ') 
    strtipo << tipo;

  TDate dataini;
  if (dal.ok())
  {
    TEsercizi_contabili esc;
    const int annoprec = esc.date2prevesc(dal);
    if (annoprec > 0)
      dataini = esc[annoprec].fine()+1L;
  }

  TString query;
  query << "USE RMOVANA KEY 2\n"
        << "SELECT (107.TIPOMOV=\"" << strtipo << "\")";
  if (dataini.ok())
    query << "&&(ANSI(107.DATACOMP)>=" << dataini.date2ansi() << ")";
  if (al.ok())
    query << "&&(ANSI(107.DATACOMP)<=" << al.date2ansi() << ")";
  if (costo && *costo)
    query << "&&(CODCOSTO==\"" << costo << "\")";
  if (commessa && *commessa)
    query << "&&(CODCMS==\"" << commessa << "\")";
  if (fase && *fase)
    query << "&&(CODFASE==\"" << fase << "\")";
  query << "\nJOIN MOVANA INTO NUMREG==NUMREG\n";

  query << "FROM CODCONTO=" << conto;
  if (dataini.ok())
    query << " DATAREG=" << TDate(dataini-90L).string();
  query << "\n";

  query << "TO CODCONTO=" << conto;
  if (al.ok())
    query << " DATAREG=" << al.string();
  query << "\n";
  
  TISAM_recordset rmovana(query);

  bool movimentato = false;
  for (int i = 0; i < rmovana.items(); i++)
  {
    rmovana.move_to(i);

    const TDate data = rmovana.get("107.DATACOMP").as_date();
    const TImporto imp(rmovana.get(RMOVANA_SEZIONE).as_string()[0], 
                       rmovana.get(RMOVANA_IMPORTO).as_real());
    if (data >= dal)
    {
      if (imp.sezione() == 'D')
        dare += imp;
      else
        avere += imp;
      movimentato = true;
    }
    else
    {
      ini += imp;
    }
  }
  ini.normalize();

  return movimentato;
}

bool TAnal_balance::saldi(const char* conto, const char* costo, 
                          const char* commessa, const char* fase,
                          const TDate& dal, const TDate& al, char tipo, 
                          TImporto& ini, TImporto& dare, TImporto& avere) const
{
  TEsercizi_contabili esc;
  const int annoprec = esc.date2prevesc(dal);
  ini = saldo_fine_anno(conto, costo, commessa, fase, annoprec, tipo);
  const bool mov = saldo_movimenti(conto, costo, commessa, fase, dal, al, tipo, 
                                   ini, dare, avere);
  return mov;
}