campo-sirio/ce/ce4400.cpp

#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <recset.h>

#include "../cg/cg2101.h"

#include "celib.h"
#include "ce2101.h"

#include "ce4400a.h"

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

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

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

public:
  TTrasf_mov_ce_cg_mask():TAutomask("ce4400a") { ditta_cespiti().init_mask(*this); }

};

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

//===============================================================================================
//Struct che serve per avere ammortamenti per categoria (Codcat|Qamm_tot|Qperse_tot)
struct TSaldo_cat :public TObject
{
  TString4 _codcat;
  real _qamm, _qperse;
  void add(const TRectype& rec_ammce);

  TSaldo_cat(const TString& codcat) : _codcat(codcat) {}
};

void TSaldo_cat::add(const TRectype& rec_ammce)
{
  //valore totale degli ammortamenti del cespite di tipo qnor,qant,qacc che trova in AMMCE
	const real qamm = rec_ammce.get_real(AMMCE_QNOR) + rec_ammce.get_real(AMMCE_QANT) + rec_ammce.get_real(AMMCE_QACC);
	//valore totale delle qperse del cespite che trova in AMMCE
  const real qperse = rec_ammce.get_real(AMMCE_QPERSE);
  
  _qamm += qamm;
  _qperse += qperse;
}

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

class TTrasf_mov_ce_cg : public TSkeleton_application
{ 
  TTrasf_mov_ce_cg_mask* _mask;

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

	void elabora();
	void delete_old_movs(const TDate& ini_es);

public:

};


void TTrasf_mov_ce_cg::delete_old_movs(const TDate& ini_es)
{
	TMovimentoPN pn;

  TRectype darec(LF_MOV);
	darec.put(MOV_DATAREG, ini_es);
	
	TString filtro;
	filtro.format("(PROVVIS==\"C\")");

  TCursor cur_mov (&pn, filtro, 2, &darec);
  const long items = cur_mov.items();
  cur_mov.freeze();
  TProgind progind(items, "Eliminazione vecchi movimenti provvisori cespiti in corso...", false, true);

  for (cur_mov = 0; cur_mov.pos() < items; ++cur_mov)
  { 
    progind.addstatus(1);
    pn.read();
    pn.remove();
  }

}

//metodo per gestire la successione degli eventi ad alto livello
void TTrasf_mov_ce_cg::elabora()
{
	//gettiamo un po' di parametri dalla maschera
	const long codes = _mask->get_long(F_ESERCIZIO);
	const TDate ini_es = _mask->get_date(F_INIZIO_ES);
	const TDate fine_es = _mask->get_date(F_FINE_ES);
	//deve accoppare i movimenti provvisori di prima nota da inizio esercizio ad oggi?
	if (_mask->get_bool(F_KILLOLD))
		delete_old_movs(ini_es);

	TDate datacalc;
	//se il trasferimento e' definitivo la data di calcolo e' quella finale dell'esercizio selezionato, senno'...
	//...e' quella indicata in F_DATACALC
	if (_mask->get_bool(F_PROVDEF))
		datacalc = _mask->get_date(F_FINE_ES);
	else
		datacalc = _mask->get_date(F_DATACALC);

	//programma vero e proprio (calcolo ammortamenti, selezione cespiti validi, trasferimento)
	TISAM_recordset cespiti("USE CESPI");
	const TRecnotype nrec = cespiti.items();

  if (nrec > 0) //test del cazzo necessario per avere una progind
  {
		//Assoc_array Categoria-QammTot-QperseTot
		TAssoc_array quote_per_cat;

		TProgind pi(nrec, TR("Ricalcolo ammortamenti in corso..."), true, true);
		for (int i = 0; cespiti.move_to(i); i++)
		{
			if (!pi.addstatus(1))
        break;
			//id e categoria del cespite corrente
			const TString& idcespite = cespiti.get(CESPI_IDCESPITE).as_string();
			TCespite cespite(idcespite);
			const TString4 codcat = cespiti.get(CESPI_CODCAT).as_string();

			//calcola gli ammortamenti di tutti i cespiti; SOLO situazione FISCALE (tiposit = 1)
			//la calc_amm pensa da sola a calcolare gli ammortamenti solo per i cespiti validi
      //l'ultimo parametro e' true x' il calcolo viene fatto in memoria!
		  cespite.calc_amm(1, datacalc, false, true);

			//controlla le quote del cespite in questione su AMMCE
			const TRectype& rec_ammce = cespite.amm_pro();
      
      TSaldo_cat* sc = (TSaldo_cat*)quote_per_cat.objptr(codcat);
      //se non trova il codice categoria lo aggiunge...
      if (sc == NULL)
      {
        sc = new TSaldo_cat(codcat);
        quote_per_cat.add(codcat, sc);
      }
      //..e poi somma i valori comunque
      sc->add(rec_ammce);

		}	//for(int i=0...
	}


	//calcolati,se richiesti,gli ammortamenti, passa in rassegna AMMCE e AMMMV alla ricerca dei cespiti..
	//..da considerare per il trasferimento vero e proprio (sono quelli

}

bool TTrasf_mov_ce_cg::create()
{
  _mask = new TTrasf_mov_ce_cg_mask;
  return TSkeleton_application::create();
}

bool TTrasf_mov_ce_cg::destroy()
{
  delete _mask;
  return true;
}

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

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

      default:
        break;
    }
  }
}


int ce4400(int argc, char* argv[])
{
  TTrasf_mov_ce_cg a;
  a.run(argc,argv,TR("Trasferimento movimenti cespiti in contabilita'"));
  return 0;
}