campo-sirio/ce/ce4200.cpp

#include <applicat.h>
#include <automask.h>
#include <form.h>
#include <printer.h>
#include <recarray.h>

#include "..\ve\velib.h"

#include "ce4200a.h"
#include "ce4200.h"

#include "ammce.h"
#include "cespi.h"
#include "salcecms.h"

//===============================================================================================
//maschera

class TCalc_cesp_cms_mask: public TAutomask 
{
public:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

  TCalc_cesp_cms_mask():TAutomask("ce4200a") {}

};

bool TCalc_cesp_cms_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
/*  switch (o.dlg())
  {
    default: break;
  }*/
  return true;
}

//===============================================================================================
//form
class TCalc_cesp_cms_form : public TForm
{

protected:
  bool validate(TForm_item &cf, TToken_string &s);
public:
  TCalc_cesp_cms_form();

  virtual ~TCalc_cesp_cms_form();
};
  
TCalc_cesp_cms_form::TCalc_cesp_cms_form() :TForm ("ce4200a")
{
} 

TCalc_cesp_cms_form::~TCalc_cesp_cms_form()
{ 
}

bool TCalc_cesp_cms_form::validate(TForm_item &cf, TToken_string &s)
{
  if (s == "_DESCRCESPITE")
  {
    TString16 str;
    str.format("%010ld",cursor()->curr().get_long(DOC_NDOC));
    const TString& descr = cache().get(LF_CESPI, str, CESPI_DESC);
    cf.set(descr);
    return true; //ricava la descrizione del cespite e la manda in stampa

  }

  return TForm::validate(cf,s);
}


//===============================================================================================
//Applicazione

class TCalc_cesp_cms : public TSkeleton_application
{ 
  TCalc_cesp_cms_mask* _mask;
  TCalc_cesp_cms_form* _form;

protected:
  virtual void main_loop();
  virtual bool create();
  virtual bool destroy();

public:
  void utilizzo_per_cms(const TRectype& ammce_rec);
  real calc_perc_util_cesp(const TRectype& salcecms_rec, const TDate& dtinices, const TDate& dtfineces);
  void elabora_docs();
  void stampa_docs();
};



real TCalc_cesp_cms::calc_perc_util_cesp(const TRectype& salcecms_rec, const TDate& dtinices, const TDate& dtfineces)
{ 
//prende il codice commessa del record..
  TString80 codcms = salcecms_rec.get(SALCECMS_CODCMS);
//..ed accede cosi' alla tabella delle commesse
  const TRectype& cms = cache().get("CMS", codcms);
//prende le date di inizio e fine commessa dalla tabella per poterle confrontare con le date limite
//del cespite nell'esercizio  
  TDate dtfine = dtfineces;
  const TDate dtfinecms = cms.get_date("D1");
  if ((dtfinecms.ok()) && (dtfinecms < dtfineces))
    dtfine = dtfinecms;

  TDate dtini = dtinices;
  const TDate dtinicms = cms.get_date("D0");
  if ((dtinicms.ok()) && (dtinicms > dtinices))
    dtini = dtinicms;
//intervallo giorni di utilizzo cespite nella commessa
  const real delta_cms = real(dtfine - dtini + 1) / real(dtfineces - dtinices + 1);

//adeesso prende la percentuale di utilizzo del cespite nella commessa..
  real percutil = salcecms_rec.get_real(SALCECMS_PERCUTIL);
//normalizza la percentuale...
  percutil = percutil / CENTO;
//...e la porta in giorni rispetto al totale di utilizzo dei giorni del cespite nell'esercizio
//(il 100% sono i giorni di utilizzo del cespite in tutte le commesse dell'esercizio)
  percutil *= delta_cms;

  return percutil;
}



