campo-sirio/pr/pr0600.cpp

// Programma di gestione percentuali di provvigione

#include <relapp.h>
#include <tabutil.h>

#include "percprov.h"
#include "pr0600a.h"
#include "pr0.h"

typedef short order[4];

class TGestione_percprovv_app:public TRelation_application
{
  TMask      *_msk;
  TRelation  *_rel;
  order      _ordinamento;
  
protected:
  virtual bool user_create();
  virtual bool user_destroy();
  virtual TMask* get_mask(int mode)       {return _msk;}
  virtual bool changing_mask(int mode)    {return FALSE;}
  virtual TRelation* get_relation() const {return _rel;}
  virtual void init_query_mode(TMask& m); 
  virtual void init_query_insert_mode(TMask& m); 
  static bool codpr_handler(TMask_field& f, KEY k);
  static bool complete_key_handler(TMask_field& f, KEY k);
  static bool output_key_handler(TMask_field& f, KEY k);
  static bool tipo_handler(TMask_field& f, KEY k);
  static void set_order_fields(TString16& ord, TMask& m);
public:
  TGestione_percprovv_app()   {};
  ~TGestione_percprovv_app()  {};
};


static inline TGestione_percprovv_app& app() { return (TGestione_percprovv_app&) main_app(); }

bool TGestione_percprovv_app::output_key_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB) // Viene passato solo quando entra in modifica, visto che e' disabled
  {
    order&  kd = app()._ordinamento;
    TMask&  m = f.mask();
    TString codpr = m.get(F_CODPR_QUERY);
    TString key   = f.get();
    TString16 ord;
    int from = 0;
    TTable apr("APR");

    apr.put("CODTAB",codpr);
    if (apr.read() == NOERR)
      ord = apr.get("S3");
    set_order_fields(ord,m);
    for (int i = 0; i < 4; i++)
    {
      if (kd[i] == 0)
        break;
      TMask_field& fld = m.field(kd[i]);
      const word size  = fld.size();
      fld.set(key.mid(from,size));
      from += size;
    }
    ((TEditable_field&)f).test_key_complete(FALSE);
  }
  return TRUE;
}

bool TGestione_percprovv_app::tipo_handler(TMask_field& f, KEY k)
{
  if (f.to_check(k))
  {
    const char v = f.get()[0];
    if (v == 'I' || v == 'V')
    {
      order& kd = app()._ordinamento;
      bool found = FALSE;
      for (int i = 0; i < 4 && !found; i++)
        if (kd[i] == F_CODART)
          found = TRUE;
      if (!found)
        return f.error_box("Impossibile settare il tipo di provvigione ad importo unitario o valore se non "
                           "e' presente la ricerca per codice articolo.");
    }
  }
  return TRUE;
}

bool TGestione_percprovv_app::complete_key_handler(TMask_field& f, KEY k)
{
  if (f.to_check(k))
  {
    TMask& m = f.mask();
    TString v,k,fmt;
    order& kd = app()._ordinamento;
    for (int i = 0; i < 4; i++)
    { 
      if (kd[i] == 0)
        break;
      TMask_field& f = m.field(kd[i]);
      if (kd[i] != F_CLIENTE)
        fmt.format("%%-%us",f.size());
      else
        fmt.format("%%%us",f.size());
      v.format(fmt,(const char*)f.get());
      k << v;
    }
    m.set(F_KEYORD,k);
  }
  return TRUE;
}

void TGestione_percprovv_app::set_order_fields(TString16& ord, TMask& m)
{
  order& kd = app()._ordinamento;

  m.hide(-G_CAMPICHIAVE);
  for (int i = 0; i < 4; i++)
    switch (ord[i])
    {
      case 'C':
        m.show(-G_CLI);
        m.field(F_CLIENTE).check_type(CHECK_REQUIRED);
        kd[i] = F_CLIENTE;
        break;
      case 'V':
        m.show(-G_CATV);
        m.field(F_CATVEN).check_type(CHECK_REQUIRED);
        kd[i] = F_CATVEN;
        break;
      case 'A':
        m.show(-G_AGE);
        m.field(F_CODAGE).check_type(CHECK_REQUIRED);
        kd[i] = F_CODAGE;
        break;
      case 'P':
        m.show(-G_PAG);
        m.field(F_CODPAG).check_type(CHECK_REQUIRED);
        kd[i] = F_CODPAG;
        break;
      case 'S':
        m.show(-G_SCONTO);
        m.field(F_CODSCONTO).check_type(CHECK_REQUIRED);
        kd[i] = F_CODSCONTO;
        break;
      case 'Z':
        m.show(-G_ZONA);
        m.field(F_CODZONA).check_type(CHECK_REQUIRED);
        kd[i] = F_CODZONA;
        break;
      case 'M':
        m.show(-G_ART);
        m.field(F_CODART).check_type(CHECK_REQUIRED);
        kd[i] = F_CODART;
        break;
      case 'E':
        m.show(-G_GMC);
        m.field(F_CODGMC).check_type(CHECK_REQUIRED);
        kd[i] = F_CODGMC;
        break;
      case 'R':
        m.show(-G_SMC);
        m.field(F_CODSMC).check_type(CHECK_REQUIRED);
        kd[i] = F_CODSMC;
        break;
      case 'F':
        m.show(-G_RFA);
        m.field(F_CODRFA).check_type(CHECK_REQUIRED);
        kd[i] = F_CODRFA;
        break;
      default:
        kd[i] = 0;
        break;
    }      
}

bool TGestione_percprovv_app::codpr_handler(TMask_field& f, KEY k)
{
  if (f.to_check(k))
  {
    TTable apr("APR");
    TString s(f.get());
    apr.put("CODTAB",s);
    if (apr.read() == NOERR)
    { 
      TString16 ord;
      TMask& m = f.mask();

      ord = apr.get("S3");
      m.set(F_DESCR,apr.get("S0"));
      m.show(F_TIPO);
      m.show(F_PERCPROVV);
      set_order_fields(ord,m);
    }
    else
      return f.error_box("Codice archivio non presente");
  }
  return TRUE;
}

void TGestione_percprovv_app::init_query_mode(TMask& m)
{
  m.hide(F_CODPR_NEW);
  m.show(F_CODPR_QUERY);
  set_search_field(F_CODPR_QUERY);
  m.hide(-G_CAMPICHIAVE);
  for (short i = F_CLIENTE; i<=F_CODRFA; i+=2)
    m.field(i).check_type(CHECK_NONE); // Il flag di forced rimane  a TRUE
}

void TGestione_percprovv_app::init_query_insert_mode(TMask& m)
{
  m.hide(F_CODPR_QUERY);
  m.show(F_CODPR_NEW);
  set_search_field(F_CODPR_NEW);
  m.hide(-G_CAMPICHIAVE);
  for (short i = F_CLIENTE; i<=F_CODRFA; i+=2)
    m.field(i).check_type(CHECK_NONE); // Il flag di forced rimane  a TRUE
}

bool TGestione_percprovv_app::user_create()
{
  _msk = new TMask("pr0600a") ;
  _msk->set_handler(F_CODPR_QUERY,codpr_handler);
  _msk->set_handler(F_CODPR_NEW,codpr_handler);
  _msk->set_handler(F_CLIENTE,complete_key_handler);
  _msk->set_handler(F_CATVEN,complete_key_handler);
  _msk->set_handler(F_CODAGE,complete_key_handler);
  _msk->set_handler(F_CODPAG,complete_key_handler);
  _msk->set_handler(F_CODSCONTO,complete_key_handler);
  _msk->set_handler(F_CODZONA,complete_key_handler);
  _msk->set_handler(F_CODART,complete_key_handler);
  _msk->set_handler(F_CODGMC,complete_key_handler);
  _msk->set_handler(F_CODSMC,complete_key_handler);
  _msk->set_handler(F_CODRFA,complete_key_handler);
  _msk->set_handler(F_KEYORD,output_key_handler);
  _msk->set_handler(F_TIPO,tipo_handler);
  _rel = new TRelation(LF_PERCPROV);
  return TRUE;
}

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

int pr0600(int argc, char** argv)
{
  TGestione_percprovv_app  a;
  a.run(argc,argv,"Gestione percentuali provvigione");
  return 0;
}