campo-sirio/ci/ci1300.cpp

#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <recarray.h>
#include <relation.h>
#include <reprint.h>

#include "../ca/calib01.h"
#include "../ca/commesse.h"

#include "rilore.h"
#include "ci1350.h"
#include "ci1300a.h"


///////////////////////////////////////////////////////////
// Report
///////////////////////////////////////////////////////////

class TRil_ore_ris_report : public TReport
{
protected:
  virtual bool use_mask() { return false; }

public:
  TRil_ore_ris_report(const char tipostampa);
};


TRil_ore_ris_report::TRil_ore_ris_report(const char tipostampa)
{
  if (tipostampa == 'M')
    load("ci1300a");
  else
    load("ci1300b");

  TRil_ore_recordset* recset = new TRil_ore_recordset;
  set_recordset(recset);
}
///////////////////////////////////////////////////////////
// Maschera
///////////////////////////////////////////////////////////

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

  void elabora_risorsa(const TString& curr_risorsa, TReport& rep) const;
	
public:
  void elabora() const;

  TRil_ore_ris_mask();
  virtual ~TRil_ore_ris_mask() {}
};

TRil_ore_ris_mask::TRil_ore_ris_mask() : TAutomask("ci1300a")
{
}

bool TRil_ore_ris_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  return true;
}

