From 4c0c8a7e32204354082c2a979f5711ba37717738 Mon Sep 17 00:00:00 2001 From: luciano Date: Fri, 21 Mar 1997 17:32:13 +0000 Subject: [PATCH] New entry!! azzeramento archivi con classe e controclasse git-svn-id: svn://10.65.10.50/trunk@4224 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- m770/771200.cpp | 2050 +++++++++++++++++++++++---------------------- m770/774.cpp | 4 +- m770/774.h | 3 +- m770/774.url | 3 + m770/774200.cpp | 6 - m770/774300.cpp | 819 ++++++++++++++++++ m770/774300a.h | 11 + m770/774300a.uml | 82 ++ m770/resetfil.cpp | 176 ++++ m770/resetfil.h | 79 ++ m770/scandich.cpp | 105 +++ m770/scandich.h | 57 ++ 12 files changed, 2364 insertions(+), 1031 deletions(-) create mode 100755 m770/774300.cpp create mode 100755 m770/774300a.h create mode 100755 m770/774300a.uml create mode 100755 m770/resetfil.cpp create mode 100755 m770/resetfil.h create mode 100755 m770/scandich.cpp create mode 100755 m770/scandich.h diff --git a/m770/771200.cpp b/m770/771200.cpp index 1a1c4ce7c..b75e2e56f 100755 --- a/m770/771200.cpp +++ b/m770/771200.cpp @@ -1,1023 +1,1027 @@ -////////////////////////////////////////// -// 771200.cpp - Quadro A 771mod -7 A // -// - Quadro A1 771mod -7 1 // -// - Quadro A2 771mod -7 2 // -// - Quadro A3 771mod -7 3 // -////////////////////////////////////////// -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "77lib.h" -#include "dipend.h" -#include "quadroa.h" -#include "quadroa3.h" -#include "soctrasf.h" -#include "771200.h" -#include "774200.h" -#include "77qaall.h" - -bool QA_cerca_codA(const long codditta, const long coddip, TString& quadro); - -bool QA_cerca_codA(const long codditta, const long coddip, TString& quadro) -{ - TString16 c58(""); - bool Result = FALSE; - TLocalisamfile qq(quadro == "A" ? LF_QUAA : LF_QUAA2); - qq.zero(); - qq.put(QUA_CODDITTA, codditta); - qq.put(QUA_CODIP, coddip); - TRectype dep(qq.curr()); - qq.read(); - TRecnotype lPos = qq.recno(); - for ( ;!qq.eof(); qq.next()) - { - if (qq.curr() > dep) break; - c58 = qq.get(QUA_RETCON); - if (c58 == "A") - { - Result = TRUE; - break; - } - } - qq.readat(lPos); - return Result; -} - -class TQuadroA : public TRelation_application -{ - private: - TString _quadro; // Codice del quadro in gestione - bool _registra; // Se TRUE fa i riporti - TRelation* _rel; - TMask* _msk[2]; - TMask* _mskAllegati; // maschera allegati 730 (A e A2) - long _coddip; - char _tipoq; - int _nproga; - int _mode; - int _anno_dic; // anno dichiarazione - TLocalisamfile* _qd, *_base; - TRiporti _rip; - int _file; - bool _soc_trasf; - TString _cognome,_nome; // dati soc.trasf. - - private: -// Handler relativi ai quadri A - A1 - A2 - A3 - static bool nprog_handler (TMask_field& f, KEY key); - static bool codanagr_handler (TMask_field& f, KEY key); - static bool codditta_hnd (TMask_field& f, KEY key); - static bool setta_nprog (TMask_field& f); - static bool QAA2alleg_handler (TMask_field& f, KEY key); - -// Handler relativi alla manutenzione quadro A - static bool QA_comp_netti_hnd (TMask_field& f, KEY key); - static bool QA_tot_impon_hnd (TMask_field& f, KEY key); - static bool QA_tot_detraz_hnd (TMask_field& f, KEY key); - static bool QA_cfdlprec_hnd (TMask_field& f, KEY key); - static bool QA_chech_ritdatlav (TMask_field& f, KEY key); - static bool QA_calcola42 (TMask_field& f, KEY k); - static bool QA_check_2527 (TMask_field& f, KEY key); - static bool QA_A2_check_58 (TMask_field& f, KEY key); - static bool QA_calcolo30 (TMask_field& f, KEY key); -// Handler relativi alla manutenzione quadro A3 - static bool QA3_codip_handler (TMask_field& f, KEY key); - static bool QA3_base_occupazionale(TMask_field& f, KEY key); - void AA3SettaCognomeNome(TMask& m); - - protected: - TString _sCognome, _sNome; // dati dipendente - int _iNprog; - long _codditta,_codip; - - virtual bool user_create(); - virtual bool user_destroy(); - virtual int rewrite(const TMask& m); - virtual int write (const TMask& m); - virtual bool remove(); - virtual TRelation* get_relation() const { return _rel; } - virtual TMask* get_mask(int mode); - virtual bool changing_mask(int mode); - virtual void init_query_mode (TMask&); - virtual void init_query_insert_mode (TMask&); - virtual void init_modify_mode (TMask&); - virtual void init_insert_mode(TMask& m); - virtual void on_config_change(); - TMask* load_mask(int n); - int anno_dic() const { return _anno_dic; } - bool QuadroA() const { return _quadro == "A"; } - bool QuadroA1() const { return _quadro == "A1"; } - bool QuadroA2() const { return _quadro == "A2"; } - bool QuadroA3() const { return _quadro == "A3"; } - - public: - bool is_societa_trasformata(TMask& m); - void carica_record2_A3(TMask& m); - char tipo_trasformata(long codditta); - void registra_record2_A3(const TMask& m); - void cancella_record2_A3(); - - TQuadroA(char tipo); - virtual ~TQuadroA() {}; -}; - -// Implementazione classe TQuadroA - -inline TQuadroA& app() { return (TQuadroA&) main_app(); } - -TQuadroA::TQuadroA(char tipo): _rel(NULL), _mode(0), _tipoq(tipo) -{ - memset(_msk, 0, sizeof(_msk)); -} - -bool TQuadroA::changing_mask(int mode) -{ - if ((mode == MODE_MOD) && (_mode == MODE_INS)) - return FALSE; - else - return _mode != mode; -} - -TMask* TQuadroA::get_mask(int mode) -{ - const int m = (mode == MODE_QUERY) ? 0 : 1; - _mode = mode; - return load_mask(m); -} - -TMask* TQuadroA::load_mask(int n) -{ - if (_msk[n] != NULL) - return _msk[n]; - - TFilename name("771200"); - - if (n == 0) - { - switch (_tipoq) - { - case 'A': // Manutenzione quadro A - name << 'a'; - break; - case '1': // Manutenzione quadro A1 - name << 'c'; - break; - case '2': // Manutenzione quadro A2 - name << 'e'; - break; - case '3': // Manutenzione quadro A3 - name << 'g'; - break; - default: - break; - } - } - else - { - switch (_tipoq) - { - case 'A': // Manutenzione quadro A - name << 'b'; - break; - case '1': // Manutenzione quadro A1 - name << 'd'; - break; - case '2': // Manutenzione quadro A2 - name << 'f'; - break; - case '3': // Manutenzione quadro A3 - name << 'h'; - break; - default: - break; - } - } - - TMask* m = new TMask(name); - - switch (n) - { - case 0: - if (m) - { - m->set_handler(QAF_CODDITTA, codditta_hnd); - if (QuadroA3()) - { - m->set_handler(F_CODANAGDIP, QA3_codip_handler); - m->set_handler(F_CODIPQUADRO, QA3_codip_handler); - m->set_handler(F_BASEOCCUPA, QA3_base_occupazionale); - } - else - { - if (QuadroA()) - m->set_handler(QAF_ALLEG_A, QAA2alleg_handler); - if (QuadroA2()) - m->set_handler(QA2F_ALLEG_A2, QAA2alleg_handler); - m->set_handler(QAF_NPROG, nprog_handler); - m->set_handler(F_CODANAGDIP, codanagr_handler); - m->set_handler(F_CODANAGDIPQA, codanagr_handler); - } - } - break; - case 1: - m->disable(DLG_FINDREC); - if (m) - { - if (QuadroA2()) - m->set_handler(QA2F_RETCON, QA_A2_check_58); - - if (QuadroA()) - { -// Calcola i compensi netti (c.23) e controllo c25-27 - m->set_handler(F_CODFISDL, QA_cfdlprec_hnd); - m->set_handler(F_DENARO, QA_comp_netti_hnd); - m->set_handler(F_NATURA, QA_comp_netti_hnd); - m->set_handler(F_COBBDIP21, QA_comp_netti_hnd); -// Se immette un B controlla che ci sia almeno un rec con A - m->set_handler(F_RETCON56, QA_A2_check_58); -// Se 27=0 => 25 deve = 0 - m->set_handler(F_IACOBBCD25, QA_check_2527); -// Calcola il totale imponibile (c.27) - m->set_handler(F_AMMLORDO24, QA_tot_impon_hnd); - m->set_handler(QAF_SVNSOGRIT, QA_tot_impon_hnd); - m->set_handler(F_DETCC, QA_tot_detraz_hnd); - m->set_handler(F_DETFC, QA_tot_detraz_hnd); - m->set_handler(F_DETAF, QA_tot_detraz_hnd); - m->set_handler(F_DETLD, QA_tot_detraz_hnd); - m->set_handler(F_DETO, QA_tot_detraz_hnd); -// Controlla che 40 sia <= 30 - m->set_handler(F_AMRIODL38, QA_chech_ritdatlav); -// Calcola 42 = 39 + 40 - 41 - m->set_handler(F_AMRIOT37, QA_calcola42); - m->set_handler(F_AMRIODL38, QA_calcola42); - m->set_handler(F_ECCRITRIMB, QA_calcola42); -// Calcolo: 30 = 23+27+28+29 - m->set_handler(F_COMPNETTI, QA_calcolo30); - m->set_handler(F_TOTIMP26, QA_calcolo30); - m->set_handler(F_AIEREP23, QA_calcolo30); - m->set_handler(F_CCTAMMCONT, QA_calcolo30); - } - } - break; - default: - break; - } - if (QuadroA3()) - set_search_field(F_CODIPQUADRO); - else - set_search_field(QAF_NPROG); - return _msk[n] = m; -} - - -bool TQuadroA::is_societa_trasformata(TMask& m) -{ - TLocalisamfile soc (LF_SOCTRASF); - soc.setkey(1); - soc.zero(); - soc.put(SOC_CODDITTA, m.get_long(QAF_CODDITTA)); - if (soc.read() == NOERR) - { - _cognome = soc.get(SOC_DENOMIN); - _nome = soc.get(SOC_NOME); - return TRUE; - } - return FALSE; -} - -// Ricerca e output dell'ultimo nprog del percipiente scelto -bool TQuadroA::setta_nprog(TMask_field& f) -{ - long nprog = 0L; - const long coddip = atol(f.get()); - const long codditta = get_firm_770(); - - TLocalisamfile quadro(app()._file); - - quadro.zero(); - quadro.put("CODDITTA", codditta); - quadro.put("CODDIP", coddip); - - TRectype rec(quadro.curr()); - - quadro.read(); - - if (quadro.curr() > rec) - { - f.mask().set(QAF_NPROG, nprog+1); - return TRUE; - } - - for ( ; !quadro.eof(); quadro.next()) - { - if (quadro.curr() > rec) break; - nprog = quadro.get_long("NPROG"); - } - - if ( (is_erede(codditta,coddip)) && (nprog + 1) > 1) - return f.error_box("Il dipendente selezionato e' un erede: non e'\n possibile indicare piu' di un rigo"); - - f.mask().set(QAF_NPROG, nprog+1); - return TRUE; -} - -bool TQuadroA::codditta_hnd(TMask_field& f, KEY k) -{ - if (k == K_TAB && !f.mask().is_running()) - { - TString16 codditta; codditta << app()._codditta; - if (codditta != "0") - { - f.set(codditta); - f.check(); - } - } - return TRUE; -} - -bool TQuadroA::codanagr_handler(TMask_field& f, KEY k) -{ - if (!f.mask().is_running()) - return TRUE; - - if (k == K_TAB && f.focusdirty()) - { - const long coddip = atol(f.get()); - if (coddip != 0L) - { - const long codditta = get_firm_770(); - if (!esiste_dipendente(codditta, coddip)) - return f.warning_box("Dipendente inesistente"); - else - setta_nprog(f); - } - } - return TRUE; -} - -void TQuadroA::AA3SettaCognomeNome(TMask& m) -{ - const int iDlgCognome = QAF_COGNOME; - const int iDlgNome = QAF_NOME; - const int iDlgNProg = QAF_NPROG; - const int iProg = m.get_int(iDlgNProg); - TString sCognome(m.get(iDlgCognome)); - TString sNome; - if (app()._codip != 0L) - { - TLocalisamfile dip (LF_DIPEND); - dip.zero(); - dip.put(DIP_CODDITTA, app()._codditta); - dip.put(DIP_CODIP, app()._codip); - if (dip.read() == NOERR) - { - sCognome = dip.get("COGNOME"); - sNome = dip.get("NOME"); - app()._sCognome = sCognome; - app()._sNome = sNome; - app()._iNprog = iProg; - m.set(iDlgCognome, sCognome); - m.set(iDlgNome, sNome); - } - } -} - -bool TQuadroA::QAA2alleg_handler(TMask_field& f, KEY k) -{ - if (k==K_SPACE) - { - KEY kAll; - if (app().QuadroA()) - { - const long lNumAllA = app()._base->get_long("N730ALLA"); - TString sNumAll; sNumAll << lNumAllA; - app()._mskAllegati->hide(QA2_ANNO_ALL); - app()._mskAllegati->show(QA_ANNO_ALL); - app()._mskAllegati->hide(QA2_NUM_ALL); - app()._mskAllegati->set(QA_NUM_ALL, sNumAll); - app()._mskAllegati->show(QA_NUM_ALL); - } - else - { - const long lNumAllA2 = app()._base->get_long("N730ALLA2"); - TString sNumAll; sNumAll << lNumAllA2; - app()._mskAllegati->hide(QA_ANNO_ALL); - app()._mskAllegati->show(QA2_ANNO_ALL); - app()._mskAllegati->hide(QA_NUM_ALL); - app()._mskAllegati->set(QA2_NUM_ALL, sNumAll); - app()._mskAllegati->show(QA2_NUM_ALL); - } - app()._mskAllegati->open_modal(); - kAll = app()._mskAllegati->run(); - - if (app()._mskAllegati->dirty() && !yesno_box("Annullare i dati inseriti")) - kAll = K_ENTER; - - if (kAll==K_ENTER) - { - if (app().QuadroA()) - { - TString sAll (app()._mskAllegati->get(QA_NUM_ALL)); - app()._base->put("N730ALLA", sAll); - } - else - { - TString sAll (app()._mskAllegati->get(QA2_NUM_ALL)); - app()._base->put("N730ALLA2", sAll); - } - app()._base->rewrite(); - } - app()._mskAllegati->close_modal(); - } - return TRUE; -} - -// Passa al modo inserimento/modifica. -bool TQuadroA::nprog_handler(TMask_field& f, KEY key) -{ - if (!f.mask().is_running()) return TRUE; - - if (key == K_CTRL+K_TAB) - { - f.set_dirty(); - return TRUE; - } - - if (key == K_TAB) - { - const int nprog = atoi(f.get()); - if (nprog==0) - return TRUE; - - const long coddip = f.mask().get_long(F_CODIP); - const long codditta = get_firm_770(); - - if ( (is_erede(codditta,coddip)) && nprog > 1) - return f.error_box("Il dipendente selezionato e' un erede: non e'\n possibile indicare piu' di un rigo"); - else - { - app()._codip = coddip; -// app().AA3SettaCognomeNome(f.mask()); -// f.mask().stop_run(K_AUTO_ENTER); // entra in modo modifica (se il record che ha chiave specificata esiste gia') oppure - // inserimento (se trova che non esiste) - } - } - return TRUE; -} - -bool TQuadroA::QA3_codip_handler(TMask_field& f, KEY key) -{ - if (!f.mask().is_running()) return TRUE; - - if ((key == K_TAB) && f.shown) - { - const long coddip = atol(f.get()); - if (coddip==0) return TRUE; - const long codditta = get_firm_770(); - if (!esiste_dipendente(codditta, coddip)) - return f.warning_box("Dipendente inesistente"); - f.mask().set(QAF_NPROG, 1); - } - return TRUE; -} - -// Se CF dat.lav.prec. e' vuoto => mette a ZERO il 19 e lo disabilita -// 26.6.96 azzera soltanto -bool TQuadroA::QA_cfdlprec_hnd(TMask_field& f, KEY k) -{ -/* - if (k == K_TAB) - { - TString tmp(f.get()); - if (tmp.empty()) - f.mask().set(F_CAUSA, 0L); - } */ - return TRUE; -} - -// Controlla che 40 NON sia > 30 -bool TQuadroA::QA_chech_ritdatlav(TMask_field& f, KEY k) -{ - if (k == K_ENTER) - { - real RitDatLavoro(f.get()); // c40 - real TotImp(f.mask().get_real(F_TOTIMP29)); // c30 - if (RitDatLavoro > TotImp) - return f.warning_box("Le ritenute del datore di lavoro non possono superare il totale imponibile"); - } - return TRUE; -} - -// Calcola che 42 = 39 + 40 - 41. Se il risultato e' negativo scrive 0 -bool TQuadroA::QA_calcola42(TMask_field& f, KEY k) -{ - if (k==K_TAB) - { - TMask& m = f.mask(); - real c39 = m.get_real(F_AMRIOT37); - real c40 = m.get_real(F_AMRIODL38); - real c41 = m.get_real(F_ECCRITRIMB); - real c42 = c39 + c40 - c41; - if (c42 < ZERO) c42 = ZERO; - TString c42s(c42.string()); - m.set(F_AMMRITDOV, c42s); - } - return TRUE; -} - -bool TQuadroA::QA_check_2527 (TMask_field& f, KEY k) -{ -// Se 27 == 0 => 25 = 0 - if (k == K_ENTER) - { - real c27 = f.mask().get_real(F_TOTIMP26); - real c25(f.get()); - - if (c27 == ZERO && c25 != ZERO) - return f.warning_box("Valore non corretto: il totale imponibile è nullo"); - } - return TRUE; -} - -// Funziona sia col quadro A che con A2 -bool TQuadroA::QA_A2_check_58(TMask_field& f, KEY k) -{ -// if (k == K_TAB || k == K_ENTER) - if (f.to_check(k,TRUE)) - { - TMask& m = f.mask(); - TString16 cod(f.get()); - cod.upper(); - const long codditta = m.get_long(QAF_CODDITTA); - const long coddip = m.get_long(F_CODIP); - if (cod == "B") - { - if (!QA_cerca_codA(codditta, coddip, app()._quadro)) - return error_box(app().QuadroA2() ? - "Non esiste nessun record con 9=A per questo dipendente" : - "Non esiste nessun record con 58=A per questo dipendente"); - else - { -// Nasconde prompt 770 mostra prompt 730 - m.reset(-G_ALL); - m.disable(-G_ALL); -// reset anche dei campi calcolati disabilitati nel quadro A - if (app().QuadroA()) m.reset(-G_2342); - m.hide(-G_770); - m.show(-G_730); - } - } -// Nasconde prompt 730 mostra prompt 770 - else - { - m.show(-G_770); - m.hide(-G_730); - m.enable(-G_ALL); - } - } - return TRUE; -} - -// calcola c23 = 20 + 21 -22 Se minore di 0 scrive 0 -bool TQuadroA::QA_comp_netti_hnd (TMask_field& f, KEY k) -{ - if (k == K_TAB) - { - real denaro = f.mask().get_real(F_DENARO); - real natura = f.mask().get_real(F_NATURA); - real cobbdip = f.mask().get_real(F_COBBDIP21); - real compnetti = denaro + natura - cobbdip; - if (compnetti < ZERO) compnetti = ZERO; - f.mask().set(F_COMPNETTI, compnetti); - if (f.mask().is_running()) - f.mask().send_key(K_TAB,F_COMPNETTI); - } - return TRUE; -} - -// 27 = 24 - 26 -bool TQuadroA::QA_tot_impon_hnd (TMask_field& f, KEY k) -{ - if (k == K_TAB || k == K_SPACE) - { - bool ForzaRicalcolo = f.focusdirty(); - real ammlordo = f.mask().get_real(F_AMMLORDO24); - real svnsrit = f.mask().get_real(QAF_SVNSOGRIT); - real tot_corr = f.mask().get_real(F_TOTIMP26); - if (tot_corr == ZERO || ForzaRicalcolo) - { - real totimp29 = ammlordo - svnsrit; -// c27 se < 0 scrivere 0 fax 15.7.96 p.1 - if (totimp29 < ZERO) - totimp29 = ZERO; - f.mask().set(F_TOTIMP26, totimp29); - } - } - return TRUE; -} - -bool TQuadroA::QA_tot_detraz_hnd (TMask_field& f, KEY k) -{ - if (k == K_TAB) - { - TMask& m = f.mask(); - real totdet36 = m.get_real(F_TOTDET36); - real detcc = m.get_real(F_DETCC); - real detfc = m.get_real(F_DETFC); - real detaf = m.get_real(F_DETAF); - real detld = m.get_real(F_DETLD); - real deto = m.get_real(F_DETO); - totdet36 = detcc + detfc + detaf + detld + deto; - m.set(F_TOTDET36, totdet36); -// disabilita il campo 37 se uno almeno da 32 a 36 e' compilato - if (totdet36 != ZERO) - m.disable(F_TOTDET36); - else - m.enable(F_TOTDET36); - } - return TRUE; -} - -bool TQuadroA::QA_calcolo30(TMask_field& f, KEY k) -{ - if (k == K_TAB) - { - TMask& m = f.mask(); - real c30 = m.get_real(F_TOTIMP29); - real c23 = m.get_real(F_COMPNETTI); - real c27 = m.get_real(F_TOTIMP26); - real c28 = m.get_real(F_AIEREP23); - real c29 = m.get_real(F_CCTAMMCONT); - c30 = c23 + c27 + c28 + c29; - if (c30 < ZERO) c30 = ZERO; - m.set(F_TOTIMP29, c30); - } - return TRUE; -} - -bool TQuadroA::QA3_base_occupazionale(TMask_field& f , KEY k) -{ - if (k == K_SPACE) - { - TString appname(30); - appname.format("773mod -1 771200i 37 \"%s\" 0", "Base occupazionale"); - TExternal_app a(appname); - a.run(); - } - return TRUE; -} - -void TQuadroA::registra_record2_A3(const TMask& m) -{ - TLocalisamfile quaa3 (LF_QUAA3); - TDate di; - long ng1,ng2; - real rd1,rd2; - - di = m.get_date(F_DIRAPTI_2); - ng1 = m.get_long(F_NGINC15_2); - ng2 = m.get_long(F_NGINC17_2); - rd1 = m.get_real(F_REDCOR16_2); - rd2 = m.get_real(F_REDCOR18_2); - - long codditta = m.get_long(QAF_CODDITTA); - long codip = m.get_long(F_CODIP); - - quaa3.setkey(1); - quaa3.zero(); - quaa3.put(QA3_CODDITTA, codditta); - quaa3.put(QA3_NPROG, 2); - quaa3.put(QA3_CODIP, codip); - if (quaa3.read() == NOERR) - { - quaa3.put(QA3_CODDITTA, codditta); - quaa3.put(QA3_NPROG, 2); - quaa3.put(QA3_CODIP, codip); - quaa3.put(QA3_DIRAPTI, di); - quaa3.put(QA3_NGINC15, ng1); - quaa3.put(QA3_REDCOR16, rd1); - quaa3.put(QA3_NGINC17, ng2); - quaa3.put(QA3_REDCOR18, rd2); - quaa3.rewrite(); - } - else - { - quaa3.put(QA3_CODDITTA, codditta); - quaa3.put(QA3_NPROG, 2); - quaa3.put(QA3_CODIP, codip); - quaa3.put(QA3_DIRAPTI, di); - quaa3.put(QA3_NGINC15, ng1); - quaa3.put(QA3_REDCOR16, rd1); - quaa3.put(QA3_NGINC17, ng2); - quaa3.put(QA3_REDCOR18, rd2); - quaa3.write(); - } -} - -int TQuadroA::rewrite(const TMask& m) -{ - if (QuadroA3() && _soc_trasf) - registra_record2_A3(m); - - m.autosave(*_rel); - const int err = _rel->rewrite(); - _registra = TRUE; - - return err; -} - -int TQuadroA::write(const TMask& m) -{ - if (QuadroA3() && _soc_trasf) - registra_record2_A3(m); - - m.autosave(*_rel); - const int err = _rel->write(); - _registra = TRUE; - - return err; -} - -void TQuadroA::cancella_record2_A3() -{ - TLocalisamfile quaa3 (LF_QUAA3); - - quaa3.setkey(1); - quaa3.zero(); - quaa3.put(QA3_CODDITTA, _codditta); - quaa3.put(QA3_NPROG, 2); - quaa3.put(QA3_CODIP, _codip); - if (quaa3.read() == NOERR) - quaa3.remove(); -} - -bool TQuadroA::remove() -{ - if (QuadroA3() && _soc_trasf) - cancella_record2_A3(); - _registra = TRUE; - return TRelation_application::remove(); -} - -bool TQuadroA::user_create() -{ - switch (_tipoq) - { - case 'A': - _file = LF_QUAA; - _quadro = "A"; - break; - case '1': - _file = LF_QUAA1; - _quadro = "A1"; - break; - case '2': - _file = LF_QUAA2; - _quadro = "A2"; - break; - case '3': - _file = LF_QUAA3; - _quadro = "A3"; - break; - default: - break; - } - - _qd = new TLocalisamfile(_file); - _rel = new TRelation(_file); - _base = new TLocalisamfile(LF_BASE); - _codditta = get_firm_770(); - -// posiziona il base (per leggere allegati) - _base->zero(); - _base->put("CODDITTA", _codditta); - _base->read(); - - set_search_field(F_CODANAGDIP); - _registra = FALSE; - - load_mask(0); - - if (QuadroA() || QuadroA2()) - _mskAllegati = new TMask("77qaall"); - - _soc_trasf = FALSE; - - return TRUE; -} - -bool TQuadroA::user_destroy() -{ - if (_msk[1] != NULL) delete _msk[1]; - if (_msk[0] != NULL) delete _msk[0]; - - if (QuadroA() || QuadroA2()) - delete _mskAllegati; - - delete _base; - - TString16 quadro = ""; - - switch (_tipoq) - { - case 'A': - quadro << "A"; - break; - case '1': - quadro << "A1"; - break; - case '2': - quadro << "A2"; - break; - case '3': - quadro << "A3"; - break; - default: - break; - } - - if (_registra) - _rip.set(quadro); - - delete _rel; - delete _qd; - - return TRUE; -} - -void TQuadroA::on_config_change() -{ - TConfig conf(CONFIG_STUDIO); - _anno_dic = (int)conf.get_long(ANNO_SEL, NULL); -} - -char TQuadroA::tipo_trasformata(long codditta) -{ - TLocalisamfile ditta (LF_NDITTE); - char tipo; - - ditta.setkey(1); - ditta.zero(); - ditta.put(NDT_CODDITTA, codditta); - if (ditta.read() == NOERR) - tipo = ditta.get_char(NDT_TIPOA); - - return tipo; -} - -void TQuadroA::carica_record2_A3(TMask& m) -{ - TLocalisamfile quaa3 (LF_QUAA3); - TDate di; - char tipo; - long ng1,ng2; - real rd1,rd2; - - ng1 = 0; - ng2 = 0; - rd1 = ZERO; - rd2 = ZERO; - - long codditta = m.get_long(QAF_CODDITTA); - long codip = m.get_long(F_CODIP); - - quaa3.setkey(1); - quaa3.zero(); - quaa3.put(QA3_CODDITTA, codditta); - quaa3.put(QA3_NPROG, 2); - quaa3.put(QA3_CODIP, codip); - if (quaa3.read() == NOERR) - { - di = quaa3.get_date(QA3_DIRAPTI); - ng1 = quaa3.get_long(QA3_NGINC15); - rd1 = quaa3.get_real(QA3_REDCOR16); - ng2 = quaa3.get_long(QA3_NGINC17); - rd2 = quaa3.get_real(QA3_REDCOR18); - } - - tipo = tipo_trasformata(codditta); - - if (tipo == 'F') - { - m.hide(F_DENTRASF); - m.show(F_COGNTRASF); - m.show(F_NOMETRASF); - m.set(F_COGNTRASF, _cognome); - m.set(F_NOMETRASF, _nome); - } - else - if (tipo == 'G') - { - m.show(F_DENTRASF); - m.hide(F_COGNTRASF); - m.hide(F_NOMETRASF); - m.set(F_DENTRASF, _cognome); - } - - m.set(F_NPROG_2, 2); - m.set(F_DIRAPTI_2, di); - m.set(F_NGINC15_2, ng1); - m.set(F_REDCOR16_2, rd1); - m.set(F_NGINC17_2, ng2); - m.set(F_REDCOR18_2, rd2); -} - -void TQuadroA::init_query_mode(TMask& m) -{ - m.set(QAF_ANNODIC, _anno_dic); - if (QuadroA3()) - { - _soc_trasf = is_societa_trasformata(m); - if (_soc_trasf) - carica_record2_A3(m); - } - else - { - // forza il ricalcolo dell'ultimo numero disponibile - TString16 dummy(m.get(QAF_NPROG)); - if (dummy.not_empty()) - setta_nprog(m.field(F_CODIP)); - } - m.hide(-1); // hide group 1 -nasconde DIPEND. - m.show(-2); // show group 2 -Ricerca su QUADRO A -} - -void TQuadroA::init_query_insert_mode(TMask& m) -{ - m.set(QAF_ANNODIC, _anno_dic); - m.hide(-2); // group 2 Nasconde ricerca su QUADROA - m.show(-1); // group 1 Ricerca su ANAGR.DIPENDENTI -} - -void TQuadroA::init_modify_mode(TMask& m) -{ - if (QuadroA1()) - m.set(QA1F_ANNORIF, _anno_dic); - if (QuadroA3()) - { - _codditta = m.get_long(QAF_CODDITTA); - _codip = m.get_long(F_CODIP); - - _soc_trasf = is_societa_trasformata(m); - if (_soc_trasf) - { - carica_record2_A3(m); - m.enable_page(1); - } - else - m.disable_page(1); - } -} - -void TQuadroA::init_insert_mode(TMask& m) -{ - if (QuadroA1()) - m.set(QA1F_ANNORIF, _anno_dic); - - if (QuadroA3()) - { - _codditta = m.get_long(QAF_CODDITTA); - _codip = m.get_long(F_CODIP); - - _soc_trasf = is_societa_trasformata(m); - if (_soc_trasf) - { - carica_record2_A3(m); - m.enable_page(1); - } - else - m.disable_page(1); - } -} - -int quadriA_A3(int argc, char* argv[]) -{ - const char tipo = toupper(*argv[2]); - const char* title = ""; - TQuadroA a(tipo); - switch (tipo) - { - case 'A': - title = "Quadro A"; - break; - case '1': - title = "Quadro A1"; - break; - case '2': - title = "Quadro A2"; - break; - case '3': - title = "Quadro A3"; - break; - default: - break; - } - a.run(argc, argv, title); - return TRUE; -} +////////////////////////////////////////// +// 771200.cpp - Quadro A 771mod -7 A // +// - Quadro A1 771mod -7 1 // +// - Quadro A2 771mod -7 2 // +// - Quadro A3 771mod -7 3 // +////////////////////////////////////////// +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "77lib.h" +#include "dipend.h" +#include "quadroa.h" +#include "quadroa3.h" +#include "soctrasf.h" +#include "771200.h" +#include "774200.h" +#include "77qaall.h" + +bool QA_cerca_codA(const long codditta, const long coddip, TString& quadro); + +bool QA_cerca_codA(const long codditta, const long coddip, TString& quadro) +{ + TString16 c58(""); + bool Result = FALSE; + TLocalisamfile qq(quadro == "A" ? LF_QUAA : LF_QUAA2); + qq.zero(); + qq.put(QUA_CODDITTA, codditta); + qq.put(QUA_CODIP, coddip); + TRectype dep(qq.curr()); + qq.read(); + TRecnotype lPos = qq.recno(); + for ( ;!qq.eof(); qq.next()) + { + if (qq.curr() > dep) break; + c58 = qq.get(QUA_RETCON); + if (c58 == "A") + { + Result = TRUE; + break; + } + } + qq.readat(lPos); + return Result; +} + +class TQuadroA : public TRelation_application +{ + private: + TString _quadro; // Codice del quadro in gestione + bool _registra; // Se TRUE fa i riporti + TRelation* _rel; + TMask* _msk[2]; + TMask* _mskAllegati; // maschera allegati 730 (A e A2) + long _coddip; + char _tipoq; + int _nproga; + int _mode; + int _anno_dic; // anno dichiarazione + TLocalisamfile* _qd, *_base; + TRiporti _rip; + int _file; + bool _soc_trasf; + TString _cognome,_nome; // dati soc.trasf. + + private: +// Handler relativi ai quadri A - A1 - A2 - A3 + static bool nprog_handler (TMask_field& f, KEY key); + static bool codanagr_handler (TMask_field& f, KEY key); + static bool codditta_hnd (TMask_field& f, KEY key); + static bool setta_nprog (TMask_field& f); + static bool QAA2alleg_handler (TMask_field& f, KEY key); + +// Handler relativi alla manutenzione quadro A + static bool QA_comp_netti_hnd (TMask_field& f, KEY key); + static bool QA_tot_impon_hnd (TMask_field& f, KEY key); + static bool QA_tot_detraz_hnd (TMask_field& f, KEY key); + static bool QA_cfdlprec_hnd (TMask_field& f, KEY key); + static bool QA_chech_ritdatlav (TMask_field& f, KEY key); + static bool QA_calcola42 (TMask_field& f, KEY k); + static bool QA_check_2527 (TMask_field& f, KEY key); + static bool QA_A2_check_58 (TMask_field& f, KEY key); + static bool QA_calcolo30 (TMask_field& f, KEY key); +// Handler relativi alla manutenzione quadro A3 + static bool QA3_codip_handler (TMask_field& f, KEY key); + static bool QA3_base_occupazionale(TMask_field& f, KEY key); + void AA3SettaCognomeNome(TMask& m); + + protected: + TString _sCognome, _sNome; // dati dipendente + int _iNprog; + long _codditta,_codip; + + virtual bool user_create(); + virtual bool user_destroy(); + virtual int rewrite(const TMask& m); + virtual int write (const TMask& m); + virtual bool remove(); + virtual TRelation* get_relation() const { return _rel; } + virtual TMask* get_mask(int mode); + virtual bool changing_mask(int mode); + virtual void init_query_mode (TMask&); + virtual void init_query_insert_mode (TMask&); + virtual void init_modify_mode (TMask&); + virtual void init_insert_mode(TMask& m); + virtual void on_config_change(); + TMask* load_mask(int n); + int anno_dic() const { return _anno_dic; } + bool QuadroA() const { return _quadro == "A"; } + bool QuadroA1() const { return _quadro == "A1"; } + bool QuadroA2() const { return _quadro == "A2"; } + bool QuadroA3() const { return _quadro == "A3"; } + + public: + bool is_societa_trasformata(TMask& m); + void carica_record2_A3(TMask& m); + char tipo_trasformata(long codditta); + void registra_record2_A3(const TMask& m); + void cancella_record2_A3(); + + TQuadroA(char tipo); + virtual ~TQuadroA() {}; +}; + +// Implementazione classe TQuadroA + +inline TQuadroA& app() { return (TQuadroA&) main_app(); } + +TQuadroA::TQuadroA(char tipo): _rel(NULL), _mode(0), _tipoq(tipo) +{ + memset(_msk, 0, sizeof(_msk)); +} + +bool TQuadroA::changing_mask(int mode) +{ + if ((mode == MODE_MOD) && (_mode == MODE_INS)) + return FALSE; + else + return _mode != mode; +} + +TMask* TQuadroA::get_mask(int mode) +{ + const int m = (mode == MODE_QUERY) ? 0 : 1; + _mode = mode; + return load_mask(m); +} + +TMask* TQuadroA::load_mask(int n) +{ + if (_msk[n] != NULL) + return _msk[n]; + + TFilename name("771200"); + + if (n == 0) + { + switch (_tipoq) + { + case 'A': // Manutenzione quadro A + name << 'a'; + break; + case '1': // Manutenzione quadro A1 + name << 'c'; + break; + case '2': // Manutenzione quadro A2 + name << 'e'; + break; + case '3': // Manutenzione quadro A3 + name << 'g'; + break; + default: + break; + } + } + else + { + switch (_tipoq) + { + case 'A': // Manutenzione quadro A + name << 'b'; + break; + case '1': // Manutenzione quadro A1 + name << 'd'; + break; + case '2': // Manutenzione quadro A2 + name << 'f'; + break; + case '3': // Manutenzione quadro A3 + name << 'h'; + break; + default: + break; + } + } + + TMask* m = new TMask(name); + + switch (n) + { + case 0: + if (m) + { + m->set_handler(QAF_CODDITTA, codditta_hnd); + if (QuadroA3()) + { + m->set_handler(F_CODANAGDIP, QA3_codip_handler); + m->set_handler(F_CODIPQUADRO, QA3_codip_handler); + m->set_handler(F_BASEOCCUPA, QA3_base_occupazionale); + } + else + { + if (QuadroA()) + m->set_handler(QAF_ALLEG_A, QAA2alleg_handler); + if (QuadroA2()) + m->set_handler(QA2F_ALLEG_A2, QAA2alleg_handler); + m->set_handler(QAF_NPROG, nprog_handler); + m->set_handler(F_CODANAGDIP, codanagr_handler); + m->set_handler(F_CODANAGDIPQA, codanagr_handler); + } + } + break; + case 1: + m->disable(DLG_FINDREC); + if (m) + { + if (QuadroA2()) + m->set_handler(QA2F_RETCON, QA_A2_check_58); + + if (QuadroA()) + { +// Calcola i compensi netti (c.23) e controllo c25-27 + m->set_handler(F_CODFISDL, QA_cfdlprec_hnd); + m->set_handler(F_DENARO, QA_comp_netti_hnd); + m->set_handler(F_NATURA, QA_comp_netti_hnd); + m->set_handler(F_COBBDIP21, QA_comp_netti_hnd); +// Se immette un B controlla che ci sia almeno un rec con A + m->set_handler(F_RETCON56, QA_A2_check_58); +// Se 27=0 => 25 deve = 0 + m->set_handler(F_IACOBBCD25, QA_check_2527); +// Calcola il totale imponibile (c.27) + m->set_handler(F_AMMLORDO24, QA_tot_impon_hnd); + m->set_handler(QAF_SVNSOGRIT, QA_tot_impon_hnd); + m->set_handler(F_DETCC, QA_tot_detraz_hnd); + m->set_handler(F_DETFC, QA_tot_detraz_hnd); + m->set_handler(F_DETAF, QA_tot_detraz_hnd); + m->set_handler(F_DETLD, QA_tot_detraz_hnd); + m->set_handler(F_DETO, QA_tot_detraz_hnd); +// Controlla che 40 sia <= 30 + m->set_handler(F_AMRIODL38, QA_chech_ritdatlav); +// Calcola 42 = 39 + 40 - 41 + m->set_handler(F_AMRIOT37, QA_calcola42); + m->set_handler(F_AMRIODL38, QA_calcola42); + m->set_handler(F_ECCRITRIMB, QA_calcola42); +// Calcolo: 30 = 23+27+28+29 + m->set_handler(F_COMPNETTI, QA_calcolo30); + m->set_handler(F_TOTIMP26, QA_calcolo30); + m->set_handler(F_AIEREP23, QA_calcolo30); + m->set_handler(F_CCTAMMCONT, QA_calcolo30); + } + } + break; + default: + break; + } + if (QuadroA3()) + set_search_field(F_CODIPQUADRO); + else + set_search_field(QAF_NPROG); + return _msk[n] = m; +} + + +bool TQuadroA::is_societa_trasformata(TMask& m) +{ + TLocalisamfile soc (LF_SOCTRASF); + soc.setkey(1); + soc.zero(); + soc.put(SOC_CODDITTA, m.get_long(QAF_CODDITTA)); + if (soc.read() == NOERR) + { + _cognome = soc.get(SOC_DENOMIN); + _nome = soc.get(SOC_NOME); + return TRUE; + } + return FALSE; +} + +// Ricerca e output dell'ultimo nprog del percipiente scelto +bool TQuadroA::setta_nprog(TMask_field& f) +{ + long nprog = 0L; + const long coddip = atol(f.get()); + const long codditta = get_firm_770(); + + TLocalisamfile quadro(app()._file); + + quadro.zero(); + quadro.put("CODDITTA", codditta); + quadro.put("CODDIP", coddip); + + TRectype rec(quadro.curr()); + + quadro.read(); + + if (quadro.curr() > rec) + { + f.mask().set(QAF_NPROG, nprog+1); + return TRUE; + } + + for ( ; !quadro.eof(); quadro.next()) + { + if (quadro.curr() > rec) break; + nprog = quadro.get_long("NPROG"); + } + + if ( (is_erede(codditta,coddip)) && (nprog + 1) > 1) + return f.error_box("Il dipendente selezionato e' un erede: non e'\n possibile indicare piu' di un rigo"); + + f.mask().set(QAF_NPROG, nprog+1); + return TRUE; +} + +bool TQuadroA::codditta_hnd(TMask_field& f, KEY k) +{ + if (k == K_TAB && !f.mask().is_running()) + { + TString16 codditta; codditta << app()._codditta; + if (codditta != "0") + { + f.set(codditta); + f.check(); + } + } + return TRUE; +} + +bool TQuadroA::codanagr_handler(TMask_field& f, KEY k) +{ + if (!f.mask().is_running()) + return TRUE; + + if (k == K_TAB && f.focusdirty()) + { + const long coddip = atol(f.get()); + if (coddip != 0L) + { + const long codditta = get_firm_770(); + if (!esiste_dipendente(codditta, coddip)) + return f.warning_box("Dipendente inesistente"); + else + setta_nprog(f); + } + } + return TRUE; +} + +void TQuadroA::AA3SettaCognomeNome(TMask& m) +{ + const int iDlgCognome = QAF_COGNOME; + const int iDlgNome = QAF_NOME; + const int iDlgNProg = QAF_NPROG; + const int iProg = m.get_int(iDlgNProg); + TString sCognome(m.get(iDlgCognome)); + TString sNome; + if (app()._codip != 0L) + { + TLocalisamfile dip (LF_DIPEND); + dip.zero(); + dip.put(DIP_CODDITTA, app()._codditta); + dip.put(DIP_CODIP, app()._codip); + if (dip.read() == NOERR) + { + sCognome = dip.get("COGNOME"); + sNome = dip.get("NOME"); + app()._sCognome = sCognome; + app()._sNome = sNome; + app()._iNprog = iProg; + m.set(iDlgCognome, sCognome); + m.set(iDlgNome, sNome); + } + } +} + +bool TQuadroA::QAA2alleg_handler(TMask_field& f, KEY k) +{ + if (k==K_SPACE) + { + KEY kAll; + if (app().QuadroA()) + { + const long lNumAllA = app()._base->get_long("N730ALLA"); + TString sNumAll; sNumAll << lNumAllA; + app()._mskAllegati->hide(QA2_ANNO_ALL); + app()._mskAllegati->show(QA_ANNO_ALL); + app()._mskAllegati->hide(QA2_NUM_ALL); + app()._mskAllegati->set(QA_NUM_ALL, sNumAll); + app()._mskAllegati->show(QA_NUM_ALL); + } + else + { + const long lNumAllA2 = app()._base->get_long("N730ALLA2"); + TString sNumAll; sNumAll << lNumAllA2; + app()._mskAllegati->hide(QA_ANNO_ALL); + app()._mskAllegati->show(QA2_ANNO_ALL); + app()._mskAllegati->hide(QA_NUM_ALL); + app()._mskAllegati->set(QA2_NUM_ALL, sNumAll); + app()._mskAllegati->show(QA2_NUM_ALL); + } + app()._mskAllegati->open_modal(); + kAll = app()._mskAllegati->run(); + + + + if (kAll == K_ESC && + app()._mskAllegati->dirty() && + !yesno_box("Annullare i dati inseriti")) + kAll = K_ENTER; + + if (kAll==K_ENTER) + { + if (app().QuadroA()) + { + TString sAll (app()._mskAllegati->get(QA_NUM_ALL)); + app()._base->put("N730ALLA", sAll); + } + else + { + TString sAll (app()._mskAllegati->get(QA2_NUM_ALL)); + app()._base->put("N730ALLA2", sAll); + } + app()._base->rewrite(); + } + app()._mskAllegati->close_modal(); + } + return TRUE; +} + +// Passa al modo inserimento/modifica. +bool TQuadroA::nprog_handler(TMask_field& f, KEY key) +{ + if (!f.mask().is_running()) return TRUE; + + if (key == K_CTRL+K_TAB) + { + f.set_dirty(); + return TRUE; + } + + if (key == K_TAB) + { + const int nprog = atoi(f.get()); + if (nprog==0) + return TRUE; + + const long coddip = f.mask().get_long(F_CODIP); + const long codditta = get_firm_770(); + + if ( (is_erede(codditta,coddip)) && nprog > 1) + return f.error_box("Il dipendente selezionato e' un erede: non e'\n possibile indicare piu' di un rigo"); + else + { + app()._codip = coddip; +// app().AA3SettaCognomeNome(f.mask()); +// f.mask().stop_run(K_AUTO_ENTER); // entra in modo modifica (se il record che ha chiave specificata esiste gia') oppure + // inserimento (se trova che non esiste) + } + } + return TRUE; +} + +bool TQuadroA::QA3_codip_handler(TMask_field& f, KEY key) +{ + if (!f.mask().is_running()) return TRUE; + + if ((key == K_TAB) && f.shown) + { + const long coddip = atol(f.get()); + if (coddip==0) return TRUE; + const long codditta = get_firm_770(); + if (!esiste_dipendente(codditta, coddip)) + return f.warning_box("Dipendente inesistente"); + f.mask().set(QAF_NPROG, 1); + } + return TRUE; +} + +// Se CF dat.lav.prec. e' vuoto => mette a ZERO il 19 e lo disabilita +// 26.6.96 azzera soltanto +bool TQuadroA::QA_cfdlprec_hnd(TMask_field& f, KEY k) +{ +/* + if (k == K_TAB) + { + TString tmp(f.get()); + if (tmp.empty()) + f.mask().set(F_CAUSA, 0L); + } */ + return TRUE; +} + +// Controlla che 40 NON sia > 30 +bool TQuadroA::QA_chech_ritdatlav(TMask_field& f, KEY k) +{ + if (k == K_ENTER) + { + real RitDatLavoro(f.get()); // c40 + real TotImp(f.mask().get_real(F_TOTIMP29)); // c30 + if (RitDatLavoro > TotImp) + return f.warning_box("Le ritenute del datore di lavoro non possono superare il totale imponibile"); + } + return TRUE; +} + +// Calcola che 42 = 39 + 40 - 41. Se il risultato e' negativo scrive 0 +bool TQuadroA::QA_calcola42(TMask_field& f, KEY k) +{ + if (k==K_TAB) + { + TMask& m = f.mask(); + real c39 = m.get_real(F_AMRIOT37); + real c40 = m.get_real(F_AMRIODL38); + real c41 = m.get_real(F_ECCRITRIMB); + real c42 = c39 + c40 - c41; + if (c42 < ZERO) c42 = ZERO; + TString c42s(c42.string()); + m.set(F_AMMRITDOV, c42s); + } + return TRUE; +} + +bool TQuadroA::QA_check_2527 (TMask_field& f, KEY k) +{ +// Se 27 == 0 => 25 = 0 + if (k == K_ENTER) + { + real c27 = f.mask().get_real(F_TOTIMP26); + real c25(f.get()); + + if (c27 == ZERO && c25 != ZERO) + return f.warning_box("Valore non corretto: il totale imponibile è nullo"); + } + return TRUE; +} + +// Funziona sia col quadro A che con A2 +bool TQuadroA::QA_A2_check_58(TMask_field& f, KEY k) +{ +// if (k == K_TAB || k == K_ENTER) + if (f.to_check(k,TRUE)) + { + TMask& m = f.mask(); + TString16 cod(f.get()); + cod.upper(); + const long codditta = m.get_long(QAF_CODDITTA); + const long coddip = m.get_long(F_CODIP); + if (cod == "B") + { + if (!QA_cerca_codA(codditta, coddip, app()._quadro)) + return error_box(app().QuadroA2() ? + "Non esiste nessun record con 9=A per questo dipendente" : + "Non esiste nessun record con 58=A per questo dipendente"); + else + { +// Nasconde prompt 770 mostra prompt 730 + m.reset(-G_ALL); + m.disable(-G_ALL); +// reset anche dei campi calcolati disabilitati nel quadro A + if (app().QuadroA()) m.reset(-G_2342); + m.hide(-G_770); + m.show(-G_730); + } + } +// Nasconde prompt 730 mostra prompt 770 + else + { + m.show(-G_770); + m.hide(-G_730); + m.enable(-G_ALL); + } + } + return TRUE; +} + +// calcola c23 = 20 + 21 -22 Se minore di 0 scrive 0 +bool TQuadroA::QA_comp_netti_hnd (TMask_field& f, KEY k) +{ + if (k == K_TAB) + { + real denaro = f.mask().get_real(F_DENARO); + real natura = f.mask().get_real(F_NATURA); + real cobbdip = f.mask().get_real(F_COBBDIP21); + real compnetti = denaro + natura - cobbdip; + if (compnetti < ZERO) compnetti = ZERO; + f.mask().set(F_COMPNETTI, compnetti); + if (f.mask().is_running()) + f.mask().send_key(K_TAB,F_COMPNETTI); + } + return TRUE; +} + +// 27 = 24 - 26 +bool TQuadroA::QA_tot_impon_hnd (TMask_field& f, KEY k) +{ + if (k == K_TAB || k == K_SPACE) + { + bool ForzaRicalcolo = f.focusdirty(); + real ammlordo = f.mask().get_real(F_AMMLORDO24); + real svnsrit = f.mask().get_real(QAF_SVNSOGRIT); + real tot_corr = f.mask().get_real(F_TOTIMP26); + if (tot_corr == ZERO || ForzaRicalcolo) + { + real totimp29 = ammlordo - svnsrit; +// c27 se < 0 scrivere 0 fax 15.7.96 p.1 + if (totimp29 < ZERO) + totimp29 = ZERO; + f.mask().set(F_TOTIMP26, totimp29); + } + } + return TRUE; +} + +bool TQuadroA::QA_tot_detraz_hnd (TMask_field& f, KEY k) +{ + if (k == K_TAB) + { + TMask& m = f.mask(); + real totdet36 = m.get_real(F_TOTDET36); + real detcc = m.get_real(F_DETCC); + real detfc = m.get_real(F_DETFC); + real detaf = m.get_real(F_DETAF); + real detld = m.get_real(F_DETLD); + real deto = m.get_real(F_DETO); + totdet36 = detcc + detfc + detaf + detld + deto; + m.set(F_TOTDET36, totdet36); +// disabilita il campo 37 se uno almeno da 32 a 36 e' compilato + if (totdet36 != ZERO) + m.disable(F_TOTDET36); + else + m.enable(F_TOTDET36); + } + return TRUE; +} + +bool TQuadroA::QA_calcolo30(TMask_field& f, KEY k) +{ + if (k == K_TAB) + { + TMask& m = f.mask(); + real c30 = m.get_real(F_TOTIMP29); + real c23 = m.get_real(F_COMPNETTI); + real c27 = m.get_real(F_TOTIMP26); + real c28 = m.get_real(F_AIEREP23); + real c29 = m.get_real(F_CCTAMMCONT); + c30 = c23 + c27 + c28 + c29; + if (c30 < ZERO) c30 = ZERO; + m.set(F_TOTIMP29, c30); + } + return TRUE; +} + +bool TQuadroA::QA3_base_occupazionale(TMask_field& f , KEY k) +{ + if (k == K_SPACE) + { + TString appname(30); + appname.format("773mod -1 771200i 37 \"%s\" 0", "Base occupazionale"); + TExternal_app a(appname); + a.run(); + } + return TRUE; +} + +void TQuadroA::registra_record2_A3(const TMask& m) +{ + TLocalisamfile quaa3 (LF_QUAA3); + TDate di; + long ng1,ng2; + real rd1,rd2; + + di = m.get_date(F_DIRAPTI_2); + ng1 = m.get_long(F_NGINC15_2); + ng2 = m.get_long(F_NGINC17_2); + rd1 = m.get_real(F_REDCOR16_2); + rd2 = m.get_real(F_REDCOR18_2); + + long codditta = m.get_long(QAF_CODDITTA); + long codip = m.get_long(F_CODIP); + + quaa3.setkey(1); + quaa3.zero(); + quaa3.put(QA3_CODDITTA, codditta); + quaa3.put(QA3_NPROG, 2); + quaa3.put(QA3_CODIP, codip); + if (quaa3.read() == NOERR) + { + quaa3.put(QA3_CODDITTA, codditta); + quaa3.put(QA3_NPROG, 2); + quaa3.put(QA3_CODIP, codip); + quaa3.put(QA3_DIRAPTI, di); + quaa3.put(QA3_NGINC15, ng1); + quaa3.put(QA3_REDCOR16, rd1); + quaa3.put(QA3_NGINC17, ng2); + quaa3.put(QA3_REDCOR18, rd2); + quaa3.rewrite(); + } + else + { + quaa3.put(QA3_CODDITTA, codditta); + quaa3.put(QA3_NPROG, 2); + quaa3.put(QA3_CODIP, codip); + quaa3.put(QA3_DIRAPTI, di); + quaa3.put(QA3_NGINC15, ng1); + quaa3.put(QA3_REDCOR16, rd1); + quaa3.put(QA3_NGINC17, ng2); + quaa3.put(QA3_REDCOR18, rd2); + quaa3.write(); + } +} + +int TQuadroA::rewrite(const TMask& m) +{ + if (QuadroA3() && _soc_trasf) + registra_record2_A3(m); + + m.autosave(*_rel); + const int err = _rel->rewrite(); + _registra = TRUE; + + return err; +} + +int TQuadroA::write(const TMask& m) +{ + if (QuadroA3() && _soc_trasf) + registra_record2_A3(m); + + m.autosave(*_rel); + const int err = _rel->write(); + _registra = TRUE; + + return err; +} + +void TQuadroA::cancella_record2_A3() +{ + TLocalisamfile quaa3 (LF_QUAA3); + + quaa3.setkey(1); + quaa3.zero(); + quaa3.put(QA3_CODDITTA, _codditta); + quaa3.put(QA3_NPROG, 2); + quaa3.put(QA3_CODIP, _codip); + if (quaa3.read() == NOERR) + quaa3.remove(); +} + +bool TQuadroA::remove() +{ + if (QuadroA3() && _soc_trasf) + cancella_record2_A3(); + _registra = TRUE; + return TRelation_application::remove(); +} + +bool TQuadroA::user_create() +{ + switch (_tipoq) + { + case 'A': + _file = LF_QUAA; + _quadro = "A"; + break; + case '1': + _file = LF_QUAA1; + _quadro = "A1"; + break; + case '2': + _file = LF_QUAA2; + _quadro = "A2"; + break; + case '3': + _file = LF_QUAA3; + _quadro = "A3"; + break; + default: + break; + } + + _qd = new TLocalisamfile(_file); + _rel = new TRelation(_file); + _base = new TLocalisamfile(LF_BASE); + _codditta = get_firm_770(); + +// posiziona il base (per leggere allegati) + _base->zero(); + _base->put("CODDITTA", _codditta); + _base->read(); + + set_search_field(F_CODANAGDIP); + _registra = FALSE; + + load_mask(0); + + if (QuadroA() || QuadroA2()) + _mskAllegati = new TMask("77qaall"); + + _soc_trasf = FALSE; + + return TRUE; +} + +bool TQuadroA::user_destroy() +{ + if (_msk[1] != NULL) delete _msk[1]; + if (_msk[0] != NULL) delete _msk[0]; + + if (QuadroA() || QuadroA2()) + delete _mskAllegati; + + delete _base; + + TString16 quadro = ""; + + switch (_tipoq) + { + case 'A': + quadro << "A"; + break; + case '1': + quadro << "A1"; + break; + case '2': + quadro << "A2"; + break; + case '3': + quadro << "A3"; + break; + default: + break; + } + + if (_registra) + _rip.set(quadro); + + delete _rel; + delete _qd; + + return TRUE; +} + +void TQuadroA::on_config_change() +{ + TConfig conf(CONFIG_STUDIO); + _anno_dic = (int)conf.get_long(ANNO_SEL, NULL); +} + +char TQuadroA::tipo_trasformata(long codditta) +{ + TLocalisamfile ditta (LF_NDITTE); + char tipo; + + ditta.setkey(1); + ditta.zero(); + ditta.put(NDT_CODDITTA, codditta); + if (ditta.read() == NOERR) + tipo = ditta.get_char(NDT_TIPOA); + + return tipo; +} + +void TQuadroA::carica_record2_A3(TMask& m) +{ + TLocalisamfile quaa3 (LF_QUAA3); + TDate di; + char tipo; + long ng1,ng2; + real rd1,rd2; + + ng1 = 0; + ng2 = 0; + rd1 = ZERO; + rd2 = ZERO; + + long codditta = m.get_long(QAF_CODDITTA); + long codip = m.get_long(F_CODIP); + + quaa3.setkey(1); + quaa3.zero(); + quaa3.put(QA3_CODDITTA, codditta); + quaa3.put(QA3_NPROG, 2); + quaa3.put(QA3_CODIP, codip); + if (quaa3.read() == NOERR) + { + di = quaa3.get_date(QA3_DIRAPTI); + ng1 = quaa3.get_long(QA3_NGINC15); + rd1 = quaa3.get_real(QA3_REDCOR16); + ng2 = quaa3.get_long(QA3_NGINC17); + rd2 = quaa3.get_real(QA3_REDCOR18); + } + + tipo = tipo_trasformata(codditta); + + if (tipo == 'F') + { + m.hide(F_DENTRASF); + m.show(F_COGNTRASF); + m.show(F_NOMETRASF); + m.set(F_COGNTRASF, _cognome); + m.set(F_NOMETRASF, _nome); + } + else + if (tipo == 'G') + { + m.show(F_DENTRASF); + m.hide(F_COGNTRASF); + m.hide(F_NOMETRASF); + m.set(F_DENTRASF, _cognome); + } + + m.set(F_NPROG_2, 2); + m.set(F_DIRAPTI_2, di); + m.set(F_NGINC15_2, ng1); + m.set(F_REDCOR16_2, rd1); + m.set(F_NGINC17_2, ng2); + m.set(F_REDCOR18_2, rd2); +} + +void TQuadroA::init_query_mode(TMask& m) +{ + m.set(QAF_ANNODIC, _anno_dic); + if (QuadroA3()) + { + _soc_trasf = is_societa_trasformata(m); + if (_soc_trasf) + carica_record2_A3(m); + } + else + { + // forza il ricalcolo dell'ultimo numero disponibile + TString16 dummy(m.get(QAF_NPROG)); + if (dummy.not_empty()) + setta_nprog(m.field(F_CODIP)); + } + m.hide(-1); // hide group 1 -nasconde DIPEND. + m.show(-2); // show group 2 -Ricerca su QUADRO A +} + +void TQuadroA::init_query_insert_mode(TMask& m) +{ + m.set(QAF_ANNODIC, _anno_dic); + m.hide(-2); // group 2 Nasconde ricerca su QUADROA + m.show(-1); // group 1 Ricerca su ANAGR.DIPENDENTI +} + +void TQuadroA::init_modify_mode(TMask& m) +{ + if (QuadroA1()) + m.set(QA1F_ANNORIF, _anno_dic); + if (QuadroA3()) + { + _codditta = m.get_long(QAF_CODDITTA); + _codip = m.get_long(F_CODIP); + + _soc_trasf = is_societa_trasformata(m); + if (_soc_trasf) + { + carica_record2_A3(m); + m.enable_page(1); + } + else + m.disable_page(1); + } +} + +void TQuadroA::init_insert_mode(TMask& m) +{ + if (QuadroA1()) + m.set(QA1F_ANNORIF, _anno_dic); + + if (QuadroA3()) + { + _codditta = m.get_long(QAF_CODDITTA); + _codip = m.get_long(F_CODIP); + + _soc_trasf = is_societa_trasformata(m); + if (_soc_trasf) + { + carica_record2_A3(m); + m.enable_page(1); + } + else + m.disable_page(1); + } +} + +int quadriA_A3(int argc, char* argv[]) +{ + const char tipo = toupper(*argv[2]); + const char* title = ""; + TQuadroA a(tipo); + switch (tipo) + { + case 'A': + title = "Quadro A"; + break; + case '1': + title = "Quadro A1"; + break; + case '2': + title = "Quadro A2"; + break; + case '3': + title = "Quadro A3"; + break; + default: + break; + } + a.run(argc, argv, title); + return TRUE; +} diff --git a/m770/774.cpp b/m770/774.cpp index 5eb6f9617..a1c1505a2 100755 --- a/m770/774.cpp +++ b/m770/774.cpp @@ -14,7 +14,9 @@ int main(int argc,char** argv) case 0: m74100(argc,argv) ; break; case 1: - riporti_dich(argc,argv) ; break; + riporti_dich(argc,argv) ; break; + case 2: + azzeramento_archivi(argc,argv) ; break; default: error_box(usage, argv[0]) ; } diff --git a/m770/774.h b/m770/774.h index 49f4a77eb..4906db712 100755 --- a/m770/774.h +++ b/m770/774.h @@ -2,7 +2,8 @@ #define __774_H extern int m74100 (int argc, char* argv[]); -extern int riporti_dich(int argc, char* argv[]); +extern int riporti_dich(int argc, char* argv[]); +extern int azzeramento_archivi(int argc, char* argv[]); #endif diff --git a/m770/774.url b/m770/774.url index 9f0d1e4df..216b5df76 100755 --- a/m770/774.url +++ b/m770/774.url @@ -8,4 +8,7 @@ MENUBAR MENU_BAR(1) MENU MENU_BAR(1) SUBMENU MENU_FILE "~File" +MENUBAR MENU_BAR(2) +MENU MENU_BAR(2) + SUBMENU MENU_FILE "~File" diff --git a/m770/774200.cpp b/m770/774200.cpp index 8d9ebf5c9..9a59c0e86 100755 --- a/m770/774200.cpp +++ b/m770/774200.cpp @@ -50,12 +50,6 @@ // Costanti #define TIPOQUA "TIPOQUA" -// NB Tutte da spostare in lffiles -#define LF_RIGHEF2 100 -#define LF_RIGHEF1 99 -#define LF_RIGHEF 98 -#define LF_QUAGD 101 - // inizializzato in TRiporti::set() - usato in filter_func() HIDDEN TRiporti* this_riporti = NULL; diff --git a/m770/774300.cpp b/m770/774300.cpp new file mode 100755 index 000000000..8725495d6 --- /dev/null +++ b/m770/774300.cpp @@ -0,0 +1,819 @@ +// Description: +// Azzeramento archivi +// +// Usage: +// 774 -2 S (livello di studio) +// 774 -2 D (livello di ditta) + +// Author: +// L.A. + +#include +#include +#include +#include +#include +#include +#include "774200.h" +#include "77lib.h" +#include "resetfil.h" +#include "scandich.h" +#include "774300a.h" + +// derivazione della classe TArray_sheet per implementare +// la funzione membro on_key() in modo che gestisca eventuali +// bottoni aggiunti dall'utente +class TArray_sheetDerived : public TArray_sheet +{ + +public: + // @cmember Gestisce la pressione del tasto (vedi ) + virtual bool on_key(KEY); + // @cmember Costruttore + TArray_sheetDerived(short x, short y, short dx, short dy, const char* caption, const char* head, byte buttons = 0): + TArray_sheet(x, y, dx, dy, caption, head, buttons){}; + // @cmember Distruttore + virtual ~TArray_sheetDerived(){}; +}; + +class TAzzeramento_archivi : public TRelation_application +{ + private: + char _liv; + long _curditta; + int _anno_dich; + + TMask* _msk; + TRelation* _rel; + TConfig* _cnf_studio; + TRiporti* _riporti; + TIsamtempfile* _logschede; + + // elenco campi da riportare + real _mem_ECCRIT23_BASEBIS; + + // elenco file da azzerare + TResetfile* _reset_BASE; + TResetfile* _reset_BASEBIS; + TResetfile* _reset_SOCTRASF; + TResetfile* _reset_PERC; + TResetfile* _reset_SCPERC; + TResetfile* _reset_RVER; + TResetfile* _reset_RPAG; + TResetfile* _reset_DIPEND; + TResetfile* _reset_QUAA; + TResetfile* _reset_QUAA1; + TResetfile* _reset_QUAA2; + TResetfile* _reset_QUAA3; + TResetfile* _reset_QUAB; + TResetfile* _reset_QUAB1; + TResetfile* _reset_QUAC; + TResetfile* _reset_QUAD; + TResetfile* _reset_QUAD1; + TResetfile* _reset_QUAE; + TResetfile* _reset_QUAE1; + TResetfile* _reset_QUAE2; + TResetfile* _reset_PROSPE1; + TResetfile* _reset_QUAF; + TResetfile* _reset_RIGHEF; + TResetfile* _reset_QUAF1; + TResetfile* _reset_RIGHEF1; + TResetfile* _reset_QUAF2; + TResetfile* _reset_RIGHEF2; + TResetfile* _reset_QUAG; + TResetfile* _reset_QUAGD; + TResetfile* _reset_QUAG1; + TResetfile* _reset_QUAH; + TResetfile* _reset_DETH; + TResetfile* _reset_QUAL; + TResetfile* _reset_QUAN; + TResetfile* _reset_QUAP; + TResetfile* _reset_QUAQ; + TResetfile* _reset_QUAR; + TResetfile* _reset_QUAS; + TResetfile* _reset_QUAT; + + // elenco di VALIDATE_RECORD function + static bool validate_record_SCPERC(const TRectype& rec); + static bool validate_record_RPAG(const TRectype& rec); + static bool validate_record_RVER(const TRectype& rec); + static bool validate_record_QUAL(const TRectype& rec); + static bool validate_record_DETH(const TRectype& rec); + + // elenco di VALIDATE_FIELD function + static bool validate_field_BASE(const TRectype& rec, const TString& fld); + static bool validate_field_BASEBIS(const TRectype& rec, const TString& fld); + + // elenco di BEFORE_RESET function + static void before_reset_BASEBIS(TRectype& rec); + + // elenco di AFTER_RESET function + static void after_reset_BASEBIS(TRectype& rec); + + // validazione e azioni su schede percipienti + bool is_resetable(const TRectype& rec); + + // handler di campi + static bool F_AZZSCH_hnd(TMask_field& f, KEY key); + static bool F_AZZQUA_hnd(TMask_field& f, KEY key); + static bool DLG_SAVEREC_hnd(TMask_field& f, KEY key); + + // creazione/distruzione istanze d'azzeramento + void azzera_create(const bool azzsch, const bool azzqua); + void azzera_destroy(const bool azzsch, const bool azzqua); + + // gestione del log delle schede percipienti + void handle_log(); + + // stampa del log delle schede percipienti + void print_log(); + + // elaborazioni previste + void elab_tutte(const bool azzsch, const bool azzqua); + void elab_selezionate(const bool azzsch, const bool azzqua); + void elab_manutenzione(const bool azzsch, const bool azzqua){} + + protected: + virtual bool user_create(); + virtual bool user_destroy(); + virtual TRelation* get_relation() const { return _rel; } + virtual TMask* get_mask(int mode) { return _msk; } + virtual bool changing_mask(int mode) { return FALSE; } + virtual void init_modify_mode(TMask&); + virtual int rewrite(const TMask& m); + virtual int write(const TMask& m); + + public: + TAzzeramento_archivi(char livello) : _liv(toupper(livello)) {} + ~TAzzeramento_archivi() {} +}; + +// riferimento all'istanza dell'applicazione +TAzzeramento_archivi& app() { return (TAzzeramento_archivi&)main_app(); } + +// implementazione per gestire eventuali bottoni aggiunti dall'utente +bool TArray_sheetDerived::on_key(KEY key) +{ + // verifico se premuto un bottone utente + switch(key) + { + // ignorato perchè non restituisce se stesso + case K_CTRL+'N': + break; + + default: + // verifico altri bottoni non previsti dallo sheet standard + if (key > K_CTRL) + { + for (int i = fields()-1; i >= 0; i--) + { + TMask_field& f = fld(i); + if (f.active() && f.is_kind_of(CLASS_BUTTON_FIELD)) + { + TButton_field& b = (TButton_field&)f; + if (b.virtual_key() == key) + { + stop_run(key); + return TRUE; + } + } + } + } + break; + } + + + + // richiamo on_key base + return TArray_sheet::on_key(key); +} + +bool TAzzeramento_archivi::user_create() +{ + _msk = new TMask("774300a"); + _rel = new TRelation(LF_STAZZ); + _cnf_studio = new TConfig(CONFIG_STUDIO,"77"); + _anno_dich = _cnf_studio->get_int(ANNO_SEL); + _riporti = new TRiporti; + _logschede = new TIsamtempfile(LF_SCPERC,"LOG",TRUE); + + // forzo il file di log delle schede all'auto eliminazione + _logschede->set_autodel(); + + // attivazione handler campi + _msk->set_handler(F_AZZSCH,F_AZZSCH_hnd); + _msk->set_handler(F_AZZQUA,F_AZZQUA_hnd); + _msk->set_handler(DLG_SAVEREC,DLG_SAVEREC_hnd); + + // disattivazione bottoni non utilizzabili + _msk->disable(DLG_DELREC); + + return TRUE; +} + +bool TAzzeramento_archivi::user_destroy() +{ + delete _msk; + delete _rel; + delete _cnf_studio; + delete _riporti; + delete _logschede; + + return TRUE; +} + +// creazione istanze d'azzeramento +void TAzzeramento_archivi::azzera_create(const bool azzsch, const bool azzqua) +{ + // richiesto azzeramento schede percipienti + if (azzsch) + { + _reset_PERC = new TResetfile(LF_PERC); + _reset_SCPERC = new TResetfile(LF_SCPERC,TRUE); + _reset_RVER = new TResetfile(LF_RVER,TRUE); + _reset_RPAG = new TResetfile(LF_RPAG,TRUE); + } + + // richiesto azzeramento quadri + if (azzqua) + { + _reset_BASE = new TResetfile(LF_BASE); + _reset_BASEBIS = new TResetfile(LF_BASEBIS); + _reset_SOCTRASF = new TResetfile(LF_SOCTRASF,TRUE); + _reset_DIPEND = new TResetfile(LF_DIPEND); + _reset_QUAA = new TResetfile(LF_QUAA,TRUE); + _reset_QUAA1 = new TResetfile(LF_QUAA1,TRUE); + _reset_QUAA2 = new TResetfile(LF_QUAA2,TRUE); + _reset_QUAA3 = new TResetfile(LF_QUAA3,TRUE); + _reset_QUAB = new TResetfile(LF_QUAB,TRUE); + _reset_QUAB1 = new TResetfile(LF_QUAB1,TRUE); + _reset_QUAC = new TResetfile(LF_QUAC,TRUE); + _reset_QUAD = new TResetfile(LF_QUAD,TRUE); + _reset_QUAD1 = new TResetfile(LF_QUAD1,TRUE); + _reset_QUAE = new TResetfile(LF_QUAE,TRUE); + _reset_QUAE1 = new TResetfile(LF_QUAE1,TRUE); + _reset_QUAE2 = new TResetfile(LF_QUAE2,TRUE); + _reset_PROSPE1 = new TResetfile(LF_PROSPE1,TRUE); + _reset_QUAF = new TResetfile(LF_QUAF,TRUE); + _reset_RIGHEF = new TResetfile(LF_RIGHEF,TRUE); + _reset_QUAF1 = new TResetfile(LF_QUAF1,TRUE); + _reset_RIGHEF1 = new TResetfile(LF_RIGHEF1,TRUE); + _reset_QUAF2 = new TResetfile(LF_QUAF2,TRUE); + _reset_RIGHEF2 = new TResetfile(LF_RIGHEF2,TRUE); + _reset_QUAG = new TResetfile(LF_QUAG,TRUE); + _reset_QUAGD = new TResetfile(LF_QUAGD,TRUE); + _reset_QUAG1 = new TResetfile(LF_QUAG1,TRUE); + _reset_QUAH = new TResetfile(LF_QUAH,TRUE); + _reset_DETH = new TResetfile(LF_DETH,TRUE); + _reset_QUAL = new TResetfile(LF_QUAL,TRUE); + _reset_QUAN = new TResetfile(LF_QUAN,TRUE); + _reset_QUAP = new TResetfile(LF_QUAP,TRUE); + _reset_QUAQ = new TResetfile(LF_QUAQ,TRUE); + _reset_QUAR = new TResetfile(LF_QUAR,TRUE); + _reset_QUAS = new TResetfile(LF_QUAS,TRUE); + _reset_QUAT = new TResetfile(LF_QUAT,TRUE); + } +} + +// distruzione istanze d'azzeramento +void TAzzeramento_archivi::azzera_destroy(const bool azzsch, const bool azzqua) +{ + // richiesto azzeramento schede percipienti + if (azzsch) + { + delete _reset_PERC; + delete _reset_SCPERC; + delete _reset_RVER; + delete _reset_RPAG; + } + + // richiesto azzeramento quadri + if (azzqua) + { + delete _reset_BASE; + delete _reset_BASEBIS; + delete _reset_SOCTRASF; + delete _reset_DIPEND; + delete _reset_QUAA; + delete _reset_QUAA1; + delete _reset_QUAA2; + delete _reset_QUAA3; + delete _reset_QUAB; + delete _reset_QUAB1; + delete _reset_QUAC; + delete _reset_QUAD; + delete _reset_QUAD1; + delete _reset_QUAE; + delete _reset_QUAE1; + delete _reset_QUAE2; + delete _reset_PROSPE1; + delete _reset_QUAF; + delete _reset_RIGHEF; + delete _reset_QUAF1; + delete _reset_RIGHEF1; + delete _reset_QUAF2; + delete _reset_RIGHEF2; + delete _reset_QUAG; + delete _reset_QUAGD; + delete _reset_QUAG1; + delete _reset_QUAH; + delete _reset_DETH; + delete _reset_QUAL; + delete _reset_QUAN; + delete _reset_QUAP; + delete _reset_QUAQ; + delete _reset_QUAR; + delete _reset_QUAS; + delete _reset_QUAT; + } +} + +// gestione del log delle schede percipienti +void TAzzeramento_archivi::handle_log() +{ + // creazione sheet + TString caption = "Schede percipienti insolute"; + TString head = "@1|"; + head << "Ditta@5@R|"; + head << "Tipo|"; + head << "Codice@R|"; + head << "Scheda@R|"; + head << "Data doc.@10@R|"; + head << "Num.doc.|"; + head << "Cau.|"; + head << "Totale doc.@15@R|"; + head << "Compenso@15@R|"; + head << "Spese@15@R|"; + head << "Iva@15@R"; + TArray_sheetDerived log_sheet(12, 3, 66, 20, caption, head); + log_sheet.add_button(DLG_PRINT, "~Stampa", K_CTRL+'S'); + + // apertura file fisico originale perchè altrimenti da "erore!" + TLocalisamfile f(LF_SCPERC); + + // riempimento sheet + for (int err = _logschede->first(); err == NOERR; err = _logschede->next()) + { + TToken_string row; + row.add(" "); + row.add(_logschede->get_long("CODDITTA")); + row.add(_logschede->get_char("TIPOA")); + row.add(_logschede->get_long("CODANAGR")); + row.add(_logschede->get_long("NPROG")); + row.add(_logschede->get_date("DATADOC")); + row.add(_logschede->get("NUMDOC")); + row.add(_logschede->get_int("CODCAUS")); + row.add(_logschede->get("TOTALE")); + row.add(_logschede->get("COMPENSO")); + row.add(_logschede->get("SPESE")); + row.add(_logschede->get("IVA")); + log_sheet.add(row); + } + + // esecuzione sheet + log_sheet.enable_check(); + KEY retkey = log_sheet.run(); + + // interpreto azione restituita + switch (retkey) + { + case K_CTRL+'S': + yesno_box("Vuoi davvero stampare"); + print_log(); + break; + case K_ENTER: + yesno_box("Vuoi davvero azzerare"); + break; + default: + break; + } +} + +// stampa del log delle schede percipienti +void TAzzeramento_archivi::print_log() +{ + TForm log_form("logazz"); +// log_form.relation()->replace(_logschede); + TArray& a = log_form.head(); + TForm_item& fi = log_form.find_field('H',odd_page,1); + fi.set("1995"); + log_form.print(); +} + +// elabora tutte le dichiarazioni +void TAzzeramento_archivi::elab_tutte(const bool azzsch, const bool azzqua) +{ + // creazione istanze d'azzeramento + azzera_create(azzsch, azzqua); + + // richiesto azzeramento schede percipienti + if (azzsch) + { + // percipienti + _reset_PERC->run(); + + // schede percipienti (non invertire l'ordine di chiamata!!) + _reset_SCPERC->set_validate_record_function(validate_record_SCPERC); + _reset_RPAG->set_validate_record_function(validate_record_RPAG); + _reset_RVER->set_validate_record_function(validate_record_RVER); + _reset_SCPERC->run(); + _reset_RPAG->run(); + _reset_RVER->run(); + } + + // richiesto azzeramento quadri + if (azzqua) + { + // quadro BASE e BASEBIS + _reset_BASE->set_validate_field_function(validate_field_BASE); + _reset_BASEBIS->set_validate_field_function(validate_field_BASEBIS); + _reset_BASEBIS->set_before_reset_function(before_reset_BASEBIS); + _reset_BASEBIS->set_after_reset_function(after_reset_BASEBIS); + _reset_BASE->run(); + _reset_BASEBIS->run(); + + // società trasformate + _reset_SOCTRASF->run(); + + // quadri A/A1/A2/A3/B/B1 + _reset_QUAA->run(); + _reset_QUAA1->run(); + _reset_QUAA2->run(); + _reset_QUAA3->run(); + _reset_QUAB->run(); + _reset_QUAB1->run(); + + // quadri C/D/D1/E/E1/E2 e prospetto E1 + _reset_QUAC->run(); + _reset_QUAD->run(); + _reset_QUAD1->run(); + _reset_QUAE->run(); + _reset_QUAE1->run(); + _reset_QUAE2->run(); + _reset_PROSPE1->run(); + + // quadri F/F1/F2/G/G1 e distinta G + _reset_QUAF->run(); + _reset_RIGHEF->run(); + _reset_QUAF1->run(); + _reset_RIGHEF1->run(); + _reset_QUAF2->run(); + _reset_RIGHEF2->run(); + _reset_QUAG->run(); + _reset_QUAG1->run(); + _reset_QUAGD->run(); + + // quadro H e dettaglio + _reset_DETH->set_validate_record_function(validate_record_DETH); + _reset_QUAH->run(); + _reset_DETH->run(); + + // quadro L + _reset_QUAL->set_validate_record_function(validate_record_QUAL); + _reset_QUAL->run(); + + // quadri N/P/Q/R/S/T + _reset_QUAN->run(); + _reset_QUAP->run(); + _reset_QUAQ->run(); + _reset_QUAR->run(); + _reset_QUAS->run(); + _reset_QUAT->run(); + } + + // distruzione istanze d'azzeramento + azzera_destroy(azzsch, azzqua); + + // controllo se esiste log schede percipienti + if (!_logschede->empty()) + handle_log(); + + return; +} + +// elabora le dichiarazioni selezionate (non implementata) +void TAzzeramento_archivi::elab_selezionate(const bool azzsch, const bool azzqua) +{ + long codditta; + + TScandich scandich(_sel_dich); + for (codditta = scandich.first(); + scandich.good(); codditta = scandich.next()) + { + _curditta = codditta; + } + + return; +} + +bool TAzzeramento_archivi::validate_record_SCPERC(const TRectype& rec) +{ + // verifica se la scheda è azzerabile + bool isresetable = app().is_resetable(rec); + + // scheda da non azzerare + if (!isresetable) + return FALSE; + + // scheda da loggare + if (isresetable == 2) + { + app()._logschede->write(rec); + return FALSE; + } + + // elimino tutti gli altri record + return TRUE; +} + +bool TAzzeramento_archivi::validate_record_RPAG(const TRectype& rec) +{ + // apro file e inizializzo chiave schede percipienti + TLocalisamfile scperc(LF_SCPERC); + scperc.setkey(1); + scperc.zero(); + scperc.put("CODDITTA",rec.get_long("CODDITTA")); + scperc.put("TIPOA",rec.get_char("TIPOA")); + scperc.put("CODANAGR",rec.get_long("CODANAGR")); + scperc.put("NPROG",rec.get_int("NPROG")); + + // non elimino pagamento se esiste scheda di appartenenza + if (scperc.read() == NOERR) + return FALSE; + + // elimino tutti gli altri record + return TRUE; +} + +bool TAzzeramento_archivi::validate_record_RVER(const TRectype& rec) +{ + // apro file e inizializzo chiave schede percipienti + TLocalisamfile scperc(LF_SCPERC); + scperc.setkey(1); + scperc.zero(); + scperc.put("CODDITTA",rec.get_long("CODDITTA")); + scperc.put("TIPOA",rec.get_char("TIPOA")); + scperc.put("CODANAGR",rec.get_long("CODANAGR")); + scperc.put("NPROG",rec.get_int("NPROG")); + + // non elimino pagamento se esiste scheda di appartenenza + if (scperc.read() == NOERR) + return FALSE; + + // elimino tutti gli altri record + return TRUE; +} + +bool TAzzeramento_archivi::validate_record_DETH(const TRectype& rec) +{ + // non elimino i record con anno maggiore dell'anno dichiarazione + if (rec.get_int("ANNO") > app()._anno_dich) + return FALSE; + + // elimino tutti gli altri record + return TRUE; +} + +bool TAzzeramento_archivi::validate_record_QUAL(const TRectype& rec) +{ + // non elimino i record con anno maggiore dell'anno dichiarazione + if (rec.get_int("QLAP") > app()._anno_dich) + return FALSE; + + // elimino tutti gli altri record + return TRUE; +} + +bool TAzzeramento_archivi::validate_field_BASE(const TRectype& rec, const TString& fld) +{ + if (fld == "ANNODIC" || + fld == "RAPPR" || + fld == "CARRAPP" || + fld == "CODCAAF" || + fld == "CODPRO" || + fld == "DITTACAAF") + return FALSE; + + return TRUE; +} + +bool TAzzeramento_archivi::validate_field_BASEBIS(const TRectype& rec, const TString& fld) +{ + if (fld == "L0CCONC1" || + fld == "L0CCONC2" || + fld == "L0CCONC3" || + fld == "L0CTES1" || + fld == "L0CTES2" || + fld == "L0CTES3") + return FALSE; + + return TRUE; +} + +void TAzzeramento_archivi::before_reset_BASEBIS(TRectype& rec) +{ + // memorizzo campi da riportare + app()._mem_ECCRIT23_BASEBIS = rec.get_real("ECCRIT23"); + return; +} + +void TAzzeramento_archivi::after_reset_BASEBIS(TRectype& rec) +{ + // campi da riportare + rec.put("ECCRIT12",app()._mem_ECCRIT23_BASEBIS); + return; +} + +// questa funzione restituisce : +// FALSE - la scheda non è azzerabile; +// TRUE - la scheda è azzerabile; +// 2 - la scheda è da loggare; +bool TAzzeramento_archivi::is_resetable(const TRectype& rec) +{ + // apro file e inizializzo chiave pagamenti + TLocalisamfile rpag(LF_RPAG); + rpag.setkey(1); + rpag.zero(); + rpag.put("CODDITTA",rec.get_long("CODDITTA")); + rpag.put("TIPOA",rec.get_char("TIPOA")); + rpag.put("CODANAGR",rec.get_long("CODANAGR")); + rpag.put("NPROG",rec.get_int("NPROG")); + + // istanzio record di confronto + TRectype dummyrec(rpag.curr()); + + // istanzio date di confronto + TDate dummydate(31,12,app()._anno_dich); + TDate dummydate2(01,01,app()._anno_dich); + + // inizializzo boolean per almeno un pagamento + bool nopags = TRUE; + + // inizializzo totale compenso e spese + real tot_compenso = ZERO; + real tot_spesa = ZERO; + + // controllo se i pagamenti sono azzerabili + for (int err = rpag.read(_isgteq); + err == NOERR && rpag.curr() == dummyrec; + err = rpag.next(), nopags = FALSE) + { + // data pagamento superiore al 31/12/AAAA + if (rpag.get_date("DATAPAG") > dummydate) + return FALSE; // scheda da non azzerare + + // pagamento non versato + if (rpag.get_long("NUMVERS") <= 0L) + return 2; // scheda da loggare + + // totalizzo compenso e spese + tot_compenso += rpag.get_real("COMPENSO"); + tot_spesa += rpag.get_real("SPESA"); + } + + // se ci sono pagamenti controllo che la scheda sia totalmente pagata + if (!nopags) + if (tot_compenso != rec.get_real("COMPENSO") || + tot_spesa != rec.get_real("SPESE")) + return 2; // scheda da loggare + + // se non ci sono pagamenti controllo la data documento + if (nopags) + // data documento minore del 01/01/AAAA + if (rec.get_date("DATADOC") < dummydate2) + return 2; // scheda da loggare + else + return FALSE; // scheda da non azzerare + + return TRUE; +} + +// implementazione funzione virtuale TRelation_application +void TAzzeramento_archivi::init_modify_mode(TMask& m) +{ + TDate dateazz; + + // disabilito checkbox azzeramento schede + dateazz = m.get_date(F_DATASCH); + if (dateazz.year() != 0) + { + m.set(F_AZZSCH,TRUE); + m.disable(F_AZZSCH); + } + + // disabilito checkbox azzeramento quadri + dateazz = m.get_date(F_DATAQUA); + if (dateazz.year() != 0) + { + m.set(F_AZZQUA,TRUE); + m.disable(F_AZZQUA); + } +} + +// implementazione funzione virtuale TRelation_application +int TAzzeramento_archivi::write(const TMask& m) +{ + bool azzsch = m.get_bool(F_AZZSCH); + bool azzqua = m.get_bool(F_AZZQUA); + + // azzeramento di tutte le dichiarazioni + elab_tutte(azzsch, azzqua); + + return TRelation_application::write(m); +} + +// implementazione funzione virtuale TRelation_application +int TAzzeramento_archivi::rewrite(const TMask& m) +{ + TDate datasch = _rel->lfile().get_date("DATASCH"); + TDate dataqua = _rel->lfile().get_date("DATAQUA"); + bool azzsch = m.get_bool(F_AZZSCH) && datasch.year() == 0; + bool azzqua = m.get_bool(F_AZZQUA) && dataqua.year() == 0; + + // azzeramento di tutte le dichiarazioni + elab_tutte(azzsch, azzqua); + + return TRelation_application::rewrite(m); +} + +// handler del campo maschera F_AZZSCH +bool TAzzeramento_archivi::F_AZZSCH_hnd(TMask_field& f, KEY k) +{ + if (f.to_check(K_TAB)) + { + TMask& m = f.mask(); + + // compila in automatico l'utente e la data di azzeramento + // delle schede percipiente + if (m.get_bool(F_AZZSCH) == TRUE) + { + TDate today(TODAY); + m.set(F_DATASCH,today); + m.set(F_USERSCH,user()); + } + else + { + m.reset(F_DATASCH); + m.reset(F_USERSCH); + } + + } + return TRUE; +} + +// handler del campo maschera F_AZZQUA +bool TAzzeramento_archivi::F_AZZQUA_hnd(TMask_field& f, KEY k) +{ + if (f.to_check(K_TAB)) + { + TMask& m = f.mask(); + + // compila in automatico l'utente e la data di azzeramento + // delle schede percipiente + if (m.get_bool(F_AZZQUA) == TRUE) + { + TDate today(TODAY); + m.set(F_DATAQUA,today); + m.set(F_USERQUA,user()); + } + else + { + m.reset(F_DATAQUA); + m.reset(F_USERQUA); + } + } + return TRUE; +} + +// handler del bottone maschera DLG_SAVEREC +bool TAzzeramento_archivi::DLG_SAVEREC_hnd(TMask_field& f, KEY k) +{ + if (k == K_SPACE) + { + TMask& m = f.mask(); + TDate datasch = app()._rel->lfile().get_date("DATASCH"); + TDate dataqua = app()._rel->lfile().get_date("DATAQUA"); + bool azzsch = m.get_bool(F_AZZSCH) && datasch.year() == 0; + bool azzqua = m.get_bool(F_AZZQUA) && dataqua.year() == 0; + if (azzsch || azzqua) + { + TString testo; + testo << "Conferma azzeramento "; + if (azzsch) + testo << "schede percipienti, "; + if (azzqua) + testo << "quadri dichiarazione, "; + testo << "per l'anno " << m.get(F_ANNODIC) << " ?"; + return f.yesno_box(testo); + } + } + return TRUE; +} + +// funzione principale di lancio applicazione +int Azzeramento_archivi(int argc, char* argv[]) +{ + TAzzeramento_archivi a(*argv[2]); + a.run(argc, argv, "Azzeramento archivi"); + return 0; +} \ No newline at end of file diff --git a/m770/774300a.h b/m770/774300a.h new file mode 100755 index 000000000..11d64b9ba --- /dev/null +++ b/m770/774300a.h @@ -0,0 +1,11 @@ +// 774300a.h - Storico azzeramenti + +#define F_ANNODIC 201 +#define F_AZZSCH 202 +#define F_USERSCH 203 +#define F_DATASCH 204 +#define F_AZZQUA 205 +#define F_USERQUA 206 +#define F_DATAQUA 207 + +#define LF_STAZZ 109 diff --git a/m770/774300a.uml b/m770/774300a.uml new file mode 100755 index 000000000..1ee955761 --- /dev/null +++ b/m770/774300a.uml @@ -0,0 +1,82 @@ +#include "774300a.h" + +TOOLBAR "" 0 18 0 4 +#include +ENDPAGE + +PAGE "Storico azzeramenti" -1 -1 78 21 + +NUMBER F_ANNODIC 4 +BEGIN + PROMPT 1 3 "Anno dichiarazione " + FIELD LF_STAZZ->ANNODIC + KEY 1 + USE LF_STAZZ KEY 1 + INPUT ANNODIC F_ANNODIC + DISPLAY "Anno" ANNODIC + DISPLAY "Azzeramento schede" DATASCH + DISPLAY "Azzeramento quadri" DATAQUA + OUTPUT F_ANNODIC ANNODIC + OUTPUT F_USERSCH USERSCH + OUTPUT F_DATASCH DATASCH + OUTPUT F_USERQUA USERQUA + OUTPUT F_DATAQUA DATAQUA + CHECKTYPE REQUIRED + FLAGS "R" + MESSAGE ENABLE,F_AZZSCH|ENABLE,F_AZZQUA +END + +GROUPBOX DLG_NULL -1 3 +BEGIN + PROMPT 1 7 "@bAzzeramento schede percipienti" + FLAGS "R" +END + +BOOLEAN F_AZZSCH +BEGIN + PROMPT 2 8 "" +END + +STRING F_USERSCH 8 +BEGIN + PROMPT 6 8 "Utente " + FIELD LF_STAZZ->USERSCH + FLAGS "D" +END + +DATE F_DATASCH +BEGIN + PROMPT 25 8 "Data azzeramento " + FIELD LF_STAZZ->DATASCH + FLAGS "D" +END + +GROUPBOX DLG_NULL -1 3 +BEGIN + PROMPT 1 12 "@bAzzeramento quadri dichiarazione" + FLAGS "R" +END + +BOOLEAN F_AZZQUA +BEGIN + PROMPT 2 13 "" +END + +STRING F_USERQUA 8 +BEGIN + PROMPT 6 13 "Utente " + FIELD LF_STAZZ->USERQUA + FLAGS "D" +END + +DATE F_DATAQUA +BEGIN + PROMPT 25 13 "Data azzeramento " + FIELD LF_STAZZ->DATAQUA + FLAGS "D" +END + +ENDPAGE + +ENDMASK + diff --git a/m770/resetfil.cpp b/m770/resetfil.cpp new file mode 100755 index 000000000..e16dd4186 --- /dev/null +++ b/m770/resetfil.cpp @@ -0,0 +1,176 @@ +#include "resetfil.h" + + +/////////////////////////////////////////////////////////// +// TResetfile +/////////////////////////////////////////////////////////// + +TResetfile::TResetfile(int logicnum, bool remove) + : _file_num(logicnum), _removerec(remove), + _validate_record_function(NULL), + _validate_field_function(NULL), + _before_reset_function(NULL), + _after_reset_function(NULL) +{ + // oggetto file da azzerare + _file = new TSystemisamfile(_file_num); +} + +TResetfile::~TResetfile() +{ + // pack file se richiesto rimozione record + if(_removerec) + _file->pack(); + + delete _file; +} + +// @doc INTERNAL +// @mfunc ritorna se il campo

