campo-sirio/lv/lv3600.cpp

#include <applicat.h>
#include <automask.h>
#include <defmask.h>
#include <progind.h>
#include <textset.h>

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

#include "lvcondv.h"
#include "lvrcondv.h"

#include  "lv3600a.h"

                                 ///////////////////////////
                                 ////    TINVCON_REC    ////
                                 ///////////////////////////

//classe TInvcon_rec
class TInvcon_rec: public TAS400_recordset
{
  TString4   _umkg;
private:
  const real convert_to_kg(const TString& codart, const TString& umkg);  
public:  
  void aggiungi_riga(const long codcf, const TString& codart);
  TInvcon_rec();
};

//CONVERT_TO_KG: metodo che converte il peso di un articolo
const real TInvcon_rec::convert_to_kg(const TString& codart, const TString& umkg)
{
  TArticolo& art = cached_article(codart);

  const TString4 ump  = art.get(ANAMAG_UMP);
	const real     peso = art.get_real(ANAMAG_PESO);

  real qtaconv = ZERO;
		
	if (ump.full() && peso != ZERO)
	{
		//preparo una cache sulla tabella delle unità di misura
		const TRectype& unita = cache().get("%UMS", ump);     
		//leggo e controllo se esiste l'unità di misura di riferimento
		const TString4 umrif = unita.get("S7");
		real fatconv = UNO;

		if (umrif == umkg)
		{
			//leggo e controllo il fattore di conversione
			fatconv = unita.get_real("R10");
		}

		//se tutti i controlli sono andati a buon fine, converto la quantità e la restituisco
    if(fatconv != ZERO)
      qtaconv = fatconv * peso;
  }
  return qtaconv;
}

//metodo per aggiungere righe al recordset da stampare
void TInvcon_rec::aggiungi_riga(const long codcf, const TString& codart)
{
  //preparo la cache sul clifo
  TToken_string clifokey;
  clifokey.add('C'); 
  clifokey.add(codcf);
  const TRectype& clifo = cache().get(LF_CLIFO, clifokey);
  
  //recupero i dati di interesse da clifo
  TString80 ragsoc1  = clifo.get(CLI_RAGSOC).left(30);
  TString80 ragsoc2  = clifo.get(CLI_RAGSOC).mid(30);
  //leggo il comune
  TString80 citta;
  TToken_string comunikey;
  comunikey.add("");
  comunikey.add(clifo.get(CLI_COMCF));
  if(clifo.get(CLI_LOCCF).full())
    citta << clifo.get(CLI_LOCCF) << ' ';
  citta << cache().get(LF_COMUNI, comunikey).get("DENCOM");
  citta.cut(39);

  //preparo la cache su anamag 
  const TRectype& anamag = cache().get(LF_ANAMAG, codart);

  //recupero i dati di interesse da anamag  
  TString80 desart = anamag.get(ANAMAG_DESCR);
  real      peso   = convert_to_kg(codart, _umkg);
  long      lavco1 = atoi(anamag.get(ANAMAG_ARTLAVCONT).left(2));
  long      lavco2 = 0;  //non serve
  long      linde1 = anamag.get_int(ANAMAG_LINDEST1);
  long      linde2 = anamag.get_int(ANAMAG_LINDEST2);
  long      lavatr = anamag.get_int(ANAMAG_LAVATRICE);
  long      codla1 = anamag.get_int(ANAMAG_CODLAV1);
  long      codla2 = anamag.get_int(ANAMAG_CODLAV2);
  long      mangan = anamag.get_int(ANAMAG_MANGDEST);
  long      ppconf = anamag.get_int(ANAMAG_PPCONF);

  //creo fisicamente la nuova riga
  new_rec("");
  set("CODCF",     (TVariant)codcf);
  set("RAGSOC1",   ragsoc1);
  set("RAGSOC2",   ragsoc2);
  set("CITTA",     citta);
  set("CODART",    codart);
  set("DESART",    desart);
  set("PESO",      peso);
  set("LAVCON1",   (TVariant)lavco1);
  set("LINDES1",   (TVariant)linde1);
  set("LINDES2",   (TVariant)linde2);
  set("LAVATR",    (TVariant)lavatr);
  set("CODARTLAV", (TVariant)codla1);
  set("CODCLILAV", (TVariant)codla2);
  set("MANGANO",   (TVariant)mangan);
  set("CONF",      (TVariant)ppconf);  
}

