campo-sirio/ve/ve2700.cpp

#include <applicat.h>
#include <automask.h>
#include <config.h>
#include <recarray.h>
#include <recset.h>
#include <relapp.h>
#include <tabutil.h>

#include "condv.h"
#include "rcondv.h"

#include "ve2.h"
#include "ve2700.h"

///////////////////////////////////////////////////////////////////////////////
//  MASCHERA DI EDIT (aggiorna i listini figghi 'u patre!)
///////////////////////////////////////////////////////////////////////////////
class TAggiorna_listini_edit_mask : public TAutomask
{
  TMask* _query_mask; //puntatore alla maschera di query

protected:
  void fill_children_list();
  void fill_ricarichi_children_list();
  void save_children_list();
  void fill_aggiorna_sheet();
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  TAggiorna_listini_edit_mask(TMask* query_mask);
};


//metodo per riempire lo sheet dei listini figli con i ricarichi oggi tanto di moda 
void TAggiorna_listini_edit_mask::fill_ricarichi_children_list()
{
  TString8 grmerc;
  grmerc.format("%-3s%-2s", (const char*)get(F_GRMERC),(const char*)get(F_SOTGRMERC));
  const TRectype& rec_gmc = cache().get("GMC", grmerc);
  TToken_string lista_listini(rec_gmc.get("S1"), ';');
  //se trova qualcosa nella lista listini collegati al grmerc...
  if (lista_listini.full())
  {
    lista_listini.trim();
    //se la lista di listini riempie il campo S1, magari continua in S2...
    if (lista_listini.len() == 70)
    {
      lista_listini.add(rec_gmc.get("S2"));
      lista_listini.trim();
    }
    //cerca se i listini trovati in GMC ci sono anche nello sheet dei figli
    TSheet_field& sf_righe = sfield(F_LISTINI_FIGLI);
    const int righe_sheet = sf_righe.items();

    FOR_EACH_STR_TOKEN(lista_listini, str)
    {
      //controlla se il listino in grmerc (chiave) esiste in una delle righe dello sheet dei figli
      TToken_string chiave(str, SAFE_PIPE_CHR);
      TString4 catven = chiave.get(0);
      catven.trim();
      TString4 codlis = chiave.get(1);
      codlis.trim();

      FOR_EACH_SHEET_ROW(sf_righe, i, row)
      {
        TString4 sh_catven = row->get(0);
        sh_catven.trim();
        TString4 sh_codlis = row->get(1);
        sh_codlis.trim();
        //se incredibilmente trova il listino di grmerc tra i figli prigionieri nello sheet setta il ricarico
        if (catven == sh_catven && codlis == sh_codlis)
          row->add(chiave.get(2), 2);
      } //FOR_EACH_SHEETT_ROW(...

    } //FOR_EACH_STR_TOKEN
    sf_righe.force_update();
  } //if(lista_listini.full...
}


//metodo per il salvataggio dei ricarichi sulla tabella GMC dei gruppi merceologici
void TAggiorna_listini_edit_mask::save_children_list()
{
  TString8 grmerc;
  grmerc.format("%-3s%-2s", (const char*)get(F_GRMERC),(const char*)get(F_SOTGRMERC));
  if (grmerc.full())
  {
    //cerca sulla tabella GMC il record corrispondente all'attuale GMC
    TTable tab_gmc("GMC");
    tab_gmc.put("CODTAB", grmerc);
    int err = tab_gmc.read();
    if (err == NOERR)
    {
      //prende S1 e, se pieno, anche S2
      TToken_string stringona(140, ';');
      TString s = tab_gmc.get("S1");
      if (s.full())
      {
        stringona.add(s);
        s = tab_gmc.get("S2");
        if (s.full())
          stringona.add(s);
      }
      //mette tutte le token_stringhine catven|codlis|ricarico in uno string_array, in modo da tener traccia..
      //..della loro posizione (ogni elemento dello string_array <20> una token_stringhina)
      TString_array ricarichi;
      FOR_EACH_STR_TOKEN(stringona, str)
        ricarichi.add(str);
      
      //giro su tutti gli elementi dell'array
      FOR_EACH_ARRAY_ROW(ricarichi, i, row)
      {
        TToken_string chiave(*row, SAFE_PIPE_CHR);  //separatore broken_pipe
        TString4 catven = chiave.get(0);
        catven.trim();
        TString4 codlis = chiave.get(1);
        codlis.trim();

        //giro sulle righe dello sheet listini figli
        TSheet_field& sf_righe = sfield(F_LISTINI_FIGLI);
        FOR_EACH_SHEET_ROW_BACK(sf_righe, r, riga)
        {
          TString4 sh_catven = riga->get(0);
          sh_catven.trim();
          TString4 sh_codlis = riga->get(1);
          sh_codlis.trim();
          //se incredibilmente trova il listino dell'array tra i figli prigionieri nello sheet..
          if (catven == sh_catven && codlis == sh_codlis)
          {
            const TString& ricarico = riga->get(2);
            chiave.add(ricarico, 2);  //setta il ricarico nella cella dello sheet
            ricarichi.add(chiave, i); //lo aggiunge all'array dei ricarichi
            break;                    //esce perch<63> non pu<70> fare altro
          }
        } //FOR_EACH_SHEET_ROW_BACK...
      } //FOR_EACH_ARRAY_ROW

      //adesso deve tornare a scrivere le nuove S1 ed S2 modificate
      TToken_string s1(70, ';'), s2(70, ';');
      FOR_EACH_ARRAY_ROW (ricarichi, r, riga)
      {
        TToken_string mini_string(*riga, SAFE_PIPE_CHR);   //separatore broken_pipe !!!
        if (s1.len() + mini_string.len() < 70)
          s1.add(mini_string);
        else
        {
          if (s2.len() + mini_string.len() < 70)
            s2.add(mini_string);
        }
      } //FOR_EACH_ARRAY_ROW..

      //finalmente scrive sulla tabella GMC
      tab_gmc.put("S1", s1);
      tab_gmc.put("S2", s2);
      tab_gmc.rewrite();

    } //if(err==NOERR)
  } //if(grmerc.full())
}


