From 77a26c798c202d2f0ecfee2ef00652be438a93c1 Mon Sep 17 00:00:00 2001 From: luca Date: Fri, 8 May 2009 11:27:47 +0000 Subject: [PATCH] Patch level :10.0 Files correlati : Ricompilazione Demo : [ ] Commento :iniziata modifica globale ai movimenti analitici e alla stampa del bilancio di commessa git-svn-id: svn://10.65.10.50/trunk@18834 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- ca/ca2100.cpp | 5 +- ca/ca2100a.h | 3 +- ca/ca2100a.uml | 113 ++++-------- ca/ca3800.cpp | 16 ++ ca/ca3800.uml | 54 ++---- ca/ca3883.cpp | 486 +++++++++++++++++++++++++++++++++++++------------ ca/ca3883.h | 16 +- ca/calib01.cpp | 11 ++ ca/f107.dir | 2 +- ca/f107.trr | 3 +- ca/f108.trr | 3 +- ca/movana.h | 1 + 12 files changed, 479 insertions(+), 234 deletions(-) diff --git a/ca/ca2100.cpp b/ca/ca2100.cpp index 075dd9353..4e876e2da 100755 --- a/ca/ca2100.cpp +++ b/ca/ca2100.cpp @@ -930,7 +930,7 @@ void TMovanal_app::write_rows(const TMask& m) mov.destroy_rows(); // Scandisce lo sheet e riempie il recarray - TSheet_field& sheet = _msk->sfield(F_RIGHE); + TSheet_field& sheet = m.sfield(F_RIGHE); FOR_EACH_SHEET_ROW(sheet, i, row) { const real dare = row->get(0), avere = row->get(); @@ -939,7 +939,8 @@ void TMovanal_app::write_rows(const TMask& m) TRectype& rec = mov.new_row(); // Crea una riga nuova _msk->row2rec(i, rec); - } + + } //FOR_EACH_SHEET... } void TMovanal_app::read_rows(const TMask& m) diff --git a/ca/ca2100a.h b/ca/ca2100a.h index c9950c445..06933960c 100755 --- a/ca/ca2100a.h +++ b/ca/ca2100a.h @@ -4,8 +4,7 @@ #define F_DATAREG 204 #define F_DATACOMP 205 #define F_DATADOC 206 -#define F_CODDITTA 207 -#define F_RAGSOC 208 +#define F_AUTOFCOMP 207 #define F_TIPODOC 209 #define F_SEZIONE 210 #define F_TOTDOC 211 diff --git a/ca/ca2100a.uml b/ca/ca2100a.uml index cd45dc1c2..824dfd270 100755 --- a/ca/ca2100a.uml +++ b/ca/ca2100a.uml @@ -8,47 +8,23 @@ ENDPAGE PAGE "Testata" 0 0 0 2 -GROUPBOX DLG_NULL 78 3 +GROUPBOX DLG_NULL 78 7 BEGIN - PROMPT 1 1 "@bDitta" -END - -NUMBER F_CODDITTA 5 -BEGIN - PROMPT 2 2 "" - FLAGS "DFR" - USE LF_NDITTE - INPUT CODDITTA F_CODDITTA - OUTPUT F_RAGSOC RAGSOC - CHECKTYPE NORMAL -END - -STRING F_RAGSOC 50 52 -BEGIN - PROMPT 9 2 "Ragione sociale " - FLAGS "D" -END - -GROUPBOX DLG_NULL 78 6 -BEGIN - PROMPT 1 4 "@bTestata" + PROMPT 1 1 "@bTestata" END LIST F_TIPO 1 25 BEGIN - PROMPT 2 5 "Tipo movimento " + PROMPT 2 2 "Tipo movimento " ITEM " |Normale" - MESSAGE RESET,F_DATAFCOMP|HIDE,F_DATAFCOMP ITEM "P|Preventivo" - MESSAGE SHOW,F_DATAFCOMP ITEM "V|Variazione preventivo" - MESSAGE SHOW,F_DATAFCOMP FIELD TIPOMOV END DATE F_DATAREG BEGIN - PROMPT 2 6 "Data di registrazione " + PROMPT 2 3 "Data di registrazione " CHECKTYPE REQUIRED FIELD DATAREG FLAGS "A" @@ -59,7 +35,7 @@ END NUMBER F_NUMREG 7 BEGIN - PROMPT 54 5 "Movimento n. " + PROMPT 54 2 "Movimento n. " USE LF_MOVANA SELECT TIPOMOV==#F_TIPO INPUT NUMREG F_NUMREG DISPLAY "Numero@7" NUMREG @@ -79,7 +55,7 @@ END DATE F_DATACOMP BEGIN - PROMPT 2 7 "Data di competenza " + PROMPT 2 4 "Data di competenza " FIELD DATACOMP CHECKTYPE REQUIRED WARNING "La data di competenza non appartiene ad un esercizio valido" @@ -87,43 +63,42 @@ END DATE F_DATAFCOMP BEGIN - PROMPT 43 7 "Data di fine competenza " + PROMPT 43 4 "Data di fine competenza " FIELD DATAFCOMP WARNING "La data di fine competenza non puo' essere anteriore alla data di competenza" END NUMBER F_ANNOES 4 BEGIN - PROMPT 54 6 "Esercizio " + PROMPT 54 3 "Esercizio " FIELD ANNOES MESSAGE COPY,F_ANNOES2 FLAGS "DG" END +BOOLEAN F_AUTOFCOMP +BEGIN + PROMPT 2 5 "Fine competenza coincidente con fine commessa di ogni riga" + MESSAGE FALSE ENABLE,F_DATAFCOMP + MESSAGE TRUE CLEAR,F_DATAFCOMP + FIELD AUTOFCOMP +END + STRING F_DESCR 50 BEGIN - PROMPT 2 8 "Descrizione " + PROMPT 2 6 "Descrizione " FIELD DESCR MESSAGE COPY,F_DESCR2 END -GROUPBOX DLG_NULL 78 6 +GROUPBOX DLG_NULL 78 7 BEGIN - PROMPT 1 10 "@bPrima nota" -END - -NUMBER F_NUMREGCG 7 -BEGIN - PROMPT 2 11 "Numero " - FLAGS "DG" - FIELD NUMREGCG - MESSAGE EMPTY ENABLE,F_TIPO|HIDE,F_RESET - MESSAGE DISABLE,F_TIPO|SHOW,F_RESET + PROMPT 1 8 "@bDati contabili" END STRINGA F_CODCAUS 3 BEGIN - PROMPT 19 11 "Causale " + PROMPT 2 9 "Causale " USE LF_CAUSALI SELECT MOVIND!='' INPUT CODCAUS F_CODCAUS DISPLAY "Codice" CODCAUS @@ -138,7 +113,7 @@ END STRINGA F_DESCAUS 50 40 BEGIN - PROMPT 34 11 "" + PROMPT 20 9 "" USE LF_CAUSALI KEY 2 SELECT MOVIND!='' INPUT DESCR F_DESCAUS DISPLAY "Descrizione@50" DESCR @@ -150,7 +125,7 @@ END STRING F_TIPODOC 2 BEGIN - PROMPT 2 12 "Documento: Tipo " + PROMPT 2 10 "Documento: Tipo " USE %TPD INPUT CODTAB F_TIPODOC DISPLAY "Codice" CODTAB @@ -163,7 +138,7 @@ END STRING F_NUMDOC 7 BEGIN - PROMPT 27 12 "Numero " + PROMPT 28 10 "Numero " CHECKTYPE NORMAL FIELD NUMDOC GROUP 5 @@ -171,55 +146,45 @@ END DATE F_DATADOC BEGIN - PROMPT 48 12 "Data " + PROMPT 47 10 "Data " FIELD DATADOC GROUP 5 END +NUMBER F_NUMREGCG 7 +BEGIN + PROMPT 2 11 "N. reg. contabile " + FLAGS "DG" + FIELD NUMREGCG + MESSAGE EMPTY ENABLE,F_TIPO|HIDE,F_RESET + MESSAGE DISABLE,F_TIPO|SHOW,F_RESET +END + LIST F_TIPOCF 1 11 BEGIN - PROMPT 2 13 "Tipo " - FIELD TIPOCF - FLAGS "G" - GROUP 5 + PROMPT 2 12 "Tipo " + FLAGS "DG" ITEM "C|Clienti" ITEM "F|Fornitori" END NUMBER F_CODCF 6 BEGIN - PROMPT 25 13 "Codice " - FIELD CODCF - FLAGS "G" - GROUP 5 + PROMPT 25 12 "Codice " + FLAGS "DG" USE LF_CLIFO INPUT TIPOCF F_TIPOCF SELECT INPUT CODCF F_CODCF - DISPLAY "Codice@6R" CODCF - DISPLAY "Ragione sociale@50" RAGSOC - DISPLAY "Codice fiscale@16" COFI - DISPLAY "Partita IVA@11" PAIV OUTPUT F_TIPOCF TIPOCF OUTPUT F_CODCF CODCF OUTPUT F_RAGSOCCF RAGSOC - HELP "Codice relativo al cliente o fornitore" CHECKTYPE NORMAL END STRING F_RAGSOCCF 50 BEGIN - PROMPT 2 14 "Ragione Sociale " - USE LF_CLIFO KEY 2 - INPUT TIPOCF F_TIPOCF SELECT - INPUT RAGSOC F_RAGSOCCF - DISPLAY "Ragione sociale@50" RAGSOC - DISPLAY "Codice@R" CODCF - DISPLAY "Codice fiscale@16" COFI - DISPLAY "Partita IVA@11" PAIV - COPY OUTPUT F_CODCF - FLAGS "G" - GROUP 5 - CHECKTYPE NORMAL + PROMPT 2 13 "Ragione Sociale " + FLAGS "D" END GROUPBOX DLG_NULL 78 4 diff --git a/ca/ca3800.cpp b/ca/ca3800.cpp index 4c2e13bfc..1974069c1 100755 --- a/ca/ca3800.cpp +++ b/ca/ca3800.cpp @@ -85,6 +85,22 @@ bool TPrint_bilancio_cms_mask::on_field_event(TOperable_field& o, TField_event e return error_box(TR("Impossibile trovare un report compatibile")); } break; + case F_ESERCIZIO: + case F_FINE_ES: + if (e == fe_init || e == fe_modify || e == fe_close) + { + const int anno = get_int(F_ESERCIZIO); + if (anno > 0) + { + TEsercizi_contabili esc; + TDate datainiesc, datafinesc; + esc.code2range(anno, datainiesc, datafinesc); + const TDate datafine = get(F_FINE_ES); + if (datafine < datainiesc || datafine > datafinesc) + set(F_FINE_ES, datafinesc); + } + } + break; default: break; } diff --git a/ca/ca3800.uml b/ca/ca3800.uml index 72dfca930..39e599c8c 100755 --- a/ca/ca3800.uml +++ b/ca/ca3800.uml @@ -11,25 +11,9 @@ BEGIN PROMPT 0 1 "" END -NUMBER F_DITTA 5 -BEGIN - PROMPT 1 2 "Ditta " - FLAGS "DF" -END - -STRING F_RAGSOC 50 -BEGIN - PROMPT 20 2 "" - USE LF_NDITTE - INPUT CODDITTA F_DITTA - OUTPUT F_RAGSOC RAGSOC - CHECKTYPE NORMAL - FLAGS "D" -END - NUMBER F_ESERCIZIO 4 BEGIN - PROMPT 1 3 "Esercizio " + PROMPT 1 2 "Esercizio " FLAGS "AZ" USE ESC INPUT CODTAB F_ESERCIZIO @@ -38,20 +22,25 @@ BEGIN DISPLAY "Fine esercizio" D1 OUTPUT F_ESERCIZIO CODTAB OUTPUT F_INIZIO_ES D0 - OUTPUT F_FINE_ES D1 CHECKTYPE REQUIRED END DATE F_INIZIO_ES BEGIN - PROMPT 20 3 "Inizio " + PROMPT 20 2 "Inizio " FLAGS "D" END DATE F_FINE_ES BEGIN - PROMPT 44 3 "Fine " - FLAGS "D" + PROMPT 44 2 "Fine " +END + +BOOLEAN F_VITAINTERA +BEGIN + PROMPT 1 3 "Inclusi esercizi successivi (vita intera)" + MESSAGE FALSE ENABLE,F_FINE_ES + MESSAGE TRUE CLEAR,F_FINE_ES END DATE F_DATASTAMPA @@ -67,7 +56,7 @@ END LISTBOX F_TIPOSTAMPA 1 30 BEGIN - PROMPT 1 7 "Stampa" + PROMPT 1 7 "Stampa " ITEM "0|Normale" MESSAGE CLEAR,F_FASE|CLEAR,F_CDC ITEM "1|Dettaglia per Fase" @@ -84,12 +73,12 @@ END STRING F_FASE 10 BEGIN - PROMPT 2 8 "Fase " + PROMPT 2 8 "Fase " END STRING F_CDC 20 BEGIN - PROMPT 2 9 "CdC " + PROMPT 2 9 "CdC " USE LF_CDC INPUT CODCOSTO F_CDC DISPLAY "Codice centro di costo" CODCOSTO @@ -97,25 +86,20 @@ BEGIN OUTPUT F_CDC CODCOSTO END -BOOLEAN F_VITAINTERA +RADIOBUTTON F_TIPOSTIMA 1 30 BEGIN - PROMPT 1 11 "Includere esercizi successivi (vita intera)" -END - -RADIOBUTTON F_TIPOSTIMA 1 32 -BEGIN - PROMPT 44 9 "Tipo di stima" - ITEM "T|Costi prev.\Ricavi prev. (Tempo)" + PROMPT 45 9 "Tipo di stima Costi\Ricavi" + ITEM "T|C prev.\R prev. (Tempo)" MESSAGE SHOW,F_TIPODETR|ENABLE,F_TIPODETR - ITEM "C|Costi cons.\Ricavi prev." + ITEM "C|C cons.\R prev." MESSAGE CLEAR,F_TIPODETR|HIDE,F_TIPODETR - ITEM "R|Costi cons.\Ricavi cons." + ITEM "R|C cons.\R cons." MESSAGE CLEAR,F_TIPODETR|HIDE,F_TIPODETR END BOOLEAN F_TIPODETR BEGIN - PROMPT 1 12 "Utilizzare consuntivi per le detrazioni " + PROMPT 1 10 "Utilizzare consuntivi per le detrazioni " END GROUPBOX F_PRE0 76 5 diff --git a/ca/ca3883.cpp b/ca/ca3883.cpp index ae9dd102c..76bd39f23 100755 --- a/ca/ca3883.cpp +++ b/ca/ca3883.cpp @@ -4,6 +4,8 @@ #include "calib02.h" #include "ca3883.h" +#include "movana.h" +#include "rmovana.h" #include "panapdc.h" #include "pconana.h" #include "commesse.h" @@ -607,7 +609,7 @@ void TPrint_saldana_recordset::parse_bill(const TString& bill, TString& conto) c conto = bill.mid(prefix_len, conto_end); } -int TPrint_saldana_recordset::estrai_saldi(const TRecordset& saldana, const int indbil, +int TPrint_saldana_recordset::estrai_saldi(const TRectype& saldana, const int indbil, TImporto& saldo, TImporto& saldop, const bool cms_detraz) const { int flag = 0; @@ -622,8 +624,7 @@ int TPrint_saldana_recordset::estrai_saldi(const TRecordset& saldana, const int { case 'R': //CostiConsuntivi RicaviConsuntivi (Cc/Rc) { - const TImporto imp_saldo(saldana.get(SALDANA_SEZIONE).as_string()[0], - saldana.get(SALDANA_SALDO).as_real()); + const TImporto imp_saldo(saldana.get_char(SALDANA_SEZIONE), saldana.get_real(SALDANA_SALDO)); if (!imp_saldo.is_zero()) { if (indbil == 3) //indbil=3 costi @@ -644,17 +645,14 @@ int TPrint_saldana_recordset::estrai_saldi(const TRecordset& saldana, const int { if (indbil == 3) //costi { - const TImporto imp_saldo(saldana.get(SALDANA_SEZIONE).as_string()[0], - saldana.get(SALDANA_SALDO).as_real()); + const TImporto imp_saldo(saldana.get_char(SALDANA_SEZIONE), saldana.get_real(SALDANA_SALDO)); saldo = imp_saldo; flag |= saldo.is_zero() ? 0 : 1; } else //indbil=4 ricavi { - const TImporto imp_saldop(saldana.get(SALDANA_SEZIONEP).as_string()[0], - saldana.get(SALDANA_SALDOP).as_real()); - const TImporto imp_saldov(saldana.get(SALDANA_SEZIONEV).as_string()[0], - saldana.get(SALDANA_SALDOV).as_real()); + const TImporto imp_saldop(saldana.get_char(SALDANA_SEZIONEP), saldana.get_real(SALDANA_SALDOP)); + const TImporto imp_saldov(saldana.get_char(SALDANA_SEZIONEV), saldana.get_real(SALDANA_SALDOV)); saldop = imp_saldop; saldop += imp_saldov; flag |= saldop.is_zero() ? 0 : 2; @@ -667,17 +665,14 @@ int TPrint_saldana_recordset::estrai_saldi(const TRecordset& saldana, const int //..usando i consuntivi (Adolf rikiesten)... if (cms_detraz && _tipodetr) { - const TImporto imp_saldo(saldana.get(SALDANA_SEZIONE).as_string()[0], - saldana.get(SALDANA_SALDO).as_real()); + const TImporto imp_saldo(saldana.get_char(SALDANA_SEZIONE), saldana.get_real(SALDANA_SALDO)); saldo = imp_saldo; flag |= saldo.is_zero() ? 0 : 1; } else //in tutti gli altri casi vanno bene i preventivi { - const TImporto imp_saldop(saldana.get(SALDANA_SEZIONEP).as_string()[0], - saldana.get(SALDANA_SALDOP).as_real()); - const TImporto imp_saldov(saldana.get(SALDANA_SEZIONEV).as_string()[0], - saldana.get(SALDANA_SALDOV).as_real()); + const TImporto imp_saldop(saldana.get_char(SALDANA_SEZIONEP), saldana.get_real(SALDANA_SALDOP)); + const TImporto imp_saldov(saldana.get_char(SALDANA_SEZIONEV), saldana.get_real(SALDANA_SALDOV)); saldop = imp_saldop; saldop += imp_saldov; flag |= saldop.is_zero() ? 0 : 2; @@ -690,15 +685,12 @@ int TPrint_saldana_recordset::estrai_saldi(const TRecordset& saldana, const int // stampa stima ricavi ca3900 (_tipo=9) else { - const TImporto imp_saldo(saldana.get(SALDANA_SEZIONE).as_string()[0], - saldana.get(SALDANA_SALDO).as_real()); + const TImporto imp_saldo(saldana.get_char(SALDANA_SEZIONE), saldana.get_real(SALDANA_SALDO)); saldo = imp_saldo; flag |= saldo.is_zero() ? 0 : 1; - const TImporto imp_saldop(saldana.get(SALDANA_SEZIONEP).as_string()[0], - saldana.get(SALDANA_SALDOP).as_real()); - const TImporto imp_saldov(saldana.get(SALDANA_SEZIONEV).as_string()[0], - saldana.get(SALDANA_SALDOV).as_real()); + const TImporto imp_saldop(saldana.get_char(SALDANA_SEZIONEP), saldana.get_real(SALDANA_SALDOP)); + const TImporto imp_saldov(saldana.get_char(SALDANA_SEZIONEV), saldana.get_real(SALDANA_SALDOV)); saldop = imp_saldop; saldop += imp_saldov; flag |= saldop.is_zero() ? 0 : 2; @@ -762,7 +754,7 @@ TAssoc_array& TPrint_saldana_recordset::get_row(TAssoc_array& cms, const char* c //for ca3800 only! void TPrint_saldana_recordset::aggiorna_importo(TAssoc_array& riga_array, const TString& livello, - const int indbil, const TRecordset& saldana, const bool inverti, const bool cms_detraz) const + const int indbil, const TRectype& saldana, const bool inverti, const bool cms_detraz) const { TString* str_imp = (TString*)riga_array.objptr(livello); if (str_imp == NULL) @@ -864,7 +856,7 @@ void TPrint_saldana_recordset::incrementa_importo(TAssoc_array& riga_array, //metodo usato solo per la stima ricavi ca3900 (_tipo=9) void TPrint_saldana_recordset::aggiorna_importi(TAssoc_array& riga_array, - const int indbil, const TRecordset& saldana, const bool inverti) const + const int indbil, const TRectype& saldana, const bool inverti) const { TString8 livello; @@ -886,30 +878,136 @@ void TPrint_saldana_recordset::aggiorna_importi(TAssoc_array& riga_array, } } -void TPrint_saldana_recordset::create_lines_to_print(const TString& query) +//calcola la durata di una commessa e le sue date di inizio e fine +long TPrint_saldana_recordset::durata_commessa(const TRectype& rec_commesse, const TDate& datafinesc, + TDate& dataini, TDate& datafine) const { - //prende le date di inizio e fine dell'eserizio selezionato sulla maschera - TEsercizi_contabili esc; - TDate datainiesc, datafinesc; - esc.code2range(_anno, datainiesc, datafinesc); - //deve procedere al confronto tra le date inizio-fine esercizio e quelle inizio-fine commessa.. - //..per spostare il record in esame nell'array corretto - TAssoc_array cms[NUM_LEVELS]; + //data iniziale commessa + dataini = rec_commesse.get(COMMESSE_DATAINIZIO); - TISAM_recordset saldana(query); + //per la data fine deve tener conto di eventuali proroghe.. + if (rec_commesse.get_bool(COMMESSE_PROROGA) && rec_commesse.get(COMMESSE_DATAPROR).ok()) + datafine = rec_commesse.get(COMMESSE_DATAPROR); + else + datafine = rec_commesse.get(COMMESSE_DATAFINE); - const long saldana_items = saldana.items(); + //datafine.ok() va messo per gli utonti che mettono le commesse all'infinito senza specificare la datafine + //in questo modo la commessa e' come se terminasse l'anno dopo e viene stampata nella sezione 2 (vedi sotto) + if (!datafine.ok()) + { + datafine = datafinesc; + datafine.addyear(1); + } + + return datafine - dataini + 1; +} + +//trova la sezione del report in cui ricade in base alle date +int TPrint_saldana_recordset::ricava_sezione_di_stampa(const TRectype& rec_commesse, + const TDate& datainiesc, const TDate& datafinesc) const +{ + int indice = -1; + + //data iniziale commessa + TDate dataini, datafine; + durata_commessa(rec_commesse, datafinesc, dataini, datafine); + + //Le commesse vengono suddivise in varie sezioni in base alle loro date di inizio/fine/proroga.. + //..e al fatto che possono essere di appoggio (Adolf rikiesten!) secondo lo schema: + // _ 0 terminano nell'anno selezionato / iniziate nel passato + // _ 1 terminano nell'anno selezionato / iniziate nell'anno selezionato + // _ 2 terminano nel futuro / iniziate nel passato + // _ 3 terminano nel futuro / iniziate nell'anno selezionato + // _ 4 di appoggio / terminano nell'anno selezionato / iniziate nell'anno selezionato + // (indice 1 ma di appoggio in pratica) + + //e' inutile considerare le commesse terminate prima dell'esercizio selezionato.. + //..cioe' nel passato oppure che iniziano nel futuro! + if (datafine >= datainiesc && dataini <= datafinesc) + { + //indice e' il parametro che stabilisce in quale sezione del report viene stampata la commessa + //se la commessa termina prima della fine dell'esercizio selezionato -> indice 0, altrimenti.. + //..indice 2 + indice = datafine <= datafinesc ? 0 : 2; + //se poi la commessa inizia dopo la data inizio esercizio selezionato -> l'indice va incrementato.. + //..di una unita' (viene spostata nella sezione di stampa successiva) + if (dataini >= datainiesc) + indice++; + + //controlla se la commessa e' di appoggio e di indice 1 (inizia e finisce nell'anno selezionato) + //in questo caso la commessa ha indice 4 e va nella sezione distaccata in fondo al report (Adolf!) + if (indice == 1) + { + const bool cms_appoggio = rec_commesse.get_bool(COMMESSE_APPOGGIO); + if (cms_appoggio) + indice = 4; + } + } + return indice; +} + +TString TPrint_saldana_recordset::ricava_chiave_cdc_fase(const TString& codcms, const TString& fase, const TString& cdc) const +{ + //ci sono filtri o raggruppamenti per fase o centro di costo? + TString chiave = codcms; + //selezione fasi solo su bilancio commessa (_tipo=8) + if (_tipo == 8 && (_tipostampa >= 1 && _tipostampa <= 3)) + { + //se vuole entrambi i livelli di dettaglio occorre sapere chi e' il babbo delle fasi o dei cdc + if (_tipostampa == 3) + { + //le fasi sono figlie dei cdc? + if (ca_multilevel_code_info(LF_FASI).parent() == LF_CDC) + chiave << '|' << cdc << '|' << fase; + else //in ogni altro caso (figlie delle commesse o di nessuno...) + chiave << '|' << fase << '|' << cdc; + } + else //livelli di dettaglio semplici + { + if (_tipostampa == 1) + chiave << '|' << fase; //dettaglia x fase + else + chiave << '|' << cdc; //dettaglia x cdc + } + } + return chiave; +} + + +const TDate TPrint_saldana_recordset::calcola_min_datacomp(const TDate& datainiesc, const TDate& datafinesc) const +{ + TDate data_min_comp = datainiesc; + TISAM_recordset recset("USE COMMESSE"); //\nSELECT BETWEEN(DATAFINE,#DATAINIESC,0)||BETWEEN(DATAPROR,#DATAINIESC,0)||(DATAFINE='')"); + for (bool ok = recset.move_first(); ok; ok = recset.move_next()) + { + TDate dataini, datafine; + durata_commessa(recset.cursor()->curr(), datafinesc, dataini, datafine); + if (datafine >= datainiesc && dataini < data_min_comp) + data_min_comp = dataini; + } + return data_min_comp; +} + + +//aggiorna l'arrayone cms con i saldana +void TPrint_saldana_recordset::parse_saldana(TAssoc_array* cms, const TDate& datainiesc, const TDate& datafinesc, + const TString& query) +{ + TISAM_recordset saldana_set(query); + const TRectype& saldana = saldana_set.cursor()->curr(); + + const long saldana_items = saldana_set.items(); TProgind pi(saldana_items, "Scansione saldi...", true, true); - for (bool ok = saldana.move_first(); ok; ok = saldana.move_next()) + for (bool ok = saldana_set.move_first(); ok; ok = saldana_set.move_next()) { //progind tanto per gradire pi.addstatus(1); if (pi.iscancelled()) break; - const TString& codconto = saldana.get(SALDANA_CONTO).as_string(); + const TString& codconto = saldana.get(SALDANA_CONTO); //trova l'indicatore di bilancio TString80 conto_anale; @@ -917,27 +1015,6 @@ void TPrint_saldana_recordset::create_lines_to_print(const TString& query) //solo i Costi(3) ed i Ricavi(4) devono essere considerati per la stampa if (indbil == 3 || indbil == 4) { - //estrae i dati di commessa e le date relative;le date servono successivamente per stabilire... - //..le sezioni in cui compariranno le commesse nella stampa - const TString& codcms = saldana.get(SALDANA_COMMESSA).as_string(); - const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms); - const TDate dataini = rec_commesse.get(COMMESSE_DATAINIZIO); - - //per la data fine deve tener conto di eventuali proroghe.. - TDate datafine; - if (rec_commesse.get_bool(COMMESSE_PROROGA) && rec_commesse.get(COMMESSE_DATAPROR).ok()) - datafine = rec_commesse.get(COMMESSE_DATAPROR); - else - datafine = rec_commesse.get(COMMESSE_DATAFINE); - - //datafine.ok() va messo per gli utonti che mettono le commesse all'infinito senza specificare la datafine - //in questo modo la commessa e' come se terminasse l'anno dopo e viene stampata nella sezione 2 (vedi sotto) - if (!datafine.ok()) - { - datafine = datafinesc; - datafine.addyear(1); - } - //gruppo e conto servono solo per il caso _tipo=8 ma vanno dichiarati e ricavati.. //..qui in modo che siano a disposizione delle commesse del cazzo poco sotto const char* gruppo = indbil == 3 ? "COSTI" : "RICAVI"; @@ -945,63 +1022,26 @@ void TPrint_saldana_recordset::create_lines_to_print(const TString& query) parse_bill(conto_anale, conto); TImporto saldo, saldop; + const int flag = estrai_saldi(saldana, indbil, saldo, saldop, false); - //Le commesse vengono suddivise in varie sezioni in base alle loro date di inizio/fine/proroga.. - //..e al fatto che possono essere di appoggio (Adolf rikiesten!) secondo lo schema: - // _ 0 terminano nell'anno selezionato / iniziate nel passato - // _ 1 terminano nell'anno selezionato / iniziate nell'anno selezionato - // _ 2 terminano nel futuro / iniziate nel passato - // _ 3 terminano nel futuro / iniziate nell'anno selezionato - // _ 4 di appoggio / terminano nell'anno selezionato / iniziate nell'anno selezionato - // (indice 1 ma di appoggio in pratica) + //estrae i dati di commessa e le date relative;le date servono successivamente per stabilire... + //..le sezioni in cui compariranno le commesse nella stampa + const TString& codcms = saldana.get(SALDANA_COMMESSA); + const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms); + //indice: indica la sezione di report in cui apparariranno i valori! + const int indice = ricava_sezione_di_stampa(rec_commesse, datainiesc, datafinesc); //e' inutile considerare le commesse terminate prima dell'esercizio selezionato.. - //..cioe' nel passato oppure che iniziano nel futuro! - if (datafine >= datainiesc && dataini <= datafinesc) + //..cioe' nel passato oppure che iniziano nel futuro! Solo le commesse con indice non.. + //..negativo sopravvivono! + if (indice >= 0) { - //indice e' il parametro che stabilisce in quale sezione del report viene stampata la commessa - //se la commessa termina prima della fine dell'esercizio selezionato -> indice 0, altrimenti.. - //..indice 2 - int indice = datafine <= datafinesc ? 0 : 2; - //se poi la commessa inizia dopo la data inizio esercizio selezionato -> l'indice va incrementato.. - //..di una unita' (viene spostata nella sezione di stampa successiva) - if (dataini >= datainiesc) - indice++; - - //controlla se la commessa e' di appoggio e di indice 1 (inizia e finisce nell'anno selezionato) - //in questo caso la commessa ha indice 4 e va nella sezione distaccata in fondo al report (Adolf!) - if (indice == 1) - { - const bool cms_appoggio = rec_commesse.get_bool(COMMESSE_APPOGGIO); - if (cms_appoggio) - indice = 4; - } - //ci sono filtri o raggruppamenti per fase o centro di costo? - const TString& fase = saldana.get(SALDANA_FASE).as_string(); - const TString& cdc = saldana.get(SALDANA_COSTO).as_string(); - TString80 chiave = codcms; - //selezione fasi solo su bilancio commessa (_tipo=8) - if (_tipo == 8 && (_tipostampa >= 1 && _tipostampa <= 3)) - { - //se vuole entrambi i livelli di dettaglio occorre sapere chi e' il babbo delle fasi o dei cdc - if (_tipostampa == 3) - { - //le fasi sono figlie dei cdc? - if (ca_multilevel_code_info(LF_FASI).parent() == LF_CDC) - chiave << '|' << cdc << '|' << fase; - else //in ogni altro caso (figlie delle commesse o di nessuno...) - chiave << '|' << fase << '|' << cdc; - } - else //livelli di dettaglio semplici - { - if (_tipostampa == 1) - chiave << '|' << fase; //dettaglia x fase - else - chiave << '|' << cdc; //dettaglia x cdc - } - } + const TString& fase = saldana.get(SALDANA_FASE); + const TString& cdc = saldana.get(SALDANA_COSTO); + //ricava la chiave completa per l'assoc_array comprendendo eventuali fasi e/o cdc + TString chiave = ricava_chiave_cdc_fase(codcms, fase, cdc); //riempie le righe degli array da mandare poi in stampa //dapprima le righe normali.. @@ -1035,15 +1075,12 @@ void TPrint_saldana_recordset::create_lines_to_print(const TString& query) //RIGHE COMMESSA DETRAZIONE: esistono solo se la commessa e' iniziata prima dell'anno //selezionato e se ha a che fare con quello in corso,quindi l'indice e' 0 o 2 - if (datafine >= datainiesc && dataini < datainiesc) + //indice è stato ricavato un tot di righe addietro... + if (indice == 0 || indice == 2) { - //indice e' il parametro che stabilisce in quale sezione del report viene stampata la commessa - //se la commessa termina prima della fine dell'esercizio selezionato -> indice 0, altrimenti.. - //..indice 2 - const int indice = datafine <= datafinesc ? 0 : 2; //aggiorna il record speciale con la somma dei saldi con anno anteriore a quello.. //..selezionato sulla maschera (CRPA request) - const int anno = saldana.get(SALDANA_ANNO).as_int(); + const int anno = saldana.get_int(SALDANA_ANNO); if (anno < _anno) { TString16 cazzo_cod; cazzo_cod.format("detr_al_%04d", _anno - 1); @@ -1066,8 +1103,216 @@ void TPrint_saldana_recordset::create_lines_to_print(const TString& query) } //if (indbil == 3 ||... } //for(bool ok=saldana.move_first().. +} - //merging dei 5 arrayini cms nell'arrayone _righe da mandare in stampa + +//aggiorna l'arrayone cms con le rmovana +void TPrint_saldana_recordset::parse_rmovana(TAssoc_array* cms, const TDate& datainiesc, const TDate& datafinesc) +{ + const TDate min_datacomp = calcola_min_datacomp(datainiesc, datafinesc); + + //cerca tutte le rmovana che soddisfano gli innumerevoli parametri + TString query; + query << "USE RMOVANA KEY 3\nJOIN MOVANA INTO NUMREG==NUMREG\n"; + + switch (_tipostampa) + { + case 1: + case 4: + if (_fase.full()) + query << " SELECT CODFASE=\"" << _fase << "\"\n"; + break; + case 2: + case 8: + if (_cdc.full()) + query << " SELECT CODCCOSTO=\"" << _cdc << "\"\n"; + break; + case 3: + if (_fase.full() || _cdc.full()) + { + if (_fase.full() && _cdc.full()) + query << " SELECT (CODFASE=\"" << _fase << "\")&&(CODCCOSTO=\"" << _cdc << "\")\n"; + else + { + if (_fase.full()) + query << " SELECT CODFASE=\"" << _fase << "\"\n"; + else + query << " SELECT CODCCOSTO=\"" << _cdc << "\"\n"; + } + } + break; + } + + query << "FROM DATACOMP=#MINDATACOMP\nTO DATACOMP=#DATACALCOLO"; + TISAM_recordset recset(query); + recset.set_var("#DATACALCOLO", _datacalcolo); + recset.set_var("#MINDATACOMP", min_datacomp); + + const long recset_items = recset.items(); + //se ci sono movana che non expirano prima dell'inizio esercizio e la cui datacomp è anteriore a datacalcolo... + if (recset_items > 0) + { + //record correntemente in esame di rmovana e movana + const TRectype& rmovana = recset.cursor()->curr(); + const TRectype& movana = recset.cursor()->curr(LF_MOVANA); + + //simpatica progind per intrattenere l'utonto + TProgind pi(recset_items, "Scansione movimenti...", true, true); + + for (bool ok = recset.move_first(); ok; ok = recset.move_next()) //giro sui vari rmovana... + { + //aggiornamento progind intrattenitiva + pi.addstatus(1); + if (pi.iscancelled()) + break; + + const char tipomov = movana.get_char(MOVANA_TIPOMOV); + //la data iniziale è la datacomp sulla testata per tutte le righe + const TDate datacomp = movana.get_date(MOVANA_DATACOMP); + + const TString& codcms = rmovana.get(RMOVANA_CODCMS); + const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms); + const int indice = ricava_sezione_di_stampa(rec_commesse, datainiesc, datafinesc); + + //solo le righe con commessa buona (indice >= 0) vengono considerate + if (indice >= 0) + { + //ci sono filtri o raggruppamenti per fase o centro di costo? + const TString& fase = rmovana.get(RMOVANA_CODFASE); + const TString& cdc = rmovana.get(RMOVANA_CODCCOSTO); + //se la riga è risultata buona ricava la chiave completa per l'assoc_array comprendendo eventuali.. + //..fasi e/o cdc + TString chiave = ricava_chiave_cdc_fase(codcms, fase, cdc); + + //calcola la "durata complessiva" della riga, ovvero l'intervallo di tempo per cui essa risulta valida + //la data fine ci fa sudare un pò + //di base è pari a datafcomp di testata (che è sempre esistente, mal che vada è uguale a datacomp) + TDate datafcomp = movana.get_date(MOVANA_DATAFCOMP); + //se invece è un movimento cazzuto con il calcolo automatico della data di morte (dataexpire)... + if (movana.get_bool(MOVANA_AUTOFCOMP)) + { + //data del cazzo che serve per non rovinare datacomp, che è la data sulla riga, non quella iniziale di cms + TDate datainicms; + durata_commessa(rec_commesse, datafinesc, datainicms, datafcomp); + } + //finalmente la tanto agognata vita della riga di movana! + //si aggiunge 1 perchè se un movimento ha datacomp=datafcomp (come in generale accade) in realtà.. + //..il poveretto vive un giorno, non 0 + const long vita_totale_riga = datafcomp - datacomp + 1; + + //riproporzionamento dell'importo di riga in base alla frazione di vita di riga interessata + real importo = rmovana.get_real(RMOVANA_IMPORTO); + + if (vita_totale_riga > 1) + { + //trova la frazione di vita della riga che interessa l'esercizio corrente + const TDate inizio_inter = fnc_max(datainiesc, datacomp); + const TDate fine_inter = fnc_min(_datacalcolo, datafcomp); + //si aggiunge anche qui 1 per gli stessi motivi della vita_totale + const long vita_frazione_riga = fine_inter - inizio_inter + 1; + + //il riproporzionamento vale solo per i movimenti che durano più di 1 giorno e con una vita_frazione.. + //..> vita_totale (il contrario sarebbe un errore!). I movimenti tutti nel futuro risultano con.. + //..vita_frazione negativa e quindi non sono considerati + //Anche le commesse tutte nel futuro rispetto a datacalcolo danno origine a una vita_frazione negativa.. + //..parando il culo al povero programma + if (vita_frazione_riga > 1 && vita_frazione_riga < vita_totale_riga) + { + importo = vita_frazione_riga * importo / vita_totale_riga; + importo.round(2); + } + } + //dopo tutto sto panegirico sul riproporzionamento finalmente si passa ad aggiornare gli array di stampa.. + //..con gli importi aggiustati + if (!importo.is_zero()) + { + //importo della riga già eventualmente riproporzionato + const TImporto importo_riga(rmovana.get_char(RMOVANA_SEZIONE), importo); + //riga array da aggiungere agli arrayoni da mandare in stampa + TAssoc_array& riga_array = get_row(cms[indice], chiave, indice, codcms, fase, cdc, + rec_commesse.get(COMMESSE_DESCRIZ)); + + + const TString& codconto = rmovana.get(RMOVANA_CODCONTO); + //trova l'indicatore di bilancio + TString80 conto_anale; + + const int indbil = _indicatori.get_indbil(codconto, conto_anale); + //solo i Costi(3) ed i Ricavi(4) devono essere considerati per la stampa + if (indbil == 3 || indbil == 4) + { + //gruppo e conto servono solo per il caso _tipo=8 ma vanno dichiarati e ricavati.. + //..qui in modo che siano a disposizione delle commesse del cazzo poco sotto + const char* gruppo = indbil == 3 ? "COSTI" : "RICAVI"; + TString80 conto; + parse_bill(conto_anale, conto); + + TRectype saldana(LF_SALDANA); + saldana.put(SALDANA_ANNO, _anno); + saldana.put(SALDANA_CONTO, conto_anale); + saldana.put(SALDANA_COSTO, cdc); + saldana.put(SALDANA_COMMESSA, codcms); + saldana.put(SALDANA_FASE, fase); + + switch(tipomov) + { + case 'P': + saldana.put(SALDANA_SEZIONEP, importo_riga.sezione()); + saldana.put(SALDANA_SALDOP, importo_riga.valore()); + break; + case 'V': + saldana.put(SALDANA_SEZIONEV, importo_riga.sezione()); + saldana.put(SALDANA_SALDOV, importo_riga.valore()); + break; + default: + saldana.put(SALDANA_SEZIONE, importo_riga.sezione()); + saldana.put(SALDANA_SALDO, importo_riga.valore()); + break; + } + + //aggiunge gli importi e normalizza + aggiorna_importo(riga_array, gruppo, indbil, saldana); + aggiorna_importo(riga_array, conto, indbil, saldana); + } + } + } //if(indice>=0)... + } //for(bool ok=recset.move_first()... + } //if(recset_items>0... +} + + +//metodo principale di riempimento degli array da mandare in stampa +void TPrint_saldana_recordset::create_lines_to_print(const TString& query) +{ + //ricava date limite di esercizio + TEsercizi_contabili esc; + TDate datainiesc, datafinesc; + esc.code2range(_anno, datainiesc, datafinesc); + + //array con le commesse divise sui vari livelli di sezione di stampa + TAssoc_array cms[NUM_LEVELS]; + + // 1) + // calcolo dei saldi alla data fine esercizio (vale per entrambi i tipi di stampa, ovvero _tipo=8 e _tipo=9) + parse_saldana(cms, datainiesc, datafinesc, query); + + // 2) + // calcolo dei saldi ad una data diversa da una data di fine esercizio (saldi alla data di adolfica richiesta) + // serve solo per il bilancio di commessa (_tipo = 8) + if (_tipo == 8) + { + if ((_datacalcolo < datafinesc) && !_vitaintera) + { + parse_rmovana(cms, datainiesc, datafinesc); + } //if((_datacalcoloput(MOVANA_DATAFCOMP, datafcomp); + } } int TAnal_mov::write(TBaseisamfile& f) const diff --git a/ca/f107.dir b/ca/f107.dir index ee4b515d2..5bb19a484 100755 --- a/ca/f107.dir +++ b/ca/f107.dir @@ -1,3 +1,3 @@ 107 0 -$movana|0|0|176|0|Movimenti di Analitica||| +$movana|0|0|177|0|Movimenti di Analitica||| diff --git a/ca/f107.trr b/ca/f107.trr index 11fa2e4cf..6f033b4ca 100755 --- a/ca/f107.trr +++ b/ca/f107.trr @@ -1,5 +1,5 @@ 107 -22 +23 ANNOES|9|4|0|Codice esercizio NUMREG|3|7|0|Numero di operazione DATAREG|5|8|0|Data operazione @@ -22,6 +22,7 @@ DANNO|2|4|0|Documento originale ANNO DCODNUM|1|4|0|Documento originale CODNUM DNDOC|3|7|0|Documento originale NDOC DATAFCOMP|5|8|0|Data finale competenza (solo Preventivi e Variazioni) +AUTOFCOMP|8|1|0|Data fine competenza calcolata in base a fine commessa 3 NUMREG| DATACOMP+NUMREG|X diff --git a/ca/f108.trr b/ca/f108.trr index 24f217b1c..a7abded05 100755 --- a/ca/f108.trr +++ b/ca/f108.trr @@ -16,6 +16,7 @@ CODCCORI|1|20|0|Codice centro di costo originario CODCMSORI|1|20|0|Codice commessa originario CODFASEORI|1|10|0|Codice fase originario CODCONTORI|1|20|0|Codice conto originario -2 +3 NUMREG+NUMRIG| CODCONTO+DATACOMP+NUMREG+NUMRIG|X +DATACOMP+NUMREG+NUMRIG|X diff --git a/ca/movana.h b/ca/movana.h index 6aa976846..a2808c088 100755 --- a/ca/movana.h +++ b/ca/movana.h @@ -20,5 +20,6 @@ #define MOVANA_DCODNUM "DCODNUM" #define MOVANA_DNDOC "DNDOC" #define MOVANA_DATAFCOMP "DATAFCOMP" +#define MOVANA_AUTOFCOMP "AUTOFCOMP" #endif \ No newline at end of file