TInvcon_rec::TInvcon_rec()
            :TAS400_recordset("AS400(185)")
{
  create_field("FILLER1",   -1,   1,  _alfafld,    false); //riempimento
  create_field("CODCF",     -1,   6,  _longfld,    true);  //codice cliente
  create_field("RAGSOC1",   -1,  30,  _alfafld,    true);  //ragione sociale 1
  create_field("RAGSOC2",   -1,  29,  _alfafld,    true);  //ragione sociale 2
  create_field("CITTA",     -1,  40,  _alfafld,    true);  //città (località + comune)
  create_field("FILLER2",   -1,   2,  _alfafld,    false); //riempimento
  create_field("CODART",    -1,   8,  _alfafld,    true);  //codice articolo
  create_field("DESART",    -1,  30,  _alfafld,    true);  //descrizione articolo
  create_field("FILLER3",   -1,   9,  _alfafld,    false); //riempimento
  create_field("PESO",      -1,   6,  _realfld,    true);  //peso
  create_field("LAVCON1",   -1,   2,  _intzerofld, true);  //lavacontinua 1
  create_field("LAVCON2",   -1,   2,  _intzerofld, false); //lavacontinua 2
  create_field("LINDES1",   -1,   2,  _intzerofld, true);  //linea di destinazione 1
  create_field("LINDES2",   -1,   2,  _intzerofld, true);  //linea di destinazione 2
  create_field("LAVATR",    -1,   2,  _intzerofld, true);  //lavatrice
  create_field("CODARTLAV", -1,   3,  _intzerofld, true);  //codice lavaggio 1
  create_field("CODCLILAV", -1,   3,  _intzerofld, true);  //codice lavaggio 2
  create_field("MANGANO",   -1,   3,  _intzerofld, true);  //mangano
  create_field("CONF",      -1,   3,  _intzerofld, true);  //numero di pezzi per confezione
  create_field("ACAPO",     -1,   2,  _alfafld,    true, TVariant("\r\n"));  //caratteri di a capo

   _umkg = ini_get_string(CONFIG_DITTA, "lv", "UmKg");
}



                                 ///////////////////////////
                                 ////    TINVCON_MSK    ////
                                 ///////////////////////////

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

  void esporta() const;

public:
  TInvcon_msk();
};

//ESPORTA: metodo che crea il file di output nel percorso desiderato
void TInvcon_msk::esporta() const
{
  //recupero i dati di interesse dalla maschera
  const TDate datasc = get_date(F_SCAD);

  //prendo il path dalla maschera
  const TString& path = get(F_PATH);
  const TString& fname = get(F_FILE);
  TFilename file = path;
  file.add(fname);

  //preparo il recodset che contiene tutti i contratti validi
  TString query1;
  query1 << "USE LVCONDV\n"
         << "SELECT (BETWEEN(DATAIN,\"\",#DATA))&&((DATASC>=#DATA)||(DATASC=\"\"))\n"
         << "BY CODCF";

  TISAM_recordset contratti(query1);
  contratti.set_var("#DATA", datasc);

  if(contratti.items() > 0)
  {
    TInvcon_rec* recset = new TInvcon_rec();

    TAssoc_array presenti;
    
    contratti.move_first();
    long oldcodcf = contratti.get(LVCONDV_CODCF).as_int();

    TProgind pi(contratti.items(), "Esportazione in corso...", true, true);

    for(bool ok1 = contratti.move_first(); ok1; ok1 = contratti.move_next())
    {
      if (!pi.addstatus(1))
			  break;

      const long codcf  = contratti.get(LVCONDV_CODCF).as_int();
      const long codcon = contratti.get(LVCONDV_CODCONT).as_int();

      if(oldcodcf != codcf)
      {
        presenti.destroy();
        oldcodcf = codcf;
      }

      //preparo il recordset che contiene le righe del contratto in essere
      TString query2;
      query2 << "USE LVRCONDV\n"
             << "BY CODART\n"
             << "FROM CODCF=" << codcf << " CODCONT=" << codcon << "\n"
             << "TO CODCF="   << codcf << " CODCONT=" << codcon << "\n";

      TISAM_recordset righe(query2);

      for(bool ok2 = righe.move_first(); ok2; ok2 = righe.move_next())
      {
        TString80 codart = righe.get(LVRCONDV_CODART).as_string();  codart.cut(7);
        
        TToken_string key;
        key.add(codcf);
        key.add(codart);

        if(!presenti.is_key(key))
        {
          presenti.add(key, key);        
          recset->aggiungi_riga(codcf, codart);
        }
      }      
    }
    recset->save_as(file);
    message_box(TR("Esportazione terminata"));
  }
  else
    warning_box(TR("Non ci sono contratti in essere rispetto alla data specificata"));
}


//ON_FIELD_EVENT: metodo che gestisce gli eventi sui campi della maschera
bool TInvcon_msk::on_field_event(TOperable_field& f, TField_event e, long jolly)
{
  switch (f.dlg())
  {
  case DLG_ELABORA:
    //alla pressione del bottone elabora eseguo il metodo elabora
    if(e == fe_button)    
      esporta();
    break;  
  default: break;
  }
  return true;
}

//metodo costruttore che precarica i campi di interesse sulla maschera
TInvcon_msk::TInvcon_msk():TAutomask("lv3600a") {}

                                 ///////////////////////////
                                 ////    TINVCON_APP    ////
                                 ///////////////////////////

//classe TInvcon_app
class TInvcon_app : public TSkeleton_application
{
  TInvcon_msk* _msk;
protected:
  virtual bool create();
  virtual bool destroy();

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

//CREATE: metodo costruttore
bool TInvcon_app::create()
{
  _msk = new TInvcon_msk; 
  return TSkeleton_application::create();
}

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

//TRANSFER: metodo principale dell'elaborazione, che non deve fare niente
//perchè viene tutto gestito nella maschera
bool TInvcon_app::transfer()
{   
  return true;
}

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

int lv3600(int argc, char *argv[])
{
  TInvcon_app a;
  a.run (argc, argv, "Invio a contapezzi");
  return TRUE;
}