bool TAggiorna_listini_edit_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch(o.dlg())
  {
  case F_GRMERC:
  case F_SOTGRMERC:
    //una volta selezionati grmerc/sotgrmerc riempie la colonna ricarico dello sheet
    if (e == fe_modify)
    {
      fill_ricarichi_children_list();
    }
    break;

    //applica i cambiamenti dovuti ai ricarichi e salva questi ultimi in gmc
  case DLG_APPLICA:
    if (e == fe_button)
    {
      save_children_list();
    }
    break;
  default:
    break;
  }
  return true;
}

//metodo per aggiungere i figli allo sheet dei medesimi
void TAggiorna_listini_edit_mask::fill_children_list()
{
  //disabilita se necessario la colonna della categoria di vendita (lo sheet serve comunque dopo!)
  TSheet_field& sf_righe = sfield(F_LISTINI_FIGLI);
  sf_righe.destroy();
  sf_righe.enable_column(F_CATVEN, ini_get_bool(CONFIG_DITTA, "ve", "GESLISCV"));

  //aggiorna sheet con i listini figli
  TString query;
  query << "USE CONDV\n";
  query << "SELECT (FATHCATVEN=#FATHCATVEN)&&(FATHCOD=#FATHCOD)\n";
  query << "FROM TIPO=L\n";
  query << "TO TIPO=L\n";
  TISAM_recordset recset_figli(query);
  recset_figli.set_var("#FATHCATVEN", get(F_FATHCATVEN));
  recset_figli.set_var("#FATHCOD", get(F_FATHCODLIS));
  const int recset_figli_items = recset_figli.items();

  const TRectype& rec = recset_figli.cursor()->curr();

  //per ogni riga del recordset va ad aggiornare lo sheet sulla maschera (aggiunge la riga)
  for (bool ok = recset_figli.move_first(); ok; ok = recset_figli.move_next())
  {
    TToken_string& row = sf_righe.row(-1);          //riga sheet da riempire

    const TString& catven = rec.get(CONDV_CATVEN);
    const TString& codlis = rec.get(CONDV_COD);
    const TString& deslis = rec.get(CONDV_DESCR);
    row.add(catven);
    row.add(codlis);
    row.add("");
    row.add(deslis);

    sf_righe.check_row(sf_righe.items()-1, 3);
  }
  sf_righe.force_update();
}

//metodo per riempire lo sheet con i dati da aggiornare
void TAggiorna_listini_edit_mask::fill_aggiorna_sheet()
{
  //rinomina le colonne dello sheet di aggiornamento come il listino che rappresentano (fighissimo!)..
  //..secondo la solita catven+codlis; fa sparire le colonne che non servono. Ricordiamo infatti che..
  //...si posson avere al massimo 10 figli (controllo demografico sui listini)
  TSheet_field& sf_multilistini = sfield(F_MULTILISTINI);

  TSheet_field& sf_figli = sfield(F_LISTINI_FIGLI);
  TString column_header;
  int num_of_columns = 2;
  FOR_EACH_SHEET_ROW(sf_figli, r, riga)
  {
    column_header.cut(0);
    column_header << riga->get(0) << " ";
    column_header.trim();
    column_header << riga->get(1);

    sf_multilistini.set_column_header(r + 2, column_header);
    num_of_columns ++;
  }
  //cancella i figli in eccesso
  for( ;sf_multilistini.exist_column(num_of_columns); num_of_columns++)
    sf_multilistini.delete_column(num_of_columns);

  //popola il double-deck sheet
}


