root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Patch level : 10.0 patch ???

Browse Source 
Files correlati     : ps0713.exe ps0713100a.msk ps0713200a.msk ps0713400a.msk
Ricompilazione Demo : [ ]
Commento            :
Versione 10.0 dei programma; escudere da progetto ps0713300 e ps0713500 (verrano fatti in seguito)

Aggiungere al progetto calib01 e calib02 e la dipendenza a vedoc


git-svn-id: svn://10.65.10.50/trunk@20373 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
luca83 2010-04-26 10:41:28 +00:00
parent c215e4cbf9
commit c6e659655d
11 changed files with 381 additions and 528 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
ps/ps0713.cpp
View File

@ -7,13 +7,13 @@ int main(int argc, char** argv)
int n = argc > 1 ? atoi(argv[1]+1) : 0; int n = argc > 1 ? atoi(argv[1]+1) : 0;
switch(n) switch(n)
{ {
case 0: ps0713100(argc, argv); break; //Trasferimento dati contabili per ATS case 0: ps0713100(argc, argv); break; //Esportazione righe IVA
case 1: ps0713200(argc, argv); break; //Trasferimento commesse case 1: ps0713200(argc, argv); break; //Importazione commesse
case 2: ps0713300(argc, argv); break; //Importazione fatture di acquisto per ATS //case 2: ps0713300(argc, argv); break; //Importazione fatture di acquisto per ATS
case 3: ps0713400(argc, argv); break; //Importazione fatture di vendita per ATS case 3: ps0713400(argc, argv); break; //Importazione fatture di vendita per ATS
case 4: ps0713500(argc, argv); break; //Importazione spese per ATS //case 4: ps0713500(argc, argv); break; //Importazione spese per ATS
default: //case 5: ps0713600(argc, argv); break; //Importazione fatture fornitori / fatture da ricevere
ps0713100(argc, argv); break; //Trasferimento dati contabili per ATS default: ps0713100(argc, argv); break; //Esportazione righe IVA
} }
exit(0); exit(0);
return 0; return 0;

1
ps/ps0713.h
View File

@ -3,3 +3,4 @@ int ps0713200(int argc, char* argv[]);
int ps0713300(int argc, char* argv[]); int ps0713300(int argc, char* argv[]);
int ps0713400(int argc, char* argv[]); int ps0713400(int argc, char* argv[]);
int ps0713500(int argc, char* argv[]); int ps0713500(int argc, char* argv[]);
int ps0713600(int argc, char* argv[]);

382
ps/ps0713100.cpp
View File

