// Variazione movimenti Primanota --> cg6 -7 P // Variazione movimenti Iva --> cg6 -7 I // Variazione movimenti Saldaconto --> cg6 -7 B // Visualizzazione stato ricezione --> cg6 -7 V // Scelta ditta per ricezione --> cg6 -7 S // Annullo movimenti ricezione --> cg6 -7 A #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "cglib04.h" #include "cglib01.h" #include "cg6800.h" #include "cg6801.h" #include "cg6802.h" #include "cg6803.h" #include "cg6804.h" class TVar_mov : public TApplication { TIsamtempfile* _tmov, *_trmov, *_tiva, *_toccas; TLocalisamfile* _pcon, *_clifo, *_mov, *_rmov, *_rmoviva, *_occas, *_causali, *_comuni; TTable* _tab_reg; TRectype* _rec_mov,* _rec_rmov,* _rec_riva; TTransfer_file _tras_file; TEsercizi_contabili _ec; char _scelta; TString _trasf,_std,_descr_civa; long _dittaric,_numreg; TString _control_rec,_record; bool _righe,_corrisp, _is_exist; int _numrig,_tiporeg; bool _registrato; public: TString _titolo; virtual bool create(); virtual bool destroy(); virtual bool menu(MENU_TAG m); virtual bool check_autorization() const {return FALSE;} bool main_loop(); void apri_temp_file(); bool esegui_controlli(); bool leggi_trasfer(); bool controlli(); void leggi_record_controllo(); bool video_PN(); bool video_IVA(); void registra_PN(TMask& m); void registra_IVA(TMask& m); bool esiste_testata_mov(TMask& m); bool ricerca_movimento(TMask& m); bool esiste_riga_mov(TMask& m); bool esiste_riga_iva(TMask& m); void ricerca_codcaus(const TString& codcaus); void setta_campi_maschera(TMask& m); bool setta_campi_maschera_iva(TMask& m); void registra_file_temp_mov(int,long,const TDate&,const TDate&,const TDate&,const TString&,TString&,long,long,const TString&,TString&,char); void registra_file_temp_rmov(long,int,int,int,long,char,const TString&,int,int,long,const real&); void registra_file_temp_riva(long,int,const real&,const TString&,const real&,int,int,int,int,long); void setta_parametri_record(const TString& sigla,const TString& flag); char TipoConto (int g, int c); void ricerca_localita(TString& com, TString& den, TString& cap, TString& prov); void datacompetenza(int anno, TString& datacomp); static bool codice_registro_hnd (TMask_field& f, KEY k); static bool codice_causale_hnd (TMask_field& f, KEY k); static bool numero_protocollo_hnd (TMask_field& f, KEY k); static bool ultimo_protocollo_hnd (TMask_field& f, KEY k); static bool codice_pagamento_hnd (TMask_field& f, KEY k); static bool data_stampa (TMask_field& f, KEY k); static bool data_competenza_hnd (TMask_field& f, KEY k); static bool controllo_partita (TMask_field& f, KEY k); static bool controllo_contropartita (TMask_field& f, KEY k); static bool controllo_importo (TMask_field& f, KEY k); static bool localita_occasionali (TMask_field& f, KEY k); static bool cap_occasionali (TMask_field& f, KEY k); static bool codice_clifo_hnd (TMask_field& f, KEY k); static bool codice_iva_hnd (TMask_field& f, KEY k); static bool imposta_hnd (TMask_field& f, KEY k); static bool detraibilita_hnd (TMask_field& f, KEY k); static bool tipocr_hnd (TMask_field& f, KEY k); static bool data (TMask_field& f, KEY k); bool decodifica_codiva(const TString& codiva); TVar_mov(char mov); }; HIDDEN TVar_mov& app() { return (TVar_mov &) main_app(); } char TVar_mov::TipoConto(int g, int c) { TLocalisamfile pcon (LF_PCON); char tipo = ' '; pcon.setkey(1); pcon.zero(); pcon.put(PCN_GRUPPO, g); pcon.put(PCN_CONTO, c); pcon.put(PCN_SOTTOCONTO, 0l); if (pcon.read() == NOERR) tipo = pcon.get_char(PCN_TMCF); return tipo; } TVar_mov::TVar_mov(char mov) : _scelta(toupper(mov)) { _tiva = NULL; _toccas = NULL; _tmov = NULL; _trmov = NULL; switch (_scelta) { case 'P': _titolo = TR("Variazione movimenti prima nota"); break; case 'I': _titolo = TR("Variazione movimenti iva"); break; default: break; } } bool TVar_mov::create() { TApplication::create(); _pcon = new TLocalisamfile (LF_PCON); _clifo = new TLocalisamfile (LF_CLIFO); _rec_mov = new TRectype (LF_MOV); _mov = new TLocalisamfile (LF_MOV); _rmov = new TLocalisamfile (LF_RMOV); _rmoviva = new TLocalisamfile (LF_RMOVIVA); _occas = new TLocalisamfile (LF_OCCAS); _causali = new TLocalisamfile (LF_CAUSALI); _comuni = new TLocalisamfile (LF_COMUNI); _tab_reg = new TTable ("REG"); _rec_rmov = new TRectype (LF_RMOV); _rec_riva = new TRectype (LF_RMOVIVA); _registrato = FALSE; dispatch_e_menu (BAR_ITEM(1)); return TRUE; } bool TVar_mov::destroy() { delete _rec_mov; delete _pcon; delete _clifo; delete _mov; delete _rmov; delete _rmoviva; delete _occas; delete _causali; delete _comuni; delete _tab_reg; delete _rec_rmov; delete _rec_riva; if (_trmov) delete _trmov; if (_tiva) delete _tiva; if (_toccas) delete _toccas; if (_tmov) delete _tmov; return TApplication::destroy(); } void TVar_mov::apri_temp_file() { TString80 tmpmov = "%"; tmpmov << get_firm_dir(); tmpmov << "\\" << TEMP_MOV; TString80 tmprmov = "%"; tmprmov << get_firm_dir(); tmprmov << "\\" << TEMP_RMOV; _tmov = new TIsamtempfile(LF_MOV, tmpmov, 0); _trmov = new TIsamtempfile(LF_RMOV, tmprmov, 0); TString80 tmprmoviva = "%"; tmprmoviva << get_firm_dir(); tmprmoviva << "\\" << TEMP_RMOVIVA; TString80 tmpoccas = "%"; tmpoccas << get_firm_dir(); tmpoccas << "\\" << TEMP_OCC; _is_exist = FALSE; TString tmp = tmprmoviva.mid(1); tmp << ".dbf"; if (fexist(tmp)) { _tiva = new TIsamtempfile(LF_RMOVIVA, tmprmoviva, 0); _toccas = new TIsamtempfile(LF_OCCAS, tmpoccas, 0); _is_exist = TRUE; } } void TVar_mov::leggi_record_controllo() { _tras_file.read_control_rec(); _control_rec = _tras_file.record(); } bool TVar_mov::main_loop() { _dittaric = get_firm(); if (!esegui_controlli()) return FALSE; apri_temp_file(); if (_scelta == 'I' && !_is_exist) return error_box(TR("I movimenti iva non sono stati ricevuti: impossibile variarli")); if (_scelta == 'P') { if (!video_PN()) { if (_registrato) { setta_parametri_record(" ","C"); leggi_record_controllo(); TString str; str.spaces(60); _control_rec.overwrite(str,241); _tras_file.write_control_rec(_control_rec,1024); } return FALSE; } } else { if (_scelta == 'I') if (!video_IVA()) { if (_registrato) { setta_parametri_record(" ","C"); leggi_record_controllo(); TString str; str.spaces(60); _control_rec.overwrite(str,241); _tras_file.write_control_rec(_control_rec,1024); } return FALSE; } } return FALSE; } bool TVar_mov::video_PN() { TMask* msk = new TMask("cg6800a"); KEY tasto; do { tasto = msk->run(); if (tasto != K_ENTER) { delete msk; return FALSE; } if (ricerca_movimento(*msk)) { TMask* mask = new TMask("cg6800b"); mask->set_handler(F_REGIVA, codice_registro_hnd); mask->set_handler(F_CODCAUS, codice_causale_hnd); mask->set_handler(F_PROTIVA, numero_protocollo_hnd); mask->set_handler(F_NUPROTIVA, ultimo_protocollo_hnd); mask->set_handler(F_CODPAG, codice_pagamento_hnd); mask->set_handler(F_DATAREG, data_stampa); mask->set_handler(F_DATACOMP, data_competenza_hnd); //mask->set_handler(F_DATADOC, data); if (_righe) { mask->set_handler(F_SOTTOCONTO, controllo_partita); mask->set_handler(F_SOTTOC, controllo_contropartita); mask->set_handler(F_IMPORTO , controllo_importo); } setta_campi_maschera(*mask); tasto = mask->run(); switch (tasto) { case K_ESC : break; case K_QUIT : break; case K_SAVE : { registra_PN(*mask); _registrato = TRUE; } break; default: break; } delete mask; } } while (tasto != K_QUIT); //K_ENTER delete msk; return TRUE; } void TVar_mov::ricerca_codcaus(const TString& codcaus) { TLocalisamfile& cau = *_causali; TString tipodoc; cau.setkey(1); cau.zero(); cau.put("CODCAUS", (const char*) codcaus); if (cau.read() == NOERR) tipodoc = cau.get("TIPODOC"); TTable tpd ("%TPD"); tpd.zero(); tpd.put("CODTAB", (const char*) tipodoc); if (tpd.read() == NOERR) _corrisp = tpd.get_bool("B0"); } bool TVar_mov::video_IVA() { TMask* msk = new TMask("cg6800a"); KEY tasto; do { tasto = msk->run(); if (tasto != K_ENTER) { delete msk; return FALSE; } if (ricerca_movimento(*msk)) { TMask* mask = new TMask("cg6800c"); TString regiva = _rec_mov->get(MOV_REG); if (!setta_campi_maschera_iva(*mask)) { delete msk; delete mask; return FALSE; } mask->set_handler(F_CODCF, codice_clifo_hnd); //mask->set_handler(F_DATA74TER, data); mask->set_handler(F_LOCALITA, localita_occasionali); mask->set_handler(F_CAPOCC, cap_occasionali); if (_righe) { mask->set_handler(F_SOTTOCONTO, controllo_partita); mask->set_handler(F_CODIVA, codice_iva_hnd); mask->set_handler(F_IMPOSTA, imposta_hnd); mask->set_handler(F_TIPODET, detraibilita_hnd); mask->set_handler(F_TIPOCR, tipocr_hnd); } tasto = mask->run(); switch (tasto) { case K_ESC : break; case K_QUIT : break; case K_SAVE : { registra_IVA(*mask); _registrato = TRUE; } break; default: break; } delete mask; } } while (tasto != K_QUIT); //K_ENTER delete msk; return TRUE; } bool TVar_mov::ricerca_movimento(TMask& m) { _numrig = atoi(m.get(F_NUMRIG)); if (_numrig == 0) { _righe = FALSE; return esiste_testata_mov(m); } else { _righe = TRUE; bool annullato = esiste_testata_mov(m); if (!annullato) return FALSE; if (_scelta == 'P') return esiste_riga_mov(m); else return esiste_riga_iva(m); } return TRUE; } bool TVar_mov::esiste_testata_mov(TMask& m) { _numreg = m.get_long(F_NUMREG); _tmov->setkey(1); _tmov->zero(); _tmov->put(MOV_NUMREG, _numreg); if (_tmov->read() == NOERR) { if (_scelta == 'P') { _trmov->setkey(1); _trmov->zero(); _trmov->put(RMI_NUMREG, _numreg); _trmov->read(); long nr = _trmov->get_long(RMV_NUMREG); if (_numreg != nr) return error_box(TR("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento")); } else if (_scelta == 'I') { _tiva->setkey(1); _tiva->zero(); _tiva->put(RMI_NUMREG, _numreg); _tiva->read(); long nr = _tiva->get_long(RMI_NUMREG); if (_numreg != nr) return error_box(TR("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento")); } *_rec_mov = _tmov->curr(); } else return error_box(TR("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento")); return TRUE; } bool TVar_mov::esiste_riga_mov(TMask& m) { _numreg = m.get_long(F_NUMREG); _numrig = m.get_int (F_NUMRIG); _trmov->setkey(1); _trmov->zero(); _trmov->put(RMV_NUMREG, _numreg); _trmov->put(RMV_NUMRIG, _numrig); if (_trmov->read() == NOERR) *_rec_rmov = _trmov->curr(); else return error_box(TR("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento")); return TRUE; } bool TVar_mov::esiste_riga_iva(TMask& m) { _numreg = m.get_long(F_NUMREG); _numrig = m.get_int (F_NUMRIG); _tiva->setkey(1); _tiva->zero(); _tiva->put(RMI_NUMREG, _numreg); _tiva->put(RMI_NUMRIG, _numrig); if (_tiva->read() == NOERR) *_rec_riva = _tiva->curr(); else return error_box(TR("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento")); return TRUE; } void TVar_mov::setta_campi_maschera(TMask& m) { TDate datareg (_rec_mov->get_date(MOV_DATAREG)); TDate datadoc (_rec_mov->get_date(MOV_DATADOC)); TDate datacomp(_rec_mov->get_date(MOV_DATACOMP)); int anno = _rec_mov->get_int (MOV_ANNOES); TString numdoc = _rec_mov->get (MOV_NUMDOC); TString regiva = _rec_mov->get (MOV_REG); regiva.trim(); long protiva = _rec_mov->get_long(MOV_PROTIVA); long nuprotiva = _rec_mov->get_long(MOV_UPROTIVA); TString provvis = _rec_mov->get (MOV_PROVVIS); TString codcaus = _rec_mov->get (MOV_CODCAUS); TString codpag = _rec_mov->get (MOV_CODPAG); codpag.trim(); m.set(F_NUMREG, _numreg); m.set(F_NUMRIG, _numrig); m.set(F_DATAREG, datareg.string()); m.set(F_DATACOMP, datacomp.string()); m.set(F_ANNO, anno); m.set(F_DATADOC, datadoc.string()); m.set(F_NUMDOC, numdoc); m.set(F_REGIVA, regiva); m.set(F_PROTIVA, protiva); m.set(F_NUPROTIVA, nuprotiva); m.set(F_CODCAUS, codcaus); m.set(F_CODPAG, codpag); m.set(F_PROVV, provvis); m.disable(F_NUMREG); m.disable(F_NUMRIG); if (!_righe) { m.enable(F_DATAREG); m.enable(F_DATACOMP); m.enable(F_DATADOC); m.enable(F_NUMDOC); m.enable(F_REGIVA); m.enable(F_PROTIVA); m.enable(F_NUPROTIVA); m.enable(F_CODCAUS); m.enable(F_CODPAG); m.enable(F_PROVV); m.disable(F_GRUPPO); m.disable(F_CONTO); m.disable(F_SOTTOCONTO); m.disable(F_SEZIONE); m.disable(F_IMPORTO); m.disable(F_DESCR); m.disable(F_GRUPPOC); m.disable(F_CONTOC); m.disable(F_SOTTOC); } else { int gruppo = _trmov->get_int (RMV_GRUPPO); int conto = _trmov->get_int (RMV_CONTO); long sottocon = _trmov->get_long(RMV_SOTTOCONTO); TString sezione = _trmov->get (RMV_SEZIONE); TString descr = _trmov->get (RMV_DESCR); int gruppoc = _trmov->get_int (RMV_GRUPPOC); int contoc = _trmov->get_int (RMV_CONTOC); long sottoc = _trmov->get_long(RMV_SOTTOCONTOC); real importo = _trmov->get_real(RMV_IMPORTO); m.set(F_GRUPPO, gruppo); m.set(F_CONTO, conto); m.set(F_SOTTOCONTO, sottocon); m.set(F_SEZIONE, sezione); m.set(F_DESCR, descr); m.set(F_GRUPPOC, gruppoc); m.set(F_CONTOC, contoc); m.set(F_SOTTOC, sottoc); m.set(F_IMPORTO, importo.string()); m.disable(F_DATAREG); m.disable(F_DATACOMP); m.disable(F_DATADOC); m.disable(F_NUMDOC); m.disable(F_REGIVA); m.disable(F_PROTIVA); m.disable(F_NUPROTIVA); m.disable(F_CODCAUS); m.disable(F_CODPAG); m.disable(F_PROVV); m.enable(F_GRUPPO); m.enable(F_CONTO); m.enable(F_SOTTOCONTO); m.enable(F_SEZIONE); m.enable(F_IMPORTO); m.enable(F_DESCR); m.enable(F_GRUPPOC); m.enable(F_CONTOC); m.enable(F_SOTTOC); } } bool TVar_mov::setta_campi_maschera_iva(TMask& m) { TDate datareg (_rec_mov->get_date(MOV_DATAREG)); TDate data74ter (_rec_mov->get_date(MOV_DATA74TER)); int meseliq = _rec_mov->get_int(MOV_MESELIQ); TString regiva = _rec_mov->get (MOV_REG); regiva.trim(); TString codcaus = _rec_mov->get (MOV_CODCAUS); long codcf = _rec_mov->get_long(MOV_CODCF); TString ocfpi = _rec_mov->get (MOV_OCFPI); char provvis = _rec_mov->get_char(MOV_PROVVIS); /***************************************************** ***** CLIENTI OCCASIONALI ***** *****************************************************/ TString ragsoc,ind,com,cap,localita,prov,civ; if (ocfpi.not_empty()) { _toccas->setkey(1); _toccas->zero(); _toccas->put(OCC_CFPI, ocfpi); if (_toccas->read() == NOERR) { ragsoc = _toccas->get(OCC_RAGSOC); ind = _toccas->get(OCC_INDIR); civ = _toccas->get(OCC_CIV); com = _toccas->get(OCC_COM); cap = _toccas->get(OCC_CAP); TLocalisamfile& comuni = *_comuni; comuni.setkey(1); comuni.zero(); comuni.put(COM_COM, com); if (comuni.read() == NOERR) { localita = comuni.get(COM_DENCOM); prov = comuni.get(COM_PROVCOM); } } } /*****************************************************/ if (codcaus.not_empty()) ricerca_codcaus(codcaus); int anno = datareg.year(); TRegistro rg (regiva, anno); _tiporeg = rg.tipo(); if (regiva.not_empty()) { if (!rg.ok()) return error_box(TR("Registrazione presente ma con PRIMANOTA ERRATA: correggerla prima")); } else return error_box(TR("Campo NON VALIDO o codice NON PRESENTE in archivio")); m.set(F_NUMREG, _numreg); m.set(F_NUMRIG, _numrig); m.set(F_DATA74TER, data74ter.string()); m.set(F_MESELIQ, meseliq); m.set(F_CODCF, codcf); m.set(F_RAGSOCOCC, ragsoc); m.set(F_INDOCC, ind); m.set(F_CIVOCC, civ); m.set(F_LOCALITA, localita); m.set(F_CAPOCC, cap); m.set(F_PROVOCC, prov); m.set(F_COMOCC, com); m.set(F_CFPI, ocfpi); m.set(F_PROVV, provvis); m.disable(F_NUMREG); m.disable(F_NUMRIG); if (!_righe) { m.enable(F_DATA74TER); m.enable(F_MESELIQ); m.enable(F_CODCF); m.enable(F_RAGSOCOCC); m.enable(F_INDOCC); m.enable(F_CIVOCC); m.enable(F_LOCALITA); m.enable(F_CAPOCC); m.enable(F_PROVOCC); m.disable(F_PROVV); // CM000232 m.disable(F_IMPONIBILE); m.disable(F_CODIVA); m.disable(F_IMPOSTA); m.disable(F_TIPODET); m.disable(F_TIPOCR); m.disable(F_GRUPPO); m.disable(F_CONTO); m.disable(F_SOTTOCONTO); } else { TString tipodoc(_rec_mov->get(MOV_TIPODOC)); real imponibile (_tiva->get_real(RMI_IMPONIBILE)); TString codiva (_tiva->get (RMI_CODIVA)); real imposta (_tiva->get_real(RMI_IMPOSTA)); int tipodet = _tiva->get_int (RMI_TIPODET); int tipocr = _tiva->get_int (RMI_TIPOCR); int gruppo = _tiva->get_int (RMI_GRUPPO); int conto = _tiva->get_int (RMI_CONTO); long sottoc = _tiva->get_long(RMI_SOTTOCONTO); const bool first_time = _rec_mov->get("TOCFP") != "X"; if ((tipodoc == "NC" || tipodoc == "ST") && !first_time) { imponibile *= -1; imposta *= -1; } m.set(F_IMPONIBILE, imponibile.string()); m.set(F_CODIVA, codiva); m.set(F_IMPOSTA, imposta.string()); m.set(F_TIPODET, tipodet); m.set(F_TIPOCR, tipocr); m.set(F_GRUPPO, gruppo); m.set(F_CONTO, conto); m.set(F_SOTTOCONTO, sottoc); m.disable(F_DATA74TER); m.disable(F_MESELIQ); m.disable(F_CODCF); m.disable(F_RAGSOCOCC); m.disable(F_INDOCC); m.disable(F_CIVOCC); m.disable(F_LOCALITA); m.disable(F_CAPOCC); m.disable(F_PROVOCC); m.disable(F_PROVV); m.enable(F_IMPONIBILE); m.enable(F_CODIVA); m.enable(F_IMPOSTA); m.enable(F_TIPODET); m.enable(F_TIPOCR); m.enable(F_GRUPPO); m.enable(F_CONTO); m.enable(F_SOTTOCONTO); } return TRUE; } bool TVar_mov::codice_registro_hnd(TMask_field& f, KEY k) { TTable reg ("REG"); TString descr,dep; if (k == K_TAB || k == K_ENTER) { TString codreg = f.get(); TDate datareg (f.mask().get(F_DATAREG)); int anno = datareg.year(); dep.format("%04d%-3s", anno, (const char*) codreg); reg.zero(); reg.put("CODTAB", dep); if (reg.read() == NOERR) { descr = reg.get("S0"); f.mask().set(F_DESCRREG, descr); } else if (codreg.not_empty() && f.mask().is_running()) { descr = ""; f.mask().set(F_DESCRREG, descr); return warning_box(TR("Codice registro IVA non presente in tabella")); } } return TRUE; } bool TVar_mov::codice_causale_hnd(TMask_field& f, KEY k) { if (k == K_TAB || k == K_ENTER) { TString codcau = f.get(); if (f.mask().is_running()) { TString codreg = f.mask().get(F_REGIVA); if (codreg.not_empty()) if (codcau.empty()) return warning_box(TR("Il codice registro IVA e' significativo: deve essere significativo anche il codice causale")); } TLocalisamfile& cau = *app()._causali; cau.setkey(1); cau.zero(); cau.put("CODCAUS", codcau); if (cau.read() == NOERR) { const TString& descr = cau.get("DESCR"); f.mask().set(F_DESCRCAU, descr); } else if (f.mask().is_running()) { const TString& descr = ""; f.mask().set(F_DESCRCAU, descr); return warning_box(TR("Codice causale non presente in tabella")); } } return TRUE; } bool TVar_mov::numero_protocollo_hnd(TMask_field& f, KEY k) { if (k != K_ENTER) return FALSE; TString codreg = f.mask().get(F_REGIVA); long protiva = atol(f.mask().get(F_PROTIVA)); long uprotiva = atol(f.mask().get(F_NUPROTIVA)); if (codreg.empty()) if (protiva != 0) return warning_box(TR("Il codice registro IVA non e' significativo: non e' possibile compilare il numero protocollo IVA")); return TRUE; } bool TVar_mov::ultimo_protocollo_hnd(TMask_field& f, KEY k) { if (k != K_ENTER) return FALSE; TString codreg = f.mask().get(F_REGIVA); long protiva = atol(f.mask().get(F_PROTIVA)); long uprotiva = atol(f.mask().get(F_NUPROTIVA)); if (codreg.empty()) if (uprotiva != 0) return warning_box(TR("Il codice registro IVA non e' significativo: non e' possibile compilare l' ultimo numero protocollo IVA")); if (protiva == 0) if (uprotiva != 0) return warning_box(TR("Numero protocollo IVA non significativo: non e' possibile compilare il numero protocollo IVA riepilogato")); return TRUE; } bool TVar_mov::codice_pagamento_hnd(TMask_field& f, KEY k) { TTable pag ("%CPG"); TString descr,codpag,dep; if (k == K_TAB || k == K_ENTER) { codpag = f.get(); dep.format("%04s", (const char*)codpag); pag.zero(); pag.put("CODTAB", dep); if (pag.read() == NOERR) { descr = pag.get("S0"); f.mask().set(F_DESCRPAG, descr); } else if (codpag.not_empty() && k == K_ENTER) { descr = ""; f.mask().set(F_DESCRPAG, descr); return warning_box(TR("Codice pagamento non presente in tabella")); } } return TRUE; } bool TVar_mov::data_competenza_hnd(TMask_field& f, KEY k) { if (k == K_TAB || k == K_ENTER) { const TDate dr(f.mask().get(F_DATAREG)); // Data operazione if (f.mask().is_running()) if ( !(TDate::isdate(f.get())) ) return warning_box(TR("Data errata o formato non valido")); TString16 datacomp = f.get(); if (datacomp.empty()) { int anno = atoi(f.mask().get(F_ANNO)); app().datacompetenza(anno,datacomp); f.set(datacomp); } TDate dc (f.get()); int ae = date2esc(dc); if (ae) { int pr; // Esercizio precedente const int ar = date2esc(dr); // Esercizio in corso pr = app()._ec.pred(ar); if (ae != ar && ae != pr) { TString80 e; e << TR("La data di competenza deve appartenere all'esercizio ") << ar; if (pr > 0) e << TR(" o al ") << pr; return f.error_box(e); } f.mask().set(F_ANNO, ae); } else { if (f.mask().is_running()) return f.error_box(TR("La data non appartiene a nessun esercizio")); } } return TRUE; } bool TVar_mov::data_stampa(TMask_field& f, KEY k) { if (k == K_ENTER) { if (f.mask().is_running()) if ( !(TDate::isdate(f.get())) ) return warning_box(TR("Data errata o formato non valido")); TDate datareg (f.mask().get(F_DATAREG)); const int ae = datareg.year(); TLibro_giornale gio; gio.read(ae); //se _ae e' zero la read considera come anno quello corrente if (datareg < gio.last_print()) return warning_box(TR("La data di registrazione e' minore della data di stampa del Libro Giornale")); TString codreg = f.mask().get(F_REGIVA); if (!codreg.blank()) //movimento iva (fattura) { TRegistro rg (codreg, ae); if (datareg < rg.last_print()) return error_box(TR("La data di registrazione e' minore della data stampa del registro IVA")); } } return TRUE; } bool TVar_mov::controllo_partita(TMask_field& f, KEY k) { if (k == K_TAB || k == K_ENTER) { int gruppo = f.mask().get_int (F_GRUPPO); int conto = f.mask().get_int (F_CONTO); long sottoc = f.mask().get_long(F_SOTTOCONTO); char tipo = app().TipoConto(gruppo,conto); TBill tc (gruppo,conto,sottoc,tipo); TString descr = tc.descrizione(); f.mask().set(F_DESCRPARTITA, descr); if (k == K_ENTER) if (!tc.find()) return warning_box(TR("Sottoconto partita non presente in anagrafica Piano dei Conti oppure anagrafica Clienti / Fornitori")); } return TRUE; } bool TVar_mov::controllo_contropartita(TMask_field& f, KEY k) { if (k == K_TAB || k == K_ENTER) { int gruppo = f.mask().get_int (F_GRUPPOC); int conto = f.mask().get_int (F_CONTOC); long sottoc = f.mask().get_long(F_SOTTOC); char tipo = app().TipoConto(gruppo,conto); TBill tc (gruppo,conto,sottoc,tipo); TString descr = tc.descrizione(); f.mask().set(F_DESCRCPARTITA, descr); if (k == K_ENTER) if (gruppo != 0 && conto != 0 && sottoc != 0) if (!tc.find()) return warning_box(TR("Sottoconto contropartita non presente in anagrafica Piano dei Conti oppure anagrafica Clienti / Fornitori")); } return TRUE; } bool TVar_mov::controllo_importo(TMask_field& f, KEY k) { if (k == K_ENTER) { real importo (f.mask().get(F_IMPORTO)); char sezione = f.mask().get(F_SEZIONE)[0]; if (importo == ZERO && (sezione == 'A' || sezione == 'D') ) return warning_box(TR("L' importo deve essere significativo")); if (sezione == '\0' && importo != ZERO) return warning_box(TR("La sezione e' nulla: l'importo non puo' essere significativo")); } return TRUE; } bool TVar_mov::codice_clifo_hnd(TMask_field& f, KEY k) { char tipo; if (k == K_TAB || k == K_ENTER) { long codcf = atol(f.get()); if (app()._tiporeg == 1) tipo = 'C'; else if (app()._tiporeg == 2) tipo = 'F'; TBill tc (0,0,codcf,tipo); if (tc.find()) { TString descr = tc.descrizione(); f.mask().set(F_RAGSOCCF, descr); } else if (k == K_ENTER) { TString descr = ""; f.mask().set(F_RAGSOCCF, descr); return warning_box(TR("Campo NON VALIDO o codice non presente in archivio")); } } return TRUE; } bool TVar_mov::localita_occasionali(TMask_field& f, KEY k) { if (k == K_TAB) { TString com,den,prov,cap; com = ""; den = ""; prov = ""; cap = ""; TString localita = f.mask().get(F_LOCALITA); com = app()._tras_file.cerca_comune_den(localita); if (com.not_empty()) app().ricerca_localita(com,den,cap,prov); f.mask().set(F_COMOCC, com); f.mask().set(F_LOCALITA, den); f.mask().set(F_CAPOCC, cap); f.mask().set(F_PROVOCC, prov); } return TRUE; } bool TVar_mov::cap_occasionali(TMask_field& f, KEY k) { if (k == K_TAB) { TString com,den,prov,cap; den = ""; prov = ""; cap = ""; com = ""; TString capocc = f.mask().get(F_CAPOCC); if (capocc.not_empty()) com = app()._tras_file.cerca_comune_cap(capocc,den); if (com.not_empty()) app().ricerca_localita(com,den,cap,prov); f.mask().set(F_COMOCC, com); f.mask().set(F_LOCALITA, den); f.mask().set(F_CAPOCC, cap); f.mask().set(F_PROVOCC, prov); } return TRUE; } bool TVar_mov::codice_iva_hnd(TMask_field& f, KEY k) { if (k == K_TAB || k == K_ENTER) { TString codiva = f.get(); bool ok = app().decodifica_codiva(codiva); f.mask().set(F_DESCRCODIVA, app()._descr_civa); if (k == K_ENTER) { real imponibile (f.mask().get(F_IMPONIBILE)); real imposta (f.mask().get(F_IMPOSTA)); if ( (imponibile != ZERO || imposta != ZERO) && codiva.empty() ) return warning_box(TR("Il codice IVA deve essere indicato obbligatoriamente")); if (codiva.not_empty()) if (!ok) return warning_box(TR("Codice non presente in tabella")); } } return TRUE; } bool TVar_mov::decodifica_codiva(const TString& codiva) { TTable iva ("%IVA"); TString dep; dep.format("%-4s", (const char*)codiva); iva.zero(); iva.put("CODTAB", dep); if (iva.read() == NOERR) { _descr_civa = iva.get("S0"); return TRUE; } else { _descr_civa = ""; return FALSE; } return TRUE; } bool TVar_mov::imposta_hnd(TMask_field& f, KEY k) { if (k == K_ENTER) { real imposta (f.mask().get(F_IMPOSTA)); if (app()._corrisp && imposta != ZERO) return warning_box(TR("Il movimento e' relativo ad un corrispettivo: l'imposta deve essere uguale a 0")); } return TRUE; } bool TVar_mov::detraibilita_hnd(TMask_field& f, KEY k) { if (k == K_ENTER) { int det = atoi(f.get()); if (det != 0 && det != 1 && det != 3 && det != 9) return warning_box(TR("Valore non ammesso per il tipo detraibilita'")); } return TRUE; } bool TVar_mov::tipocr_hnd(TMask_field& f, KEY k) { if (k == K_ENTER) { int tcr = atoi(f.get()); if (tcr != 0 && tcr != 1 && tcr != 2 && tcr != 3 && tcr != 4 && tcr != 5 && tcr != 8 && tcr != 9) return warning_box(TR("Valore non ammesso per il tipo costo/ricavo")); } return TRUE; } bool TVar_mov::data(TMask_field& f, KEY k) { if (k == K_ENTER) { if ( !(TDate::isdate(f.get())) ) return warning_box(TR("Data errata o formato non valido")); } return TRUE; } void TVar_mov::datacompetenza(int anno, TString& datacomp) { TTable esc ("ESC"); TString dep (format("%04d", anno)); esc.zero(); esc.put("CODTAB", dep); if (esc.read() == NOERR) datacomp = esc.get("D1"); else datacomp = ""; } void TVar_mov::ricerca_localita(TString& codcom, TString& den, TString& cap, TString& prov) { TLocalisamfile& com = *_comuni; com.setkey(1); com.zero(); com.put(COM_COM, codcom); if (com.read() == NOERR) { den = com.get(COM_DENCOM); cap = com.get(COM_CAPCOM); prov = com.get(COM_PROVCOM); } else { den = ""; cap = ""; prov = ""; } } void TVar_mov::registra_PN(TMask& m) { if (!_righe) { long numreg = m.get_long(F_NUMREG); int anno = m.get_int (F_ANNO); TDate datareg (m.get(F_DATAREG)); TDate datacomp (m.get(F_DATACOMP)); TDate datadoc (m.get(F_DATADOC)); TString numdoc = m.get (F_NUMDOC); TString regiva = m.get (F_REGIVA); long protiva = m.get_long(F_PROTIVA); long nuprotiva = m.get_long(F_NUPROTIVA); TString codcaus = m.get(F_CODCAUS); TString codpag = m.get(F_CODPAG); char provvis = m.get(F_PROVV)[0]; registra_file_temp_mov(anno,numreg,datareg,datacomp,datadoc,numdoc,regiva,protiva,nuprotiva,codcaus,codpag,provvis); } else { long numreg = m.get_long(F_NUMREG); int numrig = m.get_int (F_NUMRIG); int gruppo = m.get_int (F_GRUPPO); int conto = m.get_int (F_CONTO); long sottoc = m.get_long(F_SOTTOCONTO); char sezione = m.get (F_SEZIONE)[0]; TString descr = m.get (F_DESCR); int gruppoc = m.get_int (F_GRUPPOC); int contoc = m.get_int (F_CONTOC); long sottocc = m.get_long(F_SOTTOC); real importo (m.get(F_IMPORTO)); registra_file_temp_rmov(numreg,numrig,gruppo,conto,sottoc,sezione,descr,gruppoc,contoc,sottocc,importo); } } void TVar_mov::registra_file_temp_mov(int ae,long nr, const TDate& dr,const TDate& dc,const TDate& dd, const TString& nd,TString& ri, long pi,long upi, const TString& cc, TString& cp, char pr) { _tmov->setkey(1); _tmov->zero(); _tmov->put(MOV_NUMREG, nr); if (_tmov->read() == NOERR) { _tmov->put(MOV_NUMREG, nr); _tmov->put(MOV_ANNOES, ae); _tmov->put(MOV_DATAREG, dr); _tmov->put(MOV_DATACOMP, dc); _tmov->put(MOV_DATADOC, dd); _tmov->put(MOV_NUMDOC, nd); _tmov->put(MOV_REG, ri); _tmov->put(MOV_PROTIVA, pi); _tmov->put(MOV_UPROTIVA, upi); _tmov->put(MOV_CODCAUS, cc); _tmov->put(MOV_CODPAG, cp); _tmov->put(MOV_ANNOIVA, dr.year()); _tmov->put(MOV_PROVVIS, pr); _tmov->rewrite(); } TRectype* rec_rmov,* rec_riva; rec_rmov = new TRectype (LF_RMOV); _trmov->setkey(1); _trmov->zero(); _trmov->put(RMV_NUMREG, nr); *rec_rmov = _trmov->curr(); for (_trmov->read(); !_trmov->eof(); _trmov->next()) { if (_trmov->curr() > *rec_rmov) break; _trmov->put(RMV_ANNOES, ae); _trmov->put(RMV_DATAREG, dr); _trmov->rewrite(); } delete rec_rmov; rec_riva = new TRectype (LF_RMOVIVA); _tiva->setkey(1); _tiva->zero(); _tiva->put(RMI_NUMREG, nr); *rec_riva = _tiva->curr(); for (_tiva->read(); !_tiva->eof(); _tiva->next()) { if (_tiva->curr() > *rec_riva) break; _tiva->put(RMI_ANNOES, ae); _tiva->rewrite(); } delete rec_riva; } void TVar_mov::registra_file_temp_rmov(long nr,int nri,int g,int c,long s,char sez,const TString& desc, int gc,int cc,long sc,const real& imp) { _trmov->setkey(1); _trmov->zero(); _trmov->put(RMV_NUMREG, nr); _trmov->put(RMV_NUMRIG, nri); if (_trmov->read() == NOERR) { _trmov->put(RMV_GRUPPO, g); _trmov->put(RMV_CONTO, c); _trmov->put(RMV_SOTTOCONTO, s); _trmov->put(RMV_SEZIONE, sez); _trmov->put(RMV_DESCR, desc); _trmov->put(RMV_GRUPPOC, gc); _trmov->put(RMV_CONTOC, cc); _trmov->put(RMV_SOTTOCONTOC, sc); _trmov->put(RMV_IMPORTO, imp); _trmov->rewrite(); } } void TVar_mov::registra_IVA(TMask& m) { TString ocfpi; if (!_righe) { long numreg = m.get_long(F_NUMREG); TDate data74ter (m.get(F_DATA74TER)); int meseliq = m.get_int(F_MESELIQ); long codcf = m.get_long(F_CODCF); /***************************************************** ***** CLIENTI OCCASIONALI ***** *****************************************************/ TString ragsococc = m.get (F_RAGSOCOCC); TString indocc = m.get (F_INDOCC); TString civocc = m.get (F_CIVOCC); TString localita = m.get (F_LOCALITA); TString capocc = m.get (F_CAPOCC); TString comocc = m.get (F_COMOCC); TString com; if (ragsococc.not_empty()) { ocfpi = m.get (F_CFPI); // Se il cliente occasionale non esisteva su questo movimento e da maschera l'ho // aggiunto devo determinare con quale codice memorizzarlo sul file dove non esiste // Sara' il successivo all'ultimo esistente sul file. if (ocfpi.empty()) { TString app; long progr; _toccas->last(); ocfpi = _toccas->get(OCC_CFPI); app = ocfpi.mid(0,3); if (app == "RIC") progr = atol(ocfpi.mid(3,6)); else progr = 0; progr++; ocfpi = format("%3s%6ld", (const char*) "RIC", progr); } // Se invece gia' esisteva sul movimento il campo della maschera nascosto contiene gia' // il valore e mi basta fare una rewrite(). _toccas->setkey(1); _toccas->zero(); _toccas->put(OCC_CFPI, ocfpi); if (_toccas->read() == NOERR) { _toccas->put(OCC_RAGSOC, ragsococc); _toccas->put(OCC_INDIR, indocc); _toccas->put(OCC_CIV, civocc); _toccas->put(OCC_COM, comocc); _toccas->put(OCC_CAP, capocc); _toccas->rewrite(); } else { _toccas->put(OCC_CFPI, ocfpi); _toccas->put(OCC_RAGSOC, ragsococc); _toccas->put(OCC_INDIR, indocc); _toccas->put(OCC_CIV, civocc); _toccas->put(OCC_COM, comocc); _toccas->put(OCC_CAP, capocc); _toccas->write(); } } else { // Se esisteva e lo voglio cancellare devo toglierlo fisicamente dal file ocfpi = m.get (F_CFPI); if (ocfpi.not_empty()) { _toccas->setkey(1); _toccas->zero(); _toccas->put(OCC_CFPI, ocfpi); if (_toccas->read() == NOERR) { _toccas->remove(); ocfpi = ""; } } } /*****************************************************/ _tmov->setkey(1); _tmov->zero(); _tmov->put(MOV_NUMREG, numreg); if (_tmov->read() == NOERR) { _tmov->put(MOV_DATA74TER, data74ter); _tmov->put(MOV_MESELIQ, meseliq); _tmov->put(MOV_CODCF, codcf); _tmov->put(MOV_OCFPI, ocfpi); _tmov->rewrite(); } } else if (_righe) { TString tipodoc(_rec_mov->get(MOV_TIPODOC)); long numreg = m.get_long(F_NUMREG); int numrig = m.get_int (F_NUMRIG); real imponibile (m.get (F_IMPONIBILE)); TString codiva = m.get (F_CODIVA); real imposta (m.get (F_IMPOSTA)); int tipodet = m.get_int (F_TIPODET); int tipocr = m.get_int (F_TIPOCR); int gruppo = m.get_int (F_GRUPPO); int conto = m.get_int (F_CONTO); long sottoc = m.get_long(F_SOTTOCONTO); const bool first_time = _rec_mov->get("TOCFP") != "X"; if ((tipodoc=="NC" || tipodoc =="ST") && !first_time) { imponibile *= -1; imposta *= -1; } registra_file_temp_riva(numreg,numrig,imponibile,codiva,imposta,tipodet,tipocr,gruppo,conto,sottoc); } } void TVar_mov::registra_file_temp_riva(long nr,int nri,const real& imp,const TString& civa,const real& imposta, int tdet,int tcr,int g,int c,long s) { _tiva->setkey(1); _tiva->zero(); _tiva->put(RMI_NUMREG, nr); _tiva->put(RMI_NUMRIG, nri); if (_tiva->read() == NOERR) { _tiva->put(RMI_IMPONIBILE, imp); _tiva->put(RMI_CODIVA, civa); _tiva->put(RMI_IMPOSTA, imposta); _tiva->put(RMI_TIPODET, tdet); _tiva->put(RMI_TIPOCR, tcr); _tiva->put(RMI_GRUPPO, g); _tiva->put(RMI_CONTO, c); _tiva->put(RMI_SOTTOCONTO, s); _tiva->rewrite(); } } bool TVar_mov::leggi_trasfer() { _trasf = _tras_file.path(_dittaric); _trasf << HEADER; _tras_file.open(_trasf); if (_tras_file.exist()) { if (_tras_file.read_control_rec()) _control_rec = _tras_file.record(); else return error_box(TR("Rilevati gravi errori negli archivi:procedura interrotta")); } else return error_box(TR("Al momento non presenti trasferimenti attivi sulla ditta selezionata")); return TRUE; } bool TVar_mov::esegui_controlli() { TConfig conf(CONFIG_DITTA); _std = conf.get("FlStTra"); if (!prefix().exist(_dittaric)) return error_box(TR("Rilevati gravi errori negli archivi: procedura interrotta")); if (!leggi_trasfer()) return FALSE; if (!controlli()) return FALSE; return TRUE; } void TVar_mov::setta_parametri_record(const TString& sigla,const TString& flag) { TConfig conf (CONFIG_DITTA); conf.set("FlStTra", flag); leggi_record_controllo(); _control_rec.overwrite(sigla,240); const int size = 1024; _tras_file.write_control_rec(_control_rec, size); } bool TVar_mov::controlli() { TString16 chiave,sigla; chiave = _control_rec.sub(241,256); chiave.trim(); sigla = _control_rec.sub(240,241); sigla.trim(); if (_std == "M" && sigla == "Z" && chiave != "") return error_box(TR("Variazione NON POSSIBILE: trasferimento movimenti gia' iniziato")); if (_std == "M" && sigla == "U") return error_box(TR("Variazione NON POSSIBILE: trasferimento movimenti gia' iniziato")); if (_std == TR("*")) { warning_box(TR("Trasferimento interamente completato: proseguire per cancellare il file")); _tras_file.remove_all(); setta_parametri_record(" "," "); return FALSE; } if (_std == "T") return error_box(TR("Variazione NON POSSIBILE: eseguire prima la ricezione delle tabelle")); return TRUE; } bool TVar_mov::menu(MENU_TAG m) { if (m == BAR_ITEM(1)) return main_loop(); return FALSE; } int cg6800 (int argc, char* argv[]) { switch (*argv[2]) { case 'P': { TVar_mov* main_app = new TVar_mov(*argv[2]); main_app->run(argc, argv,main_app->_titolo); delete main_app; } break; case 'I': { TVar_mov* main_app = new TVar_mov(*argv[2]); main_app->run(argc, argv,main_app->_titolo); delete main_app; } break; case 'B': { TVar_sc* a = new TVar_sc; a->run(argc, argv,TR("Variazione movimenti Saldaconto")); delete a; } break; case 'S': { TDitta_ric* a = new TDitta_ric; a->run(argc, argv,TR("Scelta ditta per ricezione")); delete a; } break; case 'A': { TAnn_mov* a = new TAnn_mov; a->run(argc, argv,TR("Annullamento movimenti da ricevere")); delete a; } break; case 'V': { TVis_ric* a = new TVis_ric; a->run(argc, argv,TR("Visualizzazione stato ricezione")); delete a; } break; default: break; } //main_app.run(argc, argv,main_app._titolo); return TRUE; }