campo-sirio/ps/ps0713200.cpp

#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <reputils.h>
#include <utility.h>
#include <relation.h>
#include <reprint.h>

#include "../ca/calib01.h"
#include "../ca/calib02.h"
#include "../ca/movana.h"
#include "../ca/rmovana.h"

#include "ps0713lib.h"

#include "ps0713200a.h"

                                       /////////////////////////////////
                                       ////    TIMPORTA_COMM_MSK    ////
                                       /////////////////////////////////

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

public:
  TImporta_comm_msk();
};

//ON_FIELD_EVENT: metodo che gestisce i comportamenti dei vari campi della maschera
//(per adesso segnaposto)
bool TImporta_comm_msk::on_field_event(TOperable_field& f, TField_event e, long jolly)
{
  return true;
}

//metodo costruttore
TImporta_comm_msk::TImporta_comm_msk() 
                  : TAutomask("ps0713200a"){}  

                                       /////////////////////////////////
                                       ////    TIMPORTA_COMM_APP    ////
                                       /////////////////////////////////

//Classe TImporta_comm_app
class TImporta_comm_app : public TSkeleton_application
{
  virtual bool check_autorization() const {return false;}
  virtual const char * extra_modules() const {return "cg";}

	TImporta_comm_msk*				_msk;	

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

  void scan_file(const TFilename& file, TAssoc_array& righe);
  void importa_cms(TAssoc_array& righe);

	bool transfer(const TFilename& file);
 
  TImporta_comm_app() {};
};

//SCAN_FILE: metodo che scandisce il file ed evita i duplicati
void TImporta_comm_app::scan_file(const TFilename& file, TAssoc_array& righe)
{
  TScanner s(file);
  TToken_string rec(50, ',');
  rec = s.line();
  
  TProgind pi(fsize(file), "Scansione file in corso...", true, true);

  //scorro tutto il file (per ogni riga devo riportare l'esito dell'importazione nel log)
  while (s.ok())
  {
    if (!pi.addstatus(s.tellg())) 
      break;

    TString16 idlavoro = rec.get(0);  idlavoro.strip("\"");

    //salto le righe vuote del file
    if (idlavoro.empty())
      continue;

    //recupero i dati di interesse dal file;
    //gruppo conto e sottoconto devono avere dei valori sensati
    TString gr = rec.get(1);  gr.strip("\"");  (gr == "" || gr == "?") ? gr ="0" : gr = gr;
    TString co = rec.get(2);  co.strip("\"");  (co == "" || co == "?") ? co ="0" : co = co;
    TString sc = rec.get(3);  sc.strip("\"");  (sc == "" || sc == "?") ? sc ="0" : sc = sc;

    TCommessa_string str(idlavoro, atoi(gr), atoi(co), atol(sc));
    if(!righe.is_key(str))
      righe.add(str, str);

    rec = s.line();
  }
}

void TImporta_comm_app::importa_cms(TAssoc_array& righe)
{
  TProgind pi(righe.items(), "Importazione commesse in corso...", true, true);
  TLog_report log("Importazione Commesse");

  TSystemisamfile com(LF_COMMESSE);  com.open(_excllock);
  TSystemisamfile rip(LF_RIP);       rip.open(_excllock);
  TSystemisamfile rrip(LF_RRIP);     rrip.open(_excllock);
  rip.last();
  const TRectype& r = rip.curr();
  long codice = r.get_long("CODICE");

  FOR_EACH_ASSOC_OBJECT(righe, obj, key, itm)
  {
    if (!pi.addstatus(1))
      break;

    TCommessa_string cms(key);
    TString80 codcms = cms.idlavoro();

    TString str;
    str << "La commessa " << codcms;

    rip.zero();
    rip.put("TIPO", 'B');
    rip.put("CODCOSTO", "");
    rip.put("CODCMS", codcms);
    int err_read = rip.read();

    if(err_read != NOERR)
    {
      const int  gruppo = cms.gruppo();   TString4  grup; grup.format("%03d",  gruppo);
      const int  conto  = cms.conto();    TString4  cont; cont.format("%03d",  conto);
      const long sotco  = cms.sotco();    TString8  sotc; sotc.format("%06ld", sotco);
      TString80 codconto; codconto << grup << cont << sotc;

      TString8 cod;
      cod.format("%08ld", ++codice);
      TString80 descr; descr << "Comessa " << codcms;

      TBill bill(gruppo, conto, sotco);

      const real percentuale(CENTO);

      com.put("CODCMS",  codcms);
      com.put("DESCRIZ", descr);

      rip.put("TIPO",    'B');
      rip.put("CODICE",  cod);
      rip.put("CODCMS",  codcms);
      if(gruppo > 0 && conto > 0 && sotco > 0)
        rip.put("INDBIL",  bill.indicatore_bilancio());
      rip.put("DESCRIZ", descr);

      rrip.put("TIPO",     'B');
      rrip.put("CODICE",   cod);
      rrip.put("NRIGA",    1);
      rrip.put("CODCMS",   codcms);
      rrip.put("CODCONTO", codconto);
      rrip.put("RIPARTO",  percentuale);

      int err = com.rewrite_write();
      if(err == NOERR)
        err = rip.write();

      if(err == NOERR)
        err = rrip.write();

      if(err == NOERR)
      {
        str << " <20> stata inserita";
        log.log(0, str);
      }
      else
      {
        str << " NON <20> stata inserita. Errore = " << err;
        log.log(2, str);
      }
    }
    else
    {
      str << " NON <20> stata inserita perch<63> esiste gi<67>";
      log.log(2, str);
    }
  }

  rrip.close();
  rip.close();
  com.close();
  //stampo a video il log
  TReport_book buc;
	buc.add(log);
	buc.preview();
}

TImporta_comm_app& app() { return (TImporta_comm_app&) main_app(); }

//TRASNFER: metodo che effettivamente svolge l'elaborazione di importazione
bool TImporta_comm_app::transfer(const TFilename& file)
{
  TAssoc_array righe;
  scan_file(file, righe);
  importa_cms(righe);
  return true;
}

bool TImporta_comm_app::create()
{
  _msk = new TImporta_comm_msk();
  return TSkeleton_application::create();
}

bool TImporta_comm_app::destroy()
{
	delete _msk;	
  return TApplication::destroy();
}

void TImporta_comm_app::main_loop()
{
  KEY	tasto;	
  tasto = _msk->run();
  if (tasto == K_ENTER)
  {
    //genero il nome del file da caricare
    TFilename name = _msk->get(F_PATH);
    name.add(_msk->get(F_NAME));
    TString str;
		if (transfer(name))
      message_box(TR("Importazione commesse completata"));
    else
      error_box(TR("L'importazione non <20> andata a buon fine"));		  
  }   
}

int ps0713200 (int argc, char* argv[])
{
  TImporta_comm_app main_app;
  main_app.run(argc, argv, TR("Importazione Commesse"));
  return true;
}