e5e8e29901
Files correlati : lv2 Ricompilazione Demo : [ ] Commento : Modificata la gestione dei pacchi annullati git-svn-id: svn://10.65.10.50/trunk@20380 c028cbd2-c16b-5b4b-a496-9718f37d4682
1722 lines
44 KiB
C++
Executable File
1722 lines
44 KiB
C++
Executable File
#include "lvlib.h"
|
|
#include "lvrcondv.h"
|
|
#include "lvcondv.h"
|
|
|
|
#include "../cg/cglib01.h"
|
|
#include "../mg/clifogiac.h"
|
|
|
|
#include <applicat.h>
|
|
#include <config.h>
|
|
#include <modaut.h>
|
|
#include <recset.h>
|
|
#include <utility.h>
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Utilities
|
|
///////////////////////////////////////////////////////////
|
|
|
|
void lv_set_creation_info(TRectype& rec)
|
|
{
|
|
rec.set_creation_info();
|
|
}
|
|
|
|
void lv_set_update_info(TRectype& rec)
|
|
{
|
|
rec.set_modify_info();
|
|
}
|
|
|
|
//funzione che restituisce true se la data che gli passo è una festività
|
|
bool lv_is_holiday(const TDate& data)
|
|
{
|
|
static TAssoc_array calendari;
|
|
|
|
const int anno = data.year();
|
|
|
|
TString16 key;
|
|
key.format("%05ld%4d",prefix().get_codditta(),anno);
|
|
|
|
TString* cal = (TString*)calendari.objptr(key);
|
|
|
|
if (cal == NULL)
|
|
{
|
|
TConfig ini(CONFIG_DITTA);
|
|
cal = new TString(366);
|
|
calendari.add(key,cal);
|
|
*cal = ini.get("CAL", "lv", anno);
|
|
cal->left_just(366,'-');
|
|
}
|
|
|
|
const TDate primo(1,1,anno);
|
|
const long index = data - primo;
|
|
|
|
return (*cal)[index] == 'X';
|
|
}
|
|
|
|
HIDDEN short __lv_02_active = 0x3;
|
|
HIDDEN TFilename __lv_backup_path;
|
|
|
|
bool lv_is_02_active()
|
|
{
|
|
if (__lv_02_active == 0x3)
|
|
{
|
|
__lv_02_active = main_app().has_module(L2AUT);
|
|
|
|
if (__lv_02_active)
|
|
{
|
|
__lv_backup_path = ini_get_string(CONFIG_DITTA, "lv", "Backup");
|
|
__lv_02_active = __lv_backup_path.full();
|
|
if (__lv_02_active)
|
|
{
|
|
TFilename dir(__lv_backup_path);
|
|
|
|
dir.add("com");
|
|
dir.add("dir.gen");
|
|
__lv_02_active = dir.exist() && dir.find(' ') < 0;
|
|
}
|
|
}
|
|
}
|
|
return __lv_02_active != 0;
|
|
}
|
|
|
|
const TFilename & lv_backup_path()
|
|
{
|
|
lv_is_02_active(); // serve per inizializzare il valore
|
|
return __lv_backup_path;
|
|
}
|
|
//funzione che restituisce un codice contratto valido dato cliente, indirizzo di spedizione e data
|
|
long lv_find_contract(const long codcf, const long indsped, const TDate& data)
|
|
{
|
|
TString query;
|
|
query << "USE LVCONDV\n"
|
|
<< "SELECT BETWEEN(#DATA,DATAIN,DATASC)&&BETWEEN(CODINDSP,#INDSPED,#INDSPED)&&(PROPOSTA!=\"X\")\n"
|
|
<< "FROM CODCF=#CODCF\nTO CODCF=#CODCF";
|
|
TISAM_recordset contr(query);
|
|
contr.set_var("#DATA",data);
|
|
contr.set_var("#INDSPED",indsped);
|
|
contr.set_var("#CODCF",codcf);
|
|
|
|
long cod = 0L;
|
|
if (contr.move_first())
|
|
cod = contr.get("CODCONT").as_int();
|
|
|
|
if (cod == 0L)
|
|
{
|
|
query.cut(0);
|
|
query << "USE LVCONDV\n"
|
|
<< "SELECT BETWEEN(#DATA,DATAIN,DATASC)&&(PROPOSTA!=\"X\")\n"
|
|
<< "FROM CODCF=#CODCF\nTO CODCF=#CODCF";
|
|
TISAM_recordset contr(query);
|
|
contr.set_var("#DATA",data);
|
|
contr.set_var("#CODCF",codcf);
|
|
|
|
if (contr.move_first())
|
|
cod = contr.get("CODCONT").as_int();
|
|
}
|
|
|
|
return cod;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TLaundry_contract
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TRectype& TLaundry_contract::modify_row(const char* codart)
|
|
{
|
|
const long codcf = get_int(LVRCONDV_CODCF);
|
|
const long codcont = get_int(LVRCONDV_CODCONT);
|
|
|
|
TLocalisamfile rcondv(LF_LVRCONDV);
|
|
rcondv.put(LVRCONDV_CODCF, codcf);
|
|
rcondv.put(LVRCONDV_CODCONT, codcont);
|
|
rcondv.put(LVRCONDV_CODART, codart);
|
|
|
|
int err = rcondv.read();
|
|
|
|
TRectype& riga = rcondv.curr();
|
|
return riga;
|
|
}
|
|
|
|
// Ritorna la riga di contratto corrispondente a codart
|
|
const TRectype& TLaundry_contract::row(const char* codart) const
|
|
{
|
|
TToken_string key;
|
|
key.add(get(LVRCONDV_CODCF));
|
|
key.add(get(LVRCONDV_CODCONT));
|
|
key.add(codart);
|
|
return cache().get(LF_LVRCONDV, key);
|
|
}
|
|
|
|
// Controlla se il contratto esiste veramente
|
|
bool TLaundry_contract::ok() const
|
|
{ return !empty(); }
|
|
|
|
bool TLaundry_contract::can_be_deleted() const
|
|
{
|
|
const TString4 codnum = ini_get_string(CONFIG_DITTA, "lv", "NUM_GEN");
|
|
|
|
TString query;
|
|
query << "USE DOC KEY 4 SELECT CODNUM=#CODNUM \n"
|
|
<< "FROM TIPOCF=C CODCF=#CODCF PROVV=D \n"
|
|
<< "TO TIPOCF=C CODCF=#CODCF PROVV=D \n";
|
|
|
|
TISAM_recordset rset(query);
|
|
|
|
rset.set_var("#CODNUM",TVariant(codnum));
|
|
rset.set_var("#CODCF",get_long(LVCONDV_CODCF));
|
|
|
|
return !rset.move_first();
|
|
}
|
|
|
|
//aggiunge una riga al contratto con quel codart
|
|
int TLaundry_contract::add_row(const char* codart)
|
|
{
|
|
const long codcf = get_int(LVRCONDV_CODCF);
|
|
const long codcont = get_int(LVRCONDV_CODCONT);
|
|
|
|
TLocalisamfile rcondv(LF_LVRCONDV);
|
|
rcondv.put(LVRCONDV_CODCF, codcf);
|
|
rcondv.put(LVRCONDV_CODCONT, codcont);
|
|
rcondv.put(LVRCONDV_CODART, codart);
|
|
|
|
return rcondv.rewrite_write();
|
|
}
|
|
|
|
//fa l'update di una riga del contratto
|
|
int TLaundry_contract::update_row(const char* codart, const char* fieldname, const bool bol)
|
|
{
|
|
const long codcf = get_int(LVRCONDV_CODCF);
|
|
const long codcont = get_int(LVRCONDV_CODCONT);
|
|
|
|
TLocalisamfile rcondv(LF_LVRCONDV);
|
|
rcondv.put(LVRCONDV_CODCF, codcf);
|
|
rcondv.put(LVRCONDV_CODCONT, codcont);
|
|
rcondv.put(LVRCONDV_CODART, codart);
|
|
|
|
int err = rcondv.read();
|
|
|
|
//se il record esiste
|
|
if (err == NOERR)
|
|
{
|
|
rcondv.put(LVRCONDV_CODCF, codcf);
|
|
rcondv.put(LVRCONDV_CODCONT, codcont);
|
|
rcondv.put(LVRCONDV_CODART, codart);
|
|
rcondv.put(fieldname, bol);
|
|
err = rcondv.rewrite();
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
//fa l'update di una riga del contratto
|
|
int TLaundry_contract::update_row(const char* codart, const char* fieldname, const char* str)
|
|
{
|
|
const long codcf = get_int(LVRCONDV_CODCF);
|
|
const long codcont = get_int(LVRCONDV_CODCONT);
|
|
|
|
TLocalisamfile rcondv(LF_LVRCONDV);
|
|
rcondv.put(LVRCONDV_CODCF, codcf);
|
|
rcondv.put(LVRCONDV_CODCONT, codcont);
|
|
rcondv.put(LVRCONDV_CODART, codart);
|
|
|
|
int err = rcondv.read();
|
|
|
|
//se il record esiste
|
|
if (err == NOERR)
|
|
{
|
|
rcondv.put(LVRCONDV_CODCF, codcf);
|
|
rcondv.put(LVRCONDV_CODCONT, codcont);
|
|
rcondv.put(LVRCONDV_CODART, codart);
|
|
rcondv.put(fieldname, str);
|
|
err = rcondv.rewrite();
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
//fa l'update di una riga del contratto
|
|
int TLaundry_contract::update_row(const char* codart, const char* fieldname, const long nmr)
|
|
{
|
|
const long codcf = get_int(LVRCONDV_CODCF);
|
|
const long codcont = get_int(LVRCONDV_CODCONT);
|
|
|
|
TLocalisamfile rcondv(LF_LVRCONDV);
|
|
rcondv.put(LVRCONDV_CODCF, codcf);
|
|
rcondv.put(LVRCONDV_CODCONT, codcont);
|
|
rcondv.put(LVRCONDV_CODART, codart);
|
|
|
|
int err = rcondv.read();
|
|
|
|
//se il record esiste
|
|
if (err == NOERR)
|
|
{
|
|
rcondv.put(LVRCONDV_CODCF, codcf);
|
|
rcondv.put(LVRCONDV_CODCONT, codcont);
|
|
rcondv.put(LVRCONDV_CODART, codart);
|
|
rcondv.put(fieldname, nmr);
|
|
err = rcondv.rewrite();
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
//fa l'update di una riga del contratto
|
|
int TLaundry_contract::update_row(const char* codart, const char* fieldname, const real nmr)
|
|
{
|
|
const long codcf = get_int(LVRCONDV_CODCF);
|
|
const long codcont = get_int(LVRCONDV_CODCONT);
|
|
|
|
TLocalisamfile rcondv(LF_LVRCONDV);
|
|
rcondv.put(LVRCONDV_CODCF, codcf);
|
|
rcondv.put(LVRCONDV_CODCONT, codcont);
|
|
rcondv.put(LVRCONDV_CODART, codart);
|
|
|
|
int err = rcondv.read();
|
|
|
|
//se il record esiste
|
|
if (err == NOERR)
|
|
{
|
|
rcondv.put(LVRCONDV_CODCF, codcf);
|
|
rcondv.put(LVRCONDV_CODCONT, codcont);
|
|
rcondv.put(LVRCONDV_CODART, codart);
|
|
rcondv.put(fieldname, nmr);
|
|
err = rcondv.rewrite();
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
//fa l'update di una riga del contratto
|
|
int TLaundry_contract::update_row(const char* codart, const char* fieldname, const TDate& data)
|
|
{
|
|
const long codcf = get_int(LVRCONDV_CODCF);
|
|
const long codcont = get_int(LVRCONDV_CODCONT);
|
|
|
|
TLocalisamfile rcondv(LF_LVRCONDV);
|
|
rcondv.put(LVRCONDV_CODCF, codcf);
|
|
rcondv.put(LVRCONDV_CODCONT, codcont);
|
|
rcondv.put(LVRCONDV_CODART, codart);
|
|
|
|
int err = rcondv.read();
|
|
|
|
//se il record esiste
|
|
if (err == NOERR)
|
|
{
|
|
rcondv.curr().zero();
|
|
rcondv.put(LVRCONDV_CODCF, codcf);
|
|
rcondv.put(LVRCONDV_CODCONT, codcont);
|
|
rcondv.put(LVRCONDV_CODART, codart);
|
|
rcondv.put(fieldname, data);
|
|
err = rcondv.rewrite();
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
// Legge un contratto tramite la chiave primaria cliente+codice
|
|
bool TLaundry_contract::read(const long codcf, const long codcont)
|
|
{
|
|
if (codcf > 0 && codcont > 0) // Campi obbligatori!
|
|
{
|
|
TString16 key; key.format("%ld|%ld", codcf, codcont);
|
|
*((TRectype*)this) = cache().get(LF_LVCONDV, key);
|
|
}
|
|
else
|
|
zero();
|
|
return ok();
|
|
}
|
|
|
|
// Cerca il contratto in essere alla data di un certo cliente+indirizzo
|
|
bool TLaundry_contract::read(const long codcf, const long indsped, const TDate& data)
|
|
{
|
|
const long codcont = lv_find_contract(codcf, indsped, data);
|
|
return read(codcf, codcont);
|
|
}
|
|
|
|
// Inizializza un contratto vuoto: servira' una read successiva
|
|
TLaundry_contract::TLaundry_contract() : TRectype(LF_LVCONDV)
|
|
{ zero(); }
|
|
|
|
TLaundry_contract::TLaundry_contract(const TRectype & rec): TRectype(rec)
|
|
{
|
|
}
|
|
// Inizializza un contratto in base alla chiave primaria
|
|
TLaundry_contract::TLaundry_contract(const long codcf, const long codcont)
|
|
: TRectype(LF_LVCONDV)
|
|
{ read(codcf, codcont); }
|
|
|
|
// Tenta di inizilizzare il contratto corrente di un cliente
|
|
TLaundry_contract::TLaundry_contract(const long codcf, const long indsped, const TDate& data)
|
|
: TRectype(LF_LVCONDV)
|
|
{ read(codcf, indsped, data); }
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TRecmag_lavanderie
|
|
///////////////////////////////////////////////////////////
|
|
|
|
int TRecmag_lavanderie::read(TBaseisamfile& f, word op, word lockop)
|
|
{
|
|
_update_time = 0L;
|
|
return TVariable_rectype::read(f, op, lockop);
|
|
}
|
|
int TRecmag_lavanderie::readat(TBaseisamfile& f, TRecnotype nrec, word lockop)
|
|
{
|
|
_update_time = 0L;
|
|
return TVariable_rectype::readat(f, nrec, lockop);
|
|
}
|
|
|
|
void TRecmag_lavanderie::update()
|
|
{
|
|
if (_update_time > 0L)
|
|
return;
|
|
|
|
_update_time = 1L;
|
|
|
|
TString query, filter;
|
|
const int anno = get_int(CLIFOGIAC_ANNOES);
|
|
const TString4 tipocf(get(CLIFOGIAC_TIPOCF));
|
|
const long codcf = get_long(CLIFOGIAC_CODCF);
|
|
const int indsped = get_int(CLIFOGIAC_INDSPED);
|
|
const TString80 codart(get(CLIFOGIAC_CODART));
|
|
const TString80 livello(get(CLIFOGIAC_LIVELLO));
|
|
const TDate oggi(TODAY);
|
|
TDate imese;
|
|
TEsercizi_contabili & esc = esercizi();
|
|
const TArticolo & artrec = cached_article(codart);
|
|
|
|
if (anno >= esc.date2esc(oggi))
|
|
{
|
|
imese = oggi;
|
|
imese.set_day(1);
|
|
}
|
|
else
|
|
imese = esc.esercizio(anno).fine();
|
|
|
|
/* query="USE MOVMAG KEY 2\n";
|
|
query << "SELECT (TIPOCF='C')&&(CODCF==" << codcf << ")&&(STR(CODINDSP==" << indsped << "))&&(BETWEEN(DATACOMP," << imese.date2ansi() << "," << oggi.date2ansi() << "))\n";
|
|
query << "FROM ANNOES=" << anno << "\n";
|
|
query << "TO ANNOES=" << anno << "\n"; */
|
|
query="USE MOVMAG KEY 5\n";
|
|
query << "FROM TIPOCF='C'"
|
|
<< " CODCF=" << codcf
|
|
<< " CODINDSP=" << indsped
|
|
<< " DATACOMP=" << imese.string() << "\n";
|
|
query << "TO TIPOCF='C'"
|
|
<< " CODCF=" << codcf
|
|
<< " CODINDSP=" << indsped
|
|
<< " DATACOMP=" << oggi.string() << "\n";
|
|
|
|
TISAM_recordset recmag(query);
|
|
TString8 codcausmov;
|
|
|
|
_consmese = ZERO;
|
|
for (bool ok = recmag.move_first(); ok; ok = recmag.move_next())
|
|
{
|
|
TString queryrmag("USE RMOVMAG\n");
|
|
queryrmag << " SELECT (CODART=\"" << codart << "\")&&(LIVGIAC=\"" << livello << "\")\n";
|
|
queryrmag << "FROM NUMREG=" << recmag.get(MOVMAG_NUMREG) << "\n"
|
|
<< "TO NUMREG=" << recmag.get(MOVMAG_NUMREG) << "\n";
|
|
|
|
codcausmov = recmag.get(MOVMAG_CODCAUS).as_string();
|
|
TISAM_recordset recrmag(queryrmag);
|
|
|
|
for (bool ok=recrmag.move_first(); ok; ok=recrmag.move_next())
|
|
{
|
|
const TString& codcaus = recrmag.get(RMOVMAG_CODCAUS).as_string();
|
|
const TCausale_magazzino & tcaus = cached_causale_magazzino(codcaus.full() ? codcaus : codcausmov);
|
|
int sgn_consmese = tcaus.sgn(s_consmese);
|
|
|
|
if (sgn_consmese != 0)
|
|
{
|
|
const real qta = ((TArticolo &)artrec).convert_to_um(recrmag.get(RMOVMAG_QUANT).as_real(), NULL, recrmag.get(RMOVMAG_UM).as_string());
|
|
|
|
_consmese += real(qta * sgn_consmese);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int TRecmag_lavanderie::name2index(const char* fieldname) const
|
|
{
|
|
if (strcmp(fieldname, "CONSMESE") == 0)
|
|
return 0;
|
|
return -1;
|
|
}
|
|
|
|
TFieldtypes TRecmag_lavanderie::type(const char* fieldname) const
|
|
|
|
{
|
|
if (name2index(fieldname) >= 0)
|
|
return _realfld;
|
|
return TRectype::type(fieldname);
|
|
}
|
|
|
|
|
|
int TRecmag_lavanderie::length(const char* fieldname) const
|
|
|
|
{
|
|
if (name2index(fieldname) >= 0)
|
|
return 15;
|
|
return TRectype::length(fieldname);
|
|
}
|
|
|
|
|
|
int TRecmag_lavanderie::ndec(const char* fieldname) const
|
|
{
|
|
if (name2index(fieldname) >= 0)
|
|
return 5;
|
|
return TRectype::ndec(fieldname);
|
|
}
|
|
|
|
bool TRecmag_lavanderie::exist(const char* fieldname) const
|
|
{
|
|
if (name2index(fieldname) >= 0)
|
|
return true;
|
|
return TRectype::exist(fieldname);
|
|
}
|
|
|
|
const TString & TRecmag_lavanderie::get_str(const char* fieldname) const
|
|
{
|
|
const int index = name2index(fieldname);
|
|
|
|
if (index >= 0)
|
|
((TRecmag_lavanderie *)this)->update();
|
|
switch (index)
|
|
{
|
|
case 0: return get_tmp_string() = _consmese.string();
|
|
default: break;
|
|
}
|
|
// rec.put(CLIFOGIAC_DOTOD, oldrec.get(CLIFOGIAC_DOTOD));
|
|
// rec.put(CLIFOGIAC_DOTIN, oldrec.get(CLIFOGIAC_DOTIN));
|
|
|
|
return TVariable_rectype::get_str(fieldname);
|
|
}
|
|
|
|
TRecmag_lavanderie::TRecmag_lavanderie()
|
|
: TVariable_rectype(LF_CLIFOGIAC)
|
|
{
|
|
}
|
|
|
|
TObject* TRecmag_lavanderie::dup() const
|
|
{
|
|
TRecmag_lavanderie* o = new TRecmag_lavanderie(*this);
|
|
return o;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TArticolo_lavanderie
|
|
///////////////////////////////////////////////////////////
|
|
|
|
const TString & TArticolo_lavanderie::get_str(const char* fieldname) const
|
|
{
|
|
if (*fieldname != '#')
|
|
return TRectype::get_str(fieldname);
|
|
char * fname = (char *) fieldname + 1;
|
|
const int logicnum = atoi(fname);
|
|
if (logicnum != LF_CLIFOGIAC)
|
|
return TArticolo_giacenza_data::get_str(fieldname);
|
|
|
|
const char * op1 = strchr(fname, '_');
|
|
int index = 0;
|
|
if (op1)
|
|
{
|
|
op1=op1+1;
|
|
fname = (char *) op1;
|
|
if (*op1 == '#')
|
|
index = atoi(fname + 1);
|
|
}
|
|
const char * op2 = strchr(fname, '_');
|
|
if (op2)
|
|
{
|
|
op2=op2+1;
|
|
fname = (char *) op2 + 1;
|
|
}
|
|
const char * op3 = strchr(fname, '_');
|
|
if (op3)
|
|
{
|
|
op3=op3+1;
|
|
fname = (char *) op3 + 1;
|
|
}
|
|
const char * op4 = strchr(fname, '_');
|
|
if (op4)
|
|
{
|
|
op4=op4+1;
|
|
fname = (char *) op2 + 1;
|
|
}
|
|
const char * op5 = strchr(fname, '_');
|
|
if (op5)
|
|
op5=op5+1;
|
|
const char * op6 = strstr(fname, "->");
|
|
CHECKS(op6, "Can't find '->' in string ", fieldname);
|
|
op6=op6+2;
|
|
|
|
if (logicnum == LF_CLIFOGIAC && op2 && op3 && op4)
|
|
{
|
|
((TArticolo_lavanderie *)this)->set_tipocf(*op2);
|
|
((TArticolo_lavanderie *)this)->set_codcf(atol(op3));
|
|
((TArticolo_lavanderie *)this)->set_indsped(atol(op4));
|
|
if (index == 0)
|
|
index = find_clifomag(op1, op5);
|
|
if (index > 0)
|
|
return clifomag(op1).row(index).get(op4);
|
|
}
|
|
return EMPTY_STRING;
|
|
}
|
|
|
|
void TArticolo_lavanderie::set_tipocf(char tipocf)
|
|
{
|
|
if (_tipocf != tipocf)
|
|
{
|
|
_tipocf = tipocf;
|
|
remove_body(LF_CLIFOGIAC);
|
|
}
|
|
}
|
|
|
|
void TArticolo_lavanderie::set_codcf(long codcf)
|
|
{
|
|
if (_codcf != codcf)
|
|
{
|
|
_codcf = codcf;
|
|
remove_body(LF_CLIFOGIAC);
|
|
}
|
|
}
|
|
|
|
void TArticolo_lavanderie::set_indsped(int indsped)
|
|
{
|
|
if (_indsped != indsped)
|
|
{
|
|
_indsped = indsped;
|
|
remove_body(LF_CLIFOGIAC);
|
|
}
|
|
}
|
|
|
|
void TArticolo_lavanderie::set_body_key(TRectype & rowrec)
|
|
{
|
|
const int logicnum = rowrec.num();
|
|
const char * cod = (const char *) codice();
|
|
|
|
switch (logicnum)
|
|
{
|
|
case LF_CLIFOGIAC:
|
|
rowrec.put(CLIFOGIAC_ANNOES, _anno_lav);
|
|
rowrec.put(CLIFOGIAC_CODART, cod);
|
|
rowrec.put(CLIFOGIAC_TIPOCF, _tipocf);
|
|
rowrec.put(CLIFOGIAC_CODCF, _codcf);
|
|
rowrec.put(CLIFOGIAC_INDSPED, _indsped);
|
|
break;
|
|
default:
|
|
TArticolo_giacenza_data::set_body_key(rowrec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void TArticolo_lavanderie::set_anno_lav (int anno)
|
|
{
|
|
if (_anno_lav != anno)
|
|
remove_body(LF_CLIFOGIAC);
|
|
_anno_lav = anno;
|
|
}
|
|
|
|
TRectype * TArticolo_lavanderie::new_body_record(int logicnum)
|
|
{
|
|
if (logicnum == LF_CLIFOGIAC)
|
|
return new TRecmag_lavanderie();
|
|
return new TRectype(logicnum ? logicnum : TArticolo_giacenza_data::num());
|
|
}
|
|
|
|
int TArticolo_lavanderie::find_clifomag(TRecord_array& rclifomag, const char * livello, int from) const
|
|
|
|
{
|
|
const int last = rclifomag.last_row();
|
|
|
|
if (last > 0 && from < last)
|
|
{
|
|
const int livello_len = livello ? strlen(livello) : 0;
|
|
|
|
if (livello_len == 0)
|
|
return from + 1;
|
|
|
|
for (int i = rclifomag.succ_row(from); i <= last; i = rclifomag.succ_row(i))
|
|
{
|
|
const TRectype & rec = rclifomag.row(i);
|
|
|
|
if (livello_len == 0 || rec.get(CLIFOGIAC_LIVELLO).compare(livello, livello_len) == 0)
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int TArticolo_lavanderie::find_clifomag(int annoes, const char * livello, int from) const
|
|
{
|
|
TRecord_array & rclifomag = clifomag(annoes);
|
|
return find_clifomag(rclifomag, livello, from);
|
|
}
|
|
|
|
TRecord_array & TArticolo_lavanderie::clifomag(int annoes) const
|
|
{
|
|
((TArticolo_lavanderie*)this)->set_anno_lav(annoes > 0 ? annoes : esercizi().last_mag());
|
|
TRecord_array & recarr = body(LF_CLIFOGIAC);
|
|
|
|
if (recarr.rows() == 0)
|
|
{
|
|
TString query;
|
|
const char * cod = (const char *) codice();
|
|
const int esprec = esercizi().pred(annoes);
|
|
|
|
query << "USE " << LF_CLIFOGIAC << "\n";
|
|
query << "FROM " << CLIFOGIAC_ANNOES << '=' << esprec << ' '
|
|
<< CLIFOGIAC_TIPOCF << '=' << _tipocf << ' '
|
|
<< CLIFOGIAC_CODCF << '=' << _codcf << ' '
|
|
<< CLIFOGIAC_INDSPED << '=' << _indsped << ' '
|
|
<< CLIFOGIAC_CODART << '=' << cod << '\n';
|
|
query << "TO " << CLIFOGIAC_ANNOES << '=' << esprec << ' '
|
|
<< CLIFOGIAC_TIPOCF << '=' << _tipocf << ' '
|
|
<< CLIFOGIAC_CODCF << '=' << _codcf << ' '
|
|
<< CLIFOGIAC_INDSPED << '=' << _indsped << ' '
|
|
<< CLIFOGIAC_CODART << '=' << cod << '\n';
|
|
|
|
TISAM_recordset recmag(query);
|
|
for (bool ok=recmag.move_first(); ok; ok=recmag.move_next())
|
|
{
|
|
const TRecmag_lavanderie oldrec(recmag.cursor()->curr());
|
|
const int r = recarr.add_row(oldrec);
|
|
TRecmag_lavanderie & rec = (TRecmag_lavanderie &) recarr[r];
|
|
|
|
rec.put(CLIFOGIAC_ANNOES, annoes);
|
|
::reset_clifogiac(rec, oldrec);
|
|
}
|
|
}
|
|
return recarr;
|
|
}
|
|
const TRecmag_lavanderie & TArticolo_lavanderie::find_rec(int annoes) const
|
|
{
|
|
static TRecmag_lavanderie __rec;
|
|
const int i = find_clifomag(annoes);
|
|
|
|
if (i >= 0)
|
|
return (const TRecmag_lavanderie &) clifomag(annoes).row(i);
|
|
|
|
__rec.zero();
|
|
return __rec;
|
|
}
|
|
|
|
TArticolo_lavanderie::TArticolo_lavanderie(const char* codice, const char tipocf, const long codcf, const int indsped)
|
|
: TArticolo_giacenza_data(codice), _anno_lav(0),
|
|
_tipocf(tipocf), _codcf(codcf), _indsped(indsped)
|
|
|
|
{
|
|
add_file(LF_CLIFOGIAC ,"NRIGA");
|
|
}
|
|
|
|
TArticolo_lavanderie::TArticolo_lavanderie(const TRectype & rec, const char tipocf, const long codcf, const int indsped)
|
|
: TArticolo_giacenza_data(rec), _anno_lav(0),
|
|
_tipocf(tipocf), _codcf(codcf), _indsped(indsped)
|
|
|
|
{
|
|
add_file(LF_CLIFOGIAC ,"NRIGA");
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TCache_articoli_lavanderie
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TCache_articoli_lavanderie : public TRecord_cache
|
|
{
|
|
protected:
|
|
virtual TObject* rec2obj(const TRectype& rec) const { return new TArticolo_lavanderie(rec);}
|
|
|
|
public:
|
|
TArticolo_lavanderie& lav(const char* key) { return (TArticolo_lavanderie&)query(key); }
|
|
|
|
TCache_articoli_lavanderie();
|
|
virtual ~TCache_articoli_lavanderie() { }
|
|
};
|
|
|
|
TCache_articoli_lavanderie::TCache_articoli_lavanderie()
|
|
: TRecord_cache(LF_ANAMAG, 1)
|
|
{
|
|
test_file_changes(); // Tieni d'occhio le modifiche sul file
|
|
set_items_limit(256); // Standard
|
|
}
|
|
|
|
TArticolo_lavanderie & cached_article_laundry(const char * codart, const char tipocf, const long codcf, const int indsped)
|
|
{
|
|
HIDDEN TCache_articoli_lavanderie __cache_articoli_lavanderie;
|
|
|
|
|
|
TArticolo_lavanderie & art = __cache_articoli_lavanderie.lav(codart);
|
|
|
|
art.set_tipocf(tipocf);
|
|
art.set_codcf(codcf);
|
|
art.set_indsped(indsped);
|
|
return art;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TLavanderie_calendar
|
|
///////////////////////////////////////////////////////////
|
|
|
|
// Serve per aggiungere le feste dei Patroni
|
|
void TLavanderie_calendar::set_holiday(const TDate & date, bool holiday)
|
|
{
|
|
if (_year == date.year())
|
|
{
|
|
const TDate inizio(1, 1, _year);
|
|
long ndays = date - inizio;
|
|
|
|
_days.set(ndays, holiday);
|
|
}
|
|
}
|
|
|
|
bool TLavanderie_calendar::is_holiday(const TDate& date) const
|
|
{
|
|
if (_year == date.year())
|
|
{
|
|
const TDate inizio(1, 1, _year);
|
|
long ndays = date - inizio;
|
|
|
|
return _days[ndays];
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int TLavanderie_calendar::read(int year)
|
|
{
|
|
if (year != 0)
|
|
_year = year;
|
|
|
|
TConfig cfg(CONFIG_DITTA);
|
|
const TString val = cfg.get("CAL", "lv", _year);
|
|
|
|
if (val.full())
|
|
{
|
|
const int len = val.len();
|
|
for (int i = 0; i < len; i++)
|
|
_days.set(i, val[i] == 'X');
|
|
}
|
|
else
|
|
{
|
|
const TDate inizio(1, 1, _year);
|
|
const TDate fine(31, 12, _year);
|
|
TDate data(inizio);
|
|
|
|
for (int i = 0; data <= fine; ++data, i++)
|
|
_days.set(i, data.is_holiday());
|
|
}
|
|
|
|
return NOERR;
|
|
}
|
|
|
|
int TLavanderie_calendar::write() const
|
|
{
|
|
TString val(366);
|
|
const TDate inizio(1, 1, _year);
|
|
const TDate fine(31, 12, _year);
|
|
TDate data(inizio);
|
|
TConfig cfg(CONFIG_DITTA);
|
|
|
|
for (int i = 0; data <= fine; ++data, i++)
|
|
val << (_days[i] ? 'X' : '-');
|
|
cfg.set("CAL", val, "lv", true, _year);
|
|
return NOERR;
|
|
}
|
|
|
|
int TLavanderie_calendar::remove() const
|
|
{
|
|
TString val(366);
|
|
TConfig cfg(CONFIG_DITTA);
|
|
const TDate inizio(1, 1, _year);
|
|
const TDate fine(31, 12, _year);
|
|
TDate data(inizio);
|
|
|
|
for (int i = 0; data <= fine; ++data, i++)
|
|
val << data.is_holiday() ? 'X' : '-';
|
|
cfg.set("CAL", val, "lv", true, _year);
|
|
return NOERR;
|
|
}
|
|
|
|
TLavanderie_calendar::TLavanderie_calendar(const int year) : _year(year)
|
|
{
|
|
read();
|
|
}
|
|
|
|
|
|
///////////////////////////////////
|
|
//// TCausale_lavanderie ////
|
|
///////////////////////////////////
|
|
|
|
TCausale_lavanderie::TCausale_lavanderie(const char * codice):
|
|
TRectype(cache().get("&CAU", codice))
|
|
{
|
|
}
|
|
|
|
|
|
TCausale_lavanderie::TCausale_lavanderie(const TRectype &r):
|
|
TRectype(r)
|
|
{
|
|
CHECK(r.num() == LF_TABMOD, "Tipo record errato sulla causale di magazzino");
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TCache_causali_lavanderie
|
|
///////////////////////////////////////////////////////////
|
|
class TCache_causali_lavanderie : public TRecord_cache
|
|
{
|
|
protected:
|
|
virtual TObject* rec2obj(const TRectype& rec) const{ return new TCausale_lavanderie(rec); }
|
|
|
|
|
|
public:
|
|
TCausale_lavanderie & caus(const char* key);
|
|
|
|
TCache_causali_lavanderie();
|
|
virtual ~TCache_causali_lavanderie() { }
|
|
};
|
|
|
|
|
|
TCache_causali_lavanderie::TCache_causali_lavanderie()
|
|
: TRecord_cache("LVCAU", 1)
|
|
{
|
|
test_file_changes(); // Tieni d'occhio le modifiche sul file
|
|
set_items_limit(83); // Numero primo
|
|
}
|
|
|
|
TCausale_lavanderie & TCache_causali_lavanderie::caus(const char* key)
|
|
{
|
|
TString16 k;
|
|
|
|
k << "LV||CAU|" << key;
|
|
return (TCausale_lavanderie &)query(k);
|
|
}
|
|
|
|
TCausale_lavanderie & cached_causale_lavanderie(const char * codcaus)
|
|
{
|
|
HIDDEN TCache_causali_lavanderie __cache_causali_lavanderie;
|
|
|
|
return __cache_causali_lavanderie.caus(codcaus);
|
|
}
|
|
|
|
|
|
////////////////////////
|
|
//// TDOC_KEY ////
|
|
////////////////////////
|
|
|
|
//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti
|
|
const char TDoc_key::provv()
|
|
{
|
|
return get(0)[0];
|
|
}
|
|
|
|
//ANNO: metodo che restituisce l'anno dalla TToken_string chiave dei documenti
|
|
const int TDoc_key::anno()
|
|
{
|
|
return get_int(1);
|
|
}
|
|
|
|
//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti
|
|
const char* TDoc_key::codnum()
|
|
{
|
|
return get(2);
|
|
}
|
|
|
|
//NDOC: metodo che restituisce il numero documento dalla TToken_string chiave dei documenti
|
|
const long TDoc_key::ndoc()
|
|
{
|
|
return get_int(3);
|
|
}
|
|
|
|
//SET_PROVV: metodo che setta il campo provv
|
|
void TDoc_key::set_provv(const char provv)
|
|
{
|
|
add(provv, 0);
|
|
}
|
|
|
|
//SET_ANNO: metodo che setta il campo anno
|
|
void TDoc_key::set_anno(const int anno)
|
|
{
|
|
add(anno, 1);
|
|
}
|
|
|
|
//SET_CODNUM: metodo che setta il campo codnum
|
|
void TDoc_key::set_codnum(const char* codnum)
|
|
{
|
|
add(codnum, 2);
|
|
}
|
|
|
|
//SET_NDOC: metodo che setta il campo ndoc
|
|
void TDoc_key::set_ndoc(const long ndoc)
|
|
{
|
|
add(ndoc, 3);
|
|
}
|
|
|
|
//metodi costruttori
|
|
TDoc_key::TDoc_key(const int anno, const TString& codnum, const long ndoc, const char provv)
|
|
{
|
|
add(provv);
|
|
add(anno);
|
|
add(codnum);
|
|
add(ndoc);
|
|
}
|
|
|
|
/////////////////////////
|
|
//// TRDOC_KEY ////
|
|
/////////////////////////
|
|
|
|
//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti
|
|
const char TRdoc_key::provv()
|
|
{
|
|
return get(0)[0];
|
|
}
|
|
|
|
//ANNO: metodo che restituisce l'anno dalla TToken_string chiave dei documenti
|
|
const int TRdoc_key::anno()
|
|
{
|
|
return get_int(1);
|
|
}
|
|
|
|
//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti
|
|
const char* TRdoc_key::codnum()
|
|
{
|
|
return get(2);
|
|
}
|
|
|
|
//NDOC: metodo che restituisce il numero documento dalla TToken_string chiave dei documenti
|
|
const long TRdoc_key::ndoc()
|
|
{
|
|
return get_int(3);
|
|
}
|
|
|
|
const int TRdoc_key::nriga()
|
|
{
|
|
return get_int(4);
|
|
}
|
|
|
|
//metodi costruttori
|
|
TRdoc_key::TRdoc_key(const int anno, const TString& codnum, const long ndoc, const int nriga, const char provv)
|
|
{
|
|
add(provv);
|
|
add(anno);
|
|
add(codnum);
|
|
add(ndoc);
|
|
add(nriga);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////
|
|
//// TBUONO_PRELIEVO & TBUONO_PRELIEVO_ROW ////
|
|
/////////////////////////////////////////////////////
|
|
|
|
|
|
//classe TBuono_prelievo
|
|
|
|
//CHIAVE: metodo che restituisce una TToken_string (da castare a TDoc_key) che contiene la chiave del documento
|
|
const TToken_string& TBuono_prelievo::chiave() const
|
|
{
|
|
TToken_string& k = get_tmp_string();
|
|
k.add(get(DOC_PROVV));
|
|
k.add(get(DOC_ANNO));
|
|
k.add(get(DOC_CODNUM));
|
|
k.add(get(DOC_NDOC));
|
|
return k;
|
|
}
|
|
|
|
//DATADOC: metodo che restituisce la data del documento
|
|
const TDate TBuono_prelievo::datadoc() const
|
|
{
|
|
return get_date(DOC_DATADOC);
|
|
}
|
|
|
|
//CODCONT: metodo che restituisce il codice contratto
|
|
const long TBuono_prelievo::codcont() const
|
|
{
|
|
return get_long(DOC_CODCONT);
|
|
}
|
|
|
|
//SET_DATAPRCO: metodo che setta la data di prevista consegna
|
|
void TBuono_prelievo::set_dataprco(const TDate& data)
|
|
{
|
|
put("DATAPRCO", data);
|
|
}
|
|
|
|
//SET_ITINERARIO: metodo che setta il codice dell'itinerario
|
|
void TBuono_prelievo::set_itinerario(const int coditi)
|
|
{
|
|
put("CODITI", coditi);
|
|
}
|
|
|
|
//SET_CONRTATTO: metodo che setta il codice contratto
|
|
void TBuono_prelievo::set_contratto(const int codcont)
|
|
{
|
|
put("CODCONT", codcont);
|
|
}
|
|
|
|
//classe TBuono_prelievo_row
|
|
|
|
//EVASO: metodo che indica se la riga in questione ha il flag di evaso a true
|
|
const bool TBuono_prelievo_row::evaso() const
|
|
{
|
|
return _rdoc.get_bool(RDOC_RIGAEVASA);
|
|
}
|
|
|
|
//CODART: metodo che restiuisce il codice articolo di quella riga
|
|
const TString& TBuono_prelievo_row::codart() const
|
|
{
|
|
return _rdoc.get(RDOC_CODART);
|
|
}
|
|
|
|
//DESART: metodo che restituisce la descrizione dell'articolo
|
|
const TString& TBuono_prelievo_row::desart() const
|
|
{
|
|
TString& str = get_tmp_string();
|
|
str = _rdoc.get(RDOC_DESCR);
|
|
|
|
if (_rdoc.get_bool(RDOC_DESCLUNGA))
|
|
str << _rdoc.get(RDOC_DESCEST);
|
|
|
|
return str;
|
|
}
|
|
|
|
//CAUSALE: metodo che restituisce il codice della causale della riga
|
|
const TString& TBuono_prelievo_row::causale() const
|
|
{
|
|
return _rdoc.get(RDOC_CODAGG1);
|
|
}
|
|
|
|
//QTA_RITIRATA: metodo che restituisce la quantità ritirata
|
|
const real TBuono_prelievo_row::qta_ritirata() const
|
|
{
|
|
return _rdoc.get_real(RDOC_QTAGG1);
|
|
}
|
|
|
|
//QTA_DACONS: metodo che restituisce la quantità da consegnare
|
|
const real TBuono_prelievo_row::qta_dacons() const
|
|
{
|
|
return _rdoc.get_real(RDOC_QTA);
|
|
}
|
|
|
|
//QTA_CONSEGNATA: metodo che restituisce la quantità effettivamente consegnata
|
|
const real TBuono_prelievo_row::qta_consegnata() const
|
|
{
|
|
return _rdoc.get_real(RDOC_QTAEVASA);
|
|
}
|
|
|
|
//NUM_PACCHI: metodo che restituisce il numero dei pacchi consegnati
|
|
const int TBuono_prelievo_row::num_pacchi() const
|
|
{
|
|
return _rdoc.get_int(RDOC_NCOLLI);
|
|
}
|
|
|
|
//PREZZO:metodo che restituisce il prezzo dell'articolo selezionato
|
|
const real TBuono_prelievo_row::prezzo() const
|
|
{
|
|
return _rdoc.get_real(RDOC_PREZZO);
|
|
}
|
|
|
|
//CONG_PRE: metodo che restituisce il valore del conguaglio al momento dell'inizio delle operazioni
|
|
const long TBuono_prelievo_row::cong_pre() const
|
|
{
|
|
return _rdoc.get_long("CONGPRE");
|
|
}
|
|
|
|
//CONG_ATT: metodo che restituisce il valore del conguaglio al termine dell'operazione attuale
|
|
const long TBuono_prelievo_row::cong_att() const
|
|
{
|
|
return _rdoc.get_long("CONGATT");
|
|
}
|
|
|
|
//RIFBCON: metodo che restituisce i riferimenti al buono di consegna associato
|
|
const TToken_string& TBuono_prelievo_row::rifbcon() const
|
|
{
|
|
TToken_string& kdoc = get_tmp_string();
|
|
kdoc = _rdoc.get("RIFBCON");
|
|
return kdoc;
|
|
}
|
|
|
|
//RIFBRIT: metodo che restituisce i riferimenti al buono di ritiro associato
|
|
const TToken_string& TBuono_prelievo_row::rifbrit() const
|
|
{
|
|
TToken_string& kdoc = get_tmp_string();
|
|
kdoc = _rdoc.get("RIFBRIT");
|
|
return kdoc;
|
|
}
|
|
|
|
//DATAEVA: metodo che restituisce la data di evasione di queòòa riga
|
|
const TDate& TBuono_prelievo_row::dataeva() const
|
|
{
|
|
TDate& data = _rdoc.get_date("DATAEVA");
|
|
if (!data.ok())
|
|
data = NULLDATE;
|
|
return data;
|
|
}
|
|
|
|
//SET_EVASO: metodo che setta il contenuto del flag evaso
|
|
void TBuono_prelievo_row::set_evaso(const bool evaso)
|
|
{
|
|
_rdoc.put(RDOC_RIGAEVASA, evaso);
|
|
}
|
|
|
|
//SET_CODART: metodo che setta il codice articolo
|
|
void TBuono_prelievo_row::set_codart(const char* codart)
|
|
{
|
|
_rdoc.put(RDOC_CODART, codart);
|
|
}
|
|
|
|
//SET_DESART: metodo che setta la descrizione
|
|
void TBuono_prelievo_row::set_desart(const TString& desart)
|
|
{
|
|
if (desart.len() > 50)
|
|
{
|
|
_rdoc.put(RDOC_DESCR, desart.left(50));
|
|
_rdoc.put(RDOC_DESCLUNGA, true);
|
|
_rdoc.put(RDOC_DESCEST, desart.mid(50));
|
|
}
|
|
else
|
|
_rdoc.put(RDOC_DESCR, desart);
|
|
}
|
|
|
|
//SET_CAUSALE: metodo che setta la causale sulla riga
|
|
void TBuono_prelievo_row::set_causale(const char* causale)
|
|
{
|
|
_rdoc.put(RDOC_CODAGG1, causale);
|
|
}
|
|
|
|
//SET_QTA_RITIRATA: metodo che setta la quantità ritirata sulla riga
|
|
void TBuono_prelievo_row::set_qta_ritirata(const real qta)
|
|
{
|
|
_rdoc.put(RDOC_QTAGG1, qta);
|
|
}
|
|
|
|
//SET_QTA_DACONS: metodo che setta la quyantità da consegnare
|
|
void TBuono_prelievo_row::set_qta_dacons(const real qta)
|
|
{
|
|
_rdoc.put(RDOC_QTA, qta);
|
|
}
|
|
|
|
//SET_QTA_CONSEGNATA: metodo che setta la quantita consegnata
|
|
void TBuono_prelievo_row::set_qta_consegnata(const real qta)
|
|
{
|
|
_rdoc.put(RDOC_QTAEVASA, qta);
|
|
}
|
|
|
|
//SET_NUM_PACCHI: metodo che setta il numero dei pacchi
|
|
void TBuono_prelievo_row::set_num_pacchi(const int numpacchi)
|
|
{
|
|
_rdoc.put(RDOC_NCOLLI, numpacchi);
|
|
}
|
|
|
|
//SET_CODIVA: metodo che setta il codice IVA
|
|
void TBuono_prelievo_row::set_codiva(const char* codiva)
|
|
{
|
|
_rdoc.put(RDOC_CODIVA, codiva);
|
|
}
|
|
|
|
//SET_UM: metodo che setta l'unità di misura
|
|
void TBuono_prelievo_row::set_um(const char* um)
|
|
{
|
|
_rdoc.put(RDOC_UMQTA, um);
|
|
}
|
|
|
|
//SET_PREZZO: metodo che setta il prezzo
|
|
void TBuono_prelievo_row::set_prezzo(const real prezzo)
|
|
{
|
|
_rdoc.put(RDOC_PREZZO, prezzo);
|
|
}
|
|
|
|
|
|
//SET_MAG: metodo che setta il magazzino
|
|
void TBuono_prelievo_row::set_mag(const char* mag)
|
|
{
|
|
_rdoc.put(RDOC_CODMAG, mag);
|
|
}
|
|
|
|
//SET_MAGC: metodo che setta il magazzino collegato
|
|
void TBuono_prelievo_row::set_magc(const char* magc)
|
|
{
|
|
_rdoc.put(RDOC_CODMAG, magc);
|
|
}
|
|
|
|
//SET_CONG_PRE: metodo che setta il valore del conguaglio precedente
|
|
void TBuono_prelievo_row::set_cong_pre(const real qtacong)
|
|
{
|
|
_rdoc.put("CONGPRE", qtacong);
|
|
}
|
|
|
|
//SET_CONG_ATT: metodo che setta il valore del conguaglio attuale
|
|
void TBuono_prelievo_row::set_cong_att(const real qtacong)
|
|
{
|
|
_rdoc.put("CONGATT", qtacong);
|
|
}
|
|
|
|
//SET_RIFBCON: metodo che setta i riferimenti al buono di consegna associato
|
|
void TBuono_prelievo_row::set_rifbcon(const TToken_string& keybcon)
|
|
{
|
|
TString str = keybcon;
|
|
str.replace('|', ' ');
|
|
_rdoc.put("RIFBCON", str);
|
|
}
|
|
|
|
//SET_RIFBRIT: metodo che setta i riferimenti al buono di ritiro associato
|
|
void TBuono_prelievo_row::set_rifbrit(const TToken_string& keybrit)
|
|
{
|
|
TString str = keybrit;
|
|
str.replace('|', ' ');
|
|
_rdoc.put("RIFBRIT", str);
|
|
}
|
|
|
|
//SET_DATAEVA: metodo che setta la data di evasione di quella riga
|
|
void TBuono_prelievo_row::set_dataeva(const TDate& data)
|
|
{
|
|
_rdoc.put("DATAEVA", data);
|
|
}
|
|
|
|
//ADD_QTA_CONSEGNATA: metodo che somma una quantita alla quantità presente in una riga documento
|
|
void TBuono_prelievo_row::add_qta_consegnata(const real qta)
|
|
{
|
|
_rdoc.add(RDOC_QTAEVASA, qta);
|
|
}
|
|
|
|
//ADD_PACCHI: metodo che aggiunge un certo numero di pacchi al numero presente sulla riga
|
|
void TBuono_prelievo_row::add_pacchi(const int nmr)
|
|
{
|
|
_rdoc.add(RDOC_NCOLLI, nmr);
|
|
}
|
|
|
|
|
|
///////////////////////////
|
|
//// TRIGA_PACCO ////
|
|
///////////////////////////
|
|
|
|
//READ: cerca una riga pacco in base alla chiave primaria
|
|
bool TRiga_pacco::read(const TString& codpacco, const long codriga)
|
|
{
|
|
int err = _iskeynotfound;
|
|
if (codpacco.full()) // Campo obbligatorio!
|
|
{
|
|
TLocalisamfile pacchi(LF_PACCHI);
|
|
put(PACCHI_CODPACCO, codpacco);
|
|
put(PACCHI_CODRIGA, codriga);
|
|
|
|
err = TRectype::read(pacchi);
|
|
}
|
|
|
|
if (err != NOERR)
|
|
zero();
|
|
|
|
return err == NOERR;
|
|
}
|
|
|
|
//CODPACCO: metodo che restituisce il codice univoco del pacco
|
|
const TString& TRiga_pacco::codpacco() const
|
|
{
|
|
return get(PACCHI_CODPACCO);
|
|
}
|
|
|
|
//KEY: metodo che restiuisce la chiave univoca del record analizzato (per le lavanderie CODRIGA sempre 1)
|
|
const TToken_string& TRiga_pacco::key() const
|
|
{
|
|
TToken_string& k = get_tmp_string();
|
|
k.add(get(PACCHI_CODPACCO));
|
|
k.add(get(PACCHI_CODRIGA));
|
|
return k;
|
|
}
|
|
|
|
//ARTICOLO: metodo che restituisce il codice articolo specificato in questa riga
|
|
const TString& TRiga_pacco::articolo() const
|
|
{
|
|
return get(PACCHI_CODART);
|
|
}
|
|
|
|
//QUANTITA: metodo che restituisce il numero dei pezzi nella confezione
|
|
const real TRiga_pacco::quantita() const
|
|
{
|
|
return get_real(PACCHI_QTA);
|
|
}
|
|
|
|
//UM: metodo che restituisce l'unità di misura
|
|
const TString& TRiga_pacco::um() const
|
|
{
|
|
return get(PACCHI_UM);
|
|
}
|
|
|
|
//DATA: metodo che restituisce la data in cui il pacco è creato
|
|
const TDate TRiga_pacco::data() const
|
|
{
|
|
return get_date(PACCHI_DATA);
|
|
}
|
|
|
|
//CLIENTE; metodo che restituisce il codice del cliente a cui è stato assegnato il pacco
|
|
const long TRiga_pacco::cliente() const
|
|
{
|
|
return get_long(PACCHI_CODCF);
|
|
}
|
|
|
|
//DATA: metodo che restituisce la data in cui il pacco è stato assegnato a qualcuno
|
|
const TDate TRiga_pacco::databo() const
|
|
{
|
|
return get_date(PACCHI_DATABO);
|
|
}
|
|
|
|
//ANNULLATO: metodo che ritorna true se il pacco è stato annullato
|
|
const bool TRiga_pacco::annullato() const
|
|
{
|
|
if(get(PACCHI_ANNULLATO)[0] == 'S')
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
//RIGABOLLA: metodo che restituisce una TToken_string contenete alla riga del documento che ha consegnato il pacco
|
|
const TToken_string& TRiga_pacco::rigabolla() const
|
|
{
|
|
TToken_string& bolla = get_tmp_string();
|
|
bolla.add(get_char(PACCHI_PROVV));
|
|
bolla.add(get_int(PACCHI_ANNO));
|
|
bolla.add(get(PACCHI_CODNUM));
|
|
bolla.add(get_int(PACCHI_NDOC));
|
|
bolla.add(get_int(PACCHI_IDRIGA));
|
|
|
|
return bolla;
|
|
}
|
|
|
|
//MOVMAG: metodo che restituisce i riferimenti al movimento di magazzino generato dal pacco
|
|
const long TRiga_pacco::movmag() const
|
|
{
|
|
return get_long(PACCHI_MGNUMREG);
|
|
}
|
|
|
|
//SET_KEY: metodo che setta la chiave (da usare su un TRiga_pacco vuota)
|
|
void TRiga_pacco::set_key(const char* codpacco, const int codriga)
|
|
{
|
|
put(PACCHI_CODPACCO, codpacco);
|
|
put(PACCHI_CODRIGA, codriga);
|
|
}
|
|
|
|
//SET_ARTICOLO: metodo che setta il codice articolo sul record corrente
|
|
void TRiga_pacco::set_articolo(const char* codart)
|
|
{
|
|
put(PACCHI_CODART, codart);
|
|
}
|
|
|
|
//SET_QUANTITA: metodo che setta la quantita sul record corrente
|
|
void TRiga_pacco::set_quantita(const real qta)
|
|
{
|
|
put(PACCHI_QTA, qta);
|
|
}
|
|
|
|
//SET_UM: metodo che setta l'unità di misura
|
|
void TRiga_pacco::set_um(const char* um)
|
|
{
|
|
put(PACCHI_UM, um);
|
|
}
|
|
|
|
//SET_DATA: metodo che setta la data di creazione del record corrente
|
|
void TRiga_pacco::set_data(const TDate& data)
|
|
{
|
|
put(PACCHI_DATA, data);
|
|
}
|
|
|
|
//SET_CLIENTE: metodo che setta il codice cliente sul record corrente
|
|
void TRiga_pacco::set_cliente(const long codcf)
|
|
{
|
|
put(PACCHI_CODCF, codcf);
|
|
}
|
|
|
|
//SET_DATA: metodo che setta la data di evasione sul record corrente
|
|
void TRiga_pacco::set_databo(const TDate& data)
|
|
{
|
|
put(PACCHI_DATABO, data);
|
|
}
|
|
|
|
//SET_ANNULLATO: metodo che setta il flag di annullato
|
|
void TRiga_pacco::set_annullato(const bool ann)
|
|
{
|
|
const char annullato = ann ? 'S' : 'N';
|
|
put(PACCHI_ANNULLATO, annullato);
|
|
}
|
|
|
|
//SET_RIGABOLLA: metodo che setta i riferimenti alla riga di bolla che evade il pacco sul record corrente
|
|
void TRiga_pacco::set_rigabolla(const int anno, const char* codnum, const long ndoc, const long idriga)
|
|
{
|
|
put(PACCHI_PROVV, 'D');
|
|
put(PACCHI_ANNO, anno);
|
|
put(PACCHI_CODNUM, codnum);
|
|
put(PACCHI_NDOC, ndoc);
|
|
put(PACCHI_IDRIGA, idriga);
|
|
}
|
|
|
|
//SET_MOVMAG: metodo che setta il movimento di magazzino generato dal pacco
|
|
void TRiga_pacco::set_movmag(const long movmag)
|
|
{
|
|
put(PACCHI_MGNUMREG, movmag);
|
|
}
|
|
|
|
//IS_ANNULATO: metodo che restituisce "true" se il campo annullato sul record attuale è 'S'
|
|
bool TRiga_pacco::is_annullato()
|
|
{
|
|
if(get(PACCHI_ANNULLATO)[0] == 'S')
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
//IS_ASSOCIATO: metodo che restitusce "true" se il campo cliente è valorizzato
|
|
bool TRiga_pacco::is_associato()
|
|
{
|
|
return get_int(PACCHI_CODCF) && 1;
|
|
}
|
|
//Metodi costruttori
|
|
TRiga_pacco::TRiga_pacco(const TRectype& rec)
|
|
: TRectype(rec)
|
|
{
|
|
}
|
|
|
|
TRiga_pacco::TRiga_pacco(const TRiga_pacco& rpacco)
|
|
: TRectype(rpacco)
|
|
{
|
|
}
|
|
|
|
TRiga_pacco::TRiga_pacco(const char* codpacco, const long codriga)
|
|
: TRectype(LF_PACCHI)
|
|
{
|
|
read(codpacco, codriga);
|
|
}
|
|
|
|
TRiga_pacco::TRiga_pacco()
|
|
: TRectype(LF_PACCHI)
|
|
{
|
|
zero();
|
|
}
|
|
|
|
|
|
////////////////////////////////////
|
|
//// CLASSE TGIAC_PER_CLI ////
|
|
////////////////////////////////////
|
|
|
|
//GIACART_OD: metodo che restituisce un puntatore al real che contiene il valore
|
|
//della dotazione odierna per un determinato articolo
|
|
real& TGiac_per_cli::giacart_od(const TString& codart)
|
|
{
|
|
real *giac = (real*)_odierna.objptr(codart);
|
|
if (giac == NULL)
|
|
{
|
|
giac = new real(giac_in_mag(codart, true));
|
|
_odierna.add(codart,giac);
|
|
}
|
|
return *giac;
|
|
};
|
|
|
|
//GIACART_TMP: metodo che restituisce un puntatore al real che contiene il valore
|
|
//della dotazione temporanea per un determinato articolo
|
|
real& TGiac_per_cli::giacart_tmp(const TString& codart)
|
|
{
|
|
real *giac = (real*)_temporanea.objptr(codart);
|
|
if (giac == NULL)
|
|
{
|
|
giac = new real(giac_in_mag(codart, false));
|
|
_temporanea.add(codart,giac);
|
|
}
|
|
return *giac;
|
|
};
|
|
|
|
//GIAC_IN_MAG: questo metodo restituisce le quantità presenti sul file 166 (clifogiac)
|
|
//restituendo il valore salvato in dotazione odierna se odierna == true,
|
|
//oppure il valore salvato in dotazione temporanea se odierna = false
|
|
long TGiac_per_cli::giac_in_mag(const TString& codart, bool odierna) const
|
|
{
|
|
//recupero i valori delle dotazioni odierne e temporanee dal magazzino del cliente
|
|
TLocalisamfile magcli(LF_CLIFOGIAC);
|
|
magcli.put(CLIFOGIAC_ANNOES, _year);
|
|
magcli.put(CLIFOGIAC_TIPOCF, 'C');
|
|
magcli.put(CLIFOGIAC_CODCF, _clifo);
|
|
magcli.put(CLIFOGIAC_INDSPED, _indsped);
|
|
magcli.put(CLIFOGIAC_CODART, codart);
|
|
magcli.put(CLIFOGIAC_NRIGA, 1);
|
|
|
|
//leggo il record corrispondente
|
|
if (magcli.read() == NOERR)
|
|
return magcli.get_long( odierna ? CLIFOGIAC_DOTOD : CLIFOGIAC_DOTTM);
|
|
else
|
|
{
|
|
magcli.put(CLIFOGIAC_ANNOES, _year);
|
|
magcli.put(CLIFOGIAC_TIPOCF, 'C');
|
|
magcli.put(CLIFOGIAC_CODCF, _clifo);
|
|
magcli.put(CLIFOGIAC_INDSPED, 0);
|
|
magcli.put(CLIFOGIAC_CODART, codart);
|
|
magcli.put(CLIFOGIAC_NRIGA, 1);
|
|
|
|
//leggo il record corrispondente
|
|
if (magcli.read() == NOERR)
|
|
return magcli.get_long( odierna ? CLIFOGIAC_DOTOD : CLIFOGIAC_DOTTM);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//PRESET: metodo che carica la coppia cliente - contratto
|
|
bool TGiac_per_cli::preset(const TDocumento& doc)
|
|
{
|
|
//estraggo i dati di interesse dal documento
|
|
_clifo = doc.get_long(DOC_CODCF);
|
|
_cont = doc.get_long(DOC_CODCONT);
|
|
_year = doc.get_date(DOC_DATADOC).year();
|
|
_indsped = doc.get_long(DOC_CODINDSP);
|
|
|
|
return true;
|
|
}
|
|
|
|
//RESET: metodo che distrugge i due TAssoc_array e carica la coppia cliente - contratto
|
|
bool TGiac_per_cli::reset(const TDocumento& doc)
|
|
{
|
|
preset(doc);
|
|
|
|
//distruggo i due TAssoc_array
|
|
_odierna.destroy();
|
|
_temporanea.destroy();
|
|
|
|
return true;
|
|
}
|
|
|
|
//LOAD_ROW: questo metodo popola e aggiorna i TAssoc_array
|
|
bool TGiac_per_cli::load_row(TRiga_documento& rdoc, const bool aggiorna, const bool reading)
|
|
{
|
|
//recupero il documento e la sua maschera a partire dalla riga documento
|
|
const TDocumento& doc = rdoc.doc();
|
|
real vardot;
|
|
real vartmp;
|
|
|
|
//se sul documento leggo o il cliente o il contratto o l'indirizzo di spedizione
|
|
//diversi da quelli che avevo salvato vuol dire che ho cambiato uno dei due,
|
|
//e quindi le giacenze non vanno più bene; in tal caso resetto i TAssoc_array e riparto
|
|
if (doc.get_long(DOC_CODCF) != _clifo || doc.get_long(DOC_CODCONT) != _cont || doc.get_long(DOC_CODINDSP) != _indsped)
|
|
reset(doc);
|
|
|
|
real& dotazione = giacart_od(rdoc.get(RDOC_CODART));
|
|
real& dotmp = giacart_tmp(rdoc.get(RDOC_CODART));
|
|
|
|
//instanzio una cache sulla tabella delle causali
|
|
const TString4 causale = rdoc.get(RDOC_CODAGG1);
|
|
const TCausale_lavanderie cau(causale);
|
|
|
|
//movimento o meno la dotazione temporanea a seconda di cosa prevede la causale
|
|
if (cau.is_ritiro())
|
|
{
|
|
const TCausale_magazzino& rit = cau.causale_ritiro();
|
|
const real ritirato = rdoc.get_real(RDOC_QTAGG1);
|
|
int st = rit.sgn(s_dottm);
|
|
int so = rit.sgn(s_dotod);
|
|
|
|
vartmp += real(st) * ritirato;
|
|
vardot += real(so) * ritirato;
|
|
}
|
|
if (cau.is_consegna())
|
|
{
|
|
const TCausale_magazzino& con = cau.causale_consegna();
|
|
const real consegnato = rdoc.get_real(RDOC_QTA);
|
|
int st = con.sgn(s_dottm);
|
|
int so = con.sgn(s_dotod);
|
|
|
|
vartmp += real(st) * consegnato;
|
|
vardot += real(so) * consegnato;
|
|
}
|
|
|
|
if (rdoc.get_long(RDOC_MOVMAG) != 0L && !reading)
|
|
{
|
|
dotmp -= vartmp;
|
|
dotazione -= vardot;
|
|
}
|
|
|
|
if(aggiorna)
|
|
{
|
|
rdoc.put("DOTOD", dotazione);
|
|
rdoc.put("DOTMP", dotmp);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//GIAC_ATT: questo metodo restituisce il valore della dotazione da scrivere a video in base ai valori
|
|
//di consegnato e ritirato; ATTENZIONE: restituisce la dotazione odierna se odierna = true,
|
|
//restituisce la dotazione temporanea se odierna = false
|
|
real TGiac_per_cli::giac_att(TRiga_documento& rdoc, bool odierna)
|
|
{
|
|
const TString& codart = rdoc.get(RDOC_CODART);
|
|
|
|
real giac = odierna ? giacart_od(codart) : giacart_tmp(codart);
|
|
real saldo;
|
|
|
|
//instanzio una cache sulla tabella delle causali
|
|
TString4 causale = rdoc.get(RDOC_CODAGG1);
|
|
const TCausale_lavanderie cau(causale);
|
|
|
|
//movimento o meno la dotazione temporanea/odierna a seconda di cosa prevede la causale
|
|
if (cau.is_ritiro())
|
|
{
|
|
const TCausale_magazzino& rit = cau.causale_ritiro();
|
|
const int s = rit.sgn(odierna ? s_dotod : s_dottm);
|
|
|
|
saldo += real(s) * rdoc.get_real(RDOC_QTAGG1);
|
|
}
|
|
if (cau.is_consegna())
|
|
{
|
|
const TCausale_magazzino& con = cau.causale_consegna();
|
|
const int s = con.sgn(odierna ? s_dotod : s_dottm);
|
|
|
|
saldo += real(s) * rdoc.get_real(RDOC_QTA);
|
|
}
|
|
giac += saldo;
|
|
|
|
return giac;
|
|
}
|
|
|
|
//costruttore
|
|
TGiac_per_cli::TGiac_per_cli()
|
|
{
|
|
//estraggo i dati di interesse dal documento
|
|
_clifo = 0;
|
|
_cont = 0;
|
|
_year = 0;
|
|
_indsped = 0;
|
|
}
|
|
bool TLV_report::get_usr_val(const TString& name, TVariant& var) const
|
|
{
|
|
if (name == "#NEXTCONS")
|
|
{
|
|
TRecordset& recset = *recordset();
|
|
const long clifo = recset.get("CODCF").as_int();
|
|
const long contr = recset.get("CODCONT").as_int();
|
|
const TDate dtcons = recset.get("DTCONS").as_date();
|
|
if (clifo > 0 && contr > 0 && dtcons.ok())
|
|
{
|
|
// Scrivere qui il calcolo della prossima data di consegna ...
|
|
// ... al momento non sono capace di farlo!
|
|
TDate next_dtcons = dtcons;
|
|
next_dtcons += 7;
|
|
var = next_dtcons;
|
|
return true;
|
|
}
|
|
}
|
|
return TDocument_report::get_usr_val(name, var);
|
|
}
|
|
|
|
TCursor* TLV_recordset::cursor() const
|
|
{
|
|
bool to_create = !valid_cursor();
|
|
TCursor * c = TISAM_recordset::cursor();
|
|
|
|
if (to_create && c != NULL && relation()->log2ind(LF_CLIFOGIAC) >= 0)
|
|
{
|
|
TLocalisamfile & clifogiac = relation()->lfile(LF_CLIFOGIAC);
|
|
|
|
clifogiac.set_curr(new TRecmag_lavanderie);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
bool TLV_report::set_recordset(const TString& sql)
|
|
{
|
|
if (sql.starts_with("US", true))
|
|
{
|
|
TLV_recordset* rex = new TLV_recordset(sql);
|
|
|
|
TReport::set_recordset(rex);
|
|
return rex != NULL;
|
|
}
|
|
return TDocument_report::set_recordset(sql);
|
|
}
|
|
|