è un campo chiave +bool TResetfile::iskeyfield(const RecDes& recd, const int fd) const +{ + // inizializzo risultato da restituire + bool found = FALSE; + + // loop di scansione delle chiavi del file + for (int i = 0; i < recd.NKeys && !found; i++) + { + + // Elenco dei campi della chiave + const KeyDes& keyd = recd.Ky[i]; + + // loop di scansione dei campi della chiave + for (int j = 0; j < keyd.NkFields && !found; j++) + if (fd == keyd.FieldSeq[j] % MaxFields) + found = TRUE; + } + + return found; +} + +// @doc INTERNAL +// @mfunc carica l'array

con i campi da azzerare +// @rfunc ritorna il numero di campi caricati +int TResetfile::load_resetable_fields(const RecDes& recd, + TString_array& resetable_fields) +{ + // inizializzo numero campi da restituire + int numfld = 0; + + for (int i = 0; i < recd.NFields; i++) + { + // non azzero i campi chiave + if (iskeyfield(recd, i)) + continue; + + // Descrittore campo + RecFieldDes& fieldd = recd.Fd[i]; + + // non azzero i campi indefiniti + if (fieldd.TypeF == _nullfld) + continue; + + // aggiungo campo da azzerare all'array + resetable_fields.add(fieldd.Name,numfld++); + } + + return numfld; +} + +// @doc EXTERNAL +// @mfunc esegue l'azzeramento del file +// @rfunc ritorna il codice errore relativo ad operazioni sul file +int TResetfile::run() +{ + // codice errore + int err; + + // numero campi da azzerare + int num_resetable_fields; + + // Apertura file con bloccaggio + err = _file->open(_excllock); + if (err != NOERR) + return err; + + // riferimento a record corrente + TRectype& rec = _file->curr(); + + // Descrittore record + const RecDes* recd = rec.rec_des(); + + // array dei campi da azzerare + TString_array resetable_fields(recd->NFields); + + // riempimento array dei campi da azzerare + if (!_removerec) + num_resetable_fields = load_resetable_fields(*recd, resetable_fields); + + // reperimento nome file file + const char* desfile = _file->description(); + + // composizione testo per indicatore progressivo + TString testo; + testo.format("Azzeramento %s", desfile); + + // inizializzazione indice massimo e parziale per indicatore progressivo + const long pmax = _file->items(); + long pi = 0L; + + // istanza indicatore progressivo per avanzamento azzeramento + TProgind p(pmax, testo, FALSE, TRUE); + + // loop di scansione file da azzerare + for (err = _file->first(); err == NOERR; err = _file->next()) + { + // incremento indicatore progressivo + p.addstatus(1); + pi++; + + // richiamo handler VALIDATE_RECORD + if (_validate_record_function) + if (!_validate_record_function(rec)) + continue; + + // richiamo handler BEFORE_RESET + if (_before_reset_function) + _before_reset_function(rec); + + // rimozione del record + if(_removerec) + _file->remove(); + + // azzeramento del record + else + { + // loop di scansione campi da azzerare + for (int i = 0; i < num_resetable_fields; i++) + { + // richiamo handler VALIDATE_FIELD + if (_validate_field_function) + if (!_validate_field_function(rec, resetable_fields.row(i))) + continue; + + // azzeramento campi + rec.zero(resetable_fields.row(i)); + } + } + + // richiamo handler AFTER_RESET + if (_after_reset_function) + _after_reset_function(rec); + + // registrazione record + if(!_removerec) + _file->rewrite(); + } + + // rabbocco indicatore progressivo + p.addstatus(pmax-pi); + + // chiusura file + _file->close(); + + return err; +} + diff --git a/m770/resetfil.h b/m770/resetfil.h new file mode 100755 index 000000000..18ea59dde --- /dev/null +++ b/m770/resetfil.h @@ -0,0 +1,79 @@ +#ifndef __RESETFIL_H +#define __RESETFIL_H + +#ifndef __ISAM_H +#include +#include +#endif + +/////////////////////////////////////////////////////////// +// TResetfile +/////////////////////////////////////////////////////////// + +// @doc EXTERNAL + +// @type VALIDATE_RECORD | Prototipo funzione per validare se un record e' da azzerare. +typedef bool (*VALIDATE_RECORD)(const TRectype& rec); + +// @type VALIDATE_FIELD | Prototipo funzione per validare se un campo e' da azzerare. +typedef bool (*VALIDATE_FIELD)(const TRectype& rec, const TString& fld); + +// @type BEFORE_RESET | Prototipo funzione richiamata prima dell'azzeramento di un record. +typedef void (*BEFORE_RESET)(TRectype& rec); + +// @type AFTER_RESET | Prototipo funzione richiamata dopo l'azzeramento di un record. +typedef void (*AFTER_RESET)(TRectype& rec); + +// @class TResetfile | Classe per l'azzeramento di un file +// +// @base public | TObject +class TResetfile : public TObject + +// @author:(INTERNAL) Luciano + +// @access:(INTERNAL) Private Member +{ + // @cmember:(INTERNAL) numero logico del file da azzerare + int _file_num; + // @cmember:(INTERNAL) file da azzerare + TSystemisamfile* _file; + // @cmember:(INTERNAL) effettuare remove dei record (default FALSE) + bool _removerec; + // @cmember:(INTERNAL) funzione di validate per azzerare un record + VALIDATE_RECORD _validate_record_function; + // @cmember:(INTERNAL) funzione di validate per azzerare un campo + VALIDATE_FIELD _validate_field_function; + // @cmember:(INTERNAL) funzione richiamata prima dell'azzeramento di un record + BEFORE_RESET _before_reset_function; + // @cmember:(INTERNAL) funzione richiamata dopo l'azzeramento di un record + AFTER_RESET _after_reset_function; + // @cmember:(INTERNAL) ritorna se il campo

è un campo chiave + bool iskeyfield(const RecDes& recd, const int fd) const; + // @cmember:(INTERNAL) ritorna e carica il numero campi da azzerare + int TResetfile::load_resetable_fields(const RecDes& recd,TString_array& resetable_fields); + +// @access Public Member +public: + // @cmember setta la funzione di validate se record da azzerare + void set_validate_record_function(VALIDATE_RECORD fun) + {_validate_record_function = fun;} + // @cmember setta la funzione di validate se campo da azzerare + void set_validate_field_function(VALIDATE_FIELD fun) + {_validate_field_function = fun;} + // @cmember setta la funzione richiamata prima dell'azzeramento di un record + void set_before_reset_function(BEFORE_RESET fun) + {_before_reset_function = fun;} + // @cmember setta la funzione richiamata dopo l'azzeramento di un record + void set_after_reset_function(AFTER_RESET fun) + {_after_reset_function = fun;} + // @cmember esegue l'azzeramento del file + int run(); + + // @cmember Costruttore + TResetfile(int logicnum, bool remove = FALSE); + // @cmember Distruttore + virtual ~TResetfile(); +}; + +#endif + diff --git a/m770/scandich.cpp b/m770/scandich.cpp new file mode 100755 index 000000000..1db91c58b --- /dev/null +++ b/m770/scandich.cpp @@ -0,0 +1,105 @@ +#include "scandich.h" + + +/////////////////////////////////////////////////////////// +// TScandich +/////////////////////////////////////////////////////////// + +TScandich::TScandich(scantype type) + : _type(type), + _lasterr(NOERR) +{ + // salvo codice dichiarazione in manutenzione + _dich_prec = get_firm_770(); + + switch (_type) + { + case _sel_dich: + _cnf_user = new TConfig(CONFIG_USER); + break; + case _all_dich: + _base_file = new TLocalisamfile(LF_BASE); + _base_file->setkey(1); + break; + default: + break; + } +} + +TScandich::~TScandich() +{ + switch (_type) + { + case _sel_dich: + delete _cnf_user; + break; + case _all_dich: + delete _base_file; + break; + default: + break; + } + + // ripristino codice dichiarazione in manutenzione + set_firm_770(_dich_prec); +} + +// @doc EXTERNAL +// @mfunc ritorna il codice della prima dichiarazione da elaborare +long TScandich::first() +{ + // codice dichiarazione da restituire + long coddich = 0L; + + // primo codice se richiesto _sel_dich + if (_type == _sel_dich) + { + _num_dich = 0; + coddich = _cnf_user->get_long(DITTE_SEL, "77", _num_dich++); + if (coddich == 0L) + _lasterr = _iseof; + } + + // primo codice se richiesto _all_dich + if (_type == _all_dich) + { + _lasterr = _base_file->first(); + if (_lasterr == NOERR) + coddich = _base_file->get_long("CODDITTA"); + } + + return coddich; +} + +// @doc EXTERNAL +// @mfunc ritorna il codice della successiva dichiarazione da elaborare +long TScandich::next() +{ + // codice dichiarazione da restituire + long coddich = 0L; + + // codice successivo se richiesto _sel_dich + if (_type == _sel_dich) + { + coddich = _cnf_user->get_long(DITTE_SEL, "77", _num_dich++); + if (coddich == 0L) + _lasterr = _iseof; + } + + // codice successivo se richiesto _all_dich + if (_type == _all_dich) + { + _lasterr = _base_file->next(); + if (_lasterr == NOERR) + // se dichiarazione "dichiarante" forzo fine file + if (_base_file->get_char("TIPOQUA") == 'D') + _lasterr = _iseof; + else + coddich = _base_file->get_long("CODDITTA"); + } + + return coddich; +} + + + diff --git a/m770/scandich.h b/m770/scandich.h new file mode 100755 index 000000000..e68ccfa83 --- /dev/null +++ b/m770/scandich.h @@ -0,0 +1,57 @@ +#ifndef __SCANDICH_H +#define __SCANDICH_H + +#include +#include "77lib.h" + +/////////////////////////////////////////////////////////// +// TScandich +/////////////////////////////////////////////////////////// + +// @doc EXTERNAL + +// @enum scantype | Tipo di scansione da effettuare +enum scantype { + _sel_dich, // @emem Dichiarazioni selezionate + _all_dich }; // @emem Tutte le dichiarazioni + +// @class TScandich | Classe per la scansione delle dichiarazioni da elaborare +// +// @base public | TObject +class TScandich : public TObject + +// @author:(INTERNAL) Luciano + +// @access:(INTERNAL) Private Member +{ + // @cmember:(INTERNAL) tipo di scansione richiesta + scantype _type; + // @cmember:(INTERNAL) configurazione utente per dichiarazioni selezionate + TConfig* _cnf_user; + // @cmember:(INTERNAL) file base dichiarazioni + TLocalisamfile* _base_file; + // @cmember:(INTERNAL) codice dichiarazione in manutenzione da ripristinare + long _dich_prec; + // @cmember:(INTERNAL) indice della dichiarazione selezionata + int _num_dich; + // @cmember:(INTERNAL) codice ultimo errore + int _lasterr; + +// @access Public Member +public: + // @cmember ritorna il codice della prima dichiarazione da elaborare + long first(); + // @cmember ritorna il codice della successiva dichiarazione da elaborare + long next(); + // @cmember ritorna se l'ultimo codice restituito era valido + bool good() + {return _lasterr == NOERR;} + + // @cmember Costruttore + TScandich(scantype type = _sel_dich); + // @cmember Distruttore + virtual ~TScandich(); +}; + +#endif +