// 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 #include // #include #include #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à 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 è più 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 è più 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 è più 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 è più 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 è più 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 è più 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 è più 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 è più 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) { }