root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/lv/lv2500.cpp
alex f3fed7093b Patch level : 10.0 748 
Files correlati     : lv2.exe
Ricompilazione Demo : [ ]
Commento

Implementata la copia opzionale dei dati per 02

Corretto il calcolo 02. Ora considera anche le quantita a 1


git-svn-id: svn://10.65.10.50/trunk@20495 c028cbd2-c16b-5b4b-a496-9718f37d4682
2010-05-25 21:48:34 +00:00

2152 lines
74 KiB
C++
Executable File
Raw Blame History

#include <progind.h>
#include <config.h>
#include <dongle.h>
#include <modaut.h>
#include <utility.h>
#include "lvlib.h"
#include "lv2500a.h"
#include "../pr/agenti.h"
#include "../pr/percprov.h"
#include "clifo.h"
#include "cfven.h"
#include "lvcondv.h"
#include "lvrcondv.h"
#include "doc.h"
#include "rdoc.h"
#include "../db/dblib.h"
#include "../mg/mglib.h"
#include "../ve/ve6200.h"
#include "../ve/ve6200a.h"
class TFatturazione_lavanderie;
////////////////////////////////////////
//// classe TFatturazione_msk ////
////////////////////////////////////////
class TFatturazione_msk: public TAutomask
{
protected:
virtual bool on_field_event(TOperable_field& o,TField_event e,long jolly){return true;}
public:
TFatturazione_msk();
};
////////////////////////////////////////
//// TFatturazione_lavanderie app ////
////////////////////////////////////////
//Classe TFatturazione_lavanderie_app
class TFatturazione_lav_app: public TSkeleton_application
{
TFatturazione_msk* _msk;
protected:
virtual void main_loop();
void genera_bolle_nolo(TAssoc_array& cliela, TFatturazione_lavanderie& elab, int& numdocgen);
bool controlli_preliminari();
bool copy_file(const TFilename& src, const TFilename& dst) const;
bool copy_tree(const char* src_study, const char* dst_study) const;
};
TFatturazione_lav_app & app() { return (TFatturazione_lav_app &) main_app();}
////////////////////////////////////////
//// TCalc_02_data ////
////////////////////////////////////////
//Classe TCalc_02_data
class TCalc_02_data : public TObject
{
TString _key;
TGeneric_distrib _distr;
TGeneric_distrib _distr_rit;
TAssoc_array _bol_rows;
virtual TObject* dup() const;
void copy(const TCalc_02_data & d);
public:
TCalc_02_data & operator = (const TCalc_02_data & d) { copy(d); return *this; }
const TString & key() const { return _key; }
TGeneric_distrib & distr() { return _distr; }
TGeneric_distrib & distr_rit() { return _distr_rit; }
TAssoc_array & bol_rows() { return _bol_rows; }
TCalc_02_data(const char * key) : _key(key) {}
TCalc_02_data(const TCalc_02_data & d) {copy(d);}
};
void TCalc_02_data::copy(const TCalc_02_data & d)
{
_key = d._key;
_distr = d._distr;
_bol_rows = d._bol_rows;
}
TObject* TCalc_02_data::dup() const
{
TCalc_02_data* o = new TCalc_02_data(*this);
return o;
}
////////////////////////////////////////
//// TFatturazione_lavanderie ////
////////////////////////////////////////
//Classe TFatturazione_lavanderie
class TFatturazione_lavanderie:public TFatturazione_bolle
{
TDate _data_elab;
TToken_string _campi_raggruppamento;
TAssoc_array _output_rows_02;
TAssoc_array _doc_grouped;
bool _prova;
protected:
virtual void add_rows(TRiga_documento & rout, TRiga_documento & rin);
virtual void create_row(TDocumento& doc_out, const TRiga_documento & rin);
virtual void pre_process_input(TLista_documenti& doc_in);
virtual void post_process_input(TLista_documenti& doc_in) {}
virtual void post_process(TLista_documenti& doc_out, TLista_documenti& doc_in);
virtual bool da_raggruppare(const TRiga_documento & rin);
virtual bool doc_raggruppabili(const TDocumento& doc_in, const TDocumento& doc_out, TToken_string& campi) const ;
virtual bool doc_raggruppabile(const TDocumento & doc) const { return true; }
virtual void campi_raggruppamento_righe(TToken_string& campi_riga) const;
virtual bool gestione_riferimenti() const { return true; }
virtual bool riferimenti_in_testa() const { return true; }
virtual TRiga_documento& find_or_create_row(TDocumento& doc_out, const TRiga_documento & rin,const char lavtype);
void aggiorna_fattura(TDocumento & doc, int codcont);
bool fatt_02() const { return !_prova &&lv_is_02_active(); }
void add_doc_to_list(const TString & key, const TDocumento & doc);
real get_percprovv(const TRiga_documento & row, char tipoprovv, const TString & codpr, bool first, const TRectype & age) const;
public:
int write_fatt_ragg();
void set_perc_provv(TRiga_documento & row, bool prima = true);
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
const TDate& data_elab, bool interattivo = false);
TFatturazione_lavanderie(const char* cod, bool prova = false);
~TFatturazione_lavanderie() {}
};
TFatturazione_lavanderie::TFatturazione_lavanderie(const char* cod, bool prova)
: TFatturazione_bolle(cod), _prova(prova)
{
}
//DOC_RAGGRUPPABILI: metodo che restituisce true se i documenti sono raggruppabili sulla base dei campi
//contenuti nella stringa campi
bool TFatturazione_lavanderie::doc_raggruppabili(const TDocumento& doc_in, const TDocumento& doc_out, TToken_string& campi) const
{
if (doc_in.ha_riga_esenzione() != doc_out.ha_riga_esenzione())
return false;
bool ok = true;
TString campo;
//scorro tutti i campi contenuti nella TToken_string
//se sto controllando i campi CODABI e CODCAB, allora il controllo
//deve essere numerico e non tra stringhe
for (const char* c = campi.get(0); c && ok; c = campi.get())
{
if (strncmp(c, "CODABI", 6) == 0 || strncmp(c, "CODCAB", 6) == 0)
{
long cod = doc_in.get_long(c);
ok &= (cod == doc_out.get_long(c));
}
else
{
campo = doc_in.get(c);
ok &= campo == doc_out.get(c);
}
}
return ok;
}
//DA_RAGGRUPPARE: per adesso segnaposto: resituisce sempre false
bool TFatturazione_lavanderie::da_raggruppare(const TRiga_documento & rin)
{
/* const long clifo = rin.doc().get_long(DOC_CODCF);
const int indsped = rin.doc().get_int(DOC_CODINDSP);
TLaundry_contract contr(clifo, indsped, _data_elab);
const TString80 codart = rin.get(RDOC_CODART);
const TRectype & rcont = contr.row(codart);
const int tipoforf = rcont.get_int(LVRCONDV_TIPOFORF);
// return tipoforf > 1; // Test originale
if (tipoforf > 1)
return true;
// Da qui in poi e' sottinteso tipoforf == 1
if (ini_get_int(CONFIG_DITTA, "lv", "TipoPr") == 1)
return false;
// Test GUY
const TString8 causale = rin.get(RDOC_CODAGG1);
const TCausale_lavand cau = cache().get("&CAU", causale);
if (cau.get_bool("B1"))
{
const TCausale_magazzino& con = cached_causale_magazzino(cau.get("S2"));
if (con.sgn(s_dottm)) // Causale di incremento sotazione temporanea
return true;
}
if (cau.get_bool("B4")) // Causale di rotto
return true; */
return false;
}
void TFatturazione_lavanderie::pre_process_input(TLista_documenti& doc_in)
{
for (int id = 0; id < doc_in.items(); id++)
{
TDocumento& doc = doc_in[id];
const int rows = doc.physical_rows();
for (int i = 1; i <= rows; i++)
{
TRiga_documento & row = doc[i];
TString str_real = row.get(RDOC_QTAREALE);
if (str_real.full())
{
real qta_real(decode(str_real));
row.put(RDOC_QTA, qta_real);
row.zero(RDOC_QTAREALE);
}
str_real = row.get(RDOC_QTARITREALE);
if (str_real.full())
{
real qta_real(decode(str_real));
row.put(RDOC_QTAGG1, qta_real);
row.zero(RDOC_QTARITREALE);
}
}
}
}
void TFatturazione_lavanderie::aggiorna_fattura(TDocumento & doc, int codcont)
{
const int nrows = doc.physical_rows();
const long codcf = doc.get_long(DOC_CODCF);
TString str;
str << "USE LVRCONDV\n"
<< "FROM CODCF=" << codcf << " CODCONT=" << codcont << "\n"
<< "TO CODCF=" << codcf << " CODCONT=" << codcont;
TISAM_recordset rcont(str);
for(bool ok = rcont.move_first(); ok; ok = rcont.move_next())
{
TRectype& riga = rcont.cursor()->curr();
int forfait = riga.get_int(LVRCONDV_TIPOFORF);
const TString & codart = riga.get(LVRCONDV_CODART);
bool to_add = forfait != 0;
for (int i = 1; to_add && i <= nrows ; i++)
{
TRiga_documento& rout = doc[i];
const TString80 codart_contr = rout.get(RDOC_CODART);
if (codart == codart_contr)
to_add = false;
}
if (to_add)
{
TRiga_documento& rdoc = doc.new_row("21");
rdoc.put(RDOC_CODART, codart);
rdoc.put(RDOC_CODARTMAG, riga.get(LVRCONDV_CODART));
rdoc.put(RDOC_DESCR, cached_article(codart).get(ANAMAG_DESCR));
rdoc.put(RDOC_CHECKED, true);
rdoc.put(RDOC_QTA, 0);
rdoc.put(RDOC_QTAGG1, 0);
rdoc.put(RDOC_UMQTA, riga.get(LVRCONDV_UM));
TToken_string key;
key.add('C');
key.add(codcf);
TString8 codiva = cache().get(LF_CFVEN, key, CFV_ASSFIS);
if (codiva.blank())
codiva = cache().get(LF_ANAMAG, riga.get(LVRCONDV_CODART), ANAMAG_CODIVA);
rdoc.put(RDOC_CODIVA, codiva);
rdoc.put(RDOC_CODAGG1, ini_get_string(CONFIG_DITTA, "lv", "CAUSLAV"));
set_perc_provv(rdoc);
set_perc_provv(rdoc, false);
}
}
}
void TFatturazione_lavanderie::add_doc_to_list(const TString & key, const TDocumento & doc)
{
TDocumento * doc_cli = (TDocumento *) _doc_grouped.objptr(key);
if (doc_cli == NULL)
_doc_grouped.add(key, doc);
else
{
const int nrows = doc.physical_rows();
for (int r = 1; r <=nrows; r++)
{
const TRiga_documento & row = doc[r];
TRiga_documento & new_row = doc_cli->new_row(row.get(RDOC_TIPORIGA));
doc_cli->copy_data(new_row, row);
}
}
}
real TFatturazione_lavanderie::get_percprovv(const TRiga_documento & row, char tipoprovv, const TString & codpr, bool first, const TRectype & age) const
{
real val = ZERO;
const TDocumento & doc = row.doc();
const TRectype & anamag = cache().get(LF_ANAMAG, row.get(RDOC_CODARTMAG));
switch (tipoprovv)
{
case 'A':
val = age.get_real(AGE_PERCPROVV);
break;
case 'M':
val = anamag.get_real(ANAMAG_PERCPROVV);
break;
case 'C':
val = doc.clifor().vendite().get_real(first ? CFV_PERCPROVV : CFV_PERCPROVV1);
break;
case 'V':
{
const TString16 catven = doc.get(DOC_CATVEN);
if (catven.not_empty())
val = real(cache().get("CVE", catven, "R0"));
}
break;
case 'O':
// val = _rcondv.get_real("PERCPROVV");
break;
case '1':
case '2':
case '3':
case '4':
{
const TString16 ord = cache().get("APR", codpr, "S3");
int len = ord.len();
TString key;
TString80 campo;
for (int i = 0; i < len; i++)
{
switch (ord[i])
{
case 'C':
campo = doc.clifor().get(CLI_CODCF);
campo.lpad(doc.clifor().length(CLI_CODCF));
break;
case 'V':
campo = doc.get(DOC_CATVEN);
campo.rpad(doc.length(DOC_CATVEN));
break;
case 'A':
campo = doc.get(DOC_CODAG);
campo.rpad(doc.length(DOC_CODAG));
break;
case 'P':
campo = doc.get(DOC_CODPAG);
campo.rpad(doc.length(DOC_CODPAG));
break;
case 'S':
campo = doc.clifor().vendite().get(CFV_CODSCC);
campo.rpad(doc.clifor().length(CFV_CODSCC));
break;
case 'Z':
campo = doc.get(DOC_ZONA);
campo.rpad(doc.length(DOC_ZONA));
break;
case 'M':
campo = row.get( RDOC_CODARTMAG );
campo.rpad(row.length(RDOC_CODARTMAG));
break;
case 'E':
campo = anamag.get(ANAMAG_GRMERC);
campo.rpad(anamag.length(ANAMAG_GRMERC));
campo.cut(3);
break;
case 'R':
campo = anamag.get(ANAMAG_GRMERC);
campo.rpad(anamag.length(ANAMAG_GRMERC));
break;
case 'F':
campo = anamag.get(ANAMAG_RAGGFIS);
campo.rpad(anamag.length(ANAMAG_RAGGFIS));
break;
default:
campo.cut(0);
break;
}
key << campo;
}
TLocalisamfile perc(LF_PERCPROV);
perc.put(PER_CODPR, codpr);
perc.put(PER_KEYORD, key);
if (perc.read() == NOERR)
val= perc.get_real(PER_PERCPROVV);
}
break;
default:
break;
}
return val;
}
void TFatturazione_lavanderie::set_perc_provv(TRiga_documento & row, bool prima)
{
const TString & codage = row.doc().get(prima ? DOC_CODAG : DOC_CODAGVIS);
if (codage.full())
{
const TRectype & age = cache().get(LF_AGENTI, codage);
if (!age.empty())
{
TString16 seqric(age.get(AGE_SEQRIC));
real percprovv;
if (seqric[0] == '-')
seqric = ini_get_string(CONFIG_DITTA, "ve", "AGETIPOPERC");
int len = seqric.len();
int i;
for (i = 0; percprovv.is_zero() && seqric[i] != '\0' && seqric[i] != '-'; i++)
{
TString16 codric;
if (isdigit(seqric[i]))
codric = age.get(format("CODRICPR%d", i+1));
percprovv = get_percprovv(row, seqric[i], codric, prima, age);
}
real percalt;
seqric = age.get(AGE_SEQALT);
for (i = 0; percalt.is_zero() && seqric[i] != '\0' && seqric[i] != '-'; i++)
{
TString16 codric;
if (isdigit(seqric[i]))
codric = age.get(format("CODALTPR%d", i+1));
percalt = get_percprovv(row, seqric[i], codric, prima, age);
}
percprovv += percalt;
row.put(prima ? RDOC_PERCPROV : RDOC_PERCPROV1, percprovv);
}
}
}
int TFatturazione_lavanderie::write_fatt_ragg()
{
int items = _doc_grouped.items();
TString_array kl;
_doc_grouped.get_keys(kl);
kl.sort();
FOR_EACH_ARRAY_ROW(kl, r, key)
{
TDocumento * d = (TDocumento *)_doc_grouped.objptr(*key);
if (d != NULL)
d->write();
}
_doc_grouped.destroy();
return items;
}
//POST_PROCESS: metodo che elabora i documenti di output dopo che si sono svolte
//le operazioni di base sugli stessi, in modo da raggruppare le righe raggruppabili
//e/o eliminare quelle inutili e/o aggiungere quelle per il ciclaggio su 2 linee
void TFatturazione_lavanderie::post_process(TLista_documenti& doc_out, TLista_documenti& doc_in)
{
bool use_indsp = ini_get_bool(CONFIG_DITTA, "mg", "MOV_INDSPED");
//scorro tutti i documenti di output generati precedentemente
for (int id = 0; id < doc_out.items(); id++)
{
//instanzio il documento e recupero le variabili di interesse per recuperare
//il contratto del cliente in questione
TDocumento& doc = doc_out[id];
const long clifo = doc.get_long(DOC_CODCF);
const int indsped = doc.get_int(DOC_CODINDSP);
TLaundry_contract contr(clifo,indsped,_data_elab);
//flag per il calcolo sul valore convenzionale e sul fisso per dotazione iniziale
bool valconvcli = false;
bool fixdotin = false;
bool elcons = contr.get_bool(LVCONDV_ELCONS);
bool rifbol = contr.get_bool(LVCONDV_RIFBOL);
bool riftest = ini_get_bool(CONFIG_DITTA, "lv", "RifTest");
bool liqdiff = doc.clifor().get_int(CLI_ALLEG) == 7 && doc.clifor().vendite().get_bool(CFV_FATTSOSP);
real consvconv;
real impvconv;
TAssoc_array nolo_computed;
if (liqdiff)
doc.put(DOC_LIQDIFF, "X");
else
doc.zero(DOC_LIQDIFF);
if (doc.physical_rows() > 0 && doc[1].is_descrizione())
{
if (elcons)
{
TRiga_documento& rout = doc[1];
rout.put(RDOC_DESCR, "COME DA ELENCO CONSEGNE");
rout.put(RDOC_DESCLUNGA, false);
rout.put(RDOC_DESCEST, "");
}
else
if (!rifbol)
doc.destroy_row(1, true);
}
//se devo mettere i riferimenti della bolla in testata, prendo la descrizione della prima riga
//e la metto sulla testata del documento, poi cancello la prima riga del documento
if (rifbol && riftest)
{
TRiga_documento& rout = doc[1];
TString descr = rout.get(RDOC_DESCR);
descr << ' ' << rout.get(RDOC_DESCEST);
descr.ltrim(21);
//sostituisco la stringa " - n. " e la sostituisco con la stringa " - " su tutta la stringa descrizione
int pos = descr.find(" - n. ");
while (pos > 0)
{
descr.overwrite(" - ", pos, 7);
pos = descr.find(" - n. ", pos + 1);
}
descr.strip_double_spaces();
const TString original_notes = doc.get(DOC_NOTE);
if (original_notes.full())
descr << '\n' << original_notes;
doc.put(DOC_NOTE, descr);
doc.destroy_row(1, true);
}
if (doc.physical_rows() > 0)
doc.sort_rows("LVTYPE|" RDOC_CODART);
const bool ragart = contr.get_bool(LVCONDV_RAGART); // leggo il flag di testata raggruppa su unico articolo
const int tipocan = contr.get_int(LVCONDV_TIPOCAN); // leggo il tipo canone
const real redditivita = contr.get_real(LVCONDV_REDDI);
if (ragart)
{
real totmerc;
const int rows = doc.physical_rows();
for (int i=1; i <= rows; i++) //calcolo totale merce
{
const TRiga_documento& riga = doc[i];
if (riga.is_merce())
totmerc += riga.importo(true,false);
}
const int rigamerce = doc[1].is_descrizione() ? 2 : 1;
for (int i=rigamerce; i <= rows; i++)
doc.destroy_row(i);
TRiga_documento& riga = doc.new_row("01");
const TString80 codartcfg = ini_get_string(CONFIG_DITTA, "lv", "Codartcafix");
const TString80 descart = cache().get(LF_ANAMAG, codartcfg, ANAMAG_DESCR);
// istanzio una token string e poi una cache per estrarre l'unit<69> di misura dell articolo in configurazione da UMART
TToken_string key;
key.add(codartcfg);
key.add(1);
const TRectype& umart = cache().get(LF_UMART,key);
const TString4 umcodart = umart.get(UMART_UM);
/* estraggo il codice IVA istanziando in primis una cache su CFVEN per analizzare il codice esenzione iva
del cliente in questione. Se <20> >0 imposto il codiva a tale valore, altrimenti se <20> uguale a 0 istanzio
un altra cache su ANAMAG e imposto il codiva uguale al codice iva dell articolo in questione */
key = doc.get(DOC_TIPOCF);
key.add(clifo);
const TRectype& cfven = cache().get(LF_CFVEN,key);
TString8 codiva = cfven.get(CFV_ASSFIS);
if (codiva.blank())
{
const TRectype& anamag = cache().get(LF_ANAMAG,codartcfg);
codiva = anamag.get(ANAMAG_CODIVA);
}
riga.put(RDOC_QTA,UNO);
riga.put(RDOC_UMQTA,umcodart);
riga.put(RDOC_PREZZO,totmerc);
riga.put(RDOC_CODART,codartcfg);
riga.put(RDOC_DESCR,descart);
riga.put(RDOC_CODIVA,codiva);
set_perc_provv(riga);
set_perc_provv(riga, false);
break;
}
else // se non <20> selezionato raggrupa su unico articolo controllo il tipo canone se <20> impostato a importo fisso
if (tipocan == 1) //se <20> selezionato tipo canone = importo fisso
{
// estraggo il canone fisso e l'articolo in configurazione
const real canfis=contr.get_real(LVCONDV_IMPFIX);
const TString80 codartcfg = ini_get_string(CONFIG_DITTA, "lv", "Codartfix");
const TString80 descart = cache().get(LF_ANAMAG, codartcfg, ANAMAG_DESCR);
// istanzio una token string e poi una cache per estrarre l'unit<69> di misura dell articolo in configurazione da UMART
TToken_string key;
key.add(codartcfg);
key.add(1);
const TRectype& umart = cache().get(LF_UMART,key);
const TString4 umcodart = umart.get(UMART_UM);
/* estraggo il codice IVA istanziando in primis una cache su CFVEN per analizzare il codice esenzione iva
del cliente in questione. Se <20> >0 imposto il codiva a tale valore, altrimenti se <20> uguale a 0 istanzio
un altra cache su ANAMAG e imposto il codiva uguale al codice iva dell articolo in questione */
key = doc.get(DOC_TIPOCF);
key.add(clifo);
const TRectype& cfven = cache().get(LF_CFVEN,key);
TString8 codiva = cfven.get(CFV_ASSFIS);
if (codiva.blank())
{
const TRectype& anamag = cache().get(LF_ANAMAG,codartcfg);
codiva = anamag.get(ANAMAG_CODIVA);
}
const int rigamerce = doc.physical_rows() > 0 && doc[1].is_descrizione()?2:1;
TRiga_documento& fixrow=doc.insert_row(rigamerce, "01"); // creo una nuova riga in cima al documento e imposto i valori appena estratti
fixrow.put(RDOC_QTA,UNO);
fixrow.put(RDOC_UMQTA,umcodart);
fixrow.put(RDOC_PREZZO,canfis);
fixrow.put(RDOC_CODART,codartcfg);
fixrow.put(RDOC_DESCR,descart);
fixrow.put(RDOC_CODIVA,codiva);
int tipocanfix = contr.get_int(LVCONDV_CANFIX);
const int rows = doc.physical_rows();
switch (tipocanfix)
{
case 0:
for (int k = rigamerce+1; k <= rows; k++)
doc.destroy_row(k);
break;
case 1:
for (int k = rigamerce+1; k <= rows; k++)
{
TRiga_documento& rout = doc[k];
rout.zero(RDOC_PREZZO);
}
break;
case 2:
for (int k = rigamerce+1; k <= rows; k++)
{
TRiga_documento& rout = doc[k];
rout.zero(RDOC_PREZZO);
rout.zero(RDOC_QTA);
}
break;
default: break;
}
break;
}
else // se il tipo canone <20> impostato a nessuno o % sul valore convenzionale per cliente vado in ambedue i casi ad eseguire il ciclo che analizza i tipi forfait
{
if (!contr.get_bool(LVCONDV_FORFNOCONS))
aggiorna_fattura(doc, contr.get_int(LVCONDV_CODCONT));
//per ogni documento, scorro tutte le sue righe
for (int i = 1; i <= doc.physical_rows() ; i++)
{
TRiga_documento& rout = doc[i];
const TString80 codart = rout.get(RDOC_CODART);
//leggo dalla riga del contratto di questo articolo il tipo dotazione e
//la scelta per la % sul val.conv su articolo <A> o cliente <C>
const TRectype& rcont = contr.row(codart);
const TString4 tipodot = rcont.get(LVRCONDV_NOLCIC);
const TString4 artcli = rcont.get(LVRCONDV_VCARTCLI);
real dot;
const int annoes = _data_elab.year();
//instanzio il TArticolo_lavanderia
//cerco la giacenza per articolo dell'articolo esaminato
TArticolo_lavanderie& artlav = cached_article_laundry(codart, 'C', clifo, use_indsp ? indsped : 0);
//estraggo il record corrispondente su LF_CLIFOGIAC
const TRecmag_lavanderie& reclav = artlav.find_rec(annoes);
//se lo trovo e se il tipo dotazione <20> iniziale 'I', allora leggo la dotazione iniziale
//dalle giacenze articolo per cliente, altrimenti leggo la dotazione odierna
if (tipodot == "I")
dot = reclav.get_real("DOTIN");
else
dot = reclav.get_real("DOTOD");
//leggo dalla riga contratto il tipo forfait
const int tipoforf = rcont.get_int(LVRCONDV_TIPOFORF);
switch (tipoforf)
{
case 0: //forfait = NESSUNO
{
//gestione fatturazione a kg
const bool fatkg = rcont.get_bool(LVRCONDV_FATTKG);
//se devo fatturare a kg
if(fatkg)
{
const TString4 umkg = ini_get_string(CONFIG_DITTA, "lv", "UmKg");
const TString4 umri = rout.get(RDOC_UMQTA);
//se la riga <20> gi<67> espressa in kg non devo fare niente, altrimenti:
if(umri != umkg)
{
//leggo e controllo l'unit<69> di misura del peso
const TString4 ump = artlav.get(ANAMAG_UMP);
if(ump.empty())
{
warning_box(TR("Manca l'unit<69> di misura del peso"));
break;
}
//leggo e controllo il peso dell'articolo
const real peso = artlav.get_real(ANAMAG_PESO);
if(peso == ZERO)
{
warning_box(TR("Manca il peso"));
break;
}
//leggo l'unit<69> di misura dell'articolo e la quantit<69> convertita all'unit<69> di misura dell'articolo
const TString4 umart = artlav.um()[1].get(UMART_UM);
const real qta = artlav.convert_to_um(rout.get_real(RDOC_QTA), umart, umri, false);
//se l'articolo non <20> espresso in kg, allora:
if(umart != umkg)
{
//preparo una cache sulla tabella delle unit<69> di misura
const TRectype& unita = cache().get("%UMS", ump);
real fatconv = UNO;
if (ump != umkg)
{
//leggo e controllo se esiste l'unit<69> di misura di riferimento
const TString4 umrif = unita.get("S7");
if(umrif.empty())
{
warning_box(TR("Manca l'unit<69> di misura di riferimento"));
break;
}
if(umrif != umkg)
{
warning_box(TR("L'unit<69> di misura di riferimento non <20> quella dei Kg"));
break;
}
//leggo e controllo il fattore di conversione
fatconv = unita.get_real("R10");
if(fatconv == ZERO)
{
warning_box(TR("Manca il fattore di conversione"));
break;
}
}
//se tutti i controlli sono andati a buon fine, converto la quantit<69> e la scrivo sulla riga documento
const real qtaconv = qta * fatconv * peso;
rout.put(RDOC_UMQTA, umkg);
rout.put(RDOC_QTA, qtaconv);
}
}
}
}
break;
case 1: //forfait = A VALORE FISSO
{
rout.put(RDOC_QTA, UNO); //qta fissa a UNO
rout.put(RDOC_PREZZO, rcont.get_real(LVRCONDV_IMPFISART)); //prezzo letto dalla riga contratto
// gestione in base codice per valore fisso ??? tolta la scelta dell'articolo o del cliente
}
break;
case 2: //forfait = NOLO
{
//aggiungo una riga tipo merce, che contiene tutti i dati della riga del documento
//di partenza, poi costruisco la descrizione in base alla periodicit<69> di fatturazione,
//metto la qta uguale alla dotazione che ho appena letto
//e prendo il prezzo nolo dalla riga contratto
if (dot != ZERO && nolo_computed.objptr(codart) == NULL)
{
TRiga_documento& nolorow = doc.insert_row(++i, "01");
nolo_computed.add(codart, codart);
doc.copy_data(nolorow, rout);
const TString descrart = rout.get(RDOC_DESCR);
TString80 descr("Nolo");
const int contrper = contr.get_int(LVCONDV_PERFAT);
switch (contrper)
{
case 0: descr << " per il giorno "; break;
case 1: descr << " per la settimana "; break;
case 2: descr << " per la quindicina "; break;
case 3: descr << " per il mese "; break;
default: break;
}
descr << descrart;
int split_pos = descr.find('\n');
const int descr_len = nolorow.length(RDOC_DESCR);
if (split_pos < 0 && descr.len() > descr_len)
split_pos = descr_len;
if (split_pos > descr_len)
split_pos = descr_len;
if (split_pos > 0)
{
nolorow.put(RDOC_DESCR, descr.left(split_pos));
const TString& dest = descr.mid(split_pos);
nolorow.put(RDOC_DESCLUNGA, "X");
nolorow.put(RDOC_DESCEST, dest);
}
else
{
nolorow.put(RDOC_DESCR, descr);
nolorow.zero(RDOC_DESCLUNGA);
nolorow.zero(RDOC_DESCEST);
}
nolorow.put(RDOC_QTA, dot);
nolorow.put(RDOC_PREZZO, rcont.get_real(LVRCONDV_PREZNOL));
}
}
break;
case 3: //forfait = CICLAGGIO
{
//leggo la quantit<69> consegnata e calcolo consumo e ciclaggio secondo le formule
//CONSUMO = QTA * PREZZO(dalla riga documento)
//CLICLAGGIO = DOT * PREZZO(dalla riga contratto) * MINIMO CICLAGGIO
const real qta = rout.get_real(RDOC_QTA);
const real consumo = qta * rout.get_real(RDOC_PREZZO);
const real ciclaggio = dot * rcont.get_real(LVRCONDV_PREZZO) * rcont.get_real(LVRCONDV_MINCIC);
//se il consumo <20> minore del ciclaggio, allora
if (consumo < ciclaggio)
{
//leggo il flag del tipo ciclaggio
const bool cicl2rig = contr.get_bool(LVCONDV_CICLAGGIO);
//calcolo il valore cicl secondo la formula CICL = MINIMO CICLAGGIO * DOT
const real cicl = rcont.get_real(LVRCONDV_MINCIC) * dot;
//se il ciclaggio <20> su due linee, allora aggiungo una riga merce, per pareggiare il minimo ciclaggio
//che ha come quantit<69> la differenza tra la quantit<69> di minimo cilcaggio
//e la quantit<69> effettivamente consegnata e come prezzo il prezzo preso dalla riga contratto;
//altimenti correggo quantit<69> e prezzo direttamente sulla riga documento che sto analizzando
if (cicl2rig)
{
TRiga_documento& congrow = doc.insert_row(++i, "01");
doc.copy_data(congrow,rout);
congrow.put(RDOC_DESCR,"Pareggio minimo ciclaggio");
congrow.put(RDOC_QTA, cicl - qta);
congrow.put(RDOC_PREZZO, rcont.get_real(LVRCONDV_PREZZO));
}
else
{
rout.put(RDOC_QTA, cicl);
rout.put(RDOC_PREZZO, rcont.get_real(LVRCONDV_PREZZO));
}
}
}
break;
case 4: //forfait = % SUL VALORE CONVENZIONALE
{
//leggo dalla riga contratto la % sul val.conv su articolo <A> o cliente <C>
const char tipovalconv = rcont.get_char(LVRCONDV_VCARTCLI);
//se la percentuale sul valore convenzionale <20> sull'articolo, allora:
if (tipovalconv == 'A')
{
//leggo la quantit<69> consegnata e calcolo consumo e importo convenzionale secondo le formule
//CONSUMO = QTA * PREZZO(dalla riga documento)
//IMPCONV = DOT * PREZZO(dalla riga contratto) * PERCENTUALE DI FORFAIT CLIENTE
const real qta = rout.get_real(RDOC_QTA);
const real consumo = qta * rout.get_real(RDOC_PREZZO);
const real impconv = dot * rcont.get_real(LVRCONDV_VALCONV) * rcont.get_real(LVRCONDV_FORFPERCL) / 100;
impvconv += impconv;
consvconv += consumo;
}
else
{
//se la percentuale sul valore convenzionale <20> sul cliente, allora se il flag valconvcli <20> false
if (!valconvcli)
{
//pongo valconvcli a true in modo da non tornare pi<70> in questo if
valconvcli = true;
//instanzio i due real che andranno a contenere l'importo covenzionale totale e il consumo totale
real impconvtot;
real consumotot;
TAssoc_array arts;
//scorro tutte le righe documento dalla riga in esame fino alla fine
for (int j = i; j < doc.physical_rows(); j++)
{
//instanzio la riga documento e sommo ai totali gli importi solo se
//la percentuale sul valore convenzionale <20> sul cliente
TRiga_documento& riga = doc[j];
const TString80 codart = riga.get(RDOC_CODART);
const TRectype & rcont = contr.row(codart);
const char tipvalconvcli = rcont.get_char(LVRCONDV_VCARTCLI);
char lavtype = riga.get_char("LVTYPE");
if (tipvalconvcli == 'C' && lavtype != 'D')
{
if (arts.objptr(codart) == NULL)
{
const TString4 tipodot = rcont.get(LVRCONDV_NOLCIC);
TArticolo_lavanderie& art = cached_article_laundry(codart, 'C', clifo, use_indsp ? indsped : 0);
//estraggo il record corrispondente su LF_CLIFOGIAC
const TRecmag_lavanderie& rec = art.find_rec(annoes);
//se lo trovo e se il tipo dotazione <20> iniziale 'I', allora leggo la dotazione iniziale
//dalle giacenze articolo per cliente, altrimenti leggo la dotazione odierna
if (tipodot == "I")
dot = rec.get_real("DOTIN");
else
dot = rec.get_real("DOTOD");
const real impconv = dot * rcont.get_real(LVRCONDV_VALCONV) * rcont.get_real(LVRCONDV_FORFPERCL) / CENTO;
impconvtot += impconv;
arts.add(codart, codart);
}
consumotot += riga.get_real(RDOC_QTA) * riga.get_real(RDOC_PREZZO);
}
}
//se il consumo <20> minore del ciclaggio, allora
if (consumotot < impconvtot)
{
const bool cicl2rig=contr.get_bool(LVCONDV_CICLAGGIO);
const TString80 codartcon = ini_get_string(CONFIG_DITTA, "lv", "Codartcofix");
//se il ciclaggio <20> su due linee, allora aggiungo una riga merce, che contiene
//il conguaglio al valore convenzionale, che ha come quantit<69> la costante UNO
//e come prezzo la differenza tra l'importo convenzionale totale e il consumo totale;
//altimenti correggo quantit<69> e prezzo direttamente sulla riga documento che sto analizzando
//e elimino tutte le righe che vanno a comporre il totale in modo che rimanga una riga sola
//per mostrare l'importo del conguaglio al valore convenzionale
if (cicl2rig)
{
i++;
TRiga_documento& congrow=doc.new_row("01");
doc.copy_data(congrow, rout);
congrow.put(RDOC_CODART, codartcon);
congrow.put(RDOC_CHECKED, "X");
congrow.put(RDOC_CODARTMAG, codartcon);
congrow.put(RDOC_DESCR, "Conguaglio valore convenzionale");
congrow.put(RDOC_QTA, UNO);
congrow.put(RDOC_PREZZO, impconvtot - consumotot);
set_perc_provv(congrow);
set_perc_provv(congrow, false);
}
else
{
rout.put(RDOC_CODART, codartcon);
rout.put(RDOC_CHECKED, "X");
rout.put(RDOC_CODARTMAG, codartcon);
rout.put(RDOC_DESCR, "Valore convenzionale");
rout.put(RDOC_QTA, UNO);
rout.put(RDOC_PREZZO, impconvtot);
for (int k = doc.physical_rows(); k > i; k--)
{
TRiga_documento& delrow = doc[k];
const TString80 codart = delrow.get(RDOC_CODART);
const TRectype& rcont = contr.row(codart);
const char tipvalconvcli = rcont.get_char(LVRCONDV_VCARTCLI);
char lavtype = delrow.get_char("LVTYPE");
if (tipvalconvcli == 'C' && lavtype != 'D')
doc.destroy_row(k, true);
}
}
}
}
}
}
break;
case 5: //forfait = FISSO SU DOTAZIONE INIZIALE
{
rout.put(RDOC_PREZZO, rcont.get_real(LVRCONDV_IMPFISART));
const real dotin = reclav.get_real("DOTIN");
rout.put(RDOC_QTA, dotin);
if (rout.get(RDOC_DESCR).blank())
{
const TString & descr = cached_article(codart).get(RDOC_DESCR);
rout.put(RDOC_DESCR, descr);
}
const TString80 codartorig=rout.get(RDOC_CODART);
for (int h = doc.physical_rows(); h > i; h--)
{
TRiga_documento& delrow = doc[h];
const TString80 codart=delrow.get(RDOC_CODART);
if ( codartorig == codart)
doc.destroy_row(h, true);
}
}
break;
default: break;
}
}
//se il consumo <20> minore del ciclaggio, allora
if (impvconv - consvconv > ZERO)
{
const bool cicl2rig = contr.get_bool(LVCONDV_CICLAGGIO);
const int rows = doc.physical_rows();
//se il ciclaggio <20> su due linee, allora aggiungo una riga merce, che contiene
//il conguaglio al valore convenzionale, che ha come quantit<69> la costante UNO
//e come prezzo la differenza tra l'importo convenzionale e il consumo;
//altimenti correggo quantit<69> e prezzo direttamente sulla riga documento che sto analizzando
TRiga_documento& congrow = doc.new_row("01");
const TString80 codartcon = ini_get_string(CONFIG_DITTA, "lv", "Codartcofix");
congrow.put(RDOC_CODART, codartcon);
congrow.put(RDOC_CHECKED, "X");
congrow.put(RDOC_CODARTMAG, codartcon);
congrow.put(RDOC_DESCR, "Conguaglio valore convenzionale");
congrow.put(RDOC_QTA, UNO);
TString8 codiva = doc.clifor().vendite().get(CFV_ASSFIS);
if (codiva.blank())
codiva = cache().get(LF_ANAMAG, codartcon, ANAMAG_CODIVA);
congrow.put(RDOC_CODIVA, codiva);
if (cicl2rig)
congrow.put(RDOC_PREZZO, impvconv - consvconv);
else
{
congrow.put(RDOC_PREZZO, impvconv);
for (int k = rows - 1; k >= 1; k--)
{
TRiga_documento& delrow = doc[k];
const TString80 codart = delrow.get(RDOC_CODART);
const TRectype& rcont = contr.row(codart);
const int tipoforf = rcont.get_int(LVRCONDV_TIPOFORF);
char lavtype = delrow.get_char("LVTYPE");
if (tipoforf == 4 && lavtype != 'D')
doc.destroy_row(k, true);
}
}
}
}
if (redditivita > ZERO && fatt_02() && !ragart && tipocan != 1)
{
const real totdoc = doc.totale_doc();
const real provvigione1 = doc.provvigione();
const real provvigione2 = doc.provvigione(false);
doc.put(RDOC_TOTREALE, encode(totdoc.string()));
doc.put(RDOC_PROVV1REALE, encode(provvigione1.string()));
doc.put(RDOC_PROVV2REALE, encode(provvigione2.string()));
for(int j = doc.physical_rows(); j > 0; j--)
{
TRiga_documento& rdoc = doc[j];
const TString80 codart = rdoc.get(RDOC_CODARTMAG);
const TRectype& rcont = contr.row(codart);
const int tipoforf = rcont.get_int(LVRCONDV_TIPOFORF);
long ppconf = cached_article(codart).get_long(ANAMAG_PPCONF);
const real real_qta = rdoc.get(RDOC_QTA);
if (rcont.get_int(LVRCONDV_CALCCONS) != 1 || ppconf == 0)
ppconf = 1;
const char lvtype = rdoc.get_char("LVTYPE");
// bool row_has_02 = (tipoforf == 0) && (real_qta / ppconf > UNO || redditivita >= CENTO) && (lvtype == 'C');
bool row_has_02 = (tipoforf == 0) && (lvtype == 'C');
// 0 forfait = NESSUN FORFAIT SI
// 1 forfait = A VALORE FISSO NO
// 2 forfait = NOLO NO
// 3 forfait = CICLAGGIO NO
// 4 forfait = % SUL VALORE CONVENZIONALE NO
// 5 forfait = FISSO SU DOTAZIONE INIZIALE NO
if (row_has_02)
{
const TString key = format("%04d%04d", doc.get_int("FATID"), rdoc.get_int(RDOC_IDRIGA));
real new_qta = real_qta;
TCalc_02_data * data = (TCalc_02_data *) _output_rows_02.objptr(key);
rdoc.put(RDOC_QTAREALE, encode(real_qta.string()));
if (data != NULL)
{
new_qta /= ppconf;
real test = new_qta;
test.ceil();
if (test * ppconf != real_qta)
{
warning_box(FR("L'articolo %s per il cliente %ld ha una quantit<69> %s\nnon coincidente coi pacchi. Controllare le bolle"),
(const char *)codart, doc.get_long(DOC_CODCF), real_qta.string());
ppconf = 1;
}
new_qta *= (CENTO - redditivita) / CENTO;
new_qta.round();
data->distr() = new_qta;
new_qta *= ppconf;
rdoc.put(RDOC_QTA, new_qta);
real new_qta_rit = rdoc.get_real("TOTRIT");
new_qta_rit *= (CENTO - redditivita) / CENTO;
new_qta_rit.round();
data->distr_rit() = new_qta_rit;
TAssoc_array & bol_rows = data->bol_rows();
FOR_EACH_ASSOC_OBJECT(bol_rows, obj, wkey, item)
{
TToken_string bolkey(wkey);
const long ndoc = bolkey.get_long(3);
const long id = bolkey.get_long(4);
for (int i = 0; i < doc_in.items(); i++)
{
TDocumento& doc = doc_in[i];
if (doc.get_long(DOC_NDOC) == ndoc)
{
TRiga_documento * bolrow = (TRiga_documento *) doc.get_row_id(id);
if (bolrow != NULL)
{
const TString8 causale = bolrow->get(RDOC_CODAGG1);
const TCausale_lavanderie & cau = cached_causale_lavanderie(causale);
if (cau.is_rotto())
break;
bool fatturo_ritirato = cau.is_ritiro();
bool fatturo_consegnato = cau.is_consegna();
if (fatturo_ritirato)
{
const TCausale_magazzino& rit = cau.causale_ritiro();
fatturo_ritirato = rit.sgn(s_consmese) != 0;
}
if (fatturo_consegnato)
{
const TCausale_magazzino& con = cau.causale_consegna();
fatturo_consegnato = con.sgn(s_consmese) != 0;
}
TString str_real = bolrow->get(RDOC_QTA);
real qta = real(str_real) / ppconf;
qta.round();
if (str_real.full())
bolrow->put(RDOC_QTAREALE, encode(str_real));
str_real = bolrow->get(RDOC_QTAGG1);
real qtarit = real(str_real);
data->distr_rit().add(qtarit);
if (str_real.full())
bolrow->put(RDOC_QTARITREALE, encode(str_real));
if (fatturo_ritirato && !fatturo_consegnato) // ! fatturo il ritirato o fatturo il consegnato
{
qtarit = real(str_real) / ppconf;
qtarit.round();
data->distr().add(qtarit);
}
else
data->distr().add(qta);
}
else
message_box("Riga_bolla smarrita %d - %s - %ld - id = %ld", bolkey.get_int(1), bolkey.get(0), bolkey.get(3), bolkey.get(4));
break;
}
}
}
FOR_EACH_ASSOC_OBJECT(bol_rows, obj1, wkey1, item1)
{
TToken_string bolkey(wkey);
const long ndoc = bolkey.get_long(3);
const long id = bolkey.get_long(4);
for (int i = 0; i < doc_in.items(); i++)
{
TDocumento& doc = doc_in[i];
if (doc.get_long(DOC_NDOC) == ndoc)
{
TRiga_documento * bolrow = (TRiga_documento *) doc.get_row_id(id);
if (bolrow != NULL)
{
const TString8 causale = bolrow->get(RDOC_CODAGG1);
const TCausale_lavanderie & cau = cached_causale_lavanderie(causale);
if (cau.is_rotto())
break;
bool fatturo_ritirato = cau.is_ritiro();
bool fatturo_consegnato = cau.is_consegna();
if (fatturo_ritirato)
{
const TCausale_magazzino& rit = cau.causale_ritiro();
fatturo_ritirato = rit.sgn(s_consmese) != 0;
}
if (fatturo_consegnato)
{
const TCausale_magazzino& con = cau.causale_consegna();
fatturo_consegnato = con.sgn(s_consmese) != 0;
}
const real qta = data->distr().get() * ppconf;
const real qtarit = data->distr_rit().get();
bolrow->put(RDOC_QTAGG1, qtarit);
if ((!fatturo_ritirato) || (fatturo_consegnato)) // ! fatturo il ritirato o fatturo il consegnato
bolrow->put(RDOC_QTA, qta);
else
int c = 1; // placeholder
}
else
message_box("Riga_bolla smarrita %d - %s - %ld - id = %ld", bolkey.get_int(1), bolkey.get(0), bolkey.get(3), bolkey.get(4));
break;
}
}
}
}
}
}
}
for(int h = doc.physical_rows(); h > 0; h--)
{
TRiga_documento& rdoc = doc[h];
if (rdoc.get(RDOC_DESCR).empty() || ((rdoc.imponibile() == ZERO && rdoc.get_real(RDOC_QTA) == ZERO)))
doc.destroy_row(h, true);
}
}
for (int id = doc_out.items() - 1; id >= 0 ; id--)
{
TDocumento& doc = doc_out[id];
const int rows = doc.physical_rows();
bool to_delete = true;
for (int i = rows; to_delete && i > 0; i--)
{
const TRiga_documento& riga = doc[i];
if (!riga.is_descrizione())
to_delete = (riga.imponibile() == ZERO && riga.get_real(RDOC_QTA) == ZERO);
}
if (to_delete || doc.totale_doc() == ZERO)
doc_out.destroy(id);
}
for (int id = doc_out.items() - 1; id >= 0 ; id--)
{
TDocumento& doc = doc_out[id];
const TString4 tipocf = doc.get(DOC_TIPOCF);
const int act_cli = doc.get_long(DOC_CODCF);
TToken_string key(tipocf);
key.add(act_cli);
const TRectype & reccli = cache().get(LF_CLIFO, key);
const long new_cli = reccli.get_long(CLI_CODCFFATT);
if (new_cli > 0L)
{
doc.put(DOC_CODCF, new_cli);
key = tipocf;
key.add(new_cli);
const TRectype & new_reccliven = cache().get(LF_CFVEN, key);
TLaundry_contract contr(new_cli, doc.get_long(DOC_CODINDSP), _data_elab);
doc.put(DOC_CODINDSP, new_reccliven.get(CFV_CODINDDOC));
TString descr;
TRiga_documento & r = doc.insert_row(1, "05");
r.put(RDOC_DESCR, "Consegne effettuate presso\n");
descr << act_cli << " " << reccli.get(CLI_RAGSOC);
r.put(RDOC_DESCLUNGA, "X");
r.put(RDOC_DESCEST, descr);
if (contr.get_bool(LVCONDV_RAGGCGRUP))
{
add_doc_to_list(key, doc);
doc_out.destroy(id);
}
}
}
}
//ADD_ROWS: per adesso un segnaposto
void TFatturazione_lavanderie::add_rows(TRiga_documento & rout, TRiga_documento & rin)
{
/*const TString8 causale = rin.get(RDOC_CODAGG1);
const TRectype& cau = cache().get("&CAU", causale);
const TCausale_magazzino& rit = cached_causale_magazzino(cau.get("S1"));
const TCausale_magazzino& con = cached_causale_magazzino(cau.get("S2")); //movimento o meno la dotazione temporanea/odierna a seconda di cosa prevede la causale
const long clifo = rin.doc().get_long(DOC_CODCF);
const int indsped = rin.doc().get_int(DOC_CODINDSP);
TLaundry_contract contr(clifo, indsped, _data_elab);
if (cau.get_bool("B4") && contr.get_int(LVCONDV_ADDCAPROT)) // Guardo se <20> una causale di rotto e se <20> abilitato nella testata del contratto la fatturazione dei rotti
{
const real qta = rit.sgn(s_consmese) * rin.get_real(RDOC_QTA);
rout.put(RDOC_PREZZO,contr.get_int(LVCONDV_PREZROT));
rout.add(RDOC_QTA, qta);
}
else
{
if (cau.get_bool("B0"))
{
const real qta = rit.sgn(s_consmese) * rin.get_real(RDOC_QTA);
rout.add(RDOC_QTA, qta);
}
if (cau.get_bool("B1"))
{
const real qta = con.sgn(s_consmese) * rin.get_real(RDOC_QTA);
rout.add(RDOC_QTA, qta);
}
} */
}
//CAMPI_RAGGRUPPAMENTO_RIGHE: ridefinisco il metodo campi_raggruppamento_righe della TFatturazione_bolle
void TFatturazione_lavanderie::campi_raggruppamento_righe(TToken_string& campi_riga) const
{
campi_riga = RDOC_CODART"|"RDOC_UMQTA; // Uguali sempre
const bool ragg_rig = raggruppa_righe();
if (ragg_rig)
{
// Uguali se commesse attive
if (dongle().active(CAAUT) || dongle().active(CMAUT))
{
campi_riga.add(RDOC_CODCMS);
campi_riga.add(RDOC_FASCMS);
campi_riga.add(RDOC_CODCOSTO);
}
// Uguali opzionalmente
if (riga_uguale(0)) campi_riga.add(RDOC_CODMAG);
if (riga_uguale(1)) campi_riga.add(RDOC_CODIVA);
if (riga_uguale(2))
{
const int tipoprezzo = ini_get_int(CONFIG_DITTA, "lv", "TipoPr");
if(tipoprezzo == 0)
campi_riga.add(RDOC_SCONTO);
else
campi_riga.add(RDOC_PREZZO"|"RDOC_SCONTO);
}
}
}
//FIND_OR_CREATE_ROW: questo metodo cerca tra tutte le righe documento della fattura prodotta
//una eventuale riga lavanderia raggruppabile; se la trova restituiace quella riga, altrimenti
//ne crea una nuova
TRiga_documento& TFatturazione_lavanderie::find_or_create_row(TDocumento& doc_out, const TRiga_documento& rin, const char lavtype)
{
int r;
//scorro le righe documetno
for (r = doc_out.physical_rows(); r > 0; r--)
{
//se trovo una riga raggruppabile e di lavanderia, allora interrompo il ciclo
if (doc_out[r].raggruppabile(rin, _campi_raggruppamento) && (doc_out[r].get_char("LVTYPE") == lavtype))
break;
}
//se non ho trovato la riga, ne creo una nuova
if (r <= 0)
{
TRiga_documento& row = doc_out.new_row("01");
doc_out.copy_data(row, rin);
row.put(RDOC_TIPORIGA, "01");
set_perc_provv(row);
set_perc_provv(row, false);
const TRectype& anamag = cache().get(LF_ANAMAG, rin.get(RDOC_CODART));
row.put(RDOC_CODIVA, anamag.get(ANAMAG_CODIVA));
row.zero(RDOC_CODAGG1);
row.zero(RDOC_QTA);
row.zero(RDOC_QTAGG1);
row.zero(RDOC_CODMAGC);
row.put("LVTYPE", lavtype);
r = row.get_int(RDOC_NRIGA);
}
if (fatt_02())
{
doc_out.set_row_ids();
const TString key = format("%04d%04d", doc_out.get_int("FATID"), doc_out[r].get_int(RDOC_IDRIGA));
TCalc_02_data * data = (TCalc_02_data *) _output_rows_02.objptr(key);
if (data == NULL)
{
data = new TCalc_02_data(key);
_output_rows_02.add(key, data);
}
TString bolkey = rin.get_rdoc_key();
data->bol_rows().add(bolkey, bolkey);
}
return doc_out[r];
}
//CREATE_ROW: metodo che crea fisicamente la riga sul documento di uscita partendo dal documento di ingresso (bolla)
void TFatturazione_lavanderie::create_row(TDocumento& doc_out, const TRiga_documento & rin)
{
//leggo la causale della riga del documento di ingresso
const TString8 causale = rin.get(RDOC_CODAGG1);
const TCausale_lavanderie & cau = cached_causale_lavanderie(causale);
//recupero i dati cliente dalla testata del documento e instanzio il contratto
const long clifo = rin.doc().get_long(DOC_CODCF);
const int indsped = rin.doc().get_int(DOC_CODINDSP);
TLaundry_contract contr(clifo, indsped, _data_elab);
//leggo dal documento i valori che vanno riportati sulla fattura e recupero la riga contratto
//di quell'articolo
const TString80 codart = rin.get(RDOC_CODARTMAG); // non <20> gestito il caso di un articolo fuori contratto
const real qta = rin.get_real(RDOC_QTA);
const real qta1 = rin.get_real(RDOC_QTAGG1);
const TRectype& rcont = contr.row(codart);
//leggo dalla configurazione da dove va preso il prezzo
const int tipoprezzo = ini_get_int(CONFIG_DITTA, "lv", "TipoPr");
real prezzo;
//se tipoprezzo == 0 (prezzo da contratto), allora cerco il prezzo sul contratto; se l'articolo
//non esiste sul contratto, allora cerco il suo prezzo sull'anagrafica di magazzino.
//Se tipoprezzo == 1 (prezzo da bolla), allora leggo il prezzo sulla riga della bolla
if (tipoprezzo == 0)
{
if (!rcont.empty())
prezzo = rcont.get_real(LVRCONDV_PREZZO);
}
else
prezzo = rin.get_real(RDOC_PREZZO);
//se <20> una causale di rotto e se <20> abilitato nella testata del contratto la fatturazione dei rotti
//e se sto ritirando una quantit<69> di merce diversa da zero, allora:
if (cau.is_rotto() && contr.get_bool(LVCONDV_ADDCAPROT) && !qta1.is_zero())
{
//se passo le condizioni iniziali cerco eventualmente una riga che possa essere raggruppata con quella
//che sto guardando adesso, altrimenti la creo; in ogni caso aggiungo la quantit<69> da ritirare
//al prezzo segnato in contratto
TRiga_documento& rd = find_or_create_row(doc_out, rin ,'D');
rd.put(RDOC_DESCLUNGA, "X");
rd.put(RDOC_DESCEST, "\nper addebito biancheria");
rd.add(RDOC_QTA, qta1);
rd.put(RDOC_PREZZO, rcont.get_real(LVRCONDV_PREZDAN));
}
//se <20> una causale di ritirato e se sto ritirando una quantit<69> di merce diversa da zero, allora:
if (cau.is_ritiro() && !qta1.is_zero())
{
//leggo la casuale di magazzino associata al ritiro e il suo segno sul consegnato mese
const TCausale_magazzino& rit = cau.causale_ritiro();
const real sgnrit = rit.sgn(s_consmese);
//se movimenta il consegnato mese, cerco eventualmente una riga che possa essere raggruppata con quella
//che sto guardando adesso, altrimenti la creo; in ogni caso aggiungo la quantit<69> che sto ritirando moltiplicata
//per il suo segno al prezzo ricavato sopra o da contratto (o da magazzino), o da bolla
if (!sgnrit.is_zero())
{
TRiga_documento& rr = find_or_create_row(doc_out, rin, 'C');
rr.add(RDOC_QTA, sgnrit * qta1);
rr.put(RDOC_PREZZO, prezzo);
rr.add("TOTRIT", qta1);
}
}
//se <20> una causale di consegnato e se sto consegnando una quantit<69> di merce diversa da zero, allora:
if (cau.is_consegna() && !qta.is_zero())
{
//leggo la casuale di magazzino associata al ritiro e i suoi segni sul consegnato mese,
//sulla dotazione temporanea e sulla dotazione iniziale
const TCausale_magazzino& con = cau.causale_consegna();
const real sgntmp=con.sgn(s_dottm);
const real sgndotin=con.sgn(s_dotin);
const real sgncons=con.sgn(s_consmese);
//se movimenta la dotazione temporanea e <20> previsto l'addebito dotazione temporanea con prezzo diverso,
//cerco eventualmente una riga che possa essere raggruppata con quella che sto guardando adesso,
//altrimenti la creo; in ogni caso aggiungo la quantit<69> che sto consegnando moltiplicata
//per il suo segno al prezzo scritto sul contratto per la dotazine temporanea
if (!sgntmp.is_zero() && contr.get_bool(LVCONDV_DOTTMPPRZD))
{
TRiga_documento& rt = find_or_create_row(doc_out, rin, 'T');
rt.add(RDOC_QTA, sgntmp * qta);
rt.put(RDOC_PREZZO, rcont.get_real(LVRCONDV_PRZDTTMP));
}
//se movimenta la dotazione iniziale, cerco eventualmente una riga che possa essere raggruppata con quella
//che sto guardando adesso, altrimenti la creo; in ogni caso aggiungo la quantit<69> che sto consegnando moltiplicata
//per il suo segno al prezzo ricavato sopra o da contratto (o da magazzino), o da bolla
if (!sgndotin.is_zero() && !sgncons.is_zero())
{
TRiga_documento& rc = find_or_create_row(doc_out, rin, 'C');
rc.add(RDOC_QTA, sgndotin * qta);
rc.put(RDOC_PREZZO, prezzo);
}
else
{
//se movimenta il consegnato mese, cerco eventualmente una riga che possa essere raggruppata con quella
//che sto guardando adesso, altrimenti la creo; in ogni caso aggiungo la quantit<69> che sto consegnando moltiplicata
//per il suo segno al prezzo ricavato sopra o da contratto (o da magazzino), o da bolla
if (!sgncons.is_zero())
{
TRiga_documento& rc = find_or_create_row(doc_out, rin, 'C');
rc.add(RDOC_QTA, sgncons * qta);
rc.put(RDOC_PREZZO, prezzo);
rc.add("TOTRIT", qta1);
}
}
}
}
//ELABORA: metodo che esegue alcune operazioni prliminari, quali settare la data elaborazione e trovare i campi
//in base ai quali <20> possibile raggruppare le righe documetno, e poi chiama l'elaborazione standard per la fatturazione
bool TFatturazione_lavanderie::elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
const TDate& data_elab, bool interattivo)
{
_data_elab = data_elab;
campi_raggruppamento_righe(_campi_raggruppamento);
_output_rows_02.destroy();
return TFatturazione_bolle::elabora(doc_in, doc_out, data_elab, interattivo);
}
/////////////////////////////////
//// TFatturazione_msk ////
/////////////////////////////////
TFatturazione_msk::TFatturazione_msk():TAutomask("lv2500a")
{
//imposto il periodo di fatturazione dal primo del mese precedente all'ultimo del mese precedente
//se la data odierna <20> inferiore al 10 del mese corrente
//altrimenti la imposto dal primo del mese corrente alla data odierna
TDate data(TODAY);
if (data.day() <= 10)
{
data.addmonth(-1);
data.set_day(1);
set(F_DADATA, data);
data.set_end_month();
set(F_ADATA, data);
}
else
{
set(F_ADATA, data);
data.set_day(1);
set(F_DADATA, data);
}
if (main_app().argc() > 2)
{
TString16 tpela = main_app().argv(2);
tpela = tpela.mid(4);
TString8 codela = ini_get_string(CONFIG_DITTA, "lv", tpela);
set(F_COD_ELAB, codela);
field(F_COD_ELAB).check();
disable(F_COD_ELAB);
disable(F_DESC_ELAB);
}
}
/////////////////////////////////////
//// TFatturazione_lav_app ////
/////////////////////////////////////
//GENERA_BOLLE_NOLO: metodo che genera le fatture di solo nolo per quei clienti a cui non <20> stato consegnato niente
void TFatturazione_lav_app::genera_bolle_nolo(TAssoc_array& cliela, TFatturazione_lavanderie& elab, int& numdocgen)
{
TString4 codnum = ini_get_string(CONFIG_DITTA, "lv", "NUM_GEN");
TString4 tipodoc = ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_GEN");
char stato = cache().get("%TIP", tipodoc, "S2").mid(1,1)[0];
//preparo la query sui contratti
TString str;
str << "USE LVCONDV";
if (_msk->get_long(F_DACODCF) > 0)
str << "\nFROM CODCF=" << _msk->get_long(F_DACODCF);
if (_msk->get_long(F_ACODCF) > 0)
str << "\nTO CODCF=" << _msk->get_long(F_ACODCF);
TISAM_recordset contr(str);
TLista_documenti doc_in;
TLista_documenti doc_out;
TProgind pi(contr.items(), "Fatturazione", true, true);
for(bool ok = contr.move_first(); ok; ok = contr.move_next())
{
pi.set_text(TR("Elaborazione Nolo"));
if (!pi.addstatus(1))
break;
//scarto i contratti scaduti
if (contr.get(LVCONDV_DATASC).as_date().ok())
if (_msk->get_date(F_DADATA) <= contr.get(LVCONDV_DATAIN).as_date() || _msk->get_date(F_ADATA) >= contr.get(LVCONDV_DATASC).as_date())
continue;
//scarto tutti quelli che non sono in periodo di fatturazione corretto
if (contr.get(LVCONDV_PERFAT).as_int() > _msk->get_int(F_PERFAT))
continue;
// scarto i clienti sospesi
if (contr.get(LVCONDV_FATTSOSP).as_bool())
continue;
if(cliela.is_key(contr.get(LVCONDV_CODCF).as_string()))
continue;
TDocumento *pdoc= new TDocumento('D', _msk->get_date(F_DATAFAT).year(), codnum, 0);
doc_in.add(pdoc);
TDocumento& doc = *pdoc;
doc.put(DOC_TIPODOC, tipodoc);
doc.put(DOC_STATO, stato);
doc.put(DOC_TIPOCF, 'C');
TLaundry_contract contratto(contr.cursor()->curr());
const long codcf = contratto.get_long(LVCONDV_CODCF);
const int codcont = contratto.get_int(LVCONDV_CODCONT);
const bool fattnocons = !contratto.get_bool(LVCONDV_FORFNOCONS);
doc.put(DOC_CODCF, codcf);
TToken_string key("C");
key.add(codcf);
const TRectype& clifo = cache().get(LF_CLIFO, key);
const TString4 codpag = clifo.get(CLI_CODPAG);
const long codabi = clifo.get_long(CLI_CODABI);
const long codcab = clifo.get_long(CLI_CODCAB);
const TString80 iban = clifo.get(CLI_IBAN);
//recupero i dati di interesse dal file CFVEN
const TRectype& cfven = cache().get(LF_CFVEN, key);
const long codabipr = cfven.get_long(CFV_CODABIPR);
const long codcabpr = cfven.get_long(CFV_CODCABPR);
const bool ragdoc = cfven.get_bool(CFV_RAGGDOC);
const TString8 codag1 = cfven.get(CFV_CODAG1);
const TString4 codmez = cfven.get(CFV_CODSPMEZZO);
const TString4 codporto = cfven.get(CFV_CODPORTO);
const TString4 codnote1 = cfven.get(CFV_CODNOTESP1);
const TString4 codnote2 = cfven.get(CFV_CODNOTESP2);
const TString4 codnote = cfven.get(CFV_CODNOTE);
const TString8 codvet1 = cfven.get(CFV_CODVETT1);
const TString8 codvet2 = cfven.get(CFV_CODVETT2);
const TString8 codvet3 = cfven.get(CFV_CODVETT3);
const real speseinc = cfven.get_real(CFV_PERCSPINC);
const TString4 catven = cfven.get(CFV_CATVEN);
const bool addbolli = cfven.get_bool(CFV_ADDBOLLI);
const TString8 codlist = cfven.get(CFV_CODLIST);
const TString4 codzona = cfven.get(CFV_CODZONA);
//gestione sconto
TString sconto;
const char tpgest = ini_get_string(CONFIG_DITTA, "ve", "GESSCO")[0];
switch(tpgest)
{
case 'P': sconto = cfven.get(CFV_SCONTO); break; //Percentuale su anagrafica cliente
case 'T': sconto = cache().get("%SCC", cfven.get(CFV_CODSCC), "S1"); break; //Gestione tabella sconti
case 'A': //Gestione archivio sconti
{
TConfig ditta(CONFIG_DITTA, "ve");
TLocalisamfile sconti(LF_SCONTI);
sconti.put("TIPO", "I");
if(ditta.get_bool("SCOKEY", "ve", 1))
sconti.put("CODCAT", cfven.get(CFV_CATVEN));
TString16 cod;
if(ditta.get_bool("SCOKEY", "ve", 2))
cod.format("%-2s", (const char*)cfven.get(CFV_CODSCC));
else
cod = " ";
if(ditta.get_bool("SCOKEY", "ve", 3))
{
TString8 tmp;
tmp.format("%-2s", (const char*)cfven.get(CFV_CODZONA));
cod << tmp;
}
else
cod << " ";
if(ditta.get_bool("SCOKEY", "ve", 4))
cod << clifo.get(CLI_CODPAG);
sconti.put("CODART", cod);
if (sconti.read() == NOERR)
sconto = sconti.get("SCONTO");
}
case 'N': //sconto non gestito
default: break;
}
doc.put(DOC_CODPAG, codpag);
doc.put(DOC_CODABIA, codabi);
doc.put(DOC_CODCABA, codcab);
doc.put(DOC_IBAN, iban);
doc.put(DOC_CODABIP, codabipr);
doc.put(DOC_CODCABP, codcabpr);
doc.put(DOC_CODAGVIS, codag1);
doc.put(DOC_CODSPMEZZO, codmez);
doc.put(DOC_ZONA, codzona);
doc.put(DOC_CODPORTO, codporto);
doc.put(DOC_CODNOTESP1, codnote1);
doc.put(DOC_CODNOTESP2, codnote2);
doc.put(DOC_CODNOTE, codnote);
doc.put(DOC_CODVETT1, codvet1);
doc.put(DOC_CODVETT2, codvet2);
doc.put(DOC_CODVETT3, codvet3);
doc.put(DOC_CATVEN, catven);
doc.put(DOC_CODLIST, codlist);
doc.put(DOC_PERCSPINC, speseinc);
doc.put(DOC_ADDBOLLI, addbolli);
doc.put(DOC_SCONTOPERC, sconto);
TString str;
str << "USE LVRCONDV\n"
<< "FROM CODCF=" << codcf << " CODCONT=" << codcont << "\n"
<< "TO CODCF=" << codcf << " CODCONT=" << codcont;
TISAM_recordset rcont(str);
for(bool ok = rcont.move_first(); ok; ok = rcont.move_next())
{
TRectype& riga = rcont.cursor()->curr();
const int tipoforf = riga.get_int(LVRCONDV_TIPOFORF);
if (tipoforf > 0 &&
((tipoforf == 2) ||
(tipoforf != 2 && fattnocons)))
{
TRiga_documento& rdoc = doc.new_row("21");
rdoc.put(RDOC_CODART, riga.get(LVRCONDV_CODART));
rdoc.put(RDOC_CODARTMAG, riga.get(LVRCONDV_CODART));
rdoc.put(RDOC_QTA, UNO);
rdoc.put(RDOC_QTAGG1, UNO);
rdoc.put(RDOC_PREZZO, riga.get_real(LVRCONDV_PREZNOL));
rdoc.put(RDOC_CHECKED, true);
rdoc.put(RDOC_UMQTA, riga.get(LVRCONDV_UM));
TToken_string key;
key.add('C');
key.add(codcf);
TString8 codiva = cache().get(LF_CFVEN, key, CFV_ASSFIS);
if (codiva.blank())
codiva = cache().get(LF_ANAMAG, riga.get(LVRCONDV_CODART), ANAMAG_CODIVA);
rdoc.put(RDOC_CODIVA, codiva);
rdoc.put(RDOC_CODAGG1, ini_get_string(CONFIG_DITTA, "lv", "CAUSLAV"));
elab.set_perc_provv(rdoc);
elab.set_perc_provv(rdoc, false);
}
}
if (ini_get_bool(CONFIG_DITTA, "lv", "RifTest"))
elab.put("B15", true); //forzo la descrizione abbreviata
if (doc.physical_rows() > 0)
{
elab.elabora(doc_in, doc_out, _msk->get_date(F_DATAFAT));
int err = doc_out.write();
numdocgen += doc_out.items();
}
doc_out.destroy(-1);
doc_in.destroy(-1);
}
}
//CONTROLLI PRELIMINARI: metodo che si preoccupa di ferivicare la presenza in configurazione di tutti
//i dati necessari alla fatturazione
bool TFatturazione_lav_app::controlli_preliminari()
{
bool corretto = true;
//controllo se il tipo documento <20> configurato
if (ini_get_string(CONFIG_DITTA, "lv", "NUM_FAT").empty() || ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_FAT").empty())
{
warning_box(TR("Il Tipo documento fattura non <20> configurato correttamente"));
corretto = false;
}
//controllo se le causali di dafault sono configurate
if (ini_get_string(CONFIG_DITTA, "lv", "CAUSLAV").empty())
{
warning_box(TR("La causale di default non <20> configurata correttamente"));
corretto = false;
}
if (ini_get_string(CONFIG_DITTA, "lv", "CAULVRITDT").empty())
{
warning_box(TR("La causale di default non <20> configurata correttamente"));
corretto = false;
}
//controllo se l'articolo per il canone fisso <20> configurato
if (ini_get_string(CONFIG_DITTA, "lv", "Codartfix").empty())
{
warning_box(TR("L'articolo per canone fisso non <20> configurato correttamente"));
corretto = false;
}
//controllo se l'articolo per il raggruppamento <20> configurato
if (ini_get_string(CONFIG_DITTA, "lv", "Codartcafix").empty())
{
warning_box(TR("L'articolo per il raggruppamento non <20> configurato correttamente"));
corretto = false;
}
//controllo se l'articolo per il raggruppamento <20> configurato
if (ini_get_string(CONFIG_DITTA, "lv", "Codartcofix").empty())
{
warning_box(TR("L'articolo per il valore convenzionale non <20> configurato correttamente"));
corretto = false;
}
//controllo se l'unit<69> di misura per la fatturazioni a Kg <20> settata
if(ini_get_string(CONFIG_DITTA, "lv", "UmKg").empty())
{
warning_box(TR("L'unit<69> di misura per la fatturazione a Kg non <20> configurata correttamente"));
corretto = false;
}
return corretto;
}
bool TFatturazione_lav_app::copy_file(const TFilename& src, const TFilename& dst) const
{
// Crea la cartella di destinazione se necessario
const char* dstdir = dst.path();
if (*dstdir && !xvt_fsys_mkdir(dstdir))
return error_box(FR("Impossibile creare la cartella %s"), dst.path());
// Copia veramente il file
return ::fcopy(src, dst);
}
bool TFatturazione_lav_app::copy_tree(const char* src_study, const char* dst_study) const
{
xvt_fsys_save_dir();
TFilename mask(src_study); mask.add("*.");
SLIST dlist = xvt_fsys_list_files(DIR_TYPE, mask, TRUE);
xvt_fsys_restore_dir();
TProgind pd(xvt_slist_count(dlist), TR("Copia cartelle"), true, true);
TString msg; // Messaggio di progresso
bool go_on = true;
for (SLIST_ELT d = xvt_slist_get_first(dlist); d && go_on; d = xvt_slist_get_next(dlist, d))
{
if (!pd.addstatus(1))
{
go_on = false;
break;
}
const TFilename dir = xvt_slist_get(dlist, d, NULL);
TString name = dir.name(); name.lower();
if (name == "cesp") // Ignora la vetusta cartella Cespiti in FoxPro
continue;
msg.cut(0) << TR("Copia di ") << name;
pd.set_text(msg);
mask = dir; mask.add("*.*");
TString_array files; list_files(mask, files);
TProgind pi(files.items(), "Copia file", true, true);
TFilename dst;
FOR_EACH_ARRAY_ROW(files, i, f)
{
if (!pi.addstatus(1))
{
go_on = false;
break;
}
TFilename src(*f);
TString16 ext(src.ext()); ext.lower();
if (ext != "zip" && ext != "rar" && ext != "mdb" && ext != "inf")
{
msg.cut(0) << TR("Copia di ") << src;
pi.set_text(msg);
dst = dst_study;
dst.add(name);
dst.add(src.name());
copy_file(src, dst);
}
}
}
xvt_slist_destroy(dlist);
return go_on;
}
void TFatturazione_lav_app::main_loop()
{
bool prova = false;
if (main_app().argc() > 2)
{
TString16 tpela = main_app().argv(2);
tpela = tpela.mid(4);
prova = (tpela == "FatPro");
}
//instanzio la maschera
_msk = new TFatturazione_msk();
_msk->show(F_SAVEDATA, lv_is_02_active());
//instanzio i localisamfile che mi servono
TLocalisamfile doc(LF_DOC);
TLocalisamfile rdoc(LF_RIGHEDOC);
while (_msk->run()!= K_QUIT)
{
if (!controlli_preliminari())
{
TString str;
str << "Prima di poter eseguire la fatturazione <20> necessario correggre tutti gli errori segnalati. "
<< "Si prega di controllare i dati di configurazione";
warning_box(str);
return;
}
if (_msk->get_bool(F_SAVEDATA))
{
TFilename src = firm2dir(-1);
TFilename dst = ini_get_string(CONFIG_DITTA, "lv", "Backup");
copy_tree(src, dst);
}
//leggo i dati di primo interesse
const TString4 mskzona = _msk->get(F_CODZONA);
const TString4 mskcat = _msk->get(F_CODCATC);
//preparo le date estremi (dal - al) della query e l'anno dell'esercizio
TDate al = _msk->get_date(F_ADATA);
//se la data "al" non <20> corretta, la pongo uguale alla data fattura
if (!al.ok())
al = _msk->get_date(F_DATAFAT);
const long year = al.year();
TDate dal = _msk->get_date(F_DADATA);
//se la data "dal" non <20> corretta, la pongo uguale a 1/1/annoes
if (!dal.ok())
{
dal.set_day(1);
dal.set_month(1);
dal.set_year(year);
}
//instanzio una TFatturaziome_lavanderie
TFatturazione_lavanderie elab(_msk->get(F_COD_ELAB), prova);
//preparo le variabili di interesse
TLista_documenti docsin;
TLista_documenti docsout;
long lastcli = 0;
const int period = _msk->get_int(F_PERFAT);
const TDate datafat = _msk->get_date(F_DATAFAT);
long indsped;
//preparo la query
TString query;
//&&(BETWEEN(DATADOC,#DADATA,#ADATA))&&(STATO==\"2\")&&(TIPODOC==\"B01\")
query << "USE DOC KEY 3 SELECT (TIPOCF==\"C\")&&"
<< "(BETWEEN(CODCF," << _msk->get_long(F_DACODCF) << ',' << _msk->get_long(F_ACODCF) << "))\n"
<< "BY TIPOCF CODCF DATADOC\n"
<< "FROM DATADOC=" << dal << " PROVV=D ANNO=" << year << "\n"
<< "TO DATADOC=" << al << " PROVV=D ANNO=" << year << "\n";
// query << "USE DOC KEY 2 SELECT BETWEEN(DATADOC,#DADATA,#ADATA)&&STATO==\"2\")&&(TIPODOC==\"B01\")\n"
// << "FROM " << "TIPOCF=C PROVV=D ANNO=#ANNO DATADOC=#DADATA \n"
// << "TO " << "TIPOCF=C PROVV=D ANNO=#ANNO DATADOC=#ADATA \n";
//instanzio il recordset
TISAM_recordset recset(query);
TProgind pi(recset.items(), "Fatturazione", true, true);
long last_clifo = 0;
int numdocgen = 0;
//TAssoc_array dei clienti per cui ho generato dei documenti
TAssoc_array cliela;
//scorro tutti documenti che la query mi restiuisce
for (bool ok = recset.move_first(); ok; ok = recset.move_next())
{
//leggo il codcf
const long clifo = recset.get(DOC_CODCF).as_int();
if (clifo != last_clifo)
{
TString80 str;
str << TR("Elaborazione Cliente ") << clifo;
pi.set_text(str);
last_clifo=clifo;
}
if (!pi.addstatus(1))
break;
//se non <20> l'ultimo cliente, allora:
if (clifo != lastcli)
{
//se effettivamente devo elaborare delle bolle per questo cliente, allora:
if (docsin.items()!= 0)
{
//elaboro tutti i documenti, li salvo nei file di Campo e svuoto le TList_file
elab.put("B15", 'X');
elab.elabora(docsin, docsout, datafat);
const int items = docsout.items();
if (items > 0)
{
docsout.write();
numdocgen += items;
TString tmp;
tmp << lastcli;
cliela.add(tmp, tmp);
}
docsout.destroy(-1);
docsin.rewrite();
docsin.destroy(-1);
}
lastcli = clifo;
}
//preparo la chiave e recupero da CFVEN i dati di quel cliente
TToken_string key;
key.add('C');
key.add(clifo);
const TRectype& clienti = cache().get(LF_CFVEN,key);
//se il documento che sto analizzando <20> corretto, allora:
bool cliok = elab.is_document_ok(recset.cursor()->curr());
if (cliok)
{
//se il codice di zona <20> pieno, allora:
if (mskzona.full())
{
//leggo il codice di zona standard di quel cliente e lo confronto con quello della mascera (V o F)
const TString& codzona = clienti.get(CFV_CODZONA);
cliok = (codzona == mskzona);
}
//se il codice categoria economica <20> pieno e ho passato il test sul codice di zona, allora:
if (cliok && mskcat.full())
{
//leggo il codice categoria economica standard di quel cliente e lo confronto con quello della mascera (V o F)
const TString& codcat = clienti.get(CFV_CODCATC);
cliok = (codcat == mskcat);
}
}
//se ho passato tutti e due i test, allora:
if (cliok)
{
//cerco sul contratto qual'<27> il periodo di fatturazione di quel cliente
indsped = recset.get(DOC_CODINDSP).as_int();
TLaundry_contract contr(clifo, indsped, datafat);
const int contrper = contr.get_int(LVCONDV_PERFAT);
//se il cliente non <20> sospeso e se si <20> nel periodo di fatturazione giusto, aggiungo il documento alla
//lista dei documetni da elaborare
if (!contr.get_bool(LVCONDV_FATTSOSP) && contrper <= period)
docsin.add(new TDocumento(recset.cursor()->curr()));
}
}
//se ho dei documenti in lista li elaboro e poi svuoto le TList_file
if (docsin.items() != 0)
{
if (ini_get_bool(CONFIG_DITTA, "lv", "RifTest"))
elab.put("B15", true); //forzo la descrizione abbreviata
elab.elabora(docsin, docsout, datafat);
const int items = docsout.items();
if (items > 0)
{
docsout.write();
numdocgen += items;
TString tmp;
tmp << lastcli;
cliela.add(tmp, tmp);
}
docsout.destroy(-1);
docsin.rewrite();
docsin.destroy(-1);
}
genera_bolle_nolo(cliela, elab, numdocgen);
numdocgen += elab.write_fatt_ragg();
TString str;
if (numdocgen > 1 || numdocgen == 0)
str << "Sono state generate " << numdocgen << " fatture";
else
str << "E' stata generata " << numdocgen << " fattura";
message_box(str);
message_box(TR("Elaborazione terminata"));
}
}
int lv2500(int argc, char *argv[])
{
TFatturazione_lav_app a;
a.run (argc, argv, "Fatturazione lavanderie");
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink