campo-sirio/m770/generic.cpp

// generic - relapp generica adattata per il 770 
//
//  - Applicazioni -
//
//    Anagrafica dipendenti, 
//    Prospetto quadro E1, 
//    Societa' trasformate
//
//  Riempie automaticamente i campi della maschera con id uguali a CODDITTA77 e ANNODIC77
//  con la ditta  e l'anno dichiarazione correnti del 770
//
// Lista modifiche
//
// 10.5.96	Via il flag erede si fa il controllo su CODDIPDEC
//
 
#include <msksheet.h>
#include <relapp.h>
#include <urldefid.h>
#include <tabutil.h>
#include <config.h>

#include "dipend.h"    
#include <nditte.h>
#include "77lib.h"   
#include "pe1.h"  
#include "anadip.h"  
#include "771100.h" 
#include "771200.h"
#include "774200.h"

#define CODDITTA77	181
#define	ANNODIC77	182
                                   
void socbbis_setta_ditta(TMask& m);

class TGenericRel_application : public TRelation_application
{
  private:                                   
    static bool codditta77_handler  (TMask_field& m, KEY k);
    static bool check_handler       (TMask_field& m, KEY k);
    static bool PE1calcrit_handler     (TMask_field& m, KEY k);
    static bool ADabilita_coddipdec (TMask_field& m, KEY k);
    static bool ADCodDipDec (TMask_field& m, KEY k);
    static bool eredi_handler       (TMask_field& m, KEY k);
    static bool date_handler        (TMask_field& m, KEY k);
    long			_codditta;
    long			_lCodDipDec;
    const char*   _maskname;
    int           _num;
    TString16     _quadro;
    TRiporti      _rip;
    TRelation*    _rel;
    TMask*        _msk;
    bool          _alterna_field,_registra;
    int			_anno_dic;
    bool			_MaskConAnnoDic, _MaskConCodditta;
    bool			MaskConAnnoDic() const;
    bool			MaskConCodditta() const { return _MaskConCodditta; }
    void 			LeggiMask();
    bool		Dipendenti() const { return _num == LF_DIPEND; }
  protected:
    virtual bool user_create();
    virtual bool user_destroy();                  
    virtual int  rewrite(const TMask& m);
    virtual int  write  (const TMask& m);  
    virtual bool remove();                     
    virtual void on_config_change();
    virtual TMask* get_mask(int) { return _msk; }
    virtual bool changing_mask(int) { return FALSE;}
    virtual TRelation* get_relation() const { return _rel; }  
    virtual void init_insert_mode(TMask&);
    virtual void init_modify_mode(TMask&);    
    virtual void init_query_mode(TMask&);
    virtual void init_query_insert_mode(TMask&);
    void 			init_mask(TMask&);
    
  public:                                                                     
    bool			_ADCheckFallito;
    TGenericRel_application(const char* name, const int num, const char* quadro);
};

TGenericRel_application& app() { return (TGenericRel_application&)main_app(); }

TGenericRel_application::TGenericRel_application(const char* name, const int num, const char* quadro)
: _maskname(name), _num(num),
  _MaskConCodditta(FALSE), _MaskConAnnoDic(FALSE),
  _msk(NULL), _rel(NULL), _quadro(quadro), _ADCheckFallito(FALSE)
{
}

void TGenericRel_application::LeggiMask()
{
  _MaskConAnnoDic  = _msk->id2pos(ANNODIC77) > 0;
  _MaskConCodditta = _msk->id2pos(CODDITTA77) > 0;
}                  

bool TGenericRel_application::MaskConAnnoDic() const
{
  return  _MaskConAnnoDic;
}

void TGenericRel_application::on_config_change()
{
  if (MaskConAnnoDic())
  {
    TConfig conf(CONFIG_STUDIO);
    _anno_dic = (int)conf.get_long(ANNO_SEL, NULL, -1, TDate(TODAY).year());
  }
}
                                    
