campo-sirio/ve/ve2100.cpp

// Gestione sconti di Riga/Incondizionati/Documenti
#include <relapp.h>
#include <config.h>
#include <tabutil.h>
#include <recarray.h>

#include "ve2100.h"

#define MAX_REAL "9999999999.99999" //mmmhh..


static void key_disable(TMask & m, short id, int key = 1)
{
  ((TEditable_field &)m.field(id)).reset_key(key);
  m.disable(id);
} 

static void key_enable(TMask & m, short id, int key = 1)
{
  ((TEditable_field &)m.field(id)).set_key(key);
  m.enable(id);
} 
struct enable_key_info
{ 
  bool enabled;
  short normal_field,search_field;
};

class TTabelle_sconti: public TRelation_application {
  TMask *_msk; // maschera principale
  TRelation *_rel; // relazione principale

  char _sconti; // carattere che indica il tipo di tabella
  bool _catven; // abilitazione della gestione della categoria di vendita
  bool _scoum;  // abilitazione della gestione delle unita' di misura
  bool _sca;  // abilitazione della gestione degli scaglioni
  enable_key_info _sci_k_id[4]; // struct contenente informazioni sull'abilitazione degli sconti incondizionati
  TString _gessco; // indicatore di abilitazione degli sconti incondizionati
  TString _gesscoriga; // indicatore di abilitazione degli sconti di riga
  
  virtual bool user_create();
  virtual bool user_destroy();                        
  virtual TMask *get_mask(int) { return _msk; }
  virtual bool changing_mask(int) { return FALSE; }
  virtual TRelation *get_relation() const { return _rel; }
  virtual void init_query_mode(TMask& m);
  virtual void init_query_insert_mode(TMask& m);
  virtual bool remove(); // metodo usato per rimuovere il record sul file
  void renumber_sca(const TRectype& r);   //metodo per rinumerare gli scaglioni
  static void fill_rec(TRectype& r, TMask& m);
  static real find_prev_qta(TRectype& r);
  static real find_next_qta(TRectype& r);
  static bool handle_qta(TMask_field &, KEY); // handler della quantita' limite per scaglione
  static bool handle_sca(TMask_field &, KEY); // handler dello scaglione
  // Gli handler seguenti sono necessari solo per controllare l'esistenza effettiva del campo immesso
  // Si dira' perche' non e' stato messo un bel CHECKTYPE FORCED su tali campi?
  // Risposta, perche quando si clicca su nuovo per andare in modo ricerca/inserimento, tutti i campi
  // che hanno CHECKTYPE FORCED risultano non essere validi. Percio' si e' rimesso il CHECKTYPE REQUIRED
  // e si controlla la consistenza del campo.
  static bool handle_um(TMask_field &, KEY);  // handler delle unita' di misura per gli sconti di riga
  static bool handle_art(TMask_field &, KEY); // handler dei codici articoli per sconti di riga
  static bool handle_sco(TMask_field &, KEY); // handler delle sconto cliente
  static bool handle_zon(TMask_field &, KEY); // handler delle zone
  static bool handle_cpg(TMask_field &, KEY); // handler delle condizioni di pagamento

public:
  TTabelle_sconti() {_sca = _scoum = _catven = FALSE;}
  virtual ~TTabelle_sconti() {}
};

inline TTabelle_sconti& app() { return (TTabelle_sconti &) main_app(); }

// Handlers per i campi quantita' limite e scaglione, valgono solo per gli sconti di riga

void TTabelle_sconti::fill_rec(TRectype &r, TMask& m)
{
  TString16 tipo(m.get(F_R_TIPO));
  TString16 codcat(m.get(F_R_CODCAT));
  if (codcat.empty()) codcat = m.get(F_R_RICERCA);
  TString   codart(m.get(F_R_CODART));
  if (codart.empty()) codart = m.get(F_R_RICERCA_A);
  TString16 um(m.get(F_R_UM));
  int sca = m.get_int(F_R_SCA);
  r.zero();
  r.put("TIPO",tipo);r.put("CODCAT",codcat);
  r.put("CODART",codart); r.put("UM",um);r.put("NSCAGL",sca);
}    

real TTabelle_sconti::find_prev_qta(TRectype& r)
{
  TLocalisamfile f(LF_SCONTI);
  real qta = 0.0;
  f.curr() = r;
  int nscagl = r.get_int("NSCAGL");
  f.put("NSCAGL", nscagl-1);
  if (f.read() == NOERR)
    qta = f.get_real("QLIM");
  return qta;
}
       