TAggiorna_listini_edit_mask::TAggiorna_listini_edit_mask(TMask* query_mask)
                           : TAutomask("ve2700b"), _query_mask(query_mask)
{
  //aggiorna campi listino padre
  set(F_FATHCATVEN, _query_mask->get(F_FATHCATVEN));
  set(F_FATHDESVEN, _query_mask->get(F_FATHDESVEN));
  set(F_FATHCODLIS, _query_mask->get(F_FATHCODLIS));
  set(F_FATHDESLIS, _query_mask->get(F_FATHDESLIS));

  //popola lo sheet dei listini figli
  fill_children_list();
  //e poi riempie lo sheet di aggiornamento dei figli
  fill_aggiorna_sheet();
}



///////////////////////////////////////////////////////////////////////////////
//  MASCHERA DI QUERY (seleziona il listino padre tra i listini con paternit<69>)
///////////////////////////////////////////////////////////////////////////////
class TAggiorna_listini_query_mask : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  TAggiorna_listini_query_mask();
};

bool TAggiorna_listini_query_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch(o.dlg())
  {
  case F_FATHCODLIS:
    if (e == fe_button)
    {
      TString query;
      query << "USE CONDV\n";
      query << "SELECT (FATHCOD!='')&&(BETWEEN(FATHCATVEN,#CATVEN,#CATVEN))\n";
      query << "FROM TIPO=L\n";
      query << "TO TIPO=L\n";
      //ottiene tutti i listini che hanno un padre
      TISAM_recordset listini_figli(query);
      listini_figli.set_var("#CATVEN", get(F_FATHCATVEN));
      const int listini_figli_items = listini_figli.items();
      //adesso deve crearsi la lista dei padri
      TAssoc_array listini_padri;
      for (bool ok = listini_figli.move_first(); ok; ok = listini_figli.move_next())
      {
        //quale <20> il padre del figlio?
        TToken_string key;
        key.add(listini_figli.get(CONDV_FATHCATVEN).as_string(), 0);
        key.add(listini_figli.get(CONDV_FATHCOD).as_string(), 1);
        //se non esiste gi<67> nella lista dei padri deve essere aggiunto!
        if (!listini_padri.is_key(key))
        {
          //necessita della descrizione del padre
          TToken_string chiave;
          chiave.add("L");
          chiave.add(key.get(0));
          chiave.add("");
          chiave.add("");
          chiave.add(key.get(1));
          const TString& descr_padre = cache().get(LF_CONDV, chiave, CONDV_DESCR);
          listini_padri.add(key, descr_padre);
        }
      } //for(bool ok =...
      //utilizzando l'assoc_array dei padri propone uno sheet di ricerca dei soli listini che hanno paternit<69>
      //maschera volante di ricerca (<28> una display)
      TArray_sheet sheet(-1, -1, 78, 10, TR("Listini padri"), HR("Cat.Ven.|Codice|Descrizione@50"));
      //riempimento dello sheet
      FOR_EACH_ASSOC_STRING(listini_padri, obj, key, descr)
      {
        TToken_string row;
        row = key;
        row.add(descr);
        sheet.add(row);
      }
      sheet.rows_array().sort();  //riordina le righe attualmente scombinate
      
      if (sheet.run() == K_ENTER)
      {
        //riempie la maschera di query 
        TToken_string& row = sheet.row(-1);
        set(F_FATHCATVEN, row.get(0), true);
        set(F_FATHCODLIS, row.get(1));
        set(F_FATHDESLIS, row.get(2));

        //lancia la maschera di edit
        TAggiorna_listini_edit_mask edit_mask(this);  //gli passa la maschera principale
        edit_mask.run();
      }
    }
    break;
  default:
    break;
  }
  return true;
}

TAggiorna_listini_query_mask::TAggiorna_listini_query_mask() : TAutomask("ve2700a") 
{
  //in base alla cervellotica configurazione impostata dall'utonto abilita/disabilita campi
  const bool gesliscv = ini_get_bool(CONFIG_DITTA, "ve", "GESLISCV");
  enable(F_FATHCATVEN, gesliscv);
  enable(F_FATHDESVEN, gesliscv);
  //attenzione!!! il campo CATVEN <20> in chiave 1! per disabilitarlo ci vuole questo trucco!
  if (!gesliscv)
    efield(F_FATHCATVEN).reset_key(1);
}

////////////////////////////////////////////////////////
//	APPLICAZIONE
////////////////////////////////////////////////////////
class TAggiorna_listini : public TSkeleton_application
{
public:
  virtual void main_loop();
};


void TAggiorna_listini::main_loop()
{
  TAggiorna_listini_query_mask mask;
  while (mask.run() == K_ENTER)
  {
  }
}


int ve2700(int argc, char* argv[])
{
  TAggiorna_listini a;
  a.run(argc, argv, TR("Aggiornamneto listini multiplo"));
  return 0;
}