diff --git a/ve/ve1100.cpp b/ve/ve1100.cpp index 474c8a5c5..b6d6578e4 100755 --- a/ve/ve1100.cpp +++ b/ve/ve1100.cpp @@ -3,16 +3,11 @@ ////////////////////////////////////////////////////////////// #include - -#include #include -#include -#include #include #include #include #include -#include #include "velib.h" #include "sconti.h" diff --git a/ve/ve1200.cpp b/ve/ve1200.cpp index 209ed0b8b..2fe59cf42 100755 --- a/ve/ve1200.cpp +++ b/ve/ve1200.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include diff --git a/ve/velib02.cpp b/ve/velib02.cpp index 8dc07d29b..a3220accd 100755 --- a/ve/velib02.cpp +++ b/ve/velib02.cpp @@ -216,7 +216,7 @@ TRiga_documento::TRiga_documento(const TRiga_documento& rec, TDocumento* doc, const TTipo_riga_documento& TRiga_documento::tipo() const { - const TString16 tiporig(get(RDOC_TIPORIGA)); + const TString4 tiporig(get(RDOC_TIPORIGA)); CHECK(tiporig.not_empty(), "Tipo riga documento nullo"); TTipo_riga_documento* o = (TTipo_riga_documento*)_tipi.objptr(tiporig); if (o == NULL) diff --git a/ve/velib03.cpp b/ve/velib03.cpp index ee0054cc1..226335c39 100755 --- a/ve/velib03.cpp +++ b/ve/velib03.cpp @@ -1444,7 +1444,7 @@ const TTipo_documento& TDocumento::tipo(const char * tipodoc) const TTipo_documento& TDocumento::tipo() const { - const TString16 tipodoc(get("TIPODOC")); + const TString4 tipodoc(get("TIPODOC")); return tipo(tipodoc); } diff --git a/ve/velib03a.cpp b/ve/velib03a.cpp index fed3e7c32..51fca4038 100755 --- a/ve/velib03a.cpp +++ b/ve/velib03a.cpp @@ -3,6 +3,8 @@ #include "velib.h" #include "vepriv.h" +#include "../mg/mglib.h" + ///////////////// ////////////////////////////////////////// // Tipo documento /////////////////////////////////////////////////////////// diff --git a/ve/velib04.cpp b/ve/velib04.cpp index 29902b4c0..3e5007fd9 100755 --- a/ve/velib04.cpp +++ b/ve/velib04.cpp @@ -1,11 +1,7 @@ #include -#include -#include "velib.h" #include "velib04.h" -#include - /////////////////////////////////////////////////////////// // Lista di documenti /////////////////////////////////////////////////////////// @@ -185,12 +181,14 @@ TElaborazione::TElaborazione(const char* cod) : TRectype(LF_TABCOM) int TElaborazione::read(const char* cod) { - CHECK(cod && *cod, "Codice elaborazione nullo"); - TTable eld("%ELD"); - put("CODTAB", cod); - const int err = TRectype::read(eld); - if (err != NOERR) + int err = NOERR; + + *this = cache().get("%ELD", cod); + if (empty()) + { yesnofatal_box("Codice elaborazione non valido: %s", cod); + err = _iskeynotfound; + } return err; } diff --git a/ve/velib04.h b/ve/velib04.h index d1e77d471..a4a4b7815 100755 --- a/ve/velib04.h +++ b/ve/velib04.h @@ -5,6 +5,11 @@ #include "velib.h" #endif +#ifndef __CALIB01_H +#include "../ca/calib01.h" +#endif + + class TLista_documenti : public TObject // velib04 { TArray _documenti; @@ -18,12 +23,12 @@ public: TToken_string& tipidoc, TToken_string& statidoc, const TDate& dd, const TDate& ad, const char* codnum = "", long dn = 0L, long an = 0L); - int write(bool re = FALSE) const; - int rewrite() const { return write(TRUE); } + int write(bool re = false) const; + int rewrite() const { return write(true); } int add(TDocumento* doc) { return _documenti.add(doc); } int add(const TDocumento& doc) { return _documenti.add(doc); } - int destroy(int i, bool pack = TRUE) { return _documenti.destroy(i, pack); } + int destroy(int i, bool pack = true) { return _documenti.destroy(i, pack); } const TDocumento& operator[] (int n) const { return doc(n); } TDocumento& operator[] (int n) { return (TDocumento&)_documenti[n]; } @@ -100,7 +105,7 @@ public: TParametri_elaborazione & params() { return _parms;} virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, - const TDate& data_elab, bool interattivo = FALSE) pure; + const TDate& data_elab, bool interattivo = false) pure; TElaborazione(const char* cod); TElaborazione(const TRectype& rec) : TRectype(rec) { } @@ -111,7 +116,7 @@ class TElaborazione_esterna : public TElaborazione // velib04 { public: virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, - const TDate& data_elab, bool interattivo = FALSE); + const TDate& data_elab, bool interattivo = false); TElaborazione_esterna(const char* cod); TElaborazione_esterna(const TRectype& rec) : TElaborazione(rec) { } @@ -127,7 +132,7 @@ protected: public: virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, - const TDate& data_elab, bool interattivo = FALSE); + const TDate& data_elab, bool interattivo = false); TConsegna_ordini(const char* cod) : TElaborazione(cod) { } TConsegna_ordini(const TRectype& rec) : TElaborazione(rec) { } @@ -141,7 +146,7 @@ class TFatturazione_bolle : public TElaborazione // velib04a public: virtual bool raggruppa(TDocumento& din, TDocumento& dout); virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, - const TDate& data_elab, bool interattivo = FALSE); + const TDate& data_elab, bool interattivo = false); void tipi_validi(TToken_string& tipi) const; void stati_validi(TToken_string& stati) const; @@ -249,11 +254,11 @@ public: class TContabilizzazione : public TElaborazione // velib04b { bool _auto_data; // Flag per data di registrazione automatica - bool _nump_iva; // se TRUE prende il numero protocollo da registro iva, se no prende il numero protocollo dal numero doc. + bool _nump_iva; // se true prende il numero protocollo da registro iva, se no prende il numero protocollo dal numero doc. TDate _data_reg; // Data di registrazione documenti long _total_docs;// Numero di documenti contabilizzati error_type _error; // Errore rilevato durante l'elaborazione - bool _can_write; // se TRUE e' abilitata la scrittura. Non appena rileva un errore rimane a FALSE for this instance + bool _can_write; // se true e' abilitata la scrittura. Non appena rileva un errore rimane a false for this instance TString16 _spin_cod, // codice iva spese d'incasso _spbo_cod; // codice iva spese bolli TAssoc_array _totali_lordi;// array per totalizzare i lordi per aliquota, al fine di aggiustare gli imponibili @@ -354,9 +359,9 @@ protected: void display_error(TDocumento&); // Verifica se non ci sono stati errori bool good() const { return _error == no_error;} - // Ritorna TRUE se il saldaconto e' abilitato (verifica anche la causale del documento corrente) + // Ritorna true se il saldaconto e' abilitato (verifica anche la causale del documento corrente) bool sc_enabled() const ; - // Ritorna TRUE se il modulo INTRA e' abilitato (verifica anche la causale del documento corrente) + // Ritorna true se il modulo INTRA e' abilitato (verifica anche la causale del documento corrente) bool in_enabled() const ; // Controlla se il tipo riga esiste bool valid_row_type(const char* rt) const; @@ -364,7 +369,7 @@ public: // Cambia lo stato del documento error_type change_doc_status(TDocumento&); virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, - const TDate& data_elab, bool interattivo = FALSE); + const TDate& data_elab, bool interattivo = false); void set_auto(const bool a) { _auto_data = a; } void set_writeable(const bool b) { _can_write = b; } const long processed_docs() const { return _total_docs; } @@ -376,7 +381,7 @@ public: // Personalizzazioni bool call_exe(const TDocumento& doc, const TMovimentoPN& movimento) const; - // Ritorna TRUE se il documento precedente a doc e' gia' stato contabilizzato + // Ritorna true se il documento precedente a doc e' gia' stato contabilizzato bool prev_contabilized(const TDocumento& doc) const; TContabilizzazione(const char* cod); @@ -389,7 +394,7 @@ class TCopia_documento : public TElaborazione // velib04 { public: virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, - const TDate& data_elab, bool interattivo = FALSE); + const TDate& data_elab, bool interattivo = false); TCopia_documento(const char* cod); TCopia_documento(const TRectype& rec) : TElaborazione(rec) { } @@ -401,7 +406,7 @@ class TGenerazione_effetti : public TElaborazione // velib04c { error_type _error; // Errore rilevato durante l'elaborazione long _total_bills; // Totale effetti generati - bool _can_write; // se TRUE e' abilitata la scrittura. Non appena rileva un errore rimane a FALSE for this instance + bool _can_write; // se true e' abilitata la scrittura. Non appena rileva un errore rimane a false for this instance TBit_array _valid_array; // array dei tipi di pagamento validi per la generazione di effetti TLocalisamfile *_efffile, // file effetti @@ -417,7 +422,7 @@ class TGenerazione_effetti : public TElaborazione // velib04c protected: // Visualizza l'ultimo errore rilevato void display_error(TDocumento& doc); - // Restituisce TRUE se il tipo di pagamento passato e' valido per generare l'effetto + // Restituisce true se il tipo di pagamento passato e' valido per generare l'effetto bool valid_type(int) const ; // Genera l'effetto void generate_bill(TDocumento&); @@ -433,7 +438,7 @@ protected: bool good() const { return _error == no_error;} public: virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, - const TDate& data_elab, bool interattivo = FALSE); + const TDate& data_elab, bool interattivo = false); // Effettua il raggruppamento vero e proprio degli effetti (solo se ci sono elementi nell'assoc_array passato) long group_bills(TAssoc_array&); @@ -453,23 +458,34 @@ protected: public: virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, - const TDate& data_elab, bool interattivo = FALSE); + const TDate& data_elab, bool interattivo = false); TConsuntivazione_produzione(const char* cod) : TElaborazione(cod) { } TConsuntivazione_produzione(const TRectype& rec) : TElaborazione(rec) { } virtual ~TConsuntivazione_produzione() { } }; -class TContabilizzazione_analitica : public TContabilizzazione // velib04b +class TContabilizzazione_analitica : public TElaborazione // velib04b { + error_type _error; // Errore rilevato durante l'elaborazione + +protected: + error_type search_costo_ricavo(const TRiga_documento& riga, TBill& conto); + bool find_conti(const TRiga_documento& riga, TString_array& conti); + + const TCausale& doc2caus(const TDocumento& doc); + const TCausale& rdoc2caus(const TRiga_documento& rdoc); + + void init_distrib(TString_array& conti, TGeneric_distrib& distrib); + public: virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, - const TDate& data_elab, bool interattivo = FALSE); - bool elabora(const TDocumento& doc_in, const TImporto& totdoc); + const TDate& data_elab, bool interattivo = false); + bool elabora(const TDocumento& doc, long numreg_cg, TViswin* viswin, bool can_write); - TContabilizzazione_analitica(const char* cod) : TContabilizzazione(cod) { } - TContabilizzazione_analitica(const TRectype& rec) : TContabilizzazione(rec) { } - virtual ~TContabilizzazione_analitica() { } + TContabilizzazione_analitica(); + TContabilizzazione_analitica(const TRectype& rec); + virtual ~TContabilizzazione_analitica(); }; #endif diff --git a/ve/velib04b.cpp b/ve/velib04b.cpp index 8e2a6fbd7..8603300c8 100755 --- a/ve/velib04b.cpp +++ b/ve/velib04b.cpp @@ -895,15 +895,14 @@ bool TContabilizzazione::load_parameters() // return true; TConfig conf(CONFIG_DITTA, "ve"); - - _search_seq = new TToken_string((const char*)conf.get("RICERCACR","ve")); + _search_seq = new TToken_string(conf.get("RICERCACR")); // costruisce la stringa che controlla la ricerca del conto costo/ricavo // Attenzione! non esegue alcun controllo di consistenza sulla corretta sequenza // presuppone che il programma di configurazione abbia generato correttamente // il tutto. - if (_search_seq->items() == 0) + if (_search_seq->empty_items()) { error_box("Non e' abilitata alcuna ricerca per il conto di costo/ricavo in configurazione."); return false; @@ -2144,14 +2143,10 @@ bool TContabilizzazione::valid_row_type(const char* rt) const error_type TContabilizzazione::compile_rows_mov(TDocumento& doc) // Compila le righe { - TString16 tiporiga, codiva1, codiva2; - const int rows = doc.rows(); - const int ndec = doc.decimals(); const bool fat_com = doc.tipo().fattura_commerciale(); static TString_array tabella_ripartizione; - - if (fat_com && tabella_ripartizione.items() == 0) + if (fat_com && tabella_ripartizione.empty()) { TConfig cnf(CONFIG_STUDIO); for (int k = 1; k <= MAX_IVA_SLICES; k++) @@ -2165,16 +2160,17 @@ error_type TContabilizzazione::compile_rows_mov(TDocumento& doc) _righe_iva->destroy(); // resetta l'assoc_array delle righe di iva _totali_lordi.destroy();// resetta l'assoc_array dei totali lordi + + const int rows = doc.rows(); for (int i=1; good() && i<=rows; i++) // browse all this fucked document rows { TRiga_documento& r = doc[i]; - tiporiga = r.get(RDOC_TIPORIGA); + const TString4 tiporiga = r.get(RDOC_TIPORIGA); if (valid_row_type(tiporiga)) // controlla l'esistenza della riga { - TBill conto; const char tipo = r.tipo().tipo(); // Le righe omaggio senza addebito IVA vanno saltate - const bool riga_omaggio = r.get_bool(RDOC_ADDIVA) && tipo == 'O'; + const bool riga_omaggio = tipo == 'O' && r.get_bool(RDOC_ADDIVA); if ((tipo != RIGA_DESCRIZIONI && tipo != RIGA_SCONTI) || riga_omaggio) { const bool spesa = r.tipo().tipo() == RIGA_SPESEDOC; @@ -2188,18 +2184,19 @@ error_type TContabilizzazione::compile_rows_mov(TDocumento& doc) const bool ritenuta = tipo_rit != '\0' && !_caus->intra(); + TBill conto; if (!ritenuta) search_costo_ricavo(conto,r); // l'errore eventuale viene settato qui dentro if (good()) { if (fat_com) { - codiva2 = r.get(RDOC_CODIVA); // Save... + const TString4 codiva2 = r.get(RDOC_CODIVA); // Save... for (int j=0; j < MAX_IVA_SLICES; j++) { const real perc = real(tabella_ripartizione.row(j).get(0)) / CENTO; - codiva1 = tabella_ripartizione.row(j).get(1); - if (perc == ZERO || codiva1.trim().empty()) + const TString4 codiva1 = tabella_ripartizione.row(j).get(1); + if (perc == ZERO || codiva1.blank()) continue; r.put(RDOC_CODIVA, codiva1); @@ -2243,11 +2240,11 @@ error_type TContabilizzazione::compile_rows_mov(TDocumento& doc) _righe_iva->add_omaggi(r, conto); else _righe_iva->add(r, conto); - const TString16 cod(r.get(RDOC_CODIVA)); if (r.doc().tipo().calcolo_lordo()) // Si ricorda che calcolo_lordo() e fattura_commerciale() sono esclusivi. { - // Totalizza per ogni codice iva il lordo + // Totalizza per ogni codice iva il lordo + const TString& cod = r.get(RDOC_CODIVA); if (!_totali_lordi.is_key(cod)) _totali_lordi.add(cod, new real); real& rl = (real&) _totali_lordi[cod]; @@ -2261,12 +2258,12 @@ error_type TContabilizzazione::compile_rows_mov(TDocumento& doc) _error = row_type_error; } - if (good() && _righe_iva->items() == 0) + if (good() && _righe_iva->empty()) _error = no_rows_error; // Crea le righe per le spese d'incasso e bolli if (good()) - add_spese_inbo(doc,ndec); + add_spese_inbo(doc, doc.decimals()); // Aggiorna le righe di sconto (sconto ad importo o percentuale) if (good()) @@ -2322,21 +2319,20 @@ error_type TContabilizzazione::compile_rows_mov(TDocumento& doc) error_type TContabilizzazione::compile_rows_mov_re(TDocumento& doc) // Compila le righe { - TString16 tiporiga, codiva1, codiva2; const int rows = doc.rows(); const int ndec = doc.decimals(); _righe_iva->destroy(); // resetta l'assoc_array delle righe di iva for (int i=1; good() && i<=rows; i++) // browse all this fucked document rows { - TRiga_documento & r = doc[i]; - tiporiga = r.get(RDOC_TIPORIGA); + const TRiga_documento& r = doc[i]; + const TString4 tiporiga = r.get(RDOC_TIPORIGA); if (valid_row_type(tiporiga)) // controlla l'esistenza della riga { TBill conto; const char tipo = r.tipo().tipo(); // Le righe omaggio senza addebito IVA vanno saltate - const bool riga_omaggio = r.get_bool(RDOC_ADDIVA) && tipo == 'O'; + const bool riga_omaggio = tipo == 'O' && r.get_bool(RDOC_ADDIVA); if ((tipo != 'D' && tipo != 'C') && !riga_omaggio) { search_costo_ricavo(conto,r); // l'errore eventuale viene settato qui dentro @@ -3487,23 +3483,22 @@ error_type TContabilizzazione::write_anal(const TDocumento& doc, const TMoviment return _error; } - bool is_anal = false; - TImporto totanal; + bool has_anal_bill = false; for (int i = movimento.cg_items(); i > 0; i--) { const TRectype& cgrow = movimento.cg_rows().row(i); const TBill bill(cgrow); if (bill.is_analitico()) { - const TImporto imp(cgrow.get_char(RMV_SEZIONE), cgrow.get_real(RMV_IMPORTO)); - totanal += imp; - is_anal = true; + has_anal_bill = true; + break; } } - if (is_anal) + if (has_anal_bill) { - TContabilizzazione_analitica canal(NULL); - canal.elabora(doc, totanal); + TContabilizzazione_analitica canal; + const long numreg_cg = movimento.curr().get_long(MOV_NUMREG); + canal.elabora(doc, numreg_cg, _viswin, _can_write); } return _error; @@ -3839,7 +3834,7 @@ bool TContabilizzazione::elabora(TLista_documenti& doc_in, TLista_documenti& doc const bool ft_em_ric = num.fattura_emettere_ricevere(); if (good()) - { + { if (ft_em_ric) { diff --git a/ve/velib04f.cpp b/ve/velib04f.cpp index c7bf74030..941b3f8fb 100755 --- a/ve/velib04f.cpp +++ b/ve/velib04f.cpp @@ -1,21 +1,437 @@ +#include +#include + #include "velib04.h" -bool TContabilizzazione_analitica::elabora(const TDocumento& doc, const TImporto& totdoc) +#include "../ca/movana.h" +#include "../ca/rmovana.h" +#include "../ca/rrip.h" +#include "../mg/anamag.h" + + +class TCache_causali : public TCache { - // Scandisco le righe, saltando descrizioni e sconti +protected: + TObject* key2obj(const char* key); + +public: + const TCausale& causale(const TDocumento& doc); + TCache_causali() : TCache(17) { } +}; + +TObject* TCache_causali::key2obj(const char* key) +{ + return new TCausale(key); +} + +const TCausale& TCache_causali::causale(const TDocumento& doc) +{ + // Cerca il codice causale sul cliente + TToken_string key; + key.add(doc.get(DOC_TIPOCF)); + key.add(doc.get(DOC_CODCF)); + const TRectype& cfven = cache().get(LF_CFVEN, key); + const char* fld = doc.is_nota_credito() ? CFV_CODCAUSNC : CFV_CODCAUS; + TString4 codcaus = cfven.get(fld); + + // Se non lo trova guarda sul tipo documento + if (codcaus.empty()) + { + const TTipo_documento& tipo = doc.tipo(); + codcaus = tipo.causale(); + } + + // Trasforma il codice in causale vera e propria + return (const TCausale&)*objptr(codcaus); +} + + +/////////////////////////////////////////////////////////// +// TContabilizzazione_analitica +/////////////////////////////////////////////////////////// + +static TCache_ripartizioni _rip; +static TToken_string _search_seq; + +const TCausale& TContabilizzazione_analitica::doc2caus(const TDocumento& doc) +{ + static TCache_causali _caus; + return _caus.causale(doc); +} + +const TCausale& TContabilizzazione_analitica::rdoc2caus(const TRiga_documento& rdoc) +{ + return doc2caus(rdoc.doc()); +} + +// Copiata dalla contabilizzazione ed eliminati riferimenti a tutte le variabili globali del cazzo +error_type TContabilizzazione_analitica::search_costo_ricavo(const TRiga_documento& r, TBill& conto) +{ + if (_search_seq.blank()) + { + TConfig conf(CONFIG_DITTA, "ve"); + _search_seq = conf.get("RICERCACR"); + } + const int items = _search_seq.items(); + + TToken_string clifo_key; + clifo_key.format("%c|%ld", r.doc().get_char(DOC_TIPOCF), r.doc().get_long(DOC_CODCF)); + const TRectype& cli_file = cache().get(LF_CLIFO, clifo_key); + + const bool is_cli = cli_file.get(CLI_TIPOCF) != 'F'; + bool skip_art_related = false; + bool skip_clifo = !cli_file.empty(); + + const TCodiceIVA codiva(r.get(RDOC_CODIVA)); + const char t = r.tipo().tipo(); + + switch (t) + { + case 'O': // righe omaggio come articoli spiaccicato identico (avranno imponibile 0) + case 'M': // righe di merce + { + // posiziona l'anagrafica sull'articolo specificato sulla ..iga + const TRectype& anamag = cache().get(LF_ANAMAG, r.get(RDOC_CODARTMAG)); + if (anamag.empty()) // se non trova l'articolo saltera' anche gmc,smc,rfa. + skip_art_related = true; + + TString16 tok; + // Scorre la stringa di ricerca + for (int i=0; _error == no_error && i 3) + codtab.cut(3); // gli ultimi 2 si riferiscono al sottogruppo. + const TRectype& tab = cache().get(is_fis ? "RFA" : "GMC", codtab); + if (!tab.empty()) + { + const int gr = tab.get_int(is_cli ? "I3" : "I0"); + const int co = tab.get_int(is_cli ? "I4" : "I1"); + const long so = tab.get_long(is_cli ? "I5" : "I2"); + conto.set(gr,co,so); + } + if (conto.ok()) + break; + } + else + if (tok == "CV" || tok == "CC") + { + const bool is_cve = tok == "CV"; + if (is_cve && !is_cli) + continue; // se e' un fornitore salta questa condizione + TString16 cod = is_cve ? r.doc().get(DOC_CATVEN) : EMPTY_STRING; + if (cod.empty()) + { + if (skip_clifo) + continue; // se non aveva trovato il cliente salta al prossimo + + const TRectype& cfven = cache().get(LF_CFVEN, clifo_key); + cod = cfven.get(is_cve ? CFV_CATVEN : CFV_CODCATC); + } + const TRectype& t = cache().get(is_cve ? "CVE" : "CCO", cod); + if (!t.empty()) + { + const bool x =(is_cve || is_cli); + const int gr = t.get_int(x ? "I3" : "I0"); + const int co = t.get_int(x ? "I4" : "I1"); + const long so = t.get_long(x ? "I5": "I2"); + conto.set(gr,co,so); + } + if (conto.ok()) + break; + } + } + break; // case 'M' + } + case 'P': // righe prestazione + case 'S': // righe spese + { + const TRectype& tab = cache().get('P' ? "PRS" : "SPP", r.get(RDOC_CODART)); + if (!tab.empty()) + { + int gr = tab.get_int(is_cli ? "I0" : "I3"); + int co = tab.get_int(is_cli ? "I1" : "I4"); + long so = tab.get_long(is_cli ? "I2" : "I5"); + conto.set(gr,co,so); + if (!is_cli && !conto.ok()) + { + gr = r.get_int("QTAGG1"); + co = r.get_int("QTAGG2"); + so = r.get_long("QTAGG3"); + conto.set(gr,co,so); + } + } + + if (t == 'P' && !conto.find()) // Cerca il conto nella stringa di ricerca (solo per prestazioni) + { + TString16 tok; + // Scorre la stringa di ricerca ma solo per causale o CLI/FO + for (int i=0; _error == no_error && iget(4); + if (slice <= ZERO) + slice = UNO; + distrib.add(slice); + } +} + +bool TContabilizzazione_analitica::elabora(const TDocumento& doc, long numreg_cg, TViswin* viswin, bool can_write) +{ + TAnal_mov* mov = NULL; + + TDate datareg, datacomp; + int annoes = 0; + TString descr; + + if (numreg_cg > 0) + { + const TRectype& mov_cg = cache().get(LF_MOV, numreg_cg); + datareg = mov_cg.get_date(MOV_DATAREG); + datacomp = mov_cg.get_date(MOV_DATACOMP); + annoes = mov_cg.get_int(MOV_ANNOES); + descr = mov_cg.get(MOV_DESCR); + } + else + { + datareg = datacomp = TDate(TODAY); + annoes = datareg.year(); + } + + const int decimals = TCurrency::get_firm_dec(); + + // Scandisco le righe del documento, for (int i = 1; i <= doc.physical_rows(); i++) { const TRiga_documento& riga = doc[i]; + + // salto descrizioni, sconti e omaggi if (riga.is_descrizione() || riga.is_sconto() || riga.is_omaggio()) continue; - const TRectype& anamag = cache().get(LF_ANAMAG, riga.get(RDOC_CODARTMAG)); + // salto valori nulli + const real valore = riga.valore(true, decimals); + if (valore.is_zero()) + continue; - TBill bill; - if (search_costo_ricavo(bill, riga) != no_error) - break; + TString_array conti; + bool ok = find_conti(riga, conti); + + if (conti.empty()) + { + if (viswin != NULL) + { + TString msg; + msg.format(FR("*** Impossibile determinare il conto analitico per l'articolo: '%s'"), (const char*)riga.get(RDOC_CODART)); + viswin->add_line(msg); + } + continue; + } + + if (can_write) + { + TGeneric_distrib esso(valore, decimals); + init_distrib(conti, esso); + FOR_EACH_ARRAY_ROW(conti, i, row) + { + if (mov == NULL) + { + mov = new TAnal_mov; + mov->put(MOVANA_DATAREG, datareg); + mov->put(MOVANA_DATACOMP, datacomp); + mov->put(MOVANA_ANNOES, annoes); + mov->put(MOVANA_NUMREGCG, numreg_cg); + mov->put(MOVANA_DESCR, descr); + } + TRectype& rmov = mov->new_row(); + rmov.put(RMOVANA_ANNOES, annoes); + rmov.put(RMOVANA_CODCONTO, row->get(0)); + rmov.put(RMOVANA_CODCMS, row->get()); + rmov.put(RMOVANA_CODFASE, row->get()); + rmov.put(RMOVANA_CODCCOSTO,row->get()); + rmov.put(RMOVANA_IMPORTO, esso.get()); + rmov.put(RMOVANA_SEZIONE, 'D'); + } + + if (mov != NULL) + { + TLocalisamfile movana(LF_MOVANA); + mov->write(movana); + delete mov; + } + } } - return good(); + return can_write; } bool TContabilizzazione_analitica::elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, @@ -24,8 +440,20 @@ bool TContabilizzazione_analitica::elabora(TLista_documenti& doc_in, TLista_docu const TImporto zero; for (int i = 0; doc_in.items(); i++) { - if (!elabora(doc_in[i], zero)) + if (!elabora(doc_in[i], 0, NULL, true)) break; } - return good(); -} \ No newline at end of file + return true; +} + +TContabilizzazione_analitica::TContabilizzazione_analitica() : TElaborazione(NULL) +{ +} + +TContabilizzazione_analitica::TContabilizzazione_analitica(const TRectype& rec) + : TElaborazione(rec) +{ +} + +TContabilizzazione_analitica::~TContabilizzazione_analitica() +{ } diff --git a/ve/velib06.cpp b/ve/velib06.cpp index 5c29897f7..4bf9ad758 100755 --- a/ve/velib06.cpp +++ b/ve/velib06.cpp @@ -1,4 +1,3 @@ -#include #include #include #include @@ -21,11 +20,6 @@ #include "veini.h" #include "sconti.h" -#include "../cg/cg2103.h" -#include "../ca/calib01.h" - -#include "doc.h" -#include "rdoc.h" TDocumento_mask::TDocumento_mask(const char* td) : TVariable_mask(), _progs_page(-1),