void TRil_ore_ris_mask::elabora_risorsa(const TString& curr_risorsa, TReport& rep) const
{
  const int tipo_ordinamento = get_int(F_ORDINAMENTO);
  const char tipo_stampa = get(F_TIPOSTAMPA)[0];
	const bool split = get_bool(F_RIPARTISCI);


  //creare un assoc_array con chiave TToken_string cms-sede-fase(1) o sede-cms-fase(2) in base ai parametri..
  //..indicati sulla maschera
  //se tipo_stampa = 'M'ensile: il contenuto dell'assoc_array sarà: tot_Prev - 31 valori giornalieri Consuntivi - tot_Consuntivo
  //se tipo_stampa = 'A'nnuale: il contenuto dell'assoc_array sarà: tot_Prev - 12 valori mensili Consuntivi - tot_Consuntivo

  TAssoc_array righe;

  const TVariant tiporisorsa = get(F_RISOATT);

  //query sul file delle ore in chiave 3: TIPO+TIPORA+CODICE+.....frega niente altro
  TString query;
  query << "USE RILORE KEY 3";
  query << "\nFROM TIPO=#TIPO TIPORA=#TPRA CODICE=#CODICE";
  query << "\nTO TIPO=#TIPO TIPORA=#TPRA CODICE=#CODICE";

  TISAM_recordset rilore_recset(query);
  rilore_recset.set_var("#TPRA", tiporisorsa);
  rilore_recset.set_var("#CODICE", curr_risorsa);

  //un giro con le ore a 'P'reventivo, uno con quelle a 'C'onsuntivo
  for (int i = 0; i < 2; i++)
  {
    const TVariant tipo = i == 0 ? "P" : "C";
    rilore_recset.set_var("#TIPO", tipo);

    const long rilore_recset_items = rilore_recset.items();

    for (bool ok = rilore_recset.move_first(); ok; ok = rilore_recset.move_next())
    {
      const TString80 codcosto = rilore_recset.get(RILORE_CODCOSTO).as_string();
      const TString80 codcms = rilore_recset.get(RILORE_CODCMS).as_string();
      const TString16 codfase = rilore_recset.get(RILORE_CODFASE).as_string();

      //panegirico allucinante per riproporzionare le ore in base al mese, alla commessa, alle feste ecc. in modo da..
      //..ottenere alla fine il numero di giorni lavorativi buoni per la commessa nel mese scelto
      //date limite commessa
      const TRectype& rec_cms = cache().get(LF_COMMESSE, codcms);
      TDate ini_cms, fine_cms;
      const int durata_cms = ca_durata_commessa(rec_cms, ini_cms, fine_cms);
      //date limite qta ore sul record del file LF_RILORE
      TDate dataini = rilore_recset.get(RILORE_DADATA).as_date();
      TDate datafine = rilore_recset.get(RILORE_ADATA).as_date();

      //adatta le date alla commessa se quest'ultima è contenuta nell'intervallo (può essere più breve..
      //..dell'intervallo selezionato, oppure sovrapporsi solo parzialmente)
      if (fine_cms < datafine)
        datafine = fine_cms;
      if (ini_cms > dataini)
        dataini = ini_cms;
			if (i == 1 && (dataini.month() != get_int(F_MESE) || dataini.year() != get_int(F_ANNO)))
				continue;
      //se la commessa fosse tutta nel futuro o nel passato -> lascia perdere
			const long giorni_lavorativi = split ? ci_calcola_giorni_lavorativi(dataini, datafine)  : 1L;
      if (giorni_lavorativi <= 0)
        continue;

      //metodo semidivino per calcolare, dati l'anno ed il il mese selezionati, la commessa corrente, le date inizio e fine,..
      //..quanti sono i giorni di lavoro lavorativi per suddividere la quantità di ore
      TDate ini_lav, fine_lav;
      const int anno = get_int(F_ANNO);
      const int mese = tipo_stampa == 'M' ? get_int(F_MESE) : 0;
			long giorni_lavorativi_cms = ci_calcola_giorni_lavorativi_cms(anno, mese, ini_cms, fine_cms, dataini, datafine, ini_lav, fine_lav);

      //adesso deve riproporzionare il monte ore sul record sul mese selezionato (fa tutto il lavoro se ci sono giorni..
      //..lavorativi sulla commessa in questione)
			if (giorni_lavorativi_cms == 0 && !split && i == 1)
				giorni_lavorativi_cms = giorni_lavorativi;
      if (giorni_lavorativi_cms > 0)
      {
        const real tot_ore = rilore_recset.get(RILORE_QTAORE).as_real();
        const real tot_ore_uso_risorsa_nel_periodo_per_cms = tot_ore * giorni_lavorativi_cms / giorni_lavorativi;

        //crea la chiave per l'assoc_array
        TToken_string key;
        switch(tipo_ordinamento)
        {
        case 1: key.add(codcms);  break;
        case 2: key.add(codcms); key.add(codcosto); break;
        case 3: key.add(codcms); key.add(codfase);  break;
        case 4: key.add(codcms); key.add(codcosto); key.add(codfase); break;
        case 5: key.add(codcosto);  break;
        case 6: key.add(codcosto);  key.add(codcms);  break;
        case 7: key.add(codcosto);  key.add(codfase); break;
        case 8: key.add(codcosto);  key.add(codcms); key.add(codfase);  break;
        default:  break;
        }

        //se la chiave non esiste già nell'assoc_array allora crea l'elemento
        TToken_string* record = (TToken_string*)righe.objptr(key);
        if (record == NULL)
        {
          record = new TToken_string;
          righe.add(key, record);
        }

        if (i == 0) //'P'reventivo (aggiorna solo il totale)
        {
          real prev = record->get(0);
          prev += tot_ore_uso_risorsa_nel_periodo_per_cms;
          record->add(prev.string(), 0);
        }
        else  //'C'onsuntivo (aggiorna tutte le caselle dei giorni lavorativi)
        {
					if (split)
					{
						const real ore_al_giorno = tot_ore / giorni_lavorativi;
						for (TDate data = ini_lav; data <= fine_lav; ++data)
						{
							if (giorni_lavorativi == 1 || ci_is_ferial_day(data))
							{
								const int index = tipo_stampa == 'M' ? data.day() : data.month();
								real prev = record->get(index);
								prev += ore_al_giorno;
								record->add(prev.string(), index);
								real tot = record->get(32);
								tot += ore_al_giorno;
								record->add(tot.string(), 32);
							}
						}
					}
					else
					{
						const int index = tipo_stampa == 'M' ? rilore_recset.get(RILORE_GIORNO).as_int() : rilore_recset.get(RILORE_MESE).as_int();
						real prev = record->get(index);
						prev += tot_ore;
						record->add(prev.string(), index);
						real tot = record->get(32);
						tot += tot_ore;
						record->add(tot.string(), 32);
					}
        }
      } //if (giorni_lavorativi_cms > 0)..
    } //for (bool ok = rilore_recset.move_first();..

  } //for (int i = 0; i < 2; i++)...

  //setta un nuovo recset al report: se non lo facesse il recset sarebbe sempre il medesimo per ogni..
  //..risorsa (ovvero assoc_array) e quindi si incrementerebbe all'ignoranza
  TRil_ore_recordset* recset = new TRil_ore_recordset;
  rep.set_recordset(recset);
  //tenta la mask2report per far apparire sul report i campi di selezione della maschera
  rep.mask2report(*this);
  //finita l'elaborazione che ha riempito l'assoc_array, asegna il medesimo ad un..
  //..csv_recordset e poi sbatte quest'ultimo (ordinato) nel report
  //Il tutto nel magico metodo che segue!
  ci_fill_recset_from_ass(righe, rep, split);
  //campo a mano per fare scattare la mask2report()
  rep.recordset()->set_var("#CODRIS", curr_risorsa, true);

}


