From 35fc696ada7eaccc8a035f4dcc1bcfe2865dcea9 Mon Sep 17 00:00:00 2001 From: nik Date: Tue, 18 Apr 1995 13:40:57 +0000 Subject: [PATCH] Aggiunto invio contabilita' git-svn-id: svn://10.65.10.50/trunk@1263 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- cg/cg2.cpp | 6 +- cg/cg2.h | 2 + cg/cg2.url | 6 + cg/cg2500.cpp | 663 +++++++++++++++ cg/cg2900.cpp | 2099 ++++++++++++++++++++++++++++++++++++++++++++++++ cg/cg2900.h | 15 + cg/cg2900a.uml | 62 ++ cg/cg2900b.uml | 34 + cg/cglib04.cpp | 6 +- cg/cglib04.h | 2 +- 10 files changed, 2891 insertions(+), 4 deletions(-) create mode 100755 cg/cg2500.cpp create mode 100755 cg/cg2900.cpp create mode 100755 cg/cg2900.h create mode 100755 cg/cg2900a.uml create mode 100755 cg/cg2900b.uml diff --git a/cg/cg2.cpp b/cg/cg2.cpp index 3f0247d85..1d1b215cc 100755 --- a/cg/cg2.cpp +++ b/cg/cg2.cpp @@ -14,13 +14,17 @@ int main(int argc,char** argv) case 2: cg2300(argc, argv); break; case 3: - cg2400(argc, argv); break; + cg2400(argc, argv); break; + case 4: + cg2500(argc, argv); break; case 5: cg2600(argc, argv); break; case 6: cg2700(argc, argv); break; case 7: cg2800(argc, argv); break; + case 8: + cg2900(argc, argv); break; default: cg2100(argc, argv); break; } diff --git a/cg/cg2.h b/cg/cg2.h index 404837d80..e35050d86 100755 --- a/cg/cg2.h +++ b/cg/cg2.h @@ -5,8 +5,10 @@ int cg2100(int argc, char** argv); int cg2200(int argc, char** argv); int cg2300(int argc, char* argv[]); int cg2400(int argc, char* argv[]); +int cg2500(int argc, char* argv[]); int cg2600(int argc, char* argv[]); int cg2700(int argc, char* argv[]); int cg2800(int argc, char* argv[]); +int cg2900(int argc, char* argv[]); #endif // __CG2_H diff --git a/cg/cg2.url b/cg/cg2.url index 5d4fbdd03..da6de7cd8 100755 --- a/cg/cg2.url +++ b/cg/cg2.url @@ -37,3 +37,9 @@ MENUBAR MENU_BAR(7) MENU MENU_BAR(7) SUBMENU MENU_FILE "~File" + +MENUBAR MENU_BAR(8) + +MENU MENU_BAR(8) + SUBMENU MENU_FILE "~File" + diff --git a/cg/cg2500.cpp b/cg/cg2500.cpp new file mode 100755 index 000000000..99f251c72 --- /dev/null +++ b/cg/cg2500.cpp @@ -0,0 +1,663 @@ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "..\ba\batbind.h" +#include "cglib04.h" + +HIDDEN TString80 TEMP; + +class Tabinv_application : public Tab_application +{ +private: + TMask* _msk; + TString _tabname; + TTransfer_file _tras_file; + + TString _trasf,_control_rec; + long _ditta_tab, _ditta_tras; + bool _disable,_ditte_uguali,_salta_hnd; + +public: + bool user_create(); + virtual void init_query_mode(TMask&); + virtual void init_modify_mode(TMask&); + virtual void init_insert_mode(TMask&); + virtual int write(const TMask& m); + virtual int rewrite(const TMask& m); + + void leggi_trasfer(); + void confronta_ditta(); + char cerca_stato(long codditta); + void codifica_ditta(TMask& m); + void tabella_ditta(TMask& m); + + //void esegui_controlli(TMask& m); + static bool controlli_hnd (TMask_field& f, KEY k); + + static bool nascosto_handler(TMask& m, KEY k); + static bool stato_invio (TMask_field& f, KEY k); + + static bool ditta_handler (TMask_field& f, KEY k); + static bool almeno_un_flag(TMask_field& f, KEY k); + static bool clifo_comune (TMask_field& f, KEY k); + static bool pcon_comune (TMask_field& f, KEY k); + static bool prima_nota (TMask_field& f, KEY k); + static bool data_invio (TMask_field& f, KEY k); + static bool sigla_file (TMask_field& f, KEY k); + static bool chiave_file (TMask_field& f, KEY k); + + static bool nome_id (TMask_field& f, KEY k); + + const char* riconverti(TString& data_PC); + + Tabinv_application() {} + virtual ~Tabinv_application() {} +}; + +HIDDEN inline Tabinv_application& app() {return (Tabinv_application&) main_app();} + +const char* Tabinv_application::riconverti (TString& data_PC) +{ + TEMP = data_PC.mid(8,2); + TEMP << data_PC.mid(3,2); + TEMP << data_PC.mid(0,2); + return TEMP; +} + +char Tabinv_application::cerca_stato(long ditta) +{ + TTable ind ("%IND"); + TString dep; + char stato = '\0'; + + dep = format("%05d", ditta); + + ind.zero(); + ind.put("CODTAB", dep); + if (ind.read() == NOERR) + stato = ind.get_char("S6"); + + return stato; +} + +bool Tabinv_application::nascosto_handler(TMask& m, KEY k) +{ + if (k == K_SHIFT+K_F12) + { + if (app()._tabname == "%IND") + { + app()._disable = FALSE; + + m.enable(F_NUMULINV); + m.enable(F_DATAULIN); + m.enable(F_STATO); + + if (app()._ditta_tab == app()._ditta_tras) + { + m.enable(F_USELAB); + m.enable(F_CHIAVE); + } + } + else + if (app()._tabname == "%INS") + { + m.enable(F_DITTAINV); + app()._salta_hnd = TRUE; + } + } + + return TRUE; +} + +bool Tabinv_application::stato_invio(TMask_field& f, KEY k) +{ + if ( (k == K_ENTER || k == K_TAB) && f.mask().mode() != MODE_QUERY ) + { + if ( k == K_ENTER) + { + TString stato = f.get(); + int num = f.mask().get_int(F_NUMULINV); + + if (num == 0 && stato != "") + return warning_box("Numero ultimo invio NON INDICATO: impossibile indicare lo stato ultimo invio"); + } + + if (k == K_TAB) + { + long codditta = f.mask().get_long(F_DITTAINV); + + char stato = app().cerca_stato(codditta); + + if (stato != '\0' && app()._disable) + return warning_box("Rilevato STATO DI RIPARTENZA: prima concludere il trasferimento"); + } + } + + return TRUE; +} + +bool Tabinv_application::ditta_handler(TMask_field& f, KEY k) +{ + if (k == K_TAB && f.mask().mode() == MODE_QUERY) + { + long codditta = f.mask().get_long(F_DITTAINV); + + if (codditta != 0) + { + if (!prefix().exist(codditta)) + { + f.error_box("La ditta selezionata non e' abilitata per la contabilita' "); + return FALSE; + } + } + } + return TRUE; +} + +bool Tabinv_application::almeno_un_flag(TMask_field& f, KEY k) +{ + if (k == K_ENTER && f.mask().mode() != MODE_QUERY) + { + bool cau = f.mask().get_bool(F_CAUSALI); + bool clifo = f.mask().get_bool(F_CLIFO); + bool pcon = f.mask().get_bool(F_PCON); + bool pn = f.mask().get_bool(F_MOV); + bool iva = f.mask().get_bool(F_IVA); + bool fat = f.mask().get_bool(F_FATT); + + if (!cau && !clifo && !pcon && !pn && !iva && !fat) + return warning_box("E' necessario indicare almeno una sigla file da trasferire"); + + long ditta = f.mask().get_long(F_DITTAINV); + + app().set_firm(ditta); + + TConfig conf (CONFIG_DITTA); + + TString pcon_cau = conf.get("PcTcCm","cg"); + + bool causali = f.mask().get_bool(F_CAUSALI); + + if (causali && pcon_cau != "") + return warning_box("Tabella causali in comune: impossibile trasferirla"); + } + + return TRUE; +} + +bool Tabinv_application::clifo_comune(TMask_field& f, KEY k) +{ + if (k == K_ENTER && f.mask().mode() != MODE_QUERY) + { + long ditta = f.mask().get_long(F_DITTAINV); + + app().set_firm(ditta); + + TConfig conf (CONFIG_DITTA); + + TString ana_com = conf.get("AnCfCm","cg"); + + bool clifo = f.mask().get_bool(F_CLIFO); + + if (clifo && ana_com != "") + return warning_box("Anagrafica clienti / fornitori in comune: impossibile trasferirla"); + } + + return TRUE; +} + +bool Tabinv_application::pcon_comune(TMask_field& f, KEY k) +{ + if (k == K_ENTER && f.mask().mode() != MODE_QUERY) + { + long ditta = f.mask().get_long(F_DITTAINV); + + app().set_firm(ditta); + + TConfig conf (CONFIG_DITTA); + + TString pcon_cau = conf.get("PcTcCm","cg"); + + bool pcon = f.mask().get_bool(F_PCON); + + if (pcon && pcon_cau != "") + return warning_box("Anagrafica Piano dei conti in comune: impossibile trasferirla"); + } + + return TRUE; +} + +bool Tabinv_application::prima_nota(TMask_field& f, KEY k) +{ + if (k == K_ENTER && f.mask().mode() != MODE_QUERY) + { + bool pn = f.mask().get_bool(F_MOV); + + if (!pn && (f.mask().get_bool(F_IVA) || f.mask().get_bool(F_FATT)) ) + return warning_box("Se si vuole inviare l' iva e' obbligatorio inviare anche la primanota"); + } + + return TRUE; +} + +bool Tabinv_application::data_invio (TMask_field& f, KEY k) +{ + if (k == K_ENTER && f.mask().mode() != MODE_QUERY) + { + int num = f.mask().get_int(F_NUMULINV); + TDate data (f.get()); + + if (num != 0 && !data.ok()) + return warning_box("Se indicato il numero deve essere indicata anche la data di invio"); + + if (num == 0 && data.ok()) + return warning_box("Se non indicato il numero non puo' essere indicata la data di invio"); + } + + return TRUE; +} + +bool Tabinv_application::sigla_file(TMask_field& f, KEY k) +{ + if (k == K_ENTER && f.mask().mode() != MODE_QUERY) + { + int num = f.mask().get_int(F_NUMULINV); + TString sigla = f.get(); + + if (num == 0 && sigla != "") + return warning_box("Numero ultimo invio NON INDICATO: impossibile indicare la sigla ultimo file elaborato"); + + TString stato = f.mask().get(F_STATO); + + if (stato != "F" && sigla != "") + return warning_box("La sigla ultimo file elaborato puo' essere indicata solo se lo stato ultimo invio e' F"); + } + + return TRUE; +} + +bool Tabinv_application::chiave_file(TMask_field& f, KEY k) +{ + if (k == K_ENTER && f.mask().mode() != MODE_QUERY) + { + TString sigla = f.mask().get(F_USELAB); + TString chiave = f.get(); + + if (sigla == "" && chiave != "") + return warning_box("Sigla ultimo file elaborato NON INDICATA: impossibile indicare la chiave ultimo record elaborato"); + + TString stato = f.mask().get(F_STATO); + + if (stato != "F" && chiave == "" && sigla != "") + return warning_box("La chiave ultimo record elaborato deve essere indicata obbligatoriamente"); + } + + return TRUE; +} + + +bool Tabinv_application::nome_id(TMask_field& f, KEY k) +{ + if (k == K_TAB && !app()._salta_hnd) + { + long codditta = f.mask().get_long(F_DITTAINV); + + if (codditta != 0) + return warning_box("Rilevato STATO DI RIPARTENZA: prima concludere il trasferimento"); + } + return TRUE; +} + +//void Tabinv_application::esegui_controlli(TMask& m) +bool Tabinv_application::controlli_hnd(TMask_field& f, KEY k) +{ + if (k == K_TAB && !f.mask().field(F_NUMULINV).enabled()) + { + int num = f.mask().get_int(F_NUMULINV); + TDate data (f.mask().get(F_DATAULIN)); + + if (num != 0 && !data.ok()) + return warning_box("Se indicato il numero deve essere indicata anche la data di invio"); + + if (num == 0 && data.ok()) + return warning_box("Se non indicato il numero non puo' essere indicata la data di invio"); + + TString sigla = f.mask().get(F_USELAB); + + if (num == 0 && sigla != "") + return warning_box("Numero ultimo invio NON INDICATO: impossibile indicare la sigla ultimo file elaborato"); + + TString stato = f.mask().get(F_STATO); + + if (stato != "F" && sigla != "") + return warning_box("La sigla ultimo file elaborato puo' essere indicata solo se lo stato ultimo invio e' F"); + + TString chiave = f.mask().get(F_CHIAVE); + + if (sigla == "" && chiave != "") + return warning_box("Sigla ultimo file elaborato NON INDICATA: impossibile indicare la chiave ultimo record elaborato"); + + if (stato != "F" && chiave == "" && sigla != "") + return warning_box("La chiave ultimo record elaborato deve essere indicata obbligatoriamente"); + } + return TRUE; +} + +void Tabinv_application::leggi_trasfer() +{ + _trasf = ""; + _trasf = firm2dir(0); + _trasf << "\\trasfer"; + + _tras_file.open(_trasf); + + if (_tras_file.exist()) + { + if (_tras_file.read_control_rec()) + { + _control_rec = _tras_file.record(); + _ditta_tras = atol(_control_rec.sub(25,29)); + } + else + _ditta_tras = 0; + } + else + _ditta_tras = 0; +} + +void Tabinv_application::confronta_ditta() +{ + _ditta_tab = _msk->get_long(F_DITTAINV); + + if (_ditta_tab == _ditta_tras) + { + TString uselab = _tras_file.ult_file(); + TString chiave = _tras_file.key(); + + _msk->set(F_USELAB, uselab); + _msk->set(F_CHIAVE, chiave); + _ditte_uguali = TRUE; + } + else + _ditte_uguali = FALSE; +} + +void Tabinv_application::codifica_ditta(TMask& m) +{ + TLocalisamfile ditte ( LF_NDITTE); + + long ditta = m.get_long(F_DITTAINV); + + ditte.setkey(1); + ditte.zero(); + ditte.put(NDT_CODDITTA, ditta); + if (ditte.read() == NOERR) + { + TString ragsoc = ditte.get(NDT_RAGSOC); + m.set(F_RAGSOC, ragsoc); + } +} + +void Tabinv_application::tabella_ditta(TMask& m) +{ + TTable ind ("%IND"); + TString dep; + + long ditta = m.get_long(F_DITTAINV); + + if (ditta != 0) + { + dep = format("%05d", ditta); + + ind.zero(); + ind.put("CODTAB", dep); + if (ind.read() == NOERR) + { + TString stato = ind.get_char("S6"); + int num = ind.get_int ("I0"); + TDate data = ind.get_date("D0"); + + m.set(F_STATO, stato); + m.set(F_NUMULINV, num); + m.set(F_DATAULIN, data.string()); + } + } +} + +void Tabinv_application::init_query_mode(TMask& m) +{ + leggi_trasfer(); + _disable = TRUE; + + if (_tabname == "%INS") + { + m.disable(F_DITTAINV); + long ditta = m.get_long(F_DITTAINV); + if (ditta != 0) + { + codifica_ditta(m); + tabella_ditta(m); + confronta_ditta(); + } + else + { + m.reset(F_NUMULINV); + m.reset(F_DATAULIN); + m.reset(F_STATO); + m.reset(F_USELAB); + m.reset(F_CHIAVE); + m.reset(F_RAGSOC); + } + } + + m.disable(F_NUMULINV); + m.disable(F_DATAULIN); + m.disable(F_STATO); + m.disable(F_USELAB); + m.disable(F_CHIAVE); +} + +void Tabinv_application::init_modify_mode(TMask& m) +{ + if (_tabname == "%IND") + { + leggi_trasfer(); + confronta_ditta(); + codifica_ditta(m); + //esegui_controlli(m); + } + + if (_tabname == "%INS") + { + m.disable(F_DITTAINV); + long ditta = m.get_long(F_DITTAINV); + if (ditta != 0) + { + codifica_ditta(m); + tabella_ditta(m); + confronta_ditta(); + } + else + { + m.reset(F_NUMULINV); + m.reset(F_DATAULIN); + m.reset(F_STATO); + m.reset(F_USELAB); + m.reset(F_CHIAVE); + m.reset(F_RAGSOC); + } + } + + m.disable(F_NUMULINV); + m.disable(F_DATAULIN); + m.disable(F_STATO); + m.disable(F_USELAB); + m.disable(F_CHIAVE); +} + +void Tabinv_application::init_insert_mode(TMask& m) +{ + if (_tabname == "%IND") + { + leggi_trasfer(); + confronta_ditta(); + codifica_ditta(m); + //esegui_controlli(m); + } + + if (_tabname == "%INS") + { + m.disable(F_DITTAINV); + long ditta = m.get_long(F_DITTAINV); + if (ditta != 0) + { + codifica_ditta(m); + tabella_ditta(m); + confronta_ditta(); + } + else + { + m.reset(F_NUMULINV); + m.reset(F_DATAULIN); + m.reset(F_STATO); + m.reset(F_USELAB); + m.reset(F_CHIAVE); + m.reset(F_RAGSOC); + } + } + + m.disable(F_NUMULINV); + m.disable(F_DATAULIN); + m.disable(F_STATO); + m.disable(F_USELAB); + m.disable(F_CHIAVE); +} + +int Tabinv_application::write(const TMask& m) +{ + if (_tabname == "%IND") + { + TString str; + + TString std = m.get(F_STATO); + + TConfig conf (CONFIG_DITTA); + conf.set("FlStInv", std); + + int num = m.get_int(F_NUMULINV); + TString data = m.get (F_DATAULIN); + TString sigla = m.get (F_USELAB); + TString chiave = m.get (F_CHIAVE); + + if (sigla == "") + sigla = " "; + + if (_tras_file.read_control_rec()) + { + if (_ditte_uguali) + { + _control_rec = _tras_file.record(); + str = format("%03d", num); + _control_rec.overwrite(str,29); + str = riconverti(data); + _control_rec.overwrite(str,32); + _control_rec.overwrite(sigla,240); + str = format("%-15s", (const char*) chiave); + _control_rec.overwrite(str,241); + + _tras_file.write_control_rec(_control_rec,256); + } + } + } + + return Tab_application::write(m); +} + +int Tabinv_application::rewrite(const TMask& m) +{ + if (_tabname == "%IND") + { + TString str; + + TString std = m.get(F_STATO); + + TConfig conf (CONFIG_DITTA); + conf.set("FlStInv", std); + + int num = m.get_int(F_NUMULINV); + TString data = m.get (F_DATAULIN); + TString sigla = m.get (F_USELAB); + TString chiave = m.get (F_CHIAVE); + + if (sigla == "") + sigla = " "; + + if (_tras_file.read_control_rec()) + { + if (_ditte_uguali) + { + _control_rec = _tras_file.record(); + str = format("%03d", num); + _control_rec.overwrite(str,29); + str = riconverti(data); + _control_rec.overwrite(str,32); + _control_rec.overwrite(sigla,240); + str = format("%-15s", (const char*) chiave); + _control_rec.overwrite(str,241); + + _tras_file.write_control_rec(_control_rec,256); + } + } + } + + return Tab_application::rewrite(m); +} + +bool Tabinv_application::user_create() +{ + Tab_application::user_create(); + + _msk = get_mask(); + _tabname = get_tabname(); + + if (_tabname == "%IND") + { + _msk->set_handler(nascosto_handler); + _msk->set_handler(F_STATO, stato_invio); + _msk->set_handler(F_DITTAINV, ditta_handler); + _msk->set_handler(F_CAUSALI, almeno_un_flag); + _msk->set_handler(F_CLIFO, clifo_comune); + _msk->set_handler(F_PCON, pcon_comune); + _msk->set_handler(F_MOV, prima_nota); + _msk->set_handler(F_DATAULIN, data_invio); + _msk->set_handler(F_USELAB, sigla_file); + _msk->set_handler(F_CHIAVE, chiave_file); + _msk->set_handler(F_GHOST_FIELD, controlli_hnd); + } + + if (_tabname == "%INS") + { + _msk->set_handler(nascosto_handler); + _msk->set_handler(F_DITTAINV, nome_id); + _salta_hnd = FALSE; + } + + return TRUE; +} + +cg2500(int argc, char* argv[]) +{ + Tabinv_application a; + + a.run(argc,argv, "Tabelle"); + return 0; +} + + diff --git a/cg/cg2900.cpp b/cg/cg2900.cpp new file mode 100755 index 000000000..48e19960f --- /dev/null +++ b/cg/cg2900.cpp @@ -0,0 +1,2099 @@ +// Invio contabilita' + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "cg2900.h" +#include "cglib04.h" + +HIDDEN TString80 TEMP; + +HIDDEN int date2esc(const TDate& d, int* prevesc = NULL); + +class TInv_cont : public TApplication +{ + enum { BUFSIZE = 4096 }; + + TTransfer_file _tras_file; + TProgind* _prog; + + TString _control_rec, _trasf, _std, _stato, _marker, _nome_simbolico; + TString _files, _codcaus, _numdoc, _reg, _codpag, _tipodoc, _codcausm; + TString _ocfpi, _ragsococc, _indocc, _capocc, _localocc, _provocc, _codvali; + bool _esiste_ditta, _esiste_record; + long _ditta, _protiva, _uprotiva, _codcf, _numrec, _tot_rec; + long _dim_tot, _dim_disk; + int _num; + TDate _data, _datadoc, _data74ter; + real _corrlire, _cambioi, _corrval; + +public: + virtual bool create(); + virtual bool destroy(); + virtual bool menu(MENU_TAG m); + + bool main_loop(); + + bool esiste_tabella_studio(); + bool record_controllo(); + bool esegui_controlli(); + bool leggi_trasfer(); + bool controlli(); + bool sub_controlli(); + bool tabella_ditta(); + bool controlla_stato_invio(); + bool numero_data(); + void leggi_record_controllo(); + void codifica_ditta (TMask& m); + bool testata_mov_PN (long numreg); + bool testata_mov_IVA(long numreg); + void cerca_occasionale(); + void cerca_comune_occas(const TString& com); + + void crea_marker(TMask& m); + void setta_parametri_record(TMask& m,const TString& flag); + void setta_tabella_studio(TMask& m, bool flag_ditta = TRUE); + void setta_tabella_ditta(TMask& m, const char* flag, bool comp = TRUE); + void crea_record_controllo(TMask& m); + + bool invio_contabilita(TMask& m); + bool invio_tab_cau(TString& key,TMask& m); + bool invio_clifo (TString& key,TMask& m); + bool invio_pcon (TString& key,TMask& m); + bool invio_mov_PN (TString& key,TMask& m); + bool invio_mov_IVA(TString& key,TMask& m); + + void aggiorna_marker(TString& token, int pos); + void calcola_totale_record(); + + const char* converti (TString& data_AS400); + const char* riconverti (TString& data_PC); + const char* cerca_provincia(const TString& comcf); + + static bool setta_maschera_hnd(TMask_field& f, KEY k); + + int calcola_numero_dischi(TMask& m); + FILE* chiedi_disco(const char* name, int disk, char floppy, bool lettura); + long determina_dimensione(FILE* f); + bool scrivi_disco(char floppy, int disk, const char* work, FILE* i, TProgind& w); + + TInv_cont() {}; +}; + +HIDDEN TInv_cont& app() { return (TInv_cont &) main_app(); } + +FILE* TInv_cont::chiedi_disco(const char* name, int disk, char floppy, bool lettura) +{ + message_box("Inserire il disco %d nel drive %c:", disk, floppy); + + // name.ext(format("%03d", disk)); + + FILE* f = NULL; + bool retry = TRUE; + while (retry) + { + f = fopen(name, lettura ? "rb" : "wb"); + if (f == NULL) + retry = yesno_box("Il file %s non e' accessibile: riprovare?", (const char*)name); + else + { + retry = FALSE; + fclose(f); + } + } + + return f; +} + +long TInv_cont::determina_dimensione(FILE* f) +{ + CHECK(f, "Can't measure NULL file"); + fseek(f, 0, SEEK_END); + const long s = ftell(f); + fseek(f, 0, SEEK_SET); + return s; +} + +bool TInv_cont::scrivi_disco(char floppy, int disk, const char* work, + FILE* i, TProgind& w) +{ + // const TFilename from(filename); // File da splittare + + // TFilename work; + // work << floppy << ":/" << from.name(); // File su dischetto + + chiedi_disco(work, disk, floppy, FALSE); + + TString str; + str.format("%02d", disk); + aggiorna_marker(str,31); // Aggiorna il num. progr. disco su marker + + TString path_m; + path_m << floppy << ":\\marker"; + + TString path_t; + path_t << floppy << ":\\trasfer"; + + fcopy(_marker,path_m); // Copia il marker su disco + + //FILE* i = fopen(from, "rb"); + FILE* o = fopen(path_t, "wb"); + + //if (i == NULL) return error_box("Impossibile aprire il file '%s'", from); + + //TProgind w(_dim_disk, "Trasferimento su dischetti in corso... Prego attendere", TRUE, TRUE, 40); + + TString buffer(BUFSIZE); + + long tot_scritti = BUFSIZE; + + while (tot_scritti <= _dim_disk) + { + const word letti = fread((char*)(const char*)buffer, 1, BUFSIZE, i); + + long scritti = fwrite((char*)(const char*)buffer, letti, 1, o); + + tot_scritti += letti; + + if (letti < BUFSIZE) break; + + w.addstatus(letti); + } + + //fclose(i); + fclose(o); + + return TRUE; +} + +bool TInv_cont::main_loop() +{ + TString str; + bool ripartenza = FALSE; + + if (!esiste_tabella_studio()) return FALSE; + + if (!esegui_controlli()) return FALSE; + + TMask msk ("cg2900a"); + KEY tasto; + + if (_ditta != 0) + { + msk.set(F_DITTAINV, _ditta); + msk.disable(F_DITTAINV); + codifica_ditta(msk); + msk.set(F_NUMULINV, _num); + msk.set(F_DATAULIN, _data.string()); + msk.set(F_STATO, _stato); + + TString uselab = _tras_file.ult_file(); + TString chiave = _tras_file.key(); + msk.set(F_USELAB, uselab); + msk.set(F_CHIAVE, chiave); + msk.set(F_DATALIM, _data.string()); + msk.disable(F_DATALIM); + + ripartenza = TRUE; + } + + msk.disable(F_NUMULINV); + msk.disable(F_DATAULIN); + msk.disable(F_STATO); + msk.disable(F_USELAB); + msk.disable(F_CHIAVE); + + if (!ripartenza) + msk.set_handler(F_DITTAINV, setta_maschera_hnd); + + tasto = msk.run(); + + if (tasto != K_ENTER) return FALSE; + + if (!ripartenza) + { + crea_marker(msk); //Crea il record con le informazioni sul marker + setta_parametri_record(msk,"F"); //Aggiorna parametri contabili ditta + setta_tabella_studio(msk); //Aggiorna la tabella studio per invio + setta_tabella_ditta(msk,"F"); //Aggiorna la tabella ditta per invio + crea_record_controllo(msk); //Crea il record di controllo sul file trasfer + } + + if (!invio_contabilita(msk)) + return FALSE; + + calcola_totale_record(); + str.format("%06ld", _tot_rec); + aggiorna_marker(str,23); + + TMask mask ("cg2900b"); + KEY k; + + k = mask.run(); + + if (k == K_ENTER) + { + int num_disk = calcola_numero_dischi(mask); + char floppy = mask.get(F_FLOPPY)[0]; + + str.format("%02d", num_disk); + aggiorna_marker(str,29); + + const TFilename from(_trasf); // File da splittare + + TFilename work; + work << floppy << ":/" << from.name(); // File su dischetto + + FILE* i = fopen(from, "rb"); + + if (i == NULL) return error_box("Impossibile aprire il file '%s'", from); + + TProgind w(_dim_tot, "Trasferimento su dischetti in corso... Prego attendere", TRUE, TRUE, 60); + + for (int j = 0; j < num_disk; j++) + { + scrivi_disco(floppy,j+1,work,i,w); + } + fclose(i); + + setta_tabella_studio(msk,FALSE); //Aggiorna la tabella studio per invio + setta_tabella_ditta(msk," ",FALSE); //Aggiorna la tabella ditta per invio + setta_parametri_record(msk," "); //Aggiorna parametri contabili ditta + + _tras_file.open(_trasf); + leggi_record_controllo(); + TString record(256); + record.format("%-256s",(const char*) record); + _control_rec.overwrite(record,0); + _tras_file.write_control_rec(_control_rec,256); + + fremove(_marker); + fremove(_trasf); + } + + return FALSE; +} + +int TInv_cont::calcola_numero_dischi(TMask& msk) +{ + int numdisc = 0; + + FILE* t = fopen(_trasf, "rb"); + if (t == NULL) return error_box("Impossibile aprire il file '%s'", _trasf); + + long dim_t = determina_dimensione(t); //Determina la dimensione del trasfer + fclose(t); + + FILE* m = fopen(_marker, "rb"); + if (m == NULL) return error_box("Impossibile aprire il file '%s'", _marker); + + long dim_m = determina_dimensione(m); // Determina la dimensione del marker + fclose(m); + + _dim_tot = dim_t + dim_m; // Determina la dimensione totale + + int item = msk.get_int(F_DIM); + + switch (item) + { + case 1 : + _dim_disk = 1400000; + break; + case 2 : + _dim_disk = 1200000; + break; + case 3 : + _dim_disk = 720000; + break; + case 4 : + _dim_disk = 360000; + break; + default : + break; + }; + + if (_dim_tot < _dim_disk) + numdisc = 1; + else + { + //double dischi = _dim_tot / _dim_disk; + //numdisc = (int)ceil(dischi); + numdisc = _dim_tot / _dim_disk; + if ( (_dim_tot % _dim_disk) != 0) + numdisc += 1; + } + + return numdisc; +} + +HIDDEN int date2esc(const TDate& d, int* prevesc) +{ + if (prevesc) *prevesc = 0; + TTable esc("ESC"); + for (int err = esc.first(); err == NOERR; err = esc.next()) + { + const TDate ia(esc.get("D0")); // Data inizio esercizio + const TDate fa(esc.get("D1")); // Data fine esercizio + const anno = esc.get_int("CODTAB"); + if (d >= ia && d <= fa) + return anno; + if (prevesc) *prevesc = anno; + } + return 0; +} + +bool TInv_cont::create() +{ + TApplication::create(); + + dispatch_e_menu (BAR_ITEM(1)); + + return TRUE; +} + +bool TInv_cont::destroy() +{ + return TApplication::destroy(); +} + +void TInv_cont::leggi_record_controllo() +{ + _tras_file.read_control_rec(); + _control_rec = _tras_file.record(); +} + +const char* TInv_cont::converti (TString& data_AS400) +{ + TEMP = data_AS400.mid(4,2); + TEMP << "-" <addstatus(1); + _tras_file.open(_trasf); + + record.spaces(); + + // Se trovo un codice causale alfanumerico l'invio deve essere interrotto + const char* codcau = cau.get(CAU_CODCAUS); + if (!real::is_natural(codcau)) + return error_box("Rilevato un codice causale alfanumerico nella causale %03s: impossibile proseguire",codcau); + str.format("%03s", codcau); + record.overwrite("W1",0); //Tipo record + record.overwrite(str,2); //Codice causale + + + //Salvataggio della sigla e della chiave sul record di controllo del file trasfer + leggi_record_controllo(); + TString chiave,app; + chiave.format("%2s%03s", (const char*) "W1", codcau); + app.format("%-15s", (const char*) chiave); + _control_rec.overwrite("W",240); + _control_rec.overwrite(app,241); + //_tras_file.write_control_rec(_control_rec,size); + //_tras_file.close(); + + TString descr = cau.get(CAU_DESCR); + descr.format("%-.20s", (const char*) descr); + record.overwrite(descr,15); //Descrizione + + TString tipodoc = cau.get(CAU_TIPODOC); + record.overwrite(tipodoc,35); //Tipo documento + + //Se trovo un registro IVA con lunghezza maggiore di 1 l'invio deve essere interrotto + TString reg = cau.get(CAU_REG); + if (reg.len() > 1) + return error_box("Rilevato un registro IVA con lunghezza superiore a 1 nella causale %03s: impossibile proseguire", codcau); + record.overwrite(reg,37); //Registro IVA + + bool alleg = cau.get_bool(CAU_ALLEG); + if (alleg) + record.overwrite("X",38); + else //Flag esclusione tipo documento da allegato + record.overwrite(" ",38); + + int m770 = atoi(cau.get(CAU_M770)); + str = format("%1d", m770); + record.overwrite(str,39); //Collegamento modello 770 + + TString cespiti = cau.get(CAU_COLLCESP); + record.overwrite(cespiti,40); //Collegamento cespiti + + bool numdoc = cau.get_bool(CAU_NUMDOC); + if (numdoc) + record.overwrite("1",206); + else //Flag immissione numero documento + record.overwrite("0",206); + + bool datadoc = cau.get_bool(CAU_DATADOC); + if (datadoc) + record.overwrite("1",207); + else //Flag immissione data documento + record.overwrite("0",207); + + const char* codcausim = cau.get(CAU_CODCAUSIM); + if (!real::is_natural(codcausim)) + return error_box("Rilevato un codice causale per incasso immediato alfanumerico nella causale %03s: impossibile proseguire",codcau); + str.format("%03s", codcausim); + record.overwrite(str,209); //Codice causale per incasso immediato + + bool intracom = cau.get_bool(CAU_INTRACOM); + if (intracom) + record.overwrite("X",246); + else //Flag per operazioni intracomunitarie + record.overwrite(" ",246); + + bool valintra = cau.get_bool(CAU_VALINTRA); + if (valintra) + record.overwrite("X",247); + else //Gestione valuta per oper. intracomunitarie + record.overwrite(" ",247); + + bool ritfatt = cau.get_bool(CAU_RITFATT); + if (ritfatt) + record.overwrite("X",248); + else //Flag causale per fattura ricevuta in ritardo + record.overwrite(" ",248); + + bool autofatt = cau.get_bool(CAU_AUTOFATT); + if (autofatt) + record.overwrite("X",249); + else //Autofattura art.34 + record.overwrite(" ",249); + + int num = 0; + int pos_gcs = 41; + int pos_sez = 191; + _codcaus = cau.get(CAU_CODCAUS); + + TLocalisamfile rcau (LF_RCAUSALI); + + do + { + num++; + + rcau.setkey(1); + rcau.zero(); + rcau.put(RCA_CODCAUS, _codcaus); + rcau.put(RCA_NRIGA, num); + + if (rcau.read() == NOERR) + { + int g = rcau.get_int (RCA_GRUPPO); + int c = rcau.get_int (RCA_CONTO); + + if (g > 99) + return error_box("Rilevato un gruppo composto da 3 cifre nella causale %03s riga %d: impossibile proseguire",codcau,num); + + if (c > 99) + return error_box("Rilevato un conto composto da 3 cifre nella causale %03s riga %d: impossibile proseguire",codcau,num); + + long s = rcau.get_long(RCA_SOTTOCONTO); + TString sez = rcau.get (RCA_SEZIONE); + + str = format("%02d", g); + record.overwrite(str,pos_gcs); //Gruppo + pos_gcs += 2; + str = format("%02d", c); + record.overwrite(str,pos_gcs); //Conto + pos_gcs += 2; + str = format("%06ld", s); + record.overwrite(str,pos_gcs); //Sottoconto + pos_gcs += 6; + + record.overwrite(sez,pos_sez); //Sezione + pos_sez++; + } + else + { + int g = 0; + int c = 0; + long s = 0; + TString sez = " "; + + str = format("%02d", g); + record.overwrite(str,pos_gcs); //Gruppo + pos_gcs += 2; + str = format("%02d", c); + record.overwrite(str,pos_gcs); //Conto + pos_gcs += 2; + str = format("%06ld", s); + record.overwrite(str,pos_gcs); //Sottoconto + pos_gcs += 6; + + record.overwrite(sez,pos_sez); //Sezione + pos_sez++; + } + + if (num == 15) + { + TString cau_app; + + rcau.next(); + if (!rcau.eof()) + cau_app = rcau.get(RCA_CODCAUS); + else + cau_app = ""; + + if (_codcaus == cau_app) + return error_box("Rilevata una causale con piu' di 15 righe: impossibile proseguire"); + } + } + while (num < 15); + + _numrec++; + TString stringa; + stringa.format("%06ld", _numrec); + int posiz = _files.find("W"); + _control_rec.overwrite(stringa,((posiz * 6) + 47)); + _tras_file.write_control_rec(_control_rec,size); + _tras_file.close(); + + _tras_file.open(_trasf,TRUE); + _tras_file.write_control_rec(record,size); + _tras_file.close(); + } + delete _prog; + + //Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare + //e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di + //ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche' + //la chiave e' compilata con i dati del file precedente. + _tras_file.open(_trasf); + leggi_record_controllo(); + TString chiave,app,sigla; + app.format("%-15s", (const char*) chiave); + char sigla_p = _tras_file.ult_file()[0]; + int posiz = _files.find(sigla_p); + TString nuova_sigla = " "; + if (posiz < _files.len()) + nuova_sigla = _files.mid(posiz+1,1); + + _control_rec.overwrite(nuova_sigla,240); + _control_rec.overwrite(app,241); + _tras_file.write_control_rec(_control_rec,size); + _tras_file.close(); + + setta_tabella_ditta(m,"D",FALSE); + setta_parametri_record(m,"D"); + + return TRUE; +} + +bool TInv_cont::invio_clifo(TString& key,TMask& m) +{ + int size = 256; + TString record(size); + char tipocf; + long codcf; + TLocalisamfile clifo (LF_CLIFO); + + long cicli = clifo.items(); + cicli -= _numrec; + _prog = new TProgind(cicli,"Invio anagrafica Clienti / Fornitori in corso... Prego attendere.",FALSE); + + if (key == "") + clifo.first(); + else + { + tipocf = (key.mid(2,1))[0]; + codcf = atol(key.mid(3,6)); + clifo.setkey(1); + clifo.zero(); + clifo.put(CLI_TIPOCF, tipocf); + clifo.put(CLI_CODCF, codcf); + clifo.read(); + } + + for (; !clifo.eof(); clifo.next()) + { + TString str; + + _prog->addstatus(1); + _tras_file.open(_trasf); + + record.spaces(); + + // Il tipocf su PC e' C = cliente F = fornitore. + // Il tipocf su AS400 e' 1 = cliente 2 = fornitore. + TString tipo_cod; + + char tipo = clifo.get_char(CLI_TIPOCF); + if (tipo == 'C') + tipo_cod = "1"; + else + if (tipo == 'F') + tipo_cod = "2"; + + record.overwrite("A1",0); //Tipo record + record.overwrite(tipo_cod,2); //Tipo cliente/fornitore + + long codice = clifo.get_long(CLI_CODCF); + str.format("%06ld", codice); + record.overwrite(str,3); //Codice cliente/fornitore + + //Salvataggio della chiave sul record di controllo del file trasfer + leggi_record_controllo(); + TString chiave,app; + chiave.format("%2s%s%06ld", (const char*) "A1", (const char*) tipo_cod, codice); + app.format("%-15s", (const char*) chiave); + _control_rec.overwrite("A",240); + _control_rec.overwrite(app,241); + // _tras_file.write_control_rec(_control_rec,size); + // _tras_file.close(); + + //Il tipo persona su PC e' F = fisica G = giuridica + //Il tipo persona su AS400 e' 0 = giuridica 1 = fisica + char tipop = clifo.get_char(CLI_TIPOPERS); + TString tipopers; + + if (tipop == 'F') + tipopers = "1"; + else + if (tipop == 'G') + tipopers = "0"; + + record.overwrite(tipopers,15); //Tipo persona + + TString ragsoc = clifo.get(CLI_RAGSOC); + TString cognome = ragsoc.mid(0,30); + TString nome = ragsoc.mid(30,20); + str.format("%-30s", (const char*) cognome); //Cognome o I ragione sociale + record.overwrite(str,16); + str.format("%-20s", (const char*) nome); + record.overwrite(str,46); //Nome o II ragione sociale + + //Se la partita IVA e' maggiore di 11 il programma di invio viene fermato + TString paiv = clifo.get(CLI_PAIV); + if (paiv.len() > 11) + return error_box("Rilevata partita IVA con piu' di 11 caratteri in codice %c%d: impossibile proseguire",tipo,codice); + str.format("%-11s", (const char*) paiv); + record.overwrite(str,66); //Partita IVA + + TString cofi = clifo.get(CLI_COFI); + str.format("%-16s", (const char*) cofi); + record.overwrite(str,77); //Codice fiscale + + TString indcf = clifo.get(CLI_INDCF); + str.format("%-35s", (const char*) indcf); + record.overwrite(str,93); //Indirizzo + + TString capcf = clifo.get(CLI_CAPCF); + record.overwrite(capcf,128); //Codice di avviamento postale + + TString localita = clifo.get(CLI_LOCCF); + str.format("%-.20s", (const char*) localita); + record.overwrite(str,133); //Localita' + + TString comcf = clifo.get(CLI_COMCF); + TString provincia = cerca_provincia(comcf); + str.format("%-2s", (const char*) provincia); + record.overwrite(str,153); //Provincia + + TString ptel = clifo.get(CLI_PTEL); + TString tel = clifo.get(CLI_TEL); + TString appoggio; + appoggio << ptel << " " << tel; + if (appoggio.len() > 12) + warning_box("Rilevato numero telefonico troppo lungo in codice %c%d: impossibile inviare",tipo,codice); + else //Numero telefono + record.overwrite(appoggio,155); + + TString alleg = clifo.get(CLI_ALLEG); + record.overwrite(alleg,167); //Flag gestione allegato + + int gruppo = clifo.get_int(CLI_GRUPPORIC); + int conto = clifo.get_int(CLI_CONTORIC); + + if (gruppo > 99) + return error_box("Rilevato gruppo costo/ricavo composto da 3 cifre in codice %c%d: impossibile proseguire",tipo,codice); + + if (conto > 99) + return error_box("Rilevato conto costo/ricavo composto da 3 cifre in codice %c%d: impossibile proseguire",tipo,codice); + + long sottoc = clifo.get_long(CLI_SOTTOCRIC); + str.format("%02d", gruppo); + record.overwrite(str,168); //Gruppo di costo/ricavo + str.format("%02d", conto); + record.overwrite(str,170); //Conto di costo/ricavo + str.format("%06ld", sottoc); + record.overwrite(str,172); //sottoconto di costo/ricavo + + long codalleg = clifo.get_long(CLI_CODALLEG); + str.format("%06ld", codalleg); + record.overwrite(str,179); + + //Se il codice di pagamento e' superiore alle 2 cifre l'invio deve essere interrotto + TString codpag = clifo.get(CLI_CODPAG); + if (codpag.len() > 2) + return error_box("Rilevato un codice di pagamento composto da 3 o piu' cifre in codice %c%d: impossibile proseguire",tipo,codice); + + str.format("%-2s", (const char*) codpag); + + _numrec++; + TString stringa; + stringa.format("%06ld", _numrec); + int posiz = _files.find("A"); + _control_rec.overwrite(stringa,((posiz * 6) + 47)); + _tras_file.write_control_rec(_control_rec,size); + _tras_file.close(); + + _tras_file.open(_trasf,TRUE); + _tras_file.write_control_rec(record,size); + _tras_file.close(); + } + delete _prog; + + //Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare + //e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di + //ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche' + //la chiave e' compilata con i dati del file precedente. + _tras_file.open(_trasf); + leggi_record_controllo(); + TString chiave,app,sigla; + app.format("%-15s", (const char*) chiave); + char sigla_p = _tras_file.ult_file()[0]; + int posiz = _files.find(sigla_p); + TString nuova_sigla = " "; + if (posiz < _files.len()) + nuova_sigla = _files.mid(posiz+1,1); + + _control_rec.overwrite(nuova_sigla,240); + _control_rec.overwrite(app,241); + _tras_file.write_control_rec(_control_rec,size); + _tras_file.close(); + + setta_tabella_ditta(m,"D",FALSE); + setta_parametri_record(m,"D"); + + return TRUE; +} + +bool TInv_cont::invio_pcon(TString& key,TMask& m) +{ + int size = 256; + TString record(size); + int gruppo,conto; + long sottoc; + TLocalisamfile pcon (LF_PCON); + + long cicli = pcon.items(); + cicli -= _numrec; + _prog = new TProgind(cicli,"Invio anagrafica Piano dei Conti in corso... Prego attendere.",FALSE); + + if (key == "") + pcon.first(); + else + { + gruppo = atoi(key.mid(2,2)); + conto = atoi(key.mid(4,2)); + sottoc = atol(key.mid(6,6)); + pcon.setkey(1); + pcon.zero(); + pcon.put(PCN_GRUPPO, gruppo); + pcon.put(PCN_CONTO, conto); + pcon.put(PCN_SOTTOCONTO, sottoc); + pcon.read(); + } + + for (; !pcon.eof(); pcon.next()) + { + TString str; + + _prog->addstatus(1); + _tras_file.open(_trasf); + + record.spaces(); + + int g = pcon.get_int (PCN_GRUPPO); + + if (g > 99) + return error_box("Rilevato un gruppo composto da 3 cifre in %03d: impossibile proseguire",g); + + int c = pcon.get_int (PCN_CONTO); + + if (c > 99) + return error_box("Rilevato un conto composto da 3 cifre in %03d: impossibile proseguire",c); + + long s = pcon.get_long(PCN_SOTTOCONTO); + + // Se si tratta di un GRUPPO + + if (g != 0 && c == 0 && s == 0) + { + //Salvataggio della sigla e della chiave sul record di controllo del file trasfer + leggi_record_controllo(); + TString chiave,app; + chiave.format("%2s%02d%02d%06ld", (const char*) "P1", g, c, s); + app.format("%-15s", (const char*) chiave); + _control_rec.overwrite("P",240); + _control_rec.overwrite(app,241); + // _tras_file.write_control_rec(_control_rec,size); + // _tras_file.close(); + + record.overwrite("P1",0); //Tipo record + str.format("%02d", g); + record.overwrite(str,2); //Gruppo + + TString descr (pcon.get(PCN_DESCR)); + str.format("%-.30s", (const char*) descr); + record.overwrite(str,15); //Descrizione gruppo + } + + // Se si tratta di un CONTO + + if (g != 0 && c != 0 && s == 0) + { + //Salvataggio della sigla e della chiave sul record di controllo del file trasfer + leggi_record_controllo(); + TString chiave,app; + chiave.format("%2s%02d%02d%06ld", (const char*) "P2", g, c, s); + app.format("%-15s", (const char*) chiave); + _control_rec.overwrite("P",240); + _control_rec.overwrite(app,241); + // _tras_file.write_control_rec(_control_rec,size); + // _tras_file.close(); + + record.overwrite("P2",0); //Tipo record + str.format("%02d", g); + record.overwrite(str,2); //Gruppo + + str.format("%02d", c); + record.overwrite(str,4); //Conto + + TString descr (pcon.get(PCN_DESCR)); + str.format("%-.30s", (const char*) descr); + record.overwrite(str,15); //Descrizione conto + + int indbil = pcon.get_int(PCN_INDBIL); + str.format("%d", indbil); + record.overwrite(str,45); //Indicatore di bilancio + + TString tmcf = pcon.get(PCN_TMCF); + record.overwrite(tmcf,46); //Flag conto cliente/fornitore + + bool stsottbil = pcon.get_bool(PCN_STSOTTBIL); + if (stsottbil) + str = "0"; + else + str = "1"; + record.overwrite(str,47); //Flag stampa dettaglio sottoconti su bilancio + + // Classe IV direttiva CEE + + TString sez = pcon.get(PCN_SEZIVD); + if (sez == "0") + sez = " "; + record.overwrite(sez,48); //Sezione IV dir + + TString let = pcon.get(PCN_LETTIVD); + record.overwrite(let,49); //Lettera IV dir + + int numrom = atoi(pcon.get(PCN_NUMRIVD)); + str.format("%03d", numrom); + record.overwrite(str,60); //Numero arabo corrispondente al numero romano + TString numr = itor(numrom); + str.format("%-8s", (const char*) numr); + record.overwrite(str,50); //Numero romano IV dir + + int num = pcon.get_int(PCN_NUMIVD); + str.format("%02d", num); + record.overwrite(str,58); //Numero arabo IV dir + + // Classe IV direttiva CEE di segno opposto + + TString sezop = pcon.get(PCN_SEZIVDOPP); + if (sezop == "0") + sezop = " "; + record.overwrite(sezop,63); //Sezione IV dir + + TString letop = pcon.get(PCN_LETTIVDOPP); + record.overwrite(letop,64); //Lettera IV dir + + int numromop = atoi(pcon.get(PCN_NUMRIVDOPP)); + str.format("%03d", numromop); + record.overwrite(str,75); //Numero arabo corrispondente al numero romano + TString numrop = itor(numromop); + str.format("%-8s", (const char*) numrop); + record.overwrite(str,65); //Numero romano IV dir + + int numop = pcon.get_int(PCN_NUMIVDOPP); + str.format("%02d", numop); + record.overwrite(str,73); //Numero arabo IV dir + } + + // Se si tratta di un SOTTOCONTO + + if (g != 0 && c != 0 && s != 0) + { + //Salvataggio della sigla e della chiave sul record di controllo del file trasfer + leggi_record_controllo(); + TString chiave,app; + chiave.format("%2s%02d%02d%06ld", (const char*) "P3", g, c, s); + app.format("%-15s", (const char*) chiave); + _control_rec.overwrite("P",240); + _control_rec.overwrite(app,241); + // _tras_file.write_control_rec(_control_rec,size); + // _tras_file.close(); + + record.overwrite("P3",0); //Tipo record + str.format("%02d", g); + record.overwrite(str,2); //Gruppo + + str.format("%02d", c); + record.overwrite(str,4); //Conto + + str.format("%06ld", s); + record.overwrite(str,6); + + TString descr (pcon.get(PCN_DESCR)); + str.format("%-.30s", (const char*) descr); + record.overwrite(str,15); //Descrizione sottoconto + + int tipospric = pcon.get_int(PCN_TIPOSPRIC); + str.format("%d", tipospric); + record.overwrite(str,45); //Tipo costo/ricavo + + int ricser = pcon.get_int(PCN_RICSER); + if (ricser == 0) + str = " "; + else + str.format("%d", ricser); + record.overwrite(str,46); //Tipo attivita' + + // Classe IV direttiva CEE + + TString sez = pcon.get(PCN_SEZIVD); + if (sez == "0") + sez = " "; + record.overwrite(sez,47); //Sezione IV dir + + TString let = pcon.get(PCN_LETTIVD); + record.overwrite(let,48); //Lettera IV dir + + int numrom = atoi(pcon.get(PCN_NUMRIVD)); + str.format("%03d", numrom); + record.overwrite(str,59); //Numero arabo corrispondente al numero romano + TString numr = itor(numrom); + str.format("%-8s", (const char*) numr); + record.overwrite(str,49); //Numero romano IV dir + + int num = pcon.get_int(PCN_NUMIVD); + str.format("%02d", num); + record.overwrite(str,57); //Numero arabo IV dir + + // Classe IV direttiva CEE di segno opposto + + TString sezop = pcon.get(PCN_SEZIVDOPP); + if (sezop == "0") + sezop = " "; + record.overwrite(sezop,62); //Sezione IV dir + + TString letop = pcon.get(PCN_LETTIVDOPP); + record.overwrite(letop,63); //Lettera IV dir + + int numromop = atoi(pcon.get(PCN_NUMRIVDOPP)); + str.format("%03d", numromop); + record.overwrite(str,74); //Numero arabo corrispondente al numero romano + TString numrop = itor(numromop); + str.format("%-8s", (const char*) numrop); + record.overwrite(str,64); //Numero romano IV dir + + int numop = pcon.get_int(PCN_NUMIVDOPP); + str.format("%02d", numop); + record.overwrite(str,72); //Numero arabo IV dir + } + + _numrec++; + TString stringa; + stringa.format("%06ld", _numrec); + int posiz = _files.find("P"); + _control_rec.overwrite(stringa,((posiz * 6) + 47)); + _tras_file.write_control_rec(_control_rec,size); + _tras_file.close(); + + _tras_file.open(_trasf,TRUE); + _tras_file.write_control_rec(record,size); + _tras_file.close(); + } + delete _prog; + + //Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare + //e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di + //ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche' + //la chiave e' compilata con i dati del file precedente. + _tras_file.open(_trasf); + leggi_record_controllo(); + TString chiave,app,sigla; + app.format("%-15s", (const char*) chiave); + char sigla_p = _tras_file.ult_file()[0]; + int posiz = _files.find(sigla_p); + TString nuova_sigla = " "; + if (posiz < _files.len()) + nuova_sigla = _files.mid(posiz+1,1); + + _control_rec.overwrite(nuova_sigla,240); + _control_rec.overwrite(app,241); + _tras_file.write_control_rec(_control_rec,size); + _tras_file.close(); + + setta_tabella_ditta(m,"D",FALSE); + setta_parametri_record(m,"D"); + + return TRUE; +} + +bool TInv_cont::testata_mov_PN(long numreg) +{ + TLocalisamfile mov (LF_MOV); + + mov.setkey(1); + mov.zero(); + mov.put(MOV_NUMREG, numreg); + if (mov.read() == NOERR) + { + _datadoc = mov.get_date(MOV_DATADOC); + _numdoc = mov.get (MOV_NUMDOC); + _reg = mov.get (MOV_REG); + _codcausm = mov.get (MOV_CODCAUS); + _codpag = mov.get (MOV_CODPAG); + _tipodoc = mov.get (MOV_TIPODOC); + _protiva = mov.get_long(MOV_PROTIVA); + _uprotiva = mov.get_long(MOV_UPROTIVA); + } + else + return FALSE; + + return TRUE; +} + +bool TInv_cont::invio_mov_PN(TString& key,TMask& m) +{ + int size = 256; + TString record(size); + long numreg,nreg_p; + int numrig; + TLocalisamfile rmov (LF_RMOV); + + nreg_p = -1; + + long cicli = rmov.items(); + cicli -= _numrec; + _prog = new TProgind(cicli,"Invio Movimenti di primanota in corso... Prego attendere.",FALSE); + + if (key == "") + rmov.first(); + else + { + numreg = atol(key.mid(2,6)); + numrig = atoi(key.mid(8,2)); + rmov.setkey(1); + rmov.zero(); + rmov.put(RMV_NUMREG, numreg); + rmov.put(RMV_NUMRIG, numrig); + rmov.read(); + } + + for (; !rmov.eof(); rmov.next()) + { + TString str; + + _prog->addstatus(1); + _tras_file.open(_trasf); + + record.spaces(); + + long nreg = rmov.get_long(RMV_NUMREG); + int nrig = rmov.get_int (RMV_NUMRIG); + + //Salvataggio della chiave sul record di controllo del file trasfer + leggi_record_controllo(); + TString chiave,app; + chiave.format("%2s%06ld%02d", (const char*) "Z1", nreg, nrig); + app.format("%-15s", (const char*) chiave); + _control_rec.overwrite("Z",240); + _control_rec.overwrite(app,241); + // _tras_file.write_control_rec(_control_rec,size); + // _tras_file.close(); + + if (nreg > 999999) + return error_box("Rilevato un numero di registrazione composto da 7 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig); + + if (nrig > 99) + return error_box("Rilevato un numero di riga composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig); + + record.overwrite("Z1",0); //Tipo record + + str.format("%06ld", nreg); + record.overwrite(str,2); //Numero di registrazione + + str.format("%02d", nrig); + record.overwrite(str,8); //Numero di riga + + if (nreg != nreg_p) + if (!testata_mov_PN(nreg)) + return error_box("Rilevata riga mancante di testata: impossibile proseguire"); + + nreg_p = nreg; + + TDate datareg (rmov.get(RMV_DATAREG)); + TString dataregstr = datareg.string(); + str = riconverti(dataregstr); + record.overwrite(str,15); //Data di registrazione + + //Determino il segnalino della competenza + int segnalino; + + int annoes = rmov.get_int(RMV_ANNOES); + int anno = date2esc(datareg); + if (annoes == anno) + segnalino = 0; + else + segnalino = 1; + str.format("%d", segnalino); + record.overwrite(str,21); //Segnalino della competenza + + TString datadocstr = _datadoc.string(); + str = riconverti(datadocstr); + record.overwrite(str,22); //Data documento + + str.format("%-7s", (const char*) _numdoc); + record.overwrite(str,28); + + if (_reg.len() > 1) + return error_box("Rilevato un codice registro IVA composto da 2 o piu' cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig); + record.overwrite(_reg,35); //Codice registro IVA + + str.format("%05d", _protiva); + record.overwrite(str,36); //Numero protocollo IVA + + // Se trovo un codice causale alfanumerico l'invio deve essere interrotto + const char* cod_causm = (const char*)_codcausm; + if (_codcausm != "") + if (!real::is_natural(cod_causm)) + return error_box("Rilevato un codice causale alfanumerico in %07ld riga %03d: impossibile proseguire",nreg,nrig); + str.format("%03s", (const char*)_codcausm); + record.overwrite(str,41); //Codice causale + + TString descr = rmov.get(RMV_DESCR); + str.format("%-.30s", (const char*) descr); + record.overwrite(str,44); //Descrizione riga di movimento + + int gruppo = rmov.get_int(RMV_GRUPPO); + if (gruppo > 99) + return error_box("Rilevato un gruppo di partita composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig); + str.format("%02d", gruppo); + record.overwrite(str,74); //Gruppo di partita + + int conto = rmov.get_int(RMV_CONTO); + if (conto > 99) + return error_box("Rilevato un conto di partita composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig); + str.format("%02d", conto); + record.overwrite(str,76); //Conto di partita + + long sottoc = rmov.get_long(RMV_SOTTOCONTO); + str.format("%06ld", sottoc); + record.overwrite(str,78); //Sottoconto di partita + + TString sez = rmov.get(RMV_SEZIONE); + str.format("%s", (const char*) sez); + record.overwrite(str,84); //Sezione importo + + int gruppoc = rmov.get_int(RMV_GRUPPOC); + if (gruppoc > 99) + return error_box("Rilevato un gruppo di contropartita composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig); + str.format("%02d", gruppoc); + record.overwrite(str,85); //Gruppo di contropartita + + int contoc = rmov.get_int(RMV_CONTOC); + if (contoc > 99) + return error_box("Rilevato un conto di contropartita composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig); + str.format("%02d", contoc); + record.overwrite(str,87); //Conto di contropartita + + long sottocc = rmov.get_long(RMV_SOTTOCONTOC); + str.format("%06ld", sottocc); + record.overwrite(str,89); //Sottoconto di contropartita + + if (_codpag.len() > 2) + return error_box("Rilevato un codice di pagamento composto da 3 o piu' cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig); + str.format("%-2s", (const char*) _codpag); + record.overwrite(str,95); //Codice di pagamento + + real importo (rmov.get_real(RMV_IMPORTO)); + str.format("%011s", (const char*) importo.string()); + record.overwrite(str,97); //Importo riga di movimento + + str.format("%05d", _uprotiva); + record.overwrite(str,108); //Ultimo numero di protocollo IVA + + TString tipoc = rmov.get(RMV_TIPOC); + record.overwrite(tipoc,219); //Flag cliente/fornitore + + record.overwrite(_tipodoc,220); //Tipo documento + + _numrec++; + TString stringa; + stringa.format("%06ld", _numrec); + int posiz = _files.find("Z"); + _control_rec.overwrite(stringa,((posiz * 6) + 47)); + _tras_file.write_control_rec(_control_rec,size); + _tras_file.close(); + + _tras_file.open(_trasf,TRUE); + _tras_file.write_control_rec(record,size); + _tras_file.close(); + } + delete _prog; + + //Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare + //e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di + //ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche' + //la chiave e' compilata con i dati del file precedente. + _tras_file.open(_trasf); + leggi_record_controllo(); + TString chiave,app,sigla; + app.format("%-15s", (const char*) chiave); + char sigla_p = _tras_file.ult_file()[0]; + int posiz = _files.find(sigla_p); + TString nuova_sigla = " "; + if (posiz < _files.len()) + nuova_sigla = _files.mid(posiz+1,1); + + _control_rec.overwrite(nuova_sigla,240); + _control_rec.overwrite(app,241); + _tras_file.write_control_rec(_control_rec,size); + _tras_file.close(); + + setta_tabella_ditta(m,"D",FALSE); + setta_parametri_record(m,"D"); + + return TRUE; +} + +bool TInv_cont::testata_mov_IVA(long numreg) +{ + TLocalisamfile mov (LF_MOV); + + mov.setkey(1); + mov.zero(); + mov.put(MOV_NUMREG, numreg); + if (mov.read() == NOERR) + { + _codcf = mov.get_long(MOV_CODCF); + _data74ter = mov.get_date(MOV_DATA74TER); + _corrlire = mov.get_real(MOV_CORRLIRE); + _codvali = mov.get (MOV_CODVALI); + _cambioi = mov.get_real(MOV_CAMBIOI); + _corrval = mov.get_real(MOV_CORRVALUTA); + _ocfpi = mov.get (MOV_OCFPI); + if (_ocfpi.not_empty()) + cerca_occasionale(); + } + else + return FALSE; + + return TRUE; +} + +void TInv_cont::cerca_occasionale() +{ + TLocalisamfile occas (LF_OCCAS); + + occas.setkey(1); + occas.zero(); + occas.put(OCC_CFPI, _ocfpi); + if (occas.read() == NOERR) + { + _ragsococc = occas.get(OCC_RAGSOC); + _indocc = occas.get(OCC_INDIR); + _capocc = occas.get(OCC_CAP); + TString com = occas.get(OCC_COM); + cerca_comune_occas(com); + } + else + { + _ragsococc = ""; + _indocc = ""; + _capocc = ""; + _localocc = ""; + _provocc = ""; + } +} + +void TInv_cont::cerca_comune_occas(const TString& com) +{ + TLocalisamfile comuni (LF_COMUNI); + + comuni.setkey(1); + comuni.zero(); + comuni.put(COM_COM, com); + if (comuni.read() == NOERR) + { + _localocc = comuni.get(COM_DENCOM); + _provocc = comuni.get(COM_PROVCOM); + } +} + +bool TInv_cont::invio_mov_IVA(TString& key,TMask& m) +{ + int size = 256; + TString record(size); + long numreg,nreg_p; + int numrig; + int numero_righe = 0; + TLocalisamfile rmoviva (LF_RMOVIVA); + + nreg_p = -1; + + long cicli = rmoviva.items(); + cicli -= _numrec; + _prog = new TProgind(cicli,"Invio Movimenti iva in corso... Prego attendere.",FALSE); + + if (key == "") + rmoviva.first(); + else + { + numreg = atol(key.mid(2,6)); + numrig = atoi(key.mid(8,2)); + rmoviva.setkey(1); + rmoviva.zero(); + rmoviva.put(RMI_NUMREG, numreg); + rmoviva.put(RMI_NUMRIG, numrig); + rmoviva.read(); + } + + for (; !rmoviva.eof(); rmoviva.next()) + { + TString str; + + _prog->addstatus(1); + _tras_file.open(_trasf); + + record.spaces(); + + long nreg = rmoviva.get_long(RMI_NUMREG); + int nrig = rmoviva.get_int (RMI_NUMRIG); + + //Salvataggio della chiave sul record di controllo del file trasfer + leggi_record_controllo(); + TString chiave,app; + chiave.format("%2s%06ld%02d", (const char*) "U1", nreg, nrig); + app.format("%-15s", (const char*) chiave); + _control_rec.overwrite("U",240); + _control_rec.overwrite(app,241); + // _tras_file.write_control_rec(_control_rec,size); + // _tras_file.close(); + + if (nreg > 999999) + return error_box("Rilevato un numero di registrazione composto da 7 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig); + + if (nrig > 99) + return error_box("Rilevato un numero di riga composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig); + + record.overwrite("U1",0); //Tipo record + + str.format("%06ld", nreg); + record.overwrite(str,2); //Numero di registrazione + + str.format("%02d", nrig); + record.overwrite(str,8); //Numero di riga + + if (nreg != nreg_p) + { + numero_righe = 0; + if (!testata_mov_IVA(nreg)) + return error_box("Rilevata riga mancante di testata: impossibile proseguire"); + } + + numero_righe++; + if (numero_righe > 9) + return error_box("Rilevata una registrazione IVA con piu' di 9 righe: impossibile proseguire"); + + nreg_p = nreg; + + str.format("%06ld", _codcf); + record.overwrite(str,15); //Codice cliente/fornitore + + real imponibile (rmoviva.get_real(RMI_IMPONIBILE)); + str.format("%011s", (const char*) imponibile.string()); + record.overwrite(str,21); //Imponibile + + //Se trovo un codice iva composto da piu' di 2 cifre l'invio viene interrotto + TString codiva (rmoviva.get(RMI_CODIVA)); + if (codiva.len() > 2) + return error_box("Rilevato un codice IVA composto da 3 o piu' cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig); + str.format("%02s", (const char*) codiva); + record.overwrite(str,32); //Codice iva + + real imposta (rmoviva.get_real(RMI_IMPOSTA)); + str.format("%09s", (const char*) imposta.string()); + record.overwrite(str,34); //Imposta + + int tipocr = rmoviva.get_int(RMI_TIPOCR); + str.format("%01d", tipocr); + record.overwrite(str,43); //Tipo costo/ricavo + + int tipodet = rmoviva.get_int(RMI_TIPODET); + str.format("%01d", tipodet); + record.overwrite(str,44); //Tipo detraibilita' + + int gruppo = rmoviva.get_int(RMI_GRUPPO); + if (gruppo > 99) + return error_box("Rilevato un gruppo composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig); + str.format("%02d", gruppo); + record.overwrite(str,45); //Gruppo + + int conto = rmoviva.get_int(RMI_CONTO); + if (conto > 99) + return error_box("Rilevato un conto composto da 3 cifre in %07ld riga %03d: impossibile proseguire",nreg,nrig); + str.format("%02d", conto); + record.overwrite(str,47); //Conto + + long sottoc = rmoviva.get_long(RMI_SOTTOCONTO); + str.format("%06ld", sottoc); + record.overwrite(str,49); //Sottoconto + + TString data74terstr = _data74ter.string(); + str = riconverti(data74terstr); + record.overwrite(str,55); //Data per registri 74 TER + + if (_ocfpi.not_empty()) + { + str.format("%-.25s", (const char*) _ragsococc); + record.overwrite(str,61); //Ragione sociale cliente occasionale + + str.format("%-.22s", (const char*) _indocc); + record.overwrite(str,86); //indirizzo cliente occasionale + + str.format("%-.18s", (const char*) _localocc); + record.overwrite(str,108); //Localita cliente occasionale + + str.format("%-5s", (const char*) _capocc); + record.overwrite(str,126); //Codice avviamento postale cliente occasionale + + str.format("%-.2s", (const char*) _provocc); + record.overwrite(str,131); //Provincia cliente occasionale + } + + int tipoatt = rmoviva.get_int(RMI_TIPOATT); + str.format("%01d", tipoatt); + record.overwrite(str,133); //Tipo attivita' + + str.format("%011s", (const char*) _corrlire.string()); + record.overwrite(str,135); //Corrispettivo in lire + + record.overwrite(_codvali,146); //Codice valuta + + str.format("%011s", (const char*) _cambioi.string()); + record.overwrite(str,149); //Cambio + + str.format("%014s", (const char*) _corrval.string()); + record.overwrite(str,160); //Corrispettivo in valuta + + _numrec++; + TString stringa; + stringa.format("%06ld", _numrec); + int posiz = _files.find("U"); + _control_rec.overwrite(stringa,((posiz * 6) + 47)); + _tras_file.write_control_rec(_control_rec,size); + _tras_file.close(); + + _tras_file.open(_trasf,TRUE); + _tras_file.write_control_rec(record,size); + _tras_file.close(); + } + delete _prog; + + //Inizializzo l'ultima sigla file elaborato su trasfer con la sigla del file successivo da inviare + //e inizializzo la chiave, altrimenti se si blocca l'invio subito dopo aver finito un file si rischia di + //ritrasferire l'ultimo record quando si riparte; inoltre non si riesce a inviare il file successivo perche' + //la chiave e' compilata con i dati del file precedente. + _tras_file.open(_trasf); + leggi_record_controllo(); + TString chiave,app,sigla; + app.format("%-15s", (const char*) chiave); + char sigla_p = _tras_file.ult_file()[0]; + int posiz = _files.find(sigla_p); + TString nuova_sigla = " "; + if (posiz < _files.len()) + nuova_sigla = _files.mid(posiz+1,1); + + _control_rec.overwrite(nuova_sigla,240); + _control_rec.overwrite(app,241); + _tras_file.write_control_rec(_control_rec,size); + _tras_file.close(); + + setta_tabella_ditta(m,"D",FALSE); + setta_parametri_record(m,"D"); + + return TRUE; +} + +bool TInv_cont::menu(MENU_TAG m) +{ + if (m == BAR_ITEM(1)) + return main_loop(); + return FALSE; +} + +int cg2900 (int argc, char* argv[]) +{ + TInv_cont a; + + a.run(argc,argv, "Invio contabilita'"); + + return TRUE; +} diff --git a/cg/cg2900.h b/cg/cg2900.h new file mode 100755 index 000000000..ef0b2743f --- /dev/null +++ b/cg/cg2900.h @@ -0,0 +1,15 @@ +// Campi maschera tabella ditte per invio + +#define F_DITTAINV 101 +#define F_NUMULINV 103 +#define F_DATAULIN 104 +#define F_STATO 105 +#define F_RAGSOC 106 +#define F_USELAB 107 +#define F_CHIAVE 108 +#define F_DATALIM 109 + +// Campi maschera cg2900b.uml + +#define F_FLOPPY 201 +#define F_DIM 202 \ No newline at end of file diff --git a/cg/cg2900a.uml b/cg/cg2900a.uml new file mode 100755 index 000000000..9b91a702b --- /dev/null +++ b/cg/cg2900a.uml @@ -0,0 +1,62 @@ +#include "cg2900.h" + +PAGE "Invio contabilita'" -1 -1 76 11 + +NUMBER F_DITTAINV 5 +BEGIN + PROMPT 2 1 "Codice ditta inviante " + FLAGS "Z" + CHECKTYPE REQUIRED +END + +STRING F_RAGSOC 50 +BEGIN + PROMPT 2 2 "Ragione sociale " + FLAGS "D" +END + +NUMBER F_NUMULINV 3 +BEGIN + PROMPT 2 4 "Numero ultimo invio " + FLAGS "R" +END + +DATE F_DATAULIN +BEGIN + PROMPT 44 4 "Data ultimo invio " +END + +STRING F_STATO 1 +BEGIN + PROMPT 2 5 "Stato ultimo invio " +END + +STRING F_USELAB 1 +BEGIN + PROMPT 27 5 "" +END + +STRING F_CHIAVE 15 +BEGIN + PROMPT 30 5 "" +END + +DATE F_DATALIM +BEGIN + PROMPT 2 7 "Data limite invio " + CHECKTYPE REQUIRED +END + +BUTTON DLG_OK 9 2 +BEGIN + PROMPT -12 -1 "" +END + +BUTTON DLG_QUIT 9 2 +BEGIN + PROMPT -22 -1 "" +END + +ENDPAGE + +ENDMASK diff --git a/cg/cg2900b.uml b/cg/cg2900b.uml new file mode 100755 index 000000000..ff2929ae0 --- /dev/null +++ b/cg/cg2900b.uml @@ -0,0 +1,34 @@ +#include "cg2900.h" + +PAGE "" -1 -1 40 7 + +LIST F_FLOPPY 1 5 +BEGIN + PROMPT 1 1 "Disco " + ITEM "A|A:" + ITEM "B|B:" +END + +LIST F_DIM 7 +BEGIN + PROMPT 1 3 "Dimensione dischi " + ITEM "1|1,4 Mb" + ITEM "2|1,2 Mb" + ITEM "3|720 Kb" + ITEM "4|360 Kb" + HELP "Indicare la dimensione dei dischi che si vogliono usare" +END + +BUTTON DLG_OK 9 2 +BEGIN + PROMPT -12 -1 "" +END + +BUTTON DLG_QUIT 9 2 +BEGIN + PROMPT -22 -1 "" +END + +ENDPAGE + +ENDMASK diff --git a/cg/cglib04.cpp b/cg/cglib04.cpp index 2e0afa5d6..9e625fdbf 100755 --- a/cg/cglib04.cpp +++ b/cg/cglib04.cpp @@ -53,11 +53,13 @@ void TTransfer_file::close() fclose(_trasfer); } -bool TTransfer_file::open(const char* path) +bool TTransfer_file::open(const char* path, bool create) { if (_trasfer) fclose(_trasfer); - _trasfer = fopen (path, "r+t"); + const char* mode = create ? "a+t" : "r+t"; + + _trasfer = fopen (path, mode); return _trasfer != NULL; } diff --git a/cg/cglib04.h b/cg/cglib04.h index 0d996d5d8..9583cbe09 100755 --- a/cg/cglib04.h +++ b/cg/cglib04.h @@ -80,7 +80,7 @@ private: public: const char* path (long codditta = 0); - bool open (const char* path); + bool open (const char* path, bool create=FALSE); void close (); bool exist() const { return _trasfer != NULL; }