79f6f95cda
git-svn-id: svn://10.65.10.50/branches/R_10_00@22795 c028cbd2-c16b-5b4b-a496-9718f37d4682
969 lines
22 KiB
C++
Executable File
969 lines
22 KiB
C++
Executable File
#include "pg0001.h"
|
||
#include "pg0001200a.h"
|
||
|
||
#include <automask.h>
|
||
#include <progind.h>
|
||
#include <reprint.h>
|
||
|
||
#include <clifo.h>
|
||
#include <mov.h>
|
||
#include <rmov.h>
|
||
#include <rmoviva.h>
|
||
/*#include <anagr.h>
|
||
#include <anafis.h>
|
||
#include <comuni.h>
|
||
#include <causali.h>
|
||
#include <nditte.h>
|
||
#include <multirel.h>*/
|
||
|
||
#include "..\tc\tc0701.h"
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TClifo_recset
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class TClifo_recset : public TAS400_recordset
|
||
{
|
||
TAssoc_array _index;
|
||
|
||
protected:
|
||
void add_field(const char* name = "Filler", int from = -1, char tipo = 'a',
|
||
int len = 0, const char* def = NULL);
|
||
|
||
public:
|
||
bool find(char tipocf, long codcf);
|
||
virtual const TVariant& get(const char* column_name) const;
|
||
|
||
TClifo_recset(const char * query);
|
||
};
|
||
|
||
void TClifo_recset::add_field(const char* name, int from, char tipo, int len, const char* def)
|
||
{
|
||
const bool required = false;
|
||
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(name, pos, len, t, required, var);
|
||
}
|
||
else
|
||
create_field(name, pos, len, t, required);
|
||
}
|
||
|
||
const TVariant& TClifo_recset::get(const char* column_name) const
|
||
{
|
||
TFixed_string fname(column_name);
|
||
|
||
if (fname == CLI_COFI)
|
||
{
|
||
TVariant& var = get_tmp_var();
|
||
TString80 s(TAS400_recordset::get(fname).as_string());
|
||
|
||
var.set(s.trim());
|
||
return var;
|
||
}
|
||
return TAS400_recordset::get(fname);
|
||
}
|
||
|
||
|
||
TClifo_recset::TClifo_recset(const char * query)
|
||
: TAS400_recordset(TString("AS400(213)\n") << query)
|
||
{
|
||
const char a = 'a';
|
||
const char n = 'n';
|
||
const bool o = true;
|
||
const bool f = false;
|
||
|
||
add_field(CLI_TIPOCF, 1, a, 1);
|
||
add_field(CLI_CODCF, 2, n, 6);
|
||
add_field("LIBERO", 8, a, 10);
|
||
add_field(CLI_RAGSOC, 18, a, 50);
|
||
add_field(CLI_INDCF, 68, a, 30);
|
||
add_field(CLI_CAPCF, 98, n, 5);
|
||
add_field(CLI_LOCCF, 103, a, 25);
|
||
add_field("PROV", 128, a, 2);
|
||
add_field("LIBERO2", 130, a, 9);
|
||
add_field(CLI_COFI, 139, a, 16);
|
||
add_field("LIBERO3", 155, a, 45);
|
||
add_field(CLI_PAIV, 201, a, 11);
|
||
add_field("FINE-RECORD", 211, a, 2, "\r\n"); // terminatore record
|
||
|
||
TString16 pos, key;
|
||
|
||
for (bool ok = move_first(); ok; ok = move_next())
|
||
{
|
||
pos.format("%ld", current_row());
|
||
key.format("%c|%ld", get(CLI_TIPOCF).as_string()[0], get(CLI_CODCF).as_int());
|
||
|
||
_index.add(key, pos);
|
||
}
|
||
}
|
||
|
||
bool TClifo_recset::find(char tipocf, long codcf)
|
||
{
|
||
TString16 key;
|
||
|
||
key.format("%c|%ld", tipocf, codcf);
|
||
|
||
TString * s = (TString *) _index.objptr(key);
|
||
long pos = 0L;
|
||
const bool ok = s && s->full();
|
||
|
||
if (ok)
|
||
pos = atoi(*s);
|
||
move_to(pos);
|
||
return ok;
|
||
}
|
||
|
||
class TMov_recset;
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TIVA_recset
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class TIVA_recset : public TAS400_recordset
|
||
{
|
||
|
||
TRecnotype _first, _last;
|
||
long _numreg;
|
||
|
||
private:
|
||
void add_field(const char* name = "Filler", int from = -1, char tipo = 'a',
|
||
int len = 0, const char* def = NULL);
|
||
|
||
public:
|
||
bool find(long numreg);
|
||
virtual const TVariant& get(const char* column_name) const;
|
||
virtual bool move_to(TRecnotype pos);
|
||
|
||
TIVA_recset(TMov_recset & mov);
|
||
};
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TRMov_recset
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class TRMov_recset : public TAS400_recordset
|
||
{
|
||
TRecnotype _first, _last;
|
||
long _numreg;
|
||
|
||
private:
|
||
void add_field(const char* name = "Filler", int from = -1, char tipo = 'a',
|
||
int len = 0, const char* def = NULL);
|
||
|
||
|
||
public:
|
||
bool find(long numreg);
|
||
virtual const TVariant& get(const char* column_name) const;
|
||
virtual bool move_to(TRecnotype pos);
|
||
|
||
TRMov_recset(TMov_recset & mov);
|
||
};
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TMov_recset
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class TMov_recset : public TAS400_recordset
|
||
{
|
||
bool _indetraibile;
|
||
protected:
|
||
void add_field(const char* name = "Filler", int from = -1, char tipo = 'a',
|
||
int len = 0, const char* def = NULL);
|
||
|
||
public:
|
||
bool vendite() const { return get("TIPOR").as_int() == 2;}
|
||
bool acquisti() const { return !vendite();}
|
||
bool fattura() const { return get("TIPOM").as_int() == 0;}
|
||
bool nota_credito() const { return !fattura();}
|
||
virtual const TVariant& get(const char* column_name) const;
|
||
bool indetraibile() const { return _indetraibile;}
|
||
|
||
TMov_recset(const char * query, TArray & recsets);
|
||
};
|
||
|
||
void TMov_recset::add_field(const char* name, int from, char tipo, int len, const char* def)
|
||
{
|
||
const bool required = false;
|
||
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(name, pos, len, t, required, var);
|
||
}
|
||
else
|
||
create_field(name, pos, len, t, required);
|
||
}
|
||
|
||
const TVariant& TMov_recset::get(const char* column_name) const
|
||
{
|
||
TString16 fname(column_name);
|
||
TVariant& var = get_tmp_var();
|
||
|
||
if (fname == MOV_TIPO)
|
||
{
|
||
var = vendite() ? "C" : "F";
|
||
return var;
|
||
}
|
||
else
|
||
if (fname == MOV_REG)
|
||
{
|
||
var = vendite() ? "V00" : "A00";
|
||
return var;
|
||
}
|
||
else
|
||
if (fname == MOV_CODCF)
|
||
{
|
||
if (vendite())
|
||
fname = fattura() ? "S1" : "S2";
|
||
else
|
||
fname = fattura() ? "S2" : "S1";
|
||
}
|
||
else
|
||
if (fname == MOV_CODCAUS)
|
||
{
|
||
((TMov_recset *)this)->_indetraibile = TAS400_recordset::get("CODCAUSO").as_int() == 4;
|
||
int ccaus;
|
||
|
||
if (vendite())
|
||
ccaus = fattura() ? 1 : 2;
|
||
else
|
||
ccaus = fattura() ? 11 : 12;
|
||
var.set(ccaus);
|
||
return var;
|
||
}
|
||
|
||
var = TAS400_recordset::get(fname);
|
||
|
||
if (fname == MOV_DATAREG || fname == MOV_DATADOC)
|
||
{
|
||
const TDate d(atol(var.as_string()) + 20000000L);
|
||
|
||
var.set(d);
|
||
}
|
||
else
|
||
if (fname == MOV_TOTDOC || fname == RMI_IMPONIBILE ||
|
||
fname == RMI_IMPOSTA)
|
||
{
|
||
const real r = var.as_real() / CENTO;
|
||
|
||
var.set(r);
|
||
}
|
||
return var;
|
||
}
|
||
|
||
TMov_recset::TMov_recset(const char * query, TArray & recsets)
|
||
: TAS400_recordset(TString("AS400(543)\n") << query),
|
||
_indetraibile(false)
|
||
{
|
||
const char a = 'a';
|
||
const char n = 'n';
|
||
|
||
add_field("TIPOR", 1, n, 1);
|
||
add_field("L00", 2, a, 6);
|
||
add_field("L01", 8, n, 1);
|
||
add_field("L02", 9, n, 4);
|
||
add_field("NUMREG", 13, n, 7);
|
||
add_field("L03", 20, n, 2);
|
||
add_field("PROG", 22, n, 1);
|
||
add_field("L04", 23, n, 2);
|
||
add_field("L05", 25, a, 2);
|
||
add_field(MOV_DATAREG, 27, a, 6);
|
||
add_field("L07", 33, a, 6);
|
||
add_field("L08", 39, a, 1);
|
||
add_field(MOV_PROTIVA, 40, n, 7);
|
||
add_field(MOV_NUMDOC, 47, n, 9);
|
||
add_field(MOV_DATADOC, 56, a, 6);
|
||
add_field("L09", 62, a, 1);
|
||
add_field("CODCAUSO" , 63, n, 2);
|
||
add_field(RMI_CODIVA, 65, n, 2);
|
||
add_field("TIPOM", 67, n, 1);
|
||
add_field("L10", 68, a, 18);
|
||
add_field("G1", 86, a, 2);
|
||
add_field("C1", 88, a, 2);
|
||
add_field("S1", 90, n, 7);
|
||
add_field("L11", 97, n, 6);
|
||
add_field("G2", 103, a, 2);
|
||
add_field("C2", 105, a, 2);
|
||
add_field("S2", 107, n, 7);
|
||
add_field("L12", 114, n, 6);
|
||
add_field("G3", 120, a, 2);
|
||
add_field("C3", 122, a, 2);
|
||
add_field("S3", 124, n, 7);
|
||
add_field("L13", 131, a, 152);
|
||
add_field("ANNO", 283, n, 4);
|
||
add_field("NUMDOC1", 287, a, 13);
|
||
add_field("L15", 300, a, 18);
|
||
add_field("CODICEE", 318, a, 1);
|
||
add_field("L16", 319, a, 29);
|
||
add_field("L17", 348, a, 20);
|
||
add_field("L18", 368, a, 68);
|
||
add_field("L19", 131, a, 152);
|
||
add_field("L20", 436, n, 1);
|
||
add_field("L21", 437, a, 24);
|
||
add_field("L22", 461, a, 39);
|
||
add_field("ANNULLATO", 500, a, 1);
|
||
add_field("L23", 501, a, 5);
|
||
add_field(RMI_IMPONIBILE, 506, n, 11);
|
||
add_field(RMI_IMPOSTA, 517, n, 9);
|
||
add_field(MOV_TOTDOC, 526, n, 11);
|
||
add_field("L24", 537, n, 5);
|
||
add_field("FINE-RECORD", 541, a, 2, "\r\n"); // terminatore record
|
||
|
||
bool ok;
|
||
|
||
for (ok = move_last(); ok;)
|
||
{
|
||
const int p = current_row();
|
||
|
||
if (get("ANNULLATO").as_string()[0] == 'A')
|
||
{
|
||
destroy(p);
|
||
if (p <= last())
|
||
move_to(p);
|
||
else
|
||
move_last();
|
||
}
|
||
else
|
||
ok = move_prev();
|
||
}
|
||
|
||
long numreg = 0L;
|
||
|
||
for (ok = move_first(); ok; ok = move_next())
|
||
{
|
||
if (get("PROG").as_int() == 1)
|
||
numreg++;
|
||
set(MOV_NUMREG, numreg);
|
||
}
|
||
|
||
recsets.add(new TIVA_recset(*this), LF_RMOVIVA);
|
||
recsets.add(new TRMov_recset(*this), LF_RMOV);
|
||
|
||
for (ok = move_last(); ok;)
|
||
{
|
||
const int p = current_row();
|
||
|
||
if (get("PROG").as_int() > 1)
|
||
{
|
||
destroy(p);
|
||
if (p <= last())
|
||
move_to(p);
|
||
else
|
||
move_last();
|
||
}
|
||
else
|
||
ok = move_prev();
|
||
}
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TIVA_recset
|
||
///////////////////////////////////////////////////////////
|
||
|
||
void TIVA_recset::add_field(const char* name, int from, char tipo, int len, const char* def)
|
||
{
|
||
const bool required = false;
|
||
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(name, pos, len, t, required, var);
|
||
}
|
||
else
|
||
create_field(name, pos, len, t, required);
|
||
}
|
||
|
||
bool TIVA_recset::find(long numreg)
|
||
{
|
||
if (numreg != _numreg)
|
||
{
|
||
_first = _last = -1L;
|
||
|
||
bool ok = false;
|
||
TRecnotype f = 0L, l = last();
|
||
TRecnotype pos = f + (l - f) / 2;
|
||
|
||
while (!ok && f <= l)
|
||
{
|
||
TAS400_recordset::move_to(pos);
|
||
|
||
const long n = get(RMI_NUMREG).as_int();
|
||
|
||
if (n > numreg)
|
||
l = pos - 1;
|
||
else
|
||
if (n < numreg)
|
||
f = pos + 1;
|
||
else
|
||
{
|
||
f = pos;
|
||
ok = true;
|
||
}
|
||
pos = f + (l - f) / 2;
|
||
}
|
||
if (ok)
|
||
{
|
||
bool ok1 = TAS400_recordset::move_to(f);
|
||
|
||
while (ok1 && numreg == get(RMV_NUMREG).as_int())
|
||
{
|
||
f = current_row();
|
||
ok1 = TAS400_recordset::move_prev();
|
||
}
|
||
ok1 = TAS400_recordset::move_to(f);
|
||
while (ok1 && numreg == get(RMV_NUMREG).as_int())
|
||
{
|
||
l = current_row();
|
||
ok1 = TAS400_recordset::move_next();
|
||
}
|
||
_first = f;
|
||
_last = l;
|
||
_numreg = numreg;
|
||
}
|
||
return ok;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
const TVariant& TIVA_recset::get(const char* column_name) const
|
||
{
|
||
const TFixed_string fname(column_name);
|
||
|
||
if (fname == RMI_IMPONIBILE || fname == RMI_IMPOSTA)
|
||
{
|
||
TVariant& var = get_tmp_var();
|
||
const real i = TAS400_recordset::get(fname).as_real() / CENTO;
|
||
var.set(i);
|
||
return var;
|
||
}
|
||
return TAS400_recordset::get(fname);
|
||
}
|
||
|
||
bool TIVA_recset::move_to(TRecnotype pos)
|
||
{
|
||
if (_first < 0L)
|
||
return TAS400_recordset::move_to(pos);
|
||
if (pos == 0L)
|
||
pos = _first;
|
||
if (pos <= _last)
|
||
return TAS400_recordset::move_to(pos);
|
||
return false;
|
||
}
|
||
|
||
TIVA_recset::TIVA_recset(TMov_recset & mov)
|
||
:TAS400_recordset("AS400(62)\n"),
|
||
_first(-1L), _last(-1L), _numreg(-1L)
|
||
{
|
||
const char a = 'a';
|
||
const char n = 'n';
|
||
TVariant var;
|
||
|
||
add_field(RMI_NUMREG, 1, n, 7);
|
||
add_field(RMI_NUMRIG, 8, n, 3);
|
||
add_field(RMI_CODIVA, 11, n, 4);
|
||
add_field(RMI_IMPONIBILE, 15, n, 15); // 18
|
||
add_field(RMI_IMPOSTA, 30, n, 15); // 18
|
||
add_field(RMI_TIPODET, 45, n, 1);
|
||
add_field(RMI_TIPOCR, 46, n, 1);
|
||
add_field(RMI_INTRA, 47, a, 1);
|
||
add_field(RMI_TIPOATT, 48, n, 1);
|
||
add_field(RMI_TIPOC, 49, a, 1);
|
||
add_field(RMI_GRUPPO, 50, n, 3);
|
||
add_field(RMI_CONTO, 53, n, 3); // 18
|
||
add_field(RMI_SOTTOCONTO, 56, n, 6);
|
||
TString4 fgr, fco, fso;
|
||
|
||
for (bool ok = mov.move_first(); ok; ok = mov.move_next())
|
||
{
|
||
new_rec();
|
||
set(RMI_NUMREG, mov.get(MOV_NUMREG));
|
||
set(RMI_NUMRIG, mov.get("PROG"));
|
||
|
||
int civa = mov.get(RMI_CODIVA).as_int();
|
||
int ccaus = mov.get("CODCAUSO").as_int();
|
||
const bool indetraibile = mov.indetraibile();
|
||
|
||
civa += ccaus * 100;
|
||
if (civa == 0)
|
||
civa = 310;
|
||
else
|
||
if (indetraibile)
|
||
set(RMI_TIPODET, "9");
|
||
var.set(civa);
|
||
set(RMI_CODIVA, var);
|
||
set(RMI_IMPONIBILE, mov.TAS400_recordset::get(RMI_IMPONIBILE));
|
||
set(RMI_IMPOSTA, mov.TAS400_recordset::get(RMI_IMPOSTA));
|
||
if (mov.vendite())
|
||
{
|
||
if (mov.fattura())
|
||
{
|
||
fgr = "G2"; fco = "C2"; fso = "S2";
|
||
}
|
||
else
|
||
{
|
||
fgr = "G1"; fco = "C1"; fso = "S1";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (mov.fattura())
|
||
{
|
||
fgr = "G1"; fco = "C1"; fso = "S1";
|
||
}
|
||
else
|
||
{
|
||
fgr = "G2"; fco = "C2"; fso = "S2";
|
||
}
|
||
}
|
||
set(RMI_GRUPPO, mov.get(fgr));
|
||
set(RMI_CONTO, mov.get(fco));
|
||
set(RMI_SOTTOCONTO,mov.get(fso));
|
||
}
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TRMov_recset
|
||
///////////////////////////////////////////////////////////
|
||
|
||
void TRMov_recset::add_field(const char* name, int from, char tipo, int len, const char* def)
|
||
{
|
||
const bool required = false;
|
||
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(name, pos, len, t, required, var);
|
||
}
|
||
else
|
||
create_field(name, pos, len, t, required);
|
||
}
|
||
|
||
bool TRMov_recset::find(long numreg)
|
||
{
|
||
if (numreg != _numreg)
|
||
{
|
||
_first = _last = -1L;
|
||
|
||
bool ok = false;
|
||
TRecnotype f = 0L, l= last();
|
||
TRecnotype pos = f + (l - f) / 2;
|
||
|
||
while (!ok && f <= l)
|
||
{
|
||
TAS400_recordset::move_to(pos);
|
||
|
||
const long n = get(RMV_NUMREG).as_int();
|
||
|
||
if (n > numreg)
|
||
l = pos - 1;
|
||
else
|
||
if (n < numreg)
|
||
f = pos + 1;
|
||
else
|
||
{
|
||
f = pos;
|
||
ok = true;
|
||
}
|
||
pos = f + (l - f) / 2;
|
||
}
|
||
if (ok)
|
||
{
|
||
bool ok1 = TAS400_recordset::move_to(f);
|
||
|
||
while (ok1 && numreg == get(RMV_NUMREG).as_int())
|
||
{
|
||
f = current_row();
|
||
ok1 = TAS400_recordset::move_prev();
|
||
}
|
||
ok1 = TAS400_recordset::move_to(f);
|
||
while (ok1 && numreg == get(RMV_NUMREG).as_int())
|
||
{
|
||
l = current_row();
|
||
ok1 =TAS400_recordset:: move_next();
|
||
}
|
||
_first = f;
|
||
_last = l;
|
||
_numreg = numreg;
|
||
}
|
||
return ok;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
const TVariant& TRMov_recset::get(const char* column_name) const
|
||
{
|
||
const TFixed_string fname(column_name);
|
||
|
||
if (fname == RMV_IMPORTO)
|
||
{
|
||
TVariant& var = get_tmp_var();
|
||
const real i = TAS400_recordset::get(fname).as_real() / CENTO;
|
||
var.set(i);
|
||
return var;
|
||
}
|
||
return TAS400_recordset::get(fname);
|
||
}
|
||
|
||
bool TRMov_recset::move_to(TRecnotype pos)
|
||
{
|
||
if (_first < 0L)
|
||
return TAS400_recordset::move_to(pos);
|
||
if (pos == 0L)
|
||
pos = _first;
|
||
if (pos <= _last)
|
||
return TAS400_recordset::move_to(pos);
|
||
return false;
|
||
}
|
||
|
||
TRMov_recset::TRMov_recset(TMov_recset & mov)
|
||
:TAS400_recordset("AS400(99)\n"),
|
||
_first(-1L), _last(-1L), _numreg(-1L)
|
||
|
||
{
|
||
const char a = 'a';
|
||
const char n = 'n';
|
||
TVariant var;
|
||
int row = 1;
|
||
TString4 fgr, fco, fso;
|
||
TVariant sez, tipo;
|
||
|
||
add_field(RMV_NUMREG, 1, n, 7);
|
||
add_field(RMV_NUMRIG, 8, n, 3);
|
||
add_field(RMV_SEZIONE, 11, a, 1);
|
||
add_field(RMV_TIPOC, 12, a, 1);
|
||
add_field(RMV_GRUPPO, 13, n, 3);
|
||
add_field(RMV_CONTO, 16, n, 3);
|
||
add_field(RMV_SOTTOCONTO, 19, n, 6);
|
||
add_field(RMV_DESCR, 25, a, 50);
|
||
add_field(RMV_IMPORTO, 85, n, 15); // 18
|
||
|
||
for (bool ok = mov.move_first(); ok; ok = mov.move_next())
|
||
{
|
||
const int prog = mov.get("PROG").as_int();
|
||
|
||
if (prog == 1)
|
||
{
|
||
row = 1;
|
||
|
||
// 1o conto cliente/fornitore solo sul primo record
|
||
new_rec();
|
||
set(RMV_NUMREG, mov.get(MOV_NUMREG));
|
||
|
||
var.set(row++);
|
||
set(RMV_NUMRIG, var);
|
||
if (mov.vendite())
|
||
{
|
||
if (mov.fattura())
|
||
{
|
||
fgr = "G1"; fco = "C1"; fso = "S1";
|
||
sez = "D";
|
||
}
|
||
else
|
||
{
|
||
fgr = "G2"; fco = "C2"; fso = "S2";
|
||
sez = "A";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (mov.fattura())
|
||
{
|
||
fgr = "G2"; fco = "C2"; fso = "S2";
|
||
sez = "A";
|
||
}
|
||
else
|
||
{
|
||
fgr = "G1"; fco = "C1"; fso = "S1";
|
||
sez = "D";
|
||
}
|
||
}
|
||
set(RMV_SEZIONE, sez);
|
||
tipo = mov.vendite() ? "C" : "F";
|
||
set(RMV_TIPOC, tipo);
|
||
set(RMV_GRUPPO, mov.get(fgr));
|
||
set(RMV_CONTO, mov.get(fco));
|
||
set(RMV_SOTTOCONTO,mov.get(fso));
|
||
set(RMV_IMPORTO, mov.TAS400_recordset::get(MOV_TOTDOC));
|
||
}
|
||
else
|
||
int i = 0;
|
||
|
||
// 2o conto costo/ricavo
|
||
int ccaus = mov.get(MOV_CODCAUS).as_int();
|
||
const bool indetraibile = mov.indetraibile();
|
||
|
||
new_rec();
|
||
set(RMV_NUMREG, mov.get(MOV_NUMREG));
|
||
var.set(row++);
|
||
set(RMV_NUMRIG, var);
|
||
if (mov.vendite())
|
||
{
|
||
sez = "A"; // trucco perch<63> non si pu<70> usare test_swap
|
||
if (mov.fattura())
|
||
{
|
||
fgr = "G2"; fco = "C2"; fso = "S2";
|
||
}
|
||
else
|
||
{
|
||
fgr = "G1"; fco = "C1"; fso = "S1";
|
||
sez = "D";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
sez = "D"; // trucco perch<63> non si pu<70> usare test_swap
|
||
if (mov.fattura())
|
||
{
|
||
fgr = "G1"; fco = "C1"; fso = "S1";
|
||
}
|
||
else
|
||
{
|
||
fgr = "G2"; fco = "C2"; fso = "S2";
|
||
}
|
||
}
|
||
set(RMV_SEZIONE, sez);
|
||
set(RMV_GRUPPO, mov.get(fgr));
|
||
set(RMV_CONTO, mov.get(fco));
|
||
set(RMV_SOTTOCONTO,mov.get(fso));
|
||
|
||
real importo = mov.TAS400_recordset::get(RMI_IMPONIBILE).as_real();
|
||
|
||
if (indetraibile)
|
||
importo += mov.TAS400_recordset::get(RMI_IMPOSTA).as_real();
|
||
|
||
set(RMV_IMPORTO, importo);
|
||
|
||
// 3o conto IVA
|
||
if (!indetraibile && !mov.TAS400_recordset::get(RMI_IMPOSTA).as_real().is_zero())
|
||
{
|
||
new_rec();
|
||
set(RMV_NUMREG, mov.get(MOV_NUMREG));
|
||
var.set(row++);
|
||
set(RMV_NUMRIG, var);
|
||
if (mov.vendite())
|
||
sez = mov.fattura() ? "A" : "D";
|
||
else
|
||
sez = mov.fattura() ? "D" : "A";
|
||
set(RMV_SEZIONE, sez);
|
||
set(RMV_GRUPPO, mov.get("G3"));
|
||
set(RMV_CONTO, mov.get("C3"));
|
||
set(RMV_SOTTOCONTO,mov.get("S3"));
|
||
set(RMV_IMPORTO, mov.TAS400_recordset::get(RMI_IMPOSTA));
|
||
}
|
||
else
|
||
int i = 0;
|
||
}
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TMaestri_mask
|
||
///////////////////////////////////////////////////////////
|
||
|
||
class TMaestri_mask : public TAutomask
|
||
{
|
||
private:
|
||
void serialize(bool bSave);
|
||
protected:
|
||
bool on_field_event(TOperable_field& o, TField_event e, long jolly);
|
||
public:
|
||
TMaestri_mask();
|
||
virtual ~TMaestri_mask();
|
||
};
|
||
|
||
TMaestri_mask::TMaestri_mask() : TAutomask("pg0001200a")
|
||
{
|
||
serialize(false);
|
||
}
|
||
|
||
TMaestri_mask::~TMaestri_mask()
|
||
{
|
||
serialize(true);
|
||
}
|
||
|
||
bool TMaestri_mask::on_field_event(TOperable_field& f, TField_event e, long jolly)
|
||
{
|
||
return TRUE;
|
||
}
|
||
|
||
HIDDEN bool browse_file_handler(TMask_field& f, KEY k)
|
||
{
|
||
if (k == K_F9)
|
||
{
|
||
FILE_SPEC fs; memset(&fs, 0, sizeof(FILE_SPEC));
|
||
strcpy(fs.type, "");
|
||
strcpy(fs.name, f.get());
|
||
xvt_fsys_get_default_dir(&fs.dir);
|
||
xvt_fsys_save_dir();
|
||
if (xvt_dm_post_file_open(&fs, TR("Selezione file")) == FL_OK)
|
||
{
|
||
TFilename n;
|
||
xvt_fsys_convert_dir_to_str(&fs.dir, n.get_buffer(n.size()), n.size());
|
||
n.add(fs.name);
|
||
f.set(n);
|
||
}
|
||
xvt_fsys_restore_dir();
|
||
f.set_focus();
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
void TMaestri_mask::serialize(bool bSave)
|
||
{
|
||
const char* defpar = "tc";
|
||
TConfig ini(CONFIG_DITTA, defpar);
|
||
for (int i = fields()-1; i >= 0; i--)
|
||
{
|
||
TMask_field& f = fld(i);
|
||
const TFieldref* fr = f.field();
|
||
if (fr != NULL)
|
||
{
|
||
if (bSave)
|
||
fr->write(ini, defpar, f.get());
|
||
else
|
||
f.set(fr->read(ini, defpar));
|
||
}
|
||
}
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TMaestri_sender
|
||
///////////////////////////////////////////////////////////
|
||
class TMaestri_sender : public TTS_sender
|
||
{
|
||
TMaestri_mask * _mask;
|
||
|
||
protected:
|
||
// virtual bool test_swap(const TRecordset& mov) { return ((TMov_recset&)mov).nota_credito();}
|
||
|
||
protected:
|
||
virtual TRecordset & movrecset();
|
||
virtual TRecordset & rmovrecset(const TRecordset & mov);
|
||
virtual TRecordset & rivarecset(const TRecordset & mov);
|
||
virtual const TRecordset & clirecset(const char tipocf, const long codcf);
|
||
virtual const char * decode_causale(const TRecordset& mov);
|
||
virtual TMask & get_mask();
|
||
virtual const char * extra_modules() const {return "ba";}
|
||
|
||
public:
|
||
virtual void update_parameters(const TMask & m, TRecordset & mov) {}
|
||
TMaestri_sender() : _mask(NULL) {}
|
||
};
|
||
|
||
TMaestri_sender& app() { return (TMaestri_sender&)main_app(); }
|
||
|
||
TMask & TMaestri_sender::get_mask()
|
||
{
|
||
if (_mask == NULL)
|
||
_mask = new TMaestri_mask;
|
||
|
||
return * _mask;
|
||
}
|
||
|
||
const char * TMaestri_sender::decode_causale(const TRecordset& mov)
|
||
{
|
||
const int codcaus = mov.get(MOV_CODCAUS).as_int();
|
||
|
||
switch (codcaus)
|
||
{
|
||
case 1:
|
||
return "Fattura di vendita";
|
||
case 2:
|
||
return "Nota di credito a cliente";
|
||
case 11:
|
||
return "Fattura di acquisto";
|
||
case 12:
|
||
return "Nota di credito da fornitore";
|
||
default:
|
||
break;
|
||
}
|
||
return "";
|
||
}
|
||
|
||
TRecordset & TMaestri_sender::movrecset()
|
||
{
|
||
|
||
TRecordset * mov = get_recset(LF_MOV);
|
||
|
||
if (mov == NULL)
|
||
{
|
||
TString query("SELECT * FROM ");
|
||
TMask & m = get_mask();
|
||
TFilename name = m.get(F_INPATH);
|
||
|
||
name.add(m.get(F_INFILEM));
|
||
query << name;
|
||
|
||
mov = set_recset(LF_MOV, new TMov_recset(query, recsets()));
|
||
}
|
||
|
||
return *mov;
|
||
}
|
||
|
||
TRecordset & TMaestri_sender::rmovrecset(const TRecordset & mov)
|
||
{
|
||
TRMov_recset * rmov = (TRMov_recset *) get_recset(LF_RMOV);
|
||
CHECK(rmov != NULL, "Recordset righe contabili non inizializzato");
|
||
long numreg = mov.get(MOV_NUMREG).as_int();
|
||
|
||
rmov->find(numreg);
|
||
return *rmov;
|
||
}
|
||
|
||
TRecordset & TMaestri_sender::rivarecset(const TRecordset & mov)
|
||
{
|
||
TIVA_recset * rmoviva = (TIVA_recset *) get_recset(LF_RMOVIVA);
|
||
CHECK(rmoviva != NULL, "Recordset righe IVA non inizializzato");
|
||
long numreg = mov.get(MOV_NUMREG).as_int();
|
||
|
||
rmoviva->find(numreg);
|
||
return *rmoviva;
|
||
}
|
||
|
||
const TRecordset& TMaestri_sender::clirecset(const char tipocf, const long codcf)
|
||
{
|
||
TClifo_recset * clifo = (TClifo_recset *) get_recset(LF_CLIFO);
|
||
|
||
if (clifo == NULL)
|
||
{
|
||
TString query("SELECT * FROM ");
|
||
TMask & m = get_mask();
|
||
TFilename name = m.get(F_INPATH);
|
||
|
||
name.add(m.get(F_INFILEA));
|
||
query << name;
|
||
|
||
clifo = (TClifo_recset *) set_recset(LF_CLIFO, new TClifo_recset(query));
|
||
}
|
||
|
||
if (!clifo->find(tipocf, codcf))
|
||
{
|
||
TString msg(tipocf == 'C' ? "Cliente " : "Fornitore ");
|
||
|
||
msg << codcf << " assente";
|
||
app().log(2, msg);
|
||
}
|
||
|
||
return *clifo;
|
||
}
|
||
|
||
int pg0001200(int argc, char* argv[])
|
||
{
|
||
TMaestri_sender app;
|
||
app.run(argc, argv, "Invio a TeamSystem");
|
||
return 0;
|
||
}
|