void TCalc_cesp_cms::utilizzo_per_cms(const TRectype& ammce_rec)
{
//totale quote del cespite in esame per l'esercizio corrente (per tutte le commesse)
  real qtot = ammce_rec.get_real(AMMCE_QNOR);
  qtot += ammce_rec.get_real(AMMCE_QACC);
  qtot += ammce_rec.get_real(AMMCE_QANT);
//controllo su date inizio e fine del periodo di utilizzo del cespite nell'esercizio selezionato
  if (qtot != ZERO)
  {
    const TString16 idcesp = ammce_rec.get(CESPI_IDCESPITE);
    const TRectype& cespi = cache().get(LF_CESPI, idcesp);

    const TDate dtinies = _mask->get_date(F_INIZIO_ES);
    const TDate dtfines = _mask->get_date(F_FINE_ES);

    TDate dtfine = dtfines;
    const TDate dtalien = cespi.get_date(CESPI_DTALIEN);
    if ((dtalien.ok()) && (dtalien < dtfines))
      dtfine = dtalien;
  
    TDate dtini = dtinies;
    const TDate dtfunz = cespi.get_date(CESPI_DTFUNZ);
    if ((dtfunz.ok()) && (dtfunz > dtinies))
      dtini = dtfunz;
  //..a questo punto dtini e dtfine rappresentano il periodo di utilizzo del cespite 
  //nell'esercizio selezionato
  //quindi il periodo di utilizzo del cespite nell'esercizio,in giorni,sara'...
    const long delta_cesp = dtfine - dtini + 1;
    
  //Adesso si controlla la durata di ogni commessa (alla quale il cespite ha partecipato) durante
  //l'esercizio delezionato
    const int current_ese = ammce_rec.get_int(AMMCE_CODES);

  //crea un record array dove memorizzare i record del file salcecms riguardanti il cespite e 
  //l'esercizio selezionati
    TRecord_array salcecms(LF_SALCECMS, "NRIGA");
    TRectype* key = new TRectype(LF_SALCECMS);
    key->put("IDCESPITE",idcesp);
    key->put("CODES",current_ese);
    salcecms.read(key);

  //ciclo su SALCECMS data una chiave idcespite + esercizio (si fa solo se salcecms non e' vuoto,
  //e' inutile perdere tempo..)
    if (salcecms.rows() > 0)
    {
  //crea documento relativo al cespite in questione (nell'esercizio);ogni riga del documento
  //sara' relativa ad una commessa
      const TString4 codnum = _mask->get(F_CODNUM);
      const TString4 tipodoc = _mask->get(F_TIPODOC);
      const TString4 tiporiga = _mask->get(F_TIPORIGA);
      TDocumento doc_cesp('D', current_ese, codnum, atol(idcesp));
      doc_cesp.put(DOC_TIPODOC, tipodoc);
      doc_cesp.put(DOC_DATADOC, TDate(TODAY));
      doc_cesp.body(LF_RIGHEDOC).destroy_rows();

      TGeneric_distrib distrib(qtot, TCurrency::get_firm_dec());
      int i;
      for (i=1; i<=salcecms.last_row(); i++ )
      {
        const real perc = calc_perc_util_cesp(salcecms[i], dtini, dtfine);
        distrib.add(perc);
      }
  //e riempiamo 'sta riga!
      for (i=1; i<=salcecms.last_row(); i++ )
      {
        TRiga_documento& rigadoc = doc_cesp.new_row(tiporiga);
        TString80 codcms = salcecms[i].get(SALCECMS_CODCMS);
        rigadoc.put(RDOC_CODCMS, codcms); //codice commessa
        rigadoc.put(RDOC_QTA, 1);
        const real quota = distrib.get();
        const TRectype& cms = cache().get("CMS", codcms);
        TString80 descr = cms.get("S0");  //descrizione commessa cosi' tanto x mettercela
        rigadoc.put(RDOC_DESCR, descr);
        rigadoc.put(RDOC_PREZZO, quota);          //ammortamento cespite per la commessa
        const real perc_cms = salcecms[i].get_real(SALCECMS_PERCUTIL);
        rigadoc.put(RDOC_QTAGG1, perc_cms);       //% utilizzo cespite nella commessa
        rigadoc.put(RDOC_QTAGG2, dtfine - dtini); //giorni di utilizzo cespite nella commessa
        rigadoc.put(RDOC_QTAGG3, delta_cesp);     //giorni di utilizzo cespite nell'esercizio
        real perc = quota * CENTO / qtot; perc.round(2);  //percentuale della quota
        rigadoc.put(RDOC_QTAGG4, perc);
        rigadoc.put(RDOC_DATACONS, TDate(TODAY)); //data di elaborazione
        rigadoc.put(RDOC_CODIVA, _mask->get(F_CODIVA)); //codice IVA obbligatorio
      }
  //scrittura del documento sul file
      doc_cesp.write();

    }//fine if (salcecms.rows()>0)
  }//fine if(qtot!=0)
}


