root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/mg/mglib02.cpp
alex d0ab8cc457 Patch level : 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            : riportata la versione 98.01.05 patch 34


git-svn-id: svn://10.65.10.50/trunk@7409 c028cbd2-c16b-5b4b-a496-9718f37d4682
1998-11-04 18:04:26 +00:00

1145 lines
30 KiB
C++
Executable File
Raw Blame History

// oggetto TArticolo, multirecord dell'articolo di anagrafica magazzino
// oggetto TArticolo_giacenza, multirecord dell'articolo di magazzino
// oggetto TMov_Mag , multirecord del movimento di magazzino
// funzione di ricostruzione saldi
#include <mask.h>
#include <progind.h>
// #include <utility.h>
#include <tabutil.h>
#include "mglib.h"
#include "anamag.h"
#include "mag.h"
#ifndef __CGLIB01_H
#include "..\cg\cglib01.h"
#include "..\ve\veconf.h"
// libreria per i movimenti
char * Nome_valorizz[]=
{
"Ultimo costo", "Media ultimi costi", "Prezzo di listino",
"Costo standard", "Costo medio acquisto" ,
"Costo medio ponderato" ,
"FIFO annuale", "LIFO annuale",
"FIFO", "LIFO",
"FIFO Ragionieristico", "LIFO Ragionieristico"
} ;
const TString & TArticolo::get_str(const char* fieldname) const
{
if (*fieldname != '#')
return TRectype::get_str(fieldname);
char * fname = (char *) fieldname + 1;
const int logicnum = atoi(fname);
const char * op1 = strchr(fname, '_');
int index = 0;
if (op1)
{
op1=op1+1;
if (*op1 == '#')
index = atoi(fname + 1);
}
const char* op2 = strstr(fname, "->");
CHECKS(op2, "Can't find '->' in string ", fieldname);
op2=op2+2;
switch (logicnum)
{
case LF_UMART:
{
if (index == 0)
index = find_um(op1);
if (index > 0 && op2)
return um().row(index).get(op2);
}
break;
case LF_CODCORR:
{
if (index == 0)
index = find_codcorr(op1);
if (index > 0 && op2)
return codcorr().row(index).get(op2);
}
break;
case LF_DESLIN:
{
if (index == 0)
index = find_deslin(op1);
if (index > 0 && op2)
return deslin().row(index).get(op2);
}
break;
default:
break;
}
return EMPTY_STRING;
}
void TArticolo::set_body_key(TRectype & rowrec)
{
const int logicnum = rowrec.num();
const TString& cod = codice();
switch (logicnum)
{
case LF_UMART:
rowrec.put(UMART_CODART, cod);
break;
case LF_DESLIN:
rowrec.put(DESLIN_CODART, cod);
break;
case LF_CODCORR:
rowrec.put(CODCORR_CODART, cod);
break;
default:
break;
}
}
int TArticolo::read(TRectype & rec, word op, word lockop)
{
const TString80 compstr(rec.get(ANAMAG_CODART));
if (op == _isequal && lockop == _nolock && codice() == compstr)
return NOERR;
put(ANAMAG_CODART, compstr);
const int err = TMultiple_rectype::read(rec, op , lockop);
if (err != NOERR)
zero();
return err;
}
int TArticolo::read(const char * cod, word op, word lockop)
{
TRectype tmp(*this);
tmp.put(ANAMAG_CODART,cod);
return read( tmp, op, lockop);
}
const TString & TArticolo::descrizione(const char* lingua) const
{
if (lingua && *lingua)
{
TString16 f; f.format("#%d_%s->%s", LF_DESLIN, lingua, DESLIN_DESCR);
return get(f);
}
else
return get(ANAMAG_DESCR);
}
void TArticolo::update_ultcosti(real costo,TDate data)
{
TDate data1(get_date(ANAMAG_DULTCOS1));
if (data>= data1)
{
real costo1(get_real(ANAMAG_ULTCOS1));
put(ANAMAG_DULTCOS1,data);
put(ANAMAG_ULTCOS1,costo);
put(ANAMAG_DULTCOS2,data1);
put(ANAMAG_ULTCOS2,costo1);
} else {
if (data>= get_date(ANAMAG_DULTCOS2))
put(ANAMAG_DULTCOS2,data);
put(ANAMAG_ULTCOS2,costo);
}
}
bool TArticolo::unlock()
{
bool rv;
if (codice().not_empty())
{
TLocalisamfile anag(LF_ANAMAG);
anag.curr()=*this;
rv=(anag.read(_isequal,_unlock)==NOERR);
return rv;
}
return FALSE;
}
bool TArticolo::lock_and_prompt()
{
TString mess;
int err;
do {
TLocalisamfile anag(LF_ANAMAG);
anag.curr()=*this;
err=anag.read(_isequal,_testandlock);
switch (err)
{
case NOERR:
return TRUE;
case _islocked:
{
mess.cut(0);
mess << "Il record di anagrafica dell'articolo ''"<< codice() << "'' risulta essere gi<67> in uso.\n Interrompo ?";
break;
}
default:
mess.cut(0);
mess << "Non riesco ad accedere al record di anagrafica dell'articolo ''"<< codice() << "'' \n Interrompo ?";
}
TTimed_breakbox bbox((const char *)mess,10);
if (bbox.run()==K_ESC)
return FALSE;
} while (TRUE);
return FALSE;
}
real TArticolo::convert_to_um(const real& v, const char * to_um, const char * from_um)
{
// Se from_um non specificato significa che la qta che si desidera convertire e' in UM base
int i1, i2 = 0;
i1 = find_um(to_um);
if (from_um != NULL)
i2 = find_um(from_um);
TRecord_array& u = um();
real fc1 = i1 ? ((TRectype&)u[i1]).get_real("FC") : 1.00; // Fattore di conversione
real fc2 = i2 ? ((TRectype&)u[i2]).get_real("FC") : 1.00;
real r = (v * fc2) / fc1;
// TBI: ricerca sulla tabella UMS nel caso di um non presenti in LF_UMART
return r;
}
TArticolo::TArticolo(const char* codice)
: TMultiple_rectype(LF_ANAMAG)
{
add_file(LF_UMART,"NRIGA");
add_file(LF_CODCORR,"NRIGA");
add_file(LF_DESLIN,"NRIGA");
if (codice && *codice)
read(codice);
}
TArticolo::TArticolo(const TRectype& rec)
: TMultiple_rectype(rec)
{
add_file(LF_UMART,"NRIGA");
add_file(LF_CODCORR,"NRIGA");
add_file(LF_DESLIN,"NRIGA");
read(rec.get(ANAMAG_CODART));
}
TArticolo::~TArticolo()
{
}
// *****************
//
const TString & TArticolo_giacenza::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_MAG && logicnum !=LF_STOMAG)
return TArticolo::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;
const char * op4 = strstr(fname, "->");
CHECKS(op4, "Can't find '->' in string ", fieldname);
op4=op4+2;
switch (logicnum)
{
case LF_MAG:
if (index == 0)
index = find_mag(op1, op2, op3);
if (index > 0 && op3)
return mag(op1).row(index).get(op4);
break;
case LF_STOMAG:
if (index = 0)
index = find_storico(op1, op2);
if (index > 0)
return storico(op1).row(index).get(op4);
break;
}
return EMPTY_STRING;
}
void TArticolo_giacenza::set_body_key(TRectype & rowrec)
{
const int logicnum = rowrec.num();
const char * cod = (const char *) codice();
switch (logicnum)
{
case LF_STOMAG:
rowrec.put(STOMAG_CODART, cod);
rowrec.put(STOMAG_ANNOESRIF, _anno_sto);
break;
case LF_MAG:
rowrec.put(MAG_ANNOES, _anno_mag);
rowrec.put(MAG_CODART, cod);
break;
default:
TArticolo::set_body_key(rowrec);
break;
}
}
void TArticolo_giacenza::set_anno_mag (const char * anno)
{
if (_anno_mag != anno)
remove_body(LF_MAG);
_anno_mag = anno;
}
void TArticolo_giacenza::set_anno_sto (const char * anno)
{
if (_anno_sto != anno)
remove_body(LF_STOMAG);
_anno_sto = anno;
}
void TArticolo_giacenza::zero(char c)
{
reset_anno_sto();
reset_anno_mag();
TArticolo::zero(c);
}
int TArticolo_giacenza::find_mag(const char * annoes, const char * codmag, const char * livello, int from) const
{
TRecord_array & rmag = mag(annoes);
const int last = rmag.last_row();
if (last > 0 && from < last)
{
const int codmag_len = codmag ? strlen(codmag) : 0;
const int livello_len = livello ? strlen(livello) : 0;
if (codmag_len == 0 && livello_len == 0)
return from + 1;
for (int i = rmag.succ_row(from); i <= last; i = rmag.succ_row(i))
{
const TRectype & rec = rmag.row(i);
if (codmag_len == 0 || rec.get(MAG_CODMAG).compare(codmag, codmag_len) == 0)
if (livello_len == 0 || rec.get(MAG_LIVELLO).compare(livello, livello_len) == 0)
return i;
}
}
return -1;
}
int TArticolo_giacenza::find_storico(const char * annoesrif, const char * annoes, const char * codmag, int from) const
{
TRecord_array & rsto = storico(annoesrif);
const int last = rsto.last_row();
if (last > 0 && from <= last)
{
const int codmag_len = codmag ? strlen(codmag) : 0;
if (codmag_len == 0)
return from + 1;
for (int i = rsto.succ_row(from); i <= last; i = rsto.succ_row(i))
{
const TRectype & rec = rsto.row(i);
if (rec.get(STOMAG_CODMAG).compare(codmag, codmag_len) == 0)
return i;
}
}
return -1;
}
TRecord_array & TArticolo_giacenza::mag(const char * annoes) const
{
TString16 anno = annoes;
if (anno.blank())
{
TEsercizi_contabili ese;
anno.format("%04d", ese.last());
}
((TArticolo_giacenza*)this)->set_anno_mag(anno);
return body(LF_MAG);
}
TRecord_array & TArticolo_giacenza::storico(const char * annoesrif) const
{
TString16 anno = annoesrif;
if (anno.blank())
{
TEsercizi_contabili ese;
anno.format("%04d", ese.last());
}
((TArticolo_giacenza *) this)->set_anno_sto(anno);
return body(LF_STOMAG);
}
bool TArticolo_giacenza::is_last_esercizio(const char* annoes) const
{
bool yes = TRUE;
if (annoes && *annoes)
{
const int anno = atoi(annoes);
if (anno > 0)
{
TEsercizi_contabili e;
yes = anno == e.last();
}
}
return yes;
}
bool TArticolo_giacenza::azzera_saldi(const char * cod_es)
{
TRecord_array& rec_arr = TArticolo_giacenza::mag(cod_es);
const int last = rec_arr.last_row();
for (int r = last;r > 0 ; r = rec_arr.pred_row(r)) // Scorre le righe
{
TRectype& mag = rec_arr[r];
mag.put(MAG_GIAC,0);
mag.put(MAG_RIM,0);mag.put(MAG_VALRIM,0);
mag.put(MAG_ACQ,0);mag.put(MAG_VALACQ,0);
mag.put(MAG_ENT,0);mag.put(MAG_VALENT,0);
mag.put(MAG_VEN,0);mag.put(MAG_VALVEN,0);
mag.put(MAG_USC,0);mag.put(MAG_VALUSC,0);
mag.put(MAG_ORDF,0);mag.put(MAG_VALORDF,0);
mag.put(MAG_ORDC,0);mag.put(MAG_VALORDC,0);
mag.put(MAG_SCARTI,0);mag.put(MAG_VALSCARTI,0);
mag.put(MAG_PRODCOMP,0);
mag.put(MAG_PRODFIN,0);
mag.put(MAG_INCL,0);
mag.put(MAG_ACL,0);
mag.put(MAG_NLABEL,0);
}
return rec_arr.write(TRUE) == NOERR;
}
bool TArticolo_giacenza::riporta_saldi(const char * oldes, const char* newes, const TTipo_valorizz tipo, const char* catven, const char* codlis)
{
TString codes(newes), mag, liv;
TRecord_array& rec_arr = TArticolo_giacenza::mag(oldes);
const int last = rec_arr.last_row();
real rim, val, giac, inpf, proc, icl, acl;
rec_arr.renum_key(MAG_ANNOES, codes); // Rinumera
for (int r = last;r > 0 ; r = rec_arr.pred_row(r)) // Scorre le righe
{
TRectype& rec = rec_arr[r];
mag = rec.get(MAG_CODMAG); mag.cut(3);
liv = rec.get(MAG_LIVELLO);
giac = rec.get_real(MAG_GIAC);
inpf = rec.get_real(MAG_PRODFIN);
proc = rec.get_real(MAG_PRODCOMP);
acl = rec.get_real(MAG_ACL);
icl = rec.get_real(MAG_INCL);
rim = giac + inpf - proc + acl - icl;
switch (tipo)
{
case valorizz_costmedio:
val = costo_medio(oldes, mag, liv);
break;
case valorizz_costmediopond:
val = costo_mediopond(oldes, mag, liv);
break;
case valorizz_ultcos:
val = ultimo_costo(oldes);
break;
case valorizz_mediacos:
val = media_costi(oldes);
break;
case valorizz_przlist:
val = prezzo_listino(oldes, catven, codlis);
break;
case valorizz_coststd:
val = costo_standard(oldes);
break;
case valorizz_FIFOa:
val = FIFO_annuale(oldes, mag, liv);
break;
case valorizz_LIFOa:
val = LIFO_annuale(oldes, mag, liv);
break;
case valorizz_FIFO:
val = FIFO(oldes, mag, liv);
break;
case valorizz_LIFO:
val = LIFO(oldes, mag, liv);
break;
case valorizz_FIFOr:
val = FIFO_ragionieristico(oldes, mag, liv);
break;
case valorizz_LIFOr:
val = LIFO_ragionieristico(oldes, mag, liv);
break;
default:
break;
}
rec.put(MAG_RIM, rim); rec.put(MAG_VALRIM, val);
rec.zero(MAG_ACQ); rec.zero(MAG_VALACQ);
rec.zero(MAG_ENT); rec.zero(MAG_VALENT);
rec.zero(MAG_VEN); rec.zero(MAG_VALVEN);
rec.zero(MAG_USC); rec.zero(MAG_VALUSC);
rec.zero(MAG_SCARTI);
}
// Scrive il pastrocchio (eventualmente sovrascrive)
return rec_arr.write(TRUE) == NOERR;
}
real TArticolo_giacenza::disponibilita(const char * annoes, const char * codmag, const char * livello, bool solo_giac) const
{
real giac;
TRecord_array & rmag = mag(annoes);
for (int i = find_mag(annoes, codmag, livello); i > 0;
i = find_mag(annoes, codmag, livello, i))
{
const TRectype & rec = rmag.row(i);
giac += rec.get_real(MAG_GIAC);
if (!solo_giac)
{
giac += rec.get_real(MAG_ORDF) - rec.get_real(MAG_ORDC);
giac += rec.get_real(MAG_PRODFIN) - rec.get_real(MAG_PRODCOMP);
}
}
return giac;
}
real TArticolo_giacenza::ultimo_costo(const char * annoes) const
{
if (is_last_esercizio(annoes))
{
const real costo = get_real(ANAMAG_ULTCOS1);
return costo == ZERO ? costo_standard(annoes) : costo;
}
else
{
const int index = find_storico(annoes, annoes);
if (index < 0 ) return ZERO;
const real costo = storico(annoes).row(index).get_real(STOMAG_ULTCOS1);
return costo == ZERO ? costo_standard(annoes) : costo;
}
}
real TArticolo_giacenza::media_costi(const char * annoes) const
{
if (is_last_esercizio(annoes))
{
real costo = get_real(ANAMAG_ULTCOS1);
costo = (costo + get_real(ANAMAG_ULTCOS2)) / 2.0;
return costo == ZERO ? costo_standard(annoes) : costo;
}
else
{
const int index = find_storico(annoes, annoes);
if (index < 0 ) return ZERO;
const TRectype & rec = storico(annoes).row(index);
real costo = rec.get_real(STOMAG_ULTCOS1);
costo = (costo + rec.get_real(STOMAG_ULTCOS2)) / 2.0;
return costo == ZERO ? costo_standard(annoes) : costo;
}
}
real TArticolo_giacenza::prezzo_listino(const char * annoes, const char * catven, const char * codlist) const
{
if (is_last_esercizio(annoes))
{
TConfig cfg(CONFIG_DITTA);
TCondizione_vendita cv(&cfg);
cv.put_listino(codlist,catven);
if (cv.ricerca(codice()))
return cv.get_prezzo();
else
{
// se non lo trova, cerca nel prezzo indicato nelle UM
TString16 f;
f.format("#%d->%s", LF_UMART, UMART_PREZZO);
return get_real(f);
}
}
else
{
const int index = find_storico(annoes, annoes);
if (index < 0 ) return ZERO;
return storico(annoes).row(index).get_real(STOMAG_PRZLIST);
}
}
real TArticolo_giacenza::costo_standard(const char * annoes) const
{
if (is_last_esercizio(annoes))
return get_real(ANAMAG_COSTSTD);
else
{
const int index = find_storico(annoes, annoes);
if (index < 0 ) return ZERO;
return storico(annoes).row(index).get_real(STOMAG_COSTSTD);
}
}
real TArticolo_giacenza::costo_medio(const char * annoes, const char * codmag, const char * livello) const
{
real acq;
real valacq;
CHECK(strlen(codmag)<=3, "Non <20> pi<70> possibile avere valorizzazione a livello di deposito");
TRecord_array & rmag = mag(annoes);
for (int i = find_mag(annoes, codmag, livello); i > 0;
i = find_mag(annoes, codmag, livello, i))
{
const TRectype & rec = rmag.row(i);
acq += rec.get_real(MAG_ACQ);
valacq += rec.get_real(MAG_VALACQ);
}
return acq == ZERO ? costo_standard(annoes) : valacq / acq;
}
// costo medio ponderato per periodi pari alla durata dell'esercizio
real TArticolo_giacenza::costo_mediopond(const char * annoes, const char * codmag, const char * livello) const
{
real acq;
real valacq;
CHECK(strlen(codmag)<=3, "Non <20> pi<70> possibile avere valorizzazione a livello di deposito");
TRecord_array & rmag = mag(annoes);
for (int i = find_mag(annoes, codmag, livello); i > 0; i = find_mag(annoes, codmag, livello, i))
{
const TRectype & rec = rmag.row(i);
acq += rec.get_real(MAG_ACQ) ;
acq += rec.get_real(MAG_RIM) ;
valacq += rec.get_real(MAG_VALACQ);
valacq += rec.get_real(MAG_VALRIM);
}
return acq == ZERO ? costo_standard(annoes) : valacq / acq;
}
real TArticolo_giacenza::LIFO_annuale(const char * annoes, const char * codmag, const char * livello,
bool giac_eff, bool valorizza_componenti) const
{
CHECK(strlen(codmag)<=3, "Non <20> pi<70> possibile avere valorizzazione a livello di deposito");
real rim;
real valrim;
real acq;
real valacq;
real giacenza;
TRecord_array & rmag = mag(annoes);
for (int i = find_mag(annoes, codmag, livello); i > 0; i = find_mag(annoes, codmag, livello, i))
{
const TRectype & rec = rmag.row(i);
rim += rec.get_real(MAG_RIM);
valrim += rec.get_real(MAG_VALRIM);
acq += rec.get_real(MAG_ACQ);
valacq += rec.get_real(MAG_VALACQ);
giacenza += giacenza_corretta(rec,giac_eff,valorizza_componenti);
}
if (giacenza <= ZERO)
return ZERO;
if (giacenza > rim)
return ((giacenza - rim) * (acq == ZERO ? costo_standard(annoes) : valacq / acq) + valrim) / giacenza;
return valrim / rim;
}
real TArticolo_giacenza::FIFO_annuale(const char * annoes, const char * codmag, const char * livello,
bool giac_eff, bool valorizza_componenti) const
{
CHECK(strlen(codmag)<=3, "Non <20> pi<70> possibile avere valorizzazione a livello di deposito");
real rim;
real valrim;
real acq;
real valacq;
real giacenza;
TRecord_array & rmag = mag(annoes);
for (int i = find_mag(annoes, codmag, livello); i > 0; i = find_mag(annoes, codmag, livello, i))
{
const TRectype & rec = rmag.row(i);
rim += rec.get_real(MAG_RIM);
valrim += rec.get_real(MAG_VALRIM);
acq += rec.get_real(MAG_ACQ);
valacq += rec.get_real(MAG_VALACQ);
giacenza += giacenza_corretta(rec,giac_eff,valorizza_componenti);
}
if (giacenza <= ZERO)
return ZERO;
if (giacenza > acq)
return ((giacenza - acq) * (valrim / rim) + valacq) / giacenza;
return valacq / acq;
}
real TArticolo_giacenza::LIFO(const char * annoes, const char * codmag, const char * livello,
bool giac_eff, bool valorizza_componenti) const
{
CHECK(strlen(codmag)<=3, "Non <20> pi<70> possibile avere valorizzazione a livello di deposito");
real rim;
real valrim;
real acq;
real valacq;
real giacenza;
TRecord_array & rmag = mag(annoes);
for (int i = find_mag(annoes, codmag, livello); i > 0; i = find_mag(annoes, codmag, livello, i))
{
const TRectype & rec = rmag.row(i);
rim += rec.get_real(MAG_RIM);
valrim += rec.get_real(MAG_VALRIM);
acq += rec.get_real(MAG_ACQ);
valacq += rec.get_real(MAG_VALACQ);
giacenza += giacenza_corretta(rec,giac_eff,valorizza_componenti);
}
if (giacenza <= ZERO)
return ZERO;
if (giacenza > rim)
return ((giacenza - rim) * (acq == ZERO ? costo_standard(annoes) : valacq / acq) + valrim) / giacenza;
TRecord_array & rstorico = storico(annoes);
// const int last = rstorico.last_row();
rim = giacenza;
for (i = find_storico(annoes, "", codmag); i > 0; i = find_storico(annoes, "", codmag, i))
{
const TRectype & rec = rstorico.row(i);
const real qta = rec.get(STOMAG_QUANT);
if (qta > giacenza)
{
valrim += (rec.get_real(STOMAG_VALORE) / qta) * giacenza;
break;
}
else
{
valrim += rec.get_real(STOMAG_VALORE);
giacenza -= qta;
}
}
return valrim / rim;
}
real TArticolo_giacenza::FIFO(const char * annoes, const char * codmag, const char * livello,
bool giac_eff, bool valorizza_componenti) const
{
CHECK(strlen(codmag)<=3, "Non <20> pi<70> possibile avere valorizzazione a livello di deposito");
real rim;
real valrim;
real acq;
real valacq;
real giacenza;
TRecord_array & rmag = mag(annoes);
for (int i = find_mag(annoes, codmag, livello); i > 0; i = find_mag(annoes, codmag, livello, i))
{
const TRectype & rec = rmag.row(i);
rim += rec.get_real(MAG_RIM);
valrim += rec.get_real(MAG_VALRIM);
acq += rec.get_real(MAG_ACQ);
valacq += rec.get_real(MAG_VALACQ);
giacenza += giacenza_corretta(rec,giac_eff,valorizza_componenti);
}
if (giacenza <= ZERO)
return ZERO;
if (giacenza <= acq)
return valacq / acq;
TRecord_array & rstorico = storico(annoes);
const int last = rstorico.last_row();
real res = giacenza - acq;
rim = ZERO;
valrim = ZERO;
TFixed_string cmag(codmag);
int codmag_len = codmag ? strlen(cmag) : 0;
for (i = last; i > 0; i--)
{
const TRectype & rec = rstorico.row(i);
if (codmag_len == 0 || rec.get(STOMAG_CODMAG).compare(codmag, codmag_len) == 0)
{
const real qta = rec.get(STOMAG_QUANT);
if (qta > res)
{
rim += res;
valrim += (rec.get_real(STOMAG_VALORE) / qta) * res;
}
else
{
rim += qta;
valrim += rec.get_real(STOMAG_VALORE);
res -= qta;
}
}
}
return ((giacenza - acq) * (valrim / rim) + valacq) / giacenza;
}
real TArticolo_giacenza::FIFO_ragionieristico(const char * annoes, const char * codmag, const char * livello,
bool giac_eff, bool valorizza_componenti) const
{
CHECK(strlen(codmag)<=3, "Non <20> pi<70> possibile avere valorizzazione a livello di deposito");
return ZERO; // da implementare
}
real TArticolo_giacenza::LIFO_ragionieristico(const char * annoes, const char * codmag, const char * livello,
bool giac_eff, bool valorizza_componenti) const
{
CHECK(strlen(codmag)<=3, "Non <20> pi<70> possibile avere valorizzazione a livello di deposito");
return ZERO; // da implementare
}
void TArticolo_giacenza::put_ultimo_costo(const real& costo, const TDate& data)
{
TDate d = get(ANAMAG_DULTCOS1);
if (data >= d)
{
if (data > d)
{
put(ANAMAG_ULTCOS2, get(ANAMAG_ULTCOS1));
put(ANAMAG_DULTCOS2, get(ANAMAG_DULTCOS1));
}
put(ANAMAG_DULTCOS1, data);
put(ANAMAG_ULTCOS1, costo);
}
else
{
d = get(ANAMAG_DULTCOS2);
if (data >= d)
{
put(ANAMAG_ULTCOS2, costo);
put(ANAMAG_DULTCOS2, data);
}
}
}
void TArticolo_giacenza::put_costo_standard(const real& costo)
{
put(ANAMAG_COSTSTD, costo);
}
// calcola la giacenza corretta dai campi Conto Lavoro e Produzione
real TArticolo_giacenza::giacenza_corretta(const TRectype & rec ,bool giac_eff,bool valorizza_componenti) const
{
CHECK(rec.num() == LF_MAG, "Il record passato deve essere di LF_MAG");
real giacenza(rec.get_real(MAG_GIAC));
if (giac_eff)
{
giacenza += rec.get_real(MAG_INCL);
giacenza -= rec.get_real(MAG_ACL);
giacenza += valorizza_componenti ? 0 : (rec.get_real(MAG_PRODFIN)-rec.get_real(MAG_PRODCOMP));
}
return giacenza;
}
real TArticolo_giacenza::giacenza_anno(const char* codmag,
const char* livello,
int anno) const
{
TString16 annoes;
if (anno > 0)
annoes.format("%04d", anno);
const TRecord_array& rmag = mag(annoes);
real giac;
for (int i = find_mag(annoes, codmag, livello); i > 0;
i = find_mag(annoes, codmag, livello, i))
{
const TRectype& rec = rmag.row(i);
giac += rec.get_real("GIAC");
}
return giac;
}
TArticolo_giacenza::TArticolo_giacenza(const char* codice)
: TArticolo(codice)
{
add_file(LF_MAG,"NRIGA");
add_file(LF_STOMAG,"NRIGA");
}
TArticolo_giacenza::TArticolo_giacenza(const TRectype& rec)
: TArticolo(rec)
{
add_file(LF_MAG,"NRIGA");
add_file(LF_STOMAG,"NRIGA");
}
// causali
int TCausale_magazzino::sgn(TTipo_saldomag tiposaldo)
{
static TString *segni=NULL; if (segni==NULL) segni=new TString80;
*segni=get("S2");
switch (tiposaldo)
{
case s_giac:
return atoi(segni->mid(0,2));
case s_acq:
return atoi(segni->mid(2,2));
case s_ent:
return atoi(segni->mid(4,2));
case s_ven:
return atoi(segni->mid(6,2));
case s_usc:
return atoi(segni->mid(8,2));
case s_ordc:
return atoi(segni->mid(10,2));
case s_ordf:
return atoi(segni->mid(12,2));
case s_incl:
return atoi(segni->mid(14,2));
case s_acl:
return atoi(segni->mid(16,2));
case s_prodc:
return atoi(segni->mid(18,2));
case s_prodf:
return atoi(segni->mid(20,2));
case s_rim:
return atoi(segni->mid(22,2));
case s_scart:
return atoi(segni->mid(24,2));
case s_label:
return atoi(segni->mid(26,2));
case s_user1:
return atoi(segni->mid(28,2));
case s_user2:
return atoi(segni->mid(30,2));
case s_user3:
return atoi(segni->mid(32,2));
case s_user4:
return atoi(segni->mid(34,2));
case s_user5:
return atoi(segni->mid(36,2));
case s_user6:
return atoi(segni->mid(38,2));
default:
return 0;
}
}
bool TCausale_magazzino::is_fiscale()
{
return (tipomov()=='S' || tipomov()=='C' );
}
TCausale_magazzino::TCausale_magazzino(const char * codice):
TRectype(LF_TABCOM)
{
TTable f("%CAU");
settab("CAU");
put("CODTAB", codice);
if (TRectype::read(f) != NOERR)
zero();
}
const real CENTO=real(100.0);
bool TCondizione_vendita:: ricerca(const char * codice, const real & qta)
{
int tiporic;
switch (_condv.get_char("TIPO")) {
case 'L':
tiporic=A_LISTINI;
break;
case 'C':
tiporic=A_CONTRATTI;
break;
case 'O':
tiporic=A_OFFERTE;
break;
}
return cerca(tiporic,codice, qta);
}
bool TCondizione_vendita::cerca( int tiporicerca, const char * codriga , const real & qta)
{
if( config_ditta().get_bool( "GES", "ve", tiporicerca ) )
{
_condv.setkey( 1 );
if (_condv.get("COD").empty())
return FALSE;
switch( tiporicerca )
{
case A_CONTRATTI:
{
}
break;
case A_LISTINI:
{
_condv.put("TIPOCF", "");
_condv.put("CODCF", "");
if( !config_ditta().get_bool("GESLISCV", "ve"))
_condv.put("CATVEN", "");
}
break;
case A_OFFERTE:
{
}
break;
}
if( _condv.read( ) == NOERR )
{
// si posiziona sulla riga
const bool gest_scagl = _condv.get_bool("GESTSCAGL");
const TString16 seqricrighe( _condv.get( "SEQRIC" ) );
bool found = FALSE;
for( int i = 0; !found && i < seqricrighe.len( ); i ++ )
{
_rcondv.zero( );
_rcondv.put( "TIPO", _condv.get( "TIPO"));
_rcondv.put( "CATVEN", _condv.get( "CATVEN"));
_rcondv.put( "TIPOCF", _condv.get( "TIPOCF"));
_rcondv.put( "CODCF", _condv.get( "CODCF"));
_rcondv.put("COD", _condv.get("COD"));
if (gest_scagl)
_rcondv.put("NSCAGL", 1);
char ricerca = seqricrighe[ i ];
_rcondv.put( "TIPORIGA", ricerca );
switch( ricerca )
{
case 'A':
{
_rcondv.put( "CODRIGA", codriga);
if (_rcondv.read() != NOERR &&
_rcondv.prev() == NOERR &&
_rcondv.get("TIPORIGA")[0] == 'A')
{
const TString cod_found(_rcondv.get("CODRIGA"));
return cod_found.compare(codriga, cod_found.len()) == 0;
}
}
break;
case 'R':
_rcondv.put("CODRIGA", anamag().get( "RAGGFIS"));
_rcondv.read();
break;
case 'S':
{
_rcondv.put( "CODRIGA", anamag().get("GRMERC"));
_rcondv.read( );
}
break;
case 'G':
{
_rcondv.put( "CODRIGA", anamag().get("GRMERC").left(3));
_rcondv.read( );
}
break;
default:
break;
}
found = _rcondv.good();
}
// individua lo scaglione corretto in base alla quantita'
if (found && gest_scagl)
{
TRectype rec(_rcondv.curr());
int last_scagl = 0;
int scagl = _rcondv.get_int("NSCAGL");
real qta_lim(_rcondv.get_real("QLIM"));
while (_rcondv.good() && scagl > last_scagl && qta_lim > ZERO && qta > qta_lim)
{
if (_rcondv.next() == NOERR)
{
last_scagl = scagl;
scagl = _rcondv.get_int("NSCAGL");
qta_lim =_rcondv.get_real("QLIM");
rec = _rcondv.curr();
}
}
_rcondv.read(rec);
}
_prezzo = _rcondv.get_real("PREZZO");
return found;
}
}
// Ricerca fallita
return FALSE;
}
void TCondizione_vendita::put_condv(const char *tipocv,const char *codicecv,const char *catven,const char *tipocf,const char *codcf)
{
_condv.put("TIPO",tipocv);
_condv.put("CATVEN",catven);
_condv.put("TIPOCF",tipocf);
_condv.put("CODCF",codcf);
_condv.put("COD",codicecv);
}
void TCondizione_vendita::put_listino(const char * codlist,const char *catven)
{
if( !config_ditta().get_bool("GESLISCV", "ve"))
put_condv("L",codlist,"","","");
else
put_condv("L",codlist,catven,"","");
}
void TCondizione_vendita::put_contratto(const char * codcontr,const char *tipocf,const char *codcf)
{
put_condv("C",codcontr,"",tipocf,codcf);
}
void TCondizione_vendita::put_offerta(const char * codoff)
{
put_condv("C",codoff,"","","");
}
TCondizione_vendita::TCondizione_vendita(TConfig * ditta,
TLocalisamfile * anamag, TLocalisamfile * umart)
: _condv(LF_CONDV), _rcondv(LF_RCONDV),
_sconti( LF_SCONTI ),
_anamag(anamag), _umart(umart), _config_ditta(ditta), _ivarid(FALSE)
{
}
Reference in New Issue View Git Blame Copy Permalink