campo-sirio/ca/ca2300.cpp

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

#include "calib01.h"
#include "ca2.h"
#include "ca2300a.h"

#include "../cg/cglib01.h"

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

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

public:
  TRic_saldi_msk();  
  virtual ~TRic_saldi_msk(){};
};

bool TRic_saldi_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case F_ANNO:
    if (e == fe_init || e == fe_modify)
    {
      //in base all'esercizio selezionato dall'utonto, questo magico programma cerca quale è il movimento con data..
      //..competenza più antica che interessa l'esercizio selezionato (ricordiamo che i movimenti possono avere..
      //..durata pluriennale, da istruzioni adolfiche) ed esegue dall'esercizio contenente tale data il ricalcolo..
      //..dei saldi (Silvan non sei nessuno!)
      const int selected_anno = atoi(o.get());
      TEsercizi_contabili esc;
      TDate datainiesc, datafinesc;
      esc.code2range(selected_anno, datainiesc, datafinesc);
      TString query;
      query << "USE MOVANA\nSELECT (BETWEEN(DATAFCOMP,#DATAINIESC,0))||(AUTOFCOMP==\"X\")";
      TISAM_recordset recset(query);
      recset.set_var("#DATAINIESC", datainiesc);
      
      TDate datacomp = datainiesc;

      const long recset_items = recset.items();
      TProgind pi(recset_items, "Ricerca movimenti che interessano l'esercizio selezionato...", true, true);
      for (bool ok = recset.move_first(); ok; ok = recset.move_next())
      {
        if (!pi.addstatus(1))
          break;

        const TDate curr_date = recset.get(MOVANA_DATACOMP).as_date();
        if (curr_date < datacomp)
          datacomp = curr_date;
      }
      const int first_anno = esc.date2esc(datacomp);
      set(F_FIRST_ANNO, first_anno);
    }
    break;
  default:
    break;
  }
  return true;
}

TRic_saldi_msk::TRic_saldi_msk() :TAutomask ("ca2300a") { }  

///////////////////////////////////////////////////////////
// TAnal_mov_ric
///////////////////////////////////////////////////////////

class TAnal_mov_ric : public TAnal_mov
{
  int _annoes;

public:
  virtual int readat(TBaseisamfile& f, TRecnotype nrec, word lockop);
  virtual int read(TBaseisamfile& f, word op, word lockop);

public:
  void set_annoes(int anno) { _annoes = anno; }
  TAnal_mov_ric(long numreg = 0) : TAnal_mov(numreg), _annoes(0) {}
};

int TAnal_mov_ric::readat(TBaseisamfile& f, TRecnotype nrec, word lockop)
{
  const int err = TMultiple_rectype::readat(f, nrec, lockop);
  
	kill_saldi();
  load_saldi(false);
  save_saldi(_annoes);

  return err;
}

int TAnal_mov_ric::read(TBaseisamfile& f, word op, word lockop)
{
  const int err = TMultiple_rectype::read(f, op, lockop);
	
	kill_saldi();
	load_saldi(false);
  save_saldi(_annoes);

  return err;
}

//--------------------------------------------------------------------
//  APPLICAZIONE
//--------------------------------------------------------------------

class TRic_saldi_app : public TSkeleton_application
{
  TRic_saldi_msk * _mask;

protected:
  virtual const char * extra_modules() const {return "cm";} //deve funzionare anche per le commesse

  virtual bool create();
  virtual bool destroy();
  virtual void main_loop();
  static bool elabora_movimento(const TRelation& rel, void* pJolly) {	return true; }
  bool remove_saldi(const int first_anno);

public:
  TRic_saldi_app() {}
  virtual ~TRic_saldi_app() {}
};

bool TRic_saldi_app::create()
{
  _mask = new TRic_saldi_msk;  
  return TSkeleton_application::create();
}

bool TRic_saldi_app::destroy()
{
  delete _mask;
  return TSkeleton_application::destroy();
}

bool TRic_saldi_app::remove_saldi(const int first_anno)
{
  TSystemisamfile saldana(LF_SALDANA);
  const bool can_do = saldana.open(_excllock) == NOERR;
  if (can_do)
  {
    //deve azzerare i saldi a partire dal primo anno di interesse
    TString query;
    query << "USE SALDANA\nFROM ANNO=#ANNO";

    TISAM_recordset recset(query);
    recset.set_var("#ANNO", long(first_anno));
    const long recset_items = recset.items();
    TProgind pi(recset_items, "Azzeramento saldi...", true, true);

    const TRectype& rec_saldana = recset.cursor()->curr();
    for (bool ok = recset.move_first(); ok; ok = recset.move_next())
    {
      if (!pi.addstatus(1))
        break;
      rec_saldana.remove(saldana);
    }
    //alla fine compatta il file
    saldana.close();
    saldana.pack(true, false);
  }
  else
    error_box("Inpossibile procedere! File dei saldi analitici in uso");

	return can_do;
}

void TRic_saldi_app::main_loop()
{
  while (_mask->run() == K_ENTER)
  { 
    //Il ricalcolo saldi e' diviso in 2 fasi:
    //1  Azzeramento e ricalcolo dei saldi dei movimenti di tipo normale o temporaneo per il solo anno selezionato
    //2  Azzeramento e ricalcolo dei saldi dei movimenti di tipo preventivo o variazione per TUTTI gli esercizi..
    //..questo perche' i movimenti P e T possono essere "spalmati" su piu' anni

    //AZZERAMENTO dei saldi
		const int first_anno = _mask->get_int(F_FIRST_ANNO);
    remove_saldi(first_anno);

    //RICOSTRUZIONE saldi (eventualmente spammati su piu' anni)
    TEsercizi_contabili esc;
    const TDate datainies = esc[first_anno].inizio();
    TRelation rel_movana(LF_MOVANA);
    TRectype darec(LF_MOVANA);
    darec.put(MOVANA_DATACOMP, datainies);

    TCursor cur_movana(&rel_movana, "", 2, &darec);
    const long items = cur_movana.items();

    if (items > 0)
    {
      TAnal_mov_ric* amr = new TAnal_mov_ric;
      amr->set_annoes(0);
      rel_movana.lfile().set_curr(amr); //il record principale della rel e' un TMov_anal!!
      cur_movana.scan(elabora_movimento, this, "Ricostruzione saldi...");
      rel_movana.lfile().set_curr(new TRectype(LF_MOVANA)); //il record principale della rel e' un TMov_anal!!
    }
  } 
}

int ca2300(int argc, char* argv[])
{
  TRic_saldi_app app;
  app.run(argc, argv, "Ricostruzione saldi di analitica");
  return 0;
}