campo-sirio/lv/lv2600.cpp

#include <automask.h>
#include <textset.h>
#include <utility.h>

#include "../ve/velib.h"

#include  "lv2600a.h"

                                 /////////////////////////////////
                                 ////    TACQUISIZIONE_MSK    ////
                                 /////////////////////////////////

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

//ON_FIELD_EVENT: metodo che gestisce gli eventi sui campi della maschera
bool TAcquisizione_msk::on_field_event(TOperable_field& f,TField_event e,long jolly)
{
  switch (f.dlg())
	{
  case F_PATH:
    //se il campo <20> vuoto, provo a scriverlo dalla configurazione
    if (f.empty())
    {
      TConfig* configlv = new TConfig(CONFIG_DITTA,"lv");
      TString path = configlv->get("PathContapezzi");
      if (path.full())
        f.set(path);
    }
    break;
  default:
	  break;
	}
  return true;
}

TAcquisizione_msk::TAcquisizione_msk():TAutomask("lv2600a") 
{
}

                                 ///////////////////////////////////
                                 ////    TACQUISIZIONE_CACHE    ////
                                 ///////////////////////////////////

//classe TAcquisizione_cache
class TAcquisizione_cache : TCache
{
  TString4 _codnum, _tipodoc, _stato;

protected:
	virtual void discarding(const THash_object* obj);
  virtual TObject* key2obj(const char* key);

public:
  TDocumento& doc(const TDate& gg, const long cc);
  TAcquisizione_cache();
};

//DISCARDING: metodo che salva un documento sul disco prima di eliminarlo dalla cache
void TAcquisizione_cache::discarding(const THash_object* obj)
{
  TDocumento& doc = (TDocumento&)obj->obj();
  doc.rewrite();
}

//KEY2OBJ: metodo che sceglie il documento giusto da disco in modo da poterlo continuare, o lo crea se non c'<27>
TObject* TAcquisizione_cache::key2obj(const char* key)
{
  TToken_string chiave(key);
  const TDate datadoc = chiave.get();
  const long codcf = chiave.get_long();

  TString query;
  query<< "USE DOC KEY 2 SELECT STATO=#STATO\n";
  for (int i = 0; i < 2; i++)
  {
    query << (i ? "TO" : "FROM") << " " 
          << "TIPOCF=C CODCF=#CODCF ANNO=#ANNO DATADOC=#DATADOC CODNUM=#CODNUM\n";
  }
  TISAM_recordset rset(query);
  rset.set_var("#STATO", TVariant(_stato));
  rset.set_var("#CODCF", codcf);
  rset.set_var("#ANNO", long(datadoc.year()));
  rset.set_var("#DATADOC", datadoc);
  rset.set_var("#CODNUM", TVariant(_codnum));
  
  TDocumento* doc = NULL;

  if (rset.move_first())   
      doc = new TDocumento(rset.cursor()->curr());    
  else 
  {
    doc = new TDocumento('D',datadoc.year(),_codnum,0);
    doc->put(DOC_TIPODOC, _tipodoc);
    doc->put(DOC_STATO, _stato);
    doc->put(DOC_DATADOC, datadoc);
    doc->put(DOC_TIPOCF, "C");
    doc->put(DOC_CODCF, codcf);
  }
  return doc;
}

//DOC: metodo che restituisce un puntatore ad un documento identificato dalla coppia data - cliente
TDocumento& TAcquisizione_cache::doc(const TDate& gg, const long cc)
{
  TString16 key;
  key << gg.date2ansi() << '|' << cc;
  return *(TDocumento*)objptr(key);
}

//metodo costruttore di una cache di 17 elementi
TAcquisizione_cache::TAcquisizione_cache() : TCache(17) 
{
  TConfig cfg(CONFIG_DITTA, "lv");
  _codnum = cfg.get("NUM_RIT", NULL, 0);
  _tipodoc = cfg.get("TIPOOC_RIT", NULL, 0);
  _stato = cfg.get("STATO_RIT", NULL, 0);
}

                                 ////////////////////////////////////////////
                                 ////    TACQUISIZIONE_LAVANDERIE_APP    ////
                                 ////////////////////////////////////////////

//classe TAcquisizione_lavanderie_app
class TAcquisizione_lavanderie_app : public TSkeleton_application
{ 
  TAcquisizione_msk*		_msk;

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

  void elabora_file(const TString& file, bool new_file);


public:
  bool transfer();
  virtual void main_loop();  
};

//CREATE: metodo costruttore
bool TAcquisizione_lavanderie_app::create()
{
  _msk = new TAcquisizione_msk();
  TSheet_field& sheet = _msk->sfield(F_SHEET_NAME);
  sheet.set_auto_append();

  return TSkeleton_application::create();
}

//DESTROY: metodo distruttore
bool TAcquisizione_lavanderie_app::destroy()
{
	delete _msk;
  return TApplication::destroy();
}

//ELABORA_FILE: metodo che effettivamente fa l'elaborazione del file, creando i documenti
void TAcquisizione_lavanderie_app::elabora_file(const TString& file, bool new_file)
{
  TAcquisizione_cache ca;

  //scandisco il file
	TScanner s(file);	
  while (s.ok()) 
  {
    TString80 riga = s.line();
    if (riga.blank())
      continue;    

    TDate datadoc;
    long codcf;
    TString80 codart;
    long qta;
    long rotti;
    long ndoc;
    TString16 tipo_conteggio;
    TString80 operatore;

    //controllo quale tracciato record devo seguire
    if (riga.len() == 34) // -> MONTANARI
    {
      //leggo i campi dalla riga del file 
      datadoc.set_day(atoi(riga.mid(0,2)));
      datadoc.set_month(atoi(riga.mid(2,2)));
      datadoc.set_year(atoi(riga.mid(4,4)));
      
      codcf = atol(riga.mid(8,6));
      codart = riga.mid(14,8);
      qta = atol(riga.mid(22,6));
      rotti = atol(riga.mid(28,6));
    }
    else if (riga.len() == 121) // ->SKEMA
    {
      //leggo i campi dalla riga del file
      TDate datadoc;
      datadoc.set_year(atoi(riga.mid(0,4)));
      datadoc.set_month(atoi(riga.mid(4,2)));
      datadoc.set_day(atoi(riga.mid(6,2)));

      codart = riga.mid(8,20);
      codcf = atol(riga.mid(28,20));
      qta = atoi(riga.mid(48,11));
      ndoc = atoi(riga.mid(59,11));
      
      switch (atoi(riga.mid(70,11)))
      {
      case 1: tipo_conteggio = "Automatico"; break;
      case 2: tipo_conteggio = "Manuale"; break;
      case 3: tipo_conteggio = "Scarto"; break;
      default: break;
      }

      operatore = riga.mid(81,40);
    }

    bool found = false;

    TDocumento& doc = ca.doc(datadoc,codcf);
    //cerco se esiste gi<67> una riga sul documento selezionato per quell'articolo;
    //se la trovo sommo la quantit<69> appena letta a quella gi<67> esistente,
    //altrimenti creo una nuova riga documento  
    if (doc.rows() > 0 && new_file)
    {
      if (!yesno_box(TR("ATTENZIONE: il documento che si sta importando esiste gi<67>!\nSi desidera continuare?")))
        return;
      else if (yesno_box(TR("ATTENZIONE: Si desidera sovrascrivere il documento esistente(rispondendo NO le quantit<69> verranno sommate a quelle esistenti)?")))
        doc.destroy_rows();
    }

    for (int i = 1; i <= doc.rows(); i++)
    {
      TRiga_documento& rdoc = doc[i];
      if (rdoc.get(RDOC_CODART) == codart)
      {
        long qtardoc = rdoc.get_long(RDOC_QTA);
        qtardoc += qta;
        rdoc.put(RDOC_QTA,qtardoc);
        found = true;
        break;
      }
    }
  
    if (found == false)
    {
      TRiga_documento& rdoc = doc.new_row("01");
      rdoc.put(RDOC_CODART,codart);
      rdoc.put(RDOC_QTA,qta);
    }
    new_file = false;
  }
}

//TRANSFER: metodo che scorre i campi nome e, se sono pieni, richiama il metodo
//ELABORA_FILE(), che effettivamente fa l'elaborazione
bool TAcquisizione_lavanderie_app::transfer()
{   
  //prendo il path dalla maschera
  const TString& path = _msk->get(F_PATH);
  TSheet_field& sheet = _msk->sfield(F_SHEET_NAME);
  TFilename file;

  //per ogni riga dello sheet, leggo il suo contenuto, se contiene dei caratteri jolly
  //preparo la lista dei file che soddisfano la maschera in quella directory e li elaboro
  //tutti, altrimenti elaboro esattamente il file che <20> scritto sullo sheet
  FOR_EACH_SHEET_ROW(sheet, r1, row1)
  {  
    if(row1->full())
    {
      file = path;
      file.add(*row1);

      if (file.find('*') >= 0 || file.find('?') >= 0)
      {          
          TString_array lista_file;
          list_files(file, lista_file);

          FOR_EACH_ARRAY_ROW(lista_file, r2, row2)
            elabora_file(*row2, true);
      }
      else
        elabora_file(file, true);
    }
  }
  return true;
}

void TAcquisizione_lavanderie_app::main_loop()
{
  while (_msk->run() == K_ENTER)
		transfer();
}

int lv2600(int argc, char *argv[])
{
  TAcquisizione_lavanderie_app a;
  a.run (argc, argv, "Acquisizione bolle di rientro/ritiro");
  return TRUE;
}