bool TGenericRel_application::user_create()
{           
  _alterna_field = FALSE;
  _msk = new TMask(_maskname);
  _rel = new TRelation(_num);

// Determina se la maschera contiene i campi CODDITTA e ANNODIC
  LeggiMask();

  if (MaskConCodditta())    
    _msk->set_handler(CODDITTA77, codditta77_handler);  

  if (_num == LF_PROSPE1)
  {
    _msk->set_handler(PE1F_CODCAUS,  check_handler);
    _msk->set_handler(PE1F_CODCAUS2, check_handler);
    _msk->set_handler(PE1F_IMPONIBILE, PE1calcrit_handler);
  }                                            

  if (Dipendenti())
  { 
//    _msk->set_handler(F_DIP_EREDE,     eredi_handler);
    _msk->set_handler(ADF_CODDIPDEC,    eredi_handler);
    _msk->set_handler(F_DIP_QUALIFICA,  ADabilita_coddipdec);
    _msk->set_handler(ADF_CODDIPDEC,    ADCodDipDec);
    set_search_field(ADF_DIP_CODDIP);
  }  

  if (_num == LF_SOCTRASF)
  {
    char tipo;

    _msk->set_handler(F_SOC_DATAFINPI, date_handler);    
    
    long codditta = get_firm_770();
    
    TLocalisamfile ditta (LF_NDITTE); 
    
    ditta.setkey(1);
    ditta.zero();
    ditta.put(NDT_CODDITTA, codditta);
    if (ditta.read() == NOERR)
      tipo = ditta.get_char(NDT_TIPOA);
      
    if (tipo == 'F')
    {
      _msk->show(-1);
      _msk->hide(-2);
    }                
    else
      if (tipo == 'G')
      {
        _msk->show(-2);
        _msk->hide(-1);
      }
  }
  
  if (_num == LF_BASEBIS)
    _msk->set_handler(F_BSE_DATAFINPI, date_handler);

  for (int i = 0; i < _msk->fields(); i++)
  {
    TMask_field& campo = _msk->fld(i);
    
    if (campo.in_group(8) || campo.in_group(9))
    {
      _alterna_field = TRUE;
      break;
    }
  }                                  
  _registra = FALSE;
  return TRUE;
}

bool TGenericRel_application::user_destroy()
{  
  if (_quadro != "" && _quadro != "0")
    if (_registra)
      _rip.set(_quadro ,0);
  delete _msk;
  delete _rel;
  return TRUE;
}                         

int TGenericRel_application::rewrite(const TMask& m)
{
  m.autosave(_rel);
  const int err = _rel->rewrite();
  _registra = TRUE;
  return err;
}

int TGenericRel_application::write(const TMask& m)
{
  m.autosave(_rel);
  const int err = _rel->write();
  _registra = TRUE;
  return err;
}

bool TGenericRel_application::remove()
{
  _registra = TRUE;
  return TRelation_application::remove();
}

void socbbis_setta_ditta(TMask& m)
{
  TString16 codditta; codditta << get_firm_770();
  if (codditta != "0")        
  {
    m.set(CODDITTA77, codditta);
    m.field(CODDITTA77).check();
  }
}  

void TGenericRel_application::init_mask(TMask& m)
{
  if (MaskConAnnoDic())
    _msk->set(ANNODIC77, _anno_dic); 
}

void TGenericRel_application::init_modify_mode(TMask& m)
{
  init_mask(m);
  if (Dipendenti())
    _lCodDipDec = m.get_long(ADF_CODDIPDEC);
}

void TGenericRel_application::init_insert_mode(TMask& m)
{
  init_mask(m);
}

void TGenericRel_application::init_query_mode(TMask& m)
{                   
  if (_num == LF_SOCTRASF || _num == LF_BASEBIS) 
  {
    socbbis_setta_ditta(m);
    m.send_key(K_AUTO_ENTER,0);
  }

  if (_num == LF_PROSPE1)
  {    
    m.send_key(K_SHIFT+K_CTRL+'h', -9);  // Nasconde ricerca su prospe1
    m.send_key(K_SHIFT+K_CTRL+'s', -8);  // Show ricerca su ca7
  }
}

void TGenericRel_application::init_query_insert_mode(TMask& m)
{
  if (Dipendenti())
    _ADCheckFallito = FALSE;

  if (_num == LF_PROSPE1)
  {    
    m.send_key(K_SHIFT+K_CTRL+'h', -8);  // Nasconde ricerca su ca7
    m.send_key(K_SHIFT+K_CTRL+'s', -9);  // Show ricerca su prospe1
  }
}