real TTabelle_sconti::find_next_qta(TRectype& r)
{
  TLocalisamfile f(LF_SCONTI);
  real qta(MAX_REAL);
  f.curr() = r;
  int nscagl = r.get_int("NSCAGL");
  f.put("NSCAGL", nscagl+1);
  if (f.read() == NOERR)
    qta = f.get_real("QLIM");
  return qta;
}

bool TTabelle_sconti::handle_qta(TMask_field &f, KEY k)
{
  if (f.to_check(k))
  {
    TMask& m = f.mask();
    real qta_prev,qta_next;
    real current_qta(f.get());
    TRectype r1(LF_SCONTI);
    fill_rec(r1,m);
    TRectype r2(r1);
    
    qta_prev = find_prev_qta(r1);
    qta_next = find_next_qta(r2);
    int sca = m.get_int(F_R_SCA);
    if (sca == 1 && current_qta == 0.0)
    {
      f.error_box("La quantita' limite deve essere maggiore di 0");
      return FALSE;
    }
    if (sca == 9 && current_qta == 0.0) return TRUE;
    if (qta_next <= current_qta)
    {
      f.error_box("La quantita' limite deve essere minore di %s.", 
                  (const char*)qta_next.string());
      return FALSE;
    }
    if (qta_prev >= current_qta)
    {
      f.error_box("La quantita' limite deve maggiore di %s.", 
                  (const char*)qta_prev.string());
      return FALSE;
    }
  }
  return TRUE;
}
 
bool TTabelle_sconti::handle_sca(TMask_field &f, KEY k)
{
  TMask& m = f.mask();
  if (f.to_check(k))
  {
    int sca = atoi(f.get());
    if (sca == 1) return TRUE;
    
    TRectype r(LF_SCONTI);
    fill_rec(r, m);
    TLocalisamfile sconti(LF_SCONTI);
    
    sconti.curr() = r;
    sconti.read();
    if (sconti.bad()) // se non l'ha trovato significa che e' in inserimento
    {
      sca--;
      r.put("NSCAGL",sca); //cerca quello precedente...
      if (sconti.read(r) != NOERR) // se non lo trova segnala l'errore di errata sequenza
      {
        f.error_box("Il numero di scaglione immesso non e' in sequenza.");
        return FALSE;
      }
    }
  }
  return TRUE;
}

bool TTabelle_sconti::handle_art(TMask_field &f, KEY k)
{
  if (f.to_check(k))
  {
    TLocalisamfile a(LF_ANAMAG);
    TString art(f.get());
    if (art.empty()) return TRUE;
    a.put("CODART",art);
    if (a.read() != NOERR)
    {
      f.error_box("Codice articolo non presente sull'anagrafica");
      return FALSE;
    }
  }
  return TRUE;
}

bool TTabelle_sconti::handle_um(TMask_field &f, KEY k)
{
  if (f.to_check(k))
  {
    TMask& m = f.mask(); 
    TString art(m.get(F_R_CODART));
    TLocalisamfile a(LF_UMART);
    a.setkey(2);
    a.put("UM",f.get());
    a.put("CODART",art);
    if (a.read() != NOERR)
    {
      f.error_box("Unita' di misura non presente per l'articolo indicato");
      return FALSE;
    }
  }
  return TRUE;
}

bool TTabelle_sconti::handle_sco(TMask_field &f, KEY k)
{
  if (f.to_check(k))
  {
    TLocalisamfile a(LF_SCONTI); 
    TString sco(f.get());
    if (sco.empty()) return TRUE;
    a.put("TIPO","D");
    a.put("CODCAT",sco);
    if (a.read() != NOERR)
    {
      f.error_box("Sconto cliente non presente");
      return FALSE;
    }
  }
  return TRUE;
}

bool TTabelle_sconti::handle_zon(TMask_field &f, KEY k)
{
  if (f.to_check(k))
  {
    TTable a("%ZON"); 
    TString zon(f.get());
    if (zon.empty()) return TRUE;
    a.put("CODTAB",zon);
    if (a.read() != NOERR)
    {
      f.error_box("Zona non presente");
      return FALSE;
    }
  }
  return TRUE;
}

