root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/m770/generic.cpp
nik a1095f6e04 Cazzo, cazzeggio e controcazzeggio! 
Prime modifiche per utilizzare le nuove maschere (upgrade R9604/R9605)


git-svn-id: svn://10.65.10.50/trunk@3889 c028cbd2-c16b-5b4b-a496-9718f37d4682
1996-11-12 09:52:22 +00:00

782 lines
21 KiB
C++
Executable File
Raw Blame History

// 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 <progind.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
HIDDEN const char* QUALIFICA_EREDE = "11";
void socbbis_setta_ditta(TMask& m);
long ADCalcolaItems(const int lffile, const long codditta, const long coddip);
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);
void ADCancellaQuadri(const long codditta,const long coddip);
// static bool eredi_handler (TMask_field& m, KEY k);
static bool date_handler (TMask_field& m, KEY k);
long _codditta;
long _lCodDipDec;
long _lCodDip;
TString16 _sQualificaPrec; // qualifica prima di andare in edit
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_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);
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;
}
// Costruisce un cursore solo per sapere gli items per la progind
long ADCalcolaItems(const int lffile, const long codditta, const long coddip)
{
long items=0L;
TRelation* rel = new TRelation(lffile);
TString filtro;
filtro.format("CODDITTA=%ld && CODDIP=%ld", codditta,coddip);
TCursor* cur = new TCursor(rel,filtro,1);
(*cur) = 0L;
items = cur->items();
delete cur;
delete rel;
return items;
}
void TGenericRel_application::ADCancellaQuadri(const long codditta,const long coddip)
{
bool bRimossoA,bRimossoA1,bRimossoA2,bRimossoA3,bRimossoB,bRimossoB1;
bRimossoA=bRimossoA1=bRimossoA2=bRimossoA3=bRimossoB=bRimossoB1=FALSE;
long items = ADCalcolaItems(LF_QUAA, codditta, coddip);
TProgind progA(items,"Cancellazione quadro A", FALSE,TRUE);
// Cancella quadro A
TLocalisamfile qa(LF_QUAA);
qa.zero();
qa.put("CODDITTA", (long) codditta);
qa.put("CODDIP", (long) coddip);
TRectype dep(qa.curr());
for (qa.read(_isgteq, _lock); !qa.eof(); qa.next(_lock))
{
progA.addstatus(1);
if (qa.curr() > dep)
{
qa.reread(_unlock);
break;
}
const long lDit = qa.get_long("CODDITTA");
const long lDip = qa.get_long("CODDIP");
if (lDit == codditta && lDip == coddip)
{
bRimossoA = TRUE;
qa.remove();
}
}
// Cancella quadro A1
items = ADCalcolaItems(LF_QUAA1, codditta, coddip);
TProgind progA1(items,"Cancellazione quadro A-1", FALSE,TRUE);
TLocalisamfile qa1(LF_QUAA1);
qa1.zero();
qa1.put("CODDITTA", (long) codditta);
qa1.put("CODDIP", (long) coddip);
TRectype dep1(qa1.curr());
for (qa1.read(_isgteq, _lock); !qa1.eof(); qa1.next(_lock))
{
progA1.addstatus(1);
if (qa1.curr() > dep1)
{
qa1.reread(_unlock);
break;
}
const long lDit = qa1.get_long("CODDITTA");
const long lDip = qa1.get_long("CODDIP");
if (lDit == codditta && lDip == coddip)
{
bRimossoA1 = TRUE;
qa1.remove();
}
}
// Cancella quadro A2
items = ADCalcolaItems(LF_QUAA2, codditta, coddip);
TProgind progA2(items,"Cancellazione quadro A-2", FALSE,TRUE);
TLocalisamfile qa2(LF_QUAA2);
qa2.zero();
qa2.put("CODDITTA", (long) codditta);
qa2.put("CODDIP", (long) coddip);
TRectype dep2(qa2.curr());
for (qa2.read(_isgteq, _lock); !qa2.eof(); qa2.next(_lock))
{
progA2.addstatus(1);
if (qa2.curr() > dep2)
{
qa2.reread(_unlock);
break;
}
const long lDit = qa2.get_long("CODDITTA");
const long lDip = qa2.get_long("CODDIP");
if (lDit == codditta && lDip == coddip)
{
bRimossoA2 = TRUE;
qa2.remove();
}
}
// Cancella quadro A3
items = ADCalcolaItems(LF_QUAA3, codditta, coddip);
TProgind progA3(items,"Cancellazione quadro A-3", FALSE,TRUE);
TLocalisamfile qa3(LF_QUAA3);
qa3.zero();
qa3.put("CODDITTA", (long) codditta);
qa3.put("NPROG", 1);
qa3.put("CODDIP", (long) coddip);
TRectype dep3(qa3.curr());
for (qa3.read(_isgteq, _lock); !qa3.eof(); qa3.next(_lock))
{
progA3.addstatus(1);
const long lDit = qa3.get_long("CODDITTA");
const long lDip = qa3.get_long("CODDIP");
if (lDit != codditta || lDip != coddip)
{
qa3.reread(_unlock);
continue;
}
if (lDit == codditta && lDip == coddip)
{
bRimossoA3 = TRUE;
qa3.remove();
}
}
// Cancella quadro B
items = ADCalcolaItems(LF_QUAB, codditta, coddip);
TProgind progB(items,"Cancellazione quadro B", FALSE,TRUE);
TLocalisamfile qb(LF_QUAB);
qb.zero();
qb.put("CODDITTA", (long) codditta);
qb.put("CODDIP", (long) coddip);
TRectype dep4(qb.curr());
for (qb.read(_isgteq, _lock); !qb.eof(); qb.next(_lock))
{
progB.addstatus(1);
if (qb.curr() > dep4)
{
qb.reread(_unlock);
break;
}
const long lDit = qb.get_long("CODDITTA");
const long lDip = qb.get_long("CODDIP");
if (lDit == codditta && lDip == coddip)
{
bRimossoB = TRUE;
qb.remove();
}
}
// Cancella quadro B1
items = ADCalcolaItems(LF_QUAB1, codditta, coddip);
TProgind progB1(items,"Cancellazione quadro B-1", FALSE,TRUE);
TLocalisamfile qb1(LF_QUAB1);
qb1.zero();
qb1.put("CODDITTA", (long) codditta);
qb1.put("CODDIP", (long) coddip);
TRectype dep5(qb1.curr());
for (qb1.read(_isgteq, _lock); !qb1.eof(); qb1.next(_lock))
{
progB1.addstatus(1);
if (qb1.curr() > dep5)
{
qb1.reread(_unlock);
break;
}
const long lDit = qb1.get_long("CODDITTA");
const long lDip = qb1.get_long("CODDIP");
if (lDit == codditta && lDip == coddip)
{
bRimossoB1 = TRUE;
qb1.remove();
}
}
if (bRimossoA)
_rip.set("A");
if (bRimossoA1)
_rip.set("A1");
if (bRimossoA2)
_rip.set("A2");
if (bRimossoA3)
_rip.set("A3");
if (bRimossoB)
_rip.set("B");
if (bRimossoB1)
_rip.set("B1");
}
bool TGenericRel_application::remove()
{
_registra = TRUE;
if (Dipendenti())
{
const long codditta = _codditta;
const long coddip = _lCodDip;
// Se era un erede resetta il riferimento al deceduto..
if (_sQualificaPrec != "" && _sQualificaPrec == QUALIFICA_EREDE)
{
if (_lCodDipDec > 0L)
if (!riscrivi_erede(codditta, _lCodDipDec, coddip,0L))
return warning_box("Fallita cancellazione erede");
}
// Se era un deceduto cancella cod.dip.dec. sugli eredi
if (is_deceduto(codditta,coddip))
{
TLocalisamfile dip (LF_DIPEND);
TProgind ProgDip(dip.items(),"Cancellazione codice deceduto ..", FALSE,TRUE);
for (dip.first(); !dip.eof(); dip.next(_lock))
{
ProgDip.addstatus(1);
const long lDipDec = dip.get_long(DIP_CODDIPDEC);
if (lDipDec == coddip)
{
dip.put(DIP_CODDIPDEC, 0L);
dip.rewrite();
}
else
dip.reread(_unlock);
}
}
// Cancella tutti i quadri che facevano riferimento a questo dip.
ADCancellaQuadri(codditta,coddip);
}
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())
{
_lCodDip = m.get_long(ADF_DIP_CODDIP);
_lCodDipDec = m.get_long(ADF_CODDIPDEC);
_sQualificaPrec = m.get(F_DIP_QUALIFICA);
}
}
void TGenericRel_application::init_insert_mode(TMask& m)
{
init_mask(m);
}
void TGenericRel_application::init_query_mode(TMask& m)
{
if (Dipendenti())
{
_lCodDipDec = 0L;
_sQualificaPrec = "";
}
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 == QUALIFICA_EREDE)
m.enable(ADF_CODDIPDEC);
else
{
// Se prima era un erede e ora non lo e' piu' aggiorna il deceduto (brr..)
if (app()._sQualificaPrec != "" &&
app()._sQualificaPrec == QUALIFICA_EREDE)
{
const long codditta = app()._codditta;
const long coddip = m.get_long(ADF_DIP_CODDIP);
const long lDecedutoPrec = m.get_long(ADF_CODDIPDEC);
if (lDecedutoPrec > 0L)
if (!riscrivi_erede(codditta, lDecedutoPrec,coddip,0L))
return warning_box("Fallita cancellazione erede");
}
m.reset(ADF_CODDIPDEC);
m.disable(ADF_CODDIPDEC);
}
}
return TRUE;
}
const char* FALLITO_EREDE_MSG = "Impossibile inserire un nuovo erede. Il numero massimo di eredi e' 10";
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("Impossibile cancellare il codice erede nella scheda del dipendente deceduto");
// Scrive l'erede nel rec.del dec. attuale
if (lDecedutoCorrente != 0L)
if (!scrivi_erede(codditta, lDecedutoCorrente, coddip))
return warning_box(FALLITO_EREDE_MSG);
}
else
if (lDecedutoCorrente != 0L)
{
if (!scrivi_erede(codditta, lDecedutoCorrente, coddip))
return warning_box(FALLITO_EREDE_MSG);
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;
}
Reference in New Issue View Git Blame Copy Permalink