bool TGenericRel_application::codditta77_handler(TMask_field& f, KEY k)
{
  app()._codditta = get_firm_770();
  TString16 codditta; codditta << app()._codditta;         
  TMask& m = f.mask();
  if (codditta != "0")        
  {
    m.set(CODDITTA77, codditta);
    m.field(CODDITTA77).check();
  }
  return TRUE;
}

// Handler dell'imponibile   
// Ricalcola ritenuta se:
// 1. cambia imponibile
// 2. la ritenuta e' ZERO
bool TGenericRel_application::PE1calcrit_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB)
  {
    TMask& m = f.mask();
// Leggi i dati..
    const double perc = atof(m.get(PE1F_HPERC));
    const real impo(f.get());
    const real rope_prec(m.get(PE1F_RITENUTA));

// Ricalcola sempre se e' cambiato  
    const bool forza = f.focusdirty();
    
    if (rope_prec != ZERO && !forza)
      return FALSE;
      
    const real rite_calc = (impo * perc) / 100;
    m.set(PE1F_RITENUTA, rite_calc.string());    
  }
  return TRUE;
}

bool TGenericRel_application::check_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB && f.to_check(k) && f.mask().is_running())
  { 
    TTable ca7 ("%CA7");
    
    TString codice = f.get();
    
    ca7.zero();
    ca7.put("CODTAB", codice);
    if (ca7.read() == NOERR)
    {
      int     artbil = ca7.get_int("I3");
      bool    imp    = ca7.get_bool("B0");
      TString codqua = ca7.get     ("S1");
      
      if (artbil == 1015 || codqua != "E1" || imp)
        return f.warning_box("Codice causale non valido per Quadro E1");
    }
    else
      return f.warning_box("Valore non presente in tabella causali");
  }                                        

  return TRUE;  
}                       

// A.Dip. se qualifica=11 (erede) abilita cod.dip.dec.
bool TGenericRel_application::ADabilita_coddipdec(TMask_field& f, KEY k)
{               
  if (k == K_TAB)
  {
    TMask& m = f.mask();
    TString qual(f.get());
    if (qual == "11")
      m.enable(ADF_CODDIPDEC);
    else
      m.disable(ADF_CODDIPDEC);
  }
  return TRUE;
}

bool TGenericRel_application::ADCodDipDec(TMask_field& f, KEY k)
{
  if (k == K_ENTER)
  {
    TMask& m = f.mask();
    TString sCodDec(f.get());
    long lDecedutoCorrente = 0L;
    const long codditta = app()._codditta;
    const long coddip = m.get_long(ADF_DIP_CODDIP);
        
    if (sCodDec.not_empty())
    {
      lDecedutoCorrente = atol((const char*)sCodDec);
      if (!esiste_dipendente(codditta,lDecedutoCorrente))
        return warning_box("Dipendente inesistente");
    }        
    const long lDecedutoOriginario = app()._lCodDipDec;
    const bool bCambiatoDeceduto = //(lDecedutoCorrente != 0L) && 
                                   (lDecedutoOriginario != 0L) &&
                                   (lDecedutoCorrente != lDecedutoOriginario);
    if (bCambiatoDeceduto)
    {
// Cancella l'erede nel rec.del dec. precedente    
      if (!riscrivi_erede(codditta, lDecedutoOriginario,coddip,0L))
        return warning_box("Fallita cancellazione erede");
// Scrive l'erede nel rec.del dec. attuale
      if (lDecedutoCorrente != 0L)
        if (!scrivi_erede(codditta, lDecedutoCorrente, coddip))
          return warning_box("Fallita scrittura codice erede su deceduto");
    }
    else
      if (lDecedutoCorrente != 0L)
      {
        if (!scrivi_erede(codditta, lDecedutoCorrente, coddip))
          return warning_box("Fallita scrittura codice erede su deceduto");
        app()._lCodDipDec = lDecedutoCorrente;
      }
  }
  return TRUE;
}