bool TTabelle_sconti::handle_cpg(TMask_field &f, KEY k)
{
  if (f.to_check(k))
  {
    TTable a("%CPG");
    TString con(f.get());
    if (con.empty()) return TRUE;
    a.put("CODTAB",con);
    if (a.read() != NOERR)
    {
      f.error_box("Condizione di pagamento non presente");
      return FALSE;
    }
  }
  return TRUE;
}

bool TTabelle_sconti::user_create() {
  bool gotcha= FALSE; // booleano di avvenuta inizializzazione
  int i; // indice di ciclo
    
  _sconti= '*'; // inizializzazione dell'indicatore del tipo di tabella
  if (argc()>2) _sconti= toupper((argv(2))[0]); // se c'<27>, prende il tipo di tabella dalla linea di comando
  else {
    TMask choose("VE2100"); // istanzia la maschera di scelta del tipo di tabella
    if (choose.run() == K_ENTER) _sconti= toupper((choose.get(F_TIPOSC))[0]); // prende il tipo di tabella dalla maschera
  }
  TConfig prassid(CONFIG_DITTA, "ve"); // apre il file di configurazione di ditta
  switch (_sconti) {
    case 'D': // sconti documento
      _msk= new TMask("VE2100D"); // apre la maschera relativa
      set_search_field(F_D_CODCAT); // setta il campo di ricerca
      gotcha= TRUE;
      break;
    case 'R': // sconti di riga
      _gesscoriga = prassid.get("GESSCORIGA");  // legge lo stato del parametro di abilitazione degli sconti riga
      if (_gesscoriga == "A") {
        _msk= new TMask("VE2100R"); // apre la maschera relativa
        set_search_field(F_R_RICERCA); // setta il campo di ricerca
        _catven= prassid.get_bool("GESSCORIGACV"); // legge il parametro di abilitazione delle categorie di vendita
        _scoum = prassid.get_bool("GESSCOUM"); // legge il parametro di abilitazione delle unita' di misura
        _sca = prassid.get_bool("GESSCOSCA"); // legge il parametro di abilitazione degli scaglioni
        if (!_catven)
        {
          key_disable(*_msk, F_R_CODCAT); // se non <20> abilitato, viene disabilitato anche il campo
          set_search_field(F_R_RICERCA_A); // setta il campo di ricerca
        }
        if (!_scoum)
          key_disable(*_msk, F_R_UM); // se non e' abilitato, viene disabilitato anche il campo
        else
          _msk->set_handler(F_R_UM,handle_um);
        if (!_sca)
        {
          key_disable(*_msk, F_R_SCA); // se non e' abilitato, viene disabilitato anche il campo
          _msk->disable(F_R_QLIM); // disabilita pure la qta' limite
        }
        else
        {
          _msk->set_handler(F_R_QLIM, handle_qta); // setta l'handler per controllare la quantita' limite
          _msk->set_handler(F_R_SCA,  handle_sca); // setta l'handler per controllare la sequenza degli scaglioni
        }
        _msk->set_handler(F_R_CODART,handle_art);
        _msk->set_handler(F_R_RICERCA_A,handle_art);
        gotcha= TRUE;
      } else error_box("Gli sconti di riga non sono abilitati nella configurazione");
      break;
    case 'I': // sconti incondizionati
      _gessco= prassid.get("GESSCO"); // legge lo stato del parametro di abilitazione degli sconti
      if (_gessco=="A") {
        _msk= new TMask("VE2100I"); // apre la maschera relativa
        // inizializza l'array dei campi da disabilitare condizionalmente
        _sci_k_id[0].normal_field = F_I_CATVEN;
        _sci_k_id[0].search_field = F_I_RICERCA;
        _sci_k_id[0].enabled = TRUE;
        _sci_k_id[1].normal_field = F_I_SCCLIENTI;
        _sci_k_id[1].search_field = F_I_RICERCA_SC;
        _sci_k_id[1].enabled = TRUE;
        _sci_k_id[2].normal_field = F_I_ZONE;
        _sci_k_id[2].search_field = F_I_RICERCA_ZO;
        _sci_k_id[2].enabled = TRUE;
        _sci_k_id[3].normal_field = F_I_CONDPAG;
        _sci_k_id[3].search_field = F_I_RICERCA_CO;
        _sci_k_id[3].enabled = TRUE;
        _msk->set_handler(F_I_SCCLIENTI,handle_sco);
        _msk->set_handler(F_I_ZONE,handle_zon);
        _msk->set_handler(F_I_CONDPAG,handle_cpg);
        _msk->set_handler(F_I_RICERCA_SC,handle_sco);
        _msk->set_handler(F_I_RICERCA_ZO,handle_zon);
        _msk->set_handler(F_I_RICERCA_CO,handle_cpg);
        for (i=0; i<4; i++) {
          if (!prassid.get_bool("SCOKEY", NULL, i+1)) // se nel file di config. il campo non <20> abilitato...
          {
            key_disable(*_msk, _sci_k_id[i].normal_field); // il campo non <20> abilitato viene disabilitato anche sulla maschera
            key_disable(*_msk, _sci_k_id[i].search_field);
            _sci_k_id[i].enabled = FALSE;
          }
          else gotcha = TRUE;
        }
        if (!gotcha) error_box("Non ci sono campi chiave abilitati nella configurazione della ditta");
        ////
        ////
        //// Necessito della possibilita' di cambiare il filtro alla browse di un TEdit_field!!
        //// Cosi' posso far vedere solo i record editabili.
        ////
      } else error_box("Gli sconti incondizionati non sono abilitati nella configurazione");
      break;
    default: // messaggio di errore se si indica una tabella non valida
      error_box("Indicare la tabella sulla linea di comando (D, R o I) oppure selezionarla dalla maschera di partenza");
      break;
  }
  if (gotcha) _rel= new TRelation(LF_SCONTI); // se <20> stata selezionata una tabella, apre la relazione (un unico file)
  return (gotcha);
}