@ -1,101 +1,76 @@
#include <applicat.h> #include <applicat.h>
#include <automask.h> #include <automask.h>
#include <progind.h> #include <progind.h>
#include <recarray.h>
#include <relation.h>
#include <textset.h> #include <textset.h>
#include <mov.h> #include <mov.h>
#include <rmoviva.h> #include <rmoviva.h>
#include "../ca/calib01.h"
#include "../ca/calib02.h"
#include "../cg/cgsaldac.h" #include "../cg/cgsaldac.h"
#include "ps0713.h"
#include "ps0713100a.h" #include "ps0713100a.h"
/////////////////////////////////////////////////////////// ///////////////////////////////////
// TEsporta_ps0713 maschera //// TESPORTA_DATIVA_MSK ////
/////////////////////////////////////////////////////////// ///////////////////////////////////
class TEsporta_ps0713_mask : public TAutomask //Classe TEsporta_dativa_msk
class TEsporta_dativa_msk : public TAutomask
{ {
public: public:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
TEsporta_ps0713_mask(); TEsporta_dativa_msk();
~TEsporta_ps0713_mask();
}; };
bool TEsporta_ps0713_mask::on_field_event(TOperable_field& o, TField_event e, long jolly) //ON_FIELD_EVENT: metodo che gestisce i comportamenti dei vari campi della maschera
bool TEsporta_dativa_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{ {
switch (o.dlg()) switch (o.dlg())
{ {
//giochetto per avere la lista dei files validi nella directory di trasferimento! case F_ADATA:
case F_ADATA: if (e == fe_modify || e == fe_close)
if (e == fe_modify || e == fe_close) {
{ //setto il campo F_NAME a un valore fisso, e cioè: "data_in_ANSI.txt"
TDate adata = o.get(); TDate adata = o.get();
TString str_adata; TString16 str_adata; str_adata << adata.date2ansi() << ".txt";
str_adata << adata.date2ansi() << ".txt"; set(F_NAME, str_adata);
set(F_NAME, str_adata); }
} break;
break; default: break;
default:
break;
} }
return true; return true;
} }
TEsporta_ps0713_mask::TEsporta_ps0713_mask() : TAutomask("ps0713100a") //metodo costruttore
{ TEsporta_dativa_msk::TEsporta_dativa_msk() : TAutomask("ps0713100a"){}
//carica i parametri del file di configurazione
TConfig configfile("ps0713conf.ini", "MAIN");
for (int i = 0; i < fields() ; i++)
{
TMask_field& f = fld(i);
const TFieldref* fr = f.field();
if (fr != NULL)
f.set(configfile.get(fr->name()));
}
}
TEsporta_ps0713_mask::~TEsporta_ps0713_mask() ///////////////////////////////////
{ //// TESPORTA_DATIVA_REC ////
//carica i parametri del file di configurazione ///////////////////////////////////
TConfig configfile("ps0713conf.ini", "MAIN");
for (int i = 0; i < fields() ; i++)
{
TMask_field& f = fld(i);
const TFieldref* fr = f.field();
if (fr != NULL)
configfile.set(fr->name(), f.get());
}
}
///////////////////////////////////////////////////////////// //Classe TEsporta_dativa_rec (righe movimenti iva)
// TEsporta_ps0713 recordset (righe movimenti iva) class TEsporta_dativa_rec : public TCSV_recordset
/////////////////////////////////////////////////////////////
class TEsporta_ps0713_recordset : public TCSV_recordset
{ {
public: public:
TEsporta_ps0713_recordset(); TEsporta_dativa_rec();
}; };
//metodo costruttore
TEsporta_ps0713_recordset::TEsporta_ps0713_recordset() TEsporta_dativa_rec::TEsporta_dativa_rec()
: TCSV_recordset("CSV(\"\t\")") : TCSV_recordset("CSV(\"\t\")")
{ {
} }
///////////////////////////////////
//// TESPORTA_DATIVA_APP ////
///////////////////////////////////
/////////////////////////////////////////////////////////// //Classe TEsporta_dativa_app
// TEsporta_ps0713 applicazione class TEsporta_dativa_app : public TSkeleton_application
///////////////////////////////////////////////////////////
class TEsporta_ps0713_app : public TSkeleton_application
{ {
protected: protected:
virtual bool check_autorization() const {return false;} virtual bool check_autorization() const {return false;}
virtual const char * extra_modules() const {return "cg";} virtual const char * extra_modules() const {return "cg";}
@ -105,41 +80,180 @@ protected:
public: public:
void esporta_righe_iva(const TMask& msk) const; void esporta_righe_iva(const TMask& msk) const;
void set_inviva(TISAM_recordset& rmoviva) const; void set_inviva(TISAM_recordset& rmoviva) const;
}; };
void TEsporta_ps0713_app::set_inviva(TISAM_recordset& rmoviva) const //TEST_PARTITA: metodo che cerca l'ultima data pagamento delle partite relative ad un numreg (la maggiore)
//il metodo restiruisce true se esiste almeno una partita per il numreg indicato
bool TEsporta_dativa_app::test_partita(const long numreg, TDate& last_data_pag) const
{ {
long last_numreg = 0L; TPartite_array torneo;
const long items = rmoviva.items(); //aggiungo all'array tutte le partite con quel numreg
TProgind pi(items, TR("Impostazione flag Inviata parte IVA..."), true, true); torneo.add_numreg(numreg);
TLocalisamfile mov(LF_MOV); TPartita* partita = torneo.first();
//se esiste almeno una partita ed è chiusa
if (partita != NULL && partita->chiusa())
{
//scorro tutte le partite
for (int r = partita->last(); r > 0; r = partita->pred(r))
{
//instanzio una riga_partite
const TRiga_partite& row = partita->riga(r);
const tipo_movimento tipo = row.tipo();
//controllo il tipo_movimento; se è del tipo tm_pagamento o tm_pagamento_insoluto
//recupero la data del pagamento, e se questa è maggiore di quella già trovata, aggiorno
//quest'ultima
if (tipo == tm_pagamento || tipo == tm_pagamento_insoluto)
{
const TDate datadoc = row.get_date(PART_DATAPAG);
if (datadoc > last_data_pag)
last_data_pag = datadoc;
}
}
return true;
}
return false;
}
//ESPORTA_RIGHE_IVA: metodo che prepara il csv-recordset per essere esportato
void TEsporta_dativa_app::esporta_righe_iva(const TMask& m) const
{
//instanzio il TFilename e controllo la sua esistenza
TFilename path = m.get(F_PATH);
path.add(m.get(F_NAME));
if (path.exist())
{
TString str;
str << "ATTENZIONE! " << "Il file " << m.get(F_NAME) << "è già esistente.\n"
<< "Se si procede sara' azzerato il file esistente!\nContinuare?";
if (!yesno_box(str))
return;
}
//preparo le date di interesse
const TDate adata(m.get_date(F_ADATA));
const TDate dadata(1, 1, adata.year() - 1);
//preparo query su righe iva joinati ai mov
TString query;
query << "USE RMOVIVA "
<< "SELECT ((NUM(ANSI(23.DATAREG))>=NUM(ANSI(#DADATA)))"
<< "&&(NUM(ANSI(23.DATAREG))<=NUM(ANSI(#ADATA))))&&(23.INVIVA!=\"X\")&&(23.TIPO=\"F\")";
if (m.get_int(F_JOB) == 1)
query << "&&(CODCMS!=\"\")\n";
else
query << "&&(CODCMS=\"\")\n";
query << "JOIN MOV INTO NUMREG==NUMREG\n"
<< "JOIN %IVA ALIAS 101 INTO CODTAB==CODIVA\n"
<< "JOIN CLIFO TO MOV INTO TIPOCF==TIPO CODCF==CODCF";
//instanzio il recordset
TISAM_recordset rmoviva(query);
rmoviva.set_var("#DADATA", dadata);
rmoviva.set_var("#ADATA", adata);
//instanzio il csv recordset
TEsporta_dativa_rec csv;
TProgind pi(rmoviva.items(), TR("Estrazione dati..."), true, true);
for (bool ok = rmoviva.move_first(); ok; ok = rmoviva.move_next()) for (bool ok = rmoviva.move_first(); ok; ok = rmoviva.move_next())
{ {
if (!pi.addstatus(1)) if (!pi.addstatus(1))
break; break;
const long curr_numreg = rmoviva.get(RMI_NUMREG).as_int();
if (curr_numreg != last_numreg) TDate last_data_pag;
const long numreg = rmoviva.get(RMI_NUMREG).as_int();
const real impiva = rmoviva.get(RMI_IMPONIBILE).as_real();
bool partita_chiusa = test_partita(numreg, last_data_pag);
if (partita_chiusa)
{
//creazione di un nuovo record da esportare
csv.new_rec("");
//..e successivo riempimento
TString8 codcms; codcms.cut(0);
TString query_movana;
query_movana << "USE MOVANA KEY 3\n"
<< "FROM NUMREGCG=NUMREG\n"
<< "TO NUMREGCG=NUMREG";
TISAM_recordset rec_movana(query_movana);
rec_movana.set_var("#NUMREGCG", numreg);
TAnal_mov movana = rec_movana.move_first();
for(int i = 1; i <= movana.rows(); i++)
{
const TRectype& rmovana = movana.body()[i];
const real impana = rmovana.get_real("IMPORTO");
if(impiva == impana)
codcms = rmovana.get("CODCMS");
}
csv.set(0, codcms);
csv.set(1, rmoviva.get("23.CODCF"));
csv.set(2, rmoviva.get("20.RAGSOC"));
csv.set(3, rmoviva.get(RMI_IMPONIBILE).as_real());
csv.set(6, rmoviva.get("23.DATADOC"));
csv.set(7, rmoviva.get("23.NUMDOC"));
csv.set(8, last_data_pag);
}
}
csv.save_as(path, fmt_text);
#ifdef DBG
xvt_sys_goto_url(path, "open");
#endif
TString msg;
msg << "Si conferma l'esportazione definitiva dei movimenti IVA fino al ";
msg << m.get(F_ADATA);
if (yesno_box(msg))
set_inviva(rmoviva); //mette il flag di "INVIVA" alla testata movimento
}
//SET_INVIA: metodo che mette il flag di "INVIVA" alla testata movimento
void TEsporta_dativa_app::set_inviva(TISAM_recordset& rmoviva) const
{
long last_numreg = 0L;
TProgind pi(rmoviva.items(), TR("Impostazione flag Inviata parte IVA..."), true, true);
TLocalisamfile mov(LF_MOV);
//scorro il recordset che contiene le righe IVA joinate con i movimenti
for (bool ok = rmoviva.move_first(); ok; ok = rmoviva.move_next())
{
if (!pi.addstatus(1))
break;
const long curr_numreg = rmoviva.get(RMI_NUMREG).as_int();
//ad ogni cambio di numreg
if (curr_numreg != last_numreg)
{ {
TDate last_data_pag; TDate last_data_pag;
bool partita_chiusa = test_partita(curr_numreg, last_data_pag); bool partita_chiusa = test_partita(curr_numreg, last_data_pag);
//controllo che la partita sia chiusa
if (partita_chiusa) if (partita_chiusa)
{ {
mov.put(MOV_NUMREG, curr_numreg); //leggo dal file LF_MOV quello che ha il numero di registrazione selezioante
mov.put(MOV_NUMREG, curr_numreg);
int err = mov.read(); int err = mov.read();
//se riesco a leggerlo setto il flag di invio e aggriono il movimento
if (err == NOERR) if (err == NOERR)
{ {
mov.put(MOV_INVIVA, 'X'); mov.put(MOV_INVIVA, 'X');
err = mov.rewrite(); err = mov.rewrite();
} }
//se non sono riuscito ne a leggerlo ne a scriverlo, lo segnalo
if (err != NOERR) if (err != NOERR)
{ {
TString cazzone; TString str;
cazzone << TR("Impossibile aggiornare il movimento "); str << "Impossibile aggiornare il movimento " << curr_numreg;
cazzone << curr_numreg; error_box(str);
error_box(cazzone);
break; break;
} }
} }
@ -148,124 +262,16 @@ void TEsporta_ps0713_app::set_inviva(TISAM_recordset& rmoviva) const
} }
} }
bool TEsporta_ps0713_app::test_partita(const long numreg, TDate& last_data_pag) const void TEsporta_dativa_app::main_loop()
{ {
bool finito = false; TEsporta_dativa_msk m;
TPartite_array torneo;
torneo.add_numreg(numreg);
TPartita* partita = torneo.first();
if (partita != NULL && partita->chiusa())
{
for (int r = partita->last(); r > 0; r = partita->pred(r))
{
const TRiga_partite& row = partita->riga(r);
const tipo_movimento tipo = row.tipo();
if (tipo == tm_pagamento || tipo == tm_pagamento_insoluto)
{
const TDate datadoc = row.get_date(PART_DATAPAG);
if (datadoc > last_data_pag)
last_data_pag = datadoc;
}
}
finito = true;
}
return finito;
}
void TEsporta_ps0713_app::esporta_righe_iva(const TMask& m) const
{
TFilename path = m.get(F_PATH);
path.add(m.get(F_NAME));
if (path.exist())
if (!yesno_box(TR("ATTENZIONE! File gia' presente! Se si procede sara' azzerato il file esistente!\nContinuare?")))
return;
// query su righe iva joinati ai mov
TString query;
query << "USE RMOVIVA ";
query << "SELECT ((NUM(ANSI(23.DATAREG))>=NUM(ANSI(#DADATA)))&&(NUM(ANSI(23.DATAREG))<=NUM(ANSI(#ADATA))))&&(23.INVIVA!=\"X\")&&(23.TIPO=\"F\")";
if (m.get_int(F_JOB) == 1)
query << "&&(CODCMS!=\"\")";
else
query << "&&(CODCMS=\"\")";
query << "\nJOIN MOV INTO NUMREG==NUMREG";
query << "\nJOIN %IVA ALIAS 101 INTO CODTAB==CODIVA";
query << "\nJOIN CLIFO TO MOV INTO TIPOCF==TIPO CODCF==CODCF";
TISAM_recordset rmoviva(query);
const TDate& adata = m.get_date(F_ADATA);
const TDate dadata(1,1, adata.year() - 1);
rmoviva.set_var("#DADATA", dadata);
rmoviva.set_var("#ADATA", adata);
TEsporta_ps0713_recordset csv;
const long items = rmoviva.items();
TProgind pi(items, TR("Estrazione dati..."), true, true);
TString ws;
for (bool ok = rmoviva.move_first(); ok; ok = rmoviva.move_next())
{
if (!pi.addstatus(1))
break;
TDate last_data_pag;
bool partita_chiusa = test_partita(rmoviva.get(RMI_NUMREG).as_int(), last_data_pag);
if (partita_chiusa)
{
//creazione di un nuovo record da esportare
csv.new_rec("");
//..e successivo riempimento
csv.set(0, rmoviva.get(RMI_CODCMS));
csv.set(1, rmoviva.get("23.CODCF"));
csv.set(2, rmoviva.get("20.RAGSOC"));
const real imponibile = rmoviva.get(RMI_IMPONIBILE).as_real();
// const real imposta = rmoviva.get(RMI_IMPOSTA).as_real();
// const real lordo = imponibile + imposta;
// csv.set(3, lordo);
csv.set(3, imponibile);
//csv.set(2, rmoviva.get("101@.R0")); //aliquota non ci vuole piu'
// csv.set(5, imposta);
csv.set(6, rmoviva.get("23.DATADOC"));
csv.set(7, rmoviva.get("23.NUMDOC"));
csv.set(8, last_data_pag);
// csv.set(9, rmoviva.get(RMI_GRUPPO));
// csv.set(10, rmoviva.get(RMI_CONTO));
// csv.set(11, rmoviva.get(RMI_SOTTOCONTO));
// csv.set(12, rmoviva.get(RMI_NUMREG));
}
} //for(move_first()..
csv.save_as(path, fmt_text);
#ifdef DBG
xvt_sys_goto_url(path, "open");
#endif
TString msg;
msg << TR("Si conferma l'esportazione definitiva dei movimenti IVA fino al ");
msg << m.get(F_ADATA);
if (yesno_box(msg))
set_inviva(rmoviva); //mette il flag di "INVIVA" alla testata movimento
}
void TEsporta_ps0713_app::main_loop()
{
TEsporta_ps0713_mask m;
while (m.run() == K_ENTER) while (m.run() == K_ENTER)
esporta_righe_iva(m); esporta_righe_iva(m);
} }
int ps0713100(int argc, char* argv[]) int ps0713100(int argc, char* argv[])
{ {
TEsporta_ps0713_app app; TEsporta_dativa_app app;
app.run(argc, argv, TR("Trasferimento dati IVA")); app.run(argc, argv, TR("Trasferimento dati IVA"));
return 0; return 0;
} }

1
ps/ps0713100a.h
View File

@ -1,5 +1,4 @@
//campi maschera ps0713100a //campi maschera ps0713100a
#define F_PATH 101 #define F_PATH 101
#define F_NAME 102 #define F_NAME 102
#define F_ADATA 103 #define F_ADATA 103

62
ps/ps0713100a.uml
View File

@ -1,52 +1,60 @@
#include "ps0713100a.h" #include "ps0713100a.h"
TOOLBAR "" 0 -2 0 2 TOOLBAR "topbar" 0 0 0 2
BUTTON DLG_OK 10 2 #include <elabar.h>
BEGIN
PROMPT -12 -11 ""
END
BUTTON DLG_QUIT 10 2
BEGIN
PROMPT -22 -11 ""
END
ENDPAGE ENDPAGE
PAGE "Trasferimento dati IVA per ATS" -1 -1 64 10 PAGE "Trasferimento dati IVA per ATS" -1 -1 80 10
STRING F_PATH 255 40 STRING DLG_PROFILE 50
BEGIN BEGIN
PROMPT 2 2 "Cartella dove creare il file da esportare " PROMPT 9 -12 "Profilo "
DSELECT PSELECT
FLAGS "M" FLAGS "H"
CHECKTYPE REQUIRED
FIELD PATH
WARNING "Selezionare una cartella valida!"
END END
STRING F_NAME 30 GROUPBOX DLG_NULL 78 4
BEGIN BEGIN
PROMPT 2 3 "Nome file generato da esportare " PROMPT 1 1 "@bParametri file da esportare"
FLAGS "B" END
STRING F_PATH 255 50
BEGIN
PROMPT 2 2 "Cartella "
DSELECT
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
FIELD NAME FLAGS "M"
FIELD PATH
END
STRING F_NAME 50
BEGIN
PROMPT 2 3 "File "
FLAGS "D" FLAGS "D"
CHECKTYPE NORMAL
FIELD NAME
END
GROUPBOX DLG_NULL 78 6
BEGIN
PROMPT 1 5 "@bParametri movimenti da esportare"
END END
DATE F_ADATA DATE F_ADATA
BEGIN BEGIN
PROMPT 2 5 "Esporta movimenti fino alla data " PROMPT 2 6 "Esporta movimenti fino alla data "
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
FIELD ADATA FIELD ADATA
END END
RADIOBUTTON F_JOB 20 RADIOBUTTON F_JOB 60
BEGIN BEGIN
PROMPT 2 7 "Tipo record da esportare" PROMPT 2 7 "Tipo record da esportare"
ITEM "1|CON id. lavoro" ITEM "1|CON id. lavoro"
ITEM "2|SENZA id. lavoro" ITEM "2|SENZA id. lavoro"
FLAGS "Z"
END END
ENDPAGE ENDPAGE

216
ps/ps0713200.cpp
View File

@ -8,167 +8,115 @@
#include "tabutil.h" #include "tabutil.h"
#include "ps0713.h"
#include "ps0713200a.h" #include "ps0713200a.h"
/////////////////////////////////
//// TIMPORTA_COMM_MSK ////
/////////////////////////////////
//Classe TImporta_comm_msk
/////////////////////////////////////////////////////////// class TImporta_comm_msk : public TAutomask
// TAutomask
///////////////////////////////////////////////////////////
class TImportaComm_mask : public TAutomask
{ {
protected: protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public: public:
TImportaComm_mask(); TImporta_comm_msk();
}; };
TImportaComm_mask::TImportaComm_mask() :TAutomask ("ps0713200a")
{
}
bool TImportaComm_mask::on_field_event(TOperable_field& f, TField_event e, long jolly) //ON_FIELD_EVENT: metodo che gestisce i comportamenti dei vari campi della maschera
{ //(per adesso segnaposto)
switch (f.dlg()) bool TImporta_comm_msk::on_field_event(TOperable_field& f, TField_event e, long jolly)
{ {
//giochetto per avere la lista dei files validi nella directory di trasferimento!
case F_NAME:
if (e == fe_button)
{
TArray_sheet as(-1, -1, 72, 20, TR("Selezione file"),
"File@32");
TFilename path = get(F_PATH);
path.add("*.csv"); //files delle testate
list_files(path, as.rows_array());
TFilename name;
FOR_EACH_ARRAY_ROW(as.rows_array(), i, row)
{
name = *row;
*row = name.name();
}
if (as.run() == K_ENTER)
{
f.set(as.row(as.selected()));
}
}
break;
default:
break;
}
return true; return true;
} }
/////////////////////////////////////// //metodo costruttore
// TSkeleton_application TImporta_comm_msk::TImporta_comm_msk() : TAutomask("ps0713200a"){}
///////////////////////////////////////
class TCommCSV : public TSkeleton_application /////////////////////////////////
//// TIMPORTA_COMM_APP ////
/////////////////////////////////
//Classe TImporta_comm_app
class TImporta_comm_app : public TSkeleton_application
{ {
virtual bool check_autorization() const {return false;} virtual bool check_autorization() const {return false;}
virtual const char * extra_modules() const {return "cg";} virtual const char * extra_modules() const {return "cg";}
TImportaComm_mask* _msk; TImporta_comm_msk* _msk;
TConfig* _configfile;
public: public:
virtual bool create(); virtual bool create();
virtual bool destroy(); virtual bool destroy();
virtual void main_loop(); virtual void main_loop();
virtual void ini2mask();
virtual void mask2ini();
bool transfer(const TFilename& file); bool transfer(const TFilename& file);
TCommCSV() {}; TImporta_comm_app() {};
}; };
TCommCSV& app() { return (TCommCSV&) main_app(); } TImporta_comm_app& app() { return (TImporta_comm_app&) main_app(); }
///////////////////////////////// //TRASNFER: metodo che effettivamente svolge l'elaborazione di importazione
// inserimento commesse bool TImporta_comm_app::transfer(const TFilename& file)
/////////////////////////////////
bool TCommCSV::transfer(const TFilename& file)
{ {
TLog_report log("Inserimento Commesse"); TLog_report log("Importazione Commesse");
TToken_string rec(50,',');
//Instazio lo scanner con cui leggerò il file di testo
//che contiene codcms|gr|co|stco
TScanner s(file); TScanner s(file);
TToken_string rec(50, ',');
rec = s.line(); rec = s.line();
//Instanzio la tabella che devo riempire
TTable comm("CMS"); TTable comm("CMS");
TProgind pi(fsize(file),"Inserimento Commesse in corso...",true,true); TProgind pi(fsize(file), "Importazione Commesse in corso...", true, true);
//scorro tutto il file (per ogni riga devo riportare l'esito dell'importazione nel log)
while (s.ok()) while (s.ok())
{ {
if (!pi.addstatus(s.tellg())) if (!pi.addstatus(s.tellg()))
break; break;
TString str = "La commessa "; TString codtab = rec.get(0); codtab.strip("\"");
TString codtab = rec.get(0);
codtab.strip("\"");
//salto le righe vuote del file //salto le righe vuote del file
if (codtab.empty()) if (codtab.empty())
continue; continue;
//recupero i dati di interesse dal file
TString descr = "IDLAVORO "; descr << codtab;
//gruppo conto e sottoconto devono avere dei valori sensati
TString gr = rec.get(1); gr.strip("\""); (gr == "" || gr == "?") ? gr ="0" : gr = gr;
TString co = rec.get(2); co.strip("\""); (co == "" || co == "?") ? co ="0" : co = co;
TString sc = rec.get(3); sc.strip("\""); (sc == "" || sc == "?") ? sc ="0" : sc = gr;
comm.zero(); comm.zero();
comm.put("CODTAB", codtab); //setto il campo CODTAB comm.put("CODTAB", codtab); //setto il campo CODTAB
comm.put("S0", descr); //setto il campo descrizione (S0)
TString tmp = "IDLAVORO "; comm.put("I1", gr); //setto il campo gruppo (I1)
tmp << codtab; comm.put("I2", co); //setto il campo conto (I2)
comm.put("I3", sc); //setto il campo sottoconto (I3)
comm.put("S0", tmp); //setto il campo descrizione (S0)
TString gr = rec.get(1);
gr.strip("\"");
TString co = rec.get(2);
co.strip("\"");
TString sc = rec.get(3);
sc.strip("\"");
//inserisco il gruppo, il conto e il sottoconto
//solo se esistono e/o hanno valori sensati
if (gr == "" || gr == "?")
gr = "0";
comm.put("I1", gr);
if (co == "" || co == "?")
co = "0";
comm.put("I2", co);
if (sc == "" || sc == "?")
sc = "0";
comm.put("I3", sc);
//salvo ciò che ho appena importato
int err = comm.write(); int err = comm.write();
if (err == NOERR) //preparo il log con tutti i risultati delle operazioni svolte
TString str = "La commessa ";
switch(err)
{ {
str << codtab << " è stata inserita"; case NOERR: str << codtab << " è stata inserita"; log.log(0, str); break;
log.log(0, str); case 224: str << codtab << " NON è stata inserita perchè esiste già"; log.log(2, str); break;
} default: str << codtab << " NON è stata inserita. Errore = " << err; log.log(2, str); break;
else
{
if (err == 224)
str << codtab << " NON è stata inserita perchè esiste già";
else
str << codtab << " NON è stata inserita. Errore = " << err;
log.log(2, str);
} }
//leggo la riga successiva
rec = s.line(); rec = s.line();
} }
//stampo a video il log
TReport_book buc; TReport_book buc;
buc.add(log); buc.add(log);
buc.preview(); buc.preview();
@ -176,70 +124,38 @@ bool TCommCSV::transfer(const TFilename& file)
return true; return true;
} }
void TCommCSV::mask2ini() bool TImporta_comm_app::create()
{ {
//carica i parametri del file di configurazione _msk = new TImporta_comm_msk();
_configfile->set_paragraph("MAIN");
for (int i = 0; i < _msk->fields() ; i++)
{
TMask_field& f = _msk->fld(i);
const TFieldref* fr = f.field();
if (fr != NULL)
_configfile->set(fr->name(), f.get());
}
}
void TCommCSV::ini2mask()
{
//carica i parametri del file di configurazione
_configfile->set_paragraph("MAIN");
for (int i = 0; i < _msk->fields() ; i++)
{
TMask_field& f = _msk->fld(i);
const TFieldref* fr = f.field();
if (fr != NULL)
f.set(_configfile->get(fr->name()));
}
}
bool TCommCSV::create()
{
_configfile = new TConfig("ps0713conf.ini");
_msk = new TImportaComm_mask();
return TSkeleton_application::create(); return TSkeleton_application::create();
} }
bool TCommCSV::destroy() bool TImporta_comm_app::destroy()
{ {
delete _msk; delete _msk;
delete _configfile;
return TApplication::destroy(); return TApplication::destroy();
} }
void TCommCSV::main_loop() void TImporta_comm_app::main_loop()
{ {
KEY tasto; KEY tasto;
ini2mask();
tasto = _msk->run(); tasto = _msk->run();
if (tasto == K_ENTER) if (tasto == K_ENTER)
{ {
mask2ini();
//genero il nome del file da caricare //genero il nome del file da caricare
TFilename name = _msk->get(F_PATH); TFilename name = _msk->get(F_PATH);
name.add(_msk->get(F_NAME)); name.add(_msk->get(F_NAME));
TString str;
if (transfer(name)) if (transfer(name))
{ message_box(TR("Importazione commesse completata"));
message_box(TR("Importazione documenti completata")); else
} error_box(TR("L'importazione non è andata a buon fine"));
} }
} }
int ps0713200 (int argc, char* argv[]) int ps0713200 (int argc, char* argv[])
{ {
TCommCSV main_app; TImporta_comm_app main_app;
main_app.run(argc, argv, TR("Importazione Commesse")); main_app.run(argc, argv, TR("Importazione Commesse"));
return true; return true;
} }

7
ps/ps0713200a.h
View File

@ -1,6 +1,3 @@
//campi maschera ps0713200a //campi maschera ps0713200a
#define F_PATH 101
#define F_CODITTA 101 #define F_NAME 102
#define F_RAGSOC 102
#define F_PATH 103
#define F_NAME 104

57
ps/ps0713200a.uml
View File

@ -1,59 +1,38 @@
#include "ps0713200a.h" #include "ps0713200a.h"
PAGE "Importazione dati commesse da file" -1 -1 78 12 TOOLBAR "" 0 0 0 2
GROUPBOX DLG_NULL 76 3 #include <elabar.h>
ENDPAGE
PAGE "Importazione dati commesse da file" 0 0 0 0
STRING DLG_PROFILE 50
BEGIN BEGIN
PROMPT 2 1 "@bDitta corrente" PROMPT 1 -1 "Profilo "
PSELECT
FLAGS "H"
END END
NUMBER F_CODITTA 5 GROUPBOX DLG_NULL 78 4
BEGIN BEGIN
PROMPT 3 2 "Codice " PROMPT 1 1 "@bSorgente"
FLAGS "FD"
USE LF_NDITTE
INPUT CODDITTA F_CODITTA
OUTPUT F_RAGSOC RAGSOC
CHECKTYPE REQUIRED
END END
STRING F_RAGSOC 50 STRING F_PATH 255 50
BEGIN BEGIN
PROMPT 23 2 "" PROMPT 2 2 "Cartella "
FLAGS "D"
END
GROUPBOX DLG_NULL 76 4
BEGIN
PROMPT 2 4 "@bSorgente"
END
STRING F_PATH 256 39
BEGIN
PROMPT 3 5 "Cartella "
DSELECT DSELECT
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
FIELD ComInPath FIELD ComInPath
END END
STRING F_NAME 18 STRING F_NAME 255 50
BEGIN BEGIN
PROMPT 3 6 "File " PROMPT 2 3 "File "
FSELECT "*.*"
FIELD ComInFile FIELD ComInFile
END END
BUTTON DLG_ELABORA 10 2
BEGIN
PROMPT -12 -1 ""
PICTURE BMP_ELABORA
MESSAGE EXIT,K_ENTER
END
BUTTON DLG_QUIT 10 2
BEGIN
PROMPT -22 -1 ""
END
ENDPAGE
ENDMASK ENDMASK

106
ps/ps0713400.cpp
View File

@ -1,23 +1,17 @@
#include <applicat.h>
#include <automask.h> #include <automask.h>
#include <progind.h> #include <progind.h>
#include <utility.h>
#include <textset.h> #include <textset.h>
#include "ps0713.h"
#include "ps0713400a.h"
#include "../cg/cglib01.h"
#include "../mg/anamag.h"
#include "../ve/velib.h" #include "../ve/velib.h"
#include "clifo.h" #include "ps0713400a.h"
#include "doc.h"
#include "rdoc.h"
/////////////////////////////////////////////////////////// ///////////////////////////////////
// TAutomask //// TIMPORTA_FATVEN_MSK ////
/////////////////////////////////////////////////////////// ///////////////////////////////////
//Classe TImporta_fatven_msk
class TImporta_fatven_msk : public TAutomask class TImporta_fatven_msk : public TAutomask
{ {
protected: protected:
@ -31,54 +25,30 @@ TImporta_fatven_msk::TImporta_fatven_msk() :TAutomask ("ps0713400a")
{ {
} }
//ON_FIELD_EVENT: metodo che gestisce i comportamenti dei vari campi della maschera
//(per adesso segnaposto)
bool TImporta_fatven_msk::on_field_event(TOperable_field& f, TField_event e, long jolly) bool TImporta_fatven_msk::on_field_event(TOperable_field& f, TField_event e, long jolly)
{ {
switch (f.dlg())
{
//giochetto per avere la lista dei files validi nella directory di trasferimento!
case F_NAME:
if (e == fe_button)
{
TArray_sheet as(-1, -1, 72, 20, TR("Selezione file"),"File@32");
TFilename path = get(F_PATH);
path.add("*.csv"); //files delle testate
list_files(path, as.rows_array());
TFilename name;
FOR_EACH_ARRAY_ROW(as.rows_array(), i, row)
{
name = *row;
*row = name.name();
}
if (as.run() == K_ENTER)
{
f.set(as.row(as.selected()));
}
}
break;
default:
break;
}
return true; return true;
} }
/////////////////////////////////////////////// ///////////////////////////////////
//// CLASSI DERIVATE PER IMPORTAZIONE DATI //// //// TIMPORTA_FATVEN_REC ////
/////////////////////////////////////////////// ///////////////////////////////////
///////////////////////////////////////////////////////////// //Classe TImporta_fatven_rec
// Recordset specifici per i dati da trasferire class TImporta_fatven_rec : public TCSV_recordset
/////////////////////////////////////////////////////////////
class TImporta_fatven_recset : public TCSV_recordset
{ {
protected: protected:
virtual TRecnotype new_rec(const char* buf = NULL); virtual TRecnotype new_rec(const char* buf = NULL);
public: public:
TImporta_fatven_recset(const char * fileName); TImporta_fatven_rec(const char * fileName);
}; };
TRecnotype TImporta_fatven_recset::new_rec(const char* buf) //NEW_REC: metodo che crea una nuova riga del recordset, cambiando il separatore col carattere TAB
//e eliminando eventuali doppi apici agli estremi del campo
TRecnotype TImporta_fatven_rec::new_rec(const char* buf)
{ {
TToken_string str(256,'\t'); //nuovo record tab separator TToken_string str(256,'\t'); //nuovo record tab separator
@ -116,16 +86,18 @@ TRecnotype TImporta_fatven_recset::new_rec(const char* buf)
return n; return n;
} }
//metodo contruttre
TImporta_fatven_recset::TImporta_fatven_recset(const char * fileName) TImporta_fatven_rec::TImporta_fatven_rec(const char * fileName)
: TCSV_recordset("CSV(,)") : TCSV_recordset("CSV(,)")
{ {
load_file(fileName); load_file(fileName);
} }
/////////////////////////////////////// ///////////////////////////////////
// TSkeleton_application //// TIMPORTA_FATVEN_APP ////
/////////////////////////////////////// ///////////////////////////////////
//Classe TImporta_fatven_app
class TImporta_fatven_app : public TSkeleton_application class TImporta_fatven_app : public TSkeleton_application
{ {
virtual bool check_autorization() const {return false;} virtual bool check_autorization() const {return false;}
@ -135,8 +107,8 @@ class TImporta_fatven_app : public TSkeleton_application
protected: protected:
long togli_apici_numero(TImporta_fatven_recset& s, int i); long togli_apici_numero(TImporta_fatven_rec& s, int i);
const TString& togli_apici(TImporta_fatven_recset& s, int i); const TString& togli_apici(TImporta_fatven_rec& s, int i);
bool find_clifo(long& codcf, TString& paiv, long& abi, long& cab, TString& codpag); bool find_clifo(long& codcf, TString& paiv, long& abi, long& cab, TString& codpag);
public: public:
@ -148,14 +120,18 @@ public:
TImporta_fatven_app() {} TImporta_fatven_app() {}
}; };
long TImporta_fatven_app::togli_apici_numero(TImporta_fatven_recset & s, int i) //TOGLI_APICI_NUMERO: metodo che restituisce un campo del recordset come numero
//preoccupandosi prima di eliminare eventuali doppi apici
long TImporta_fatven_app::togli_apici_numero(TImporta_fatven_rec& s, int i)
{ {
TString80 tmp = s.get(i).as_string(); TString80 tmp = s.get(i).as_string();
tmp.strip("\""); tmp.strip("\"");
return atol(tmp); return atol(tmp);
} }
const TString& TImporta_fatven_app::togli_apici(TImporta_fatven_recset & s, int i) //TOGLI_APICI: metodo che restituisce un campo del recordset come stringa
//preoccupandosi prima di eliminare eventuali doppi apici
const TString& TImporta_fatven_app::togli_apici(TImporta_fatven_rec & s, int i)
{ {
TString& tmp = get_tmp_string(); TString& tmp = get_tmp_string();
tmp = s.get(i).as_string(); tmp = s.get(i).as_string();
@ -164,6 +140,8 @@ const TString& TImporta_fatven_app::togli_apici(TImporta_fatven_recset & s, int
return tmp; return tmp;
} }
//FIND_CLIFO: metodo che cerca un cliente dati codcf e paiv: se lo trova setta tutti i campi di interesse
//legati al cliente e restituisce true; in caso contrario restituisce false
bool TImporta_fatven_app::find_clifo(long& codcf, TString& paiv, long& abi, long& cab, TString& codpag) bool TImporta_fatven_app::find_clifo(long& codcf, TString& paiv, long& abi, long& cab, TString& codpag)
{ {
if (!paiv.blank()) if (!paiv.blank())
@ -183,12 +161,14 @@ bool TImporta_fatven_app::find_clifo(long& codcf, TString& paiv, long& abi, long
return false; return false;
} }
//TRANSFER: metodo che effettivamente fa l'elaborazione del file di input, generando i vari documenti
//pronti per essere contabilizzati
bool TImporta_fatven_app::transfer(const TFilename& file) bool TImporta_fatven_app::transfer(const TFilename& file)
{ {
const TString4 codnum = "F01"; //?????????????????????????? const TString4 codnum = "F01"; //Da analisi
const TString4 tpdoc = "F01"; //?????????????????????????? const TString4 tpdoc = "F01"; //Da analisi
TImporta_fatven_recset s(file); TImporta_fatven_rec s(file);
TProgind pi(s.items(),"Importazione fatture in corso ...",true,true); TProgind pi(s.items(),"Importazione fatture in corso ...",true,true);
@ -207,7 +187,6 @@ bool TImporta_fatven_app::transfer(const TFilename& file)
return true; return true;
} }
for (bool ok = s.move_first(); ok; ok = s.move_next()) for (bool ok = s.move_first(); ok; ok = s.move_next())
{ {
if (!pi.addstatus(1)) if (!pi.addstatus(1))
@ -279,7 +258,6 @@ bool TImporta_fatven_app::transfer(const TFilename& file)
long cab; long cab;
TString4 codpag; TString4 codpag;
if (!find_clifo(codcf, paiv, abi, cab, codpag)) if (!find_clifo(codcf, paiv, abi, cab, codpag))
{ {
//campi cliente (da utilizzare se non esiste già) //campi cliente (da utilizzare se non esiste già)
@ -386,6 +364,7 @@ bool TImporta_fatven_app::transfer(const TFilename& file)
return true; return true;
} }
//CREATE: metodo che instanzia maschera e appicazione
bool TImporta_fatven_app::create() bool TImporta_fatven_app::create()
{ {
_msk = new TImporta_fatven_msk(); _msk = new TImporta_fatven_msk();
@ -393,6 +372,7 @@ bool TImporta_fatven_app::create()
return TSkeleton_application::create(); return TSkeleton_application::create();
} }
//DESTROY: metodo che rilascia maschera e applicazione
bool TImporta_fatven_app::destroy() bool TImporta_fatven_app::destroy()
{ {
delete _msk; delete _msk;

7
ps/ps0713400a.h
View File

@ -1,6 +1,3 @@
//campi maschera ps0713400a //campi maschera ps0713400a
#define F_PATH 201
#define F_CODITTA 101 #define F_NAME 202
#define F_RAGSOC 102
#define F_PATH 103
#define F_NAME 104

56
ps/ps0713400a.uml
View File

@ -1,68 +1,38 @@
#include "ps0713400a.h" #include "ps0713400a.h"
TOOLBAR "" 0 20 0 2 TOOLBAR "topbar" 0 0 0 2
BUTTON DLG_ELABORA 10 2 #include <elabar.h>
BEGIN
PICTURE BMP_ELABORA
MESSAGE EXIT,K_ENTER
PROMPT -12 -1 ""
END
BUTTON DLG_QUIT 10 2 ENDPAGE
BEGIN
PROMPT -22 -1 "" PAGE "Inserimento fatture" -1 -1 80 10
END
STRING DLG_PROFILE 50 STRING DLG_PROFILE 50
BEGIN BEGIN
PROMPT 9 0 "Profilo " PROMPT 9 -12 "Profilo "
PSELECT PSELECT
FLAGS "H" FLAGS "H"
END END
ENDPAGE GROUPBOX DLG_NULL 78 4
PAGE "Inserimento fatture" 0 0 0 -3
GROUPBOX DLG_NULL 90 3
BEGIN BEGIN
PROMPT 2 1 "@bDitta corrente" PROMPT 1 1 "@bSorgente"
END END
NUMBER F_CODITTA 5 STRING F_PATH 255 50
BEGIN BEGIN
PROMPT 3 2 "Codice " PROMPT 2 2 "Cartella "
FLAGS "FD"
USE LF_NDITTE
INPUT CODDITTA F_CODITTA
OUTPUT F_RAGSOC RAGSOC
CHECKTYPE REQUIRED
END
STRING F_RAGSOC 50
BEGIN
PROMPT 23 2 ""
FLAGS "D"
END
GROUPBOX DLG_NULL 90 4
BEGIN
PROMPT 2 4 "@bSorgente"
END
STRING F_PATH 256 39
BEGIN
PROMPT 3 5 "Cartella "
DSELECT DSELECT
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
FIELD ComInPath FIELD ComInPath
END END
STRING F_NAME 18 STRING F_NAME 255 50
BEGIN BEGIN
PROMPT 3 6 "File " PROMPT 2 3 "File "
FIELD ComInFile FIELD ComInFile
FSELECT "*.csv"
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
END END