Patch level : NO PATCH

Files correlati     :
Ricompilazione Demo : [ ]
Commento            :
Aggiunto in prima versione


git-svn-id: svn://10.65.10.50/branches/R_10_00@21193 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
luca83 2010-11-25 08:52:50 +00:00
parent 8699be41fa
commit 335f4aa082
3 changed files with 448 additions and 0 deletions

404
lv/lv4500.cpp Executable file
View File

@ -0,0 +1,404 @@
#include <applicat.h>
#include <automask.h>
#include <execp.h>
#include <progind.h>
#include <reputils.h>
#include <utility.h>
#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>
#include "../ce/ammce.h"
#include "../ce/cespi.h"
#include "../ce/salce.h"
#include "../cg/cg2103.h"
#include "../cg/cglib01.h"
#include "lv4.h"
#include "lv4100.h"
#include "lv4500a.h"
#define T_N "N"
#define T_X "X"
/////////////////////////////////
//// LAUNDRY_RECORDSET ////
/////////////////////////////////
//Classe TLaundry_recordset: è un TAS400_recordset "intelligente"
class TLaundry_recordset : public TAS400_recordset
{
public:
void add_field(const char* name, const char* tipo, int pos, int len);
TLaundry_recordset(const int rec_length);
};
//ADD_FIELD: aggiunge i campi al recordset
void TLaundry_recordset::add_field(const char* name, const char* tipo, int pos, int len)
{
const TFixed_string str_tipo(tipo);
if (str_tipo.ends_with("N"))
{
create_field(name, pos-1, len, _intzerofld);
return;
}
create_field(name, pos-1, len, _alfafld);
}
TLaundry_recordset::TLaundry_recordset(const int rec_lenght)
: TAS400_recordset("AS400()")
{
TString16 query;
query << "AS400(" << rec_lenght << ")";
TFilename cazzone;
parse_query(query, cazzone);
}
////////////////////////////////
//// TIMPORTA_FAT_REC ////
////////////////////////////////
class TImporta_fat_rec : public TLaundry_recordset
{
protected:
virtual TRecnotype new_rec(const char* trc);
public:
TImporta_fat_rec(const TFilename& filename);
};
/////////////////////////////////////////////////////////////
// Recordset specifici per i dati da trasferire INPUT
/////////////////////////////////////////////////////////////
TRecnotype TImporta_fat_rec::new_rec(const char* trc)
{
if (trc && *trc > ' ')
{
TString rec; rec << trc << "\r\n";
return TText_recordset::new_rec(rec);
}
return -1;
}
//questo invece è il metodo magico che vale per il caricamento da file esterno
TImporta_fat_rec::TImporta_fat_rec(const TFilename& filename)
: TLaundry_recordset(89)
{
TFilename cazzone;
//as400 con lunghezza 89 e chiave lunga 1 (a partire dal ventesimo carattere): è il tipo record
parse_query("AS400(89,20,1)", cazzone);
//Tipo record C
add_field("NDOC", T_N, 1, 6);
add_field("DATADOC", T_N, 7, 8);
add_field("NPART", T_N, 15, 6);
add_field("TIPOMOV", T_X, 21, 1);
add_field("SEZIONE", T_X, 22, 1);
add_field("CODCF", T_N, 23, 6);
add_field("IMPORTO", T_X, 29, 13);
add_field("CODVAL", T_X, 42, 4);
add_field("CODPAG", T_X, 46, 4);
add_field("DATASCAD", T_N, 50, 8);
add_field("ABICAB", T_N, 58, 12);
add_field("CODCAU", T_N, 70, 4);
add_field("REGIVA", T_X, 74, 1);
add_field("NREGIVA", T_N, 75, 2);
add_field("NPROG", T_N, 77, 11);
//Tipo record G
add_field("NDOC", T_N, 1, 6);
add_field("DATADOC", T_N, 7, 8);
add_field("NPART", T_N, 15, 6);
add_field("TIPOMOV", T_X, 21, 1);
add_field("SEZIONE", T_X, 22, 1);
add_field("IMPORTO", T_X, 23, 13);
add_field("CODMASTRO", T_N, 36, 6);
add_field("CODCONTO", T_N, 42, 6);
//Tipo record I
add_field("NDOC", T_N, 1, 6);
add_field("DATADOC", T_N, 7, 8);
add_field("NPART", T_N, 15, 6);
add_field("TIPOMOV", T_X, 21, 1);
add_field("SEZIONE", T_X, 22, 1);
add_field("IMPONIBILE", T_X, 23, 13);
add_field("IMPOSTA", T_X, 36, 11);
add_field("CODIVA", T_N, 47, 4);
add_field("CODMASTRO", T_N, 36, 6);
add_field("CODCONTO", T_N, 42, 6);
//Tipo record R
add_field("NDOC", T_N, 1, 6);
add_field("DATADOC", T_N, 7, 8);
add_field("NPART", T_N, 15, 6);
add_field("TIPOMOV", T_X, 21, 1);
add_field("NRATA", T_N, 22, 6);
add_field("IMPRATA", T_X, 28, 13);
add_field("TIPORATA", T_X, 41, 1);
add_field("DATASCAD", T_N, 42, 8);
TText_recordset::load_file(filename);
}
///////////////////////////////////////////////////////////
// TAutomask
///////////////////////////////////////////////////////////
class TImporta_fat_msk : public TAutomask
{
protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
TImporta_fat_msk();
};
TImporta_fat_msk::TImporta_fat_msk() :TAutomask ("lv4500a")
{
}
bool TImporta_fat_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("*.txt"); //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;
}
///////////////////////////////////////
// TSkeleton_application
///////////////////////////////////////
class TImporta_fat_app : public TSkeleton_application
{
TImporta_fat_msk* _msk;
protected:
bool search_gr_sp_ca(const int gruppo, const char* specie, const int categoria);
const TFilename crea_tmpdir() const;
const TFilename crea_nomefile(const long ndoc) const;
const int segno_testata(const char sezione, const TCausale& cau) const;
const int segno_riga(const char sezione, const TCausale& cau) const;
const TString16 genera_real(const TVariant importo, const int segno) const;
void genera_testata(TImporta_fat_rec& recset, TConfig* conf, TFilename& tmpdir);
//void genera_contropartite(TImporta_fat_rec& recset, TConfig* configfile);
void genera_righe_iva(TImporta_fat_rec& recset, TConfig* conf, int nriga, const TCausale& cau);
void genera_rate(TImporta_fat_rec& recset, TConfig* conf, int nriga);
void elabora_file(const TFilename& tmpdir);
void elimina_file(const TFilename& tmpdir);
public:
virtual bool create();
virtual bool destroy();
virtual void main_loop();
void transfer(const TFilename& file);
};
bool TImporta_fat_app::search_gr_sp_ca(const int gruppo, const char* specie, const int categoria)
{
return true;
}
const TFilename TImporta_fat_app::crea_tmpdir() const
{
TFilename tmpdir;
tmpdir.tempdir();
tmpdir.add("fatture");
make_dir(tmpdir);
return tmpdir;
}
const TFilename TImporta_fat_app::crea_nomefile(const long ndoc) const
{
TString strname;
strname.format("%06l", ndoc);
strname << ".ini";
return strname;
}
const int TImporta_fat_app::segno_testata(const char sezione, const TCausale& cau) const
{
return cau.sezione_clifo() == sezione ? 1 : -1;
}
const int TImporta_fat_app::segno_riga(const char sezione, const TCausale& cau) const
{
return cau.sezione_clifo() == sezione ? -1 : 1;
}
const TString16 TImporta_fat_app::genera_real(const TVariant importo, const int segno) const
{
real imp = importo.as_real();
imp /= CENTO;
imp *= segno;
return imp.string();
}
void TImporta_fat_app::genera_testata(TImporta_fat_rec& recset, TConfig* conf, TFilename& tmpdir)
{
const long ndoc = recset.get("NDOC").as_int();
const TDate datadoc = recset.get("DATADOC").as_date();
const TCausale cau(recset.get("CODCAU").as_string());
const int segno = segno_testata(recset.get("SEZIONE").as_string()[0], cau);
TFilename nomefile = crea_nomefile(ndoc);
conf = new TConfig(nomefile);
conf->set_paragraph("Transaction"); //setto il paragrafo [Transaction] del file ini
conf->set("Action","INSERT");
conf->set("Mode", "AUTO");
TString paragraph;
paragraph.format("%d", LF_MOV);
conf->set_paragraph(paragraph); //setto il paragrafo [23] del file ini (testata)
conf->set(MOV_ANNOES, datadoc.year());
conf->set(MOV_DATAREG, datadoc);
conf->set(MOV_DATACOMP, datadoc);
conf->set(MOV_DATADOC, datadoc);
conf->set(MOV_NUMDOC, ndoc);
conf->set(MOV_CODCAUS, recset.get("CODCAU").as_int()); //da codificare se mappato
conf->set(MOV_ANNOIVA, datadoc.year());
conf->set(MOV_REG, recset.get("REGIVA").as_int()); //da codificare se mappato
conf->set(MOV_PROTIVA, recset.get("NREGIVA").as_int());
conf->set(MOV_CODVAL, recset.get("CODVAL").as_string()); //da codificare se mappato
conf->set(MOV_TIPO, 'C');
conf->set(MOV_CODCF, recset.get("CODCF").as_int());
conf->set(MOV_TOTDOC, genera_real(recset.get("IMPORTO"), segno));
conf->set(MOV_CODPAG, recset.get("CODPAG").as_int()); //da codificare se mappato
}
void TImporta_fat_app::genera_righe_iva(TImporta_fat_rec& recset, TConfig* conf, int nriga, const TCausale& cau)
{
const TDate datadoc = recset.get("DATADOC").as_date();
const int segno = segno_riga(recset.get("SEZIONE").as_string()[0], cau);
TString paragraph;
paragraph.format("%d,%d", LF_RMOVIVA, nriga++);
conf->set_paragraph(paragraph);
conf->set(RMI_ANNOES, datadoc.year());
conf->set(RMI_CODIVA, recset.get("CODIVA").as_int()); //da codificare se mappato
conf->set(RMI_IMPONIBILE, genera_real(recset.get("IMPONIBILE"), segno));
conf->set(RMI_IMPOSTA, genera_real(recset.get("IMPOSTA"), 1));
/*Mancano Codice mastro e codice conto*/
}
void TImporta_fat_app::genera_rate(TImporta_fat_rec& recset, TConfig* conf, int nriga)
{
}
void TImporta_fat_app::elabora_file(const TFilename& tmpdir)
{
TString app;
app << "cg2 -0 -i" << tmpdir << "/*.ini";
TExternal_app primanota(app);
primanota.run(true);
}
void TImporta_fat_app::elimina_file(const TFilename& tmpdir)
{
}
void TImporta_fat_app::transfer(const TFilename& file)
{
TImporta_fat_rec recset(file);
TProgind pi(recset.items(), "Importazione in corso...", true, true);
TConfig* configfile = NULL;
TFilename tmpdir = crea_tmpdir();
int nrigai, nrigar;
for(bool ok = recset.move_first(); ok; ok = recset.move_next())
{
if (!pi.addstatus(1))
break;
const char tipomov = recset.get("TIPOMOV").as_string()[0];
const TCausale cau(recset.get("CODCAU").as_string());
switch(tipomov)
{
case 'C': genera_testata(recset, configfile, tmpdir); nrigai = nrigar = 0; break;
//case 'G': genera_contropartite(recset, configfile); break;
case 'I': genera_righe_iva(recset, configfile, nrigai, cau); break;
case 'R': genera_rate(recset, configfile, nrigar); break;
default: break;
}
}
elabora_file(tmpdir);
}
bool TImporta_fat_app::create()
{
_msk = new TImporta_fat_msk();
return TSkeleton_application::create();
}
bool TImporta_fat_app::destroy()
{
delete _msk;
return TApplication::destroy();
}
void TImporta_fat_app::main_loop()
{
KEY tasto;
tasto = _msk->run();
if (tasto == K_ENTER)
{
//genero il nome del file da caricare
TFilename file = _msk->get(F_PATH);
file.add(_msk->get(F_NAME));
if(!file.exist())
{
error_box(TR("Il file selezionato non esiste; si prega di controllare"));
return;
}
transfer(file);
}
}
int lv4500 (int argc, char* argv[])
{
TImporta_fat_app main_app;
main_app.run(argc, argv, TR("Importazione fatture COGECO"));
return true;
}

3
lv/lv4500a.h Executable file
View File

@ -0,0 +1,3 @@
//campi maschera lv4500a
#define F_PATH 101
#define F_NAME 102

41
lv/lv4500a.uml Executable file
View File

@ -0,0 +1,41 @@
#include "lv4500a.h"
TOOLBAR "" 0 0 0 2
#include "elabar.h"
ENDPAGE
TOOLBAR "" 0 21 0 2
STRING DLG_PROFILE 50
BEGIN
PROMPT 9 -1 "Profilo "
PSELECT
END
ENDPAGE
PAGE "Importazione fatture COGECO" 0 0 0 -3
GROUPBOX DLG_NULL 80 4
BEGIN
PROMPT 1 1 "@bSorgente"
END
STRING F_PATH 255 55
BEGIN
PROMPT 2 2 "Cartella "
DSELECT
CHECKTYPE REQUIRED
FIELD ComInPath
END
STRING F_NAME 18
BEGIN
PROMPT 2 3 "File "
FIELD ComInFile
CHECKTYPE REQUIRED
END
ENDPAGE
ENDMASK