void TCalc_cesp_cms::elabora_docs()
{
  TRectype darec(LF_AMMCE),arec(LF_AMMCE);
  const int esercizio = _mask->get_int(F_ESERCIZIO);    
  darec.put(AMMCE_IDCESPITE, _mask->get(F_DA_IDCESPITE));
  arec.put(AMMCE_IDCESPITE, _mask->get(F_A_IDCESPITE));
  TString filtro;
  filtro.format("(CODES==%d)&&(TPSALDO==2)&&(TPAMM==1)",esercizio);

  TRelation rel(LF_AMMCE);
  TCursor cur(&rel, filtro, 1, &darec, &arec);
  const long items = cur.items();
  cur.freeze();

//ciclo sui cespiti di AMMCE nel codes selezionato
  for (cur=0; cur.pos()<items; ++cur)
  { 
    utilizzo_per_cms(cur.curr());
  }
}


void TCalc_cesp_cms::stampa_docs()
{

//setta la testata del form
  _form->find_field('H', odd_page, FR_CODDITTA).set(_mask->get(F_DITTA));
  _form->find_field('H', odd_page, FR_RAGSOC).set(_mask->get(F_RAGSOC));
  _form->find_field('H', odd_page, FR_ESERCIZIO).set(_mask->get(F_ESERCIZIO));
  _form->find_field('H', odd_page, FR_DATAINIZIO).set(_mask->get(F_INIZIO_ES));
  _form->find_field('H', odd_page, FR_DATAFINE).set(_mask->get(F_FINE_ES));

//stampa i documenti via form (ci vuole una setregion)
  TCursor& curform = *_form->cursor();
  TRectype darec(curform.curr());
  darec.put(RDOC_PROVV, 'D');
  darec.put(RDOC_ANNO, _mask->get_int(F_ESERCIZIO));
  darec.put(RDOC_CODNUM, _mask->get(F_CODNUM));
  darec.put(RDOC_NDOC, _mask->get_long(F_DA_IDCESPITE));
  TRectype arec(darec);
  arec.put(RDOC_NDOC, _mask->get_long(F_A_IDCESPITE));
  curform.setregion(darec, arec);
  _form->print();
}


bool TCalc_cesp_cms::create()
{
  _mask = new TCalc_cesp_cms_mask;
  _form = new TCalc_cesp_cms_form;

  TConfig config_doc ("ce4200a.ini", "Main");
  _mask->set(F_CODNUM, config_doc.get("CODNUM"));
  _mask->set(F_TIPODOC, config_doc.get("TIPODOC"));
  _mask->set(F_TIPORIGA, config_doc.get("TIPORIGA"));
  _mask->set(F_CODIVA, config_doc.get("CODIVA"));

  return TSkeleton_application::create();
}

bool TCalc_cesp_cms::destroy()
{
  delete _mask;
  delete _form;
  return TRUE;
}

void TCalc_cesp_cms::main_loop()
{
  KEY k = K_ENTER;
  while (k != K_QUIT)
  {
    k = _mask->run();

    switch (k)
    {
      case K_ENTER:
        elabora_docs();
      break;

      case K_ESC: 
        stampa_docs();
      break;

      default:
        break;
    }
  }
}


int ce4200(int argc, char* argv[])
{
  TCalc_cesp_cms a;
  a.run(argc,argv,TR("Calcolo e stampa cespiti per commessa"));
  return 0;
}