//metodo di alto livello per filtrare su ris/att e chiamare i metodi di livello inferiore per elaborare la singola ris/att
void TRil_ore_ris_mask::elabora() const
{
  TReport_book book;

  //stampa mensile o annuale?
  const char tipostampa = get(F_TIPOSTAMPA)[0];
  TRil_ore_ris_report rep(tipostampa);

  if (tipostampa == 'M')
    format_report_month(get_int(F_ANNO), get_int(F_MESE), rep);

  //query sulla tabella interessata (risorse o attrezzature)
  TString16 da_ris_att, a_ris_att;
  TString query_ris_att;
  TString msg;
  const char tiporisorsa = get(F_RISOATT)[0];

  if (tiporisorsa == 'R')
  {
    da_ris_att = get(F_DA_CODRIS);
    a_ris_att = get(F_A_CODRIS);
    query_ris_att << "USE RSS";
    msg << "Scansione risorse...";
  }
  else
  {
    da_ris_att = get(F_DA_CODATT);
    a_ris_att = get(F_A_CODATT);
    query_ris_att << "USE ATR";
    "Scansione attrezzature...";
  }

  query_ris_att << "\nFROM CODTAB=#DACODICE";
  query_ris_att << "\nTO CODTAB=#ACODICE";
  
  TISAM_recordset recset_ris_att(query_ris_att);
  recset_ris_att.set_var("#DACODICE", da_ris_att);
  recset_ris_att.set_var("#ACODICE", a_ris_att);
  const long recset_ris_att_items = recset_ris_att.items();

  TProgind pi(recset_ris_att_items, msg, true, true);

  //per ogni risorsa/attrezzatura dell'elenco genera un report singolo che viene riempito nella elabora_risorsa e..
  //..aggiunto al book per la stampa finale
  for (bool ok = recset_ris_att.move_first(); ok; ok = recset_ris_att.move_next())
  {
    if (!pi.addstatus(1))
      break;

    const TString80 curr_risorsa = recset_ris_att.cursor()->curr().get("CODTAB");

    elabora_risorsa(curr_risorsa, rep);

    book.add(rep);
  }

  //e alla fine stampa il book
  book.preview();
}


///////////////////////////////////////////////////////////
// Applicazione
///////////////////////////////////////////////////////////

class TRil_ore_ris : public TSkeleton_application
{
protected:

public:
  virtual void main_loop();
};


void TRil_ore_ris::main_loop()
{
  TRil_ore_ris_mask mask;
  
  while (mask.run() == K_ENTER)
  {
    mask.elabora();
  }
}

int ci1300(int argc, char* argv[])
{
  TRil_ore_ris sd;
  sd.run(argc, argv, "Rilevazione ore per Risorsa - Attrezzatura");
  return 0;
}