root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ps/pg0001200.cpp
luca 063b45782c Patch level : 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :


git-svn-id: svn://10.65.10.50/trunk@16033 c028cbd2-c16b-5b4b-a496-9718f37d4682
2008-01-23 09:37:37 +00:00

968 lines
22 KiB
C++
Executable File
Raw Blame History

#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(fname).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(MOV_CODCAUS, 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();
var.set(TAS400_recordset::get(fname).as_real() / CENTO);
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(60)\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, 3);
add_field(RMI_IMPONIBILE, 14, n, 15); // 18
add_field(RMI_IMPOSTA, 29, n, 15); // 18
add_field(RMI_TIPODET, 44, n, 1);
add_field(RMI_TIPOCR, 45, n, 1);
add_field(RMI_INTRA, 46, a, 1);
add_field(RMI_TIPOATT, 47, n, 1);
add_field(RMI_TIPOC, 48, a, 1);
add_field(RMI_GRUPPO, 49, n, 3);
add_field(RMI_CONTO, 52, n, 3); // 18
add_field(RMI_SOTTOCONTO, 55, 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(MOV_CODCAUS).as_int();
const bool indetraibile = mov.indetraibile();
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();
var.set(TAS400_recordset::get(fname).as_real() / CENTO);
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;
}
Reference in New Issue View Git Blame Copy Permalink