bool TGenericRel_application::eredi_handler(TMask_field& f, KEY k)
{               
  if (k == K_TAB || k == K_SPACE) 
  {               
    TString depdec(f.get());
    bool erede  = depdec.not_empty();
    
    if (erede)
    {
      f.mask().disable(F_DIP_CODEREDE0);
      f.mask().disable(F_DIP_CODEREDE1);
      f.mask().disable(F_DIP_CODEREDE2);
      f.mask().disable(F_DIP_CODEREDE3);
      f.mask().disable(F_DIP_CODEREDE4);
      f.mask().disable(F_DIP_CODEREDE5);
      f.mask().disable(F_DIP_CODEREDE6);      
      f.mask().disable(F_DIP_CODEREDE7);
      f.mask().disable(F_DIP_CODEREDE8);
      f.mask().disable(F_DIP_CODEREDE9);                                                
    }
    else
    {
      f.mask().enable(F_DIP_CODEREDE0);
      f.mask().enable(F_DIP_CODEREDE1);
      f.mask().enable(F_DIP_CODEREDE2);              
      f.mask().enable(F_DIP_CODEREDE3);
      f.mask().enable(F_DIP_CODEREDE4);
      f.mask().enable(F_DIP_CODEREDE5);
      f.mask().enable(F_DIP_CODEREDE6);
      f.mask().enable(F_DIP_CODEREDE7);
      f.mask().enable(F_DIP_CODEREDE8);
      f.mask().enable(F_DIP_CODEREDE9);                                          
    }
  }
  return TRUE;  
}

bool TGenericRel_application::date_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB)
  {                     
    TDate datainpi;
    
    TMask& m = f.mask();
    
    TFilename name = m.source_file();
    
    if (name == "771200i.msk")
      datainpi = m.get_date(F_BSE_DATAINPI);  
    if (name == "771100h.msk")          
      datainpi = m.get_date(F_SOC_DATAINPI);  
    
    TDate datafinpi (f.get());

    if (datafinpi < datainpi)
      return f.error_box("La data finale non puo' essere inferiore alla data iniziale");
  }
  return TRUE;
}

class TGeneric_application : public TApplication
{
  TFilename _maskname;
  
protected:
  bool create() { dispatch_e_menu(BAR_ITEM(1)); return TRUE; }
  bool destroy() { return TRUE; }
  bool menu(MENU_TAG);

//  static bool codditta77_handler(TMask_field& m, KEY k);
  
public:
  TGeneric_application(const char* name) : _maskname(name) {}
};


bool TGeneric_application::menu(MENU_TAG)
{ 
  KEY k;
  if (_maskname.empty())
  {
    TMask m("Inserire il nome della maschera", 1, 42, 4);
    m.add_string(101, 0, "", 1, 1, 40);
    m.efield(101).check_type(CHECK_REQUIRED);
    m.add_button(DLG_OK, 0, "", -12, -1, 10, 2);
    m.add_button(DLG_CANCEL, 0, "", -22, -1, 10, 2);
    k = m.run();
    if (k == K_ENTER)
      _maskname = m.get(101);
    else
      return FALSE;  
  } 

  TMask m(_maskname);
  
//  if (m.id2pos(F_CODDITTA) > 0)
//    m.set_handler(F_CODDITTA, codditta77_handler);
      
  k = m.run();
  if (k == K_QUIT) stop_run();

  return k != K_QUIT;
}

///////////////////////////////////////////////////////////
// 2 modi :
//  RUN,773,-1,771230m,89,"Prospetto del Quadro E1","E1"    [771230i.uml]
// oppure
//  773 -1 menu_st "Stampe dichiarazioni" [prassi.mnu]
///////////////////////////////////////////////////////////
int generic(int argc, char* argv[])
{
//  TApplication::check_parameters(argc, argv);
  TFilename mask;
  int num = 0;
  if (argc > 1) 
    mask = argv[2];

  if (argc < 6)
  {
    const char* title  = argv[3];              
    TGeneric_application a(mask);
    a.run(argc, argv, title);
  }
  else
  {
    num    = atoi(argv[3]);
    const char* title  = argv[4];             
    const char* quadro = argv[5];
    TGenericRel_application a(mask, num, quadro);
    a.run(argc, argv, title ? title : "Test Relation Application");
  }
  return 0;
}