bool TTabelle_sconti::user_destroy() {
  delete _rel;
  delete _msk;
  return TRUE;
}

void TTabelle_sconti::init_query_mode(TMask& m) {
  int i;
  
  switch (_sconti)
  {
    case 'D':
      set_search_field(F_D_CODCAT); // setta il campo di ricerca
      break;
    case 'I':
      for (i=0; i<4;i++)
        if (_sci_k_id[i].enabled)
        {
          m.show(_sci_k_id[i].search_field);
          m.hide(_sci_k_id[i].normal_field);
          key_enable(m,_sci_k_id[i].search_field);
          key_disable(m,_sci_k_id[i].normal_field);
          set_search_field(_sci_k_id[i].search_field);
          break;
        }
      break;
    case 'R':
      if (_catven)
      {
        m.show(F_R_RICERCA);
        m.hide(F_R_CODCAT);
        set_search_field(F_R_RICERCA); // setta il campo di ricerca
      }
      else
      {
        m.hide(F_R_CODART);
        m.show(F_R_RICERCA_A);
        set_search_field(F_R_RICERCA_A); // setta il campo di ricerca
      }
      break;
    default: break;
  }
}

void TTabelle_sconti::init_query_insert_mode(TMask& m) {
  int i;
  
  switch (_sconti)
  {
    case 'D':
      set_search_field(F_D_CODCAT); // setta il campo di ricerca
      break;
    case 'I':
      for (i=0; i<4;i++)
        if (_sci_k_id[i].enabled)
        {
          m.show(_sci_k_id[i].normal_field);
          m.hide(_sci_k_id[i].search_field);
          key_enable(m,_sci_k_id[i].normal_field);
          key_disable(m,_sci_k_id[i].search_field);
          set_search_field(_sci_k_id[i].normal_field);
          break;
        }
      break;
    case 'R':
      if (_catven)
      {
        m.hide(F_R_RICERCA);
        m.show(F_R_CODCAT);
        set_search_field(F_R_CODCAT); // setta il campo di ricerca
      }
      else
      {            
        m.hide(F_R_RICERCA_A);
        m.show(F_R_CODART);
        set_search_field(F_R_CODART); // setta il campo di ricerca
      }
      break;
    default: break;
  }
}

void TTabelle_sconti::renumber_sca(const TRectype& r)
{
  TRectype from(r);
  from.zero("NSCAGL");  
  TRecord_array rec_arr(from,"NSCAGL");
  if (rec_arr.read(from) == NOERR)
  {
    rec_arr.pack();
    rec_arr.rewrite();
  }
}

bool TTabelle_sconti::remove()
{
  TRectype r(LF_SCONTI);
  fill_rec(r,*_msk);
  const bool rt = TRelation_application::remove();
  if (_sca) // rinumera gli scaglioni
    renumber_sca(r);
  return rt;
}

int ve2100(int argc, char* argv[]) {
  TTabelle_sconti a;
  
  a.run(argc, argv, "Tabella sconti ");
  return 0;
}