root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/tc/tc9300.cpp
alex 6490226d5f Patch level : 10.0 744 
Files correlati     : tc9.exe
Ricompilazione Demo : [ ]
Commento

COrretto il calcolo del numero riga nel trasferimento sispa. Non era sempre consecutivo.


git-svn-id: svn://10.65.10.50/trunk@20477 c028cbd2-c16b-5b4b-a496-9718f37d4682
2010-05-19 13:47:33 +00:00

1972 lines
53 KiB
C++
Executable File
Raw Blame History

#include <applicat.h>
#include <automask.h>
#include <config.h>
#include <lffiles.h>
#include <prefix.h>
#include <progind.h>
#include <recarray.h>
#include <utility.h>
#include <textset.h>
#include "../cg/cglib01.h"
#include "../cg/cglib03.h"
#include "tc0.h"
#include "tc9300a.h"
#include <anagr.h>
#include <anafis.h>
#include <clifo.h>
#include <comuni.h>
#include <mov.h>
#include <nditte.h>
#include <rmov.h>
#include <rmoviva.h>
#include <multirel.h>
#define SLF_MOV "23"
#define ALIAS_REG 100
#define REG_OFFSET 1000000L
#define GIRO_OFFSET 2000000L
///////////////////////////////////////////////////////////
// TRiclassifica_cache
///////////////////////////////////////////////////////////
class TRiclassifica_cache : public TCache
{
TLocalisamfile _multirel;
protected:
virtual TObject* key2obj(const char* key);
public:
const char * sdecode(const char* tab, const TString& cod);
long decode(const char* tab, const TString& cod);
const TString & sdecode_caufor(const TString& cod);
const TString & sdecode_caureg(const TString& cod);
const TString & sdecode_caugiro(const TString& cod);
const TString & sdecode_contov(const TString& cod);
const TString & sdecode_caucon(const TString& cod);
const TString & sdecode_sezcon(const TString& cod);
bool sdecode_rc(const TString& cod);
TRiclassifica_cache() : _multirel(LF_MULTIREL) { _multirel.setkey(2);}
};
TObject* TRiclassifica_cache::key2obj(const char* key)
{
TToken_string tok(key);
TString8 tab, cod;
tok.get(0,tab);
tok.get(1, cod);
_multirel.setkey(1);
_multirel.put(MULTI_COD, tab);
_multirel.put(MULTI_FIRST, cod);
_multirel.put(MULTI_SECOND, "");
int err = _multirel.read(_isgteq);
if (err == NOERR && _multirel.get(MULTI_FIRST) == cod)
return new TString(_multirel.get(MULTI_SECOND));
return NULL;
}
long TRiclassifica_cache::decode(const char* tab, const TString& cod)
{
TToken_string tok;
tok.add(tab);
tok.add(cod);
const TString* ric = (const TString*) objptr(tok);
return (ric ? atol(*ric) : 0);
}
const TString & TRiclassifica_cache::sdecode_caufor(const TString& cod)
{
TString & codricl = get_tmp_string();
TToken_string tok;
tok.add("SCCAU");
tok.add(cod);
const TString* ric = (const TString*) objptr(tok);
if (ric && *ric)
{
_multirel.setkey(1);
_multirel.put(MULTI_COD, "SCCAU");
_multirel.put(MULTI_FIRST, cod);
_multirel.put(MULTI_SECOND, *ric);
int err = _multirel.read(_isequal);
if (err == NOERR)
codricl = _multirel.get(MULTI_DATA).sleft(5);
}
return codricl;
}
const TString & TRiclassifica_cache::sdecode_caureg(const TString& cod)
{
TString & codricl = get_tmp_string();
TToken_string tok;
tok.add("SCCAU");
tok.add(cod);
const TString* ric = (const TString*) objptr(tok);
if (ric && *ric)
{
_multirel.setkey(1);
_multirel.put(MULTI_COD, "SCCAU");
_multirel.put(MULTI_FIRST, cod);
_multirel.put(MULTI_SECOND, *ric);
int err = _multirel.read(_isequal);
if (err == NOERR)
codricl = _multirel.get(MULTI_DATA).smid(6, 5);
}
return codricl;
}
bool TRiclassifica_cache::sdecode_rc(const TString& cod)
{
TString & codricl = get_tmp_string();
TToken_string tok;
tok.add("SCCAU");
tok.add(cod);
const TString* ric = (const TString*) objptr(tok);
if (ric && *ric)
{
_multirel.setkey(1);
_multirel.put(MULTI_COD, "SCCAU");
_multirel.put(MULTI_FIRST, cod);
_multirel.put(MULTI_SECOND, *ric);
int err = _multirel.read(_isequal);
if (err == NOERR)
codricl = _multirel.get(MULTI_DATA).smid(5, 1);
}
return codricl.full();
}
const TString & TRiclassifica_cache::sdecode_caugiro(const TString& cod)
{
TString & codricl = get_tmp_string();
TToken_string tok;
tok.add("SCCAU");
tok.add(cod);
const TString* ric = (const TString*) objptr(tok);
if (ric && *ric)
{
_multirel.setkey(1);
_multirel.put(MULTI_COD, "SCCAU");
_multirel.put(MULTI_FIRST, cod);
_multirel.put(MULTI_SECOND, *ric);
int err = _multirel.read(_isequal);
if (err == NOERR)
codricl = _multirel.get(MULTI_DATA).smid(11, 5);
}
return codricl;
}
const TString & TRiclassifica_cache::sdecode_caucon(const TString& cod)
{
TString & codricl = get_tmp_string();
TToken_string tok;
tok.add("SCCAU");
tok.add(cod);
const TString* ric = (const TString*) objptr(tok);
if (ric && *ric)
{
_multirel.setkey(1);
_multirel.put(MULTI_COD, "SCCAU");
_multirel.put(MULTI_FIRST, cod);
_multirel.put(MULTI_SECOND, *ric);
int err = _multirel.read(_isequal);
if (err == NOERR)
codricl = _multirel.get(MULTI_DATA).smid(28, 5);
}
return codricl;
}
const TString & TRiclassifica_cache::sdecode_sezcon(const TString& cod)
{
TString & codricl = get_tmp_string();
TToken_string tok;
tok.add("SCCAU");
tok.add(cod);
const TString* ric = (const TString*) objptr(tok);
if (ric && *ric)
{
_multirel.setkey(1);
_multirel.put(MULTI_COD, "SCCAU");
_multirel.put(MULTI_FIRST, cod);
_multirel.put(MULTI_SECOND, *ric);
int err = _multirel.read(_isequal);
if (err == NOERR)
codricl = _multirel.get(MULTI_DATA).smid(33, 1);
}
return codricl;
}
const TString & TRiclassifica_cache::sdecode_contov(const TString& cod)
{
TString & codricl = get_tmp_string();
TToken_string tok;
tok.add("SCCAU");
tok.add(cod);
const TString* ric = (const TString*) objptr(tok);
if (ric && *ric)
{
_multirel.setkey(1);
_multirel.put(MULTI_COD, "SCCAU");
_multirel.put(MULTI_FIRST, cod);
_multirel.put(MULTI_SECOND, *ric);
int err = _multirel.read(_isequal);
if (err == NOERR)
codricl = _multirel.get(MULTI_DATA).smid(16, 12);
}
return codricl;
}
const char * TRiclassifica_cache::sdecode(const char* tab, const TString& cod)
{
TToken_string tok;
tok.add(tab);
tok.add(cod);
const TString* ric = (const TString*) objptr(tok);
return ric ? (const char *) *ric : "";
}
class TMovim_set : public TAS400_recordset
{
protected:
void add_field(const char* name = "Filler", int from = -1, int len = 0, char tipo = 'a',
const char* def = NULL);
public:
TMovim_set();
};
void TMovim_set::add_field(const char* name, int from, int len,
char tipo, const char* def)
{
const bool required = false;
TString80 fname(name);
const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
const int pos = from - 1;
if (def && *def)
{
CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
TVariant var(def); var.convert_to(t);
create_field(fname, pos, len, t, required, var);
}
else
create_field(fname, pos, len, t, required);
}
TMovim_set::TMovim_set() : TAS400_recordset("AS400(217)")
{
create_field("COFI", -1, 16, _alfafld);
create_field("PAIV", -1, 11, _alfafld);
create_field("RAGSOC", -1, 50, _alfafld);
create_field("ESIVA", -1, 2, _alfafld);
create_field("ESCOGE", -1, 4, _alfafld);
create_field("ARGOMENTO", -1, 1, _alfafld);
create_field("COMPETENZA", -1, 1, _alfafld);
create_field("NUMPART", -1, 7, _longzerofld);
create_field("NUMINT", -1, 3, _longzerofld);
create_field("DATAOP", -1, 6, _longzerofld);
create_field("CODCONTO", -1, 12, _alfafld);
create_field("TIPOREG", -1, 2, _longzerofld);
create_field("CODREG", -1, 2, _longzerofld);
create_field("NUMPROT", -1, 7, _longzerofld);
create_field("TIPOART", -1, 1, _longzerofld);
create_field("TIPOMOV", -1, 1, _alfafld);
create_field("CODCOST", -1, 3, _longzerofld);
create_field("CODCAUS", -1, 5, _longzerofld);
create_field("NUMDESC", -1, 1, _longzerofld);
create_field("SGNIMPT", -1, 1, _alfafld);
create_field("IMPORTO", -1, 13, _longzerofld);
create_field("SGNCONTIMP", -1, 1, _alfafld);
create_field("ANNOTAZ", -1, 30, _alfafld);
create_field("DATADOC", -1, 6, _longzerofld);
create_field("NUMDOC", -1, 7, _alfafld);
create_field("TIPOANAG", -1, 1, _alfafld);
create_field("FLGSTO", -1, 1, _alfafld);
create_field("LIBERO", -1, 20, _alfafld);
create_field("FINEREC", -1, 2, _alfafld, true, "\r\n");
}
class TIvamov_set : public TAS400_recordset
{
protected:
void add_field(const char* name = "Filler", int from = -1, int len = 0, char tipo = 'a',
const char* def = NULL);
public:
TIvamov_set();
};
void TIvamov_set::add_field(const char* name, int from, int len,
char tipo, const char* def)
{
const bool required = false;
TString80 fname(name);
const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
const int pos = from - 1;
if (def && *def)
{
CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
TVariant var(def); var.convert_to(t);
create_field(fname, pos, len, t, required, var);
}
else
create_field(fname, pos, len, t, required);
}
TIvamov_set::TIvamov_set() : TAS400_recordset("AS400(171)")
{
create_field("COFI", -1, 16, _alfafld);
create_field("PAIV", -1, 11, _alfafld);
create_field("RAGSOC", -1, 50, _alfafld);
create_field("NUMPART", -1, 7, _longzerofld);
create_field("NUMINT", -1, 2, _longzerofld);
create_field("SGNIMPB", -1, 1, _alfafld);
create_field("IMPONIBILE", -1, 13, _longzerofld);
create_field("SGNIMPIVA", -1, 1, _alfafld);
create_field("IMPOSTA", -1, 13, _longzerofld);
create_field("CODCAUS", -1, 5, _longzerofld);
create_field("CODIVA", -1, 3, _alfafld);
create_field("FILLER", -1, 2, _alfafld);
create_field("MERCIVEN", -1, 1, _alfafld);
create_field("QUADROA", -1, 1, _alfafld);
create_field("CODCOSTRIC", -1, 6, _alfafld);
create_field("FLGES", -1, 1, _alfafld);
create_field("DETRAIB", -1, 5, _longzerofld);
create_field("CODTABPRODAG", -1, 3, _alfafld);
create_field("CODIVACOMPAG", -1, 3, _alfafld);
create_field("DATAFATTSOSP", -1, 1, _alfafld);
create_field("MULTIPUNTO", -1, 2, _alfafld);
create_field("LIBERO", -1, 22, _alfafld);
create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}
class TIntramov_set : public TAS400_recordset
{
protected:
void add_field(const char* name = "Filler", int from = -1, int len = 0, char tipo = 'a',
const char* def = NULL);
public:
TIntramov_set();
};
void TIntramov_set::add_field(const char* name, int from, int len,
char tipo, const char* def)
{
const bool required = false;
TString80 fname(name);
const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
const int pos = from - 1;
if (def && *def)
{
CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
TVariant var(def); var.convert_to(t);
create_field(fname, pos, len, t, required, var);
}
else
create_field(fname, pos, len, t, required);
}
TIntramov_set::TIntramov_set() : TAS400_recordset("AS400(206)")
{
create_field("COFI", -1, 16, _alfafld);
create_field("PAIV", -1, 11, _alfafld);
create_field("RAGSOC", -1, 50, _alfafld);
create_field("TIPOREC", -1, 1, _alfafld);
create_field("ESERCIZIO", -1, 4, _longzerofld);
create_field("NUMPART", -1, 7, _longzerofld);
create_field("NUMPROG", -1, 2, _longzerofld);
create_field("SGNIMPT", -1, 1, _alfafld);
create_field("IMPORTO", -1, 13, _longzerofld);
create_field("SGNVAL", -1, 1, _alfafld);
create_field("IMPVAL", -1, 13, _longzerofld);
create_field("TRANSAZ", -1, 1, _longzerofld);
create_field("NOMENC", -1, 8, _longzerofld);
create_field("MASSA", -1, 10, _longzerofld);
create_field("UNIT", -1, 10, _longzerofld);
create_field("SGNSTAT", -1, 1, _alfafld);
create_field("IMPVAL", -1, 13, _longzerofld);
create_field("RGMCONS", -1, 1, _alfafld);
create_field("MODTRASP", -1, 1, _longzerofld);
create_field("PAPROV", -1, 2, _alfafld);
create_field("PADEST", -1, 2, _alfafld);
create_field("PROVINCIA", -1, 2, _alfafld);
create_field("MESE", -1, 2, _longzerofld);
create_field("TRIMESTRE", -1, 1, _longzerofld);
create_field("ANNO", -1, 1, _longzerofld);
create_field("SGNATTRIB", -1, 1, _alfafld);
create_field("ESIVA", -1, 2, _longzerofld);
create_field("CODCLIFO", -1, 6, _alfafld);
create_field("LIBERO", -1, 20, _alfafld);
create_field("FINEREC", -1, 2, _alfafld, true, "\r\n");
}
/* non li abbiamo i ratei
class TRateimov_set : public TAS400_recordset
{
protected:
void add_field(const char* name = "Filler", int len = 0, char tipo = 'a',
int from = -1, const char* def = NULL);
public:
TRateimov_set();
};
void TRateimov_set::add_field(const char* name, int len,
char tipo, int from, const char* def)
{
const bool required = false;
TString80 fname(name);
const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
const int pos = from - 1;
if (def && *def)
{
CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
TVariant var(def); var.convert_to(t);
create_field(fname, pos, len, t, required, var);
}
else
create_field(fname, pos, len, t, required);
}
TRateimov_set::TRateimov_set() : TAS400_recordset("AS400(222)")
{
create_field("COFI", -1, 16, _alfafld);
create_field("PAIV", -1, 11, _alfafld);
create_field("RAGSOC", -1, 50, _alfafld);
create_field("ESCOGEIN", -1, 4, _longzerofld);
create_field("ESCOGEFI", -1, 4, _longzerofld);
create_field("NUMPART", -1, 7, _longzerofld);
create_field("NUMPROG", -1, 3, _longzerofld);
create_field("INRATRIS", -1, 8, _longzerofld);
create_field("FIRATRIS", -1, 8, _longzerofld);
create_field("CODCPART", -1, 6, _alfafld);
create_field("CODCCONT", -1, 6, _alfafld);
create_field("SGNIMPT", -1, 1, _alfafld);
create_field("IMPORTO", -1, 13, _longzerofld);
create_field("SGNCNIMPT", -1, 1, _alfafld);
create_field("CODCLIFO", -1, 6, _alfafld);
create_field("DATADOC", -1, 8, _longzerofld);
create_field("NUMDOC", -1, 7, _alfafld);
create_field("ANNOTAZ", -1, 30, _alfafld);
create_field("DATAOP", -1, 8, _longzerofld);
create_field("CCOSTO", -1, 3, _longzerofld);
create_field("LIBERO", -1, 20, _alfafld);
create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}
*/
class TForsisp_set : public TAS400_recordset
{
protected:
void add_field(const char* name = "Filler", int from = -1, int len = 0, char tipo = 'a',
const char* def = NULL);
public:
TForsisp_set();
};
void TForsisp_set::add_field(const char* name, int from, int len,
char tipo, const char* def)
{
const bool required = false;
TString80 fname(name);
const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
const int pos = from - 1;
if (def && *def)
{
CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
TVariant var(def); var.convert_to(t);
create_field(fname, pos, len, t, required, var);
}
else
create_field(fname, pos, len, t, required);
}
TForsisp_set::TForsisp_set() : TAS400_recordset("AS400(304)")
{
create_field("CODANAG", -1, 6, _alfafld);
create_field("COFI", -1, 16, _alfafld);
create_field("PAIV", -1, 11, _alfafld);
create_field("TIPOANAG", -1, 1, _alfafld);
create_field("RAGSOC", -1, 50, _alfafld);
create_field("INDIRIZZO", -1, 28, _alfafld);
create_field("NUMERO", -1, 7, _alfafld);
create_field("COMUNE", -1, 35, _alfafld);
create_field("CAP", -1, 5, _longzerofld);
create_field("STATEST", -1, 35, _alfafld);
create_field("TELEFONO", -1, 20, _alfafld);
create_field("TELEFAX", -1, 20, _alfafld);
create_field("TELEX", -1, 20, _alfafld);
create_field("PREFISSO", -1, 4, _alfafld);
create_field("FRAZIONE", -1, 35, _alfafld);
create_field("PROVINCIA", -1, 2, _alfafld);
create_field("TESTAZMUN", -1, 1, _alfafld);
create_field("CODCOM", -1, 4, _alfafld);
create_field("CODFRAZ", -1, 2, _alfafld);
create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}
class TClisisp_set : public TAS400_recordset
{
protected:
void add_field(const char* name = "Filler", int from = -1, int len = 0, char tipo = 'a',
const char* def = NULL);
public:
TClisisp_set();
};
void TClisisp_set::add_field(const char* name, int from, int len,
char tipo, const char* def)
{
const bool required = false;
TString80 fname(name);
const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
const int pos = from - 1;
if (def && *def)
{
CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
TVariant var(def); var.convert_to(t);
create_field(fname, pos, len, t, required, var);
}
else
create_field(fname, pos, len, t, required);
}
TClisisp_set::TClisisp_set() : TAS400_recordset("AS400(304)")
{
create_field("CODANAG", -1, 6, _alfafld);
create_field("COFI", -1, 16, _alfafld);
create_field("PAIV", -1, 11, _alfafld);
create_field("TIPOANAG", -1, 1, _alfafld);
create_field("RAGSOC", -1, 50, _alfafld);
create_field("INDIRIZZO", -1, 28, _alfafld);
create_field("NUMERO", -1, 7, _alfafld);
create_field("COMUNE", -1, 35, _alfafld);
create_field("CAP", -1, 5, _longzerofld);
create_field("STATEST", -1, 35, _alfafld);
create_field("TELEFONO", -1, 20, _alfafld);
create_field("TELEFAX", -1, 20, _alfafld);
create_field("TELEX", -1, 20, _alfafld);
create_field("PREFISSO", -1, 4, _alfafld);
create_field("FRAZIONE", -1, 35, _alfafld);
create_field("PROVINCIA", -1, 2, _alfafld);
create_field("TESTAZMUN", -1, 1, _alfafld);
create_field("CODCOM", -1, 4, _alfafld);
create_field("CODFRAZ", -1, 2, _alfafld);
create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}
/*
class TMovplus_set : public TAS400_recordset
{
protected:
void add_field(const char* name = "Filler", int len = 0, char tipo = 'a',
int from = -1, const char* def = NULL);
public:
TMovplus_set();
};
void TMovplus_set::add_field(const char* name, int len,
char tipo, int from, const char* def)
{
const bool required = false;
TString80 fname(name);
const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
const int pos = from - 1;
if (def && *def)
{
CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
TVariant var(def); var.convert_to(t);
create_field(fname, pos, len, t, required, var);
}
else
create_field(fname, pos, len, t, required);
}
TMovplus_set::TMovplus_set()
: TAS400_recordset("AS400(200)")
{
create_field("COFI", -1, 16, _alfafld);
create_field("PAIV", -1, 11, _alfafld);
create_field("RAGSOC", -1, 50, _alfafld);
create_field("ARGOMENTO", -1, 1, _alfafld);
create_field("NUMPART", -1, 7, _longzerofld);
create_field("NUMINT", -1, 3, _longzerofld);
create_field("PROMEM", -1, 50, _alfafld);
create_field("NOTEVAR", -1, 1, _alfafld);
create_field("CODANCOIN", -1, 6, _alfafld);
create_field("TIPOCOIN", -1, 1, _alfafld);
create_field("PRIPCOIN", -1, 5, _longzerofld);
create_field("LIBERO", -1, 47, _alfafld);
create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}
*/
class TMovpart_set : public TAS400_recordset
{
protected:
void add_field(const char* name = "Filler", int len = 0, char tipo = 'a',
int from = -1, const char* def = NULL);
public:
TMovpart_set();
};
void TMovpart_set::add_field(const char* name, int len,
char tipo, int from, const char* def)
{
const bool required = false;
TString80 fname(name);
const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
const int pos = from - 1;
if (def && *def)
{
CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
TVariant var(def); var.convert_to(t);
create_field(fname, pos, len, t, required, var);
}
else
create_field(fname, pos, len, t, required);
}
TMovpart_set::TMovpart_set() : TAS400_recordset("AS400(322)")
{
create_field("COFI", -1, 16, _alfafld);
create_field("PAIV", -1, 11, _alfafld);
create_field("RAGSOC", -1, 50, _alfafld);
create_field("ARGOMENTO", -1, 1, _longzerofld);
create_field("NUMPART", -1, 7, _longzerofld);
create_field("NUMINT", -1, 3, _longzerofld);
create_field("DATAOP", -1, 8, _longzerofld);
create_field("CODSCONT", -1, 6, _alfafld);
create_field("CODCLIFO", -1, 6, _alfafld);
create_field("TIPOREG", -1, 2, _longzerofld);
create_field("CODREG", -1, 2, _longzerofld);
create_field("ANNODOC", -1, 4, _longzerofld);
create_field("NUMDOC", -1, 7, _alfafld);
create_field("NUMPROT", -1, 7, _longzerofld);
create_field("DATADOC", -1, 8, _longzerofld);
create_field("ANNOPAG", -1, 4, _longzerofld);
create_field("TIPOMOV", -1, 1, _alfafld);
create_field("CODCAUS", -1, 5, _longzerofld);
create_field("CODPAG", -1, 6, _alfafld);
create_field("DATASCAD", -1, 8, _longzerofld);
create_field("IMPTMOV", -1, 12, _longzerofld);
create_field("SGNIMPT", -1, 1, _alfafld);
create_field("CODAG", -1, 3, _alfafld);
create_field("CODVALEST", -1, 3, _alfafld);
create_field("CAMBIO", -1, 9, _longzerofld);
create_field("CODABICF", -1, 5, _longzerofld);
create_field("CODCABCF", -1, 5, _longzerofld);
create_field("CODABIAZ", -1, 5, _longzerofld);
create_field("CODCABAZ", -1, 5, _longzerofld);
create_field("NUMDOC2", -1, 7, _alfafld);
create_field("NUMPROT2", -1, 7, _longzerofld);
create_field("DATADOC2", -1, 8, _longzerofld);
create_field("ANNOTAZ", -1, 30, _alfafld);
create_field("TIPOPAG", -1, 1, _longzerofld);
create_field("DTNEWSCAD", -1, 8, _longzerofld);
create_field("IMPTSP", -1, 12, _longzerofld);
create_field("CONTUNI", -1, 8, _longzerofld);
create_field("IMPTIVA", -1, 12, _longzerofld);
create_field("TIPOANAG", -1, 1, _alfafld);
create_field("TIPOVAL", -1, 1, _alfafld);
create_field("LIBERO", -1, 15, _alfafld);
create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}
class TInvioSispac_mask : public TAutomask
{
protected:
bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
TInvioSispac_mask();
virtual ~TInvioSispac_mask(){};
};
TInvioSispac_mask::TInvioSispac_mask() :TAutomask ("tc9300a")
{
}
bool TInvioSispac_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
switch (o.dlg())
{
case F_CODDITTA:
if (e==fe_init && o.empty())
{
set(F_CODDITTA, main_app().get_firm());
((TEdit_field&) o).check();
disable(F_CODDITTA);
}
break;
default:
break;
}
return TRUE;
}
class TInvioSispac : public TSkeleton_application
{
TCursor* _cur;
TInvioSispac_mask* _msk;
TConfig* _configfile;
TDate _dataini, _datafin;
TRiclassifica_cache * _tabelle;
protected:
virtual bool create(void);
virtual bool destroy(void);
virtual void main_loop() ;
void invio_sispac();
void sispac_cli();
void sispac_for();
void sispac_reverse_movim(long numreg, TMovim_set & recset, long firstmov, long lastmov,
const TString & cofi, const TString & paiv,
const TString & ragsoc, const TString & esiva,
const TString & annoes, bool comp);
void sispac_reverse_giro(long numreg, TMovim_set & recset, long firstmov, long lastmov,
const TString & cofi, const TString & paiv,
const TString & ragsoc, const TString & esiva,
const TString & annoes, bool comp);
void sispac_movim();
void sispac_reverse_moviva(long numreg, TIvamov_set & recset, const TString & cofi,
const TString & paiv, const TString & ragsoc);
void sispac_moviva();
void sispac_intramov();
void sispac_movpart();
void conferma(bool conf = true);
const TString & scod2ricl(const char* tab, const TString& cod);
const TString & scod2caucf(const TString& cod);
const TString & scod2ricl(const char* tab, const TVariant& cod);
const TString & scod2caureg(const TString& cod);
const TString & scod2caugiro(const TString& cod);
const TString & scod2caucon(const TString& cod);
const TString & scod2sezcon(const TString& cod);
const TString & scod2contov(const TString& cod);
bool scod2rc(const TString& cod);
const long cod2ricl(const char* tab, const TString& cod);
public:
TConfig& config() {return *_configfile;};
TInvioSispac() {} ;
virtual ~TInvioSispac() {} ;
};
// restituisce un riferimento all' applicazione
inline TInvioSispac& app() { return (TInvioSispac&) main_app();}
const TString & TInvioSispac::scod2ricl(const char* tab, const TString& cod)
{
TString & codricl = get_tmp_string();
if (cod.full())
{
codricl = _tabelle->sdecode(tab, cod);
if (codricl.blank())
codricl = cod;
}
return codricl;
}
const TString & TInvioSispac::scod2caucf(const TString& cod)
{
if (cod.full())
return _tabelle->sdecode_caufor(cod);
return EMPTY_STRING;
}
const TString & TInvioSispac::scod2caureg(const TString& cod)
{
TString & codricl = get_tmp_string();
if (cod.full())
codricl = _tabelle->sdecode_caureg(cod);
return codricl;
}
const TString & TInvioSispac::scod2caugiro(const TString& cod)
{
TString & codricl = get_tmp_string();
if (cod.full())
codricl = _tabelle->sdecode_caugiro(cod);
return codricl;
}
const TString & TInvioSispac::scod2caucon(const TString& cod)
{
TString & codricl = get_tmp_string();
if (cod.full())
codricl = _tabelle->sdecode_caucon(cod);
return codricl;
}
const TString & TInvioSispac::scod2sezcon(const TString& cod)
{
TString & codricl = get_tmp_string();
if (cod.full())
codricl = _tabelle->sdecode_sezcon(cod);
return codricl;
}
const TString & TInvioSispac::scod2contov(const TString& cod)
{
TString & codricl = get_tmp_string();
if (cod.full())
codricl = _tabelle->sdecode_contov(cod);
return codricl;
}
bool TInvioSispac::scod2rc(const TString& cod)
{
TString & codricl = get_tmp_string();
if (cod.full())
return _tabelle->sdecode_rc(cod);
return false;
}
const TString & TInvioSispac::scod2ricl(const char* tab, const TVariant& cod)
{
return scod2ricl(tab, cod.as_string());
}
const long TInvioSispac::cod2ricl(const char* tab, const TString& cod)
{
long codricl = 0;
if (cod.full())
{
codricl = _tabelle->decode(tab, cod);
if (codricl <= 0 && real::is_natural(cod))
codricl = atol(cod);
}
return codricl;
}
void TInvioSispac::sispac_cli()
{
TClisisp_set recset;
TString query;
query << "USE " << LF_CLIFO
<< "\nJOIN " << LF_COMUNI << " INTO " << COM_STATO << "==" << CLI_STATOCF << " " << COM_COM << "==" << CLI_COMCF
<< "\nFROM " << CLI_TIPOCF << "=C"
<< "\nTO " << CLI_TIPOCF << "=C";
TISAM_recordset input(query);
TVariant var;
TString fcomname;
fcomname << LF_COMUNI << "." << COM_DENCOM;
TProgind p(input.items(), TR("Esportazione Clienti"), true, true);
for (bool ok = input.move_first(); ok ; ok = input.move_next())
{
recset.new_rec();
const long codcli = input.get(CLI_CODCF).as_int();
var = format("%06d", codcli);
recset.set("CODANAG", var);
recset.set("COFI", input.get(CLI_COFI));
recset.set("PAIV", input.get(CLI_PAIV));
const int cflen = input.get(CLI_COFI).as_string().len();
const int pilen = input.get(CLI_PAIV).as_string().len();
if (cflen > 11)
var = "F";
else
if (cflen == 0 && pilen == 0)
var = "P";
else
var = "D";
recset.set("TIPOANAG", var);
recset.set("RAGSOC", input.get(CLI_RAGSOC));
recset.set("INDIRIZZO", input.get(CLI_INDCF));
recset.set("NUMERO", input.get(CLI_CIVCF));
TString loc(input.get(CLI_LOCCF).as_string());
TString comune(input.get(fcomname).as_string());
if (comune.full())
{
if (loc.full())
loc << " - ";
loc << comune;
}
var = comune;
recset.set("COMUNE", var);
recset.set("CAP", input.get(CLI_CAPCF));
recset.set("FINEREC", "\r\n");
p.addstatus(1L);;
if (p.iscancelled())
break;
}
TFilename outputname = _configfile->get("PATH", "OPZIONI");
outputname << "/clisisp";
recset.save_as(outputname);
}
void TInvioSispac::sispac_for()
{
TForsisp_set recset;
TString query;
query << "USE " << LF_CLIFO
<< "\nJOIN " << LF_COMUNI << " INTO " << COM_STATO << "==" << CLI_STATOCF << " " << COM_COM << "==" << CLI_COMCF
<< "\nFROM " << CLI_TIPOCF << "=F"
<< "\nTO " << CLI_TIPOCF << "=F";
TISAM_recordset input(query);
TVariant var;
TString fcomname;
fcomname << LF_COMUNI << "." << COM_DENCOM;
TProgind p(input.items(), TR("Esportazione Fornitori"), true, true);
for (bool ok = input.move_first(); ok ; ok = input.move_next())
{
recset.new_rec();
const long codfor = input.get(CLI_CODCF).as_int();
var = format("%06d", codfor);
recset.set("CODANAG", var);
recset.set("COFI", input.get(CLI_COFI));
recset.set("PAIV", input.get(CLI_PAIV));
const int cflen = input.get(CLI_COFI).as_string().len();
const int pilen = input.get(CLI_PAIV).as_string().len();
if (cflen > 11)
var = "F";
else
if (cflen == 0 && pilen == 0)
var = "P";
else
var = "D";
recset.set("TIPOANAG", var);
recset.set("RAGSOC", input.get(CLI_RAGSOC));
recset.set("INDIRIZZO", input.get(CLI_INDCF));
recset.set("NUMERO", input.get(CLI_CIVCF));
TString loc(input.get(CLI_LOCCF).as_string());
TString comune(input.get(fcomname).as_string());
if (comune.full())
{
if (loc.full())
loc << " - ";
loc << comune;
}
var = comune;
recset.set("COMUNE", var);
recset.set("CAP", input.get(CLI_CAPCF));
recset.set("FINEREC", "\r\n");
p.addstatus(1L);;
if (p.iscancelled())
break;
}
TFilename outputname = _configfile->get("PATH", "OPZIONI");
outputname << "/forsisp";
recset.save_as(outputname);
}
void TInvioSispac::sispac_reverse_movim(long numreg, TMovim_set & recset, long firstmov, long lastmov,
const TString & cofi, const TString & paiv,
const TString & ragsoc, const TString & esiva,
const TString & annoes, bool comp)
{
TString query;
TString key;
query << "USE " << LF_RMOV << " SELECT " << RMV_NUMREG << "==" << numreg
<< "\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;
TISAM_recordset input(query);
TVariant var;
TVariant treg;
TVariant tpart;
TArray tipoart;
int rdare = 0;
int ravere = 0;
for (bool ok = input.move_first(); ok ; ok = input.move_next())
{
const long codes = input.get(RMV_ANNOES).as_int();
const TString4 rowtype = input.get(RMV_ROWTYPE).as_string();
if (rowtype == "F")
continue;
recset.new_rec();
var = cofi;
recset.set("COFI", var);
var = paiv;
recset.set("PAIV", var);
var = ragsoc;
recset.set("RAGSOC", var);
var = esiva;
recset.set("ESIVA", var);
var = annoes;
recset.set("ESCOGE", var);
var = "V";
treg = "03";
recset.set("ARGOMENTO", var);
var = "N";
const TDate datareg(input.get(SLF_MOV "." MOV_DATAREG).as_date());
if (comp)
var = "1";
recset.set("COMPETENZA", var);
var = format("%07ld", input.get(RMV_NUMREG).as_int() + REG_OFFSET);
recset.set("NUMPART", var);
var = format("%03ld", input.get(RMV_NUMRIG).as_int());
recset.set("NUMINT", var);
recset.set("DATAOP", datareg.string(brief, '\0', full, full, amg_date));
TString16 codice;
long gruppo = input.get(RMV_GRUPPO).as_int();
const long conto = input.get(RMV_CONTO).as_int();
const long sottoconto = input.get(RMV_SOTTOCONTO).as_int();
TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string());
if (gruppo == 10)
gruppo = 0;
if (rowtype == "I") // verificare
codice = scod2contov(ccaus);
else
if (input.get(RMV_TIPOC).as_string().full())
codice.format("%01ld%02ld000%06ld", gruppo, conto, sottoconto);
else
codice.format("%01ld%02ld%03ld000000", gruppo, conto, sottoconto);
var = codice;
recset.set("CODCONTO", var);
recset.set("TIPOREG", treg);
recset.set("CODREG", TVariant("01")); // in futuro campo su registro
const long prot = input.get(SLF_MOV "." MOV_PROTIVA).as_int();
var = format("%07ld", prot);
recset.set("NUMPROT", var);
const real * v = (real *) tipoart.objptr(lastmov - firstmov); // qui
if (v != NULL)
recset.set("TIPOART", *v);
TString8 codcaus = scod2caureg(ccaus);
if (input.get(RMV_TIPOC).as_string().full())
{
const TString8 codcauscf = scod2caucf(ccaus);
if (codcauscf.full())
codcaus = codcauscf;
}
var = "R";
if (codcaus == "00255")
var = "S";
recset.set("TIPOMOV", var);
recset.set("CODCOST", TVariant("000"));
var = codcaus;
recset.set("CODCAUS", var);
recset.set("NUMDESC", TVariant("0"));
real importo = input.get(RMV_IMPORTO).as_real();
if (rowtype == "T")
importo += input.get(SLF_MOV "." MOV_RITFIS).as_real();
var = "P";
if (importo < ZERO)
{
importo = -importo;
var = "N";
}
recset.set("SGNIMPT", var);
importo *= CENTO;
var = importo.string(13, 0, '0');
recset.set("IMPORTO", var);
const bool dare = input.get(RMV_SEZIONE).as_string() == "D";
const char * s = dare ? "A" : "D";
recset.set("SGNCONTIMP", s);
const TDate datadoc(input.get(SLF_MOV "." MOV_DATADOC).as_date());
var = datadoc.string(brief, '\0', full, full, amg_date);
recset.set("DATADOC", var);
recset.set("NUMDOC", input.get(SLF_MOV "." MOV_NUMDOC).as_int());
const long codcf = input.get(SLF_MOV "." MOV_CODCF).as_int();
var = "";
if (codcf > 0L)
{
key = "C" ; key << "|" << codcf;
const TRectype & clifo = cache().get(LF_CLIFO, key);
const int cflen = clifo.get(CLI_COFI).len();
if (cflen > 11)
var = "2";
}
recset.set("TIPOANAG", var);
recset.set("FINEREC", "\r\n");
}
}
void TInvioSispac::sispac_reverse_giro(long numreg, TMovim_set & recset, long firstmov, long lastmov,
const TString & cofi, const TString & paiv,
const TString & ragsoc, const TString & esiva,
const TString & annoes, bool comp)
{
TString query;
TString key;
query << "USE " << LF_RMOV << " SELECT " << RMV_NUMREG << "==" << numreg
<< "\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;
TISAM_recordset input(query);
TVariant var;
TVariant treg;
TString codice_cf;
TVariant tpart;
TArray tipoart;
int rdare = 0;
int ravere = 0;
for (bool ok = input.move_first(); ok ; ok = input.move_next())
{
const long codes = input.get(RMV_ANNOES).as_int();
const TString4 rowtype = input.get(RMV_ROWTYPE).as_string();
if (rowtype == "F")
continue;
recset.new_rec();
var = cofi;
recset.set("COFI", var);
var = paiv;
recset.set("PAIV", var);
var = ragsoc;
recset.set("RAGSOC", var);
var = esiva;
recset.set("ESIVA", var);
var = annoes;
recset.set("ESCOGE", var);
var = "P";
treg = "01";
recset.set("ARGOMENTO", var);
var = "N";
const TDate datareg(input.get(SLF_MOV "." MOV_DATAREG).as_date());
if (comp)
var = "1";
recset.set("COMPETENZA", var);
var = format("%07ld", input.get(RMV_NUMREG).as_int() + GIRO_OFFSET);
recset.set("NUMPART", var);
var = format("%03ld", input.get(RMV_NUMRIG).as_int());
recset.set("NUMINT", var);
recset.set("DATAOP", datareg.string(brief, '\0', full, full, amg_date));
TString16 codice;
long gruppo = input.get(RMV_GRUPPO).as_int();
const long conto = input.get(RMV_CONTO).as_int();
const long sottoconto = input.get(RMV_SOTTOCONTO).as_int();
TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string());
if (gruppo == 10)
gruppo = 0;
if (rowtype == "I") // verificare
codice = scod2contov(ccaus);
else
if (rowtype == "D" || rowtype == "N") // verificare
codice = codice_cf;
else
if (input.get(RMV_TIPOC).as_string().full())
{
codice.format("%01ld%02ld000%06ld", gruppo, conto, sottoconto);
codice_cf = codice;
}
else
codice.format("%01ld%02ld%03ld000000", gruppo, conto, sottoconto);
var = codice;
recset.set("CODCONTO", var);
recset.set("TIPOREG", treg);
recset.set("CODREG", TVariant("01")); // in futuro campo su registro
const long prot = input.get(SLF_MOV "." MOV_PROTIVA).as_int();
var = format("%07ld", prot);
recset.set("NUMPROT", var);
const real * v = (real *) tipoart.objptr(lastmov - firstmov); // qui
if (v != NULL)
recset.set("TIPOART", *v);
TString8 codcaus = scod2caugiro(ccaus);
if (input.get(RMV_TIPOC).as_string().full())
{
const TString8 codcauscf = scod2caucf(ccaus);
if (codcauscf.full())
codcaus = codcauscf;
}
var = "R";
if (codcaus == "00255")
var = "S";
recset.set("TIPOMOV", var);
recset.set("CODCOST", TVariant("000"));
var = codcaus;
recset.set("CODCAUS", var);
recset.set("NUMDESC", TVariant("0"));
real importo = input.get(RMV_IMPORTO).as_real();
if (rowtype == "T")
importo += input.get(SLF_MOV "." MOV_RITFIS).as_real();
var = "P";
if (importo < ZERO)
{
importo = -importo;
var = "N";
}
recset.set("SGNIMPT", var);
importo *= CENTO;
var = importo.string(13, 0, '0');
recset.set("IMPORTO", var);
recset.set("SGNCONTIMP", input.get(RMV_SEZIONE));
const TDate datadoc(input.get(SLF_MOV "." MOV_DATADOC).as_date());
var = datadoc.string(brief, '\0', full, full, amg_date);
recset.set("DATADOC", var);
recset.set("NUMDOC", input.get(SLF_MOV "." MOV_NUMDOC).as_int());
const long codcf = input.get(SLF_MOV "." MOV_CODCF).as_int();
var = "";
if (codcf > 0L)
{
key = "F" ; key << "|" << codcf;
const TRectype & clifo = cache().get(LF_CLIFO, key);
const int cflen = clifo.get(CLI_COFI).len();
if (cflen > 11)
var = "2";
}
recset.set("TIPOANAG", var);
recset.set("FINEREC", "\r\n");
}
}
void TInvioSispac::sispac_movim()
{
TMovim_set recset;
TString query;
TString key;
TEsercizi_contabili esc;
long numregrev = -1L;
key << prefix().get_codditta();
const TRectype & ditta = cache().get(LF_NDITTE, key);
key = ditta.get(NDT_TIPOA);
key << "|" <<ditta.get_long(NDT_CODANAGR);
const TRectype & anagr = cache().get(LF_ANAG, key);
const TString16 paiv(anagr.get(ANA_PAIV));
const TString16 cofi(anagr.get(ANA_COFI));
const TString80 ragsoc(anagr.get(ANA_RAGSOC));
TString4 esiva; esiva.format("%02d", _dataini.year() % 100) ;
TString4 annoes; annoes << esiva << esiva ;
query << "USE " << LF_RMOV << " SELECT BETWEEN(" << LF_MOV << "." << MOV_DATAREG << "," << _dataini.date2ansi() << "," << _datafin.date2ansi() << ")&&("
<< LF_MOV << "." << MOV_INVIATO << "!=\"X\")"
<< "\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;
TISAM_recordset input(query);
TVariant var;
TVariant treg;
TVariant tpart;
TArray tipoart;
long lastmov = -1;
long firstmov = -1;
int rdare = 0;
int ravere = 0;
TProgind p(input.items() * 2, TR("Esportazione Movimenti"), true, true);
for (bool ok = input.move_first(); ok ; ok = input.move_next())
{
long nmov =input.get(RMV_NUMREG).as_int();
TString4 sezione(input.get(RMV_SEZIONE).as_string());
if (nmov != lastmov)
{
if (firstmov < 0)
firstmov = nmov;
if (lastmov > 0)
{
real v = ZERO;
if (rdare == 1 && ravere > 1)
v = UNO;
else
if (rdare > 1 && ravere == 1)
v = 2.00;
else
if (rdare > 1 && ravere > 1)
v = 3.00;
tipoart.add(v, lastmov - firstmov);
}
lastmov = nmov;
rdare = 0;
ravere = 0;
}
if (sezione == "D")
rdare++;
else
ravere++;
p.addstatus(1L);;
if (p.iscancelled())
break;
}
if (lastmov > 0)
{
real v = ZERO;
if (rdare == 1 && ravere > 1)
v = UNO;
else
if (rdare > 1 && ravere == 1)
v = 2.00;
else
if (rdare > 1 && ravere > 1)
v = 3.00;
tipoart.add(v, lastmov - firstmov);
}
lastmov = 0;
int nrow = 0;
for (bool ok = input.move_first(); ok ; ok = input.move_next())
{
const long codes = input.get(RMV_ANNOES).as_int();
const TString4 rowtype = input.get(RMV_ROWTYPE).as_string();
const TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string());
const long numreg = input.get(RMV_NUMREG).as_int();
const TDate datareg(input.get(SLF_MOV "." MOV_DATAREG).as_date());
const bool comp = codes != esc.date2esc(datareg);
TString4 sezione(input.get(RMV_SEZIONE).as_string());
if (numreg != lastmov)
{
lastmov = numreg;
nrow = 0;
}
if (numregrev < 0L && scod2rc(ccaus))
numregrev = numreg;
if (rowtype == "F")
continue;
if (numregrev > 0L && numreg != numregrev)
{
sispac_reverse_movim(numregrev, recset, firstmov, lastmov, cofi, paiv, ragsoc, esiva, annoes, comp);
sispac_reverse_giro(numregrev, recset, firstmov, lastmov, cofi, paiv, ragsoc, esiva, annoes, comp);
numregrev = -1L;
}
recset.new_rec();
var = cofi;
recset.set("COFI", var);
var = paiv;
recset.set("PAIV", var);
var = ragsoc;
recset.set("RAGSOC", var);
var = esiva;
recset.set("ESIVA", var);
var = annoes;
recset.set("ESCOGE", var);
const TString & reg = input.get(SLF_MOV "." MOV_REG).as_string();
if (reg.blank())
{
var = "P";
treg = "01";
}
else
{
TRegistro r(reg, input.get(SLF_MOV "." MOV_ANNOIVA).as_int());
switch (r.iva())
{
case iva_vendite :
if (r.corrispettivi())
{
var = "S";
treg = "04";
}
else
{
var = "V";
treg = "03";
}
break;
case iva_acquisti :
var = "A";
treg = "02";
break;
default:
var = "";
treg = "01";
break;
}
}
const TString4 tipomov = var.as_string();
recset.set("ARGOMENTO", var);
var = "N";
if (comp)
var = "1";
recset.set("COMPETENZA", var);
var = format("%07ld", numreg);
recset.set("NUMPART", var);
var = format("%03ld", ++nrow);
recset.set("NUMINT", var);
recset.set("DATAOP", datareg.string(brief, '\0', full, full, amg_date));
TString16 codice;
long gruppo = input.get(RMV_GRUPPO).as_int();
const long conto = input.get(RMV_CONTO).as_int();
const long sottoconto = input.get(RMV_SOTTOCONTO).as_int();
if (gruppo == 10)
gruppo = 0;
if (input.get(RMV_TIPOC).as_string().full())
codice.format("%01ld%02ld000%06ld", gruppo, conto, sottoconto);
else
codice.format("%01ld%02ld%03ld000000", gruppo, conto, sottoconto);
var = codice;
recset.set("CODCONTO", var);
recset.set("TIPOREG", treg);
recset.set("CODREG", TVariant("01")); // in futuro campo su registro
const long prot = input.get(SLF_MOV "." MOV_PROTIVA).as_int();
var = format("%07ld", prot);
recset.set("NUMPROT", var);
const real * v = (real *) tipoart.objptr(lastmov - firstmov); // qui
if (v != NULL)
recset.set("TIPOART", *v);
TString8 codcaus = scod2ricl("SCCAU", ccaus);
const TString4 tipocf = input.get(RMV_TIPOC).as_string();
const TString8 codcauscf = scod2caucf(ccaus);
const TString8 codcauscon = scod2caucon(ccaus);
const TString4 sezcon = scod2sezcon(ccaus);
if (tipocf == "C" || tipocf == "F")
{
if (codcauscf.full())
codcaus = codcauscf;
else
if (sezcon == sezione && codcauscon.full())
codcaus = codcauscon;
}
else
if (sezcon == sezione && codcauscon.full())
codcaus = codcauscon;
var = "R";
if (codcaus == "00255")
var = "S";
recset.set("TIPOMOV", var);
recset.set("CODCOST", TVariant("000"));
var = codcaus;
recset.set("CODCAUS", var);
recset.set("NUMDESC", TVariant("0"));
real importo = input.get(RMV_IMPORTO).as_real();
real ritenute = input.get(SLF_MOV "." MOV_RITFIS).as_real();
if (ritenute != ZERO && rowtype == "T")
importo += ritenute;
var = "P";
if (importo < ZERO)
{
importo = -importo;
var = "N";
}
recset.set("SGNIMPT", var);
importo *= CENTO;
var = importo.string(13, 0, '0');
recset.set("IMPORTO", var);
recset.set("SGNCONTIMP", input.get(RMV_SEZIONE));
const TDate datadoc(input.get(SLF_MOV "." MOV_DATADOC).as_date());
var = datadoc.string(brief, '\0', full, full, amg_date);
recset.set("DATADOC", var);
recset.set("NUMDOC", input.get(SLF_MOV "." MOV_NUMDOC).as_int());
const long codcf = input.get(SLF_MOV "." MOV_CODCF).as_int();
var = "";
if (codcf > 0L)
{
key = tipomov == "A" ? "F" : "C" ; key << "|" << codcf;
const TRectype & clifo = cache().get(LF_CLIFO, key);
const int cflen = clifo.get(CLI_COFI).len();
if (cflen > 11)
var = "2";
}
recset.set("TIPOANAG", var);
recset.set("FINEREC", "\r\n");
p.addstatus(1L);;
if (p.iscancelled())
break;
}
TFilename outputname = _configfile->get("PATH", "OPZIONI");
outputname << "/movim";
recset.save_as(outputname);
}
void TInvioSispac::sispac_reverse_moviva(long numreg, TIvamov_set & recset, const TString & cofi,
const TString & paiv, const TString & ragsoc)
{
TString query;
TString key;
query << "USE " << LF_RMOVIVA << " SELECT " << RMV_NUMREG << "==" << numreg <<
"\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;
TISAM_recordset input(query);
TVariant var;
for (bool ok = input.move_first(); ok ; ok = input.move_next())
{
recset.new_rec();
var = cofi;
recset.set("COFI", var);
var = paiv;
recset.set("PAIV", var);
var = ragsoc;
recset.set("RAGSOC", var);
var = format("%07ld", input.get(RMI_NUMREG).as_int() + REG_OFFSET);
recset.set("NUMPART", var);
var = format("%03ld", input.get(RMI_NUMRIG).as_int());
recset.set("NUMINT", var);
real imponibile = input.get(RMI_IMPONIBILE).as_real();
var = "P";
if (imponibile < ZERO)
{
imponibile = -imponibile;
var = "N";
}
recset.set("SGNIMPB", var);
imponibile *= CENTO;
var = imponibile.string(13, 0, '0');
recset.set("IMPONIBILE", var);
real imposta = input.get(RMI_IMPOSTA).as_real();
var = "P";
if (imposta < ZERO)
{
imposta = -imposta;
var = "N";
}
recset.set("SGNIMPIVA", var);
imposta *= CENTO;
var = imposta.string(13, 0, '0');
recset.set("IMPOSTA", var);
const TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string());
TString8 codcaus = scod2caureg(ccaus);
if (input.get(RMI_TIPOC).as_string().full())
{
const TString8 codcauscf = scod2caucf(ccaus);
if (codcauscf.full())
codcaus = codcauscf;
}
var = codcaus;
recset.set("CODCAUS", var);
const TString8 civa(input.get(RMI_CODIVA).as_string());
TString8 codiva = scod2ricl("SCIVA", civa);
var = codiva;
recset.set("CODIVA", var);
recset.set("FILLER", TVariant("00"));
TVariant var1("M");
var = "";
if (codcaus == "00100")
{
var = "S";
var1 = "S";
}
else
if (codcaus == "00110")
{
var = "N";
var1 = "N";
}
else
if (codcaus == "00200" || codcaus == "00220" ||
codcaus == "00255" || codcaus == "00301")
var1 ="M";
recset.set("MERCIVEN", var1);
recset.set("QUADROA", var);
int tipodet;
TCausale cau(ccaus, _dataini.year());
const real percdetr = (CENTO - indetraibile_al(input.get(RMI_TIPODET).as_string(), cau, _dataini.year(), tipodet)) * CENTO;
var = percdetr.string(5, 0, '0');
recset.set("DETRAIB", percdetr);
recset.set("FINEREC", "\r\n");
}
}
void TInvioSispac::sispac_moviva()
{
TIvamov_set recset;
TString query;
TString key;
TEsercizi_contabili esc;
long numregrev = -1L;
key << prefix().get_codditta();
const TRectype & ditta = cache().get(LF_NDITTE, key);
key = ditta.get(NDT_TIPOA);
key << "|" <<ditta.get_long(NDT_CODANAGR);
const TRectype & anagr = cache().get(LF_ANAG, key);
const TString16 paiv(anagr.get(ANA_PAIV));
const TString16 cofi(anagr.get(ANA_COFI));
const TString80 ragsoc(anagr.get(ANA_RAGSOC));
const int esiva = _dataini.year() % 100 ;
TString4 annoes; annoes << esiva << esiva ;
query << "USE " << LF_RMOVIVA << " SELECT BETWEEN(" << LF_MOV << "." << MOV_DATAREG << "," << _dataini.date2ansi() << "," << _datafin.date2ansi() << ")&&("
<< LF_MOV << "." << MOV_INVIATO << "!=\"X\")"
<< "\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;
TISAM_recordset input(query);
TVariant var;
int lastmov = 0;
int nrow = 0;
TProgind p(input.items(), TR("Esportazione Movimenti IVA"), true, true); // qui
for (bool ok = input.move_first(); ok ; ok = input.move_next())
{
const TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string());
const long numreg = input.get(RMI_NUMREG).as_int();
if (numreg != lastmov)
{
lastmov = numreg;
nrow = 0;
}
TString16 key;
key << numreg <<"|1";
if (cache().get(LF_RMOV, key).empty())
continue;
if (scod2rc(ccaus))
numregrev = numreg;
if (numregrev > 0L && numreg != numregrev)
{
sispac_reverse_moviva(numregrev, recset, cofi, paiv, ragsoc);
numregrev = -1L;
}
recset.new_rec();
var = cofi;
recset.set("COFI", var);
var = paiv;
recset.set("PAIV", var);
var = ragsoc;
recset.set("RAGSOC", var);
var = format("%07ld", numreg);
recset.set("NUMPART", var);
var = format("%03ld", ++nrow);
recset.set("NUMINT", var);
real imponibile = input.get(RMI_IMPONIBILE).as_real();
var = "P";
if (imponibile < ZERO)
{
imponibile = -imponibile;
var = "N";
}
recset.set("SGNIMPB", var);
imponibile *= CENTO;
var = imponibile.string(13, 0, '0');
recset.set("IMPONIBILE", var);
real imposta = input.get(RMI_IMPOSTA).as_real();
var = "P";
if (imposta < ZERO)
{
imposta = -imposta;
var = "N";
}
recset.set("SGNIMPIVA", var);
imposta *= CENTO;
var = imposta.string(13, 0, '0');
recset.set("IMPOSTA", var);
TString8 codcaus = scod2ricl("SCCAU", ccaus);
if (input.get(RMI_TIPOC).as_string().full())
{
const TString8 codcauscf = scod2caucf(ccaus);
if (codcauscf.full())
codcaus = codcauscf;
}
var = codcaus;
recset.set("CODCAUS", var);
const TString8 civa(input.get(RMI_CODIVA).as_string());
TString8 codiva = scod2ricl("SCIVA", civa);
var = codiva;
recset.set("CODIVA", var);
recset.set("FILLER", TVariant("00"));
TVariant var1("N");
TString8 codreg(input.get(SLF_MOV "." MOV_REG).as_string());
if (codreg.full())
{
TRegistro reg(codreg, input.get(SLF_MOV "." MOV_ANNOES).as_int());
if (reg.iva() == iva_vendite)
var1 = "M";
}
var = "";
if (codcaus == "00100")
{
var = "S";
var1 = "S";
}
else
if (codcaus == "00110")
{
var = "N";
var1 = "N";
}
else
if (codcaus == "00200" || codcaus == "00220" ||
codcaus == "00255" || codcaus == "00301")
var1 ="M";
recset.set("MERCIVEN", var1);
recset.set("QUADROA", var);
int tipodet;
TCausale cau(ccaus, _dataini.year());
const real percdetr = (CENTO - indetraibile_al(input.get(RMI_TIPODET).as_string(), cau, _dataini.year(), tipodet)) * CENTO;
var = percdetr.string(5, 0, '0');
recset.set("DETRAIB", percdetr);
recset.set("FINEREC", "\r\n");
p.addstatus(1L);;
if (p.iscancelled())
break;
}
TFilename outputname = _configfile->get("PATH", "OPZIONI");
outputname << "/ivamov";
recset.save_as(outputname);
}
void TInvioSispac::sispac_intramov()
{
TIntramov_set recset;
/*
TString query;
query << "USE " << LF_CLIFO
<< "\nJOIN " << LF_COMUNI << " INTO " << COM_STATO << "==" << CLI_STATOCF << " " << COM_COM << "==" << CLI_COMCF << "\n"
<< "FROM " << CLI_TIPOCF << "=F\n"
<< "TO " << CLI_TIPOCF << "=F";
TISAM_recordset input(query);
TVariant var;
for (bool ok = input.move_first(); ok ; input.move_next())
{
}
TFilename outputname = _configfile->get("PATH", "OPZIONI");
outputname << "intramov";
recset.save_as(outputname); */
}
void TInvioSispac::sispac_movpart()
{
TMovpart_set recset;
/*
TString query;
query << "USE " << LF_CLIFO
<< "\nJOIN " << LF_COMUNI << " INTO " << COM_STATO << "==" << CLI_STATOCF << " " << COM_COM << "==" << CLI_COMCF << "\n"
<< "FROM " << CLI_TIPOCF << "=F\n"
<< "TO " << CLI_TIPOCF << "=F";
TISAM_recordset input(query);
TVariant var;
for (bool ok = input.move_first(); ok ; input.move_next())
{
}
TFilename outputname = _configfile->get("PATH", "OPZIONI");
outputname << "movpart";
recset.save_as(outputname);
*/
}
void TInvioSispac::conferma(bool conf)
{
TString query;
query << "USE " << LF_MOV << "KEY 2"
<< "\nFROM " << RMV_DATAREG << "=" << _dataini.date2ansi()
<< "\nTO " << RMV_DATAREG << "=" << _datafin.date2ansi();
TISAM_recordset mov(query);
if (mov.items() > 0L)
{
TProgind pi(mov.items(), conf ? TR("Conferma movimenti") : TR("Ripristino movimenti"), true, true);
TLocalisamfile cgmov(LF_MOV);
for (bool ok = mov.move_first(); ok; ok = mov.move_next())
{
if (!pi.addstatus(1))
break;
const long numreg = mov.get(MOV_NUMREG).as_int();
cgmov.put(MOV_NUMREG, numreg);
if (cgmov.read(_isequal, _lock) == NOERR)
{
cgmov.put(MOV_INVIATO, conf);
cgmov.rewrite();
}
}
}
}
void TInvioSispac::invio_sispac()
{
if (_msk->get_bool(F_CLIFOR))
{
sispac_cli();
sispac_for();
}
if (_msk->get_bool(F_RIPRISTIN0))
conferma(false);
if (_msk->get_bool(F_MOVCONT))
{
sispac_movim();
sispac_moviva();
sispac_intramov();
sispac_movpart();
if (yesno_box(TR("Confermare il traferimento")))
{
_configfile->set("NUMEROINVIO", _msk->get(F_NUMEROINVIO),"OPZIONI");
_configfile->set("DATA", _msk->get_date(F_DATAFIN),"OPZIONI");
conferma();
}
}
}
bool TInvioSispac::create()
{
_msk = new TInvioSispac_mask();
TFilename configname = "tc9300conf.ini";
configname.custom_path();
_configfile = new TConfig(configname);
_tabelle = new TRiclassifica_cache;
return TSkeleton_application::create();
}
bool TInvioSispac::destroy()
{
delete _configfile;
delete _msk;
delete _tabelle;
return TSkeleton_application::destroy();
}
void TInvioSispac::main_loop()
{
_msk->set(F_NUMEROINVIO, _configfile->get_int("NUMEROINVIO","OPZIONI")+1);
_msk->set(F_DATAINI, _configfile->get("DATA","OPZIONI"));
_msk->set(F_DESTINAZIONE, _configfile->get("PATH","OPZIONI"));
while (_msk->run() != K_QUIT)
{
_configfile->set("PATH", _msk->get(F_DESTINAZIONE),"OPZIONI");
_dataini = _msk->get_date(F_DATAINI);
_datafin = _msk->get_date(F_DATAFIN);
invio_sispac();
_msk->set(F_NUMEROINVIO, _configfile->get_int("NUMEROINVIO","OPZIONI")+1);
_msk->set(F_DESTINAZIONE, _configfile->get("PATH","OPZIONI"));
}
}
int tc9300(int argc, char **argv)
{
TInvioSispac a;
a.run(argc, argv, "Invio dati contabilit<69> Sispac/Cosmo");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink